一:Encache

1. 什么是Encache

EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。

官网: http://www.ehcache.org/

2. 基本介绍

Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储,缓存加载器,缓存扩展,缓存异常处理程序,一个gzip缓存servlet过滤器,支持REST和SOAP api等特点。

Ehcache最初是由Greg Luck于2003年开始开发。2009年,该项目被Terracotta购买。软件仍然是开源,但一些新的主要功能(例如,快速可重启性之间的一致性的)只能在商业产品中使用,例如Enterprise EHCache and BigMemory。维基媒体Foundationannounced目前使用的就是Ehcache技术。

3. 特点

主要的特性有:

  1. 快速
  2. 简单
  3. 多种缓存策略
  4. 缓存数据有两级:内存和磁盘,因此无需担心容量问题
  5. 缓存数据会在虚拟机重启的过程中写入磁盘
  6. 可以通过RMI、可插入API等方式进行分布式缓存
  7. 具有缓存和缓存管理器的侦听接口
  8. 支持多缓存管理器实例,以及一个实例的多个缓存区域
  9. 提供Hibernate的缓存实现

ehcache与redis的区别

1.redis的数据结构比较丰富,有key-value、hash、set等;ehcache比较简单,只有key-value

2.ehcache直接在jvm虚拟机中缓存,速度快,效率高;但是缓存共享麻烦,集群分布式应用不方便。redis是通过socket访问到缓存服务,效率ecache低,比数据库要快很多,处理集群和分布式缓存方便,有成熟的方案。如果是单个应用或者对缓存访问要求很高的应用,用ehcache。如果是大型系统,存在缓存共享、分布式部署、缓存内容很大的,建议用redis。

二: Encache与Spring 集成

1. 前言

Spring自身并没有实现缓存解决方案,但是对缓存管理功能提供了声明式的支持,能够与多种流行的缓存实现进行集成。

Spring Cache是作用在方法上的(不能理解为只注解在方法上),其核心思想是:当我们在调用一个缓存方法时会把该方法参数和返回结果作为一个键值存放在缓存中,等到下次利用同样的参数调用该方法时将不再执行该方法,而是直接从缓存中获取结果进行返回。所以在使用Spring Cache的时候我们要保证我们的缓存的方法对于相同的方法参数要有相同的返回结果。

2. 开始集成

  • 导入依赖

    1
    2
    3
    4
    5
    <dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>2.10.3</version>
    </dependency>
  • 编写ehcache.xml

    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
    <?xml version="1.0" encoding="UTF-8"?>
    <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">

    <!-- 磁盘缓存位置 在Windows的缓存目录为:C:\Users\登录用户~1\AppData\Local\Temp\ Linux:/tmp -->
    <diskStore path="java.io.tmpdir/ehcache"/>

    <!--name:缓存名称。-->
    <!--maxElementsInMemory:缓存最大个数。-->
    <!--eternal:缓存中对象是否为永久的,如果是,超时设置将被忽略,对象从不过期。-->
    <!--timeToIdleSeconds:置对象在失效前的允许闲置时间(单位:秒)。仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。-->
    <!--timeToLiveSeconds:缓存数据的生存时间(TTL),也就是一个元素从构建到消亡的最大时间间隔值,这只能在元素不是永久驻留时有效,如果该值是0就意味着元素可以停顿无穷长的时间。-->
    <!--maxEntriesLocalDisk:当内存中对象数量达到maxElementsInMemory时,Ehcache将会对象写到磁盘中。-->
    <!--overflowToDisk:内存不足时,是否启用磁盘缓存。-->
    <!--diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。-->
    <!--maxElementsOnDisk:硬盘最大缓存个数。-->
    <!--diskPersistent:是否在VM重启时存储硬盘的缓存数据。默认值是false。-->
    <!--diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认是120秒。-->
    <!--memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。-->
    <!--clearOnFlush:内存数量最大时是否清除。-->

    <!--@Cacheable(value = "users", condition = "#user.getId() <= 2")-->
    <!--@CachePut(value = "users", key = "#user.getId()")-->
    <!--@CacheEvict(value = "users", allEntries = true)-->


    <!-- 默认缓存 -->
    <defaultCache
    maxEntriesLocalHeap="10000"
    eternal="false"
    timeToIdleSeconds="120"
    timeToLiveSeconds="120"
    maxEntriesLocalDisk="10000000"
    diskExpiryThreadIntervalSeconds="120"
    memoryStoreEvictionPolicy="LRU">
    <persistence strategy="localTempSwap"/>
    </defaultCache>

    <!-- 博客文章详情缓存 -->
    <cache name="articlesDetail"
    maxElementsInMemory="1000"
    eternal="false"
    timeToIdleSeconds="120"
    timeToLiveSeconds="120"
    overflowToDisk="false"
    memoryStoreEvictionPolicy="LRU"/>

    <!-- hotArticles缓存 -->
    <cache name="articlesDetail"
    maxElementsInMemory="1000"
    eternal="true"
    overflowToDisk="false"
    memoryStoreEvictionPolicy="LRU"/>

    </ehcache>
  • 在需要缓存的地方加上缓存注解

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    /**
    * 第一次执行会缓存文章,以id作为key, 第二次会直接取缓存的数据(需要在缓存有效期,过期会重新查询数据库)
    * @param id
    * @return
    */
    @Override
    @Cacheable(value = "articlesDetail", key = "#id")
    public BlogArticles selectByPrimaryKey(Integer id) {
    return getMappser().selectByPrimaryKey(id);
    }

    /**
    * 保存文章,同时删除record.getId()该已存的缓存数据
    * @param record
    * @return
    */
    @Override
    @CacheEvict(value = "articlesDetail", key = "#record.getId()")
    public int updateByPrimaryKeySelective(BlogArticles record) {
    setCurrentOperator(record);
    return getMappser().updateByPrimaryKeySelective(record);
    }

