解决a different object with the same identifier value was already associated with the session错误

项目中提交订单后，并确认订单时，报错了。

先判断订单的状态是否已取消，如果已取消，直接返回。如果没有取消，则更新订单的状态。上代码

POrderEntity pOrder = this.getEntity(POrderEntity.class, pOrderEntity.getId());//第一步.获取订单状态
  if(pOrder.getOrderStatus().trim().equals("已取消")){
  throw new BusinessException("该订单已取消，无法确认订单!");
  }
  //解决a different object with the same identifier value was already associated with the session错误
  this.getSession().clear();

。。。。。。

//保存各种信息
pOrderEntity.setMoney(moneyNew);
// 更新处理时间
pOrderEntity.setHandleTime(new Date());
// 更新订单状态为已确认
pOrderEntity.setOrderStatus(IOrderServiceI.ORDER_STATUS_FINISH);
this.saveOrUpdate(pOrderEntity);//第二步.更新订单状态信息

在第二步hibernate的saveOrUpdate的时候出错了a different object with the same identifier value was already associated with the session

在第一步完成后，添加this.getSession().clear();好了。这里用flush不行

首先session是有一级缓存的，目的是为了减少查询数据库的时间，提高效率，一级缓存的生命周期和session是一样的，

session.flush()和session.clear()就针对session的一级缓存的处理。

   简单的说，

1 session.flush()的作用就是将session的缓存中的数据与数据库同步。

2 session.clear()的作用就是清除session中的缓存数据（不管缓存与数据库的同步）。

session.clear()的作用是只清除session中的缓存数据，但不管缓存与数据库的同步。

比如，你执行了

Po po = new Po();

session.save(po),

之后马上执行session.clear()，在事务结束的时候，这条数据是不会被持久化到数据库中的，因为一般缓存是在事务提交的时候进行清理的，当在清理缓存前就把缓存给清除了，自然就不会同步到数据库了。不过这个也有例外的情况，就是当对象使用native生成器来生成主键id时，当执行session.save()方法时,就会立马往数据库插入一条数据，这时候执行session.clear()也不会影响了。

1.Clear 方法
  无论是Load 还是 Get 都会首先查找缓存（一级缓存） 如果没有，才会去数据库查找，调用Clear() 方法，可以强制清除Session缓存。

 

例：

 

[java]  view plain copy

1. public void testClear(){  
2.         Session session =  HibernateUitl.getSessionFactory().getCurrentSession();  
3.         session.beginTransaction();  
4.         Teacher t = (Teacher) session.get(Teacher.class, 3);  
5.         System.out.println(t.getName());  
6.         Teacher t2 = (Teacher) session.get(Teacher.class, 3);  
7.         System.out.println(t2.getName());  
8.         session.getTransaction().commit();  
9.     }  

 

 

这里虽然用了2个get方法（get方法会立即执行sql语句），但因为第一次执行了会缓存一个ID为3的实体，所以虽然有2个get方法只执行一次SQL语句。

 

[java]  view plain copy

1. public void testClear(){  
2.         Session session =  HibernateUitl.getSessionFactory().getCurrentSession();  
3.         session.beginTransaction();  
4.         Teacher t = (Teacher) session.get(Teacher.class, 3);  
5.         System.out.println(t.getName());  
6.         session.clear();//这里不clear只会执行一次sql语句，有clear会执行2次  
7.         Teacher t2 = (Teacher) session.get(Teacher.class, 3);  
8.         System.out.println(t2.getName());  
9.         session.getTransaction().commit();  
10.     }  

 

这里在第2次get前执行session.clear(),我们把hibernate show_sql 出来，它就会执行2次sql语句了。

 

所以session.clear()会清除缓存。

2 当更新或者保存大批量数据的时候，可以每固定数量的时候，进行清理缓存，同时清除缓存：

for (int i = 0; i < 1000;i ++){

if (i /20 == 0) {

  session.flush();

  session.clear();

}

}

因为把大量的对象放到session缓存中会浪费大量的内容空间。

3 执行完session.flush()时，并不意味着数据就肯定持久化到数据库中的，因为事务控制着数据库，如果事务提交失败了，缓存中的数据还是照样会被回滚的。

2.Flush方法
  可以强制进行从内存到数据库的同步。

 

例：

 

[java]  view plain copy

1. @Test  
2.       
3.     public void testFlush(){  
4.         Session session =  HibernateUitl.getSessionFactory().getCurrentSession();  
5.         session.beginTransaction();  
6.         Teacher t = (Teacher) session.get(Teacher.class, 3);  
7.         t.setName("yyy");  
8.    
9.         t.setName("yyyyy");  
10.         session.getTransaction().commit();  
11.     }  

 

 

看这段代码，我们setName() 2次， 但程序只会更改数据库一次，在commit时。

 

[java]  view plain copy

1. @Test  
2.       
3.     public void testFlush(){  
4.         Session session =  HibernateUitl.getSessionFactory().getCurrentSession();  
5.         session.beginTransaction();  
6.         Teacher t = (Teacher) session.get(Teacher.class, 3);  
7.         t.setName("yyy");  
8.         session.flush();//有flush会执行2次UPDAE,没有会只执行一次  
9.         t.setName("yyyyy");  
10.         session.getTransaction().commit();  
11.     }  

 

 

 

我们在第2次setName（）时 执行session.flush().

 

再看hibernate 执行的sql 语句

 

[java]  view plain copy

1. Hibernate:   
2.     update  
3.         Teacher   
4.     set  
5.         birthday=?,  
6.         name=?,  
7.         title=?   
8.     where  
9.         id=?  
10. Hibernate:   
11.     update  
12.         Teacher   
13.     set  
14.         birthday=?,  
15.         name=?,  
16.         title=?   
17.     where  
18.         id=?  

 

执行了2次Update

 

所以看出来flush方法会强制与数据库同步。

Flush方法是可以设置的，也就是fulsh什么时候执行是可以设置的

 

 在session.beginTransaction前设置FlushMode

 

session.setFlushMode(FlushMode.Always|AUTO|COMMIT|NEVER|MANUAL)

 

FlushMode有5个值可选

Always:任何代码都会Flush
AUTO:默认方式–自动
Commit:COMMIT时
Never:始终不
MANUAL:手动方式

 

触发场景，解决方案：
1. show业务操作，开启一个session ，从中查出一些实体，这时某个实体是存在于session中的持久化对象。通过业务逻辑将此实体用于页面展示。此时这个session并未关闭。

2. 这时执行一步save业务逻辑，将上一步获得的实体id传回后台 。这时通过new的方式创建了一个临时对象，并且我将传回的id作为主键赋值给了临时对象。然后调用了session.save(obj); 方法 。。。抛出异常。

原因很简单，session中有2个oid一样的对象，hibernate不知道该让哪个持久化到库里。当时解决思路也很清晰，直接clear();清空一下 session缓存不就Ok了。但是clear打击面太广了（慎用！）。其他一些“无辜”对象也被杀掉，导致其他业务无法进行了。

后来在session中发现一个evict方法，“定点清除”对象缓存。这下就好了，先用传回来的id用get方法（其实这里用load方法也行反正都是从缓存中加载）获得session里的持久化实体，然后杀掉，再保存临时实体。没问题了。

 

设置FlushMode 有个好处是可以节省开销，比如默认session只做查询时，就可以不让他与数据库同步了。

session.evict(obj)，会把指定的缓冲对象进行清除
session.clear()，把缓冲区内的全部对象清除，但不包括操作中的对象