这章我们就来学习下hibernate的关系关联，即一对一(one-to-one)，一对多(one-to-many)，多对多(many-to-many)。这章也将是hibernate的最后一章了，用于初学者可以了。
首先讲述一对一:就以一个人对应一张身份证为列子。
第一步:新建表 persion(人)与card(身份证) 表结构如下 两个pid都给的varchar是为了在主键生成策略中使用uuid
第二步:项目/com.entity下新建两个实体类，与数据库对应,然后封装构造，有参构造中去掉pid。建好后再新建这两个类的hbm.xml文件,在persion.hbm.xml中将<id/>节点中的主键生成策略改成uuid
<id name="pid" type="java.lang.String">
<column name="PID" />
//改uuid
<generator class="uuid" />
</id>
将card.hbm.xml中的<id/>节点中的主键生成策略改成foreign,等于外键的意思
<id name="pid" type="java.lang.String">
<column name="PID" />
<!-- 主键生成策略 改成外键 -->
<generator class="foreign">
</generator>
</id>
第三步:就要开始建立一对一关系了:先在persion实体类中定义一个card的对象，记住不要实例化(new)，然后封装。
private Card card;
public Card getCard() {
return card;
} public void setCard(Card card) {
this.card = card;
}
接着在card实体类中定义一个persion的对象，也不要实例化(new)，然后封装。
private Person person;
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
第四步:就要开始建立一对关系的配置了。在persion.hbm.xml<class/>节点中添加<one-to-one/>节点;其中name属性值为persion实体类中定义的card对象的变量名。
<one-to-one name="card" class="com.entity.Card" cascade="all"></one-to-one>
在card.hbm.xml<class/>节点中添加<one-to-one/>节点;其中name属性值为card实体类中定义的persion对象的变量名。
<one-to-one name="person" class="com.entity.Person"></one-to-one>
还要在card.hbm.xml主键生成策略中添加一个参数<param/>，其中name属性值为固定写法，persion为card实体类中定义的persion对象的变量名。
<id name="pid" type="java.lang.String">
<column name="PID" />
<!-- 主键生成策略 改成外键 -->
<generator class="foreign">
<param name="property">person</param>
</generator>
</id>
配置到这里就完了。那么有人肯定会有疑问?
persion.hbm.xml 中的<one-to-one/>中cascade="all"是什么意思?
cascade这个属性就相当与两张表的关联属性,有以下属性值
none:所有情况下均不进行关联操作。这是默认值。
all:所有情况下均进行关联操作
save-update:在执行save/update/saveOrUpdate时进行关联操作。
delete:在执行delete时进行关联操作。
all-delete-orphan:当对象图中产生孤儿节点时,在数据库中删除该节点
就拿delete来说吧，就是删除persion的对象数据时，对应的card对象数据也将被删除。
第五步:hibernate.cfg.xml配置文件中加上实体类.hbm.xml的映射关系<mapping/>
<mapping resource="com/entity/Card.hbm.xml" />
<mapping resource="com/entity/Person.hbm.xml" />
第六步:就要开始测试了:建立一个测试类，其中写个junit的@Test测试方法。
既然用了@Tset,那么就在再用下@Before(方法执行之前触发)与@Aafter(方法执行之后触发)，这样我们就可以将重复的代码写在这两个方法里面，减轻代码量
private Configuration configuration; private SessionFactory factory;
private Session session;
private Transaction transaction;
@Before
public void Before() {
configuration = new Configuration().configure();
factory = configuration.buildSessionFactory();
session = factory.openSession();
transaction = session.beginTransaction();
}
@After
public void after() {
// 关闭seeion
session.close();
// 关闭SessionFactory
factory.close();
}
增加:注意要互相添加值（互设）
@Test
public void add() {
// 增加
Person p = new Person("哈哈");
Card c = new Card("431088192215523305");
互设
p.setCard(c);
c.setPerson(p);
//这里因为建立cascade关联关系，所以只要添加设立了关系那端即可
session.save(p);
transaction.commit();
}
查询:
// 查询
Person p = session.get(Person.class,
"4028abee5f2a0142015f2a0144280000");
System.out.println(p+"--"+p.getCard());
其余我就不再测试了。
接下来讲述一对多:以一个省份对应多个城市为例子。
第一步:一样要新建两张表，province(省份)与城市(city)，表结构如下:
第二步:项目/com.entity下新建两个实体类，与数据库对应,然后封装构造，有参构造中去掉表主键。建好后再新建这两个类的hbm.xml文件,在province.hbm.xml与city.hbm.xml中将<id/>节点中的主键生成策略改成uuid。
第三步:在province(一端)实体类中定义并实例化city(多端)的集合，(set与list)以set为例。然后封装即可。
private Set<City> cities = new HashSet<>();
public Set<City> getCities() {
return cities;
}
public void setCities(Set<City> cities) {
this.cities = cities;
}
第四步:在city(多端)实体类中定义province(一端)对象,封装。注意:这个时候要将pid(多端表中一端表外键)这个属性在city的实体类中去掉(数据库表中依然存在),因为已经定义的province的对象，同时请将city.hbm.xml中所对应生成pid的<property/>节点也去掉!
private Province province;
public Province getProvince() {
return province;
}
public void setProvince(Province province) {
this.province = province;
}
第五步:在一端的hbm.xml中<class/>节点中添加如下代码:
<!--name 一端类中定义多端的集合名 table 表名 -->
<set name="cities" table="city" inverse="true" cascade="save-update">
<key>
<!-- 一端(province)主键名 -->
<column name="pid" />
</key>
<!-- 多端类(city)全限定名 -->
<one-to-many class="com.entity.City" />
</set>
在多端的hbm.xml中<class/>节点中添加如下代码:
<!--name="多端类中定义一端的集合名" class="一端类全限定名" -->
<many-to-one name="province" class="com.entity.Province">
<!-- 多端表中外键名(一端主键名) -->
<column name="pid" />
</many-to-one>
第六步:hibernate.cfg.xml配置文件中加上实体类.hbm.xml的映射关系<mapping/>
<mapping resource="com/entity/Province.hbm.xml" />
<mapping resource="com/entity/City.hbm.xml" />
这样配置就可以了，那么疑问又来了?在一端的hbm.xml<set/>中inverse又是什么?
Inverse：负责控制关系，默认为false，也就是关系的两端都能控制，但这样会造成一些问题，更新的时候会因为两端都控制关系，于是重复更新。一般来说有一端要设为true。那么SQL语句的维护关系就在多端进行操作。
第七步：测试:@Test就与一对一的测试方法一样即可
增加:
Province p = new Province("湖南");
City c = new City("长沙");
City c1 = new City("株洲");
City c2 = new City("湘潭");
//互设
p.getCities().add(c);
p.getCities().add(c1);
p.getCities().add(c2);
c.setProvince(p);
c1.setProvince(p);
c2.setProvince(p);
session.save(p);
transaction.commit();
查询:
City c = (City) session.createQuery("from City where cname=?").setParameter(, "长沙").uniqueResult();
System.out.println(c.getProvince().getPid());
其余的方法就不测试了。
最后讲述多对多:就以多个角色对应多个权限,多个权限对应多个角色为例子:
第一步:还是老样子建表：角色表(users),权限表(role)，还要一张中间表(users_role),表结构如下:
第二步:项目/com.entity下新建两个实体类,中间表不用,与数据库对应,然后封装构造,有参构造中去掉表主键。建好后再新建这两个类的hbm.xml文件,在hbm.xml中将<id/>节点中的主键生成策略改成uuid。
第三步:在这两个实体类中定义并实例化对方的集合，(set与list)以set为例。然后封装即可。
第四步:在users.hbm.xml中添加如下代码：
//name=集合对象名 table=中间表名
<set name="roles" table="users_role" inverse="true" cascade="save-update">
//该类主键名
<key column="uid"></key>
//calss set集合中对象的全路径名 column外键名(set集合中对象的主键名)
<many-to-many class="com.entity.Role" column="rid" />
</set>
在role.hbm.xml中添加如下代码：
//name=集合对象名 table=中间表名
<set name="users" table="users_role" inverse="true" cascade="save-update">
//该类主键名
<key column="rid"></key>
//calss set集合中对象的全路径名 column外键名(set集合中对象的主键名)
<many-to-many class="com.entity.Users" column="uid" />
</set>
第六步:hibernate.cfg.xml配置文件中加上实体类.hbm.xml的映射关系<mapping/>
<mapping resource="com/entity/Users.hbm.xml" />
<mapping resource="com/entity/role.hbm.xml" />
最后测试：
增加:
Users u = new Users("哈哈");
Role r = new Role("草鸡管理员");
Role r1 = new Role("普通管理员");
Role r2 = new Role("垃圾管理员");
u.getRoles().add(r);
u.getRoles().add(r1);
u.getRoles().add(r2);
r.getUsers().add(u);
r1.getUsers().add(u);
r2.getUsers().add(u);
transaction.commit();
查询:
Users s = session.get(Users.class, "4028abee5f664493015f6644959b0001");
for (Role r : s.getRoles()) {
System.out.println(r);
｝
//List<Users> ls = session.createQuery("from Users u left outer join fetch u.roles r where r.rid='4028abee5f664493015f6644958a0000'").list();
// for (Users users : ls) {
// System.out.println(users.getRoles());
// }
到此,hibernate结束!