Hibernate对象的状态
站在持久化的角度, Hibernate 把对象分为 4 种状态:
1. 持久化状态
2. 临时状态
3. 游离状态
4. 删除状态
Session 的特定方法能使对象从一个状态转换到另一个状态.
下面是各状态之间的转换图, 以及如何转换的:
准备工作:
1. 建立持久化类
Person类
package com.hibernate.entities; public class Person { private Integer id; private String name; private Integer age; public Person() { super(); } public Person(String name, Integer age) { super(); this.name = name; this.age = age; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } }
2. 建立持久化类的映射文件
Person.hbm.xml
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.hibernate.entities.Person" table="PERSONS"> <id name="id" type="java.lang.Integer"> <column name="ID" /> <generator class="identity" /> </id> <property name="name" type="java.lang.String"> <column name="NAME" /> </property> <property name="age" type="java.lang.Integer"> <column name="AGE" /> </property> </class> </hibernate-mapping>
3. 建立Hibernate的主配置文件 hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <!-- 配置连接数据库的信息 --> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">oracle</property> <property name="hibernate.connection.url">jdbc:mysql:///hibernate</property> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <!-- 配置数据库方言 --> <property name="hibernate.dialect">org.hibernate.dialect.MySQL57InnoDBDialect</property> <!-- 设置数据表生成策略 --> <property name="hibernate.hbm2ddl.auto">update</property> <!-- 是否格式化SQL --> <property name="hibernate.format_sql">true</property> <!-- 是否显示SQL --> <property name="hibernate.show_sql">true</property> <!-- 修改delete()的默认行为, 使删除对象的OID变为null --> <property name="hibernate.use_identifier_rollback">true</property> <!-- 添加配置文件 --> <mapping resource="com/hibernate/entities/Person.hbm.xml"/> </session-factory> </hibernate-configuration>
4. 建立单元测试类
package com.test; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.annotations.SelectBeforeUpdate; import org.hibernate.cfg.Configuration; import org.junit.After; import org.junit.Before; import org.junit.Test; public class TestHibernate { private SessionFactory sessionFactory; private Session session; private Transaction transaction; @Before public void init(){ sessionFactory = new Configuration().configure().buildSessionFactory(); session = sessionFactory.openSession(); transaction = session.beginTransaction(); } @After public void distory(){ transaction.commit(); session.close(); sessionFactory.close(); } }
这里我直接把注释, 说明等文字写在代码里了,可以直接复制下来, 放到IDE开发工具里面慢慢看
package com.test; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.annotations.SelectBeforeUpdate; import org.hibernate.cfg.Configuration; import org.junit.After; import org.junit.Before; import org.junit.Test; import com.hibernate.entities.Person; public class TestHibernate { private SessionFactory sessionFactory; private Session session; private Transaction transaction; @Before public void init(){ sessionFactory = new Configuration().configure().buildSessionFactory(); session = sessionFactory.openSession(); transaction = session.beginTransaction(); } @After public void distory(){ transaction.commit(); session.close(); sessionFactory.close(); } /* * 站在持久化的角度: * Hibernate 把对象分为 4 种状态: * 持久化状态, 临时状态, 游离状态, 删除状态. * Session 的特定方法能使对象从一个状态转换到另一个状态. */ /* * 一: 临时对象(Transient) * 1. 在使用代理主键的情况下, OID 通常为 null * 2. 不处于 Session 的缓存中 * 3. 在数据库中没有对应的记录 */ /* * 二: 持久化对象(也叫"托管")(Persist) * 1. OID 不为 null. * 2. 位于Session缓存中. * 3. 若在数据库中已经有和其对应的记录, 持久化对象和数据库中的相关记录对应. * 4. Session在flush缓存时, 会根据持久化对象的属性变化, 来同步更新数据库. * 5. 在同一个Session实例缓存中, 数据库表中的每条记录只对应唯一的持久化对象. */ /* * 三: 删除对象(Removed) * 1. 在数据库中没有和其OID对应的记录. * 2. 不再处于Session缓存中. * 3. 一般情况下, 应用程序不再使用该对象. */ /* * 四: 游离对象(也叫"托管")(Detached) * 1. OID不为null. * 2. 不再处于Session缓存中. * 3. 一般情况下, 游离对象是持久化对象转变过来的, 因此在数据库中可能还存在与它对应的记录. */ /** * save()方法:使一个临时对象转变为持久化对象. * 执行save()方法时, 系统会完成以下操作: * 1. 把 new 对象加入到Session缓存中, 使它进入持久化状态. * 2. 选用映射文件指定的标示符生成器, 为持久化对象分配唯一的OID. * 在使用中代理主键的情况下, setId() 方法为 new 对象设置的OID 是无效的. * 3. 计划执行一条 insert 语句(在flush缓存的时候). * persist()方法: 同save()方法. */ @Test public void testSaveOrPersist(){ // 保存一个对象 // Person person = new Person("Tom", 12); // session.save(person); // 使用 save() 保存一个有id值的对象时, 正常保存. // Person person = new Person("Tom", 12); // person.setId(100); // session.save(person); // 使用 persist()保存一个有id值得对象时, 抛异常! // Person person = new Person("Mike", 23); // person.setId(100); // session.persist(person); // 试图修改持久化对象的 ID, 不允许! // Person person = session.get(Person.class, 1); // person.setId(1000); // session.update(person); } /** * get() 和 load() 方法 * 相同点: * 都可以根据指定的OID, 从数据库中加载一个持久化对象. * 不通电: * 1. 当数据库不存在OID对应的记录时: * load() 会抛出异常. * get() 返回null. * 2. 两者采用不同的加载策略: * load() 支持延迟加载. * get() 不支持. */ @Test public void testGetOrLoad(){ // 1. 使用 get() 获取对象 // 当调用 get() 时, Hibernate会计划执行SQL, 在flush时的时候, 会发送SQL语句. // session.get(Person.class, 2); // session.flush(); // System.out.println("======================"); // 2. 使用 load() 延迟加载对象 // 当调用 load() 时, Hibernate不会计划执行SQL // 即使flush操作的时候, 如果没有使用这个对象, 那么Hibernate就不会发送SQL语句. // 只有在使用这个对象的时候, Hiberante才会发送SQL语句. 这就是延迟加载! Person person = session.load(Person.class, 2); session.flush(); System.out.println("======================"); System.out.println(person.getName()); } /** * 1. update(): 使一个游离对象转变为持久化对象, 并且计划执行一条SQL语句. * 2. 如果希望Session仅当修改了 new 对象的属性时, 才执行 update 语句 * 可以把映射文件中的<class>元素的 select-before-update 设置为true, 默认为false. * 3. 当 update() 关联一个游离对象时, 如果在Session的缓存中已经存在相同OID的持久化对象, 会抛异常! * 4. 当 update() 关联一个游离对象时, 如果在数据库中不存在相应的记录, 也会抛出异常! */ @Test public void testUpdate(){ // 一: 正常的 update // // tip:游离对象是由持久化对象转换过来的. // Person person = session.get(Person.class, 1); // transaction.commit(); // // session 关闭后, person 对象转换为游离对象. // session.close(); // session = sessionFactory.openSession(); // transaction = session.beginTransaction(); // person.setAge(19); // // 执行完 update, person对象由游离对象转变为持久化对象. // session.update(person); // 二: 当在配置文件添加 select-before-update=true 的时候 // 这里我们用注释来做, 在类上加上: @SelectBeforeUpdate(value=true) // 1. 没有改变任何属性, 当时Hibernate仍然发送一条SQL语句来验证属性值是否改变. // Person person = session.get(Person.class, 1); // session.update(person); // 2. 改变了属性之后, 不仅发送一条SQL语句, 还会发送一条update语句. // Person person = session.get(Person.class, 1); // person.setName("Kim"); // session.update(person); // 三: Session缓存中存在相同的OID. // // 先获取一个持久化Person, 然后关闭Session变为游离态. // Person person1 = session.get(Person.class, 1); // transaction.commit(); // session.close(); // session = sessionFactory.openSession(); // transaction = session.beginTransaction(); // // 开启Session, 再获取一个相同的Person对象 // Person person2 = session.get(Person.class, 1); // person1.setName("Sunny"); // // 把游离态的person1转化为持久化态, 由于我们缓存中已经有一个OID为1的person2 // // 所以抛异常!(Hibernate不允许缓存中存在OID相同的对象) // session.update(person1); // 四: 数据库中不存在相应的记录 // 意味着这是一个临时对象, 或者删除对象 // 只能执行save()或者persist()进行持久化 // update() 只能把游离对象, 转化为持久化对象 // Person person = new Person("Lily", 15); // // 抛异常! // session.update(person); } /** * saveOrUpdate(): 包含了 save() 和 update() 的功能 * 如果是一个临时对象, 就执行save() * 如果是一个持久化对象, 就执行update() * 判断是临时对象的标准: * 1. 如果对象的OID为null. * 2. 映射文件中<id> 设置了 unsaved-value 属性, * 并且java对象的OID取值与这个unsaved-value属性值匹配. */ @Test public void testSaveOrUpdate(){ // id(OID)值为null, 执行 insert 语句 // Person person = new Person("Mike", 15); // session.saveOrUpdate(person); // id(OID)值为unsaved-value的值(100), 执行insert语句 // Person person = new Person("Mike", 15); // person.setId(100); // session.saveOrUpdate(person); // 数据库中有与id(OID)值对应的值, 那么就执行update语句 Person person = new Person("Mike", 15); // 数据库中有主键为2的数据, 执行update语句 person.setId(2); session.saveOrUpdate(person); } /** * merge() */ @Test public void testMerge(){ /* * 一: 临时对象 * 创建一个新的News对象,把new1对象的属性拷贝到新建的News对象中 * 持久化这个News对象,计划执行一条insert语句 */ // Person person = new Person("Tom", 13); // // 发送了一条insert // session.merge(person); /* * 二: 游离对象 + 存在Session缓存中 */ // Person person1 = session.get(Person.class, 1); // // guanbiSession, 开启Session使对象变为游离态 // transaction.commit(); // session.close(); // session = sessionFactory.openSession(); // transaction = session.beginTransaction(); // // 重新加载到Session缓存中. // Person person2 = session.get(Person.class, 1); // person1.setName("Mike"); // // 把person1对象的属性拷贝到person2持久化对象中,计划执行一条update语句 // // 发送了2条select, 1条update // session.merge(person1); /* * 三: 游离对象 + 不存在Session缓存中 + 数据库中存在id为1的记录 */ // Person person = session.get(Person.class, 1); // transaction.commit(); // session.close(); // session = sessionFactory.openSession(); // transaction = session.beginTransaction(); // person.setName("Kim"); // // 从数据库加载id为1的News持久化对象(会发送一条select) // // 把person对象的属性拷贝到News持久化对象中,计划执行一条update语句 // // 发送了2条select, 1条update // session.merge(person); /* * 四: 游离对象 + 不存在Session缓存中 + 数据库中不存在id为1的记录 */ // // 1 条select // Person person = session.get(Person.class, 1); // // 从数据库中删除, 1 条delete // session.delete(person); // transaction.commit(); // session.close(); // session = sessionFactory.openSession(); // transaction = session.beginTransaction(); // // 1 一条insert // session.merge(person); } /** * delete(): 既可以删除一个游离对象, 也可以删除一个持久化对象 * 处理过程: * 1. 计划执行一条 delete 语句 * 2. 把对象从 Session缓存中移除, 该对象进入删除状态 * hibernate.use_identifier_rollback 属性: * 这个值默认为false, 如果改为true, 将改变 delete()的运行行为, * delete()会把持久化对象或游离对象的OID置为null, 使它们变为临时对象 */ @Test public void testDelete(){ // 1. hibernate.use_identifier_rollback=false // Person person = session.get(Person.class, 3); // session.delete(person); // session.flush(); // // 打印 3 // System.out.println(person.getId()); // 2. hibernate.use_identifier_rollback=true Person person = session.get(Person.class, 3); session.delete(person); session.flush(); // 打印 null System.out.println(person.getId()); } }