Hibernate学习之hibernate状态

hibernate有三种状态，transient(瞬时状态)，persistent(持久化状态)以及detached(离线状态)，瞬时状态就是刚new出来一个对象，还没有被保存到数据库中，持久化状态就是已经被保存到数据库中，离线状态就是数据库中有，但是session中不存在该对象。

 1             session = HibernateUtil.openSession();
 2             session.beginTransaction();
 3             Person person = new Person();
 4             person.setName("sunfei");
 5             /*
 6              *  以上person就是一个Transient(瞬时状态),此时person并没有被session进行托管，即在session的
 7              *  缓存中还不存在person这个对象，当执行完save方法后，此时person被session托管，并且数据库中存在了该对象
 8              *  person就变成了一个Persistent(持久化对象)
 9              */
10             session.save(person);
11             session.getTransaction().commit();
12             session.close();

hibernate会发出一条insert的语句，执行完save方法后，该person对象就变成了持久化的对象了,被保存在了session缓存当中，如果在save方法后重新进行update操作，这时person又重新修改了属性值，那么在提交事务时，此时hibernate对象就会拿当前这个person对象和保存在session缓存中的person对象进行比较，如果两个对象相同，则不会发送update语句，否则，如果两个对象不同，则会发出update语句。

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");session = HibernateUtil.openSession();session.beginTransaction();Person u = new Person();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语句.

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");session = HibernateUtil.openSession();session.beginTransaction();Person u = new Person();u.setBorn(sdf.parse("1976-2-3"));u.setUsername("zhangsan2");u.setPassword("zhangsan2");session.save(u);/** 以下三条语句没有任何意义*/session.save(u);session.update(u);session.update(u);u.setUsername("zhangsan3");session.getTransaction().commit();

此时hibernate也会发出两条sql语句，原理和上面一样

1             session = HibernateUtil.openSession();
2             session.beginTransaction();
3             //此时u是Persistent(持久化状态)
4             Person u = (Person)session.load(Person.class, 4);
5             //由于u这个对象和session中的对象不一致，所以会发出sql完成更新
6             u.setUsername("bbb");
7             session.getTransaction().commit();

同样记住一点：当session调用load、get方法时，此时如果数据库中有该对象，则该对象也变成了一个持久化对象，被session所托管。因此，这个时候如果对对象进行操作，在提交事务时同样会去与session中的持久化对象进行比较，因此这里会发送两条sql语句.

            session.beginTransaction();//此时u是PersistentPerson u = (Person)session.load(Person.class, 4);u.setUsername("123");//清空session
            session.clear();session.getTransaction().commit();

当我们load出user对象时，此时Person是持久化的对象，在session缓存中存在该对象，此时我们在对Person进行修改后，然后调用session.clear()方法，这个时候就会将session的缓存对象清空，那么session中就没有了Person这个对象，这个时候在提交事务的时候，发现已经session中已经没有该对象了，所以就不会进行任何操作，因此这里只会发送一条select语句

1             session.beginTransaction();
2             //此时u是一个离线对象，没有被session托管
3             Person u = new Person();
4             u.setId(4);
5             u.setPassword("hahahaha");
6             //当执行save的时候总是会添加一条数据，此时id就会根据Hibernate所定义的规则来生成
7             session.save(u);
8             session.getTransaction().commit();

调用了u.setId(4)时，此时u是一个离线的对象，因为数据库中存在id=4的这个对象，但是该对象又没有被session所托管，所以这个对象就是离线的对象，要使离线对象变成一个持久化的对象，应该调用什么方法呢？我们知道调用save方法，可以将一个对象变成一个持久化对象，但是，当save一执行的时候，此时hibernate会根据id的生成策略往数据库中再插入一条数据，所以如果调用save方法，此时数据库会发送一条插入的语句：

                                 Hibernate: insert into t_person (born, password, username) values (?, ?, ?)

所以对于离线对象，如果要使其变成持久化对象的话，我们不能使用save方法，而应该使用update方法

 1 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 2             session = HibernateUtil.openSession();
 3             session.beginTransaction();
 4             Person u = new Person();
 5             u.setId(5);
 6             //完成update之后也会变成持久化状态
 7             session.update(u);
 8             u.setBorn(sdf.parse("1998-12-22"));
 9             u.setPassword("world");
10             u.setUsername("world");
11             //会发出一条sql
12             session.update(u);
13             session.getTransaction().commit();

当调用了update方法以后，此时u已经变成了一个持久化的对象，那么如果此时对u对象进行修改操作后，在事务提交的时候，则会拿该对象和session中刚保存的持久化对象进行比较，如果不同就发一条sql语句:

                                 Hibernate: update t_user set born=?, password=?, username=? where id=?

 1 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 2             session = HibernateUtil.openSession();
 3             session.beginTransaction();
 4             Person u = new Person();
 5             u.setId(5);
 6             //完成update之后也会变成持久化状态
 7             session.update(u);
 8             u.setBorn(sdf.parse("1998-12-22"));
 9             u.setPassword("lisi");
10             u.setUsername("lisi");
11             //会抛出异常
12             u.setId(333);
13             session.getTransaction().commit();

调用update方法后，Person变成了一个持久化对象，在对Person进行一些修改后，此时又通过 u.setId(333)方法设置了u的ID，那么这个时候，hibernate会报错，因为我们的u当前已经是一个持久化对象，如果试图修改一个持久化对象的ID的值的话，就会抛出异常，这点要特别注意.

                    org.hibernate.HibernateException: identifier of an instance of com.swust.bean.Person was altered from 5 to 333

            session.beginTransaction();Person u = new Person();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_person where id=?

