hibernate的三种状态
转载:https://www.cnblogs.com/xiaoluo501395377/p/3380270.html
瞬时状态: 刚new出来一个对象，对象在session和数据库中都不存在的状态
持久化状态: 对象在session和数据库中都存在的状态
游离状态: 对象在session中不存在,但在数据库中存在的状态
1.游离态转变为持久态
session = HibernateUtil.openSession(); session.beginTransaction(); User user = new User(); user.setUsername("aaa"); user.setPassword("aaa"); user.setBorn(new Date()); /* * 以上user就是一个Transient(瞬时状态),此时user并没有被session进行托管，即在session的 * 缓存中还不存在user这个对象，当执行完save方法后，此时user被session托管，并且数据库中存在了该对象 * user就变成了一个Persistent(持久化对象) */ session.save(user); session.getTransaction().commit();
此时我们知道hibernate会发出一条insert的语句，执行完save方法后，该user对象就变成了持久化的对象了
Hibernate: insert into t_user (born, password, username) values (?, ?, ?)
2.修改持久态属性,提交事务后发出对应SQL
session = HibernateUtil.openSession(); session.beginTransaction(); User user = new User(); user.setUsername("aaa"); user.setPassword("aaa"); user.setBorn(new Date()); //以上u就是Transient（瞬时状态），表示没有被session管理并且数据库中没有 //执行save之后，被session所管理，而且，数据库中已经存在，此时就是Persistent状态 session.save(user); //此时u是持久化状态，已经被session所管理，当在提交时，会把session中的对象和目前的对象进行比较 //如果两个对象中的值不一致就会继续发出相应的sql语句 user.setPassword("bbb"); //此时会发出2条sql，一条用户做插入，一条用来做更新 session.getTransaction().commit();
在调用了save方法后，此时user已经是持久化对象了，被保存在了session缓存当中，这时user又重新修改了属性值，那么在提交事务时，此时hibernate对象就会拿当前这个user对象和保存在session缓存中的user对象进行比较，如果两个对象相同，则不会发送update语句，否则，如果两个对象不同，则会发出update语句。
Hibernate: insert into t_user (born, password, username) values (?, ?, ?) Hibernate: update t_user set born=?, password=?, username=? where id=?
3.在事务中持久态被修改多次,且调用save,update方法
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); session = HibernateUtil.openSession(); session.beginTransaction(); User u = new User(); u.setBorn(new Date()); u.setUsername("zhangsan"); u.setPassword("zhangsan"); session.save(u); u.setPassword("222"); //该条语句没有意义 session.save(u); u.setPassword("zhangsan111"); //没有意义 session.update(u); u.setBorn(sdf.parse("1988-12-22")); //没有意义 session.update(u); session.getTransaction().commit();
在调用save方法后，u此时已经是持久化对象了，记住一点：如果一个对象以及是持久化状态了，那么此时对该对象进行各种修改，或者调用多次update、save方法时，hibernate都不会发送sql语句，只有当事物提交的时候，此时hibernate才会拿当前这个对象与之前保存在session中的持久化对象进行比较，如果不相同就发送一条update的sql语句，否则就不会发送update语句
Hibernate: insert into t_user (born, password, username) values (?, ?, ?) Hibernate: update t_user set born=?, password=?, username=? where id=?
4.当数据库已有对象被取出,该取出对象为持久态
session = HibernateUtil.openSession(); session.beginTransaction(); //此时u是Persistent User u = (User)session.load(User.class, 4); //由于u这个对象和session中的对象不一致，所以会发出sql完成更新 u.setUsername("bbb"); session.getTransaction().commit();
记住一点：当session调用load、get方法时，此时如果数据库中有该对象，则该对象也变成了一个持久化对象，被session所托管。因此，这个时候如果对对象进行操作，在提交事务时同样会去与session中的持久化对象进行比较，因此这里会发送两条sql语句
Hibernate: select user0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_, user0_.username as username0_0_ from t_user user0_ where user0_.id=? Hibernate: update t_user set born=?, password=?, username=? where id=?
5.调用clear方法清空session缓存对象
session = HibernateUtil.openSession(); session.beginTransaction(); //此时u是Persistent User u = (User)session.load(User.class, 4); u.setUsername("123"); //清空session session.clear(); session.getTransaction().commit();
当我们load出user对象时，此时user是持久化的对象，在session缓存中存在该对象，此时我们在对user进行修改后，然后调用session.clear()方法，这个时候就会将session的缓存对象清空，那么session中就没有了user这个对象，这个时候在提交事务的时候，发现已经session中已经没有该对象了，所以就不会进行任何操作，因此这里只会发送一条select语句
Hibernate: select user0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_, user0_.username as username0_0_ from t_user user0_ where user0_.id=?
6.游离态的变为持久态,应使用update方法
session = HibernateUtil.openSession(); session.beginTransaction(); //此时u是一个离线对象，没有被session托管 User u = new User(); u.setId(4); u.setPassword("hahahaha"); //当执行save的时候总是会添加一条数据，此时id就会根据Hibernate所定义的规则来生成 session.save(u); session.getTransaction().commit();
当调用了u.setId(4)时，此时u是一个离线的对象，因为数据库中存在id=4的这个对象，但是该对象又没有被session所托管，所以这个对象就是离线的对象，要使离线对象变成一个持久化的对象，应该调用什么方法呢？我们知道调用save方法，可以将一个对象变成一个持久化对象，但是，当save一执行的时候，此时hibernate会根据id的生成策略往数据库中再插入一条数据，所以如果调用save方法，此时数据库会发送一条插入的语句：
Hibernate: insert into t_user (born, password, username) values (?, ?, ?)
所以对于离线对象，如果要使其变成持久化对象的话，我们不能使用save方法，而应该使用update方法
7.不能修改持久态主键,修改后会报异常
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); session = HibernateUtil.openSession(); session.beginTransaction(); User u = new User(); u.setId(5); //完成update之后也会变成持久化状态 session.update(u); u.setBorn(sdf.parse("1998-12-22")); u.setPassword("lisi"); u.setUsername("lisi"); //会抛出异常 u.setId(333); session.getTransaction().commit();
调用update方法后，user变成了一个持久化对象，在对user进行一些修改后，此时又通过 u.setId(333)方法设置了u的ID，那么这个时候，hibernate会报错，因为我们的u当前已经是一个持久化对象，如果试图修改一个持久化对象的ID的值的话，就会抛出异常.
org.hibernate.HibernateException: identifier of an instance of com.xiaoluo.bean.User was altered from 5 to 333
8.用delete方法将持久态,游离态转变为临时态
session = HibernateUtil.openSession(); session.beginTransaction(); User u = new User(); u.setId(5); //现在u就是transient对象 session.delete(u); //此时u已经是瞬时对象，不会被session和数据库所管理 u.setPassword("wangwu"); session.getTransaction().commit();
这里在调用了session.delete()方法以后，此时后u就会变成一个瞬时对象，因为此时数据库中已经不存在该对象了，既然u已经是一个瞬时对象了，那么对u再进行各种修改操作的话，hibernate也不会发送任何的修改语句，因此这里只会 有一条 delete的语句发生：
Hibernate: delete from t_user where id=?
9.saveOrUpdate方法将游离态或临时态转变为持久态
session = HibernateUtil.openSession(); session.beginTransaction(); User u = new User(); u.setId(4); u.setPassword("zhaoliu"); //如果u是离线状态就执行update操作，如果是瞬时状态就执行Save操作 //但是注意：编程中不建议使用这种模棱两可的方法 session.saveOrUpdate(u); session.getTransaction().commit();
saveOrUpdate这个方法其实是一个"偷懒"的方法，如果对象是一个离线对象，那么在执行这个方法后，其实是调用了update方法，如果对象是一个瞬时对象，则会调用save方法，记住：如果对象设置了ID值，例如u.setId(4)，那么该对象会被假设当作一个离线对象，此时就会执行update操作。
Hibernate: update t_user set born=?, password=?, username=? where id=?
如果此时我将u.setId(4)这句话注释掉，那么此时u就是一个瞬时的对象，那么此时就会执行save操作，就会发送一条insert语句
Hibernate: insert into t_user (born, password, username) values (?, ?, ?)
