首页 > 代码库 > Hibernate缓存

Hibernate缓存

2024-09-23 03:43:34   217人阅读

Hibernate中会经经常使用到set等集合来表示1-N的关系。

比方，我有Customer和Order两个对象。当中，在Customer中有一个Order的set集合，表示在一个顾客能够拥有多个Order，而在Order对象中存在了一个Customer的对象，表示这个Order是哪个顾客下的单。这个算是比較典型的双向1-N关联。

这给我们带来了非常大的优点，当我得到了Customer对象的时候，我们能够非常方便的将与其相关联的Order集合查询出来，这也非常符合我们的实际业务，毕竟我们不可能给这个Cutomer对象别人的Order吧，这既不安全。并且对Customer的普通顾客来说，并无卵用。

所以我们不得不说Hibernate的ORM做的非常好。但凡事都有可是（要是没有可是，也就没有写这篇文章的必要了）。

我们再对数据库进行訪问的时候必需要考虑性能问题（通俗点讲。就是用少发SQL语句）。当我们设定了1-N这样的关系后，查询过程中就有可能出现N+1问题。

关于N+1问题。并非本文的重点。

但关于N+1问题，我们须要知道的是，这个问题会导致SQL语句的添加，也就是要与数据库进行很多其它的交互。这无疑会给项目以及后台数据库带来影响。

Hibernate缓存

Hibernate是一个持久化框架。常常须要訪问数据库。

假设我们可以减少应用程序对物理数据库訪问的频次，那会提供应用程序的执行性能。缓存内的数据是对物理数据源中的数据的复制，应用程序执行时先从缓存中读写数据。

缓存就是数据库数据在内存中的暂时容器。包含数据库数据在内存中的暂时拷贝。它位于数据库与数据库訪问层中间。ORM在查询数据时首先会依据自身的缓存管理策略，在缓存中查找相关数据。如发现所需的数据，则直接将此数据作为结果加以利用，从而避免了数据库调用性能的开销。而相对内存操作而言。数据库调用是一个代价高昂的过程。

Hibernate缓存包含两大类：一级缓存和二级缓存。

  • Hibernate一级缓存又被成为“Session的缓存”。Session缓存是内置的。不能被卸载，是事务范围的缓存。

    在一级缓存中。持久化类的每一个实例都具有唯一的OID。

  • Hibernate二级缓存又被称为“SessionFactory的缓存”。因为SessionFactory对象的生命周期和应用程序的整个过程相应，因此Hibernate二级缓存是进程范围或者集群范围的缓存，有可能出现并发问题，因此须要採用适当的并发訪问策略。该策略为被缓存的数据提供了事务隔离级别。

    第二级缓存是可选的，是一个可配置的插件。默认下SessionFactory不会启用这个插件。

那么什么样的数据适合放入到缓存中？

  • 非常少被改动的数据 　　
  • 不是非常重要的数据，同意出现偶尔并发的数据 　　
  • 不会被并发訪问的数据 　　
  • 常量数据

什么样的数据不适合放入到缓存中？　

  • 常常被改动的数据 　　
  • 绝对不同意出现并发訪问的数据，如財务数据。绝对不同意出现并发 　　
  • 与其它应用共享的数据

Hibernate一级缓存

Demo

首先看一个很easy的样例：

 

1
2
3
4
5
6
7
8

@Test
public void test() {
	Customer customer1 = (Customer) session.load(Customer.class, 1);
	System.out.println(customer1.getCustomerName());

	Customer customer2 = (Customer) session.load(Customer.class, 1);
	System.out.println(customer2.getCustomerName());
}

 

看一下控制台的输出：

 

1
2
3
4
5
6
7
8
9
10

Hibernate:
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_
    from
        CUSTOMERS customer0_
    where
        customer0_.CUSTOMER_ID=?
Customer1
Customer1

 

我们能够看到，尽管我们调用了两次session的load方法。但实际上仅仅发送了一条SQL语句。我们第一次调用load方法时候，得到了查询结果，然后将结果放到了session的一级缓存中。此时，当我们再次调用load方法。会首先去看缓存中是否存在该对象，假设存在，则直接从缓存中取出，就不会在发送SQL语句了。

可是，我们看一下以下这个样例：

 

1
2
3
4
5
6
7
8
9
10
11

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

 

我们解释一下上面的代码，在第5、6、7、8行。我们是先将session关闭。然后又又一次打开了新的session。这个时候。我们再看一下控制台的输出结果：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Hibernate:
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_
    from
        CUSTOMERS customer0_
    where
        customer0_.CUSTOMER_ID=?
Customer1
Hibernate:
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_
    from
        CUSTOMERS customer0_
    where
        customer0_.CUSTOMER_ID=?
Customer1

 

我们能够看到，发送了两条SQL语句。其原因是：Hibernate一级缓存是session级别的，所以假设session关闭后。缓存就没了，当我们再次打开session的时候，缓存中是没有了之前查询的对象的，所以会再次发送SQL语句。

我们略微对一级缓存的知识点进行总结一下。然后再開始讨论关于二级缓存的内容。

