【Hibernate框架学习】：Hibernate进阶之Hibernate核心接口和类(一)

       我们来看一下Hibernate的执行流程：

       

        

       由此我们可以大概知道Hibernate的核心接口和类，Hibernate的核心类和接口一共有6个，分别为:Session、

SessionFactory、Transaction、Query、Criteria和Configuration。这6个核心类和接口在任何开发中都会用到。通

过这些接口，不仅可以对持久化对象进行存取，还能够进行事务控制。下面对这6个核心接口和类分别加以介绍。

       Configuration类

       Configuration类的作用是对Hibernate进行配置，以及对它进行启动。在Hibernate的启动过程中，

Configuration类的实例首先定位映射文档的位置，读取这些配置，然后创建一个SessionFactory对象。虽然

Configuration 类在整个Hibernate项目中只扮演着一个很小的角色，但它是启动Hibernate 时所遇到的第一个对

象。

       Configuration类负责管理Hibernate的配置信息。它包括如下内容：

Hibernate运行的底层信息：数据库的URL、用户名、密码、JDBC驱动类，数据库Dialect，数据库连接池等，

Hibernate映射文件（*.hbm.xml）。

        Hibernate配置的两种方法：

        属性文件（hibernate.properties）。

        调用代码：

        Configuration configure = new Configuration(); 

        Xml文件（hibernate.cfg.xml）。

        调用代码：

        Configuration configure = new Configuration().configure();

        Hibernate源码中对应方法：

        

        这里默认调用的是hibernate.cfg.xml，如果这个Hibernate核心配置名字不是这样子的，那么就需要这样调用：

        Xml文件（hibernate3.cfg.xml）

        调用代码：

        Configuration configure = new Configuration().configure("hibernate3.cfg.xml");

        Hibernate源码中对应方法：

        

        SessionFactory接口

        SessionFactory接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建Session对象。这里用到了

工厂模式。需要注意的SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一SessionFactory就

够，当需要操作多个数据库时，可以为每个数据库指定一SessionFactory。

       会话工厂是对属于单一数据库的映射文件的线程安全的、不可变的缓存快照。它是会话的工厂类，可能持有一个

可选的（二级）数据库缓存，可以在进程级别或集群级别保存可以在事务中重用的数据。

       应用程序从SessionFactory（会话工厂）里获得Session(会话)实例。它在多个应用线程间进行共享。通常情况

下，整个应用只有唯一的一个会话工厂。例如在应用初始化时被创建。然而，如果你使用Hibernate访问多个数据

库，你需要对每一个数据库使用一个会话工厂。会话工厂缓存了生成的SQL语句和Hibernate在运行时使用的映射元

数据。

       调用代码：

       SessionFactory sessionFactory = configure.buildSessionFactory();

       Hibernate源码中对应方法：

       

       说明：SessionFactory由Configuration对象创建，所以每个Hibernate配置文件，实际上是对SessionFactory

的配置。

       Session接口

       Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语

句)。但需要注意的是Session对象是非线程安全的。同时，Hibernate的Session不同于JSP应用中的HttpSession。这

里当使用Session这个术语时，其实指的是Hibernate中的Session，而以后会将HttpSession对象称为用户Session。

      对于Session我们是那么的熟悉，在JavaWeb开发中Session可以用来保存用户会话过程中状态信息。而

Hibernate中的Session是对象与数据库会话持久化管理器。

      会话是单线程、声明短暂的对象，代表应用和持久化层之间的一次对话，封装了JDBC连接，事务的工程。保存必

需持久化对象缓存，用于遍历对象图，或者表示查找对象。

       Session（会话）不是线程安全的，它代表与数据库之间的一次操作，它的概念介于Connection和Transaction之

间。Session也称为持久化管理器，因为它是与持久化有关的操作接口。Session通过SessionFactory打开，在所有的

工作完成后，需要关闭。它与Web层的HttpSession没有任何关系。

       我们不建议使用JDBC的connection操作数据库，而是通过使用session操作数据库，因此session可以理解为操

作数据库的对象。

       session与connection，是多对一关系，每个session都有一个与之对应的connection，一个connection不同时

刻可以供多个session使用。

       如何获得session对象

       1)第一种方式调用代码：

       sessionFactory.openSession();

       Hibernate源码中对应方法：

       

       第二种方式调用代码：

       sessionFactory.getCurrentSession();

       Hibernate源码中对应方法：

       

       如果使用getCurrentSession()需要在hibernate.cfg.xml文件进行一定的配置，如果是本地事务(JDBC事务)，配

