Hibernate ORM框架——续第一章：对象在Hibernate中的状态
对象在Hibernate中的状态
1.对象的状态也称之为对象的生命周期。
2.hibernate只分了3个阶段
2.1 临时，瞬时（）（transient）
2.2 持久化（persistent）
2.3 游离，托管，分离（），离线（detached）
3.图解：
4、代码
（1）hibernate.cfg.xml除映射文件路径变，其余不变
（2）util包不变
（3）类
package com.nf; public class Person { private int pid ; private String name; private float salary; public int getPid() { return pid; } public void setPid(int pid) { this.pid = pid; } public String getName() { return name; } public void setName(String name) { this.name = name; } public float getSalary() { return salary; } public void setSalary(float salary) { this.salary = salary; } }
（4）PersonMapper.xml
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.nf.Person" table="persons"> <id name="pid" column="id"> <generator class="native"></generator> </id> <property name="name" column="name"></property> <property name="salary" column="salary"></property> </class> </hibernate-mapping>
4.test包测试--Main.java笔记说明（重点）
package com.nf; import java.util.List; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.boot.MetadataSources; import org.hibernate.boot.registry.StandardServiceRegistry; import org.hibernate.boot.registry.StandardServiceRegistryBuilder; import util.HibernateUtil; public class Main { public static void main(String[] args) { // 如果只执行此代码，并且在hibernate.cfg.xml中设定了 // <property name="hbm2ddl.auto">create</property> // 则会默认从映射文件中找到需求把相应的表创建好，放在PL/SQl中 // SessionFactory sf= HibernateUtil.getSessionFactory(); //一、演示的是瞬时-----save()/saveOrUpdate()------到持久的转换 //transientToPersistent(); //二、缓存：get方法01 //cacheDemo(); //二、缓存：get方法02--get前查询所有 //cacheDemo2(); //三、检验持久态下对对象的修改，要不要调用update-->不用 //cacheDemo3(); /* 四、 * 下面表明整个持久化状态下，对它的更改，删除操作 * 会当成一个整体看待，以最终的情况为准、 */ //cacheDemo4(); //五、游离对象 /* Person p = new Person(); p.setPid(3); p.setName("yyyy"); p.setSalary(5555); testUpdate2(p);*/ //六、Load()方法 testLoad(); } //演示的是瞬时-----save()/saveOrUpdate()------到持久的转换 private static void transientToPersistent() { SessionFactory sf = HibernateUtil.getSessionFactory(); Session s = sf.openSession(); Transaction tx = s.beginTransaction(); Person p = new Person(); p.setName("two"); p.setSalary(2000); //在调用save前都是属于瞬时状态。如果new的主键有与数据库相对应的，则为游离状态。 //调用save的时候，即便没有事务提交， //也会从数据库查询主键值(主键生成策略是通过数据库产生：id = native) //select hibernate_sequence.nextval from dual s.save(p); // 添加数据 System.out.println("-----添加数据，变成永久化状态-------"); tx.commit(); s.close(); //sf.close(); //不关闭的原因： //1.SessionFactory是一个大对象。每次创建都需要耗时。所以不再每一个方法内关闭 //2.待关闭程序时，会自动关闭 //3.使用监听器的方法来关闭 } //二、缓存：get方法01 //1:缓存的一个最重要的功能就是避免重复读取数据库 //如果两个查询缓存相同，则只会返回一个语句 //2:如果关闭Session后，再调用get（）加载方法：会报以下错误： //Session/EntityManager is closed //说明： //所有的缓存都是放在session中，这个也称之为hibernate框架的一级缓存 private static void cacheDemo(){ SessionFactory sf = HibernateUtil.getSessionFactory(); Session s = sf.openSession(); Person p1 = s.get(Person.class, 1); //System.out.println(p1.getPid()+","+p1.getName()+","+p1.getSalary()); //s.close(); System.out.println("------------"); Person p2 = s.get(Person.class, 1); s.close(); } //二、缓存：get方法02--get前查询所有 //1:缓存的一个最重要的功能就是避免重复读取数据库 //如果两个查询缓存相同，则只会返回一个语句 private static void cacheDemo2(){ SessionFactory sf = HibernateUtil.getSessionFactory(); Session s = sf.openSession(); List<Person> list = s.createQuery("from Person").list(); /*for (Person p : list) { System.out.println(p.getPid()+","+p.getName()+","+p.getSalary()); }*/ System.out.println("------查询数据结束------"); Person p2 = s.get(Person.class, 1); //System.out.println(p2.getPid()+","+p2.getName()+","+p2.getSalary()); s.close(); //get()方法的避免重复的真正原理，如果list里面已经拿到数据并且放到会话当中了，那么当执行第二条 //get()语句时，就直接拿会话中的数据，就不再重复调用查询数据库的语句。 } //三、检验持久态下对对象的修改，要不要调用update-->不用 /*如果一个对象以及是持久化状态了，那么此时对该对象进行 * 各种修改，或者调用多次update、save方法时， * hibernate都不会发送sql语句，只有当事物提交的时候， * 此时hibernate才会拿当前这个对象与之前保存在session * 中的持久化对象进行比较，如果不相同就发送一条update的sql语句， * 否则就不会发送update语句 * */ private static void cacheDemo3(){ SessionFactory sf = HibernateUtil.getSessionFactory(); Session s = sf.openSession(); Transaction tx = s.beginTransaction(); Person p2 = s.get(Person.class, 1); System.out.println("------------"); p2.setName("aa222"); System.out.println("update 之前------------"); // s.update(p2); System.out.println("update 之后------------"); tx.commit(); s.close(); } /* 四、 * 下面表明整个持久化状态下，对它的更改，删除操作 * 会当成一个整体看待，以最终的情况为准、 * 但中途的操作语句还是有用的，会从上往下执行 * 部分演示了工作单元的概念（Unit of work） */ private static void cacheDemo4(){ SessionFactory sf = HibernateUtil.getSessionFactory(); Session s = sf.openSession(); Transaction tx = s.beginTransaction(); Person p2 = s.get(Person.class, 2); System.out.println("------------"); p2.setName("aa333"); System.out.println("update 之前------------"); s.update(p2); System.out.println("update 之后------------"); System.out.println("delete 之前------------"); s.delete(p2); System.out.println("delete 之后------------"); tx.commit(); s.close(); } /* * 像下面这样更新时，p参数的主键必须是数据库里面存在的 * 也就是说p对象是一个游离对象 * 游离对象：对象被new的同时，有主键和数据库相等的主键值 */ private static void testUpdate(Person p){ SessionFactory sf = HibernateUtil.getSessionFactory(); Session s = sf.openSession(); Transaction tx = s.beginTransaction(); s.update(p); tx.commit(); s.close(); } private static void testUpdate2(Person p){ SessionFactory sf = HibernateUtil.getSessionFactory(); Session s = sf.openSession(); Transaction tx = s.beginTransaction(); // Person temp = s.get(Person.class, 3); // s.update(p); s.merge(p); tx.commit(); s.close(); } /*load()方法：与get()方法不同的是，直接返回的是com.nf.Person_$$_jvst98f_0一个代理类。*/ private static void testLoad(){ SessionFactory sf = HibernateUtil.getSessionFactory(); Session s = sf.openSession(); Transaction tx = s.beginTransaction(); Person temp = s.load(Person.class, 3); String name = temp.getName(); System.out.println(temp.getClass().getName()); tx.commit(); s.close(); } }
/*以上个人整理笔记，如果有误或者有不懂的地方，欢迎评论与指出*/
