图片 2

Java Hibernate 之 Session 状态

Session接口是Hibernate向程序提供操纵数据库的最主要接口,是单线程对象,它提供了基本的保存、更新、删除和查询方法。它有一个缓存,保存了持久化对象,当清理缓存时,按照这些持久化对象同步更新数据库。

三态的基本概念:

注意:session的某些方法(persist,load)不会立即把改动写入数据库,而是缓存到session的一级缓存中,除非显示调用flush,或者关闭session时才会更新到数据库

1,
临时状态(Transient):也叫自由态,只存在于内存中,而在数据库中没有相应数据。用new创建的对象,它没有持久化,没有处于Session中,处于此状态的对象叫临时对象;

  1. 临时状态(Transient):没与session关联
  2. 持久化状态(Persistent):与session关联,没close
  3. 游离状态(Detached):当session.close后
 //创建一个瞬态对象
  User user = new User();
  user.setName(userName);
  user.setPassword("test");
  //user仍是一个瞬态对象

Session的方法详解

1.保存

save:立即插入数据库,并且返回主键

persist:不立即(延迟)插入数据库,无返回值

2.获取

load:加载对象后,对对象的改动不会立即刷新到db,必须flush到db

ex: User user=session.load(User.class,2);

user.setName(‘gt’);

user.flush();   (延迟加载)

get:加载对象后,对对象的改动立即刷新到db

3.更新

update:持久化对象,更新

saveOrUpdate:包含save()和update()功能,如果传入的参数是临时对象(没有保存过)就调用save()方法;如果传入的参数是游离对象,就调用update()方法

merge:不会持久化对象,只会把托管对象的修改更新到db

4.删除

delete:从数据库中删除与JAVA对象对应的记录

5.清理

flush:把缓存同步到db

clear:清除session的缓存大小(更新批量时,应考虑)

三种状态的转换关系

图片 1

下面通过实例讲解:

实体:

package cn.itcast.h_session_method;

public class User {
    private Integer id;
    private String name;
    private byte[] data = new byte[1024 * 1024 * 5];

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

}

映射文件:

<?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 package="cn.itcast.h_session_method">

    <!-- 
        lazy属性:默认为true,默认可以懒加载。
     -->
    <class name="User" table="user" lazy="true">
        <id name="id">
            <generator class="native"></generator>
        </id>
        <property name="name"/>
    </class>

</hibernate-mapping>

配置文件:hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

    <!--数据库连接设置 -->
    <property name="connection.driver_class">
        com.mysql.jdbc.Driver
    </property>
    <property name="connection.url">
        jdbc:mysql://localhost:3306/mytest
    </property>
    <property name="connection.username">root</property>
    <property name="connection.password">root</property>

    <!-- 方言 -->
    <property name="dialect">
        org.hibernate.dialect.MySQL5Dialect
    </property>

    <!-- 控制台显示SQL -->
    <property name="show_sql">true</property>

    <!-- 自动更新表结构 -->
    <property name="hbm2ddl.auto">update</property>
    <mapping resource="cn/itcast/h_session_method/User.hbm.xml" />

</session-factory>

</hibernate-configuration>

测试文件

package cn.itcast.h_session_method;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import com.java1234.util.HibernateSessionFactory;

public class App {

    private static SessionFactory sessionFactory = HibernateSessionFactory.getSessionFactory();

    // save():把临时状态变为持久化状态(交给Sessioin管理)
    // 会生成:insert into ...
    @Test
    public void testSave() throws Exception {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        // --------------------------------------------

        User user = new User(); // 临时状态
        user.setName("test");
        session.save(user); // 变为了持久化状态

        // --------------------------------------------
        session.getTransaction().commit();
        session.close();

        user.setName("李四"); // 游离状态
        System.out.println(user.getName()); // 游离状态
    }

    // update():把游离状态变为持久化状态
    // 会生成:update ...
    // 在更新时,对象不存在就报错
    @Test
    public void testUpdate() throws Exception {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        // --------------------------------------------

        User user = (User) session.get(User.class, 1);
        System.out.println(user.getName()); // 持久化状态

        // session.clear(); // 清除Session中所有的对象
        session.evict(user); // 清除Session中一个指定的对象

        user.setName("newname3");
        session.update(user);
        System.out.println("----");
        // session.flush(); // 刷出到数据库

        // --------------------------------------------
        session.getTransaction().commit(); // 
        session.close();
    }

