Interface Session 
All Superinterfaces: 
Serializable 
All Known Subinterfaces: 
EventSource, Session 
All Known Implementing Classes: 
SessionImpl 

public interface Session  extends Serializable 

Java应用程序与Hibernate之间的主要运行时接口。它是抽象了持久化服务概念的核心抽象API类。 

Session的生命周期绑定在一个物理的事务（tansaction）上面。（长的事务可能跨越多个数据库事物。） 

其具体实现并不一定是线程安全的。每个线程/事务应该从一个SessionFactory获取自己的session实例。 

如果其持久化对象类是可序列化的，则Session实例也是可序列化的。 

一个典型的事务应该使用下面的形式： 

Java代码  

1. Session sess = factory.openSession();  
2. Transaction tx;  
3. try {  
4.     tx = sess.beginTransaction();  
5.     //do some work  
6.     ...  
7.     tx.commit();  
8. }  
9. catch (Exception e) {  
10.     if (tx!=null) tx.rollback();  
11.     throw e;  
12. }  
13. finally {  
14.     sess.close();  
15. }  

如果Session抛出了异常, 事务必须回滚而session会被废弃。在异常发生后Session的内部状态可能会与数据库失去同步。 

实例： 
Session.save()方法用于实体对象的持久化保存，也就是说当执行session.save()方法时会生成对应的insert SQL语句，完成数据的保存。 
如下面的代码： 

Java代码  

1. public static void insertUser()  
2. {  
3.     Session sess = HibernateSessionFactory.getSession();  
4.     User user = new User();  
5.     Transaction tx = null;  
6.     try  
7.     {  
8.         tx = sess.beginTransaction();  
9.         // do some work  
10.         user.setLogonName("关羽");  
11.         user.setNickName("关云长");  
12.         user.setPassword("1234");  
13.         sess.save(user);  
14.         tx.commit();  
15.     }  
16.     catch (Exception e)  
17.     {  
18.         if (tx != null)  
19.             tx.rollback();  
20.     }  
21.     finally  
22.     {  
23.         sess.close();  
24.     }  
25. }  

当执行到session.save()方法时，Hibernate并不会马上生成insert SQL语句来进行数据的保存，而是当稍后清理session的缓存时才有可能执行insert SQL语句，那么session.save()方法到底会执行哪些步骤呢？ 

Hibernate3.2中save()方法实现的源代码： 

Java代码  

1. /** 
2.  * Concrete implementation of a Session, and also the central, organizing component 
3.  * of Hibernate‘s internal implementation. As such, this class exposes two interfaces; 
4.  * Session itself, to the application, and SessionImplementor, to other components 
5.  * of Hibernate. This class is not threadsafe. 
6.  * 
7.  * @author Gavin King 
8.  */  
9. public final class SessionImpl extends AbstractSessionImpl   
10.         implements EventSource, org.hibernate.classic.Session, JDBCContext.Context {  
11.           //省略部分代码  
12.     // save() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
13.   
14.     public void save(Object obj, Serializable id) throws HibernateException {  
15.         save(null, obj, id);  
16.     }  
17.        
18.     public Serializable save(Object obj) throws HibernateException {  
19.         return save(null, obj);  
20.     }  
21.   
22.     public Serializable save(String entityName, Object object) throws HibernateException {  
23.         return fireSave( new SaveOrUpdateEvent(entityName, object, this) );  
24.     }  
25.   
26.     public void save(String entityName, Object object, Serializable id) throws HibernateException {  
27.         fireSave( new SaveOrUpdateEvent(entityName, object, id, this) );  
28.     }  
29.   
30.     private Serializable fireSave(SaveOrUpdateEvent event) {  
31.         errorIfClosed();  
32.         checkTransactionSynchStatus();  
33.         SaveOrUpdateEventListener[] saveEventListener = listeners.getSaveEventListeners();  
34.         for ( int i = 0; i < saveEventListener.length; i++ ) {  
35.             saveEventListener[i].onSaveOrUpdate(event);  
36.         }  
37.         return event.getResultId();  
38.     }  
39.           //省略部分代码  
40. }  

