SpringBoot整合Ehcache缓存

最新推荐文章于 2024-04-09 22:24:19 发布

Rain_storms

最新推荐文章于 2024-04-09 22:24:19 发布

阅读量516

点赞数 2

分类专栏： Java #SpringBoot 文章标签： EhCache

本文链接：https://blog.csdn.net/zhaochengweicsdn/article/details/103610309

版权

Java 同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

#SpringBoot

1 篇文章 0 订阅

订阅专栏

Ehcache 是 Java 领域比较优秀的缓存方案之一，Ehcache 这个缓存的名字很有意思，正着念反着念，都是 Ehcache，Spring Boot 中对此也提供了很好的支持，这个支持主要是通过 Spring Cache 来实现的。

一、pom文件加上ehcache的依赖

 <!-- cache -->
 <dependency>
   <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-cache</artifactId>
 </dependency>

 <dependency>
   <groupId>net.sf.ehcache</groupId>
      <artifactId>ehcache</artifactId>
       <version>2.8.2</version>
 </dependency>

二、配置ehcache.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--   *****  属性是必须的  *****   -->
    <!-- name： Cache的名称，必须是唯一的(ehcache会把这个cache放到HashMap里) -->
    <!-- maxElementsInMemory：在内存中缓存的element的最大数目 -->
    <!-- maxElementsOnDisk：在磁盘上缓存的element的最大数目，默认值为0，表示不限制 -->
    <!-- eternal：设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断 -->
    <!-- overflowToDisk： 如果内存中数据超过内存限制，是否要缓存到磁盘上 -->
    <!--   *****  属性是不必须的  *****   -->
    <!-- timeToIdleSeconds： 对象空闲时间，指对象在多长时间没有被访问就会失效。只对eternal为false的有效。默认值0，表示一直可以访问 -->
    <!-- timeToLiveSeconds： 对象存活时间，指对象从创建到失效所需要的时间。只对eternal为false的有效。默认值0，表示一直可以访问 -->
    <!-- diskPersistent： 是否在磁盘上持久化。指重启jvm后，数据是否有效。默认为false -->
    <!-- diskExpiryThreadIntervalSeconds： 对象检测线程运行时间间隔。标识对象状态的线程多长时间运行一次 -->
    <!-- diskSpoolBufferSizeMB： DiskStore使用的磁盘大小，默认值30MB。每个cache使用各自的DiskStore -->
    <!-- memoryStoreEvictionPolicy： 如果内存中数据超过内存限制，向磁盘缓存时的策略。默认值LRU，可选FIFO、LFU -->
    <!--缓存3种策略 -->
    <!-- FIFO ，first in first out (先进先出) -->
    <!-- LFU ， Less Frequently Used (最少使用).意思是一直以来最少被使用的。缓存的元素有一个hit 属性，hit 值最小的将会被清出缓存 -->
    <!-- LRU ，Least Recently Used(最近最少使用). (ehcache 默认值).缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存 -->
    <defaultCache maxElementsInMemory="10000" eternal="false"
            timeToIdleSeconds="120" timeToLiveSeconds="180" memoryStoreEvictionPolicy="FIFO"  overflowToDisk="false" />

    <cache
            name="myCache"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="180"
            timeToLiveSeconds="180"
            memoryStoreEvictionPolicy="LRU"/>
</ehcache>

三、spring指定ehcache配置文件路径

1. 如果是application.yml文件需配置

spring: 
  cache:
    ehcache:
      config: classpath:ehcache.xml

2. 如果是application.properties文件需配置

spring.cache.ehcache.config=classpath:ehcache.xml

3. 如果是普通的spring（SSM）项目需配置

四、启动类上加上 @EnableCaching开启缓存

@SpringBootApplication
@EnableCaching
@MapperScan(basePackages = {"com.example.testyc.*"})
public class TestYcApplication {
    public static void main(String[] args) {
        SpringApplication.run(TestYcApplication.class, args);
    }
}

五、cache实战（先写例子，后面具体描述cache注解的使用和注意事项）

1.创建EhcacheConfig文件

@Service
public class EhcacheConfig {

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

    /**
     * 注入cacheManager，cacheManager是缓存管理器，管理各种缓存（cache）组件
     */
    @Autowired
    private CacheManager cacheManager;

    /**
     * 缓存数据
     *
     * @param cacheName 缓存域名称
     * @param key       缓存键
     * @param obj       缓存值
     * @return
     */
    public String save(String cacheName, String key, Object obj) {
        Cache cache = cacheManager.getCache(cacheName);
        cache.put(key, obj);
        return "success";
    }

    /**
     * 获取缓存
     *
     * @param cacheName 缓存域名称
     * @param key       缓存键
     * @return
     */
    public String get(String cacheName, String key) {
        Cache cache = cacheManager.getCache(cacheName);
        return cache.get(key, String.class);
    }

