Java开发网 - hibernate annotation多对多问题：insert关系前先delete

Topic: hibernate annotation多对多问题：insert关系前先delete

1.hibernate annotation多对多问题：insert关系前先delete

Posted by: yqf0215
Posted on: 2007-10-17 09:32

我用hbiernate annation写的代码，维护多对多关系时，出了个奇怪的问题：

1：Operator.java



@Entity
//@Table(name="operator")
public class Operator implements java.io.Serializable,IfTableModel {

    private static final long serialVersionUID = 1L;
    public static final String [] column={"编号","姓名","其他信息"};
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id")
    private Integer id;
    @Column(name = "name",unique=true)
    private String name;
    @Column(name = "msg")
    private String msg;
    
    @ManyToOne(targetEntity=base.Role.class)//,cascade={CascadeType.PERSIST,CascadeType.MERGE} )
    @Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE})
    @JoinColumn(name="RoleId")
    private Role role;
    
    @ManyToMany(targetEntity=base.Department.class)
    @Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE})
    @JoinTable(
        name="operator_department ",
        joinColumns={@JoinColumn(name="OperatorId")},
        inverseJoinColumns={@JoinColumn(name="DepartId")}
            )
    private List<Department> departs=new ArrayList();

}

epartment.java



@Entity
@Table(name = "department")

public class Department implements java.io.Serializable,IfTableModel {

    private static final long serialVersionUID = 1L;
    public static final String Id = "id";
    public static final String Name = "name";
    public static final String [] column={"编号","部门名称"};
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id")
    private Integer id;
    @Column(name = "name")
    private String name;
    @ManyToMany(targetEntity=base.Operator.class,mappedBy="departs")
    private List<Operator> operators=new ArrayList();
   
}

关系说明：operator和department是多对多的关系，其中，operator端负责关系的维护
3:对operator和department操作的代码


        Transaction tx2= se.beginTransaction();
        BaseUtil u=new BaseUtil();
        List<Department> departs=u.getDepartments();
        List<Operator> opers=u.getOperators();
        opers.get(0).getDeparts().add(departs.get(0));
        opers.get(0).getDeparts().add(departs.get(1));
        tx2.commit();

现在期望的sql代码是：insert into operator_department (OperatorId, DepartId) values (?, ?)
这里出现一个奇怪的问题是，现在总是先
delete from operator_department where OperatorId=?
然后才把所有原来的关系重新插入一遍
insert into operator_department (OperatorId, DepartId) values (?, ?)
insert into operator_department (OperatorId, DepartId) values (?, ?)
insert into operator_department (OperatorId, DepartId) values (?, ?)
这样严重影响性能，各位高人帮忙看看什么原因啊？

2.Re:hibernate annotation多对多问题：insert关系前先delete [Re: yqf0215]	Copy to clipboard
Posted by: yqf0215 Posted on: 2007-10-24 09:11 没有人知道么？

3.Re:hibernate annotation多对多问题：insert关系前先delete [Re: yqf0215]

Copy to clipboard

Posted by: JiafanZhou
Posted on: 2007-10-24 17:02

First of all, I don't really like the Hibernate annotation "approach". My preference is to use the hibernate.cfg.xml and individual xml file to centralize all the hibernate configuration files to separate the bean code and hibernate logic.

However, using annotation means the bean is coupled with hibernate annotations. But I can still look at the problem here likewise.

Secondly, I don't particularly like the way you map the fields, instead you should provide the get/set methods to be mapped with Hibernate, otherwise the beans are extremely useless.

I won't recommend anyone use the "many-to-many" relationship as you mentioned here, most of the time they can be replaced with many-to-one at both ends. Likewise in your case here, try replace them with "many-to-one". And you seems forget the *inverse="true"* when mapping many-to-* relationships.

inverse="true" tells Hibernate that the collection is a mirror image of the <many-to-one> association on the other side. It's a hint that tells Hibernate you mapped the same foreign key column twice.

n.b. Without the inverse attribute, Hibernate tries to execute two different SQL statements, both updating the same foreign key column, when you manipulate the link between two instance. By specifying inverse="true", you explicitly tell Hibernate which end of the link it should not synchronize with the database. In this example, you tell Hibernate that it should propagate changes made at the Bid end of the association to the database,ignoring changes made to the bids collection in Item class.

And last but not the least, you need to further debugging the code yourself, if you still have not any progress, then I propose you find the Hibernate newsgroup and post your question to other Hibernate open source developers including the version of the Hibernate you are using, the object model and other detailed information.

Hope this helps.

Regards,
Jiafan

4.Re:hibernate annotation多对多问题：insert关系前先delete [Re: yqf0215]	Copy to clipboard
Posted by: yqf0215 Posted on: 2007-10-29 10:18 HenryShanley 你好强，但确实很多时候，还是需要manytomany的啊，例如学生上课，一个学生上多门课，一门课有多个学生，如果改用2个manytoone，还是有些不方便啊

5.Re:hibernate annotation多对多问题：insert关系前先delete [Re: yqf0215]

Copy to clipboard

Posted by: JiafanZhou
Posted on: 2007-11-30 23:23

yqf0215 wrote:
HenryShanley 你好强，但确实很多时候，还是需要manytomany的啊，例如学生上课，一个学生上多门课，一门课有多个学生，如果改用2个manytoone，还是有些不方便啊

Nope, all the many-to-many relationships can all be simplified to many-to-one, and this is exactly Gavin King suggested us to do. And it is clearly stated in the "Hibernate in Action" book.

Try to map both ends <many-to-one> and see if this works. Let me know if this is still a problem for you.

Regards,
Jiafan