彻底明白Hibernate中的Inverse

关注

最新推荐文章于 2026-03-07 06:08:47 发布 190 阅读 AI 写同款· GEO 优化 ›

以前写HBM，用一对多或多对多的时候默认总是加上“inverse=true”。当时想法很简单就是由双方来维护之间的关联关系。今天才终于明白inverse的真正含义了！

其实inverse不复杂，但是要真正明白还是要稍微看一下源码。inverse的真正作用就是指定由哪一方来维护之间的关联关系。当一方中指定了“inverse=false”（默认），那么那一方就有责任负责之间的关联关系，说白了就是hibernate如何生成Sql来维护关联的记录！举个最简单的一对多父子关系。那么代码就写成：

父亲中的关系映射
{set name="children" lazy="true" inverse="true"}
{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();
c.setParent(p); //维护父子之间关系
p.getChildren().add(c);

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

注意：{many-to-one}总是设成“inverse=false”的，而且这个属性在Mapping中是不存在的！

这样运行的下来的结果就是：

Hibernate: insert into parent (id) values (?)
Hibernate: insert into child (parent_id, id) values (?, ?)

那么假如c.setParent(p)注释掉，结果就是：

Hibernate: insert into parent (id) values (?)

比较结果显而易见！此外，inverse还有一个重要特点就是会优化Sql。（具体可以把SHOW_SQL这个属性打开，然后观察一下就知道了）

接下来再看看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);

// 改变儿子c的关系
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=? )

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=?（正确更新了）

那么根据上面的结论，关系应该是由“inverse=false”方来维护的，那么我把代码改成：

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

这样运行下来的结果：

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

比较结果很明显，少了父加载儿子的过程，乍看下是成功更新了。实际上，结果和DB是不一致的。（原因很简单就是父亲p的children并没有被更新）

那么反过来改一下：

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

这样结果就成了：

显而易见，关联更新没有被执行（更新是由“inverse=false”方负责的，而这里恰恰被注释了）。

大多数情况下，很少使用“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：

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

结果：

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”低很多。

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

p2.getChildren().add(c);

结果：

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

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