    /**
     * 移除缓存
     *
     * @param cacheName 缓存域名称
     * @param key       缓存键
     */
    public void remove(String cacheName, String key) {
        Cache cache = cacheManager.getCache(cacheName);
        logger.info("删除缓存键值:" + key);
        cache.evict(key);
    }

    /**
     * （注解式）存入缓存，如果已经存在key，则会覆盖key对应的val
     *
     * @param key 缓存键
     * @param val 缓存值
     * @return
     */
    @CachePut(key = "#key", value = "myCache")
    public String annotationSave(String key, String val) {
        return val;
    }

    /**
     * （注解式）移除缓存
     *
     * @param key 缓存键
     */
    @CacheEvict(value = "myCache", key = "#key")
    public void annotationRemove(String key) {
        logger.info("移除了缓存:" + key);
    }

    /**
     * （注解式）存入缓存，如果已经存在key，会直接把key的val返回
     *
     * @param key
     * @param val
     * @return
     */
    @Cacheable(key = "#key", value = "myCache")
    public String cacheIng(String key, String val) {
        return val;
    }

    public String testSave(String key, String val) {
        this.annotationSave(key, val);
        Object object = get("myCache", key);
        return "";
    }
}

2、编写测试类，测试缓存

@Slf4j
@SpringBootTest
class TestYcApplicationTests {

    @Autowired
    private EhcacheConfig ehcacheConfig;

    private Logger logger = LoggerFactory.getLogger(TestYcApplicationTests.class);

    @Test
    public void testCache() {
        String cacheName = "myCache";
        String key = "13333333333";
        String val = "测试缓存";
        //保存缓存
        ehcacheConfig.save(cacheName, key, val);
        //获取缓存
        Object object = ehcacheConfig.get(cacheName, key);
        log.info("输出缓存:{}", object.toString());
        //删除缓存
        ehcacheConfig.remove(cacheName, key);
        //获取缓存
        Object object2 = ehcacheConfig.get(cacheName, key);
        log.info("重新输出缓存:{}", object2);
    }

    @Test
    public void testAnnotationCache() {
        String key = "18888888888";
        String val = "注解方式测试缓存";
        //保存缓存
        ehcacheConfig.annotationSave(key, val);
        //获取缓存
        Object object = ehcacheConfig.cacheIng(key, val);
        log.info("注解方式输出缓存:{}", object.toString());
        //删除缓存
        ehcacheConfig.annotationRemove(key);
        //获取缓存
        Object object2 = ehcacheConfig.get("myCache", key);
        log.info("注解方式重新输出缓存:{}", object2);
    }
}

testCache方法的测试结果为：

testAnnotationCache方法测试的结果为：

六、ehcache注解详情

1、@Cacheable、@CachePut、@CacheEvict 主要的参数

