hibernate进阶--一对多映射配置

hibernate作为一款优秀的ORM框架，广受大家喜爱，也被Java社区公认为持久层的首选。虽然jdbc为Java数据库操 作带来了诸多便利，但是并没有统一SQL语句的写法，而且具体操作数据库的代码也足够复杂，且存在大量重复。所以有了ORM框架，让Java程序员可以从 SQL语句中解放，Hibernate就是其中的翘楚。Hibernate将JDBC进一步的封装了，在SQL的可移植性方面表现优秀，并且使 Hibernate程序代码足够简化。

ORM（对象关系映射）是面向对象程序员在代码的编写过程中更舒服，不用处理繁杂的SQL，每个对象映射到数据库中的一条记录，一个实体类对应数据库里的一张表，所有这些都让面向对象程序员处理起来得心应手。Hibernate的开发环境搭建我已经在另一篇博客中介绍了，本文主要介绍一下Hibernate的基本配置与使用。

关于session的获取、以及基本的增删改查操作：

1. @Before
2. public void init(){
3. config = new Configuration().configure();
4. serviceRegistry = new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
5. sessionFactory = config.buildSessionFactory(serviceRegistry);
6. session = sessionFactory.openSession();
7. transaction = session.getTransaction();
8. transaction.begin();
9. }

上 面这段代码主要是session的获取以及开启事务，Hibernate的CRUD都是在事务中进行的，如果不开启事务所有的操作都不会主动提交到数据库 的。关于CRUD操作，在session中有对应的API，不但功能强大而且使用方便，包括：save，update，delete，get，load 等，其中注意get和load方法：get会直接获取数据库记录对象、load则是生成代理对象，只有该对象在被第一次使用的时候才向数据库发送SQL语 句，真正的获得对象。当然还包括其他一些强大的API我们以后在学习。

配置---Hibernate的核心：

Hibernate最主要的就是配置了，首先就是hibernate.cfg.xml文件，如以前环境搭建时讲到的一样，关于数据库的基本配置信息都要在
该文件中配置好，包括对数据源的支持等以及实体类与数据表的映射关系。另一个重要的配置文件为XXX.hbm.xml文件，主要配置的是数据表与实体类之
间的映射关系，如下面User类与USER表之间的对应：

1. <hibernate-mapping>
2. <class name="com.song.hibernate.User" table="USER">
3. <id name="id" type="int">
4. <column name="ID" />
5. <generator class="assigned" />
6. </id>
7. <property name="uname" type="java.lang.String">
8. <column name="UNAME" />
9. </property>
10. <property name="birth" type="java.util.Date">
11. <column name="BIRTH" />
12. </property>
13. </class>
14. </hibernate-mapping>

下文主要介绍xxx.hbm.xml文件的配置：

首先，数据类型，Java的数据类型与数据库的数据类型并不是一一对应的，所以就有了hibernate的中间类型：

Java数据类型	Hibernate数据类型	标准SQL数据类型 (PS:对于不同的DB可能有所差异)
byte、java.lang.Byte	byte	TINYINT
short、java.lang.Short	short	SMALLINT
int、java.lang.Integer	integer	INGEGER
long、java.lang.Long	long	BIGINT
float、java.lang.Float	float	FLOAT
double、java.lang.Double	double	DOUBLE
java.math.BigDecimal	big_decimal	NUMERIC
char、java.lang.Character	character	CHAR(1)
boolean、java.lang.Boolean	boolean	BIT
java.lang.String	string	VARCHAR
boolean、java.lang.Boolean	yes_no	CHAR(1)('Y'或'N')
boolean、java.lang.Boolean	true_false	CHAR(1)('Y'或'N')
java.util.Date、java.sql.Date	date	DATE
java.util.Date、java.sql.Time	time	TIME
java.util.Date、java.sql.Timestamp	timestamp	TIMESTAMP
java.util.Calendar	calendar	TIMESTAMP
java.util.Calendar	calendar_date	DATE
byte[]	binary	VARBINARY、BLOB
java.lang.String	text	CLOB
java.io.Serializable	serializable	VARBINARY、BLOB
java.sql.Clob	clob	CLOB
java.sql.Blob	blob	BLOB
java.lang.Class	class	VARCHAR
java.util.Locale	locale	VARCHAR
java.util.TimeZone	timezone	VARCHAR
java.util.Currency	currency	VARCHAR

一般我们使用hibernate的中间类型，但是也可以使用Java类型。比如java.util.Date类型并不能详细表达该date类型是日期还是
时间还是日期+时间的形式，而hibernate中间类型就有详细的区分：date表示日期，time表示时间，timestamp表示日期+时间类型。

配置主键的生成策略：

在配置文件中<generator class="assigned" />标签代表主键的生成策略，最常用的是assigned和native：

assigned：由程序控制、就是手动赋值

native：根据数据库类别使用其原生的主键生成方式，MySQL是auto_increment；

还有几种生成策略，identity自增的方式、sequence适用于oracle的sequence方式、hilo使用hige/low算法生成主键、还有包括seqhilo、uuid.hex、guid、select等以后用到再说。

配置映射关系：

1. 单向一对多映射：班级grade与学生student就是一对多的映射关系，通过班级可以查到属于该班级的所有学生，即一个班级对应多个学生，这就是单向的一对多，grade------>students
2. 单向多对一映射：同样的通过每个学生可以查找到他的班级，这就是单向的多对一，即多个学生对应一个班级，students----->grade
3. 双向的一对多映射：就是两者结合，通过一个班级可以查找到所有属于该班级的学生并且通过每个学生可以查找到他们所属的班级，几一个班级对应多个学生且多个学生对应一个班级

