一篇文章教你学会Hibernate
2014-06-23 10:34
531 查看
Hibernate实例入门
导入antlr-2.7.6.jar
导入commons-collections-3.1.jar
导入dom4j-1.6.1.jar
导入hibernate-jpa-2.0-api-1.0.1.Final.jar
导入hibernate3.jar
导入javassist-3.12.0.GA.jar
导入jta-1.1.jar
导入mysql-connector-java-3.1.13-bin.jar
导入slf4j-api-1.6.1.jar
这一部分没有过多的解释，只需要大家了解每个jar文件包的作用即可。
[java] view
plaincopy
package com.entity;
import java.util.Date;
public class User {
private String id;
private String name;
private String password;
private Date createTime;
private Date expireTime;
public String getId() {
return id;
}
public void setId(String 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 Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getExpireTime() {
return expireTime;
}
public void setExpireTime(Date expireTime) {
this.expireTime = expireTime;
}
}
创建数据库
创建表
显示表结构
这一步就是一个创建数据库的过程，与我们平常做项目使用的数据库结构和过程也没有区别。
[html] view
plaincopy
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.entity.User">
<id name="id">
<generator class="uuid"/>
</id>
<property name="name"/>
<property name="password"/>
<property name="createTime"/>
<property name="expireTime"/>
</class>
</hibernate-mapping>
User.hbm.xml的作用简而言之就是对实体和数据库中的表进行相呼应，保证我们对实体对象进行的操作都会在数据库中产生与之对应响应的结果。但仅这样的配置还有一个问题那就是我们如何将能够将数据库中的表与对象进行关联。这就需要接下来的配置了。
[html] view
plaincopy
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>
<mapping resource="com/entity/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
这里的重点区别在于，通过映射说明<mapping resource="com/entity/User.hbm.xml"/>我们可以将数据库连接和映射进行联系，也就是说通过 hibernate.cfg.xml的配置，我们就可以找到具体的实体和数据库表对应关系。
[java] view
plaincopy
package test;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.entity.User;
public class Client {
public static void main(String[] args) {
//读取hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
//建立SessionFactory
SessionFactory factory = cfg.buildSessionFactory();
//取得session
Session session = null;
try {
session = factory.openSession();
//开启事务
session.beginTransaction();
User user = new User();
user.setName("NAME1");
user.setPassword("PWD1");
user.setCreateTime(new Date());
user.setExpireTime(new Date());
//保存User对象
session.save(user);
//提交事务
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
//回滚事务
session.getTransaction().rollback();
}finally {
if (session != null) {
if (session.isOpen()) {
//关闭session
session.close();
}
}
}
}
}
程序执行结果如下：
我们向数据库中添加一个对象只需要通过HibernateAPI中最核心的Session接口，调用save()方法即可，不需要我们在代码中编写SQL语句，也不需要程序员对SQL语言过多的了解，这就体现了Hibernate完全面向对象编程。
2、创建持久化类，即其实例需要保存到数据库中的类
3、创建对象-关系映射文件
4、通过Hibernate API编写访问数据库的代码
[plain] view
plaincopy
#指定数据库使用的驱动类
hibernate.connection.driver_class = com.mysql.jdbc.Driver
#指定数据库连接串
hibernate.connection.url = jdbc:mysql://localhost:3306/hibernate_first
#指定数据库连接的用户名
hibernate.connection.username = user
#指定数据库连接的密码
hibernate.connection.password = password
#指定数据库使用的方言
hibernate.dialect = org.hibernate.dialect.MySQLDialect
#指定是否打印SQL语句
hibernate.show_sql=true
[html] view
plaincopy
＜?xml version='1.0' encoding='UTF-8'?＞
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
＜!--数据库驱动--＞
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
＜!--连接字符串--＞
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>
＜!--连接数据库的用户名--＞
<property name="hibernate.connection.username">user</property>
＜!--数据库用户密码--＞
<property name="hibernate.connection.password">root</property>
＜!--选择使用的方言--＞
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
＜!--显示执行的SQL语句--＞
<property name="hibernate.show_sql">true</property>
＜!--映射文件 --＞
<mapping resource="com/zs/hibernate/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
properties形式的配置文件和XML格式的配置文件可以同时使用。当同时使用两种类型的配置文件时，XML配置文件中的设置会覆盖properties配置文件的相同的属性。
两种配置文件的主要区别就是XML可以配置映射。这里提到的映射即对象关系映射(Object Relational Mapping)。ORM的实现目的就是将对象数据保存到数据库中，同时可以将数据库数据读入对象中，这样开发人员就可以将对数据库数据的操作转化为对这些对象的操作。
经过转换之后，可以创建相应的对象，代码如下:
[java] view
plaincopy
public class User{
private String id;
private String name;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
对于Hibernate来讲，仅仅是有上面的还是不够的，还需要一个XML格式的映射文件User.hbm.xml，代码如下:
[html] view
plaincopy
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.zs.hibernate">
<class name="User1" table="t_user1">
<id name="id" column="user_id" length="32" access="field">
<generator class="uuid"/>
</id>
<property name="name" length="30" unique="true" not-null="true"/>
</class>
</hibernate-mapping>
[java] view
plaincopy
@Entity
@Table(name="t_user")
public class User{
@Id
private String id;
@GeneratedValue
private String name;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
一对一单向关联
一对一双向关联
一对多单向关联
多对一单向关联
一对多双向关联
多对多单向关联
多对多双向关联
接下来博客，我们会分别讲解一下这七种关系映射。今天我们只讲其中的一对一单向关联。
类结构图如下所示：
具体代码如下所示：
[java] view
plaincopy
public class Person {
private int id;
private String name;
private IdCard idCard;
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 IdCard getIdCard() {
return idCard;
}
public void setIdCard(IdCard idCard) {
this.idCard = idCard;
}
}
public class IdCard {
private int id;
private String cardNo;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getCardNo() {
return cardNo;
}
public void setCardNo(String cardNo) {
this.cardNo = cardNo;
}
}
上述类结构的相应根据关联的策略不同会生成不同的表结构，可以分为主键关联和唯一外键关联。
可以看出，主键关联即利用主键进行关联，关联主键的值相同。其相应的*.hbm.xml配置文件代码如下:
[html] view
plaincopy
<class name="com.zs.hibernate.IdCard" table="t_idCard">
<id name="id">
<generator class="native"/>
</id>
<property name="cardNo"/>
</class>
<class name="com.zs.hibernate.Person" table="t_person">
<id name="id">
<generator class="foreign">
<param name="property">idCard</param>
</generator>
</id>
<property name="name"/>
<one-to-one name="idCard" constrained="true"/>
</class>
与主键关联所不同，唯一外键关联除主键外，在其一对一的指向端(Person)存在一个唯一外键，该唯一外键与被指向端(IdCard)相关联，关联主键的值相同。其相应的*.hbm.xml配置文件代码如下:
[html] view
plaincopy
<class name="com.zs.hibernate.IdCard" table="t_idCard">
<id name="id">
<generator class="native"/>
</id>
<property name="cardNo"/>
</class>
<class name="com.zs.hibernate.Person" table="t_person">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="idCard" unique="true"/>
</class>
类结构图如下所示:
具体代码如下所示:
[java] view
plaincopy
public class Person {
private int id;
private String name;
private IdCard idCard;
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 IdCard getIdCard() {
return idCard;
}
public void setIdCard(IdCard idCard) {
this.idCard = idCard;
}
}
public class IdCard {
private int id;
private String cardNo;
private Person person;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getCardNo() {
return cardNo;
}
public void setCardNo(String cardNo) {
this.cardNo = cardNo;
}
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
}
与一对一单向关联映射相同，一对一双向关联映射同样关联的策略不同会生成不同的表结构，也可以分为主键关联和唯一外键关联。但与一对一单向关联映射相同的是生成的表结构，即一对一双向关联映射与一对一单向关联相比，只是改变了一对一关联映射的加载，并没有改变存储。
同一对一单向关联映射类似，主键关联即利用主键进行关联，关联主键的值相同。其相应的*.hbm.xml配置文件代码如下:
[html] view
plaincopy
<class name="com.zs.hibernate.IdCard" table="t_idCard">
<id name="id">
<generator class="native"/>
</id>
<property name="cardNo"/>
<one-to-one name="person"/>
</class>
<class name="com.zs.hibernate.Person" table="t_person">
<id name="id">
<generator class="foreign">
<param name="property">idCard</param>
</generator>
</id>
<property name="name"/>
<one-to-one name="idCard" constrained="true"/>
</class>
一对一双向关联映射的外键关联映射也与一对一单向关联映射的外键关联映射类似，在其一对一的指向端(Person)存在一个唯一外键，该唯一外键与被指向端(IdCard)相关联，关联主键的值相同。其相应的*.hbm.xml配置文件代码如下:
[html] view
plaincopy
<class name="com.zs.hibernate.IdCard" table="t_idCard">
<id name="id">
<generator class="native"/>
</id>
<property name="cardNo"/>
<one-to-one name="person" property-ref="idCard"/>
</class>
<class name="com.zs.hibernate.Person" table="t_person">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="idCard" unique="true"/>
</class>
同样利用在类文件中注解的方式也可以取代XML配置映射。
[java] view
plaincopy
public class Group {
private int id;
private String name;
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 class User {
private int id;
private String name;
private Group group;
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 Group getGroup() {
return group;
}
public void setGroup(Group group) {
this.group = group;
}
}
通过分析上述代码和类图结构，单纯的看两者区别不大。但是通过映射表结构的对比，两者的不同之处在于指向端一个与被指向端的关系，一对一单向关联是一对一关系，而多对一单向关联则是多对一关系。(以下只给出多对一相关图示和代码，一对一图示和代码参考之前的文章Hibernate从入门到精通（五）一对一单向关联映射)
通过上说说明，我们也可以简单说一对一单向关联其实是多对一单向关联的一种特殊情况，这一点从其Hibernate映射配置中可以更加明显看出。
plaincopy
<class name="com.zs.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="group" column="groupid" cascade="save-update"/>
</class>
<class name="com.zs.hibernate.Group" table="t_group">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
</class>
plaincopy
<class name="com.zs.hibernate.Person" table="t_person">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="idCard" unique="true"/>
</class>
<class name="com.zs.hibernate.IdCard" table="t_idCard">
<id name="id">
<generator class="native"/>
</id>
<property name="cardNo"/>
</class>
我们从上面可以明显看出一对一只是在<many-to-one/> 标签中添加了unique="true"这样一个限制指向端的属性而已。
[java] view
plaincopy
public class Classes {
private int id;
private String name;
private Set students;
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 Set getStudents() {
return students;
}
public void setStudents(Set students) {
this.students = students;
}
}
public class Student {
private int id;
private String name;
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;
}
}
对比一对多关联映射和我们之前讲的多对一关联映射，可以发现两种映射原理是一致的，都是在多的一端加入一个外键，指向一的一端。它们的区别在于维护的关系不同，多对一维护的是多指向一的关系，有了此关系，在加载多的时候可以将一加载上来，一对多维护的是一指向多的关系，有了此关系，在加载一的时候可以将多加载上来。
为了更好说明上述的结论，我们再看一下一对多关联映射的表结构和相应的Hibernate映射配置。具体如下:
[html] view
plaincopy
<class name="com.zs.hibernate.Classes" table="t_classes">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="students">
<key column="classesid"/>
<one-to-many class="com.zs.hibernate.Student"/>
</set>
</class>
<class name="com.zs.hibernate.Student" table="t_student">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
</class>
通过上面表中数据和我们之前关于多对一(参考Hibernate从入门到精通（七）多对一单向关联映射)的对比，我们就可以清晰的看出，在一对多中，仅仅添加了一个<set/>标签，将多对一中的一改为多而已，如果将集合看成一个整体，则两者实际上就没有区别了。
[java] view
plaincopy
public class Classes {
private int id;
private String name;
private Set students;
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 Set getStudents() {
return students;
}
public void setStudents(Set students) {
this.students = students;
}
}
public class Student {
private int id;
private String name;
private Classes classes;
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 Classes getClasses() {
return classes;
}
public void setClasses(Classes classes) {
this.classes = classes;
}
}
通过对比之前我们在上篇博文Hibernate从入门到精通（八）一对多单向关联映射中的关于一对多单向关联映射的相应的类结构图和代码。可以发现，一对多双向关联向和单向关联的区别主要是在多的一端加入了一的一端的对象，这就将单向关联变成了双向关联。
为了更好说明两者的区别，我们再看一下一对多双向关联映射的表结构和相应的Hibernate映射配置。具体如下:
[html] view
plaincopy
<class name="com.zs.hibernate.Classes" table="t_classes">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="students" inverse="true">
<key column="classesid"/>
<one-to-many class="com.zs.hibernate.Student"/>
</set>
</class>
<class name="com.zs.hibernate.Student" table="t_student">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="classes" column="classesid"/>
</class>
从存储结构上看，一对多单向关联和双向关联没有什么区别，但是从配置文件上看，一对多双向关联的配置文件中在多的一端的配置文件上存在<many-to-one />的相关配置，即保证多对一的映射，这就保证了双向。
通过本次的讲解，关于一对多双向关联的内容，我们就讲解完毕了，一对多映射是一个比较常用和重要的映射关系，
[java] view
plaincopy
public class Role {
private int id;
private String name;
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 class User {
private int id;
private String name;
private Set roles;
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 Set getRoles() {
return roles;
}
public void setRoles(Set roles) {
this.roles = roles;
}
}
接下来我们再从存储结构上分析两者的区别和联系。具体如下：
通过上述表结构明显可以看出，在多对多关联映射中，存在第三张表，用以维护关联关系两端对象的对应关系，而这在一对多中则是不存在的。为什么会这样呢？这是因为配置文件的配置不同所导致的这样的映射结果。具体如下：
[html] view
plaincopy
<class name="com.zs.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="roles" table="t_user_role">
<key column="user_id"/>
<many-to-many class="com.zs.hibernate.Role" column="role_id" />
</set>
</class>
<class name="com.zs.hibernate.Role" table="t_role">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
</class>
通过对比上篇文章Hibernate从入门到精通（八）一对多单向关联映射中映射文件可以看出在一对多单向关联中映射配置的属性为<one-to-many/>，而多对多关联映射中配置的属性为<many-to-many/>，这就导致了映射的两种不同结果和两种不同的解决方案。
[java] view
plaincopy
public class Role {
private int id;
private String name;
private Set users;
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 Set getUsers() {
return users;
}
public void setUsers(Set users) {
this.users = users;
}
}
public class User {
private int id;
private String name;
private Set roles;
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 Set getRoles() {
return roles;
}
public void setRoles(Set roles) {
this.roles = roles;
}
}
接下来我们对比之前的博文Hibernate从入门到精通（十）多对多单向关联映射中的多对多单向关联映射，来具体分析一下多对多双向关联映射，重点体会两者的区别和联系。
接下来我们从存储结构上看两者的区别，具体如下：
从上图可以看出，多对多单向与双向的存储结构没有任何区别。接下来我们再来看一下配置信息。具体如下：
[html] view
plaincopy
<class name="com.zs.hibernate.Role" table="t_role">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="users" table="t_user_role">
<key column="role_id" not-null="true"/>
<many-to-many class="com.zs.hibernate.User" column="user_id"/>
</set>
</class>
<class name="com.zs.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="roles" table="t_user_role">
<key column="user_id" not-null="true"/>
<many-to-many class="com.zs.hibernate.Role" column="role_id" />
</set>
</class>
对比我们之前的博文Hibernate从入门到精通（十）多对多单向关联映射中的多对多单向映射的配置信息，我们可以看出在单向映射中，只能A->B,不能B->A，所以A与B的关系是不等的。而在双向关联映射中，既能A->B,也能B->A，所以A与B的关系是等价的。这样也就造成了在双向关联映射的配置文件的两个类的配置信息基本相同，即A=B。
导入commons-collections-3.1.jar
导入dom4j-1.6.1.jar
导入hibernate-jpa-2.0-api-1.0.1.Final.jar
导入hibernate3.jar
导入javassist-3.12.0.GA.jar
导入jta-1.1.jar
导入mysql-connector-java-3.1.13-bin.jar
导入slf4j-api-1.6.1.jar
这一部分没有过多的解释，只需要大家了解每个jar文件包的作用即可。
plaincopy
package com.entity;
import java.util.Date;
public class User {
private String id;
private String name;
private String password;
private Date createTime;
private Date expireTime;
public String getId() {
return id;
}
public void setId(String 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 Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getExpireTime() {
return expireTime;
}
public void setExpireTime(Date expireTime) {
this.expireTime = expireTime;
}
}
这一步与普通的JDBC没有太大的区别，在JDBC中我们也可以通过实体封装需要的信息，如果你对面向对象编程有一定的了解相信不难理解。
创建表
显示表结构
这一步就是一个创建数据库的过程，与我们平常做项目使用的数据库结构和过程也没有区别。
plaincopy
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.entity.User">
<id name="id">
<generator class="uuid"/>
</id>
<property name="name"/>
<property name="password"/>
<property name="createTime"/>
<property name="expireTime"/>
</class>
</hibernate-mapping>
从这一步开始，JDBC开始与Hibernate有一定的区别，这里我们重点讲一下User.hbm.xml的作用。User.hbm.xml的作用简而言之就是对实体和数据库中的表进行相呼应，保证我们对实体对象进行的操作都会在数据库中产生与之对应响应的结果。但仅这样的配置还有一个问题那就是我们如何将能够将数据库中的表与对象进行关联。这就需要接下来的配置了。
plaincopy
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>
<mapping resource="com/entity/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
这里的重点区别在于，通过映射说明<mapping resource="com/entity/User.hbm.xml"/>我们可以将数据库连接和映射进行联系，也就是说通过 hibernate.cfg.xml的配置，我们就可以找到具体的实体和数据库表对应关系。到此为止我们所有的配置就进行完毕了，接下来做一个测试。
plaincopy
package test;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.entity.User;
public class Client {
public static void main(String[] args) {
//读取hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
//建立SessionFactory
SessionFactory factory = cfg.buildSessionFactory();
//取得session
Session session = null;
try {
session = factory.openSession();
//开启事务
session.beginTransaction();
User user = new User();
user.setName("NAME1");
user.setPassword("PWD1");
user.setCreateTime(new Date());
user.setExpireTime(new Date());
//保存User对象
session.save(user);
//提交事务
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
//回滚事务
session.getTransaction().rollback();
}finally {
if (session != null) {
if (session.isOpen()) {
//关闭session
session.close();
}
}
}
}
}
程序执行结果如下：
通过上述实例的演示，对比上一篇Hibernate从入门到精通（一）JDBC简介文章中我们提到的JDBC操作的缺陷可以看出，我们向数据库中添加一个对象只需要通过HibernateAPI中最核心的Session接口，调用save()方法即可，不需要我们在代码中编写SQL语句，也不需要程序员对SQL语言过多的了解，这就体现了Hibernate完全面向对象编程。
1、导入jar文件
导入antlr-2.7.6.jar导入commons-collections-3.1.jar
导入dom4j-1.6.1.jar
导入hibernate-jpa-2.0-api-1.0.1.Final.jar
导入hibernate3.jar
导入javassist-3.12.0.GA.jar
导入jta-1.1.jar
导入mysql-connector-java-3.1.13-bin.jar
导入slf4j-api-1.6.1.jar
这一部分没有过多的解释，只需要大家了解每个jar文件包的作用即可。
2、编辑实体
[java] viewplaincopy
package com.entity;
import java.util.Date;
public class User {
private String id;
private String name;
private String password;
private Date createTime;
private Date expireTime;
public String getId() {
return id;
}
public void setId(String 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 Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getExpireTime() {
return expireTime;
}
public void setExpireTime(Date expireTime) {
this.expireTime = expireTime;
}
}
3、创建数据库、表
创建数据库创建表
显示表结构
这一步就是一个创建数据库的过程，与我们平常做项目使用的数据库结构和过程也没有区别。
4、创建实体映射文件User.hbm.xml
[html] viewplaincopy
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.entity.User">
<id name="id">
<generator class="uuid"/>
</id>
<property name="name"/>
<property name="password"/>
<property name="createTime"/>
<property name="expireTime"/>
</class>
</hibernate-mapping>
User.hbm.xml的作用简而言之就是对实体和数据库中的表进行相呼应，保证我们对实体对象进行的操作都会在数据库中产生与之对应响应的结果。但仅这样的配置还有一个问题那就是我们如何将能够将数据库中的表与对象进行关联。这就需要接下来的配置了。
5、创建数据库连接和映射配置文件 hibernate.cfg.xml
[html] viewplaincopy
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>
<mapping resource="com/entity/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
这里的重点区别在于，通过映射说明<mapping resource="com/entity/User.hbm.xml"/>我们可以将数据库连接和映射进行联系，也就是说通过 hibernate.cfg.xml的配置，我们就可以找到具体的实体和数据库表对应关系。
6、创建测试文件 Client.java
[java] viewplaincopy
package test;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.entity.User;
public class Client {
public static void main(String[] args) {
//读取hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
//建立SessionFactory
SessionFactory factory = cfg.buildSessionFactory();
//取得session
Session session = null;
try {
session = factory.openSession();
//开启事务
session.beginTransaction();
User user = new User();
user.setName("NAME1");
user.setPassword("PWD1");
user.setCreateTime(new Date());
user.setExpireTime(new Date());
//保存User对象
session.save(user);
//提交事务
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
//回滚事务
session.getTransaction().rollback();
}finally {
if (session != null) {
if (session.isOpen()) {
//关闭session
session.close();
}
}
}
}
}
程序执行结果如下：
我们向数据库中添加一个对象只需要通过HibernateAPI中最核心的Session接口，调用save()方法即可，不需要我们在代码中编写SQL语句，也不需要程序员对SQL语言过多的了解，这就体现了Hibernate完全面向对象编程。
Hibernate框架的使用步骤：
1、创建Hibernate的配置文件2、创建持久化类，即其实例需要保存到数据库中的类
3、创建对象-关系映射文件
4、通过Hibernate API编写访问数据库的代码
Hibernate配置文件
本此博文，我们重点讲解一下Hibernate的配置文件。Hibernate配置文件从形式来讲有两种主要的格式:一种是Java属性文件，即*.properties，这种配置格式主要定义连接各种数据库需要的参数；还有一种是XML格式的文件，这种文档除了可以定义连接各种数据库需要的参数，还可以定义程序中用的映射文件。所以一般情况下使用XML格式的配置文档。properties形式的配置文件
properties形式的配置文件默认文件名是hibernate.properties，一个properties形式的配置文件内容如下所示：[plain] view
plaincopy
#指定数据库使用的驱动类
hibernate.connection.driver_class = com.mysql.jdbc.Driver
#指定数据库连接串
hibernate.connection.url = jdbc:mysql://localhost:3306/hibernate_first
#指定数据库连接的用户名
hibernate.connection.username = user
#指定数据库连接的密码
hibernate.connection.password = password
#指定数据库使用的方言
hibernate.dialect = org.hibernate.dialect.MySQLDialect
#指定是否打印SQL语句
hibernate.show_sql=true
XML格式的配置文件
XML格式的配置文件的默认文件名为hibernate.cfg.xml，一个XML配置文件的示例如下所示：[html] view
plaincopy
＜?xml version='1.0' encoding='UTF-8'?＞
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
＜!--数据库驱动--＞
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
＜!--连接字符串--＞
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>
＜!--连接数据库的用户名--＞
<property name="hibernate.connection.username">user</property>
＜!--数据库用户密码--＞
<property name="hibernate.connection.password">root</property>
＜!--选择使用的方言--＞
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
＜!--显示执行的SQL语句--＞
<property name="hibernate.show_sql">true</property>
＜!--映射文件 --＞
<mapping resource="com/zs/hibernate/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
properties形式的配置文件和XML格式的配置文件可以同时使用。当同时使用两种类型的配置文件时，XML配置文件中的设置会覆盖properties配置文件的相同的属性。
两种配置文件的主要区别就是XML可以配置映射。这里提到的映射即对象关系映射(Object Relational Mapping)。ORM的实现目的就是将对象数据保存到数据库中，同时可以将数据库数据读入对象中，这样开发人员就可以将对数据库数据的操作转化为对这些对象的操作。
基本映射
了解了映射的意义和概念之后，我们来讲解一下映射的分类。从映射的概念来看，单个的数据库表可以映射成为一个对象，抛开Hibernate不谈，这种思路在很多项目开发中时常见的，即根据表结构创建相应实体类，这种简单的映射关系在Hibernate映射中被称为基本映射。基本映射实例
如下图所示的表结构：经过转换之后，可以创建相应的对象，代码如下:
[java] view
plaincopy
public class User{
private String id;
private String name;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
对于Hibernate来讲，仅仅是有上面的还是不够的，还需要一个XML格式的映射文件User.hbm.xml，代码如下:
[html] view
plaincopy
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.zs.hibernate">
<class name="User1" table="t_user1">
<id name="id" column="user_id" length="32" access="field">
<generator class="uuid"/>
</id>
<property name="name" length="30" unique="true" not-null="true"/>
</class>
</hibernate-mapping>
注解配置基本映射实例
除了上述XML方式配置映射外，还可以通过给类文件添加注解的方式配置映射，具体代码如下:[java] view
plaincopy
@Entity
@Table(name="t_user")
public class User{
@Id
private String id;
@GeneratedValue
private String name;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
关系映射分类
关系映射即在基本映射的基础上处理多个相关对象和多个相关表之间联系的映射。关系映射从对应关系的角度可以分为如下七种类型：一对一单向关联
一对一双向关联
一对多单向关联
多对一单向关联
一对多双向关联
多对多单向关联
多对多双向关联
接下来博客，我们会分别讲解一下这七种关系映射。今天我们只讲其中的一对一单向关联。
一对一单向关联
一对一单向关联从对象的角度分析，即在一个对象(Person)中存在另一个对象(IdCard)的引用，而在另一个对象(IdCard)中则不存在该对象(Person)的引用，这样就可以在加载该对象(Person)的时候找到另一个对象(IdCard)。类结构图如下所示：
具体代码如下所示：
[java] view
plaincopy
public class Person {
private int id;
private String name;
private IdCard idCard;
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 IdCard getIdCard() {
return idCard;
}
public void setIdCard(IdCard idCard) {
this.idCard = idCard;
}
}
public class IdCard {
private int id;
private String cardNo;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getCardNo() {
return cardNo;
}
public void setCardNo(String cardNo) {
this.cardNo = cardNo;
}
}
上述类结构的相应根据关联的策略不同会生成不同的表结构，可以分为主键关联和唯一外键关联。
主键关联
主键关联表结构如下:可以看出，主键关联即利用主键进行关联，关联主键的值相同。其相应的*.hbm.xml配置文件代码如下:
[html] view
plaincopy
<class name="com.zs.hibernate.IdCard" table="t_idCard">
<id name="id">
<generator class="native"/>
</id>
<property name="cardNo"/>
</class>
<class name="com.zs.hibernate.Person" table="t_person">
<id name="id">
<generator class="foreign">
<param name="property">idCard</param>
</generator>
</id>
<property name="name"/>
<one-to-one name="idCard" constrained="true"/>
</class>
唯一外键关联
唯一外键关联表结构如下:与主键关联所不同，唯一外键关联除主键外，在其一对一的指向端(Person)存在一个唯一外键，该唯一外键与被指向端(IdCard)相关联，关联主键的值相同。其相应的*.hbm.xml配置文件代码如下:
[html] view
plaincopy
<class name="com.zs.hibernate.IdCard" table="t_idCard">
<id name="id">
<generator class="native"/>
</id>
<property name="cardNo"/>
</class>
<class name="com.zs.hibernate.Person" table="t_person">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="idCard" unique="true"/>
</class>
一对一双向关联
与一对一单向关联映射所不同的的是在一对一双向关联中，不但在一个对象(Person)中存在另一个对象(IdCard)的引用，而在另一个对象(IdCard)中也存在对该对象(Person)的引用，这样即可以在加载该对象(Person)的时候找到另一个对象(IdCard)，也可以在加载另一个对象(IdCard)的时候找到该对象(Person)。类结构图如下所示:
具体代码如下所示:
[java] view
plaincopy
public class Person {
private int id;
private String name;
private IdCard idCard;
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 IdCard getIdCard() {
return idCard;
}
public void setIdCard(IdCard idCard) {
this.idCard = idCard;
}
}
public class IdCard {
private int id;
private String cardNo;
private Person person;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getCardNo() {
return cardNo;
}
public void setCardNo(String cardNo) {
this.cardNo = cardNo;
}
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
}
与一对一单向关联映射相同，一对一双向关联映射同样关联的策略不同会生成不同的表结构，也可以分为主键关联和唯一外键关联。但与一对一单向关联映射相同的是生成的表结构，即一对一双向关联映射与一对一单向关联相比，只是改变了一对一关联映射的加载，并没有改变存储。
主键关联
主键关联表结构如下:同一对一单向关联映射类似，主键关联即利用主键进行关联，关联主键的值相同。其相应的*.hbm.xml配置文件代码如下:
[html] view
plaincopy
<class name="com.zs.hibernate.IdCard" table="t_idCard">
<id name="id">
<generator class="native"/>
</id>
<property name="cardNo"/>
<one-to-one name="person"/>
</class>
<class name="com.zs.hibernate.Person" table="t_person">
<id name="id">
<generator class="foreign">
<param name="property">idCard</param>
</generator>
</id>
<property name="name"/>
<one-to-one name="idCard" constrained="true"/>
</class>
唯一外键关联
唯一外键关联表结构如下:一对一双向关联映射的外键关联映射也与一对一单向关联映射的外键关联映射类似，在其一对一的指向端(Person)存在一个唯一外键，该唯一外键与被指向端(IdCard)相关联，关联主键的值相同。其相应的*.hbm.xml配置文件代码如下:
[html] view
plaincopy
<class name="com.zs.hibernate.IdCard" table="t_idCard">
<id name="id">
<generator class="native"/>
</id>
<property name="cardNo"/>
<one-to-one name="person" property-ref="idCard"/>
</class>
<class name="com.zs.hibernate.Person" table="t_person">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="idCard" unique="true"/>
</class>
同样利用在类文件中注解的方式也可以取代XML配置映射。
多对一单向关联映射
多对一关联映射与一对一关联映射类似，只是在多对一的指向端可以存在多个对象，在指向端加载的时候，同时加载被指向端。多对一和一对一的异同
对比一对一单向关联映射和多对一单向关联映射，两者的相同之处在于在指向端被加载的时候，被指向端会被一起加载进来，这一点从如下类的结构图和代码中看出。(以下只给出多对一相关图示和代码，一对一图示和代码参考之前的文章Hibernate从入门到精通（五）一对一单向关联映射)[java] view
plaincopy
public class Group {
private int id;
private String name;
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 class User {
private int id;
private String name;
private Group group;
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 Group getGroup() {
return group;
}
public void setGroup(Group group) {
this.group = group;
}
}
通过分析上述代码和类图结构，单纯的看两者区别不大。但是通过映射表结构的对比，两者的不同之处在于指向端一个与被指向端的关系，一对一单向关联是一对一关系，而多对一单向关联则是多对一关系。(以下只给出多对一相关图示和代码，一对一图示和代码参考之前的文章Hibernate从入门到精通（五）一对一单向关联映射)
通过上说说明，我们也可以简单说一对一单向关联其实是多对一单向关联的一种特殊情况，这一点从其Hibernate映射配置中可以更加明显看出。
多对一映射配置:
[html] viewplaincopy
<class name="com.zs.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="group" column="groupid" cascade="save-update"/>
</class>
<class name="com.zs.hibernate.Group" table="t_group">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
</class>
一对一映射配置：
[html] viewplaincopy
<class name="com.zs.hibernate.Person" table="t_person">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="idCard" unique="true"/>
</class>
<class name="com.zs.hibernate.IdCard" table="t_idCard">
<id name="id">
<generator class="native"/>
</id>
<property name="cardNo"/>
</class>
我们从上面可以明显看出一对一只是在<many-to-one/> 标签中添加了unique="true"这样一个限制指向端的属性而已。
一对多单向关联映射
在讲解一对多单向关联之前，按照我们的惯例首先看一下其相应的类结构图和代码。具体如下:[java] view
plaincopy
public class Classes {
private int id;
private String name;
private Set students;
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 Set getStudents() {
return students;
}
public void setStudents(Set students) {
this.students = students;
}
}
public class Student {
private int id;
private String name;
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;
}
}
对比一对多关联映射和我们之前讲的多对一关联映射，可以发现两种映射原理是一致的，都是在多的一端加入一个外键，指向一的一端。它们的区别在于维护的关系不同，多对一维护的是多指向一的关系，有了此关系，在加载多的时候可以将一加载上来，一对多维护的是一指向多的关系，有了此关系，在加载一的时候可以将多加载上来。
为了更好说明上述的结论，我们再看一下一对多关联映射的表结构和相应的Hibernate映射配置。具体如下:
[html] view
plaincopy
<class name="com.zs.hibernate.Classes" table="t_classes">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="students">
<key column="classesid"/>
<one-to-many class="com.zs.hibernate.Student"/>
</set>
</class>
<class name="com.zs.hibernate.Student" table="t_student">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
</class>
通过上面表中数据和我们之前关于多对一(参考Hibernate从入门到精通（七）多对一单向关联映射)的对比，我们就可以清晰的看出，在一对多中，仅仅添加了一个<set/>标签，将多对一中的一改为多而已，如果将集合看成一个整体，则两者实际上就没有区别了。
一对多单向关联映射缺陷
到此为止，关于一对多单向关联基本，但是细心的读者可能发现了在一对多中的一的一端维护关系是有缺陷的。例如:在保存Student的时候关系字段classesid为null，则将无法保存数据等等。这些问题如何解决，这就需要引出我们下次讲解的一对多双向关联映射了。一对多双向关联映射
一对多双向关联映射，即在一的一端存在多的一端的一个集合对象，在多的一端存在一的一端的一个对象，这样就可以保证在加载一的一端或多的一端将被指向端的集合或对象加载上来，即保证双向关联。一对多双向关联映射和一对多单向关联映射的异同
一对多双向关联映射相应的类结构图和代码。具体如下:[java] view
plaincopy
public class Classes {
private int id;
private String name;
private Set students;
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 Set getStudents() {
return students;
}
public void setStudents(Set students) {
this.students = students;
}
}
public class Student {
private int id;
private String name;
private Classes classes;
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 Classes getClasses() {
return classes;
}
public void setClasses(Classes classes) {
this.classes = classes;
}
}
通过对比之前我们在上篇博文Hibernate从入门到精通（八）一对多单向关联映射中的关于一对多单向关联映射的相应的类结构图和代码。可以发现，一对多双向关联向和单向关联的区别主要是在多的一端加入了一的一端的对象，这就将单向关联变成了双向关联。
为了更好说明两者的区别，我们再看一下一对多双向关联映射的表结构和相应的Hibernate映射配置。具体如下:
[html] view
plaincopy
<class name="com.zs.hibernate.Classes" table="t_classes">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="students" inverse="true">
<key column="classesid"/>
<one-to-many class="com.zs.hibernate.Student"/>
</set>
</class>
<class name="com.zs.hibernate.Student" table="t_student">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="classes" column="classesid"/>
</class>
从存储结构上看，一对多单向关联和双向关联没有什么区别，但是从配置文件上看，一对多双向关联的配置文件中在多的一端的配置文件上存在<many-to-one />的相关配置，即保证多对一的映射，这就保证了双向。
通过本次的讲解，关于一对多双向关联的内容，我们就讲解完毕了，一对多映射是一个比较常用和重要的映射关系，
多对多单向关联映射
在讲解多对多单向关联映射之前，首先看一下相关类图和代码，具体如下：[java] view
plaincopy
public class Role {
private int id;
private String name;
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 class User {
private int id;
private String name;
private Set roles;
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 Set getRoles() {
return roles;
}
public void setRoles(Set roles) {
this.roles = roles;
}
}
多对多单向关联和一对多单向关联的异同
多对多单向关联映射与一对多单向关联映射类似，都是在指向端被加载时，将被指向段加载上来，即单向的约束，所不同的是将一对多中一的一端从一变成了多而已，这点可以从类图上明显看出。但从代码上看一对多和多对多的区别则很难看出两者的区别。(参考Hibernate从入门到精通（八）一对多单向关联映射)接下来我们再从存储结构上分析两者的区别和联系。具体如下：
通过上述表结构明显可以看出，在多对多关联映射中，存在第三张表，用以维护关联关系两端对象的对应关系，而这在一对多中则是不存在的。为什么会这样呢？这是因为配置文件的配置不同所导致的这样的映射结果。具体如下：
[html] view
plaincopy
<class name="com.zs.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="roles" table="t_user_role">
<key column="user_id"/>
<many-to-many class="com.zs.hibernate.Role" column="role_id" />
</set>
</class>
<class name="com.zs.hibernate.Role" table="t_role">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
</class>
通过对比上篇文章Hibernate从入门到精通（八）一对多单向关联映射中映射文件可以看出在一对多单向关联中映射配置的属性为<one-to-many/>，而多对多关联映射中配置的属性为<many-to-many/>，这就导致了映射的两种不同结果和两种不同的解决方案。
多对多双向关联映射
按照我们之前的惯例，先看一下相关类图和代码，具体如下：[java] view
plaincopy
public class Role {
private int id;
private String name;
private Set users;
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 Set getUsers() {
return users;
}
public void setUsers(Set users) {
this.users = users;
}
}
public class User {
private int id;
private String name;
private Set roles;
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 Set getRoles() {
return roles;
}
public void setRoles(Set roles) {
this.roles = roles;
}
}
接下来我们对比之前的博文Hibernate从入门到精通（十）多对多单向关联映射中的多对多单向关联映射，来具体分析一下多对多双向关联映射，重点体会两者的区别和联系。
多对多双向与多对多单向关联映射的异同
分析我们上述的类图和代码我们可以看出：单独看多对多双向关联的一端，多对多双向与多对多单向关联没有根本区别。只是在多对多的两端各有一个集合(Set),它用来存储与之相关的多个对象。(参考Hibernate从入门到精通（十）多对多单向关联映射)接下来我们从存储结构上看两者的区别，具体如下：
从上图可以看出，多对多单向与双向的存储结构没有任何区别。接下来我们再来看一下配置信息。具体如下：
[html] view
plaincopy
<class name="com.zs.hibernate.Role" table="t_role">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="users" table="t_user_role">
<key column="role_id" not-null="true"/>
<many-to-many class="com.zs.hibernate.User" column="user_id"/>
</set>
</class>
<class name="com.zs.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="roles" table="t_user_role">
<key column="user_id" not-null="true"/>
<many-to-many class="com.zs.hibernate.Role" column="role_id" />
</set>
</class>
对比我们之前的博文Hibernate从入门到精通（十）多对多单向关联映射中的多对多单向映射的配置信息，我们可以看出在单向映射中，只能A->B,不能B->A，所以A与B的关系是不等的。而在双向关联映射中，既能A->B,也能B->A，所以A与B的关系是等价的。这样也就造成了在双向关联映射的配置文件的两个类的配置信息基本相同，即A=B。
1、导入jar文件
导入antlr-2.7.6.jar导入commons-collections-3.1.jar
导入dom4j-1.6.1.jar
导入hibernate-jpa-2.0-api-1.0.1.Final.jar
导入hibernate3.jar
导入javassist-3.12.0.GA.jar
导入jta-1.1.jar
导入mysql-connector-java-3.1.13-bin.jar
导入slf4j-api-1.6.1.jar
这一部分没有过多的解释，只需要大家了解每个jar文件包的作用即可。
2、编辑实体
[java] viewplaincopy
package com.entity;
import java.util.Date;
public class User {
private String id;
private String name;
private String password;
private Date createTime;
private Date expireTime;
public String getId() {
return id;
}
public void setId(String 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 Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getExpireTime() {
return expireTime;
}
public void setExpireTime(Date expireTime) {
this.expireTime = expireTime;
}
}
这一步与普通的JDBC没有太大的区别，在JDBC中我们也可以通过实体封装需要的信息，如果你对面向对象编程有一定的了解相信不难理解。
3、创建数据库、表
创建数据库创建表
显示表结构
这一步就是一个创建数据库的过程，与我们平常做项目使用的数据库结构和过程也没有区别。
4、创建实体映射文件User.hbm.xml
[html] viewplaincopy
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.entity.User">
<id name="id">
<generator class="uuid"/>
</id>
<property name="name"/>
<property name="password"/>
<property name="createTime"/>
<property name="expireTime"/>
</class>
</hibernate-mapping>
从这一步开始，JDBC开始与Hibernate有一定的区别，这里我们重点讲一下User.hbm.xml的作用。User.hbm.xml的作用简而言之就是对实体和数据库中的表进行相呼应，保证我们对实体对象进行的操作都会在数据库中产生与之对应响应的结果。但仅这样的配置还有一个问题那就是我们如何将能够将数据库中的表与对象进行关联。这就需要接下来的配置了。
5、创建数据库连接和映射配置文件 hibernate.cfg.xml
[html] viewplaincopy
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>
<mapping resource="com/entity/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
这里的重点区别在于，通过映射说明<mapping resource="com/entity/User.hbm.xml"/>我们可以将数据库连接和映射进行联系，也就是说通过 hibernate.cfg.xml的配置，我们就可以找到具体的实体和数据库表对应关系。到此为止我们所有的配置就进行完毕了，接下来做一个测试。
6、创建测试文件 Client.java
[java] viewplaincopy
package test;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.entity.User;
public class Client {
public static void main(String[] args) {
//读取hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
//建立SessionFactory
SessionFactory factory = cfg.buildSessionFactory();
//取得session
Session session = null;
try {
session = factory.openSession();
//开启事务
session.beginTransaction();
User user = new User();
user.setName("NAME1");
user.setPassword("PWD1");
user.setCreateTime(new Date());
user.setExpireTime(new Date());
//保存User对象
session.save(user);
//提交事务
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
//回滚事务
session.getTransaction().rollback();
}finally {
if (session != null) {
if (session.isOpen()) {
//关闭session
session.close();
}
}
}
}
}
程序执行结果如下：
通过上述实例的演示，对比上一篇Hibernate从入门到精通（一）JDBC简介文章中我们提到的JDBC操作的缺陷可以看出，我们向数据库中添加一个对象只需要通过HibernateAPI中最核心的Session接口，调用save()方法即可，不需要我们在代码中编写SQL语句，也不需要程序员对SQL语言过多的了解，这就体现了Hibernate完全面向对象编程。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 一篇文章教你学会HTML
- 初窥CSS布局（一篇文章学会布局）
- 一篇文章学会Spring4.0
- 一篇文章学会springMVC
- 一篇文章学会CORS
- 一篇文章教你学会使用java doc
- 一篇文章学会shell工具篇之sed
- 一篇文章学会Spring4.0
- 一篇文章，教你学会Git
- 转载的一篇文章【每日生活】30岁前我们都应该学会的10堂人生课（双语）
- 一篇文章教你学会基础的HTML
- 一篇文章学会页面传值的10种方法（上）
- Android广播接收器BroadcastReceiver——学会这一篇文章就够了
- 一篇文章，教你学会Git
- 一篇文章学会spring boot（包括jms和hessian的集成）
- 心情有点乱，写一篇文章释放一下，要学会淡定。
- 【干货】一篇文章学会Gulp（Getting started with Gulp）
- 一篇文章教你学会使用github
- 深入浅出，一篇文章让你学会Dagger2使用
- 一篇文章学会spark-streaming