    // saveOrUpdate():把临时或游离状态转为持久化状态
    // 会生成:insert into 或 update ...
    // 在更新时,对象不存在就报错
    // 本方法是根据id判断对象是什么状态的:如果id为原始值(对象的是null,原始类型数字是0)就是临时状态,如果不是原始值就是游离状态。
    @Test
    public void testSaveOrUpdate() throws Exception {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        // --------------------------------------------

        User user = new User();
        user.setId(3); // 自己生成一个游离状态对象
        user.setName("newName");

        session.saveOrUpdate(user);

        // --------------------------------------------
        session.getTransaction().commit();
        session.close();
    }

    // delete():把持久化或游离转为删除状态
    // 会生成:delete ...
    // 如果删除的对象不存在,就会抛异常
    @Test
    public void testDelete() throws Exception {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        // --------------------------------------------

        // User user = (User) session.get(User.class, 2); // 持久化

        User user = new User();
        user.setId(300);

        session.delete(user);
        session.flush();

        System.out.println("---");

        // --------------------------------------------
        session.getTransaction().commit();
        session.close();
    }

    // get():获取数据,是持久化状态
    // 会生成:select ... where id=?
    // 会马上执行sql语句
    // 如果数据不存在,就返回null
    @Test
    public void testGet() throws Exception {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        // --------------------------------------------

        User user = (User) session.get(User.class, 5); // 持久化
        System.out.println(user.getClass());
        // System.out.println("---");
        // System.out.println(user.getName());

        // --------------------------------------------
        session.getTransaction().commit();
        session.close();
    }

    // load():获取数据,是持久化状态
    // 会生成:select ... where id=?
    // load()后返回的是一个代理对象,要求类不能是final的,否则不能生成子类代理,就不能使用懒加载功能了。
    // 让懒加载失效的方式:一、把实体写成final的;二、在hbm.xml中写<class ... lazy="false">
    // 不会马上执行sql语句,而是在第1次使用非id或class属性时执行sql。
    // 如果数据不存在,就抛异常:ObjectNotFoundException
    @Test
    public void testLoad() throws Exception {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        // --------------------------------------------

        User user = (User) session.load(User.class, 5);
        System.out.println(user.getClass());
        System.out.println("---");
        System.out.println(user.getId());
        System.out.println(user.getName());
        // System.out.println(user.getName());

        // --------------------------------------------
        session.getTransaction().commit();
        session.close();
    }

    // 操作大量数据,要防止Session中对象过多而内存溢出
    @Test
    public void testBatchSave() throws Exception {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        // --------------------------------------------

        for (int i = 0; i < 30; i++) {
            User user = new User();
            user.setName("测试");
            session.save(user);

            if (i % 10 == 0) {
                session.flush(); // 先刷出
                session.clear(); // 再清空
            }
        }

        // --------------------------------------------
        session.getTransaction().commit();
        session.close();
    }

    @Test
    public void test2() throws Exception {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        // --------------------------------------------

        User user = (User) session.get(User.class, 5); // 持久化
        System.out.println(user.getName());

        // session.clear();
        // user = (User) session.get(User.class, 5); // 持久化

        session.refresh(user); // 刷新Session缓存中对象的状态,即重新select一下
        System.out.println(user.getName());

        // --------------------------------------------
        session.getTransaction().commit();
        session.close();
    }
}

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

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

游离对象就是,数据库存在该对象,但是该对象又没有被session所托管

 

 

2,
持久化状态(Persistent):与session关联并且在数据库中有相应数据。已经持久化,加入到了Session缓存中。如通过hibernate语句保存的对象。处于此状态的对象叫持久对象;

 //创建一个瞬态对象
  User user = new User();
  user.setName(userName);
  user.setPassword("test");
  //user仍是一个瞬态对象

Session session = sessionFactory.openSession();
Tansaction tx = session.beginTansaction();
//此时user仍是一个瞬态对象
session.save(user);
//此时user已变为持久态
tx.commit();

