Hibernate是ORM框架，能够建立面向对象的模型和关系数据库数据模型之间的映射。使Java开发人员只需要操纵Java对象，而无需编写SQL语句，就可以将Java对象持久化到数据库中。ORM是Object-Relation Mapping的简称，对象-关系映射，指的是负责Java对象的持久化，封装数据访问细节。Hibernate位于分层架构的持久层，封装数据访问的细节。持久层的解决方案有JDBC,iBatis,Hibernate,Spring jdbcTemplate,EJB的CMP等等。
优势：
1）开发简洁。如果使用jdbc那么数据插入的话您要构造PreparedStatement或者构造SQL，查询的话您要处理ResultSet，这些代码很啰嗦，而使用Hibernate的话代码更加清晰简洁，Hibernate会自动解析配置文件生成相应的SQL语句。
2）跨数据库。对于一个特定的项目，对数据库移植性通常要求不高，一般选定一个数据库后不会轻易更改。但是对于一个通用的中间件产品来讲通常要求能够支持多种数据库，例如您要开发一个工作流产品，那么您面对的客户用哪种数据库产品都有可能，这就要求您开发的工作流引擎支持多种数据库，具备跨数据库特性。
劣势：
1）复杂的查询。对于复杂的查询通常要编写针对性的SQL，已达到最优化的效能，这时如果依靠ORM工具自动生成的SQL就不太现实了。
2 Hibernate之helloworld
下面以学生，班级，课程，这几个实体对象及对象之间的关系来简单的体验Hibernate。
helloworld程序介绍简单的课程的增、删、改、查。学生和班级的关系是N:1，即一个学生只能属于一个班级，一个班级可以有多个学生。学生和课程的关系是M：N,即一个学生可以学习多门课程，一个可能也可以有多个学生来学。
数据库脚本如下：
create table clazz(id int not null AUTO_INCREMENT,name varchar(20) not null,primary key(id))
create table student(id int not null AUTO_INCREMENT,name varchar(20) not null,clazzid int not null,primary key(id));
create table course(id int not null AUTO_INCREMENT,name varchar(20) not null ,primary key(id));
create table student_course(studentid int not null,courseid int not null,primary key(studentid,courseid));
先来最简单的单表操作吧。
Hibernate开发依赖的最小包列表：
| antlr.jar cglib-full.jar asm.jar asm-attrs.jar commons-collections.jar commons-logging.jar ehcache.jar hibernate3.jar jta.jar dom4j.jar log4j.jar |
主配置文件：
hibernate.cfg.xml：
<?xml version="1.0"?>
<!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="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://localhost:3306/demo</property>
<property name="connection.username">root</property>
<property name="connection.password">frank1234</property>
<property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
<property name="show_sql">true</property>
<mapping resource="course.hbm.xml"/>
</session-factory>
</hibernate-configuration>
Course对象：
public class Course implements Serializable {
public Course(){}
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 String toString(){
return "id="+id+",name="+name;
}
}
course配置文件：
course.hbm.xml:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//HIbernate/HibernateMapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="org.frank1234.hibernate.helloworld.Course" table="course">
<id name="id" column="id">
<generator class="identity"/>
</id>
<property name="name" />
</class>
</hibernate-mapping>
这个有4个要说明的地方：
1）需要将这个配置文件，添加到hibernate.cfg.xml中，否则Hibernate不认Course对象。
抛出异常: org.hibernate.MappingException: Unknown entity: org.frank1234.hibernate.helloworld.Course
2）<generator class="identity"/>表示使用数据库的自增字段。
3）由于Course对象和数据库course表的字段名称和类型一样，所以可以直接写成<property name="name" />
4）可以给hibernate-mapping添加属性package，这样后面的class属性就可以省去包路径了。
获取Session公共类：
HibernateUtil对象：
public class HiberanteUtil {
public static SessionFactory sessionFactory = null;
static{
try{
sessionFactory = new Configuration().configure().buildSessionFactory();
}catch(Exception e){
e.printStackTrace();
}
}
public static final ThreadLocal session = new ThreadLocal();
public static Session currentSession() throws HibernateException{
Session s = (Session) session.get();
if(s == null){
s = sessionFactory.openSession();
session.set(s);
}
return s;
}
public static void closeSession() throws HibernateException{
Session s = (Session)session.get();
if(s != null)
s.close();
session.set(null);
}
}
1）其中SessionFactory是重量级的，创建和销毁都会消耗较大，他要读取配置文件信息，加载到缓存中，一般一个数据库一个，启动的时候加载一次就可以了。
2）Session对象是非线程安全的，是轻量级的，所以一个线程要创建一个Session对象，主要的增删改查接口都在Session对象中。
测试类：
CourseMain ：
public class CourseMain {
public static void main(String[] args) throws Exception{
save();
// delete();
// update();
// list();
}
private static void save(){
Course course = new Course();
course.setName("语文");
Session session = HiberanteUtil.currentSession();
Transaction tx = session.beginTransaction();
try{
tx.begin();
session.save(course);
tx.commit();
}catch (Exception e){
e.printStackTrace();
tx.rollback();
}finally {
HiberanteUtil.closeSession();
}
}
private static void delete(){
Course course = new Course();
course.setId(3);
Session session = HiberanteUtil.currentSession();
Transaction tx = session.beginTransaction();
try{
tx.begin();
session.delete(course);
tx.commit();
}catch (Exception e){
e.printStackTrace();
tx.rollback();
}finally {
HiberanteUtil.closeSession();
}
}
private static void update(){
Course course = new Course();
course.setId(5);
course.setName("英语");
Session session = HiberanteUtil.currentSession();
Transaction tx = session.beginTransaction();
try{
tx.begin();
session.update(course);
tx.commit();
}catch (Exception e){
e.printStackTrace();
tx.rollback();
}finally {
HiberanteUtil.closeSession();
}
}
private static void list(){
Session session = HiberanteUtil.currentSession();
try{
// List list = session.createQuery("from Course").list();
// for(int i =0;i<list.size();i++){
// System.out.println(list.get(i));
// }
// Course course = (Course)session.load(Course.class, 5);
// System.out.println(course);
// Course course = (Course) session.get(Course.class,5);
// System.out.println(course);
}catch(Exception e){
e.printStackTrace();
}finally {
HiberanteUtil.closeSession();
}
}
}
值得注意的有2个：
1）最后一定要记得关闭Session。
2）查询获取的几种方式。
3 1:N关联
笔者觉得这个必须得理解好，理解好了它M:N就很容易理解了。
班级和学生是1：N关系。
Clazz对象：
public class Clazz implements Serializable {
private int id;
private String name;
private Set<Student> students = new HashSet<Student>();
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<Student> getStudents() {
return students;
}
public void setStudents(Set<Student> students) {
this.students = students;
}
public String toString(){
return "id="+id+",name="+name;
}
}
clazz中有private Set<Student> students = new HashSet<Student>();属性。
Student对象：
public class Student implements Serializable {
public Student(){}
private int id;
private String name;
private Clazz clazz;
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 Clazz getClazz() {
return clazz;
}
public void setClazz(Clazz clazz) {
this.clazz = clazz;
}
public String toString(){
return "id="+id+",name="+name;
}
}
Student对象有 private Clazz clazz;属性，这是一个双向的关联关系。
但是数据库中只在Student表中保存了到Clazz表的clazzid字段，这点同对象模型不大一样，对象模型可以是多对多，一对多，甚至可以是双向的多对多，但是在数据库中只有单向的多对一。
clazz配置文件：
clazz.hbm.xml:
<hibernate-mapping>
<class name="org.frank1234.hibernate.helloworld.onetomany.Clazz" table="clazz">
<id name="id" >
<generator class="identity"/>
</id>
<property name="name"/>
<set name="students" table="student" >
<key column="clazzid"/>
<one-to-many class="org.frank1234.hibernate.helloworld.onetomany.Student"/>
</set>
</class>
</hibernate-mapping>
由于Clazz对象有一个到Student对象的Set属性。是1：N关系，
所以clazz.hbm.xml配置文件要配置如下属性：
<set name="students" table="student" >
<key column="clazzid"/>
<one-to-many class="org.frank1234.hibernate.helloworld.onetomany.Student"/>
</set>
Student配置文件：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//HIbernate/HibernateMapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="org.frank1234.hibernate.helloworld.onetomany.Student" table="student">
<id name="id" column="id">
<generator class="identity"/>
</id>
<property name="name" />
<many-to-one name="clazz" class="org.frank1234.hibernate.helloworld.onetomany.Clazz" column="clazzid" />
</class>
</hibernate-mapping>
因为Student对象有一个到Clazz对象的属性，所以其中要添加如下属性：
<many-to-one name="clazz" class="org.frank1234.hibernate.helloworld.onetomany.Clazz" column="clazzid" />
保存的单元测试类：
public class OnetoManyMain {
public static void main(String[] args) throws Exception{
save();
}
private static void save() throws Exception{
Student student1 = new Student();
student1.setName("小红");
Student student2 = new Student();
student2.setName("小兰");
Clazz clazz = new Clazz();
clazz.setName("小班");
//既然设置的是双向关联，就同时更新对象的状态，解除关系的时候也一样，同时解除
student1.setClazz(clazz);
student2.setClazz(clazz);
clazz.getStudents().add(student1);
clazz.getStudents().add(student2);
Session session = HiberanteUtil.currentSession();
Transaction tx = session.beginTransaction();
try{
session.save(clazz);
session.save(student1);
session.save(student2);
tx.commit();
}catch (Exception e){
e.printStackTrace();
tx.rollback();
}finally {
HiberanteUtil.closeSession();
}
}
}
输出为：
Hibernate: insert into clazz (name) values (?)
Hibernate: insert into student (name, clazzid) values (?, ?)
Hibernate: insert into student (name, clazzid) values (?, ?)
Hibernate: update student set clazzid=? where id=?
Hibernate: update student set clazzid=? where id=?
几点说明：
1）由上面的输出可见，执行了insert 还执行了update多执行了一次，这样对性能必然有较大影响，在clazz.hbm.xml中设置上 inverse="true"。
<set name="students" table="student" inverse="true" >
<key column="clazzid"/>
<one-to-many class="org.frank1234.hibernate.helloworld.onetomany.Student"/>
</set>
变为了如下输出，没有了update：
Hibernate: insert into clazz (name) values (?)
Hibernate: insert into student (name, clazzid) values (?, ?)
Hibernate: insert into student (name, clazzid) values (?, ?)
inverse="true"的含义是Clazz端的关联只是Student端关联的镜像，当Hibernate检测到持久化对象Clazz和Student对象均发生变化时，仅按照Student对象的变化来更新数据库。
2）级联保存和更新。
注释掉测试类的如下部分。
session.save(clazz);
// session.save(student1);
// session.save(student2);
如果配置文件不变，则输出：
Hibernate: insert into clazz (name) values (?)
如果将clazz.hbm.xml设置为：
<set name="students" table="student" inverse="true" cascade="save-update" >
<key column="clazzid"/>
<one-to-many class="org.frank1234.hibernate.helloworld.onetomany.Student"/>
</set>
那么输出为：
Hibernate: insert into clazz (name) values (?)
Hibernate: insert into student (name, clazzid) values (?, ?)
Hibernate: insert into student (name, clazzid) values (?, ?)
表示保存Clazz对象的同时也保存它关联的Student对象。
注释掉测试类的如下部分：
// session.save(clazz);
session.save(student1);
session.save(student2);
如果不修改配置文件会抛出如下异常：
Hibernate: insert into student (name, clazzid) values (?, ?)
2015-01-03 17:19:30,200: Column 'clazzid' cannot be null
因为没有保存clazz，而student表的字段clazzid不允许为空。
如果将student.hbm.xml也加上cascade="save-update"
<many-to-one name="clazz" class="org.frank1234.hibernate.helloworld.onetomany.Clazz" column="clazzid" cascade="save-update"/>
就可以正确输出：
Hibernate: insert into clazz (name) values (?)
Hibernate: insert into student (name, clazzid) values (?, ?)
Hibernate: insert into student (name, clazzid) values (?, ?)
哪个配置文件设置了cascade就可以对保存哪个对象的时候检查它的关联对象。
3）级联删除。
如果将clazz.hbm.xml配置上级联删除。
<set name="students" table="student" inverse="true" cascade="save-update, delete" >
<key column="clazzid"/>
<one-to-many class="org.frank1234.hibernate.helloworld.onetomany.Student"/>
</set>
测试代码：
Clazz clazz16 = (Clazz)session.load(Clazz.class,16);
session.delete(clazz16);
输出：
Hibernate: select clazz0_.id as id2_0_, clazz0_.name as name2_0_ from clazz clazz0_ where clazz0_.id=?
Hibernate: select students0_.clazzid as clazzid1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.clazzid as clazzid1_0_ from student students0_ where students0_.clazzid=?
Hibernate: delete from student where id=?
Hibernate: delete from student where id=?
Hibernate: delete from clazz where id=?
Hibernate生成的查询SQL还真够奇葩的。
但是如果你仅仅创建了一个Clazz对象，则级联删除是不生效的。
例如
Clazz clazz17 = new Clazz();
clazz17.setId(17);
session.delete(clazz17);
输出：
Hibernate: delete from clazz where id=?
Student表并不做删除。
这些规则咋看起来挺复杂的，其实理解了以后也不难。
4 M:N关联
M:N 同1：N类似，这里就不贴代码了。
关键配置文件如下：
<set name="courses"
table="student_course"
>
<key column="studentid"/>
<many-to-many
column="courseid"
class="org.frank1234.hibernate.helloworld.Course"/>
</set>