持久化指定的游离态对象，首先要分配一个自动生成的主键标示符。(或者如果主键生成器正在使用，使用当前主键标示符属性值) 

Hibernate3.2中update()方法实现的源代码： 

Java代码  

1. /** 
2.  * Concrete implementation of a Session, and also the central, organizing component 
3.  * of Hibernate‘s internal implementation. As such, this class exposes two interfaces; 
4.  * Session itself, to the application, and SessionImplementor, to other components 
5.  * of Hibernate. This class is not threadsafe. 
6.  * 
7.  * @author Gavin King 
8.  */  
9. public final class SessionImpl extends AbstractSessionImpl   
10.         implements EventSource, org.hibernate.classic.Session, JDBCContext.Context {  
11.           //省略部分代码  
12.     // update() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
13.   
14.     public void update(Object obj) throws HibernateException {  
15.         update(null, obj);  
16.     }  
17.   
18.     public void update(Object obj, Serializable id) throws HibernateException {  
19.         update(null, obj, id);  
20.     }  
21.   
22.     public void update(String entityName, Object object) throws HibernateException {  
23.         fireUpdate( new SaveOrUpdateEvent(entityName, object, this) );  
24.     }  
25.   
26.     public void update(String entityName, Object object, Serializable id) throws HibernateException {  
27.         fireUpdate(new SaveOrUpdateEvent(entityName, object, id, this));  
28.     }  
29.   
30.     private void fireUpdate(SaveOrUpdateEvent event) {  
31.         errorIfClosed();  
32.         checkTransactionSynchStatus();  
33.         SaveOrUpdateEventListener[] updateEventListener = listeners.getUpdateEventListeners();  
34.         for ( int i = 0; i < updateEventListener.length; i++ ) {  
35.             updateEventListener[i].onSaveOrUpdate(event);  
36.         }  
37.     }  
38.           //省略部分代码  
39. }  

实例： 
前面我在实体对象状态转化部分曾经讲过，session.update()方法能够将一个处于游离状态的对象，重新纳入Hibernate的内部缓存，变成持久化对象。 
如下面的代码： 

Java代码  

1. Configuration cfg = new Configuration();  
2. SessionFactory sf=cfg. configure().buildSessionFactory();  
3. Customer customer=new Customer("关羽",27);//customer对象处于自由状态  
4. Session session=sf.openSession();  
5. // 开启事务   
6. Transaction tx=session.beginTransaction();  
7. //保存后customer对象处于持久化状态  
8. session.save(customer);  
9. //清空缓存后customer对象处于游离状态  
10. session.flush();  
11. // 提交事务  
12. tx.commit();  
13. //session关闭  
14. session.close();  
15.   
16. // 又开启一个新的session   
17. Session session2=sf.openSession();  
18. Transaction tx2=session2.beginTransaction();  
19. //通过调用update()方法将游离状态的customer对象，再次转化成持久化状态  
20. session2.update(customer);  
21. //调用delete()方法后，当清空缓存时，会将customer对象移出缓存，同时会在数据库中生成delete事务，来删除customer对象对应的数据记录  
22. session2.delete(customer);  
23. tx.commit();  
24. session.close();  

那么update方法到底执行了哪些步骤呢？它会按照下面的步骤进行操作： 

一、首先会在缓存中寻找需要更新的实体对象，如果找到就立刻返回，从这里我们可以看出如果对一个已经处于persistent的实体对象执行update()方法，将不会产生任何作用。 
二、然后当提交事务进行缓存清理时，将会通过脏数据检查，确定变化的属性，然后生成update SQL语句完成数据的更新。 
这里有一个问题我们要强调一下，那就是只要通过update()方法将一个游离对象与session相关联，那么不论这个游离的实体对象的属性是否发生改变，都会执行update SQL语句。 
如下面的代码： 

Java代码  

1. Transaction tx=session.beginTransaction();  
2. session.update(customer);  
3. tx.commit();  
4. session.close();  

