Hibernate数据关联

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               < key column ="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)