Hibernate4学习总结(2)--配置形式的集合映射，关联关系映射

本文包括以下四个部分：

增删改查（CDUR）方法。
集合映射。

关联关系映射。
Inverse属性和cascade属性。

一、增删改查方法

需求：将客户对象保存进数据库。

User.java

package edu.scut.b_curd;
public class User {
private int id;
private String name;
private String password;
private String email;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", password=" + password
+ ", email=" + email + "]";
}
}

User表



User.hbm.xml

<pre name="code" class="html"><?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="edu.scut.b_curd.User" table="t_user">
<!-- 主键 -->
<id name="id" column="t_id">
<generator class="assigned"></generator>
</id>

<!-- 普通属性 -->
<property name="name" column="t_name" type="string" length="20"></property>
<property name="password" column="t_password" length="20"></property>
<property name="email" column="t_email" length="50"></property>
</class>
</hibernate-mapping>

1.1 保存

在事务当中，如果发生异常，就需要回滚，将数据还原为之前的状态。

public void test1(){
//1 获取session对象
Session session = HibernateUtil.getSession();

//2 开启事务
session.beginTransaction();

try {
//3 保存user
User user = new User();
user.setId(2);
user.setName("张三丰");
user.setPassword("666666");
user.setEmail("1156744308@qq.com");

session.save(user);

//4 提交事务
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
//出现异常，回滚事务
session.getTransaction().rollback();
} finally{
//关闭资源
HibernateUtil.close(session);
}
}

1.2 更新

有两种方式，第一种方式需要对对象的每一项数据都要修改，否则将成为null；第二种只操作需要修改的属性，更为常用。

public void test2(){
//1 获取session对象
Session session = HibernateUtil.getSession();
//2 打开事务
session.beginTransaction();

try {
//3 更新操作,有两种方式
/*
* 第一种方式：
* <1>必须给id赋值；
* <2>hibernate会把所有字段都更新，如果对象的属性不赋值，则设置null
*/
/*User user = new User();
user.setId(1);
user.setName("荆天明");
user.setPassword("666666");
user.setEmail("1156744308@163.com");
session.update(user);
*/

/*
* 第二种方式（推荐的方式）
* <1>先把需要更新的对象查询出来
* <2>参数一：查询的对象
* <3>参数二：ID值
*/
User user = (User) session.get(User.class,1);
//修改需要更新的属性
user.setName("盖聂");
user.setPassword("88888888");

//4 提交事务
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
//有异常，回滚事务
session.getTransaction().rollback();
} finally{
//5 关闭资源
HibernateUtil.close(session);
}
}

1.3 查询

较常用的是以下三种方式。

public void test3(){
//1 获取session对象
Session session = HibernateUtil.getSession();
//2 打开事务
session.beginTransaction();

try {
//3 查询用户
//<1>查询所有用户，hql
Query query = session.createQuery("from User");
List<User> users = query.list();
for (User user : users) {
System.out.println(user);
}

//<2>查询一个用户
User user = (User) session.get(User.class,1);
System.out.println(user);

//<3>条件查询一个用户
Query q = session.createQuery("select u from User u where name=? ");
q.setParameter(0, "盖聂");
User u = (User) q.uniqueResult();
System.out.println(u);

//4 提交事务
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
//有异常，回滚事务
session.getTransaction().rollback();
} finally{
//5 关闭资源
HibernateUtil.close(session);
}
}

1.4 删除

两种删除方式，推荐使用第一种。

public void test4(){
//1 获取session对象
Session session = HibernateUtil.getSession();
//2 打开事务
session.beginTransaction();

try {
//3 删除用户
//第一种，先查询出来
User user = (User) session.get(User.class, 1);
if(user!=null){
session.delete(user);
}

//第二种(不推荐)
User user2 = new User();
user2.setId(2);
session.delete(user2);

//4 提交事务
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
//有异常，回滚事务
session.getTransaction().rollback();
} finally{
//5 关闭资源
HibernateUtil.close(session);
}
}

二、集合映射

需求：

客户购物时填写收货地址，收货地址是基本类型，而且有多个，这时应采用集合对地址进行封装。

1.1 Set集合

客户类属性：

private int id;
private String name;

//使用Set集合来存储收货地址：元素无序的
private Set<String> addressSet = new HashSet<String>();

User.hbm.xml

<!-- 映射set集合
name:Set集合的属性名称
table：存储收货地址数据的表
key：配置用户的外键
-->
<set name="addressSet" table="t_address">
<!-- 外键 -->
<key column="u_id"></key>
<!-- Set元素的信息
type:数据类型
column：存放Set的数据字段名称
-->
<element column="address_name" type="string"></element>
</set>

1.2 List集合

客户类属性：

private int id;
private String name;
//使用List集合来存储收货地址：元素是有序的
private List<String> addressList = new ArrayList<String>();

