hibernate - solucion - Asignación de tabla de asociación de muchos a muchos con columna(s) adicional(es)

tabla intermedia entidad relacion

Question

Mi base de datos contiene 3 tablas: las entidades de usuario y servicio tienen una relación de muchos a varios y se unen a la tabla SERVICE_USER de la siguiente manera:

USUARIOS - SERVICE_USER - SERVICIOS

La tabla SERVICE_USER contiene una columna adicional BLOQUEADA.

¿Cuál es la mejor manera de realizar tal mapeo? Estas son mis clases de Entidad

@Entity
@Table(name = "USERS")
public class User implements java.io.Serializable {
private String userid;
private String email;
@Id
@Column(name = "USERID", unique = true, nullable = false,)
public String getUserid() {
return this.userid;
}
.... some get/set methods
}
@Entity
@Table(name = "SERVICES")
public class CmsService implements java.io.Serializable {
private String serviceCode;
@Id
@Column(name = "SERVICE_CODE", unique = true, nullable = false, length = 100)
public String getServiceCode() {
return this.serviceCode;
}
.... some additional fields and get/set methods
}

Seguí este ejemplo http://giannigar.wordpress.com/2009/09/04/m ... using-jpa / Aquí hay algunos códigos de prueba:

User user = new User();
user.setEmail("e2");
user.setUserid("ui2");
user.setPassword("p2");
CmsService service= new CmsService("cd2","name2");
List<UserService> userServiceList = new ArrayList<UserService>();
UserService userService = new UserService();
userService.setService(service);
userService.setUser(user);
userService.setBlocked(true);
service.getUserServices().add(userService);
userDAO.save(user);

El problema es que hibernate persiste User object y UserService one. Sin éxito con el objeto CmsService

Intenté usar la búsqueda de EAGER: no hay progreso

¿Es posible lograr el comportamiento que estoy esperando con el mapeo proporcionado anteriormente?

Tal vez hay alguna manera más elegante de mapear muchos a muchos unirse a la tabla con una columna adicional?

Answer 1

Busco una forma de mapear una tabla de asociación de muchos a muchos con columna (s) adicional (s) con hibernación en la configuración de archivos xml.

Asumiendo que tienen dos tablas ''a'' y ''c'' con una asociación de muchos a muchos con una columna llamada ''extra''. Porque no encontré ningún ejemplo completo, aquí está mi código. Espero que ayude :).

Primero aquí están los objetos de Java.

public class A implements Serializable{
protected int id;
// put some others fields if needed ...
private Set<AC> ac = new HashSet<AC>();
public A(int id) {
this.id = id;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Set<AC> getAC() {
return ac;
}
public void setAC(Set<AC> ac) {
this.ac = ac;
}
/** {@inheritDoc} */
@Override
public int hashCode() {
final int prime = 97;
int result = 1;
result = prime * result + id;
return result;
}
/** {@inheritDoc} */
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof A))
return false;
final A other = (A) obj;
if (id != other.getId())
return false;
return true;
}
}
public class C implements Serializable{
protected int id;
// put some others fields if needed ...
public C(int id) {
this.id = id;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
/** {@inheritDoc} */
@Override
public int hashCode() {
final int prime = 98;
int result = 1;
result = prime * result + id;
return result;
}
/** {@inheritDoc} */
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof C))
return false;
final C other = (C) obj;
if (id != other.getId())
return false;
return true;
}
}

Ahora, tenemos que crear la tabla de asociación. El primer paso es crear un objeto que represente una clave primaria compleja (a.id, c.id).

public class ACId implements Serializable{
private A a;
private C c;
public ACId() {
super();
}
public A getA() {
return a;
}
public void setA(A a) {
this.a = a;
}
public C getC() {
return c;
}
public void setC(C c) {
this.c = c;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((a == null) ? 0 : a.hashCode());
result = prime * result
+ ((c == null) ? 0 : c.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
ACId other = (ACId) obj;
if (a == null) {
if (other.a != null)
return false;
} else if (!a.equals(other.a))
return false;
if (c == null) {
if (other.c != null)
return false;
} else if (!c.equals(other.c))
return false;
return true;
}
}

Ahora vamos a crear el objeto de asociación en sí.

public class AC implements java.io.Serializable{
private ACId id = new ACId();
private String extra;
public AC(){
}
public ACId getId() {
return id;
}
public void setId(ACId id) {
this.id = id;
}
public A getA(){
return getId().getA();
}
public C getC(){
return getId().getC();
}
public void setC(C C){
getId().setC(C);
}
public void setA(A A){
getId().setA(A);
}
public String getExtra() {
return extra;
}
public void setExtra(String extra) {
this.extra = extra;
}
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
AC that = (AC) o;
if (getId() != null ? !getId().equals(that.getId())
: that.getId() != null)
return false;
return true;
}
public int hashCode() {
return (getId() != null ? getId().hashCode() : 0);
}
}

