comment faire une clé primaire composite (java persistance d'annotation)

Afin de répondre à votre exigence, vous pouvez mapper vos @ManyToMany comme @OneToMany de cartographie.
De cette façon, USER_ROLE contient les deux USER_ID et ROLE_ID composé de clé primaire

Je vais vous montrer comment:

@Entity
@Table(name="USER")
public class User {
@Id
@GeneratedValue
private Integer id;
@OneToMany(cascade=CascadeType.ALL, mappedBy="joinedUserRoleId.user")
private List<JoinedUserRole> joinedUserRoleList = new ArrayList<JoinedUserRole>();
//no-arg required constructor
public User() {}
public User(Integer id) {
this.id = id;
}
//addRole sets up bidirectional relationship
public void addRole(Role role) {
//Notice a JoinedUserRole object
JoinedUserRole joinedUserRole = new JoinedUserRole(new JoinedUserRole.JoinedUserRoleId(this, role));
joinedUserRole.setUser(this);
joinedUserRole.setRole(role);
joinedUserRoleList.add(joinedUserRole);
}
}
@Entity
@Table(name="USER_ROLE")
public class JoinedUserRole {
public JoinedUserRole() {}
public JoinedUserRole(JoinedUserRoleId joinedUserRoleId) {
this.joinedUserRoleId = joinedUserRoleId;
}
@ManyToOne
@JoinColumn(name="USER_ID", insertable=false, updatable=false)
private User user;
@ManyToOne
@JoinColumn(name="ROLE_ID", insertable=false, updatable=false)
private Role role;
@EmbeddedId
//Implemented as static class - see bellow
private JoinedUserRoleId joinedUserRoleId;
//required because JoinedUserRole contains composite id
@Embeddable
public static class JoinedUserRoleId implements Serializable {
@ManyToOne
@JoinColumn(name="USER_ID")
private User user;
@ManyToOne
@JoinColumn(name="ROLE_ID")
private Role role;
//required no arg constructor
public JoinedUserRoleId() {}
public JoinedUserRoleId(User user, Role role) {
this.user = user;
this.role = role;
}
public JoinedUserRoleId(Integer userId, Integer roleId) {
this(new User(userId), new Role(roleId));
}
@Override
public boolean equals(Object instance) {
if (instance == null)
return false;
if (!(instance instanceof JoinedUserRoleId))
return false;
final JoinedUserRoleId other = (JoinedUserRoleId) instance;
if (!(user.getId().equals(other.getUser().getId())))
return false;
if (!(role.getId().equals(other.getRole().getId())))
return false;
return true;
}
@Override
public int hashCode() {
int hash = 7;
hash = 47 * hash + (this.user != null ? this.user.hashCode() : 0);
hash = 47 * hash + (this.role != null ? this.role.hashCode() : 0);
return hash;
}
}
}

rappelez-vous

Si un objet est affecté un
identificateur, ou une clé composite, l'
l'identificateur DOIT ÊTRE ATTRIBUÉ à l'
instance de l'objet AVANT d'appeler save().

Nous avons donc créé une JoinedUserRoleId constructeur comme celui-ci, afin de prendre soin d'elle

public JoinedUserRoleId(User user, Role role) {
this.user = user;
this.role = role;
}

Et enfin le Rôle de la classe

@Entity
@Table(name="ROLE")
public class Role {
@Id
@GeneratedValue
private Integer id;
@OneToMany(cascade=CascadeType.ALL, mappedBy="JoinedUserRoleId.role")
private List<JoinedUserRole> joinedUserRoleList = new ArrayList<JoinedUserRole>();
//no-arg required constructor
public Role() {}
public Role(Integer id) {
this.id = id;
}
//addUser sets up bidirectional relationship
public void addUser(User user) {
//Notice a JoinedUserRole object
JoinedUserRole joinedUserRole = new JoinedUserRole(new JoinedUserRole.JoinedUserRoleId(user, this));
joinedUserRole.setUser(user);
joinedUserRole.setRole(this);
joinedUserRoleList.add(joinedUserRole);
}
}

Selon le test, nous allons écrire le code suivant

User user = new User();
Role role = new Role();
//code in order to save a User and a Role
Session session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
Serializable userId  = session.save(user);
Serializable roleId = session.save(role);
session.getTransaction().commit();
session.clear();
session.close();
//code in order to set up bidirectional relationship
Session anotherSession = HibernateUtil.getSessionFactory().openSession();
anotherSession.beginTransaction();
User savedUser = (User) anotherSession.load(User.class, userId);
Role savedRole = (Role) anotherSession.load(Role.class, roleId);
//Automatic dirty checking
//It will set up bidirectional relationship
savedUser.addRole(savedRole);
anotherSession.getTransaction().commit();
anotherSession.clear();
anotherSession.close();

Avis selon le code ci-dessus AUCUNE RÉFÉRENCE à JoinedUserRole classe.

Si vous souhaitez récupérer un JoinedUserRole, essayez les solutions suivantes

Session session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
Integer userId;
Integer roleId;
//Lets say you have set up both userId and roleId
JoinedUserRole joinedUserRole = (JoinedUserRole) session.get(JoinedUserRole.class, new JoinedUserRole.JoinedUserRoleId(userId, roleId));
//some operations
session.getTransaction().commit();
session.clear();
session.close();

ce qui concerne,

Merci à vous pour améliorer votre question ... et en tenant compte des suggestions.

(Désolé, C'est un peu étrange que vous postfix votre entités avec Daos, mais ce n'est pas le point.)

Je ne suis pas sûr qu'il y est tout le problème de la gauche :

• Les deux entités que vous décrivez ont chacun un PK, pas une paire de.
• Le lien-le tableau n'a pas d'entité correspondant, il est défini implicitement par les deux entités et de leur relation ManyToMany. Si vous avez besoin d'une troisième Entité, changer votre ManyToMany pour une paire de OneToMany et relations ManyToOne.