置为：<property name="hibernate.current_session_context_class">thread</property>；

       如果是全局事务(JTA事务)，配置为：<property name="hibernate.current_session_context_class">jta</property>

       我们来看例子：

package com.demo.test;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.jdbc.Work;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.Test;

import com.demo.domain.Students;

public class SessionTest {
	@Test
	public void testOpenSession(){
		//创建配置对象
        Configuration config =new Configuration().configure();
        //创建服务注册对象
        ServiceRegistry ServiceRegitry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //创建会话工厂对象
        SessionFactory sessionFactory =config.buildSessionFactory(ServiceRegitry);
        //会话对象
        Session session =sessionFactory.openSession();        
 
        if (session != null) {
			System.out.println("使用openSession创建session成功！");
		} else {
			System.out.println("使用openSession创建session失败！");
		}       
        
        Session sessioncopy =sessionFactory.openSession();
        System.out.println(session == sessioncopy);//输出false说明不是同一个会话
        
	}
	
	@Test
	public void testGetCurrentSession(){
		//创建配置对象，默认读取配置文件
        Configuration config =new Configuration().configure();
        //创建服务注册对象
        ServiceRegistry ServiceRegitry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //创建会话工厂对象
        SessionFactory sessionFactory =config.buildSessionFactory(ServiceRegitry);
        //会话对象
        Session session =sessionFactory.getCurrentSession();
        
        if (session != null) {
			System.out.println("使用getCurrentSession创建session成功！");
		} else {
			System.out.println("使用getCurrentSession创建session失败！");
		}         
        
        Session sessioncopy =sessionFactory.getCurrentSession();
        System.out.println(session == sessioncopy);//输出true说明是同一个会话
		
	}
	
}

       控制台输出：

       
       继续在上面的测试类中添加代码：

package com.demo.test;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.jdbc.Work;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.Test;

import com.demo.domain.Students;

public class SessionTest {
	
	@Test
	public void testSaveStudentsOpenSession(){
		//创建配置对象，默认读取配置文件
        Configuration config =new Configuration().configure();
        //创建服务注册对象
        ServiceRegistry ServiceRegitry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //创建会话工厂对象
        SessionFactory sessionFactory =config.buildSessionFactory(ServiceRegitry);
        //会话对象
        Session session =sessionFactory.openSession();
        //开启事务
        Transaction transaction = session.beginTransaction();
        
        Students student = new Students(4, "老张", "男", new Date(), "北京");
        session.doWork(new Work() {
			
			@Override
			public void execute(Connection connection) throws SQLException {
				System.out.println("connection hashCode: " + connection.hashCode());
			}
		});
        session.save(student);
        //session.close();//在这里我们不关闭session
        transaction.commit();
        
        Session sessionCopy = sessionFactory.openSession();
        transaction = sessionCopy.beginTransaction();
        student = new Students(5, "老李", "男", new Date(), "天津");
        sessionCopy.doWork(new Work() {
			
			@Override
			public void execute(Connection connection) throws SQLException {
				System.out.println("connection hashCode: " + connection.hashCode());
			}
		});

        sessionCopy.save(student);
        transaction.commit();
           
	}
	
	@Test
	public void testSaveStudentsGetCurrentSession(){
		//创建配置对象，默认读取配置文件
        Configuration config =new Configuration().configure();
        //创建服务注册对象
        ServiceRegistry ServiceRegitry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //创建会话工厂对象
        SessionFactory sessionFactory =config.buildSessionFactory(ServiceRegitry);
        //会话对象
        Session session =sessionFactory.getCurrentSession();
        //开启事务
        Transaction transaction = session.beginTransaction();
        
        Students student = new Students(6, "赵六", "男", new Date(), "北京");
        session.doWork(new Work() {
			
			@Override
			public void execute(Connection connection) throws SQLException {
				System.out.println("connection hashCode: " + connection.hashCode());
			}
		});
        session.save(student);
        //session.close();
        transaction.commit();
        
        Session sessionCopy = sessionFactory.getCurrentSession();
        transaction = sessionCopy.beginTransaction();
        student = new Students(7, "周七", "男", new Date(), "天津");
        sessionCopy.doWork(new Work() {
			
			@Override
			public void execute(Connection connection) throws SQLException {
				System.out.println("connection hashCode: " + connection.hashCode());
			}
		});

        sessionCopy.save(student);
        transaction.commit();
           
	}
	
}

       运行testSaveStudentsOpenSession()测试方法：

       控制台输出：

       

       

        运行testSaveStudentsGetCurrentSession()测试方法：

        控制台输出：

        

        从上面的例子中我们看出openSession与getCurrentSession的区别：

       （1）openSession每次创建新的session对象，getCurrentSession使用现有的session对象。openSession每次