在这段代码中并没有修改customer对象的任何属性值，但是也会执行一个update SQL语句，如果你希望在没有改变实体对象属性值的情况下不去执行update SQL语句，那么你要开启实体对象元素的”select-before-update”属性，将其设置为”true”,这个属性默认为”false”。 
如下进行配置： 
如果启用了这个属性配置，那么在清理session缓存之前，会首先执行类似如下的一条SQL语句： 
Select * from logon_user where id=‘1‘; 
查询处所有的customer实体在数据库中对应的属性值，然后逐条与缓存中属性值进行比较，如果发生了改变，那么将会生成update操作进行数据更新，如果没有发生改变那么将不会进行update操作。 
要跟据实际需求情况来决定是否开启这个选项，如果实体对象的属性不会经常发生改变，那么就应该开启这个选项，以免执行多余的update操作。如果实体对象的属性会经常发生改变，那么就没必要开启这个选项，以免在执行update操作前再执行多余的select语句。 

注意事项： 
1.当执行对一个游离实体对象执行session.update()操作时，如果在数据库中不存在这个实体对应的纪录，那么这个操作将会抛出异常。 
2.当执行session.update()方法将一个游离对象与session关联时，如果此时在缓存中已经存在了与该实体对象具有相同OID的持久化对象，那么这个方法会抛出异常。 
如下面代码： 

Java代码  

1. Customer customer1=new Customer("刘备",25);  
2. Session session1=sf.openSession();  
3. Transaction tx=session1.beginTransaction();  
4. //保存后customer对象处于持久化状态  
5. session.save(customer1);  
6. //清空缓存后customer对象处于游离状态  
7. session.flush();  
8. tx.commit();  
9. session1.close();  
10.    
11. Session session2=sf.openSession();  
12. Transaction tx2=session2.beginTransaction();  
13. Customer othercustomer=(Customer)session2.load(Customer.class,"1");  
14. //通过调用update()方法将游离状态的customer1对象，再次转化成持久化状态  
15. session2.update(customer1)  
16. tx2.commit();  
17. session2.close();  

当再次将游离对象customer1与session2关联时，此时因为load()操作，在缓存已经加载了一个和customer1具有相同OID的othercustomer对象，此时由于Hibernate缓存的对象缓存机制不允许把OID相同的对象缓存，所以会抛出异常。 

Hibernate3.2中saveOrUpdate()方法实现的源代码： 

Java代码  

1. /** 
2.  * Concrete implementation of a Session, and also the central, organizing component 
3.  * of Hibernate‘s internal implementation. As such, this class exposes two interfaces; 
4.  * Session itself, to the application, and SessionImplementor, to other components 
5.  * of Hibernate. This class is not threadsafe. 
6.  * 
7.  * @author Gavin King 
8.  */  
9. public final class SessionImpl extends AbstractSessionImpl   
10.         implements EventSource, org.hibernate.classic.Session, JDBCContext.Context {  
11.           //省略部分代码  
12.     // saveOrUpdate() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
13.   
14.     public void saveOrUpdate(Object object) throws HibernateException {  
15.         saveOrUpdate(null, object);  
16.     }  
17.   
18.     public void saveOrUpdate(String entityName, Object obj) throws HibernateException {  
19.         fireSaveOrUpdate( new SaveOrUpdateEvent(entityName, obj, this) );  
20.     }  
21.   
22.     private void fireSaveOrUpdate(SaveOrUpdateEvent event) {  
23.         errorIfClosed();  
24.         checkTransactionSynchStatus();  
25.         SaveOrUpdateEventListener[] saveOrUpdateEventListener = listeners.getSaveOrUpdateEventListeners();  
26.         for ( int i = 0; i < saveOrUpdateEventListener.length; i++ ) {  
27.             saveOrUpdateEventListener[i].onSaveOrUpdate(event);  
28.         }  
29.     }  
30.           //省略部分代码  
31. }  

查看onSaveOrUpdate(event)方法的定义： 

Java代码  