User.hbm.xml

<!-- 映射List集合 -->
<list name="addressList" table="t_address_list">
<!-- 外键 -->
<key column="u_id"></key>
<!-- list的索引字段（排序） -->
<list-index column="idx"></list-index>
<!-- list元素 -->
<element column="address_name" type="string" ></element>
</list>

1.3 Map集合

客户类属性

<pre name="code" class="html">        private int id;
private String name;

//使用Map集合来存储收货地址：元素是无序的 private Map<String, String> addressMap = new HashMap<String, String>();

User.hbm.xml

<!-- 映射Map集合 -->
<map name="addressMap" table="t_address_map">
<!-- 外键 -->
<key column="u_id"></key>
<!-- key元素 -->
<map-key type="string" column="address_no"></map-key>
<!-- value元素 -->
<element type="string" column="address_name"></element>
</map>

三、关联关系映射

本文只对常用的集中映射关系做讲解。

一对多（单向）、多对一（单向）、一对多（双向）这三类映射采用客户(Customers)和订单(Orders)举例子，其中Customers是一方，Orders是多方。

3.1 多对一（单向）

a. 关系映射图解



注意：多对一（单向）要在多方的属性当中加入一方，以此来建立单向关联。

本例中在多方实体类中添加：private Customers customers;

b. Customers.hbm.xml

<hibernate-mapping>
<class name="edu.scut.a_many2one_single.Customers" table="t_customers">
<id name="id" column="c_id">
<generator class="increment"></generator>
</id>

<property name="name" column="c_name"></property>
</class>
</hibernate-mapping>

c. Orders.hbm.xml

<hibernate-mapping>
<class name="edu.scut.a_many2one_single.Orders" table="t_orders">
<id name="id" column="o_id">
<generator class="increment"></generator>
</id>

<property name="orderno" column="o_orderno"></property>

<!-- 配置多对一的关系
cascade:级联操作
save-uodate:保存或者修改订单的同时，修改客户
delete:删除订单的同时删除客户
all:save+update+delete的功能之和
none:默认，没有级联操作
-->
<many-to-one name="customers"
column="c_id"
class="edu.scut.a_many2one_single.Customers"
cascade="all"></many-to-one>
</class>
</hibernate-mapping>

d. 测试类（以save()方法为例）

建立了关系，并且配置了cascade，就可以实现级联操作。

public void test1(){
//打开session
Session session = HibernateUtil.getSession();
//打开事务
s ession.beginTransaction();
//添加用户
Customers customers = new Customers();
customers.setName("东方朔");
//添加订单
Orders o1 = new Orders();
o1.setOrderno("5166001");

Orders o2 = new Orders();
o2.setOrderno("5166002");

//建立关系（orders>>customers）
o1.setCustomers(customers);
o2.setCustomers(customers);

//保存数据
//如果采用了级联操作，直接保存订单，客户也可以保存
//如果不配置相应的级联操作，那么会出现异常：(object references an unsaved transient instance - save the transient )
session.save(o1);
session.save(o2);

//提交事务
session.getTransaction().commit();

//关闭资源
HibernateUtil.close(session);
}

3.2 一对多（单向）

a. 关系映射图解



注意：一对多（单向）要在一方的属性当中加入集合来封装多方数据，以此来建立单向关联。

本例在一方实体类中添加：private Set<Orders> orders = new HashSet<Orders>();

b. Customers.hbm.xml

<hibernate-mapping>
<class name="edu.scut.b_one2many_single.Customers" table="t_customers">
<id name="id" column="c_id">
<generator class="increment"></generator>
</id>

<property name="name" column="c_name"></property>

<!-- 配置一对多的关系
name:属性名称
-->
<set name="orders" cascade="all">
<!-- key：外键字段名称 -->
<key column="c_id"></key>
<!-- set集合的元素类型 -->
<one-to-many class="edu.scut.b_one2many_single.Orders"/>
</set>
</class>
</hibernate-mapping>

c. Orders.hbm.xml

<hibernate-mapping>
<class name="edu.scut.b_one2many_single.Orders" table="t_orders">
<id name="id" column="o_id">
<generator class="increment"></generator>
</id>

<property name="orderno" column="o_orderno"></property>

</class>
</hibernate-mapping>

d. 测试类（以save()方法为例）

建立了关系，并且配置了cascade，就可以实现级联操作。

public void test1(){
//打开session
Session session = HibernateUtil.getSession();
//打开事务
session.beginTransaction();
//添加用户
Customers customers = new Customers();
customers.setName("项羽");
//添加订单
Orders o1 = new Orders();
o1.setOrderno("4326001");

Orders o2 = new Orders();
o2.setOrderno("5436002");

//建立关系（customers>>orders）
customers.getOrders().add(o1);
customers.getOrders().add(o2);

//保存数据
session.save(customers);

//提交事务
session.getTransaction().commit();

//关闭资源
HibernateUtil.close(session);
}

