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();
    }
}

/*以上个人整理笔记，如果有误或者有不懂的地方，欢迎评论与指出*/