SpringBoot配置多個cache，實現多個cacheManager靈活切換

注：本文所用的springBoot版本號為1.5.6.6

目的&效果

在springBoot中同時配置了RedisCache和ehCache，當使用@Cacheable註解時，預設為redisCache，通過指定註解中"cacheManager"的屬性值，達到任意切換cache的效果。

第一次嘗試

由於@Cacheable註解是可以通過引數指定CacheManager或CacheResolver的，因此推斷springCache本身支援配置多個CacheManager。

首先嚐試直接配置RedisCacheManager和EhCacheCacheManager，結果啟動報錯：

分析

理論上只要在其中一個CacheManager的bean上加上@primary註解就可以解決這個報錯了。 但是這樣解決看起來是不優雅的。

從程式碼中看，在CacheAspectSupport.afterSingletonsInstantiated方法中，會先通過getCacheResolver方法嘗試獲取類中的成員變數cacheResolver，如果沒有獲取到，才會通過getBean方法嘗試獲取預設的cacheManager並通過cacheManager建立一個cacheResolver。 也就是說，在此之前是有地方設定預設cacheManager的。

一路檢視原始碼，最終發現， springCache會在配置類ProxyCachingConfiguration通過@Bean例項化一個CacheInterceptor（CacheAspectSupport的子類），並給interceptor的cacheResolver、cacheManager等成員變數賦值：

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public CacheInterceptor cacheInterceptor() {
		CacheInterceptor interceptor = new CacheInterceptor
 
();
		interceptor.setCacheOperationSources(cacheOperationSource());
		if (this.cacheResolver != null) {
			interceptor.setCacheResolver(this.cacheResolver);
		}
		else if (this.cacheManager != null) {
			interceptor.setCacheManager(this.cacheManager);
		}
		if (this.keyGenerator != null) {
			interceptor.setKeyGenerator(this.keyGenerator);
		}
		if (this.errorHandler != null) {
			interceptor.setErrorHandler(this.errorHandler);
		}
		return interceptor;
	}

而用來賦值的cacheManager等，是在ProxyCachingConfiguration的父類，抽象配置類AbstractCachingConfiguration裡面獲取到預設值的：

	@Autowired(required = false)
	void setConfigurers(Collection<CachingConfigurer> configurers) {
		if (CollectionUtils.isEmpty(configurers)) {
			return;
		}
		if (configurers.size() > 1) {
			throw new IllegalStateException(configurers.size() + " implementations of " +
					"CachingConfigurer were found when only 1 was expected. " +
					"Refactor the configuration such that CachingConfigurer is " +
					"implemented only once or not at all.");
		}
		CachingConfigurer configurer = configurers.iterator().next();
		useCachingConfigurer(configurer);
	}

	/**
	 * Extract the configuration from the nominated {@link CachingConfigurer}.
	 */
	protected void useCachingConfigurer(CachingConfigurer config) {
		this.cacheManager = config.cacheManager();
		this.cacheResolver = config.cacheResolver();
		this.keyGenerator = config.keyGenerator();
		this.errorHandler = config.errorHandler();
	}

因此，只需實現CachingConfigurer配置介面編寫配置類，並重寫其cacheManager方法提供預設的cacheManager就可以指定預設的cacheManager了。

最終方案

step0 首先確保maven中已經引入了相關jar包依賴，主要包括redis和ehcache的相關依賴。

        <!--快取,redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>2.10.4</version>
        </dependency>

step1 在application.yml中新增redis的連線配置和ehcache的配置。

spring:
    redis:
      # Connection URL, will override host, port and password (user will be ignored), e.g. redis://user:[email protected]:6379
      url: redis://localhost:6379
      pool:
            maxActive: 8  # 連線池最大連線數（使用負值表示沒有限制）
            maxWait: 800 # 連線池最大阻塞等待時間（使用負值表示沒有限制）
            maxIdle: 8 # 連線池中的最大空閒連線
            minIdle: 2 # 連線池中的最小空閒連線
      timeout: 2000 # 連線或讀取超時時長（毫秒）

    cache:
        type: ehcache
        ehcache:
          config: ehcache.xml

