Gradle SpringBoot整合EhCache

1.引入依赖

代码如下（示例）：

// https://mvnrepository.com/artifact/org.ehcache/ehcache
implementation group: 'org.ehcache', name: 'ehcache', version: '3.9.2'

2.创建配置文件

默认自动加载resources目录下的ehcache.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="ehcache.xsd">
    <!--timeToIdleSeconds 当缓存闲置n秒后销毁 -->
    <!--timeToLiveSeconds 当缓存存活n秒后销毁 -->
    <!-- 缓存配置
        name:缓存名称。
        maxElementsInMemory：缓存最大个数。
        eternal:对象是否永久有效，一但设置了，timeout将不起作用。
        timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
        timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
        overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。 diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
        maxElementsOnDisk：硬盘最大缓存个数。
        diskPersistent：是否缓存虚拟机重启期数据 Whether the disk
        store persists between restarts of the Virtual Machine. The default value
        is false.
        diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。  memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是
LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
        clearOnFlush：内存数量最大时是否清除。 -->
    <!-- 磁盘缓存位置 -->
    <diskStore path="java.io.tmpdir" />
    <!-- 默认缓存 -->
    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxElementsOnDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">

        <persistence strategy="localTempSwap" />
    </defaultCache>

    <!-- 测试 -->
    <cache name="GoodsType"
           eternal="false"
           timeToIdleSeconds="2400"
           timeToLiveSeconds="2400"
           maxEntriesLocalHeap="10000"
           maxEntriesLocalDisk="10000000"
           diskExpiryThreadIntervalSeconds="120"
           overflowToDisk="false"
           memoryStoreEvictionPolicy="LRU">
    </cache>
</ehcache>

对于EhCache的配置文件也可以通过application.yml文件中使用spring.cache.ehcache.config属性来指定，比如：

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

3.开启缓存支持

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;

/**
 *
 * @ClassName: EhCacheConfig
 * @Description:配置缓存
 */
@Configuration
@EnableCaching
public class EhCacheConfig {
}

4.项目中使用

import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Repository;

@Repository
@CacheConfig(cacheNames = "GoodsType")
public class GoodsTypeDaoImpl {
    @Cacheable
    public String save(String typeId) {
        System.out.println("save()执行了=============");
        return "模拟数据库保存";
    }

    @CachePut
    public String update(String typeId) {
        System.out.println("update()执行了=============");
        return "模拟数据库更新";
    }

    @CacheEvict
    public String delete(String typeId) {
        System.out.println("delete()执行了=============");
        return "模拟数据库删除";
    }

    @Cacheable
    public String select(String typeId) {
        System.out.println("select()执行了=============");
        return "模拟数据库查询";
    }

}

清除缓存:

@Caching

5.测试

import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
class GoodsTypeDaoImplTest {

    @Autowired
    private GoodsTypeDaoImpl typeDao;

    @Test
    void save() {
        String typeId = "type111";
        // 模拟第一次保存
        String returnStr1 = typeDao.save(typeId);
        System.out.println(returnStr1);
        // 模拟第二次保存
        String returnStr2 = typeDao.save(typeId);
        System.out.println(returnStr2);

    }

    @Test
    public void testUpdate() {
        String typeId = "type111";
        // 模拟第一次查询
        String returnStr1 = typeDao.select(typeId);
        System.out.println(returnStr1);
        // 模拟第二次查询
        String returnStr2 = typeDao.select(typeId);
        System.out.println(returnStr2);
        // 模拟更新
        String returnStr3 = typeDao.update(typeId);
        System.out.println(returnStr3);
        // 模拟查询
        String returnStr4 = typeDao.select(typeId);
        System.out.println(returnStr4);
    }

    @Test
    public void testDelete() {
        String typeId = "type111";
        // 模拟第一次查询
        String returnStr1 = typeDao.select(typeId);
        System.out.println(returnStr1);
        // 模拟第二次查询
        String returnStr2 = typeDao.select(typeId);
        System.out.println(returnStr2);
        // 模拟删除
        String returnStr3 = typeDao.delete(typeId);
        System.out.println(returnStr3);
        // 模拟查询
        String returnStr4 = typeDao.select(typeId);
        System.out.println(returnStr4);
    }

    @Test
    public void testSelect() {
        String typeId = "type111";
        // 模拟第一次查询
        String returnStr1 = typeDao.select(typeId);
        System.out.println(returnStr1);
        // 模拟第二次查询
        String returnStr2 = typeDao.select(typeId);
        System.out.println(returnStr2);
    }

}

个人参考项目:https://blog.csdn.net/qq_28988969/article/details/78210873