作用

Session的缓存有三大作用：

  1. 降低訪问数据库的频率。

    应用程序从缓存中读取持久化对象的速度显然比到数据中查询数据的速度快多了。因此Session的缓存能够提高数据訪问的性能。

  2. 当缓存中的持久化对象之间存在循环关联关系时。Session会保证不出现訪问对象图的死循环，以及由死循环引起的JVM堆栈溢出异常。
  3. 保证数据库中的相关记录与缓存中的对应对象保持同步。

小结

  • 一级缓存是事务级别的。每一个事务(session)都有单独的一级缓存。这一级别的缓存是由Hibernate进行管理。普通情况下无需进行干预。
  • 每一个事务都拥有单独的一级缓存不会出现并发问题，因此无须提供并发訪问策略。
  • 当应用程序调用Session的save()、update()、saveOrUpdate()、get()或load()，以及调用查询接口的 list()、iterate()(该方法会出现N+1问题，先查id)方法时，假设在Session缓存中还不存在对应的对象。Hibernate就会把该对象增加到第一级缓存中。

    当清理缓存时，Hibernate会依据缓存中对象的状态变化来同步更新数据库。

    Session为应用程序提供了两个管理缓存的方法： evict(Object obj)：从缓存中清除參数指定的持久化对象。 clear()：清空缓存中全部持久化对象,flush():使缓存与数据库同步。

  • 当查询对应的字段，而不是对象时，不支持缓存。我们能够非常easy举一个样例来说明，看一下以下的代码。

 

1
2
3
4
5
6
7

@Test
public void test() {
	List<Customer> customers = session.createQuery("select c.customerName from Customer c").list();
	System.out.println(customers.size());
	Customer customer2 = (Customer) session.load(Customer.class, 1);
	System.out.println(customer2.getCustomerName());
}

 

我们首先是仅仅取出Customer的name属性，然后又尝试着去Load一个Customer对象，看一下控制台的输出：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Hibernate:
    select
        customer0_.CUSTOMER_NAME as col_0_0_
    from
        CUSTOMERS customer0_
3
Hibernate:
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_
    from
        CUSTOMERS customer0_
    where
        customer0_.CUSTOMER_ID=?
Customer1

 

这一点事实上非常好理解，我本身就没有查处Customer的全部属性，那我又怎么能给你把全部属性都缓存到这个对象中呢？

我们在讲之前的样例中。提到我们关闭session再打开，这个时候一级缓存就不存在了，所以我们再次查询的时候，会再次发送SQL语句。那么假设要解决问题，我们该怎么做？二级缓存能够帮我们解决问题。

Hibernate二级缓存

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）：

 

1
2
3
4

<!-- 启用二级缓存 -->
<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要求的。该文件放到根文件夹下。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

<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文件加一点配置信息：

 

1

<cache usage="read-only"/>

 

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

5、以下我们再进行一下測试。

还是上面的代码：

 

1
2
3
4
5
6
7
8
9
10
11

@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问题。

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

 

1
2
3
4
5
6
7
8
9
10
11

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

 

控制台的结果：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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查询语句。要想解决问题，我们须要用到查询缓存。

查询缓存

在前文中也提到了，我们的一级二级缓存都是对整个实体进行缓存。它不会缓存普通属性，假设想对普通属性进行缓存。则能够考虑使用查询缓存。

但须要注意的是。大部分情况下。查询缓存并不能提高应用程序的性能，甚至反而会减少应用性能，因此实际项目中要慎重的使用查询缓存。

对于查询缓存来说。它缓存的key就是查询所用的HQL或者SQL语句，须要指出的是：查询缓存不仅要求所使用的HQL、SQL语句同样。甚至要求所传入的參数也同样，Hibernate才干直接从缓存中取得数据。仅仅有常常使用同样的查询语句、而且使用同样查询參数才干通过查询缓存获得优点，查询缓存的生命周期直到属性被改动了为止。

查询缓存默认是关闭。要想使用查询缓存，仅仅须要在hibernate.cfg.xml中增加一条配置就可以：

 

1

<property name="hibernate.cache.use_query_cache">true</property>

 

并且，我们在查询hql语句时，要想使用查询缓存。就须要在语句中设置这样一个方法：setCacheable(true)。

关于这个的demo我就不进行演示了，大家能够自己慢慢试着玩一下。

但须要注意的是，我们在开启查询缓存的时候，也应该开启二级缓存。

由于假设不使用二级缓存，也有可能出现N+1的问题。

这是由于查询缓存缓存的不过对象的ID，所以首先会通过一条SQL将对象的ID都查询出来，可是当我们后面要得到每一个对象的信息的时候。此时又会发送SQL语句。所以假设我们使用查询缓存，一定也要开启二级缓存。

总结

这些就是自己今晚上研究的关于Hibernate缓存的一些问题，其出发点也是为了自己可以对Hibernate缓存的知识有一定的总结。

当然了，下一步还须要深入到缓存是怎样实现的这个深度中。

Hibernate缓存


联系
我们