step2 在專案的resources目錄下，新增ehcache.xml配置檔案。

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
    <!-- 指定一個檔案目錄，當EhCache把資料寫到硬碟上時，將把資料寫到這個檔案目錄下 -->
    <!--<diskStore path="logs/ehcache"/>-->

    <!-- 設定快取的預設資料過期策略 -->
    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            overflowToDisk="true"
            timeToIdleSeconds="10"
            timeToLiveSeconds="20"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"/>

    <cache name="cp_salary:cache:10m"
           maxElementsInMemory="100000"
           eternal="false"
           overflowToDisk="false"
           timeToIdleSeconds="10"
           timeToLiveSeconds="600"/>

    <cache name="cp_salary:cache:20m"
           maxElementsInMemory="100000"
           eternal="false"
           overflowToDisk="false"
           timeToIdleSeconds="10"
           timeToLiveSeconds="1200"/>

    <cache name="cp_salary:cache:30m"
           maxElementsInMemory="100000"
           eternal="false"
           overflowToDisk="false"
           timeToIdleSeconds="10"
           timeToLiveSeconds="1800"/>

</ehcache>

step3 編寫CacheManagerConfig類，在類裡通過@Bean註解生成RedisCacheManager和EhCacheCacheManager的bean。參考程式碼如下。

package com.lianjia.sh.salary.payroll.config;

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import com.google.common.collect.ImmutableMap;
import org.springframework.boot.autoconfigure.cache.CacheManagerCustomizer;
import org.springframework.boot.autoconfigure.cache.CacheProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.cache.ehcache.EhCacheManagerUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * @author Stephen.Shi
 * @summary CacheManager配置
 * @since 2018/9/9
 */
@Configuration
@EnableCaching
@EnableConfigurationProperties(CacheProperties.class)
public class CacheManagerConfig {
    private final CacheProperties cacheProperties;

    CacheManagerConfig(CacheProperties cacheProperties) {
        this.cacheProperties = cacheProperties;
    }

    /**
     * cacheManager名字
     */
    public interface CacheManagerNames {
        /**
         * redis
         */
        String REDIS_CACHE_MANAGER = "redisCacheManager";

        /**
         * ehCache
         */
        String EHCACHE_CACHE_MAANGER = "ehCacheCacheManager";
    }

    /**
     * 快取名，名稱暗示了快取時長 注意： 如果添加了新的快取名，需要同時在下面的RedisCacheCustomizer#RedisCacheCustomizer裡配置名稱對應的快取時長
     * ，時長為0代表永不過期；快取名最好公司內部唯一，因為可能多個專案共用一個redis。
     *
     * @see RedisCacheCustomizer#customize(RedisCacheManager)
     */
    public interface CacheNames {
        /** 15分鐘快取組 */
        String CACHE_15MINS = "cp_salary:cache:15m";
        /** 30分鐘快取組 */
        String CACHE_30MINS = "cp_salary:cache:30m";
        /** 60分鐘快取組 */
        String CACHE_60MINS = "cp_salary:cache:60m";
        /** 180分鐘快取組 */
        String CACHE_180MINS = "cp_salary:cache:180m";
    }

    /**
     * ehcache快取名
     */
    public interface EhCacheNames {
        String CACHE_10MINS = "cp_salary:cache:10m";

        String CACHE_20MINS = "cp_salary:cache:20m";

        String CACHE_30MINS = "cp_salary:cache:30m";
    }

