学步园

大多数情况下，很少使用“inverse=false”，但是我还是想仔细研究一下（这样可以更加理解“inverse=true”）。 ^_^

为什么很少使用“inverse=false”？原因很简单之前也提到过，就是不会对双向关系进行优化。

 

还是来看一个父子的例子：

 

父亲中的关系映射
{set name=children lazy=true inverse=false}
      {key column=parent_id/}
      {one-to-many class=test.Child/}
{/set}

 

儿子中关系映射
{many-to-one name=parent column=parent_id not-null=true/}

 

代码：

 

Parent p = new Parent();
Child c = new Child();
p.getChildren().add(c);
c.setParent(p);

session.save(p);
session.save(c);
session.flush();

 

 

Hibernate: insert into parent (id) values (?)
Hibernate: insert into child (parent_id, id) values (?, ?)
Hibernate: update child set parent_id=? where id=?

 

看到这里就应该明白我之前为什么说“inverse=true”会优化Sql了吧！还有之前也说过是由“inverse=false”来维护关系了，那这里就是由父亲来维护了。假设我在save(p)和save(c)之间掉flush()，结果又会是如何？事实上，是不可以这么做的！因为父亲负责维护关系，如果我在之间加入了flush()，那么就是无法关联更新了（父亲需要一个已经持久化的儿子来触发关联更新）

 

接下来再来看看update：

 

Parent p = (Parent) session.load(Parent.class, parentId);
Parent p2 = (Parent) session.load(Parent.class, parentId2);
       
c = (Child) session.find(
            "from Child as child where child.parent = ?",
            p, Hibernate.entity(Parent.class)).get(0);

p.getChildren().remove(c);
p2.getChildren().add(c);
c.setParent(p2);

 

 

Hibernate: select parent0_.id as id from parent parent0_ where parent0_.id=?    //get parent 1
Hibernate: select parent0_.id as id from parent parent0_ where parent0_.id=?    //get parent 2
Hibernate: select child0_.id as id, child0_.parent_id as parent_id from child child0_ where (child0_.parent_id=? )
//get first child for parent 1

 

Hibernate: select child0_.id as id__, child0_.id as id, child0_.parent_id as parent_id from child child0_ where child0_.parent_id=?
Hibernate: select child0_.id as id__, child0_.id as id, child0_.parent_id as parent_id from child child0_ where child0_.parent_id=?

 

Hibernate: update child set parent_id=? where id=?               // child.setParent
Hibernate: update child set parent_id=null where parent_id=?     //remove
Hibernate: update child set parent_id=? where id=?               // add

 

结果说明当设成“inverse=false”时，关系是由父亲和儿子来维护的。这种效率和之前我说的“inverse=true”低很多。

 

那么关系是由父亲来维护的，我又把代码改了一下：

 

Parent p = (Parent) session.load(Parent.class, parentId);
Parent p2 = (Parent) session.load(Parent.class, parentId2);
       
c = (Child) session.find(
            "from Child as child where child.parent = ?",
            p, Hibernate.entity(Parent.class)).get(0);

p2.getChildren().add(c);

 

 

Hibernate: select parent0_.id as id from parent parent0_ where parent0_.id=?    //get parent 1
Hibernate: select parent0_.id as id from parent parent0_ where parent0_.id=?    //get parent 2
Hibernate: select child0_.id as id, child0_.parent_id as parent_id from child child0_ where (child0_.parent_id=? )
//get first child for parent 1

 

Hibernate: select child0_.id as id__, child0_.id as id, child0_.parent_id as parent_id from child child0_ where child0_.parent_id=?
Hibernate: select child0_.id as id__, child0_.id as id, child0_.parent_id as parent_id from child child0_ where child0_.parent_id=?

 

Hibernate: update child set parent_id=? where id=?               // add

 

乍看之下对的，但是父亲p和p2的children的状态是不一致的！

小结：使用“inverse=true”可以优化代码，同时，推荐在建立双向关系的时候使用“inverse=true”！