Ehcache和Redis封装接口（支持缓存切换）

一、EhCache和Redis简介
EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点。

Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库

二、Ehcache和Redis的区别
1、操作简易程度：Ehcache操作简单易使用；Redis支持多种数据类型，操作较复杂。
2、存取速度：两者存取速度都较快。
3、应用场景：Ehcache更适合用于中小型应用；Redis更适合用于大数据缓存、数据恢复等场景。
4、持久化：Ehcache数据持久化较弱；Redis支持数据持久化，可以将更新的数据写入磁盘或追加记录文件。
5、分布式：Ehcache不适合大型分布式集群部署；Redis支持分布式。

三、封装使用
1、第一步，引入需要的依赖包

<!-- redis依赖-->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- ehcache依赖-->
<dependency>
	<groupId>net.sf.ehcache</groupId>
	<artifactId>ehcache</artifactId>
</dependency>

2、第二步，定义缓存接口

public interface CacheService<K, V> {

    void put(K key, V value, Duration ttl);

    V get(K key);

    void delete(K key);

    V getAndDelete(K key);
}

3、第三步，编写Ehcache实现类，实现CacheService缓存接口

public class EhcacheCacheServiceImpl<K, V> implements CacheService<K, V> {

    private CacheManager cacheManager;

    private static final String CACHE_NAME = "myCache";

    @Override 
    public void put(K key, V value, Duration ttl) {
        Element element = new Element(key, value);
        element.setTimeToLive((int) ttl.getSeconds());
        getCache().put(element);
    }

    @Override 
    public V get(K key) {
        Element element = getCache().get(key);
        return (element != null) ? (V) element.getObjectValue() : null;
    }

    @Override 
    public void delete(K key) {
        getCache().remove(key);
    }

    @Override
    public V getAndDelete(K key) {
        Element element = getCache().removeAndReturnElement(key);
        return (element != null) ? (V) element.getObjectValue() : null;
    }
}

4、第四步，编写Redis实现类，实现CacheService缓存接口

public class RedisCacheServiceImpl <K, V> implements CacheService<K, V> {

    private RedisTemplate<K, V> redisTemplate;

    @Override
    public void put(K key, V value, Duration ttl) {
        redisTemplate.opsForValue().set(key, value, ttl);
    }

    @Override
    public V get(K key) {
        return redisTemplate.opsForValue().get(key);
    }

    @Override
    public void delete(K key) {
        redisTemplate.delete(key);
    }

    @Override
    public V getAndDelete(K key) {
        return redisTemplate.opsForValue().getAndDelete(key);
    }
}

5、最后编写配置类，通过配置控制使用哪一种缓存，支持缓存的切换

@Configuration
@EnableCaching
public class CacheConfig {

    @NacosValue(value = "${cache.type:}", autoRefreshed = true)
    private String cacheType;

    @Autowired(required = false)
    private RedisConnectionFactory redisConnectionFactory;

    @Autowired(required = false)
    private RedisTemplate<String,String> redisTemplate;

    @Bean
    public CacheManager crateCacheManager() {
        if (cacheType.equals("redis")){
            RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(Duration.ofMinutes(10));
            return RedisCacheManager.builder(RedisCacheWriter.lockingRedisCacheWriter(redisConnectionFactory))
                    .cacheDefaults(cacheConfiguration).build();
        } else {
            return  new EhCacheCacheManager(ehCacheFactory().getObject());
        }
    }
    @Bean
    public CacheService<String,String> crateCacheService(net.sf.ehcache.CacheManager cacheManager) {
        if (cacheType.equals("redis")){
            RedisCacheServiceImpl<String,String> redisCacheServiceImpl = new RedisCacheServiceImpl<>();
            redisCacheServiceImpl.setRedisTemplate(redisTemplate);
            return redisCacheServiceImpl;
        } else {
            EhcacheCacheServiceImpl<String,String> cacheCacheServiceImpl = new EhcacheCacheServiceImpl<>();
            cacheCacheServiceImpl.setCacheManager(cacheManager);
            return cacheCacheServiceImpl;
        }
    }

    @Bean
    public EhCacheManagerFactoryBean ehCacheFactory() {
        EhCacheManagerFactoryBean ehCacheFactoryBean = new EhCacheManagerFactoryBean();
        ehCacheFactoryBean.setConfigLocation(new ClassPathResource("ehcache.xml"));
        ehCacheFactoryBean.setShared(true);
        return ehCacheFactoryBean;
    }

}