    @Bean
    public RedisTemplate redisTemplate(JedisConnectionFactory jedisConnectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(jedisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericFastJsonRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    /**
     * 預設的redisCacheManager
     * @param redisTemplate 通過引數注入，這裡沒有手動給它做配置。在引入了redis的jar包，並且往
     * application.yml裡添加了spring.redis的配置項，springboot的autoconfig會自動生成一個
     * redisTemplate的bean
     * @return
     */
    @Bean
    public RedisCacheManager redisCacheManager(RedisTemplate<Object, Object> redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        cacheManager.setUsePrefix(true);
        this.redisCacheManagerCustomizer().customize(cacheManager);
        return cacheManager;
    }

    /** cache的一些自定義配置 */
    @Bean
    public RedisCacheCustomizer redisCacheManagerCustomizer() {
        return new RedisCacheCustomizer();
    }

    private static class RedisCacheCustomizer
            implements CacheManagerCustomizer<RedisCacheManager> {
        /** CacheManager快取自定義初始化比較早，儘量不要@autowired 其他spring 元件 */
        @Override
        public void customize(RedisCacheManager cacheManager) {
            // 自定義快取名對應的過期時間
            Map<String, Long> expires = ImmutableMap.<String, Long>builder()
                    .put(CacheNames.CACHE_15MINS, TimeUnit.MINUTES.toSeconds(15))
                    .put(CacheNames.CACHE_30MINS, TimeUnit.MINUTES.toSeconds(30))
                    .put(CacheNames.CACHE_60MINS, TimeUnit.MINUTES.toSeconds(60))
                    .put(CacheNames.CACHE_180MINS, TimeUnit.MINUTES.toSeconds(180)).build();
            // spring cache是根據cache name查詢快取過期時長的，如果找不到，則使用預設值
            cacheManager.setDefaultExpiration(TimeUnit.MINUTES.toSeconds(30));
            cacheManager.setExpires(expires);
        }
    }

	/**
	* 建立ehCacheCacheManager
	*/
    @Bean
    public EhCacheCacheManager ehCacheCacheManager() {
        Resource location = this.cacheProperties
                .resolveConfigLocation(this.cacheProperties.getEhcache().getConfig());
        return new EhCacheCacheManager(EhCacheManagerUtils.buildCacheManager(location));
    }
}

step4 編寫CacheConfig.java，配置預設的cacheManager

package com.lianjia.sh.salary.payroll.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.cache.interceptor.SimpleCacheErrorHandler;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;

/**
 * Spring cache的一些配置，建議元件相關配置都放在相應的configuration類中
 *
 * @author
 */
@Configuration
@ConditionalOnBean(RedisCacheManager.class)
public class CacheConfig extends CachingConfigurerSupport {
  @Autowired
  private RedisCacheManager redisCacheManager;

  /**
   * 重寫這個方法，目的是用以提供預設的cacheManager
   * @author Stephen.Shi
   * @return
   */
  @Override
  public CacheManager cacheManager() {
    return redisCacheManager;
  }

  /** 如果cache出錯， 我們會記錄在日誌裡，方便排查，比如反序列化異常 */
  @Override
  public CacheErrorHandler errorHandler() {
    return new LoggingCacheErrorHandler();
  }


  /* non-public */ static class LoggingCacheErrorHandler extends SimpleCacheErrorHandler {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public void handleCacheGetError(RuntimeException exception, Cache cache, Object key) {
      logger.error(String.format("cacheName:%s,cacheKey:%s",
          cache == null ? "unknown" : cache.getName(), key), exception);
      super.handleCacheGetError(exception, cache, key);
    }

    @Override
    public void handleCachePutError(RuntimeException exception, Cache cache, Object key,
        Object value) {
      logger.error(String.format("cacheName:%s,cacheKey:%s",
          cache == null ? "unknown" : cache.getName(), key), exception);
      super.handleCachePutError(exception, cache, key, value);
    }

    @Override
    public void handleCacheEvictError(RuntimeException exception, Cache cache, Object key) {
      logger.error(String.format("cacheName:%s,cacheKey:%s",
          cache == null ? "unknown" : cache.getName(), key), exception);
      super.handleCacheEvictError(exception, cache, key);
    }

    @Override
    public void handleCacheClearError(RuntimeException exception, Cache cache) {
      logger.error(String.format("cacheName:%s", cache == null ? "unknown" : cache.getName()),
          exception);
      super.handleCacheClearError(exception, cache);
    }
  }
}

step5 編寫demo，檢視效果

package com.lianjia.sh.salary.payroll.service;

import com.lianjia.sh.salary.payroll.config.CacheManagerConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

/**
 * @author shitiecheng
 * @version v1
 * @since 2018/7/31
 */
@Service
public class CacheDemoService {

    @Cacheable(key = "key", cacheManager = CacheManagerConfig.CacheManagerNames.EHCACHE_CACHE_MAANGER, cacheNames = CacheManagerConfig.EhCacheNames.CACHE_10MINS)
    public String demo(String key) {
        return "abc" + key;
    }

    @Cacheable(key = "key", cacheNames = CacheManagerConfig.CacheNames.CACHE_15MINS)
    public String demo2(String key) {
        return "abc" + key;
    }
}

結果：