@IdClass Annotations JPA

Ici est une clé primaire composite pour l'un de mes entités.

public class GroupMembershipPK implements Serializable{

    private static final long serialVersionUID = 7816433876820743311L;

    private User user;
    private Group group;

    public GroupMembershipPK(){
    }

    public boolean equals(Object o){
        if(o==null){
            return false;
        }

        if(o instanceof GroupMembershipPK){
            final GroupMembershipPK groupMembershipPK=(GroupMembershipPK)o;
            return groupMembershipPK.group.getGroupName().equals(this.group.getGroupName()) &&
                groupMembershipPK.user.getName().equals(this.user.getName());
        }
        return false;
    }

    public int hashCode(){
        return super.hashCode();
    }
}

Heres mon entité(en partie) à l'aide de la ci-dessus comme une Clé Primaire Composite.

@Entity
@IdClass(GroupMembershipPK.class)
public class GroupMembership extends AbstractModelElementVersionOther{

    private static final long serialVersionUID = 9188465566607060376L;

    private String memType;
    private Group group;
    private User user;

    public GroupMembership(){
        super();
    }

    @Column(nullable=false)
    public String getMemType(){
        return this.memType;
    }

    public void setMemType(String memType){
        this.memType=memType;
    }

    @Id
    @ManyToOne
    @JoinColumn(name="groupId")
    public Group getGroup(){
        return this.group;
    }

    public void setGroup(Group group){
        this.group=group;
    }

    @Id
    @ManyToOne
    @JoinColumn(name="userId")
    public User getUser(){
        return this.user;
    }

    public void setUser(User user){
        this.user=user;
    }

    @Override
    public boolean equals(Object o) {
//

Je suis un peu confus sur ce que devrait être la méthode equals de la mise en œuvre de cette entité. Comment puis-je comparer les deux clés primaires composées?

Des commentaires sur d'autres parties de mon code sont aussi les bienvenus.

OriginalL'auteur soontobeared | 2009-09-23

jpa

7

Il n'est pas une bonne idée de stocker des entités en tant que clé primaire. Il y a certaines limitations lors de l'utilisation de langage de requête et JPA 1.0 ne prend pas en charge. En outre, il n'est pas nécessaire d'avoir recours à des entités comme clé primaire. Pensez à ce sujet.Si vous le souhaitez, prendre un regard particulier sur la question suivante

Une classe qui se comporte comme @Entity et @Embeddable

La réponse à l'une

Commentaire à propos de la réponse à l'une

Vous verrez que l'utilisation d'une entité en tant que clé primaire n'est pas nécessaire.

Au lieu de
```
public class GroupMembershipPK implements Serializable {

    private User user;
    private Group group;

}
```
Utilisation
```
public class GroupMembershipPK implements Serializable {

    private Integer userId;
    private Integer groupId;

}
```
est égal à la mise en œuvre est important, car JPA compare deux entités en l'utilisant JPA (vérifie si une entité est dans le contexte de persistance par l'aide est égal à la mise en œuvre). De sorte que vous pouvez mettre en œuvre en fonction de
```
public boolean equals(Object o) {
    if(o == null)
        return false;

    if(!(o instanceof GroupMembershipPK))
        return false;

    GroupMembershipPK other = (GroupMembershipPK) o;
    if(!(getUserId().equals(other.getUserId()))
        return false;

    if(!(getGroupId().equals(other.getGroupId()))
        return false;

    return true;
}
```
Conseils: c'est une bonne idée d'utiliser l'accès à la propriété plutôt que de l'accès sur le terrain, parce que, à certains moments, l'implémentation JPA utilise un proxy de l'objet en raison de problèmes de performances. Un objet proxy qui rend l'utilisation de l'accès à la propriété, car il permet l'implémentation JPA hits de la base de données lorsque cela est nécessaire.

Comment faire pour enregistrer un objet qui utilise une clé primaire composite ?
```
User user = new user();
Group group = new Group();

entityManager.save(user);
entityManager.save(group);

entityManager.flush();

UserGroup userGroup = new UserGroup();

userGroup.setId(new UserGroup.UserGroupId(user.getId(), group.getId()));

entityManager.save(userGroup);
```
Voulez-vous savoir comment mettre en œuvre le Groupe ?
```
public class UserGroup {

    private UserGroupId id;

    //You can create UserGroupId outside UserGroup class
    //Feel free to choice your best approach
    @Embeddable
    public static class UserGroupId implements Serializable {

        private Integer userId;
        private Integer groupId;

        //required no-arg constructor
        public UserGroupId() {}

        public UserGroupId(Integer userId, Integer groupId) {
            this.userId = userId;
            this.roupId = groupId;
        }

        //getter's and setter's

        //equals and hashcode as shown above

    }

    @EmbeddedId
    public UserGroupId getId() {
        return this.id;
    }

    public setId(UserGroupId id) {
        this.id = id;
    }
}
```
Une autre approche consiste à utiliser la clé primaire composite est IdClass. Voir IdClass

ce qui concerne,

Vous devriez également mettre en œuvre une méthode hashCode qui utilise le nom d'utilisateur et id de groupe propriétés, puisque l'égalité des objets doit également avoir le même hash. Par Exemple: (getUserId() == null ? 0 : getUserId().hashCode()) ^ (getGroupId() == null ? 0 : getGroupId().hashCode())
Horstmann Salut, vous avez raison. Mais il ont été mises en œuvre qu'est égal à la mise en œuvre en raison de réponse. Merci en tout cas
Ronald . Merci, Fonctionne parfaitement. Cependant, pouvez-vous me dire comment faire pour conserver l'entité à l'aide d'une clé primaire composite tel que décrit ci-dessus? J'obtiens l'erreur suivante dans JBoss quand j'essaie de le faire.-------"Exception in thread "main" javax.ejb.EJBException: javax.la persistance.PersistenceException: org.mise en veille prolongée.id.IdentifierGenerationException: id pour cette classe doit être attribuée manuellement avant d'appeler save()"
Il se produit parce que si un objet a un identifiant attribué - cela signifie pas @GeneratedValue -, OU UNE CLÉ COMPOSITE, l'identificateur DOIT ÊTRE ATTRIBUÉ à l'instance de l'objet AVANT d'appeler save()
Ajouté à l'original de la réponse, en ce qui concerne

OriginalL'auteur Arthur Ronald
1

Il a été mentionné en partie, de toute façon:
1. Lors de la mise en œuvre de la equals méthode, vous devriez utilisation 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 Liskovs Principe De Substitution et d'ignorer la symétrie.
2. Le prochain écueil est d'utiliser quelque chose comme name.equals(that.name) au lieu de name.equals(that.getName()). Le premier sera un échec, si c'est un proxy.
http://www.laliluna.de/jpa-hibernate-guide/ch06s06.html

OriginalL'auteur Mykhaylo Adamovych

Vous devez vous connecter pour publier un commentaire.