1.一对一关联
1 <hibernate-mapping>
2 <class
3 name="org.hibernate.sample.TUser"
4 table="t_user"
5 dynamic-update="true"
6 dynamic-insert="true"
7 >
9 <one-to-one
10 name="group"<!--对应实体内属性名称-->
11 class="org.hibernate.sample.TGroup"<!--包括包名的实体-->
12 cascade="none"
13 outer-join="auto"
14 constrained="false"
15 />
17 </class>
18 </hibernate-mapping>
1 public class TUser implements Serializable {
2 private TGroup group;
3 public TGroup getGroup() {
4 return group;
5 }
6 }
2.一对多关联
单向一对多关联：
1 <hibernate-mapping>
2 <class
3 name="org.hibernate.sample.TUser"
4 table="t_user"
5 dynamic-update="true"
6 dynamic-insert="true"
7 >
8 <set <!--使用set因为实体内属性的类别为set。之所以使用set接口而不直接使用实现类，是因为hibernate自己实现了一个set，如果实体内属性设定为jdk的HashSet，会抛转型异常。-->
9 name="addresses"<!--TUser实体内的addresses属性-->
10 table="t_address"<!--“多”方的表名称-->
11 lazy="false"<!--延迟加载，只是在需要读取对应的属性时候，才进行数据库的查询。而不是在启动服务时候就已经全部把所有映射文件的关系读取完毕，这样提升了性能。-->
12 inverse="false"<!--inverse为false的一方负责维护关系，是主控方。所谓主控方就是数据库的读，存，删，更新只能从主控方主导操作，被动方无法进行上述操作。这里是单向关系。-->
13 cascade="all"
14 sort="unsorted"
15 order-by="zipcode asc"
16 >
17 <keycolumn="user_id"></key><!--“多”表内的字段名称-->
21 <one-to-many
22 class="org.hibernate.sample.TAddress"/><!--“多”方的类名，通过key元素的colunm属性，找到对应的实体属性-->
24 </set>
25 </class>
26 </hibernate-mapping>
27
双向一对多关联：
1 <hibernate-mapping>
2 <class
3 name="org.hibernate.sample.TUser"
4 table="t_user"
5 dynamic-update="true"
6 dynamic-insert="true"
7 >
8 <set
9 name="addresses"
10 table="t_address"
11 lazy="false"
12 inverse="true"
13 cascade="all"
14 sort="unsorted"
15 order-by="zipcode asc"
16 >
17 <key column="user_id"></key><!--对应表的字段。难道key属性设置的都是对应表的字段？-->
18 <one-to-many
19 class="org.hibernate.sample.TAddress"
20 />
21 </set>
22 </class>
23 </hibernate-mapping>
24
1 <hibernate-mapping>
2 <class
3 name="org.hibernate.sample.TAddress"
4 table="t_address"
5 dynamic-update="false"
6 dynamic-insert="false"
7 >
8 <many-to-one
9 name="user"
10 class="org.hibernate.sample.TUser"
11 cascade="none"
12 outer-join="auto"
13 update="true"
14 insert="true"
15 access="property"
16 column="user_id"
17 not-null="true"
18 />
19 </class>
20 </hibernate-mapping>
21
双向关联，依然存在主控方，被动方。但建立了双向关联后，从任何一方都可以读取到对方的信息，不过更新，删除，增加依然需要主控方进行维护。之所以单向不能互访，因为有一方没有在映射文件进行mapping，就没办法在读取数据库时候把相关数据填充。
1 TAddress addr = new TAddress();
2 addr.setTel("1123");
3 addr.setZipcode("233123");
4 addr.setAddress("Hongkong");
5 addr.setUser(user);//设置关联的TUser对象，这步是必须的。TAddress为主控方，因此需要自己去维护与User的关系。
6 user.getAddresses().add(addr);
7 session.save(user);//级联更新
8
3.多对多关联
多对多关联需要建立一张中间表，以此表进行多对多的关联。同时中间表需要对两个“多”方表进行外键设定。
1 <hibernate-mapping>
2 <class
3 name="org.hibernate.sample.TGroup"
4 table="t_group"
5 dynamic-update="false"
6 dynamic-insert="false"
7 >
8 <set
9 name="roles"
10 table="t_group_role"<!--中间表-->
11 lazy="false"
12 inverse="false"
13 cascade="save-update"
14 >
15 <key column="group_id"></key><!--中间表对应此表内的字段,通过外键对应到这张表的主键-->
16 <many-to-many
17 class="org.hibernate.sample.TRole"
18 column="role_id"<!--对应“多”方表内的字段，通过外键找到对应表的主键-->
19 />
20 </set>
21 </class>
22 </hibernate-mapping>
23
1 <hibernate-mapping>
2 <class
3 name="org.hibernate.sample.TRole"
4 table="t_role"
5 dynamic-update="false"
6 dynamic-insert="false"
7 >
8 <set
9 name="groups"
10 table="t_group_role"
11 lazy="false"
12 inverse="true"
13 cascade="save-update"
14 sort="unsorted"
15 >
16 <key column="role_id"></key>
17 <many-to-many
18 class="org.hibernate.sample.TGroup"
19 column="group_id"
20 outer-join="auto"
21 />
22 </set>
23 </class>
24 </hibernate-mapping>
25
由于是多对多关联，所以保存状态时候需要把双方同时保存。
1 TRole role = new TRole();
2 TGroup group = new TGroup();
3 role.getGroups.add(group);
4 group.getRoles.add(role);
//然后通过session把两个对象都进行保存。session.add(role) ,session.add(group)