一.Hibernate 的三种实体状态
Hibernate有三种实体状态，有瞬时态(transiant),持久态(persistent),游离态(detached)。 简单理解就是,瞬时态指的是刚New 新建的一个对象，没有放在Session时，也没有存储在数据库中。 持久态，指这个对象存储在数据库中，并且存在于Session会话中。 而游离态指的是，这个对象存储在数据库中，但已经不存在于Session会话中。下面是比较官方的说法：
二. 实体状态的简单举例
仍然采用上一章的例子。不会的，可以观看上一章。
/*
* 简单举例，三种状态，瞬时态，持久态，游离态的相关说明。
*/
@Test
public void testA(){
Session session=HibernateUtil.getSession();
Transaction transaction=session.beginTransaction();
User user=new User(); //是瞬时态
user.setUserName("两个蝴蝶飞");//瞬时态
user.setAge(24);
user.setSex("男");
user.setDescription("一个迷途知返的程序员"); //瞬时态
session.save(user); //session方法之后,user就是持久态
transaction.commit();
System.out.println("持久态描述为:"+user.getDescription());//持久态
session.close(); //关闭会话后 user就是游离态
System.out.println("游离态描述:"+user.getDescription());//游离态
}
运行之后，控制台输出:
在数据库中会相应存储这条数据.
三. 三种状态的相互转换
三种状态可以相互进行转换，其中关系图如下:
其中文字描述简单理解就是:
- 瞬时态转换成持久态可以通过: Session的 save()或者saveOrUpdate()方法。
- 持久态转换成瞬时态可以通过: Session的delete()方法。持久态转换成瞬时态可以通过: Session的delete()方法。
session.delete(user); //以前，这种叫做删除态。也是网上看到的第四种状态.
// 虽然这种状态也可以取出属性，但不建议使用。逻辑上是不通的
System.out.println("瞬时态对象名称:"+user.getUserName());
- 持久态转换成游离态: 可以通过 close(), clear() 和evict() 方法。
session.close(); //关闭会话后 user就是游离态
session.clear(); //清理
session.evict(user); //驱逐
- 游离态转换成持久态: 可以通过update(); saveOrUpdate()和lock()方法。lock()是加锁的方法.
- 瞬时态转换成游离态: 加上标识符即可
User user=new User(); //瞬时态
user.setId(1); // 游离态
user.setUserName("两个蝴蝶飞"); //游离态
- 游离态转换成瞬时态:delete()方法 或者去除标识符。
去除标识符，即user.setId(null); 即可。这也是要让实体类中属性设置成包装类的其中一个小原因。
四. 瞬时态的深入理解
/*
* 瞬时态 transient 的深入理解
*/
@Test
public void testB(){
Session session=HibernateUtil.getSession();
Transaction transaction=session.beginTransaction();
User user=new User(); //是瞬时态
user.setUserName("两个蝴蝶飞");//瞬时态
user.setAge(24);
user.setSex("男");
user.setDescription("一个迷途知返的程序员"); //瞬时态
session.save(user); //session方法之后,user就是持久态
transaction.commit();
}
通过save()方法，将瞬时态转换成持久态。
五. 持久态的深入理解
五.一 持久态之后继续追加数据
/*
* 将对象变成持久态之后，继续追加数据
*/
@Test
public void testPersistent1(){
Session session=HibernateUtil.getSession();
Transaction transaction=session.beginTransaction();
User user=new User(); //是瞬时态
user.setUserName("两个蝴蝶飞");//瞬时态
user.setAge(24);
user.setSex("男");
user.setDescription("一个迷途知返的程序员"); //瞬时态
session.save(user); //session方法之后,user就是持久态
user.setPassword("1234"); //继续追加数据
transaction.commit();
}
查看Sql语句为:
先进行插入，后进行更新操作。 实际上，数据库中只生成了一条数据。
如果追加的数据是相同的数据，即:
@Test
public void testPersistent1(){
Session session=HibernateUtil.getSession();
Transaction transaction=session.beginTransaction();
User user=new User(); //是瞬时态
user.setUserName("两个蝴蝶飞");//瞬时态
user.setAge(24);
user.setSex("男");
user.setDescription("一个迷途知返的程序员"); //瞬时态
session.save(user); //session方法之后,user就是持久态
//user.setPassword("1234"); //继续追加数据
user.setAge(24); //设置相同的值
transaction.commit();
}
那么此时，只插入，并不会更新.
如果一个对象以及是持久化状态了，那么此时对该对象进行各种修改，或者调用多次update、save方法时，hibernate都不会发送sql语句，只有当事物提交的时候，此时hibernate才会拿当前这个对象与之前保存在session中的持久化对象进行比较，如果不相同就发送一条update的sql语句，否则就不会发送update语句。
五.二 提交后进行修改
/*
* 提交后，进行修改,也同样只会执行一条inset 语句
*/
@Test
public void testPersistent2(){
Session session=HibernateUtil.getSession();
Transaction transaction=session.beginTransaction();
User user=new User(); //是瞬时态
user.setUserName("两个蝴蝶飞");//瞬时态
user.setAge(24);
user.setSex("男");
user.setDescription("一个迷途知返的程序员"); //瞬时态
session.save(user); //session方法之后,user就是持久态
transaction.commit(); //先进行提交
user.setAge(24); //设置相同的值
transaction.commit();//再次进行提交
}
仍然只执行一条insert 语句。
如果此时关闭Session了呢?
@Test
public void testPersistent2(){
Session session=HibernateUtil.getSession();
Transaction transaction=session.beginTransaction();
User user=new User(); //是瞬时态
user.setUserName("两个蝴蝶飞");//瞬时态
user.setAge(24);
user.setSex("男");
user.setDescription("一个迷途知返的程序员"); //瞬时态
session.save(user); //session方法之后,user就是持久态
transaction.commit(); //先进行提交
session.close(); //clear() 也是执行一条insert 语句
Session session1=HibernateUtil.getSession();
Transaction transaction1=session1.beginTransaction();
user.setAge(24); //设置相同的值
transaction1.commit();//再次进行提交
}
仍然会执行一条insert 语句。 这就是一级缓存的作用。
五.三 查询后修改
/*
* 先查询，后进行修改
*/
@Test
public void testPersistent3(){
Session session=HibernateUtil.getSession();
Transaction transaction=session.beginTransaction();
User user=session.get(User.class,4);
user.setAge(25); //设置不同值时 一条select,一条update
//user.setAge(24); //设置相同的值 只有一条select
transaction.commit();//再次进行提交
}
如果查询的值，即get(User.class,1000) 不存在时，会报空指针的错误. NullPointerException 。
如果设置的是不同的值，原先是24,那么会执行两种条件。一种是查询语句，另外一条是修改udpate 语句。
如果设置的是相同值，那么只执行一条select 查询语句。
五.四 先清空，后提交
@Test
public void testPersistent4(){
Session session=HibernateUtil.getSession();
Transaction transaction=session.beginTransaction();
User user=session.get(User.class,4);
user.setAge(25); //设置不同值时
session.clear(); //close()时也同样效果
transaction.commit();//再次进行提交
}
只执行一条查询语句.
当我们get出user对象时，此时user是持久化的对象，在session缓存中存在该对象，此时我们在对user进行修改后，然后调用session.clear()方法，这个时候就会将session的缓存对象清空，那么session中就没有了user这个对象，这个时候在提交事务的时候，发现已经session中已经没有该对象了，所以就不会进行任何操作，因此这里只会发送一条select语句。
六. 游离态对象的深入理解
六.一 save()对象并不能将其变成持久态
@Test
public void testDetached1(){
Session session=HibernateUtil.getSession();
Transaction transaction=session.beginTransaction();
User user=new User();
user.setId(24); //不存在24时，为一条插入语句
//user.setId(5); //存在5时，为一条插入语句
//user.setId(50) //很远的值
user.setUserName("测试游离态对象123");
session.save(user);
transaction.commit();//再次进行提交
}
此时，当设置了id的值之后，就变成了游离态对象了。此时，调用save()方法时，无论id设置了多少，无论是24(接下来的值),5(已经存在的值),50(离很远的值),此时save()保存的值，都是会按照顺序进行排序的，即
是自定义的规则 ，即依次递增。并不是我们自己setId()的这个值。
只执行一条插入语句。
六.二 执行update()语句
@Test
public void testDetached2(){
Session session=HibernateUtil.getSession();
Transaction transaction=session.beginTransaction();
User user=new User();
user.setId(5); //存在时，为一条插入语句
//user.setId(50) ;// 不存在这条数据
user.setUserName("测试游离态对象123");
session.update(user); //变成了持久态对象
user.setDescription("游离态对象的测试123");
transaction.commit();//再次进行提交
}
这里会执行一条update 语句.
修改的，正是那条id=5的数据。
如果此时，设置的id并不存在的话。即
user.setId(50) //不存在这个id,会抛出异常
六.三 修改Id编号
@Test
public void testDetached3(){
Session session=HibernateUtil.getSession();
Transaction transaction=session.beginTransaction();
User user=new User();
user.setId(5);
user.setUserName("测试游离态对象123");
session.update(user); //变成了持久态对象
user.setDescription("游离态对象的测试123");
user.setId(50); //修改id编号 抛出异常
transaction.commit();//再次进行提交
}
会抛出异常:
HHH000346: Error during managed flush [org.hibernate.HibernateException: identifier of an instance of com.yjl.pojo.User was altered from 5 to 50]
六.四 修改删除的对象
@Test
public void testDetached4(){
Session session=HibernateUtil.getSession();
Transaction transaction=session.beginTransaction();
User user=new User();
user.setId(5);
session.delete(user);
user.setUserName("测试游离态对象删除123");
user.setDescription("游离态对象的测试删除123");
transaction.commit();//再次进行提交
}
会执行删除语句:
六.五 存在两个相同标识符的对象
@Test
public void testDetached5(){
Session session=HibernateUtil.getSession();
Transaction transaction=session.beginTransaction();
User user1=session.get(User.class,6);
User user2=new User();
user2.setId(6);
user2.setDescription("两个相同的id");
session.update(user2);
//session.merge(user2); // 应该使用merge()方法
transaction.commit();//再次进行提交
}
此时 ，会抛出异常
应该调用merge()方法.这个方法的作用就是解决一个持久化对象两分拷贝的问题，这个方法会将两个对象合并在一起成为一个对象。
原先的数据会被更新，换成新的数据。
谢谢!!!