以grade和students为例来学习hibernate的一对多映射关系配置：

首先是准备阶段，创建数据表grade 和 student：

1. create table grade(
2. gid int,
3. gname varchar(20) not null,
4. gdesc varchar(40)
5. );
6. create table student(
7. sid int,
8. sname varchar(20) not null,
9. sex varchar(2),
10. gid int
11. );
12. alter table student add constraint fk_student-gid foregin key (gid) references grade (gid);

然后创建两个对应的实体类：

在单向一对多中：

1. public class Grade{
2. private int gid;
3. private String gname;
4. private String gdesc;
5. private Set<Student> students;
6. //对应的getter、setter方法 构造器、及其他测试需要的toString方法等
7. }

1. public class Student{
2. private int sid;
3. private String sname;
4. private String sex;
5. //对应的getter、setter方法 构造器、及其他测试需要的toString方法等
6. }

因为是单向的一对多关系，所以在Student类中不会含有grade的引用；

对应生成的hbm.xml文件如下：

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4. <hibernate-mapping>
5. <class name="com.song.entity.Grade" table="GRADE">
6. <id name="gid" type="int">
7. <column name="GID" />
8. <generator class="assigned" />
9. </id>
10. <property name="gname" type="java.lang.String">
11. <column name="GNAME" />
12. </property>
13. <property name="gdesc" type="java.lang.String">
14. <column name="GDESC" />
15. </property>
16. <set name="students" table="STUDENT" >
17. <key>
18. <column name="GID" />
19. </key>
20. <one-to-many class="com.song.entity.Student" />
21. </set>
22. </class>
23. </hibernate-mapping>

Students.hbm.xml：

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4. <hibernate-mapping>
5. <class name="com.song.entity.Student" table="STUDENT">
6. <id name="sid" type="int">
7. <column name="SID" />
8. <generator class="assigned" />
9. </id>
10. <property name="sname" type="java.lang.String">
11. <column name="SNAME" />
12. </property>
13. <property name="sex" type="java.lang.String">
14. <column name="SEX" />
15. </property>
16. </class>
17. </hibernate-mapping>

在单向多对一中：

与单向一对多相反，这次单方不用持有一方的集合引用；

1. public class Grade{
2. private int gid;
3. private String gname;
4. private String gdesc;
5. //对应的getter、setter方法 构造器、及其他测试需要的toString方法等
6. }

1. public class Student{
2. private int sid;
3. private String sname;
4. private String sex;
5. private Grade grade;
6. //对应的getter、setter方法 构造器、及其他测试需要的toString方法等
7. }

可以通过学生来查询到其所在的班级，对应的hbm.xml配置如下：

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4. <hibernate-mapping>
5. <class name="com.song.entity.Student" table="STUDENT">
6. <id name="sid" type="int">
7. <column name="SID" />
8. <generator class="assigned" />
9. </id>
10. <property name="sname" type="java.lang.String">
11. <column name="SNAME" />
12. </property>
13. <property name="sex" type="java.lang.String">
14. <column name="SEX" />
15. </property>
16. <many-to-one name="grade" class="com.song.entity.Grade" >
17. <column name="GID" />
18. </many-to-one>
19. </class>
20. </hibernate-mapping>

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4. <hibernate-mapping>
5. <class name="com.song.entity.Grade" table="GRADE">
6. <id name="gid" type="int">
7. <column name="GID" />
8. <generator class="assigned" />
9. </id>
10. <property name="gname" type="java.lang.String">
11. <column name="GNAME" />
12. </property>
13. <property name="gdesc" type="java.lang.String">
14. <column name="GDESC" />
15. </property>
16. </class>
17. </hibernate-mapping>

class Grade{

• private int gid;
• private String gname;
• private String gdesc;
• private Set<Student> students;
• //对应的getter、setter方法 构造器、及其他测试需要的toString方法等
• }

1. public class Student{
2. private int sid;
3. private String sname;
4. private String sex;
5. private Grade grade;
6. //对应的getter、setter方法 构造器、及其他测试需要的toString方法等
7. }

在hbm.xml文件中也是要两端同时配置单向一对多和单向多对一：

1. <hibernate-mapping>
2. <class name="com.song.entity.Grade" table="GRADE">
3. <id name="gid" type="int">
4. <column name="GID" />
5. <generator class="assigned" />
6. </id>
7. <property name="gname" type="java.lang.String">
8. <column name="GNAME" />
9. </property>
10. <property name="gdesc" type="java.lang.String">
11. <column name="GDESC" />
12. </property>
13. <set name="students" table="STUDENT" inverse="true" cascade="save-update">
14. <key>
15. <column name="GID" />
16. </key>
17. <one-to-many class="com.song.entity.Student" />
18. </set>
19. </class>
20. </hibernate-mapping>

1. <hibernate-mapping>
2. <class name="com.song.entity.Student" table="STUDENT">
3. <id name="sid" type="int">
4. <column name="SID" />
5. <generator class="assigned" />
6. </id>
7. <property name="sname" type="java.lang.String">
8. <column name="SNAME" />
9. </property>
10. <property name="sex" type="java.lang.String">
11. <column name="SEX" />
12. </property>
13. <many-to-one name="grade" class="com.song.entity.Grade" cascade="all">
14. <column name="GID" />
15. </many-to-one>
16. </class>
17. </hibernate-mapping>

其中设置了在“一”端inverse属性，默认为false这里设为true，用来优化，交给多段来维护对应关系。

还有cascade：代表级联操作，默认为none，就是不级联

save-update代表在save和update时级联、delete代表在删除时级联、all代表什么情况都级联。

转：http://blog.csdn.net/weiguang111/article/details/50521917