Hibernate 基础配置及常用功能（三）

本章重点讲述Hibernate对象的三种状态以及如何配置二级缓存

有关Hibernate的三种状态如何相互转换网上都能查到，官方文档描述的也比较详细。这里主要是针对几个重点方法做代码演示。

一、状态转换

package learnhow;

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

import util.HibernateUtil;
import model.example.User;

public class HibernateTest {
    private Session session;
    private Transaction transaction;

    @Test
    public void testSaveOrUpdate() {
        session = HibernateUtil.getSessionFactory().openSession();
        transaction = session.beginTransaction();
        // Transient状态：session缓存和数据库中都没有
        User user = new User();
        user.setUserName("Linda");
        session.save(user);
        // Persistent状态：save()方法以后，对象获得id并且在session中保留有引用
        user = (User) session.get(User.class, 1);
        transaction.commit();
        session.close();
        // Detached状态：session被关闭，数据库和内存中有对象
        user.setUserName("John");
        session = HibernateUtil.getSessionFactory().openSession();
        transaction = session.beginTransaction();
        // Persistent状态：此时如果使用save()方法，Hibernate会抛出异常，使用update()方法可以更新数据库数据
        session.update(user);
        // Transient状态：数据库和session缓存中都删除对象，此时对象有id值，但依然属于T状态
        session.delete(user);
        transaction.commit();
        session.close();
        user.setUserName("Bob");
        // Transient状态：有id值的T对象为了防止冲突，应该把id值重置
        user.setId(0);
        session = HibernateUtil.getSessionFactory().openSession();
        transaction = session.beginTransaction();
        // Persistent状态：重新将对象持久化
        session.saveOrUpdate(user);
        transaction.commit();
        session.close();
    }
}

以上代码Hibernate会依次执行插入-更新-删除-插入。

二、延迟加载

package learnhow;

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

import util.HibernateUtil;
import model.example.User;

public class HibernateTest {
    private Session session;
    private Transaction transaction;

    @Test
    public void testGetAndLoad() {
        session = HibernateUtil.getSessionFactory().openSession();
        transaction = session.beginTransaction();
        // 立即发出sql语句查询结果
        User user1 = (User) session.get(User.class, 2);
        transaction.commit();
        session.close();
        session = HibernateUtil.getSessionFactory().openSession();
        transaction = session.beginTransaction();
        // 仅返回代理对象，在实际使用的时候才会触发查询条件
        User user2 = (User) session.load(User.class, 2);
        transaction.commit();
        session.close();
        // 关闭session以后可以正常使用
        System.out.println(user1);
        // 关闭session以后查询对象会抛出异常：org.hibernate.LazyInitializationException: could
        // not initialize proxy - no Session
        System.out.println(user2);
    }
}

延迟加载异常是使用Hibernate之中经常遇到的问题。例如，如果在级联条件下设置了fetch = FetchType.LAZY，关闭session以后试图触发查询操作也会抛出异常。

以上代码在4.x和5.x版本中均运行正常，唯一的不同点是在5.x版本中通过get()等方法获取对象的时候不需要强制转型。

三、配置二级缓存

Hibernate通过org.hibernate.testing.cache.CachingRegionFactory对象实现对二级缓存的管理，但是在官方文档中明确注明只适合于测试环境。因此，如果需要在生产环境中使用Hibernate配置二级缓存，官方推荐EHCache。

（1）首先通过Maven引入依赖关系（最后一项依赖是针对二级缓存的，前面都是之前两章用到的包）

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.learnhow</groupId>
    <artifactId>Hibernate_Demo</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>Hibernate_Demo Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <!-- 引入新版依赖 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.0.6.Final</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.13</version>
        </dependency>
        <dependency>
            <groupId>org.javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.20.0-GA</version>
        </dependency>
        <dependency>
            <groupId>javax.transaction</groupId>
            <artifactId>jta</artifactId>
            <version>1.1</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- Hibernate官方推荐的数据库连接池是c3p0 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>5.0.6.Final</version>
        </dependency>
        <!-- 添加二级缓存的实现依赖 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-ehcache</artifactId>
            <version>5.0.6.Final</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>Hibernate5_Demo</finalName>
    </build>
</project>

（2）从Hibernate官方文档里找一份ehcache.xml文件，复制到项目的resources目录下

<!--
  ~ Hibernate, Relational Persistence for Idiomatic Java
  ~
  ~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.
  ~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
  -->