1. public class DefaultSaveOrUpdateEventListener extends AbstractSaveEventListener implements SaveOrUpdateEventListener {  
2.   
3.     private static final Log log = LogFactory.getLog( DefaultSaveOrUpdateEventListener.class );  
4.   
5.     /** 
6.      * Handle the given update event. 
7.      * 
8.      * @param event The update event to be handled. 
9.      */  
10.     public void onSaveOrUpdate(SaveOrUpdateEvent event) {  
11.         final SessionImplementor source = event.getSession();  
12.         final Object object = event.getObject();  
13.         final Serializable requestedId = event.getRequestedId();  
14.   
15.         if ( requestedId != null ) {  
16.             //assign the requested id to the proxy, *before*   
17.             //reassociating the proxy  
18.             if ( object instanceof HibernateProxy ) {  
19.                 ( ( HibernateProxy ) object ).getHibernateLazyInitializer().setIdentifier( requestedId );  
20.             }  
21.         }  
22.   
23.         if ( reassociateIfUninitializedProxy( object, source ) ) {  
24.             log.trace( "reassociated uninitialized proxy" );  
25.             // an uninitialized proxy, noop, don‘t even need to   
26.             // return an id, since it is never a save()  
27.         }  
28.         else {  
29.             //initialize properties of the event:  
30.             final Object entity = source.getPersistenceContext().unproxyAndReassociate( object );  
31.             event.setEntity( entity );  
32.             event.setEntry( source.getPersistenceContext().getEntry( entity ) );  
33.             //return the id in the event object  
34.             event.setResultId( performSaveOrUpdate( event ) );  
35.         }  
36.   
37.     }  
38.     // 省略部分代码... ...  
39. }  

这个方法包含了save()方法和update()方法的特点，如果传入该方法的是一个游离对象，那么这个方法就会执行update操作，如果传入该方法的是一个自由对象，那么这个方法就会执行insert操作。 
这个方法幕后的工作原理如下： 
1.首先在缓存寻找，如果找到待保存的操作就直接返回。 
2.如果实体实现了拦截方法，那么就执行isUnsaved()方法，判断实体对象状态。 
3.如果实体处于自由状态就执行save(),如果实体处于游离状态那么就执行update()。 

这里存在一个问题，那就是Hibernate是怎样判断一个实体是处于游离态还是临时状态的？ 
如果实体满足下面的一个条件，就认为这个实体处于临时状态。 
Java对象的OID值为null。 
1.如果Java对象具有version属性（可以了解并发加锁部分）且为null。 
2.如果实体的设置了属性unsaved-value，而且OID值与unsaved-value值相等。 
3.如果实体的version属性设置了unsaved-value，并且version属性的值与unsaved-value值相等。 
4.如果实体实现了Interceptor,而且Interceptor.isUnsaved()方法返回true。 
满足这些条件中的一个，这个实体就被认为是临时对象。 

Session.delete()方法: 
delete()方法用于从数据库中删除一个或一批实体所对应的数据，如果传入的对象是持久化对象，那么当清理缓存时，就会执行delete操作。 
如果传入的是游离对象，那么首先会使该对象与session相关联，然后当清理缓存时，再执行delete操作。 

看如下代码： 

Java代码  

1.    
2. Session session=sessionFactory().openSession();  
3. Transaction tx=session.beginTransaction();  
4. //加载持久态对象  
5. Customer customer=(Customer)session.load(Customer.class,”1”);  
6. //计划执行一条delete语句  
7. session.delete(customer);  
8. //清理缓存，执行一条delete语句  
9. tx.commit();  
10. //关闭session,这时将会把customer对象从缓存中删除  
11. session.close();  

如果上面的代码中的customer对象是一个游离对象，那么当执行session.delete()方法时，会首先将游离的customer对象与session相关联(转换为持久态)，然后再清理缓存时，再执行delete操作。 
如果你想一次删除多条数据，那么可以采用一个重载的delete()方法：delete("from Customer c where c.id > ‘8‘");这个方法可以删除符合条件的所有数据。 

Hibernate数据保存操作方法的原理对比