1 session = HibernateUtil.openSession();
2             session.beginTransaction();
3             Person u = new Person();
4             u.setId(4);
5             u.setPassword("zhaoliu");
6             //如果u是离线状态就执行update操作，如果是瞬时状态就执行Save操作
7             //但是注意：该方法并不常用
8             session.saveOrUpdate(u);
9             session.getTransaction().commit();

saveOrUpdate这个方法，如果对象是一个离线对象，那么在执行这个方法后，其实是调用了update方法，如果对象是一个瞬时对象，则会调用save方法，记住：如果对象设置了ID值，例如u.setId(4)，那么该对象会被假设当作一个离线对象，此时就会执行update操作。

Hibernate: update t_person set born=?, password=?, username=? where id=?

如果将u.setId(4)这句话注释掉，那么此时u就是一个瞬时的对象，那么此时就会执行save操作，就会发送一条insert语句

Hibernate: insert into t_person (born, password, username) values (?, ?, ?)

 1             session = HibernateUtil.openSession();
 2             session.beginTransaction();
 3             //u1已经是持久化状态
 4             Person u1 = (Person)session.load(Person.class, 3);
 5             System.out.println(u1.getUsername());
 6             //u2是离线状态
 7             Person u2 = new Person();
 8             u2.setId(3);
 9             u2.setPassword("123456789");
10             //此时u2将会变成持久化状态，在session的缓存中就存在了两份同样的对象,在session中不能存在两份拷贝，否则会抛出异常
11             session.saveOrUpdate(u2);

u1已经是持久化的对象了，保存在session缓存中，u2通过调用saveOrUpdate方法后也变成了一个持久化的对象，此时也会保存在session缓存中，这个时候session缓存中就存在了一个持久化对象有两个引用拷贝了，这个时候hibernate就会报错:

org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated with the session: [com.xiaoluo.bean.User#3]

一个session中不能存在对一个持久化对象的双重copy，要解决这个方法，需要使用session的merge方法，这个方法的作用就是解决一个持久化对象双份拷贝的问题，这个方法会将两个对象合并在一起成为一个对象。

 1             session = HibernateUtil.openSession();
 2             session.beginTransaction();
 3             //u1已经是持久化状态
 4             Person u1 = (Person )session.load(Person .class, 3);
 5             System.out.println(u1.getUsername());
 6             //u2是离线状态
 7             Person u2 = new Person ();
 8             u2.setId(3);
 9             u2.setPassword("123456789");
10             //此时u2将会变成持久化状态，在session的缓存中就存在了两份同样的对象,在session中不能存在两份拷贝，否则会抛出异常
11 //            session.saveOrUpdate(u2);
12             //merge方法会判断session中是否已经存在同一个对象，如果存在就将两个对象合并
13             session.merge(u2);
14             //最佳实践：merge一般不用
15             session.getTransaction().commit();

调用了merge方法以后，此时会将session中的两个持久化对象合并为一个对象，但是merge方法不建议被使用

总结：

①.对于刚创建的一个对象，如果session中和数据库中都不存在该对象，那么该对象就是瞬时对象(Transient)

②.瞬时对象调用save方法，或者离线对象调用update方法可以使该对象变成持久化对象，如果对象是持久化对象时，那么对该对象的任何修改，都会在提交事务时才会与之进行比较，如果不同，则发送一条update语句，否则就不会发送语句

③.离线对象就是，数据库存在该对象，但是该对象又没有被session所托管

转载于:https://www.cnblogs.com/sunfie/p/4744724.html

Hibernate学习之hibernate状态相关推荐

Hibernate学习之Hibernate注解总结
Hibernate学习之Hibernate注解总结http://www.bieryun.com/3269.html 一.类级别的注解 @Entity name:表的名字(可选)一般表名和类名相同必须 ...
Hibernate学习5—Hibernate操作对象
第一节:Hibernate 中四种对象状态删除状态:处于删除状态的Java 对象被称为删除对象.比如说session delete一个对象,这个对象就不处于session缓存中了, 已经从sessi ...
Hibernate学习之hibernate.cfg.xml
<?xml version='1.0' encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC "-//Hib ...
hibernate学习五 Hibernate补充
1 MiddleGenIDE可以生成映射类和映射文件. 2 转载于:https://www.cnblogs.com/liufei1983/p/8635468.html
java hibernate详细_Java事务管理学习之Hibernate详细介绍
hibernate是jdbc轻量级的封装,本身不具备事务管理的能力,在事物管理层面,一般是委托于底层的jdbc和jta来完成调度的.下面这篇文章主要给大家介绍了Java事务管理学习之Hibernate ...
[原创]java WEB学习笔记94：Hibernate学习之路---session 的管理，Session 对象的生命周期与本地线程绑定...
本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱 ...
Hibernate学习笔记(一）
####1.1Hibernate框架的学习路线 第一天:Hibernate的入门(Hibernate的环境搭建.Hibernate的API.Hibernate的CRUD) 第二天:Hibernat ...
Hibernate学习汇总
一.Hibernate的基本原理 1.什么是Hibernate Hibernate,翻译过来是冬眠的意思,正好现在已经进入秋季,世间万物开始准备冬眠了.其实对于对象来说就是持久化. Hibernate ...
Hibernate学习基本配置
hibernate是一个持久层框架,是一个ORM(object,relattional mapping)对象关系映射框架,对jdbc进行了轻量级对象框架. 所谓的对象关系映射是指,一个java对象和关 ...

Hibernate学习之hibernate状态

Hibernate学习之hibernate状态相关推荐

最新文章

热门文章