<ehcache>

    <!-- Sets the path to the directory where cache .data files are created.

         If the path is a Java System Property it is replaced by
         its value in the running VM.

         The following properties are translated:
         user.home - User's home directory
         user.dir - User's current working directory
         java.io.tmpdir - Default temp file path -->
    <diskStore path="./target/tmp"/>


    <!--Default Cache configuration. These will applied to caches programmatically created through
        the CacheManager.

        The following attributes are required for defaultCache:

        maxInMemory       - Sets the maximum number of objects that will be created in memory
        eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element
                            is never expired.
        timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
                            if the element is not eternal. Idle time is now - last accessed time
        timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
                            if the element is not eternal. TTL is now - creation time
        overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache
                            has reached the maxInMemory limit.

        -->
    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />

    <!--Predefined caches.  Add your cache configuration settings here.
        If you do not have a configuration for your cache a WARNING will be issued when the
        CacheManager starts

        The following attributes are required for defaultCache:

        name              - Sets the name of the cache. This is used to identify the cache. It must be unique.
        maxInMemory       - Sets the maximum number of objects that will be created in memory
        eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element
                            is never expired.
        timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
                            if the element is not eternal. Idle time is now - last accessed time
        timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
                            if the element is not eternal. TTL is now - creation time
        overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache
                            has reached the maxInMemory limit.

        -->

    <!-- Sample cache named sampleCache1
        This cache contains a maximum in memory of 10000 elements, and will expire
        an element if it is idle for more than 5 minutes and lives for more than
        10 minutes.

        If there are more than 10000 elements it will overflow to the
        disk cache, which in this configuration will go to wherever java.io.tmp is
        defined on your system. On a standard Linux system this will be /tmp"
        -->
    <cache name="sampleCache1"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />

    <!-- Sample cache named sampleCache2
        This cache contains 1000 elements. Elements will always be held in memory.
        They are not expired. -->
    <cache name="sampleCache2"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        /> -->

    <!-- Place configuration for your caches following -->

</ehcache>

（3）配置了二级缓存之后还可以继续配置查询缓存

<?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/learnhow</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <!-- JDBC连接池，开发环境设置1就可以了 -->
        <property name="connection.pool_size">1</property>
        <!-- 数据库方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
        <!-- session交给hibernate管理 -->
        <property name="current_session_context_class">thread</property>
        <!-- 是否显示sql语句 -->
        <property name="show_sql">true</property>
        <!-- 是否对语句格式化输出 -->
        <property name="hbm2ddl.auto">update</property>
        <!-- 是否对语句格式化输出 -->
        <property name="format_sql">true</property>
        <!-- 配置二级缓存 -->
        <property name="hibernate.cache.use_second_level_cache">true</property>
        <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
        <!-- 配置查询缓存，查询缓存需要依赖二级缓存 -->
        <property name="hibernate.cache.use_query_cache">true</property>

    </session-factory>
</hibernate-configuration>

（4）另外还需要在model对象上添加@Cache注解

package model.example;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;

@Entity
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class User {
    private int id;
    private String userName;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

}

最后使用Junit测试效果：

package learnhow;

import java.util.List;

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

import model.example.User;
import util.HibernateUtil;

public class HibernateTest {
    private Session session;
    private Transaction transaction;

    @Test
    public void testSecondLevelCache() {
        session = HibernateUtil.getSessionFactory().openSession();
        transaction = session.beginTransaction();
        User user1 = session.get(User.class, 1);
        transaction.commit();
        session.close();
        session = HibernateUtil.getSessionFactory().openSession();
        transaction = session.beginTransaction();
        // 配置二级缓存以后查询同一个对象只发送一条查询语句
        User user2 = session.get(User.class, 1);
        transaction.commit();
        session.close();
    }

    @Test
    public void testQueryCache() {
        session = HibernateUtil.getSessionFactory().openSession();
        transaction = session.beginTransaction();
        String hql = "FROM User";
        // 配置了查询缓存以后，第一次查询将结果集保存进缓存中
        List<User> users_1 = session.createQuery(hql).setCacheable(true).list();
        for (User u : users_1) {
            System.out.println(u.getUserName());
        }
        transaction.commit();
        session.close();
        session = HibernateUtil.getSessionFactory().openSession();
        transaction = session.beginTransaction();
        // 第二次查询直接通过缓存获得结果集
        List<User> users_2 = session.createQuery(hql).setCacheable(true).list();
        for (User u : users_2) {
            System.out.println(u.getUserName());
        }
        transaction.commit();
        session.close();
    }
}

如果以上测试方法都只触发一条查询语句就代表配置生效了。

（有关Hibernate的基础配置，我能想到的大概就这些，要继续深入学习就得读源码了~呼，好累）