3. 注解讲解

首先使用注解标记方法,相当于定义了切点,然后使用Aop技术在这个方法的调用前、调用后获取方法的入参和返回值,进而实现了缓存的逻辑。

  • @Cacheable
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
表明所修饰的方法是可以缓存的:当第一次调用这个方法时,它的结果会被缓存下来,在缓存的有效时间内,以后访问这个方法都直接返回缓存结果,不再执行方法中的代码段。 
这个注解可以用condition属性来设置条件,如果不满足条件,就不使用缓存能力,直接执行方法。
可以使用key属性来指定key的生成规则。

@Cacheable 支持如下几个参数:

value:缓存位置名称,不能为空,如果使用EHCache,就是ehcache.xml中声明的cachename, 指明将值缓存到哪个Cache
key:缓存的key,默认为空,既表示使用方法的参数类型及参数值作为key,支持SpEL,如果要引用参数值使用井号加参数名,如:#userId,

一般来说,我们的更新操作只需要刷新缓存中某一个值,所以定义缓存的key值的方式就很重要,最好是能够唯一,因为这样可以准确的清除掉特定的缓存,而不会影响到其它缓存值 ,
本例子中使用实体加冒号再加ID组合成键的名称,如”user:1”、”order:223123”等

condition:触发条件,只有满足条件的情况才会加入缓存,默认为空,既表示全部都加入缓存,支持SpEL


// 将缓存保存到名称为UserCache中,键为"user:"字符串加上userId值,如 'user:1'
@Cacheable(value="UserCache", key="'user:' + #userId")
public User findById(String userId) {
return (User) new User("1", "mengdee");
}

// 将缓存保存进UserCache中,并当参数userId的长度小于12时才保存进缓存,默认使用参数值及类型作为缓存的key
// 保存缓存需要指定key,value, value的数据类型,不指定key默认和参数名一样如:"1"
@Cacheable(value="UserCache", condition="#userId.length() < 12")
public boolean isReserved(String userId) {
System.out.println("UserCache:"+userId);
return false;
}
  • @CachePut
1
与@Cacheable不同,@CachePut不仅会缓存方法的结果,还会执行方法的代码段。它支持的属性和用法都与@Cacheable一致。
  • @CacheEvict

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    与@Cacheable功能相反,@CacheEvict表明所修饰的方法是用来删除失效或无用的缓存数据。

    @CacheEvict 支持如下几个参数:

    value:缓存位置名称,不能为空,同上
    key:缓存的key,默认为空,同上
    condition:触发条件,只有满足条件的情况才会清除缓存,默认为空,支持SpEL
    allEntries:true表示清除value中的全部缓存,默认为false

    //清除掉UserCache中某个指定key的缓存
    @CacheEvict(value="UserCache",key="'user:' + #userId")
    public void removeUser(User user) {
    System.out.println("UserCache"+user.getUserId());
    }

    //清除掉UserCache中全部的缓存
    @CacheEvict(value="UserCache", allEntries=true)
    public final void setReservedUsers(String[] reservedUsers) {
    System.out.println("UserCache deleteall");
    }
  • @Caching

    1
    2
    3
    4
    如果需要使用同一个缓存注解(@Cacheable、@CacheEvict或@CachePut)多次修饰一个方法,就需要用到@Caching。

    @Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames="secondary", key="#p0") })
    public Book importBooks(String deposit, Date date)
  • @CacheConfig

    1
    2
    3
    4
    5
    6
    7
    8
    与前面的缓存注解不同,这是一个类级别的注解。
    如果类的所有操作都是缓存操作,你可以使用@CacheConfig来指定类,省去一些配置。

    @CacheConfig("books")
    public class BookRepositoryImpl implements BookRepository {
    @Cacheable
    public Book findBook(ISBN isbn) {...}
    }

4. 创建Cache工具类, 方便对cache进行管理

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
package com.ecut.core.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;

/**
* 缓存工具类
* @author songshuiyang
* @date 2018/3/24 12:16
*/
public class CacheUtils {

private final static Logger logger = LoggerFactory.getLogger(CacheUtils.class);

private static CacheManager cacheManager = (CacheManager) SpringContextUtils.getBean("cacheManager");

/**
* 获取缓存
* @param cacheName 缓存名
* @param key 键
* @return Object
*/
public static Object get(String cacheName, Object key) {
Cache cache = cacheManager.getCache(cacheName);
if (cache != null) {
//这里需要判断是否null
if(cache.get(key) != null){
return cache.get(key).get();
}
}
return null;
}
/**
* 添加缓存
* 存在则更新
* @param cacheName 缓存名
* @param key 键
* @param value 值
*/
public static void put(String cacheName, Object key, Object value) {
Cache cache = cacheManager.getCache(cacheName);
if(cache != null){
cache.put(key, value);
}
}
/**
* 清除缓存
* @param cacheName 缓存名
* @param key 键
*/
public static void remove(String cacheName, Object key) {
Cache cache = cacheManager.getCache(cacheName);
if (cache != null) {
cache.evict(key);
}else{
logger.warn("this key is not in Cache");
}
}
}

}

参考:
https://blog.csdn.net/vbirdbest/article/details/72763048
http://www.cnblogs.com/jingmoxukong/p/5975994.html