Hibernate inverse, cascade, update, insert, fetch用法
1. inverse="true"
例如 one-to-many 关系User (1) - Order(*)
Java代码：
public class User {
private Set<Order> orders = new HashSet<Order>();
// ...
}
public class Order {
private User user;
// ..
}
对应的 mapping files:
Order.hbm.xml
<hibernate-mapping package="org.pprun.hjpetstore.domain">
<class name="Order" table="Orders">
...
<!-- owner side of this bidirectional one-to-many association (user to order)-->
<many-to-one column="userId" foreign-key="fk_order_userId" name="user" not-null="true" />
</class>
</hibernate-mapping>
User.hbm.xm
<hibernate-mapping package="org.pprun.hjpetstore.domain">
<class name="User" table="User">
...
<set cascade="all" inverse="true" name="orders">
<key column="userId" not-null="true"/>
<one-to-many class="Order"/>
</set>
</class>
</hibernate-mapping>
好了，以上都是作为开发者必须了解的内容，也是日常工作之一。
inverse 的由来
在 Java 的世界里，我们将利用如下代码建立起 object instance 关系:
user.getOrders().add(newOrder);
order.setUser(user);
这个建立关系的代码一般会反映在 domain 对象中的一个方法中，这个方法有一个恐怖的名字 scaffolding method:
/** scaffolding code for collection field */
public final void addOrder(Order order) {
if (order == null) {
throw new IllegalArgumentException("Can't add a null Order.");
}
order.setUser(this);
this.getOrders().add(order);
}
那么，如果在 User.hbm.xm 对于关系的映射没有指定 inverse="true" 会发生什么？
Hibernate 将发出两条不同的 SQL 做同一件事情，建立起关系，但反映在数据库中(见ERD)，只是对同一个字段 orders.userId 这个外键进行操作。
通过指定 inverse="true", 我们告诉 hibernate 哪端是 owner 端，并将维护实体关系。而另一端是 inverse 端，不需要维护关系。
规则1，双向many-to-one 关系，one 端永远是 inverse 端，而many 端永远是 owner 端。
这下明白了 inverse 的含义了，它是相对于实体关系的 owner 来讲的。
Owner 怎么来的？
在这个例子中，User 是 one, Order 是 many, 因 Order 是 owner, 所以在 Orders 表中包含外键关系 userId. 这是 Owner 的来历－－ 谁拥有外键字段，谁就是 Owner.
规则２， 双向 one-to-one 关系，决定取决于 ERD，而非 JAVA, 同样是哪个实体拥有外键，哪边就是 Owner, 相反，另一端（other side）就是inverse.
规则３，双向 many-to-many，因为实现这一关系的有效办法是利用独立关联表(join table), 所以我们不得不任意指定任一端为 owner（另外一端就是 inverse）,但外键关系（复合外键）实际上是在独立的关联表中。
inverse 该放在哪边？
规则1，双向many-to-one 关系，one 端永远是 inverse 端，而many 端永远是 owner 端。
有这个规则，在映射关系时，one-to-many 是指定 one 端，即 inverse 端，因些应该指定 inverse 属性。
<set cascade="all" inverse="true" name="orders">
<key column="userId" not-null="true"/>
<one-to-many class="Order"/>
</set>
因此，many-to-one 是 owner 端，不应该指定 inverse 属性：
<!-- owner side of this bidirectional one-to-many association (user to order)-->
<many-to-one column="userId" foreign-key="fk_order_userId" name="user" not-null="true" />
因此完整的映射如下（fixed 错误的注释，请好好理解一下注释）
<hibernate-mapping package="org.pprun.hjpetstore.domain">
<class name="Order" table="Orders">
...
<!-- owner side of this bidirectional one-to-many association (user to order)-->
<many-to-one column="userId" foreign-key="fk_order_userId" name="user" not-null="true" />
</class>
</hibernate-mapping>
User.hbm.xm
<hibernate-mapping package="org.pprun.hjpetstore.domain">
<class name="User" table="User">
...
<!--
inverse="true" means Order is the owner side (User is the mirror side - inverse),
Order will take charge of relationship 'userId', which is the foreign-key in Order.
If only call user.getOrders().add(newOrder), no changes are made persistent.
But only call order.setUser(user) will make the relationship set - means the foreign-key will be persisted.
-->
<set cascade="all" inverse="true" name="orders">
<key column="userId" not-null="true"/>
<one-to-many class="Order"/>
</set>
</class>
</hibernate-mapping>
2. Inverse和Cascade的比较
Inverse：负责控制关系，默认为false，也就是关系的两端都能控制，但这样会造成一些问题，更新的时候会因为两端都控制关系，于是重复更新。一般来说有一端要设为true。
Cascade：负责控制关联对象的级联操作，包括更新、删除等，也就是说对一个对象进行更新、删除时，其它对象也受影响，比如我删除一个对象，那么跟它是多对一关系的对象也全部被删除。
举例说明区别：删除“一”那一端一个对象O的时候，如果“多”的那一端的Inverse设为true，则把“多”的那一端所有与O相关联的对象外键清空；如果“多”的那一端的Cascade设为Delete，则把“多”的那一端所有与O相关联的对象全部删除。
3. 各个配置属性含义
<
many-to-one
name
="parent"
class
="com.client.model.ClientChildType"
update
="false"
insert
="false"
cascade
="none"
>
<
column
name
="parent_id"
/>
</
many-to-one
>
update：进行update操作时是否包含此字段
insert：进行insert操作时是否包含此字段
name：映射类属性的名字
column：关联的字段
class：关联类的名字
cascade：设置操作中的级联策略 可选值为 all所有操作情况均进行级联、none所有操作情况均不进行级联、save-update执行save和update操作时级联、delete执行删除操作时级联
fetch：设置抓取数据的策略 默认值为select序列选择抓取 可选值为join外连接抓取
property-ref：指定关联类的一个属性，这个属性将会和本类的外键相对应（当外键参照一键时需要指定改属性）
fetch属性
hibernate抓取策略（单端代理的批量抓取fetch=select(默认）/join）
测试用例：
Student student = (Student)session.get(Student.class, 1);
System.out.println(student.getName());
System.out.println(student.getClasses().getName());
1）保持默认，同fetch="select",如：
<many-to-one name="classes" column="classesid" fetch="select"/>
fetch="select",另外发送一条select语句抓取当前对象关联实体或集合
执行结果：2条语句
Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.class_id as class3_1_0_ from student_join student0_ where student0_.id=?
学生1
Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from classes_join classes0_ where classes0_.id=?
高一(1)班
======================================
2）设置fetch="join",如：
<many-to-one name="classes" column="classesid" fetch="join"/>
fetch="join",hibernate会通过select语句使用外连接来加载其关联实体或集合
此时lazy会失效
执行结果：一条join语句
Hibernate: select student0_.id as id1_1_, student0_.name as name1_1_, student0_.class_id as class3_1_1_, classes1_.id as id0_0_, classes1_.name as name0_0_ from student_join student0_ left outer join classes_join classes1_ on student0_.class_id=classes1_.id where student0_.id=?
学生1
高一(1)班