En este punto, es hora de asignar todas nuestras clases con hibernate xml configuration.

A.hbm.xml y C.hxml.xml (aquietan lo mismo).

<class name="A" table="a">
<id name="id" column="id_a" unsaved-value="0">
<generator class="identity">
<param name="sequence">a_id_seq</param>
</generator>
</id>
<!-- here you should map all others table columns -->
<!-- <property name="otherprop" column="otherprop" type="string" access="field" /> -->
<set name="ac" table="a_c" lazy="true" access="field" fetch="select" cascade="all">
<key>
<column name="id_a" not-null="true" />
</key>
<one-to-many class="AC" />
</set>
</class>
<class name="C" table="c">
<id name="id" column="id_c" unsaved-value="0">
<generator class="identity">
<param name="sequence">c_id_seq</param>
</generator>
</id>
</class>

Y luego el archivo de mapeo de asociación, a_c.hbm.xml.

<class name="AC" table="a_c">
<composite-id name="id" class="ACId">
<key-many-to-one name="a" class="A" column="id_a" />
<key-many-to-one name="c" class="C" column="id_c" />
</composite-id>
<property name="extra" type="string" column="extra" />
</class>

Aquí está la muestra del código para probar.

A = ADao.get(1);
C = CDao.get(1);
if(A != null && C != null){
boolean exists = false;
// just check if it''s updated or not
for(AC a : a.getAC()){
if(a.getC().equals(c)){
// update field
a.setExtra("extra updated");
exists = true;
break;
}
}
// add
if(!exists){
ACId idAC = new ACId();
idAC.setA(a);
idAC.setC(c);
AC AC = new AC();
AC.setId(idAC);
AC.setExtra("extra added");
a.getAC().add(AC);
}
ADao.save(A);
}

Answer 2

Como se dijo anteriormente, con JPA, para tener la posibilidad de tener columnas adicionales, debe usar dos asociaciones de OneToMany, en lugar de una sola relación manyToMany. También puede agregar una columna con valores autogenerados, para que pueda funcionar como clave principal de la tabla, si es útil.

Por ejemplo, el código de implementación de la clase extra debe tener el siguiente aspecto:

@Entity
@Table(name = "USER_SERVICES")
public class UserService{
// example of auto-generated ID
@Id
@Column(name = "USER_SERVICES_ID", nullable = false)
@GeneratedValue(strategy = GenerationType.IDENTITY)
private long userServiceID;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "USER_ID")
private User user;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "SERVICE_ID")
private Service service;
// example of extra column
@Column(name="VISIBILITY")
private boolean visibility;
public long getUserServiceID() {
return userServiceID;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public Service getService() {
return service;
}
public void setService(Service service) {
this.service = service;
}
public boolean getVisibility() {
return visibility;
}
public void setVisibility(boolean visibility) {
this.visibility = visibility;
}
}

Answer 3

Dado que la tabla SERVICE_USER no es una tabla de unión pura, pero tiene campos funcionales adicionales (bloqueados), debe asignarla como una entidad y descomponer la asociación de muchos a muchos entre el usuario y el servicio en dos asociaciones de OneToMany: un usuario tiene muchos servicios de usuario, y un Servicio tiene muchos UserServices.

No nos ha mostrado la parte más importante: el mapeo e inicialización de las relaciones entre sus entidades (es decir, la parte con la que tiene problemas). Entonces te mostraré cómo debería verse.

Si haces las relaciones bidireccionales, entonces deberías tener

class User {
@OneToMany(mappedBy = "user")
private Set<UserService> userServices = new HashSet<UserService>();
}
class UserService {
@ManyToOne
@JoinColumn(name = "user_id")
private User user;
@ManyToOne
@JoinColumn(name = "service_code")
private Service service;
@Column(name = "blocked")
private boolean blocked;
}
class Service {
@OneToMany(mappedBy = "service")
private Set<UserService> userServices = new HashSet<UserService>();
}

Si no pone ninguna cascada en sus relaciones, entonces debe persistir / guardar todas las entidades. Aunque solo se debe inicializar el lado propietario de la relación (aquí, el lado UserService), también es una buena práctica asegurarse de que ambas partes estén en coherencia.

User user = new User();
Service service = new Service();
UserService userService = new UserService();
user.addUserService(userService);
userService.setUser(user);
service.addUserService(userService);
userService.setService(service);
session.save(user);
session.save(service);
session.save(userService);