3.3 一对多/多对一（双向）

将一对多（单向）和多对一（单向）同时配置，并建立双向关系就是一会多（双向）。

注意：一对多（双向）要在一方的属性当中加入集合来封装多方数据，并在多方的属性当中加入一方的对象，以此来建立双向关联。

本例在一方实体类中添加：private Set<Orders> orders = new HashSet<Orders>();在多方实体类中添加： private Customers customers;

a. Customers.hbm.xml

<hibernate-mapping>
<class name="edu.scut.c_one2many_double.Customers" table="t_customers">
<id name="id" column="c_id">
<generator class="increment"></generator>
</id>

<property name="name" column="c_name"></property>

<!-- 配置一对多的关系
name:属性名称
-->
<p align="left">                <!-- inverse=true，如果出现在单方的话，表示由多方维护关系，默认是false，表示双方共同维护关系</p><p align="left">          如果双方共同维护关系的话，就会出现如下二种情况：</p><p align="left">          1）SQL多余了，但不出错 -》一对多双向关联</p><p align="left">          2）SQL多余了，但出错    -》多对多双向关联</p><p align="left">            --></p><p align="left"><span style="color:red;">               </span> <set name="orders" cascade="all" inverse="true">
</p>			 <!-- key：外键字段名称 -->
<key column="c_id"></key>
<!-- set集合的元素类型 -->
<one-to-many class="edu.scut.c_one2many_double.Orders"/>
</set>
</class>
</hibernate-mapping>

b. Orders.hbm.xml

<hibernate-mapping>
<class name="edu.scut.c_one2many_double.Orders" table="t_orders">
<id name="id" column="o_id">
<generator class="increment"></generator>
</id>

<property name="orderno" column="o_orderno"></property>

<!-- 配置多对一的关系 -->
<many-to-one name="customers"
column="c_id"
class="edu.scut.c_one2many_double.Customers"
cascade="all"
/>
</class>
</hibernate-mapping>

d. 测试类（以save()方法为例）

建立了双向关系，并且配置了cascade，就可以实现级联操作。

public void test1(){
//打开session
Session session = HibernateUtil.getSession();
//打开事务
session.beginTransaction();
//添加用户
Customers customers = new Customers();
customers.setName("项羽");
//添加订单
Orders o1 = new Orders();
o1.setOrderno("4326001");

Orders o2 = new Orders();
o2.setOrderno("5436002");

//建立双向关系
//客户>>订单
customers.getOrders().add(o1);
customers.getOrders().add(o2);
//订单>>客户
o1.setCustomers(customers);
o2.setCustomers(customers);

//保存数据，保存客户和订单的任意一方，都可级联保存另一方
session.save(customers);

//提交事务
session.getTransaction().commit();

//关闭资源
HibernateUtil.close(session);
}

问题：有了一对多关联之后，保存数据时，会多余两条update语句！

解决方案：在一对多的关联关系配置中，在一方 把inverse="true"即可！

3.4 多对多（双向）

多对多（双向）采用老师(Teacher)和学生(Student)举例子。

注意：多对多（双向）要在双方的实体类中同时加入集合封装对方的数据，以此来建立双向关联。多对多（双向）的关联中存在一个中间表，依赖中间表来建立两个表之间的关系。

本例在Student实体类中添加：private Set<Teachers> teachers = new HashSet<Teachers>();

在Teacher实体类中添加： private Set<Students> students = new HashSet<Students>();

a. 关系映射图解



b. Students.hbm.xml

<hibernate-mapping>
<class name="edu.scut.d_many2many_double.Students" table="t_student">
<id name="id" column="s_id">
<generator class="increment"></generator>
</id>

<property name="name" column="s_name"></property>

<!-- 配置多对多的关系
table:中间表的名称
-->
<set name="teachers" table="student_teacher" inverse="true">
<!-- 当前对象所在中间表的外键 -->
<key column="s_id"></key>
<!-- set集合的元素类型 -->
<!-- column:集合类型所在中间表的外键 -->
<many-to-many class="edu.scut.d_many2many_double.Teachers" column="t_id"></many-to-many>
</set>
</class>
</hibernate-mapping>

c. Teachers.hbm.xml

<hibernate-mapping>
<class name="edu.scut.d_many2many_double.Teachers" table="t_teacher">
<id name="id" column="t_id">
<generator class="increment"></generator>
</id>

<property name="name" column="t_name"></property>

