Hibernate笔记 3：核心API

Configuration 接口

Configuration 仅仅是作为一个初始化时的对象，一个 Configeration 实例代表 Hibernate 所有 Java 类到 Sql 数据库映射的集合。

Configuration 接口的作用是：对 Hibernate 进行配置、并启动 Hibernate 和连接数据库系统。

作用：

在 Hibernate 的启动过程中，Configuration 类的实例首先定位缺省 XML 配置文件（hibernate.cfg.xml），并读取关的配置项目，然后创建出一个 SessionFactory 对象。

1. 读取配置文件：
   1. 根据默认的 XML 配置文件：（位置：src/hibernate.cfg.xml）

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

   2. 根据自定义的 XML 配置文件：（少用）

      		Configuration cfg = new Configuration().configure("cn/config/hibernate2.cfg.xml");
      

   3. 加载“映射配置文件”：（如果使用“hibernate.properties”作为核心配置文件，则无法在其中配置“映射配置文件”，需要使用 Configuration 对象加载）

      		Configuration cfg = new Configuration().configure();
      		cfg.addResource("com/eijux/domain/Customer.hbm.xml");
      

2. 创建 SessionFactory 对象：
   • 在 Hibernate 4 之前：

     		Configuration cfg = new Configuration();
     		cfg.configure();
     		SessionFactory sessionFactory = cfg.buildSessionFactory();
     

   • 在 Hibernate 4 之后：【？？？】

     		Configuration cfg = new Configuration().configure();
     		ServiceRegistry sr = new ServiceRegistryBuilder().applySettings(cfg.getProperties()).buildServiceRegistry();
     		SessionFactory sessionFactory = cfg.buildSessionFactory(sr);
     

SessionFactory 接口

SessionFactory 接口负责 Hibernate 的初始化和建立 Session 对象。


特点：
1、线程安全，同一个实例能够供多个线程共享。
2、重量级，不能随意的创建和销毁它的实例。

所以，通常情况下每一个应用只需要一个 SessionFactory，当需要操作多个数据库时，可以为每个数据库指定一个 SessionFactory。

    ——【整个应用中共享，一个 SessionFactory 实例”对应“一个数据存储源”】

因此，在实际项目使用中，通常会抽取一个 HibernateUtils 的工具类，用于提供 Session 对象：

public class HibernateUtils { 
	private static final Configuration configuration; 
	private static final SessionFactory sessionFactory;
	
	Static{
		configuration = new Configuration().configure(); 
		sessionFactory = configuration.buildSessionFactory(); 
	}
	
	/**
	* 提供获得 session 的方法： 
	*/ 
	public static Session openSession() { 
		return sessionFactory.openSession();
	}
	
	/**
	* 获取当前线程绑定的会话：
	*/
	public static Session getCurrentSession(){ 
		return sessi.onFactory.getCurrentSession(); 
	}
}

连接池

SessionFactory 内部还维护了一个连接池，如果需要使用第三方连接池（如：C3PO），则需要手动进行配置。

详见：Hibernate笔记 2：配置文件详解#配置：连接池

Session

Session 用于管理一个数据库的任务单元（增、删、改、查），它是 Java 应用和 Hibernate 之间主要运行接口，是抽象持久性服务概念的主要 API。


特点：
1、非线程安全，因此最好是一个线程只创建一个Session对象（将它设计为局部对象）。
2、轻量级，创建和销毁 Session 对象不会有太大开销。

    ——【不共享：“一请求”>>“一线程”>>“一session”>>“一事务”】

类似于 JDBC 中的连接（“connection”）。

生成方式

可以通过两种方法产生 Session。

生成方式：

1. openSession()：获取一个新的 Session；

   		Session session = sessionFactory.openSession();
   

   • 每次打开都是新的 Session；
   • 需要调用 close 方法以关闭 Session。
2. getCurrentSession()：从当前上下文中获取 Session，并绑定到当前线程；

   		Session session = sessionFactory.getCurrentSession();
   

   • 第一次调用会创建新的 Session 实例，（事务未完成前）同一线程中多次获取的是同一个 Session；
   • 无需手动关闭，事物提交或者回滚时会自动关闭 Session。
   • 必须配置“Session 管理方式”：（否则会报错“org.hibernate.HinerbateException: No CurrentSessionContext configured!”）

     		<property name="current_session_context_class">thread</property>
     或：
     		<property name="current_session_context_class">thread</property>
     

     【详见：Hibernate笔记 2：配置文件详解#配置：Session 管理方式】

