springboot整合EHCache的实践方案

下面就是“springboot整合EHCache的实践方案”的完整攻略，过程中将会包含两条实例：

1. 添加依赖

首先，在pom.xml文件中添加如下依赖：

<dependencies>
    <!-- Spring Boot 依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- EHCache 依赖 -->
    <dependency>
        <groupId>net.sf.ehcache</groupId>
        <artifactId>ehcache</artifactId>
        <version>2.10.6</version>
    </dependency>
</dependencies>

2. 配置 EHCache

在 resources 文件夹下创建一个名为 ehcache.xml 的文件，并添加如下配置：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
    <defaultCache maxElementsInMemory="10000" eternal="false"
            timeToIdleSeconds="300" timeToLiveSeconds="600"
            overflowToDisk="true" diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"/>

    <!--定义缓存名称xx，缓存大小为10000个对象,缓存最大时间为10分钟，缓存空闲时间为5分钟-->
    <cache name="xx"
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="300"
            timeToLiveSeconds="600"
            overflowToDisk="true"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"/>

    <!--定义缓存名称yy，缓存大小为100个对象,缓存最大时间为5分钟，缓存空闲时间为1分钟-->
    <cache name="yy"
            maxElementsInMemory="100"
            eternal="false"
            timeToIdleSeconds="60"
            timeToLiveSeconds="300"
            overflowToDisk="true"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"/>

</ehcache>

3. 创建 Ehcache 配置类

创建一个 EhcacheConfig 类，并添加如下代码：

import org.ehcache.config.CacheConfiguration;
import org.ehcache.config.builders.CacheConfigurationBuilder;
import org.ehcache.config.builders.ResourcePoolsBuilder;
import org.ehcache.config.units.EntryUnit;
import org.ehcache.config.units.MemoryUnit;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnClass(Ehcache.class)
@EnableCaching
public class EhcacheConfig {

    @Bean
    public CacheManager cacheManager() {
        return new EhCacheCacheManager(ehCacheManager());
    }

    @Bean(destroyMethod = "close")
    public Ehcache ehCacheManager() {
        CacheConfiguration<Object, Object> cacheConfiguration = CacheConfigurationBuilder
            .newCacheConfigurationBuilder(Object.class, Object.class, ResourcePoolsBuilder.heap(1000).offheap(10, MemoryUnit.MB))
            .withExpiry(Expirations.timeToLiveExpiration(org.ehcache.expiry.Duration.ofSeconds(600)))
            .build();
        return (Ehcache) EhcacheBuilder.newCacheManagerBuilder()
            .with(CacheManagerBuilder.persistence(new File("D:\\test")))
            .withCache("xx", cacheConfiguration).build(true)
            .getCache("xx", Object.class, Object.class);
    }

}

在上面的配置中，我们创建了一个新的缓存 "xx"，它有1000个对象的缓存，10MB的堆外内存，缓存最大时间为10分钟。

4. 使用缓存

实例1：使用 @Cacheable 注解

@RestController
@RequestMapping("/test")
public class TestController {

    @Resource
    private TestService testService;

    @GetMapping("/get/{id}")
    @Cacheable(cacheNames = "xx", key = "#id")
    public Test get(@PathVariable("id") Long id) {
        return testService.get(id);
    }

    @PostMapping("/save")
    public void save(@RequestBody Test test) {
        testService.save(test);
    }
}

在上面的代码中，我们使用了 @Cacheable 注解，它将缓存方法的返回值，并以指定的 key 存储在缓存中。

实例2：手动操作缓存

@RestController
@RequestMapping("/test")
public class TestController {

    @Resource
    private TestService testService;

    @Resource
    private CacheManager cacheManager;

    @GetMapping("/get/{id}")
    public Test get(@PathVariable("id") Long id) {
        Cache cache = cacheManager.getCache("xx");
        Element element = cache.get(id);
        if (element != null) {
            return (Test) element.getObjectValue();
        } else {
            Test test = testService.get(id);
            cache.put(new Element(id, test));
            return test;
        }
    }

    @PostMapping("/save")
    public void save(@RequestBody Test test) {
        testService.save(test);
        Cache cache = cacheManager.getCache("xx");
        cache.put(new Element(test.getId(), test));
    }
}

在上面的代码中，我们手动获取缓存实例，并使用缓存实例的 put 和 get 方法来操作缓存。需要注意的是，这种方式仅适用于非对象序列化类型的缓存。

至此，我们完成了 springboot 整合 EHCache 的实践方案，希望这篇攻略能够帮到你！