Tansaction tx2 = session.beginTansaction();
user.setPassword("pdw");
tx2.commit();
//虽然在这个事物中并没有调用session的save()方法来保存user对象,但是usr处于持久太,
//所以对user对象所做的任何修改都持久化到数据库中   ---------持久态自动更新
//那么数据库中的密码也变成了pdw

session.close();

另一种方法直接得到持久态的对象:

Session session = sessionFactory.openSession();
Tansaction tx = session.beginTansaction();
User user = (User) session.load(User.class,"key");   ------相当于hql  从DB读出来的 当然是持久态
//user对象已是持久太对象
tx.commit();
session.close();

 

3,
游离状态(Detached):持久化对象脱离了Session的对象。如Session缓存被清空的对象。 
特点:已经持久化,但不在Session缓存中。处于此状态的对象叫游离对象;

//创建一个瞬态对象
  User user = new User();
  user.setName(userName);
  user.setPassword("test");
  //user仍是一个瞬态对象

Session session = sessionFactory.openSession();
Tansaction tx = session.beginTansaction();
//此时user仍是一个瞬态对象
session.save(user);
//此时user已变为持久态
tx.commit();
session.close();      clear()   evict()  3种变游离态
user对象已经变成游离态

session close完后,对象就变成游离态。

 

图片 2 
游离对象和临时对象异同:

两者都不会被Session关联,对象属性和数据库可能不一致;

游离对象有持久化对象关闭Session而转化而来,在内存中还有对象所以此时就变成游离状态了;

Hibernate和SQL的关系:

在操作了hibernate的方法如save()等后,并没有直接生成sql语句,去操作数据库,而是把这些更新存入Session中,只有Session缓存要被更新时,底层的sql语句才能执行,数据存入数据库;

下面举例说明: 
一,Session.save(user)运行机理。 
1,把User对象加入缓存中,使它变成持久化对象; 
2,选用映射文件指定的标识生成ID; 
3,在Session清理缓存时候执行:在底层生成一个insert
sql语句,把对象存入数据库;

注意:在你执行Session.save(user)后,在Session清理缓存前,如果你修改user对象属性值,那么最终存入数据库的值将是最后修改的值;此过程中ID不能被修改;

二,Session.delete(user)运行过程。 
如果user是持久化对象,则执行删除操作,同样底层数据库的执行条件是:在Session清理缓存时候; 
如果user是游离对象: 
1,将user对象和Session关联,使之成为持久化对象; 
2,然后按照user 是持久化对象的过程执行;

三态之间的转换方法:

①如何成为自由态?对象通过构造方法成为自由态;持久态和游离态则通过session的delete方法成为自由态

②如何成为持久态?对象可以由session的load或get方法直接成为持久态;自由态对象可以通过save,saveOrUpdate或persist方法成为持久态;游离态对象则可以通过update,saveOrUpdate成为持久态

③如何成为游离态?游离态只能由持久态转换而来,通过close或clear方法实现。

几种转换方法的对比:

1.get 与load

都是从数据库中加载数据封装为Java对象,使得java对象从自由态直接变为持久态;

但是有两点区别:①get返回对象可以为null,load返回值则始终不为null,找不到时会抛异常②get即时执行insert,而load则是在使用此对象时才执行insert

2.save,update与saveOrUpdate

save是将自由态转为持久态,而update是将游离态转为持久态,saveOrUpdate可以说是两者的综合,它执行时先判断对象的状态(主要是通过有无主键判断的),若是自由态,则save,若是游离态,则update

3.save与persist

两者都是将对象由自由态转为持久态,但返回值不同:save返回主键值,而persist不返回

4,saveOrUpdate与merge

两者都是将自由态或游离态对象与数据库关联,但merge不改变对象的原有状态

此外,对clear与flush方法也作介绍。clear是将session中的对象全部变为游离态,是对象由持久态变为游离态的一种方法(另外一种是关闭session);flush方法时为了使update操作能即时进行(正常情况下,只有在事务关闭时才进行update操作)。

发表评论

电子邮件地址不会被公开。 必填项已用*标注