Tengo 2 entidades: Usuario y UsersList.

@Entity
@Table(name = "USERS")
public class User {
    @Id
    @GeneratedValue
    @Column(name = "ID")
    private Long id;

    @ManyToMany(cascade = CascadeType.REMOVE, mappedBy = "users")
    private List<UsersList> usersLists = new ArrayList<UsersList>();

    public List<UsersList> getUsersLists() {
        return usersLists;
    }

    public void setUsersLists(List<UsersList> usersLists) {
        this.usersLists = usersLists;
    }
}

y

@Entity
@Table(name = "USERS_LIST")
public class UsersList {
    @Id
    @GeneratedValue
    @Column(name = "ID")
    private Long id;

    @ManyToMany
    private List<User> users = new ArrayList<User>();

 public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }
}

y el código como este:

//1
List<User> dbUsers; //3 the user instances are persisted in DB
UsersList usersList = new UsersList();
usersList.setUsers(dbUsers);

//2 - now persist the usersList using hibernate...
saveWithHibernate(usersList); 

//3 - delete using a persisted user
deleteWithHibernate(dbUsers.get(0).getId());

donde

deleteWithHibernate(Long id) {
        User usr = hibernateTemplate.get(User.class, id);
        hibernateTemplate.delete(usr);
}

En el paso 1 tengo 3 filas de los USUARIOS (USER_ID) de la tabla.

Después del paso 2 (segundo comentario) tengo 1 fila en la USERS_LIST (USERS_LIST_ID) de la tabla y en la tabla de combinación USERS_LIST_USERS (USER_ID, USERS_LIST_ID) 3 filas.

Lo que quiero lograr en el paso 3 es el siguiente: cuando puedo eliminar un usuario de la tabla de USUARIOS – digamos usuario con USER_ID = 4, quiero tan sólo la fila con USER_ID = 4 de la tabla de combinación para ser eliminados, y los otros restantes.

Hay una anotación solución a mi problema?

¿Qué hace el método deleteWithHibernate parece?

OriginalEl autor Flueras Bogdan | 2009-08-19

2 Comentarios

  1. 9

    Lo que usted necesita es el @JoinTable atributo:

    Hibernate no sabe que el de muchos-a-muchos de relaciones referirse el uno al otro y probablemente creará dos unirse a las mesas. Si se especifica el mismo @JoinTable en ambos lados de la relación funcionará como se espera.

    Asegúrese de que el joinColumn y la inverseJoinColumn son opuestos en la oposición
    lados de la relación.

    • joinColumn en uno de los lados == inverseJoinColumn en otro lado
    • inverseJoinColumn en uno de los lados == joinColumn en otro lado

    Espero que esto ayude.

    @Entity
    public class Role extends Identifiable {
    
        @ManyToMany(cascade ={CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
        @JoinTable(name="Role_Permission",
                joinColumns=@JoinColumn(name="Role_id"),
                inverseJoinColumns=@JoinColumn(name="Permission_id")
            )
        public List<Permission> getPermissions() {
            return permissions;
        }
    
        public void setPermissions(List<Permission> permissions) {
            this.permissions = permissions;
        }
    }
    
    @Entity
    public class Permission extends Identifiable {
    
        @ManyToMany(cascade = {CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
        @JoinTable(name="Role_Permission",
                joinColumns=@JoinColumn(name="Permission_id"),
                inverseJoinColumns=@JoinColumn(name="Role_id")
            )
        public List<Role> getRoles() {
            return roles;
        }
    
        public void setRoles(List<Role> roles) {
            this.roles = roles;
        }
    
    }
    Estoy usando «@JoinTable’ en mi solución, pero todavía no soy capaz de eliminar las Filas. Es necesario mencionar todas las cascadas que usted ha mencionado?
    el OP utiliza mappedBy, es que no es suficiente para hibernar para saber lo que el @JoinTable debe parecerse? Explícitamente listado de la @JoinTable nombre y columnas parece un poco superfluo, a menos que usted realmente quiere asegurarse de que sus nombres exactos se utilizan.
    Gran solución !

    OriginalEl autor andersjanmyr

  2. -1

    Creo que debe como este annotaion

        @OnDelete(action = OnDeleteAction.CASCADE)
        @Cascade(org.hibernate.annotations.CascadeType.DELETE_ORPHAN)

    y el cambio de la cascada.quitar a CascadeType.TODOS
    el código debe ser algo como esto

       @ManyToMany(cascade = CascadeType.ALL, mappedBy = "users")
       @OnDelete(action = OnDeleteAction.CASCADE)
       @Cascade(org.hibernate.annotations.CascadeType.DELETE_ORPHAN)
       private List<UsersList> usersLists = new ArrayList<UsersList>();
    es hibernate anotación específica y no está disponible en JPA.

    OriginalEl autor Am1rr3zA

Dejar respuesta

Please enter your comment!
Please enter your name here