名称	解释
value	缓存的名称，在 spring 配置文件中定义，必须指定至少一个例如： @Cacheable(value=”mycache”) 或者 @Cacheable(value={”cache1”,”cache2”} @CachePut(value=”mycache”) @CacheEvict(value=”mycache”)
key	缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，如果不指定，则缺省按照方法的所有参数进行组合例如： @Cacheable(value=”testcache”,key=”#id”) @CachePut(value=”testcache”,key=”user.id”) @CacheEvict(value=”testcache”,key=”#p[0]”)
condition	缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才进行缓存/清除缓存例如： @Cacheable(value=”testcache”,condition=”#userName.length()>2”) @CachePut(value=”testcache”,condition=”#userName.length()>2”) @CacheEvict(value=”testcache”,condition=”#userName.length()>2”)
unless	否定缓存。当条件结果为true时，就不会缓存。 @Cacheable(value=”testcache”,unless=”#userName.length()>2”)
allEntries (@CacheEvict )	allEntries是boolean类型，表示是否需要清除缓存中的所有元素。默认为false，表示不需要。当指定了allEntries为true时，Spring Cache将忽略指定的key。有的时候我们需要Cache一下清除所有的元素，这比一个一个清除元素更有效率。例如： @CachEvict(value=”testcache”,allEntries=true)
beforeInvocation (@CacheEvict)	清除操作默认是在对应方法成功执行之后触发的，即方法如果因为抛出异常。而未能成功返回时也不会触发清除操作。使用beforeInvocation可以改变触发清除操作的时间，当我们指定该属性值为true时，Spring会在调用该方法之前清除缓存中的指定元素。例如： @CachEvict(value=”testcache”，beforeInvocation=true)

2、SpEL上下文数据（来自Spring官方文档）

名称	位置	描述	示例
methodName	root对象	当前被调用的方法名	`#root.methodname`
method	root对象	当前被调用的方法	`#root.method.name`
target	root对象	当前被调用的目标对象实例	`#root.target`
targetClass	root对象	当前被调用的目标对象的类	`#root.targetClass`
args	root对象	当前被调用的方法的参数列表	`#root.args[0]`
caches	root对象	当前方法调用使用的缓存列表	`#root.caches[0].name`
Argument Name	执行上下文	当前被调用的方法的参数，如findArtisan(Artisan artisan),可以通过#artsian.id获得参数	`#artsian.id`
result	执行上下文	方法执行后的返回值（仅当方法执行后的判断有效，如 unless cacheEvict的beforeInvocation=false）	`#result`

注意：

1.当我们要使用root对象的属性作为key时我们也可以将“#root”省略，因为Spring默认使用的就是root对象的属性。如

@Cacheable(key = "targetClass + methodName +#p0")

2.使用方法参数时我们可以直接使用“#参数名”或者“#p参数index”。

如：

@Cacheable(value="users", key="#id")

@Cacheable(value="users", key="#p0")

3、SpEL提供了多种运算符

类型	运算符
关系型运算符	<，>，<=，>=，==，!=，lt，gt，le，ge，eq，ne
算术型运算符	+，- ，* ，/，%，^
逻辑型运算符	&&，\|\|，!，and，or，not，between，instanceof
条件型运算符	?: (ternary)，?: (elvis)
正则表达式	matches
其他类型	?.，?[…]，![…]，^[…]，$[…]

七、ehcache缓存介绍及示例

1、@Cacheable 会先查询是否已经有缓存，有缓存会直接返回缓存，没有则会执行方法并缓存

如：

    @Cacheable(value = "myCache" ,key = "targetClass + methodName +#p0")
    public List<Emp> queryAll(EmpParameter emp) {
        return empMapper.queryEmp(emp);
    }

缓存参数value是必需的，它指定了你的缓存存放在哪块命名空间。

方法参数的User实体类一定要实现序列化implements Serializable，否则会报java.io.NotSerializableException异常

2、@CachePut 主要针对方法缓存，方法必须有返回值，@CachePut会将方法的参数作为key，方法的返回值作为缓存的内容。与@Cacheable区别是，@CachePut每次都会执行缓存操作。@Cacheable则会先查询是否已经有缓存，有缓存会直接返回缓存，没有才会执行方法进行缓存。

如：

@CachePut(value = "myCache", key = "#parameter")
    public Emp updata(EmpParameter parameter) {
        Emp emp = empMapper.queryEmp(parameter.getId());
        empMapper.updata(parameter);
        return emp;
    }

3、@CacheEvict 主要针对方法配置，能够根据一定的条件对缓存进行清空。@CacheEvict可以指定的属性有value、key、condition、allEntries和beforeInvocation。其中value、key和condition的语义与@Cacheable对应的属性类似。即value表示清除操作是发生在哪些Cache上的（对应Cache的名称）；key表示需要清除的是哪个key，如未指定则会使用默认策略生成的key；condition表示清除操作发生的条件。

如：

    //清除一条缓存，key为要清空的数据
    @CacheEvict(value="myCache",key="#id")
    public void delect(int id) {
        empMapper.deleteAllById(id);
    }

    //方法调用后清空所有缓存
    /**
     *allEntries是boolean类型，表示是否需要清除缓存中的所有元素。默认为false，表示不需要。当指定 
     *了allEntries为true时，Spring Cache将忽略指定的key。有的时候我们需要Cache一下清除所有的元            
     *素，这比一个一个清除元素更有效率。
     */
    @CacheEvict(value="myCache",allEntries=true)
    public void delectAll() {
        empMapper.deleteAll();
    }

    //方法调用前清空所有缓存
    /**
     *清除操作默认是在对应方法成功执行之后触发的，即方法如果因为抛出异常而未能成功返回时也不会触发            
     *清除操作。使用beforeInvocation可以改变触发清除操作的时间，当我们指定该属性值为true时，        
     *Spring会在调用该方法之前清除缓存中的指定元素。
     */
    @CacheEvict(value="myCache",beforeInvocation=true)
    public void delectAll() {
        empMapper.deleteAll();
    }

4、@Caching 分组的注解，能够同时应用多个其他的缓存注解。其拥有三个属性：cacheable、put和evict，分别用于指定@Cacheable、@CachePut和@CacheEvict。

如：

@Caching(cacheable = {
            @Cacheable(value = "emp",key = "#p0"),
            @Cacheable(value = "emp",key = "#p0")
    },
    put = {
            @CachePut(value = "emp",key = "#p0"),
            @CachePut(value = "emp",key = "#p0")
    },evict = {
            @CacheEvict(value = "emp",key = "#p0"),
           @CacheEvict(value = "emp",key = "#p0")
    })
    public Emp save(EmpParameter parameter) {
        ....
    }