¿Cómo mapear una clave compuesta con JPA e Hibernate?

En este código, cómo generar una clase Java para la clave compuesta (cómo componer la clave en hibernación):

create table Time (
     levelStation int(15) not null,
     src varchar(100) not null,
     dst varchar(100) not null,
     distance int(15) not null,
     price int(15) not null,
     confPathID int(15) not null,
     constraint ConfPath_fk foreign key(confPathID) references ConfPath(confPathID),
     primary key (levelStation, confPathID)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Aug 27 '10 21:08 kaaf

Necesitas usar @EmbeddedId:

@Entity
class Time {
    @EmbeddedId
    TimeId id;

    String src;
    String dst;
    Integer distance;
    Integer price;
}

@Embeddable
class TimeId implements Serializable {
    Integer levelStation;
    Integer confPathID;
}

Aug 27 '2010 14:08 Thierry Roy

Suponiendo que tiene las siguientes tablas de base de datos:

Primero, debe crear el @Embeddableidentificador compuesto que contiene:

@Embeddable
public class EmployeeId implements Serializable {
 
    @Column(name = "company_id")
    private Long companyId;
 
    @Column(name = "employee_number")
    private Long employeeNumber;
 
    public EmployeeId() {
    }
 
    public EmployeeId(Long companyId, Long employeeId) {
        this.companyId = companyId;
        this.employeeNumber = employeeId;
    }
 
    public Long getCompanyId() {
        return companyId;
    }
 
    public Long getEmployeeNumber() {
        return employeeNumber;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof EmployeeId)) return false;
        EmployeeId that = (EmployeeId) o;
        return Objects.equals(getCompanyId(), that.getCompanyId()) &&
                Objects.equals(getEmployeeNumber(), that.getEmployeeNumber());
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(getCompanyId(), getEmployeeNumber());
    }
}

Con esto implementado, podemos mapear la Employeeentidad que usa el identificador compuesto anotándola con @EmbeddedId:

@Entity(name = "Employee")
@Table(name = "employee")
public class Employee {
 
    @EmbeddedId
    private EmployeeId id;
 
    private String name;
 
    public EmployeeId getId() {
        return id;
    }
 
    public void setId(EmployeeId id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

La Phoneentidad que tiene una @ManyToOneasociación con Employee, necesita hacer referencia al identificador compuesto de la clase principal a través de dos @JoinColumnasignaciones:

@Entity(name = "Phone")
@Table(name = "phone")
public class Phone {
 
    @Id
    @Column(name = "`number`")
    private String number;
 
    @ManyToOne
    @JoinColumns({
        @JoinColumn(
            name = "company_id",
            referencedColumnName = "company_id"),
        @JoinColumn(
            name = "employee_number",
            referencedColumnName = "employee_number")
    })
    private Employee employee;
 
    public Employee getEmployee() {
        return employee;
    }
 
    public void setEmployee(Employee employee) {
        this.employee = employee;
    }
 
    public String getNumber() {
        return number;
    }
 
    public void setNumber(String number) {
        this.number = number;
    }
}

Jan 15 '2018 19:01 Vlad Mihalcea

La clase de clave principal debe definir métodos iguales y hashCode

1. Al implementar iguales, debe usar instancia de para permitir la comparación con subclases. Si Hibernate carga de forma diferida una relación uno a uno o muchos a uno, tendrá un proxy para la clase en lugar de la clase simple. Un proxy es una subclase. Comparar los nombres de las clases fallaría.
   Más técnicamente: debes seguir el principio de sustitución de Liskows e ignorar la simetría.
2. El siguiente problema es usar algo como name.equals(that.name) en lugar de name.equals(that.getName()) . El primero fallará, si es un proxy.

http://www.laliluna.de/jpa-hibernate-guide/ch06s06.html

Jan 18 '2013 16:01 Mike

Parece que estás haciendo esto desde cero. Intente utilizar herramientas de ingeniería inversa disponibles, como Netbeans Entities from Database, para al menos automatizar los conceptos básicos (como identificadores integrados). Esto puede convertirse en un gran dolor de cabeza si tienes muchas mesas. Sugiero evitar reinventar la rueda y utilizar tantas herramientas disponibles como sea posible para reducir la codificación a la parte mínima y más importante, lo que pretendes hacer.

Aug 27 '2010 20:08 javydreamercsw