<!-- 配置多对一的关系 -->
<set name="students" table="student_teacher" cascade="all">
<!-- 当前对象所在中间表的外键 -->
<key column="t_id"></key>
<!-- set集合类型 -->
<!-- column：集合类型所在中间表的外键 -->
<many-to-many class="edu.scut.d_many2many_double.Students" column="s_id"></many-to-many>
</set>
</class>
</hibernate-mapping>

d. 测试类（以save()方法为例）

建立了双向关系，并且配置了cascade，就可以实现级联操作。

public void test1(){
//打开session
Session session = HibernateUtil.getSession();
//打开事务
session.beginTransaction();

//保存学生
Students s1 = new Students();
s1.setName("小强");
Students s2 = new Students();
s2.setName("小花");

//保存老师
Teachers t1 = new Teachers();
t1.setName("李老师");
Teachers t2 = new Teachers();
t2.setName("卢老师");

//建立双向关系
//学生>>老师
s1.getTeachers().add(t1);
s1.getTeachers().add(t2);
s2.getTeachers().add(t1);
s2.getTeachers().add(t2);

//老师>>学生
t1.getStudents().add(s1);
t1.getStudents().add(s2);
t2.getStudents().add(s1);
t2.getStudents().add(s2);

//保存数据，保存客户和订单的任意一方，都可级联保存另一方
session.save(t1);
session.save(t2);

//提交事务
session.getTransaction().commit();

//关闭资源
HibernateUtil.close(session);
}

问题：在多对多双向关联中，SQL多余了，而且报错。

解决方案：在任的多方把inverse="true"即可！

3.5 一对一（双向）

一对一（双向）采用公民和身份证举例子。

注意：一对一（双向）要在双方的实体类中同时加入对方的对象，以此来建立双向关联。

本例在Personst实体类中添加：private IdCards idcards;

在IdCards实体类中添加： private Persons persons;

a. 关系映射图解



b. IdCards.hnm.xml

有两种方式建立一对一（双向）的关系。

<hibernate-mapping>
<class name="edu.scut.e_one2one_double.IdCards" table="t_idcards">
<id name="id" column="i_id">
<generator class="increment"></generator>
</id>

<property name="cardno" column="i_cardno"></property>

<!-- 一对一配置方式有两种 -->
<!-- 第一种：唯一外键
是一种特殊的多选一方式，但是外键多了unique约束
-->
<!-- <many-to-one name="persons"
class="edu.scut.e_one2one_double.Persons"
column="p_id"
unique="true">
</many-to-one> -->

<!-- 第二种:主键关联
constrained:是否把主键作为外键
false：不作为外键
true：作为外键
-->
<one-to-one name="persons"
class="edu.scut.e_one2one_double.Persons"
constrained="true">
</one-to-one>
</class>
</hibernate-mapping>

c. Persons.hbm.xml

<hibernate-mapping>
<class name="edu.scut.e_one2one_double.Persons" table="t_persons">
<id name="id" column="p_id">
<generator class="increment"></generator>
</id>

<property name="name" column="p_name"></property>

<!-- 配置一对一的关系 -->
<one-to-one name="idcards"
class="edu.scut.e_one2one_double.IdCards"
cascade="all">
</one-to-one>
</class>
</hibernate-mapping>

d. 测试类（以save()方法为例）

建立了双向关系，并且配置了cascade，就可以实现级联操作。

public void test1(){
//打开session
Session session = HibernateUtil.getSession();
//打开事务
session.beginTransaction();

//公民
Persons p = new Persons();
p.setName("杨过");

//身份证
IdCards ic = new IdCards();
ic.setCardno("6104271990");

//建立关系
//公民>>身份证
p.setIdcards(ic);

//身份证>>公民
ic.setPersons(p);

//保存数据
session.save(p);

//提交事务
session.getTransaction().commit();

//关闭资源
HibernateUtil.close(session);
}

四、Inverse属性和cascade属性



4.1 Inverse属性

Inverse属性是在维护关联关系的时候起作用的，表示控制权是否转移。

Inverse= false 不反转； 当前方有控制权。

Inverse= True 控制反转； 当前方没有控制权。

默认是 Inverse= false，在一对多（双向）和多对多（双向）的关联关系中，如果不明确配置，则默认Inverse= false，即两边都具有控制权，在执行保存操作的时候，双方能否会维护表。导致一对多（双向）的关联关系出现出现多余的SQL语句，而多对多（双向）关联中直接报错（org.hibernate.exception.ConstraintViolationException:could not execute
statement, Caused by:com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException:Duplicate entry '7-7' for key 'PRIMARY'），提示中间表有重复的主键。因此，需要自己手动配置Inverse=“true”。

4.2 cascade属性

cascade 表示级联操作（可以设置到一的一方或多的一方）

none：不级联操作， 默认值。
save-update：级联保存或更新。
delete：级联删除。
save-update,delete：级联保存、更新、删除。
all：同上。级联保存、更新、删除。