引用

Session的主要功能是提供对映射的实体类实例的创建，读取和删除操作。
实例可能以下面三种状态存在:
瞬态或者自由态（transient）: 不曾进行持久化，未与任何Session相关联
持久化状态（persistent）: 仅与一个Session相关联
脱管状态或者游离态（detached）: 已经进行过持久化，但当前未与任何Session相关联

游离状态的实例可以通过调用save()、persist()或者saveOrUpdate()方法进行持久化。
持久化实例可以通过调用 delete()变成游离状态。
通过get()或load()方法得到的实例都是持久化状态的。
游离状态的实例可以通过调用 update()、0saveOrUpdate()、lock()或者replicate()进行持久化。
游离或者自由状态下的实例可以通过调用merge()方法成为一个新的持久化实例。

save()和persist()将会引发SQL的INSERT，delete()会引发SQLDELETE，而update()或merge()会引发SQLUPDATE。
对持久化（persistent）实例的修改在刷新提交的时候会被检测到，它也会引起SQLUPDATE。
saveOrUpdate()或者replicate()会引发SQLINSERT或者UPDATE。

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 sess = factory.openSession();
Transaction tx;
try {
tx = sess.beginTransaction();
//do some work
...
tx.commit();
}
catch (Exception e) {
if (tx!=null) tx.rollback();
throw e;
}
finally {
sess.close();
}

引用

save方法
public Serializable save(Object object)
                  throws HibernateException

Persist the given transient instance, first assigning a generated identifier.
(Or using the current value of the identifier property if the assigned generator is used.)
This operation cascades to associated instances if the association is mapped with cascade="save-update".
持久化指定的游离态对象，首先要分配一个自动生成的主键标示符。
(或者如果主键生成器正在使用，使用当前主键标示符属性值)
如果关联关系映射配置了cascade="save-update"属性，save操作对关联对象级联操作。
Parameters:
object - a transient instance of a persistent class
一个要持久化类的自由状态的实例对象
Returns:
the generated identifier
返回生成的主键标示符
Throws:
HibernateException

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. }

 public static void insertUser()
{
Session sess = HibernateSessionFactory.getSession();
User user = new User();
Transaction tx = null;
try
{
tx = sess.beginTransaction();
// do some work
user.setLogonName("关羽");
user.setNickName("关云长");
user.setPassword("1234");
sess.save(user);
tx.commit();
}
catch (Exception e)
{
if (tx != null)
tx.rollback();
}
finally
{
sess.close();
}
}

引用

/**
* Concrete implementation of a Session, and also the central, organizing component
* of Hibernate's internal implementation. As such, this class exposes two interfaces;
* Session itself, to the application, and SessionImplementor, to other components
* of Hibernate. This class is not threadsafe.
*
* @author Gavin King
*/
public final class SessionImpl extends AbstractSessionImpl
implements EventSource, org.hibernate.classic.Session, JDBCContext.Context {
//省略部分代码
// save() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public void save(Object obj, Serializable id) throws HibernateException {
save(null, obj, id);
}
public Serializable save(Object obj) throws HibernateException {
return save(null, obj);
}
public Serializable save(String entityName, Object object) throws HibernateException {
return fireSave( new SaveOrUpdateEvent(entityName, object, this) );
}
public void save(String entityName, Object object, Serializable id) throws HibernateException {
fireSave( new SaveOrUpdateEvent(entityName, object, id, this) );
}
private Serializable fireSave(SaveOrUpdateEvent event) {
errorIfClosed();
checkTransactionSynchStatus();
SaveOrUpdateEventListener[] saveEventListener = listeners.getSaveEventListeners();
for ( int i = 0; i < saveEventListener.length; i++ ) {
saveEventListener[i].onSaveOrUpdate(event);
}
return event.getResultId();
}
//省略部分代码
}

引用

请看进行了如下总结：
一、在session的内部缓存中寻找保存对象，如果找到了，则认为此数据已经保存（曾经执行过insert操作），实体对象已经处于persistent状态，直接返回。此时即使数据相比之前的状态发生了变化，也将在事务提交时由脏数据检查来判定是否需要执行update操作。

二、如果实体对象实现了lifecycle接口，那么将执行待保存对象的onSave()方法。

三、如果实体对象实现了Validatable接口，那么将会执行相应的validate()方法。

四、如果存在拦截器对象，那么将会执行Interceptor.onSave()方法。

五、构造insert SQL语句完成数据保存。

六、数据保存成功后，设定实体对象的id为插入记录的id。

七、将保存后的实体对象纳入Hibernate的内部缓存（一级缓存）。注意Hibernate不会把保存后的实体对象纳入二级缓存，因为刚刚保存过的实体对象很可能在之后被修改，缓存的频繁更新以及带来的同步问题代价，超出了缓存该对象所带来的收益。

八、如果关联关系映射配置了cascade="save-update"属性，save操作对关联对象级联操作。

引用

update方法
public void update(Object object)
            throws HibernateException