使用都是打开一个新的session，使用完需要调用close方法关闭session；getCurrentSession是获取当前session对

象，连续使用多次时，得到的session都是同一个对象，这就是与openSession的区别之一 ；

      一般在实际开发中，往往使用getCurrentSession多，因为一般是处理同一个事务，所以在一般情况下比较少使用

openSession。

       （2）getCurrentSession在事务提交或者回滚之后会自动关闭，而openSesssion需要你手动关闭，如果使用

openSession而没有手动关闭，多次之后会导致连接池溢出。openSession存在线程并发问题,而getCurrentSession

的方式获取会话，一个用户拿到会话会自动的绑定一个线程，直到当前session失效，Hibernater会将线程剥离会

话，保证了每个用户操作数据的唯一性。

        Transaction接口

        Transaction接口是一个可选的API，可以选择不使用这个接口，取而代之的是Hibernate的设计者自己写的底层

事务处理代码。 Transaction接口是对实际事务实现的一个抽象，这些实现包括JDBC的事务、JTA中的

UserTransaction、甚至可以是CORBA 事务。之所以这样设计是能让开发者能够使用一个统一事务的操作界面，使得

自己的项目可以在不同的环境和容器之间方便地移植。

       Transaction接口是单线程的，应用程序用它表示一批不可分割操作。一个Session在某些情况下可能跨越多个事

务。
       Transaction（事务）将应用代码从底层的事务实现中抽象出来，这可能是一个JDBC事务，一个JTA用户事务或

者甚至是一个公共对象请求代理结构（CORBA），允许应用通过一组一致的API控制事务边界。这有助于保持

Hibernate应用在不同类型的执行环境或容器中的可移植性。
       调用代码：

       Transaction transation = session.beginTransaction();

       Hibernate源码中对应方法：

       
      说明：使用Hibernate进行操作时必须显式的调用Transaction（默认：autoCommit=false）。
      Hibernate对数据的操作都是封装在事务当中，并且默认是非自动提交的方式。所以session保存对象时，如果不

开启事务，并且手工提交事务，对象并不会真正保存在数据库中。

       我们来看一个例子：

package com.demo.test;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.demo.domain.Students;

public class TestStudents {
	
	private SessionFactory sessionFactory;
	private Session session;
	private Transaction transaction;
	
	@Before
	public void init() {
		//创建配置对象
        Configuration config =new Configuration().configure();
        //创建服务注册对象
        ServiceRegistry ServiceRegitry=new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //创建会话工厂对象
        sessionFactory =config.buildSessionFactory(ServiceRegitry);
        //会话对象
        session =sessionFactory.openSession();
        //开启事务
        //transaction = session.beginTransaction();
        
	}
	
    @Test
    public void testStudents(){             
            Students s =new Students(3,"王五","男",new Date(),"北京");
            session.save(s);//保存对象进入数据库           
    }
    
    @After
    public void destory(){
    	//transaction.commit();//提交事务
    	session.close();//关闭会话
    	sessionFactory.close();//关闭会话工厂
    	
    }
    
}

       控制台什么都没有输出，当然数据库中也不会存在相应的sid=3的数据。这是因为不开启事务就不能将对象保存

在数据库中。最主要的还是Hibernate默认不是自动提交事务的。

       数据库显示：

       

       如果想让Hibernate像JDBC那样自动提交事务，必须调用session对象的doWork()方法，获得JDBC的

connection后，设置其为自动提交事务模式（通常并不推荐）。不写doWork方法是无法获得jdbc的connection

的。
       我们修改上面的测试代码：

    @Test
    public void testStudents(){             
            Students s =new Students(3,"王五","男",new Date(),"北京");
            session.doWork(new Work(){

            	   @Override
            	   public void execute(Connection connection) throws SQLException{
            	       connection.setAutoCommit(true);
            	   }

            	});

            	session.save(s);//保存对象进入数据库 
            	session.flush();//真正输出SQL语句          
    }

       控制台输出：

       

       数据库显示结果：

       

       使用Hibernate的目的就是使用session来操作数据库，而doWork使用的是jdbc的connection对象执行原生的

SQL语句，这样的话，使用Hibernate就没什么意义了。