Hibernate学习（4）- Hibernate对象的生命周期

时间 2019-12-13

原文原文链接

一、Hibernate对象的生命周期（瞬时状态、持久化状态、游离状态）

一、瞬时状态（Transient）：
　　使用new操做符初始化的对象就是瞬时状态，没有跟任何数据库数据相关联；
二、持久化状态（Parsistent）：
　　若是对象与Session对象关联起来，且该对象对应到数据库记录，则称该对象处于持久化状态。
三、游离状态（Detached）
　　Session被关闭或调用了Session的evict或clear方法把它从Session中移除了，则该对象脱离了Session的管理，持久化状态变成游离状态，这表示该对象不在和数据库保持同步，不受hibernate管理。html

二、三种状态的比较

Transient：瞬时状态的对象只存在于内存中。
Parsistent：持久状态的对象分别存在于内存、session对象、数据库之中。
Detached：游离状态的对象存在于内存、数据库之中，但不在session对象中。java

三、三种状态之间的转换

一、转化路径详解

1）瞬时对象(Transient)git

　　new 建立 (无->Transient) ，即：对象经过构造方法成为瞬时态；github

2）持久对象(Persistent)sql

　　1.1）get/load (无->Persistent)，即：对象能够由session的load或get方法直接成为持久态；数据库

　　　　get经过类名和id从数据库读取指定记录，无匹配记录返回null。
　　　　load经过类名和id从数据库读取指定记录，无匹配记录抛ObjectNotException异常。缓存

　　1.2）save/saveOrUpdate/persist (Transient->Persistent) ，即：瞬时态对象能够经过save，saveOrUpdate或persist方法成为持久态；session

　　1.3）update/saveOrUpdate(Detached->Persistent)，即：游离态对象则能够经过update，saveOrUpdate成为持久态；工具

3）游离对象(Detached)spa

　　游离态只能由持久态转换而来(Persistent->Detached)，经过close、clear、evict方法实现。

　　evict--把某个对象从session中移除，变为游离态；
　　clear--把全部对象从session中移除，对象所有变为游离态；
　　close--关闭session，其中的对象所有变为游离态；

二、几种方法的详解

一、get 与 load

　　都是从数据库中加载数据封装为java对象，直接变为持久态；

二、save，update与saveOrUpdate

　　save是将瞬时态转为持久态；
　　update是将游离态转为持久态；
　　saveOrUpdate能够说是二者的综合，它执行时先判断对象的状态（主要是经过有无主键判断的），如果自由态，则save，如果游离态，则update；

三、save与persist

　　二者都是将对象由瞬时态转为持久态，但返回值不一样：save返回主键值，而persist不返回；

四、实例，详见注解状态（封装的工具类详见Demo）

package com.demo.test;

import org.hibernate.Session;
import org.junit.Test;

import com.demo.Utils.HibernateUtil;
import com.demo.pojo.User;

public class SessionTest {

    @Test
    public void saveTest() {
        Session session = null;
        User user = null;
        try {
            session = HibernateUtil.currentSession();
            session.beginTransaction();
            //建立瞬时状态对象
            user = new User();
            user.setName("东方不败");
            user.setPwd("123456");
            //user还是一个瞬态对象
            
            //持久状态，user被session管理，而且id有值   -- oid
            //此时user已变成 持久态对象
            session.save(user);
            
            //在持久状态下脏数据检查:当提交事务，清理缓存时发现session中的数据与数据库的数据不一致时，会把session的数据更新到数据库
            //保存之后，再修改对象，会产生多条sql语句，效率下降，因此在save前修改数据
            user.setName("西方求败");
            session.getTransaction().commit();        
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            HibernateUtil.closeSession();
        }
        //close、clear、evict方法都会使持久态对象  变成 游离状态 -- user
        user.setName("令狐冲");

        try {
            session = HibernateUtil.currentSession();
            session.beginTransaction();
            //update使对象变成 持久状态
            session.update(user);
            session.getTransaction().commit();        
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            HibernateUtil.closeSession();
        }
    }
    
    @Test
    public void getTest() {
        Session session = null;
        try {
            session = HibernateUtil.currentSession();
            //get后变为持久状态
            //get方法会当即查询该对象：范围（查询不到去下一级查询）从session -> sessionFactory ->数据库
            //get方法找不到对象，不会有异常，返回nul
            User user = session.get(User.class, 7L);
            System.out.println(user.toString());
            
            User user2 = session.get(User.class, 17L);
            System.out.println(user2);
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            HibernateUtil.closeSession();
        }
    }
    
    @Test
    public void loadTest() {
        Session session = null;
        try {
            session = HibernateUtil.currentSession();
            //load后变为持久状态(这里加载机制与get不一样，稍后我会单独写一篇文章 介绍 get与load 的区别)
            //对象不存在时，抛出异常
            User user = session.load(User.class, 7L);
            System.out.println(user.toString());
            
            User user2 = session.load(User.class, 17L);
            System.out.println(user2.toString());
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            HibernateUtil.closeSession();
        }
    }
    
    @Test
    public void clearTest() {
        Session session = null;
        User user = null;
        try {
            session = HibernateUtil.currentSession();
            session.beginTransaction();
            user = session.get(User.class,7L);
            System.out.println(user.getName());
            session.getTransaction().commit();    
            session.clear();
            //游离状态，不被session管理，数据库不会被更改
            user.setName("任我行");
            System.out.println(user.getName());
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            HibernateUtil.closeSession();
        }
    }
    
    @Test
    public void updateTest() {
        Session session = null;
        User user = null;
        try {
            session = HibernateUtil.currentSession();
            session.beginTransaction();
            //瞬时状态
            //手动构造对象 也能够修改，可是须要指定全部的属性值，不然，不设置的对象会置空,不建议这样update数据
            /*user = new User();
            user.setId(7L);
            user.setName("盈盈");
            session.update(user);*/
            //通常这样修改
            //先去查询
            user = session.get(User.class,7L);
            if(user != null) {
                user.setName("盈盈");
                session.update(user);
            }
            session.getTransaction().commit();    
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            HibernateUtil.closeSession();
        }
    }
    
    @Test
    public void deleteTest() {
        Session session = null;
        User user = null;
        try {
            session = HibernateUtil.currentSession();
            session.beginTransaction();
            //瞬时状态
            //手动构造一个对象，指定主键是能够删除数据的，不建议这样搞
            /*user = new User();
            user.setId(7L);
            session.delete(user);*/
            //应该这样删除数据
            //从数据先加载该对象，而后删除，能够避免异常
            user = session.get(User.class, 7L);
            if(user != null) {
                session.delete(user);
            }
            session.getTransaction().commit();    
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            HibernateUtil.closeSession();
        }
    }
    
    
}

PS：源码地址 https://github.com/JsonShare/hibernate-demo

PS：原文地址 http://www.cnblogs.com/JsonShare/p/8686078.html