Update the persistent instance with the identifier of the given detached instance.
If there is a persistent instance with the same identifier, an exception is thrown.
This operation cascades to associated instances if the association is mapped with cascade="save-update".
使用给定的游离状态对象的主键标示符来更新持久化状态实例对象。
如果存在相同主键标示符的持久化状态对象，抛出异常。
如果关联关系映射配置了cascade="save-update"属性，update操作对关联对象级联操作。

Parameters:
object - a detached instance containing updated state
包含了要更新状态的游离状态对象
Throws:
HibernateException

引用

/**
* Concrete implementation of a Session, and also the central, organizing component
* of Hibernate's internal implementation. As such, this class exposes two interfaces;
* Session itself, to the application, and SessionImplementor, to other components
* of Hibernate. This class is not threadsafe.
*
* @author Gavin King
*/
public final class SessionImpl extends AbstractSessionImpl
implements EventSource, org.hibernate.classic.Session, JDBCContext.Context {
//省略部分代码
// update() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public void update(Object obj) throws HibernateException {
update(null, obj);
}
public void update(Object obj, Serializable id) throws HibernateException {
update(null, obj, id);
}
public void update(String entityName, Object object) throws HibernateException {
fireUpdate( new SaveOrUpdateEvent(entityName, object, this) );
}
public void update(String entityName, Object object, Serializable id) throws HibernateException {
fireUpdate(new SaveOrUpdateEvent(entityName, object, id, this));
}
private void fireUpdate(SaveOrUpdateEvent event) {
errorIfClosed();
checkTransactionSynchStatus();
SaveOrUpdateEventListener[] updateEventListener = listeners.getUpdateEventListeners();
for ( int i = 0; i < updateEventListener.length; i++ ) {
updateEventListener[i].onSaveOrUpdate(event);
}
}
//省略部分代码
}

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. // 又开启一个新的session
16. Session session2=sf.openSession();
17. Transaction tx2=session2.beginTransaction();
18. //通过调用update()方法将游离状态的customer对象，再次转化成持久化状态
19. session2.update(customer);
20. //调用delete()方法后，当清空缓存时，会将customer对象移出缓存，同时会在数据库中生成delete事务，来删除customer对象对应的数据记录
21. session2.delete(customer);
22. tx.commit();
23. session.close();

Configuration cfg = new Configuration();
SessionFactory sf=cfg. configure().buildSessionFactory();
Customer customer=new Customer("关羽",27);//customer对象处于自由状态
Session session=sf.openSession();
// 开启事务
Transaction tx=session.beginTransaction();
//保存后customer对象处于持久化状态
session.save(customer);
//清空缓存后customer对象处于游离状态
session.flush();
// 提交事务
tx.commit();
//session关闭
session.close();
// 又开启一个新的session
Session session2=sf.openSession();
Transaction tx2=session2.beginTransaction();
//通过调用update()方法将游离状态的customer对象，再次转化成持久化状态
session2.update(customer);
//调用delete()方法后，当清空缓存时，会将customer对象移出缓存，同时会在数据库中生成delete事务，来删除customer对象对应的数据记录
session2.delete(customer);
tx.commit();
session.close();

引用

控制台查看Hibernate生成的sql语句如下：
Hibernate: select user0_.id as id0_0_, user0_.logon_name as logon2_0_0_, user0_.nick_name as nick3_0_0_, user0_.password as password0_0_ from logon_user user0_ where user0_.id=?
Hibernate: update logon_user set logon_name=?, nick_name=?, password=? where id=?

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

Transaction tx=session.beginTransaction();
session.update(customer);
tx.commit();
session.close();

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. Session session2=sf.openSession();
11. Transaction tx2=session2.beginTransaction();
12. Customer othercustomer=(Customer)session2.load(Customer.class,"1");
13. //通过调用update()方法将游离状态的customer1对象，再次转化成持久化状态
14. session2.update(customer1)
15. tx2.commit();
16. session2.close();

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

引用

load方法
public void load(Object object,
                 Serializable id)
          throws HibernateException

Read the persistent state associated with the given identifier into the given transient instance.
读取和给定的主键标示符关联的持久化状态到给定的自由状态的实例对象。
Parameters:
object - an "empty" instance of the persistent class
id - a valid identifier of an existing persistent instance of the class
object - 一个持久化类的空对象
id - 一个已经存在的持久化实例对象的有效的主键标示符
Throws:
HibernateException

引用

get和load方法的区别？
get和load方式是根据id取得一个记录
下边详细说一下get和load的不同，因为有些时候为了对比也会把find加进来。

1.从返回结果上对比：
load方式检索不到的话会抛出org.hibernate.ObjectNotFoundException异常
get方法检索不到的话会返回null

2.从检索执行机制上对比：
get方法和find方法都是直接从数据库中检索
而load方法的执行则比较复杂
■ 首先查找session的persistent Context中是否有缓存，如果有则直接返回
■ 如果没有则判断是否是lazy，如果不是直接访问数据库检索，查到记录返回，查不到抛出异常
■ 如果是lazy则需要建立代理对象，对象的initialized属性为false，target属性为null
■ 在访问获得的代理对象的属性时,检索数据库，如果找到记录则把该记录的对象复制到代理对象的target上，并将initialized=true，如果找不到就抛出异常 。