常用方法

Session 的所有方法，见博客：Hibernate session的方法全集

常见方法：

1. save()：向数据库中保存（持久化）实体。

   示例：

   		session.save(Object);
   

2. delete()：从数据库中删除实体。
   • 对象删除后，其状态为“Transistent”；
   • 对象需要有 ID；

   示例：

   		session.delete(Object);
   

3. load()：从数据库中加载实体。

   Session.load(Class arg0, Serializable arg1) throws HibernateException
   

   1. 参数：
      • “arg0”：需要加载对象的类，例如：User.class；
      • “arg1”：查询条件（实现了序列化接口的对象），例如："4028818a245fdd0301245fdd06380001" 字符串已经实现了序列化接口；
        • 如果是数值类类型，则 hibernate 会自动使用包装类。
   2. 返回：
      • 此方法返回类型为 Object，但返回的是“代理对象”（并非实际可用的对象，因为“延迟加载”）。【第一次使用对象时，session 不能关闭】
      • 如果数据库中没有相应的记录，则会抛出异常“找不到对象”（org.hibernate.ObjectNotFoundException）。【记录不存在时抛出异常】
   3. 执行：因为 load 方法实现了“延迟加载”（懒加载，“lazy load”），所以，只有在使用返回的对象时，它才发出查询 SQL 语句，加载对象。
      • 其延迟加载实现原理是代理方式。【？？？】

   示例：

   		try {
   			session = sf.openSession();
   			session.beginTransaction();
   			User user = (User)session.load(User.class,1);
   			
   			// 在使用对象时，才发出查询SQL语句，加载对象
   			System.out.println("user.name=" + user.getName());
   
   			// 此时 user 为 persistent 状态
   			user.setName("eijux");
   
   			session.getTransaction().commit();
   		} catch (HibernateException e) {
   			e.printStackTrace();
   			session.getTransaction().rollback();
   		} finally{
   			if (session != null){
   			if (session.isOpen())
   			session.close();
   		}
   

4. get()：从数据库中加载实体。

   Session.get(Class arg0, Serializable arg1)
   

   1. 参数：
      • “arg0”：需要加载对象的类，例如：User.class；
      • “arg1”：查询条件（实现了序列化接口的对象），例如："4028818a245fdd0301245fdd06380001" 字符串已经实现了序列化接口；
        • 如果是数值类类型，则 hibernate 会自动使用包装类。
   2. 返回：
      • 此方法返回类型为 Object，然后我们再强行转换为需要加载的对象就可以了。【返回值需要强制类型转换？？？】
      • 如果数据库中没有相应的记录，则返回 null。【不会抛出异常】
   3. 执行：该方法会立即发出查询 SQL 语句，加载对象。

   示例：

   		try {
   			session = sf.openSession();
   			session.beginTransaction();
   
   			// 方法返回类型为Object，需要再强行转换为需要加载的对象
   			// 方法会立即发出查询语句
   			User user = (User)session.get(User.class, 1);
   
   			// 数据加载完后的状态为 persistent 状态。数据将与数据库同步
   			System.out.println("user.name=" + user.getName());
   
   			// 此时 user 为 persistent 状态
   			 user.setName("eijux");
   		  
   			 session.getTransaction().commit();
   		} catch (HibernateException e) {
   			 e.printStackTrace();
   			 session.getTransaction().rollback();
   		} finally{
   			 if (session != null){
   			 if (session.isOpen()){
   				 session.close();
   			 }
   		}
   

5. update()：向数据库中更新实体。
   • 用于更新“detached”对象，更新完成后转为为“persistent”状态；【默认更新全部字段】
   • 更新“transient”对象（没有 ID）会报错；
     • 更新自己设定 ID 的“transient”对象则可以。
   • “persistent”状态的对象，只要设定字段不同的值，在 session 提交时，会自动更新（默认更新全部字段）。
   • 如果需要更新部分字段，有两种方法：
     1. update / updatable 属性：用于设置参与更新的字段。【适合 xml、注解 方式】【较少用，不灵活】
        1. xml 方式：（映射关系配置文件中）设置“<property>”标签的“update”属性，以设置在更新时是否参与更新。
           • false：不参与更新；true（默认）：参与更新。

           示例：

           		<property name="name" update="false"/>
           

        2. annotation 方式：（映射关系类中）设定“@Column”的“updatable”属性值，以设置在更新时是否参与更新。

           示例：

           		@Column(updatable=false)
           		public String getTitle() {return title;}
           

     2. dynamic-update 属性：用于设置仅更新变更的字段。【只适合 xml 方式，JAP1.0 annotation 没有对应属性】

        在实体类的映射文件（映射关系配置文件）中的“<class>”标签中，设置“dynamic-update”属性：true，表示修改了哪个字段就更新哪个字段，其它字段不更新。

        • 但要求是同一个 session（不能跨 session），如果跨了 session 同样会更新所有的字段内容。

        示例：

        		...
        		<class name="com.bjsxt.Student" dynamic-update="true">
        		...
        

        	@Test
        	public void testUpdate() {
        		Session session = sessionFactory.getCurrentSession();
        		session.beginTransaction();
        		
        		Student s = (Student)session.get(Student.class, 1);
        		s.setName("zhangsan");
        		
        		// 提交时，会只更新 name 字段，因为此时的 s 为 persistent 状态
        		session.getTransaction().commit();
        		
        		
        		s.setName("zhangsi");
        		
        		
        		Session session2 = sessionFactory.getCurrentSession();
        		session2.beginTransaction();
        		
        		// 更新时，会更新所有的字段，因为此时的 s 不是 persistent 状态
        		session2.update(s);
        		session2.getTransaction().commit();
        	}
        

        • 如果需要跨 session 实现更新修改的部分字段，需要使用 session.merget() 方法，合并字段内容：

          示例：

          	@Test
          	public void testUpdate() {
          		Session session = sessionFactory.getCurrentSession();
          		session.beginTransaction();
          		
          		Student s = (Student)session.get(Student.class, 1);
          		s.setName("zhangsan");
          		
          		// 提交时，会只更新 name 字段，因为此时的 s 为 persistent 状态
          		session.getTransaction().commit();
          		
          		
          		s.setName("zhangsi");
          		
          		
          		Session session2 = sessionFactory.getCurrentSession();
          		session2.beginTransaction();
          		
          		// 使用s ession.merget() 方法，合并字段内容
          		session2.merge(s);
          		
          		// 提交时，会只更新 name 字段
          		session2.getTransaction().commit()
          	}
          

          如上，虽然可以实现部分字段更新，但这样会多出一条 select 语句，因为在字段数据合并时，需要比较字段内容是否已变化，就需要从数据库中取出这条记录进行比较。

          所以，跨 Session 更新部分字段，建议使用 HQL（EJBQL）面向对象的查询语言：

          示例：

          	@Test
          	public void testUpdate7() {
          		Session session = sessionFactory.getCurrentSession();
          		session.beginTransaction();
          		
          		Query q = session.createQuery("update Student s set s.name='z5' where s.id = 1");
          		q.executeUpdate();
          		
          		session.getTransaction().commit();
          	}
          

6. saveOrUpdate()：向数据库中保存/更新实体。
   • 在执行的时候 hibernate 会检查，如果对象在数据库中已经有对应的记录（存在同样主键的记录），则会更新（update），否则会添加数据（save）。
7. clear()：清除 session 缓存。
   • 无论是 load 还是 get，都会首先查找缓存（一级缓存，也叫“session 缓存”)，如果没有，才会去数据库查找，调用 clear() 方法可以强制清除 session 缓存。

   示例：

   		// 使用 getCurrentSession，所以不需要手动关闭 Session
   		Session session = sessionFactory.getCurrentSession();
   		session.beginTransaction();
   		
   		Teacher t = (Teacher)session.load(Teacher.class, 1);
   		System.out.println(t.getName());
   		
   		session.clear();
   		
   		Teacher t2 = (Teacher)session.load(Teacher.class, 1);
   		System.out.println(t2.getName());
   		
   		session.getTransaction().commit();
   

   如上，两个 load 方法均会发送查询到数据库。如果注释掉 clear，则第二次 load 不发送查询到数据库，而是直接使用第一次 load 的缓存（两次 load 的是同一个记录）。

8. flush()：强制同步数据（从内存到数据库）。
   • 在默认的情况下 session.commit() 之前时，其实执行了一个 flush 命令。
   • 只有部分 SQL 语句（update、insert、delete），才需要 flush。
     • 对于“session.save()”方法：

       如果主键生成策略是“由数据库生成”（native），则 session.save 的同时就发出 SQL 语句（insert）。否则（uuid），session.save 不会发出 SQL 语句。【？？？】

   • 可以通过 session.setFlushMode(FlushMode); 来设置“刷新模式”：

     FlushMode 的枚举值：

     1. “FlushMode.ALWAYS”：任务一条SQL语句，都会 flush 一次；
     2. “FlushMode.AUTO”：自动 flush(默认)；
     3. “FlushMode.COMMIT”：只有在 commit 时才 flush；
     4. “FlushMode.MANUAL”：手动 flush；
     5. “FlushMode.NEVER”：永远不 flush。（此选项在性能优化时可能用，比如 session 取数据为只读时用，这样就不需要与数据库同步了）
     • 设置 flush 模式（FlushMode），应该在 session 开启事务之前。
9. evict()：从 session 缓存（EntityEntries属性）中逐出该对象。
   • 与 commit 同时使用，会抛出异常。【？？？】

     示例：

     		session = HibernateUtils.getSession();
     		tx = session.beginTransaction();
     
     		User1 user = new User1();
     		user.setName("李四");
     		user.setPassword("123");
     		user.setCreateTime(new Date());
     		user.setExpireTime(new Date());
     
     		/* 利用 Hibernate 将实体类对象保存到数据库中。
     		因为 user 主键生成策略采用的是 uuid，所以调用完成 save 后，只是将 user 纳入 session 的管理，不会发出 insert 语句，但是 id 已经生成，session 中的 existsInDatabase 状态为 false
     		*/
     		session.save(user);
     
     		// 从session缓存（EntityEntries属性）中逐出该对象
     		session.evict(user);
     		
     		/* 无法成功提交。
     		因为 hibernate 在清理缓存时，在 session 的临时集合（insertions）中取出 user 对象进行 insert 操作后，需要更新 entityEntries 属性中的 existsInDatabase 为 true，而我们采用 evict 已经将 user 从 session 中逐出了，所以找不到相关数据,无法更新，抛出异常。
     		*/
     		tx.commit();
     

     • 解决在逐出 session 缓存中的对象不抛出异常的方法：在 session.evict() 之前进行显示的调用 session.flush() 方法就可以了。【？？？】

       示例：

       		session.save(user);
       
       		/* flush 后 hibernate 会清理缓存，会将 user 对象保存到数据库中，将 session 中的 insertions 中的 user 对象清除，并且会设置 session 中的 existsInDatabase 状态为 false
       		*/
       		session.flush();
       
       		// 从session缓存（EntityEntries属性）中逐出该对象
       		session.evict(user);
       		
       		/* 可以成功提交。
       		因为 hibernate 在清理缓存时，在 Session 的 insertions 中集合中无法找到 user 对象所以不会发出 insert 语句，也不会更新 session 中 existsInDatabase 的状态。
       		*/
       		tx.commit();
       

10. persist()：做一个瞬态的实例持久化。
    • 在事务里执行 session.persist()，不会向数据库插数据，事务 commit 了才会插入数据。

load() 与 get()

load() 与 get()：
1、不存在对应记录时：
    load 抛出异常。
    get 返回 null。
2、返回对象：
    load 返回的是代理对象，等到真正使用对象的内容时才发出 sql 语句，这样就要求在第一次使用对象时，要求 session 处于 open 状态，否则出错。
    get 返回的对象即为 Object。（需要进行强制类型转换，来得到需要的对象类型）
3、加载时机：
    load 进行延迟加载。
    get 进行立即加载。
   
此外，get() 和 load() 只根据主键查询，不能根据其它字段查询，如果想根据非主键查询，可以使用 HQL。

Transaction

Hibernate 进行持久化操作时（CRUD）必须进行事务控制。

使用：

1. 开启事务：

   		Transaction tx = session.beginTransaction();
   

2. 提交事务：

   		tx.commit();
   

3. 回滚事务：

   		tx.rollback();
   

示例：

		Transaction tx = null;
		
		try{
			tx = session.beginTransaction();
			session.save(obj);
			tx.commit();
		}catch(HibernateException e){
			if(tx != null){
				tx.rollback();
			}
			throw e;
		}finally{
			if(session != null){
				session.close();
			}
		}