Comment mapper une clé composite avec mise en veille prolongée?

À la carte une clé composite, vous pouvez utiliser le EmbeddedId ou la IdClass annotations. Je sais que cette question n'est pas strictement sur JPA mais les règles définies par la spécification s'applique également. Donc, ici, ils sont:

2.1.4 les Clés Primaires et de l'Entité d'Identité

...

Une clé primaire composite doit
correspondent à un seul
zone de persistance ou de la propriété ou à un
ensemble de ces champs ou propriétés
décrites ci-dessous. Une clé primaire de la classe
doit être défini de façon à représenter une
clé primaire composite. Composite
les clés primaires apparaissent généralement quand
la cartographie de l'héritage de bases de données lors de l'
clé de base de données est composée de plusieurs
les colonnes. La EmbeddedId et
IdClass les annotations sont utilisées pour
désigner les clés primaires composites. Voir
les sections 9.1.14 et 9.1.15 coulisse pivotante d'élément.

...

Les règles suivantes s'appliquent pour
les clés primaires composites:

• La clé primaire de la classe doit être public et doit avoir un public de non-arg
  constructeur.
• Si le bien-fondé d'accès est utilisé, les propriétés de la clé primaire
  la classe doit être public ou protégé.
• La clé primaire de la classe doit être serializable.
• La clé primaire de la classe
  doit définir equals et hashCode
  des méthodes. La sémantique de valeur
  l'égalité de ces méthodes doit être
  compatible avec la base de données de l'égalité
  pour les types de base de données à laquelle le
  la clé est mappé.
• Une clé primaire composite doit être représenté soit et mappé en tant que
  intégrable classe (voir la Section 9.1.14,
  “EmbeddedId Annotation”) ou doit être
  représentés et associé à plusieurs
  les champs ou propriétés de l'entité
  catégorie (voir l'Article 9.1.15 coulisse pivotante d'élément, “IdClass
  L'Annotation”).
• Si la clé primaire composite de classe est associé à plusieurs champs ou
  propriétés de la classe d'entité, l'
  les noms de champs de clé primaire ou
  propriétés de la clé primaire de la classe
  et ceux de la classe d'entité doit
  correspondent et leurs types doivent être l'
  de même.

Avec un IdClass

La classe de la clé primaire composite pourrait ressembler (peut être une statique à l'intérieur de la classe):

public class TimePK implements Serializable {
    protected Integer levelStation;
    protected Integer confPathID;

    public TimePK() {}

    public TimePK(Integer levelStation, Integer confPathID) {
        this.levelStation = levelStation;
        this.confPathID = confPathID;
    }
    //equals, hashCode
}

Et l'entité:

@Entity
@IdClass(TimePK.class)
class Time implements Serializable {
    @Id
    private Integer levelStation;
    @Id
    private Integer confPathID;

    private String src;
    private String dst;
    private Integer distance;
    private Integer price;

    //getters, setters
}

La IdClass annotation des cartes de plusieurs champs à la table de PK.

Avec EmbeddedId

La classe de la clé primaire composite pourrait ressembler (peut être une statique à l'intérieur de la classe):

@Embeddable
public class TimePK implements Serializable {
    protected Integer levelStation;
    protected Integer confPathID;

    public TimePK() {}

    public TimePK(Integer levelStation, Integer confPathID) {
        this.levelStation = levelStation;
        this.confPathID = confPathID;
    }
    //equals, hashCode
}

Et l'entité:

@Entity
class Time implements Serializable {
    @EmbeddedId
    private TimePK timePK;

    private String src;
    private String dst;
    private Integer distance;
    private Integer price;

    //...
}

La @EmbeddedId annotation cartes un PK classe à la table PK.

Différences:

• À partir du modèle physique de point de vue, il n'y a pas de différences
• @EmbeddedId en quelque sorte communique plus clairement que la clé est une clé composite et de l'OMI a de sens lorsque le combiné pk est soit une entité cohérente lui-même ou réutilisés dans votre code.
• @IdClass est utile de préciser que certaines combinaison de champs est unique, mais ils n'ont pas de signification particulière.

Ils ont également affecter la façon dont vous écrire des requêtes (en les rendant plus ou moins détaillé):

• avec IdClass

  select t.levelStation from Time t

• avec EmbeddedId

  select t.timePK.levelStation from Time t

Références

• JPA 1.0 de la spécification
  • La Section 2.1.4 "des Clés Primaires et des entités de l'Identité"
  • Section 9.1.14 "EmbeddedId Annotation"
  • L'Article 9.1.15 Coulisse Pivotante D'Élément "IdClass Annotation"

Comme je l'ai expliqué dans cet article, en supposant que vous avez des tables de base de données:

Tout d'abord, vous devez créer le @Embeddable maintenant le composite de l'identificateur:

@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());
    }
}

Avec cela en place, nous pouvons tracer la Employee entité qui utilise le composite identifiant en annotant avec @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 Phone entité qui a un @ManyToOne association pour Employee, doit faire référence au composite identificateur de la classe parent par l'intermédiaire de deux @JoinColumnmappages:

@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;
    }
}

Pour plus de détails, consultez cet article.

La clé primaire de la classe doit définir equals et hashCode méthodes

1. Lorsque l'application est égal, vous devriez utiliser instanceof pour permettre la comparaison avec des sous-classes. Si Hibernate paresseux charge un-à-un ou plusieurs pour une relation, vous avez un proxy pour la classe au lieu de la plaine de la classe. Un proxy est une sous-classe. En comparant les noms de classe serait un échec.
   
   Plus techniquement: Vous devez suivre les Liskows Principe de Substitution et d'ignorer symmetricity.
2. Le prochain écueil est d'utiliser quelque chose comme nom.equals(qu'.nom) au lieu de nom.equals(qu'.getName()). Le premier sera un échec, si c'est un proxy.

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

Une autre option est de la carte est une Carte des éléments composites dans le ConfPath table.

Cette cartographie permettrait de bénéficier d'un index sur (ConfPathID,levelStation) si.

public class ConfPath {
    private Map<Long,Time> timeForLevelStation = new HashMap<Long,Time>();

    public Time getTime(long levelStation) {
        return timeForLevelStation.get(levelStation);
    }

    public void putTime(long levelStation, Time newValue) {
        timeForLevelStation.put(levelStation, newValue);
    }
}

public class Time {
    String src;
    String dst;
    long distance;
    long price;

    public long getDistance() {
        return distance;
    }

    public void setDistance(long distance) {
        this.distance = distance;
    }

    public String getDst() {
        return dst;
    }

    public void setDst(String dst) {
        this.dst = dst;
    }

    public long getPrice() {
        return price;
    }

    public void setPrice(long price) {
        this.price = price;
    }

    public String getSrc() {
        return src;
    }

    public void setSrc(String src) {
        this.src = src;
    }
}

Cartographie:

<class name="ConfPath" table="ConfPath">
    <id column="ID" name="id">
        <generator class="native"/>
    </id>
    <map cascade="all-delete-orphan" name="values" table="example"
            lazy="extra">
        <key column="ConfPathID"/>
        <map-key type="long" column="levelStation"/>
        <composite-element class="Time">
            <property name="src" column="src" type="string" length="100"/>
            <property name="dst" column="dst" type="string" length="100"/>
            <property name="distance" column="distance"/>
            <property name="price" column="price"/>
        </composite-element>
    </map>
</class>