3.根本区别说明
■ 如果你使用load方法，hibernate认为该id对应的对象（数据库记录）在数据库中是一定存在的，所以它可以放心的使用，它可以放心的使用代理来延迟加载该对象。在用到对象中的其他属性数据时才查询数据库，但是万一数据库中不存在该记录，那没办法，只能抛异常。所说的load方法抛异常是指在使用该对象的数据时，数据库中不存在该数据时抛异常，而不是在创建这个对象时(注意：这就是由于“延迟加载”在作怪)。

由于session中的缓存对于hibernate来说是个相当廉价的资源，所以在load时会先查一下session缓存看看该id对应的对象是否存在，不存在则创建代理。所以如果你知道该id在数据库中一定有对应记录存在就可以使用load方法来实现延迟加载。

■ 对于get方法，hibernate会确认一下该id对应的数据是否存在，首先在session缓存中查找，然后在二级缓存中查找，还没有就查数据库，数据库中没有就返回null。

对于load和get方法返回类型：虽然好多书中都这么说：“get()永远只返回实体类”，但实际上这是不正确的，get方法如果在session缓存中找到了该id对应的对象，如果刚好该对象前面是被代理过的，如被load方法使用过，或者被其他关联对象延迟加载过，那么返回的还是原先的代理对象，而不是实体类对象，如果该代理对象还没有加载实体数据（就是id以外的其他属性数据），那么它会查询二级缓存或者数据库来加载数据，但是返回的还是代理对象，只不过已经加载了实体数据。

get方法首先查询session缓存，没有的话查询二级缓存，最后查询数据库；反而load方法创建时首先查询session缓存，没有就创建代理，实际使用数据时才查询二级缓存和数据库。

4.简单总结

总之对于get和load的根本区别，一句话，hibernate对于load方法认为该数据在数据库中一定存在，可以放心的使用代理来延迟加载，如果在使用过程中发现了问题，只能抛异常；而对于get方法，hibernate一定要获取到真实的数据，否则返回null。

引用

saveOrUpdate方法

public void saveOrUpdate(Object object)
                  throws HibernateException
Either save(Object) or update(Object) the given instance, depending upon resolution of the unsaved-value checks (see the manual for discussion of unsaved-value checking).
This operation cascades to associated instances if the association is mapped with cascade="save-update".
可能对给定的实例对象执行save或者update方法，如果关联关系映射配置了cascade="save-update"属性，update操作对关联对象级联操作。

Parameters:
object - a transient or detached instance containing new or updated state
object - 包含新的或者已更新状态的自由态或者是游离态的
对象实例
Throws:
HibernateException
See Also:
save(Object), update(Object)

引用

/**
* Concrete implementation of a Session, and also the central, organizing component
* of Hibernate's internal implementation. As such, this class exposes two interfaces;
* Session itself, to the application, and SessionImplementor, to other components
* of Hibernate. This class is not threadsafe.
*
* @author Gavin King
*/
public final class SessionImpl extends AbstractSessionImpl
implements EventSource, org.hibernate.classic.Session, JDBCContext.Context {
//省略部分代码
// saveOrUpdate() operations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public void saveOrUpdate(Object object) throws HibernateException {
saveOrUpdate(null, object);
}
public void saveOrUpdate(String entityName, Object obj) throws HibernateException {
fireSaveOrUpdate( new SaveOrUpdateEvent(entityName, obj, this) );
}
private void fireSaveOrUpdate(SaveOrUpdateEvent event) {
errorIfClosed();
checkTransactionSynchStatus();
SaveOrUpdateEventListener[] saveOrUpdateEventListener = listeners.getSaveOrUpdateEventListeners();
for ( int i = 0; i < saveOrUpdateEventListener.length; i++ ) {
saveOrUpdateEventListener[i].onSaveOrUpdate(event);
}
}
//省略部分代码
}

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

public class DefaultSaveOrUpdateEventListener extends AbstractSaveEventListener implements SaveOrUpdateEventListener {
private static final Log log = LogFactory.getLog( DefaultSaveOrUpdateEventListener.class );
/**
* Handle the given update event.
*
* @param event The update event to be handled.
*/
public void onSaveOrUpdate(SaveOrUpdateEvent event) {
final SessionImplementor source = event.getSession();
final Object object = event.getObject();
final Serializable requestedId = event.getRequestedId();
if ( requestedId != null ) {
//assign the requested id to the proxy, *before*
//reassociating the proxy
if ( object instanceof HibernateProxy ) {
( ( HibernateProxy ) object ).getHibernateLazyInitializer().setIdentifier( requestedId );
}
}
if ( reassociateIfUninitializedProxy( object, source ) ) {
log.trace( "reassociated uninitialized proxy" );
// an uninitialized proxy, noop, don't even need to
// return an id, since it is never a save()
}
else {
//initialize properties of the event:
final Object entity = source.getPersistenceContext().unproxyAndReassociate( object );
event.setEntity( entity );
event.setEntry( source.getPersistenceContext().getEntry( entity ) );
//return the id in the event object
event.setResultId( performSaveOrUpdate( event ) );
}
}
// 省略部分代码... ...
}

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

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