Question

Hibernate 中没有自己去实现二级缓存，而是利用第三方的。简单叙述一下配置过程，也作为自己以后用到的时候配置的一个参考。

1、我们需要加入额外的二级缓存包，例如 EHcache，将其包导入。需要：ehcache-core-2.4.3.jar ， hibernate-ehcache-4.2.4.Final.jar ，slf4j-api-1.6.1.jar 2、在 hibernate.cfg.xml 配置文件中配置我们二级缓存的一些属性（此处针对的是 Hibernate4）：

<!-- 启用二级缓存 -->
<property name="cache.use_second_level_cache">true</property>
<!-- 配置使用的二级缓存的产品 -->
<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

3、我们使用的是 EHcache，所以我们需要创建一个 ehcache.xml 的配置文件，来配置我们的缓存信息，这个是 EHcache 要求的。该文件放到根目录下。

<ehcache>
    <!--  
        指定一个目录：当 EHCache 把数据写到硬盘上时，将把数据写到这个目录下.
    -->
    <diskStore path="d:\\tempDirectory"/>
    <!--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"
        />
    <!--  
        设定具体的命名缓存的数据过期策略。每个命名缓存代表一个缓存区域
        缓存区域(region)：一个具有名称的缓存块，可以给每一个缓存块设置不同的缓存策略。
        如果没有设置任何的缓存区域，则所有被缓存的对象，都将使用默认的缓存策略。即：<defaultCache.../>
        Hibernate 在不同的缓存区域保存不同的类/集合。
            对于类而言，区域的名称是类名。如:com.atguigu.domain.Customer
            对于集合而言，区域的名称是类名加属性名。如 com.atguigu.domain.Customer.orders
    -->
    <!--  
        name: 设置缓存的名字，它的取值为类的全限定名或类的集合的名字
        maxElementsInMemory: 设置基于内存的缓存中可存放的对象最大数目

        eternal: 设置对象是否为永久的, true 表示永不过期,
        此时将忽略 timeToIdleSeconds 和 timeToLiveSeconds 属性; 默认值是 false
        timeToIdleSeconds:设置对象空闲最长时间，以秒为单位，超过这个时间，对象过期。
        当对象过期时,EHCache 会把它从缓存中清除。如果此值为 0,表示对象可以无限期地处于空闲状态。
        timeToLiveSeconds:设置对象生存最长时间，超过这个时间，对象过期。
        如果此值为 0,表示对象可以无限期地存在于缓存中. 该属性值必须大于或等于 timeToIdleSeconds 属性值

        overflowToDisk:设置基于内存的缓存中的对象数目达到上限后，是否把溢出的对象写到基于硬盘的缓存中
    -->
    <cache name="com.atguigu.hibernate.entities.Employee"
        maxElementsInMemory="1"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />

    <cache name="com.atguigu.hibernate.entities.Department.emps"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        />

</ehcache>

在注释中，有一些对变量的解释。

4、开启二级缓存。我们在这里使用的 xml 的配置方式，所以要在 Customer.hbm.xml 文件加一点配置信息：

<cache usage="read-only"/>

注意是在标签内。 如果是使用注解的方法，在要在 Customer 这个类中，加入 @Cache(usage=CacheConcurrencyStrategy.READ_ONLY) 这个注解。

5、下面我们再进行一下测试。还是上面的代码：

@Test
public void test() {
    Customer customer1 = (Customer) session.load(Customer.class, 1);
    System.out.println(customer1.getCustomerName());
    transaction.commit();
    session.close();
  session = sessionFactory.openSession();
    transaction = session.beginTransaction();
    Customer customer2 = (Customer) session.load(Customer.class, 1);
    System.out.println(customer2.getCustomerName());
}

我们可以发现控制台只发出了一条 SQL 语句。这是我们二级缓存的一个小 Demo。

我们的二级缓存是 sessionFactory 级别的，所以当我们 session 关闭再打开之后，我们再去查询对象的时候，此时 Hibernate 会先去二级缓存中查询是否有该对象。

同样，二级缓存缓存的是对象，如果我们查询的是对象的一些属性，则不会加入到缓存中。

我们通过二级缓存是可以解决之前提到的 N+1 问题。

已经写了这么多了，但好像我们关于缓存的内容还没有讲完。不要着急，再坚持一下，我们的内容不多了。我们还是通过一个例子来引出下一个话题。 我们说通过二级缓存可以缓存对象，那么我们看一下下面的代码以及输出结果：

@Test
public void test() {
    List<Customer> customers1 = session.createQuery("from Customer").list();
    System.out.println(customers1.size());
    tansaction.commit();
    session.close();
    session = sessionFactory.openSession();
    transaction = session.beginTransaction();
    List<Customer> customers2 = session.createQuery("from Customer").list();
    System.out.println(customers2.size());
}

控制台的结果：

Hibernate:
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_
    from
        CUSTOMERS customer0_
3
Hibernate:
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_
    from
        CUSTOMERS customer0_
3

我们的缓存好像没有起作用哎？这是为啥？当我们通过 list() 去查询两次对象的时候，二级缓存虽然会缓存插叙出来的对象，但不会缓存我们的 hql 查询语句，要想解决这个问题，我们需要用到查询缓存。