快取是最直接有效提升系統性能的手段之一。個人認為用好用對快取是優秀程式設計師的必備基本素質。

一、通用快取介面

1、快取基礎演算法

• FIFO（First In First Out），先進先出，和OS裡的FIFO思路相同，如果一個數據最先進入快取中，當快取滿的時候，應當把最先進入快取的資料給移除掉。

• LFU（Least Frequently Used），最不經常使用，如果一個數據在最近一段時間內使用次數很少，那麼在將來一段時間內被使用的可能性也很小。

• LRU（Least Recently Used），最近最少使用，如果一個數據在最近一段時間沒有被訪問到，那麼在將來它被訪問的可能性也很小。也就是說，當限定的空間已存滿資料時，應當把最久沒有被訪問到的資料移除。

2、介面定義

簡單定義快取介面，大致可以抽象如下：

package com.power.demo.cache.contract;

import java.util.function.Function;

/**
 * 快取提供者介面
 **/
public interface CacheProviderService {

    /**
     * 查詢快取
     *
     * @param key 快取鍵 不可為空
     **/
    <T extends Object> T get(String key);

    /**
     * 查詢快取
     *
     * 
 
@param key      快取鍵 不可為空
     * @param function 如沒有快取，呼叫該callable函式返回物件 可為空
     **/
    <T extends Object> T get(String key, Function<String, T> function);

    /**
     * 查詢快取
     *
     * @param key      快取鍵 不可為空
     * @param function 如沒有快取，呼叫該callable函式返回物件 可為空
     * @param funcParm function函式的呼叫引數
     *
 
*/
    <T extends Object, M extends Object> T get(String key, Function<M, T> function, M funcParm);

    /**
     * 查詢快取
     *
     * @param key        快取鍵 不可為空
     * @param function   如沒有快取，呼叫該callable函式返回物件 可為空
     * @param expireTime 過期時間（單位：毫秒） 可為空
     **/
    <T extends Object> T get(String key, Function<String, T> function, Long expireTime);

    /**
     * 查詢快取
     *
     * @param key        快取鍵 不可為空
     * @param function   如沒有快取，呼叫該callable函式返回物件 可為空
     * @param funcParm   function函式的呼叫引數
     * @param expireTime 過期時間（單位：毫秒） 可為空
     **/
    <T extends Object, M extends Object> T get(String key, Function<M, T> function, M funcParm, Long expireTime);

    /**
     * 設定快取鍵值
     *
     * @param key 快取鍵 不可為空
     * @param obj 快取值 不可為空
     **/
    <T extends Object> void set(String key, T obj);

    /**
     * 設定快取鍵值
     *
     * @param key        快取鍵 不可為空
     * @param obj        快取值 不可為空
     * @param expireTime 過期時間（單位：毫秒） 可為空
     **/
    <T extends Object> void set(String key, T obj, Long expireTime);

    /**
     * 移除快取
     *
     * @param key 快取鍵 不可為空
     **/
    void remove(String key);

    /**
     * 是否存在快取
     *
     * @param key 快取鍵 不可為空
     **/
    boolean contains(String key);
}

注意，這裡列出的只是常見快取功能介面，一些在特殊場景下用到的統計類的介面、分散式鎖、自增（減）等功能不在討論範圍之內。

Get相關方法，注意多個引數的情況，快取接口裡面傳人的Function，這是Java8提供的函式式介面，雖然支援的入參個數有限（這裡你會非常懷念.NET下的Func委託），但是僅對Java這個語言來說，這真是一個重大的進步^_^。

介面定義好了，下面就要實現快取提供者程式了。按照儲存型別的不同，本文簡單實現最常用的兩種快取提供者：本地快取和分散式快取。

二、本地快取

本地快取，也就是JVM級別的快取(本地快取可以認為是直接在程序內通訊呼叫，而分散式快取則需要通過網路進行跨程序通訊呼叫)，一般有很多種實現方式，比如直接使用Hashtable、ConcurrentHashMap等天生執行緒安全的集合作為快取容器，或者使用一些成熟的開源元件，如EhCache、Guava Cache等。本文選擇上手簡單的Guava快取。

1、什麼是Guava

Guava，簡單來說就是一個開發類庫，且是一個非常豐富強大的開發工具包，號稱可以讓使用Java語言更令人愉悅，主要包括基本工具類庫和介面、快取、釋出訂閱風格的事件匯流排等。在實際開發中，我用的最多的是集合、快取和常用型別幫助類，很多人都對這個類庫稱讚有加。

2、新增依賴

  　　<dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
      </dependency>

3、實現介面

package com.power.demo.cache.impl;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.collect.Maps;
import com.power.demo.cache.contract.CacheProviderService;
import com.power.demo.common.AppConst;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Function;

/*
 * 本地快取提供者服務 (Guava Cache)
 * */
@Configuration
@ComponentScan(basePackages = AppConst.BASE_PACKAGE_NAME)
@Qualifier("localCacheService")
public class LocalCacheProviderImpl implements CacheProviderService {

    private static Map<String, Cache<String, Object>> _cacheMap = Maps.newConcurrentMap();

    static {

        Cache<String, Object> cacheContainer = CacheBuilder.newBuilder()
                .maximumSize(AppConst.CACHE_MAXIMUM_SIZE)
                .expireAfterWrite(AppConst.CACHE_MINUTE, TimeUnit.MILLISECONDS)//最後一次寫入後的一段時間移出
                //.expireAfterAccess(AppConst.CACHE_MINUTE, TimeUnit.MILLISECONDS) //最後一次訪問後的一段時間移出
                .recordStats()//開啟統計功能
                .build();

        _cacheMap.put(String.valueOf(AppConst.CACHE_MINUTE), cacheContainer);
    }

    /**
     * 查詢快取
     *
     * @param key 快取鍵 不可為空
     **/
    public <T extends Object> T get(String key) {
        T obj = get(key, null, null, AppConst.CACHE_MINUTE);

        return obj;
    }

    /**
     * 查詢快取
     *
     * @param key      快取鍵 不可為空
     * @param function 如沒有快取，呼叫該callable函式返回物件 可為空
     **/
    public <T extends Object> T get(String key, Function<String, T> function) {
        T obj = get(key, function, key, AppConst.CACHE_MINUTE);

        return obj;
    }

    /**
     * 查詢快取
     *
     * @param key      快取鍵 不可為空
     * @param function 如沒有快取，呼叫該callable函式返回物件 可為空
     * @param funcParm function函式的呼叫引數
     **/
    public <T extends Object, M extends Object> T get(String key, Function<M, T> function, M funcParm) {
        T obj = get(key, function, funcParm, AppConst.CACHE_MINUTE);

        return obj;
    }

    /**
     * 查詢快取
     *
     * @param key        快取鍵 不可為空
     * @param function   如沒有快取，呼叫該callable函式返回物件 可為空
     * @param expireTime 過期時間（單位：毫秒） 可為空
     **/
    public <T extends Object> T get(String key, Function<String, T> function, Long expireTime) {
        T obj = get(key, function, key, expireTime);

        return obj;
    }

    /**
     * 查詢快取
     *
     * @param key        快取鍵 不可為空
     * @param function   如沒有快取，呼叫該callable函式返回物件 可為空
     * @param funcParm   function函式的呼叫引數
     * @param expireTime 過期時間（單位：毫秒） 可為空
     **/
    public <T extends Object, M extends Object> T get(String key, Function<M, T> function, M funcParm, Long expireTime) {
        T obj = null;
        if (StringUtils.isEmpty(key) == true) {
            return obj;
        }

        expireTime = getExpireTime(expireTime);

        Cache<String, Object> cacheContainer = getCacheContainer(expireTime);

        try {
            if (function == null) {
                obj = (T) cacheContainer.getIfPresent(key);
            } else {
                final Long cachedTime = expireTime;
                obj = (T) cacheContainer.get(key, () -> {
                    T retObj = function.apply(funcParm);
                    return retObj;
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return obj;
    }

    /**
     * 設定快取鍵值  直接向快取中插入值，這會直接覆蓋掉給定鍵之前對映的值
     *
     * @param key 快取鍵 不可為空
     * @param obj 快取值 不可為空
     **/
    public <T extends Object> void set(String key, T obj) {

        set(key, obj, AppConst.CACHE_MINUTE);
    }

    /**
     * 設定快取鍵值  直接向快取中插入值，這會直接覆蓋掉給定鍵之前對映的值
     *
     * @param key        快取鍵 不可為空
     * @param obj        快取值 不可為空
     * @param expireTime 過期時間（單位：毫秒） 可為空
     **/
    public <T extends Object> void set(String key, T obj, Long expireTime) {
        if (StringUtils.isEmpty(key) == true) {
            return;
        }

        if (obj == null) {
            return;
        }

        expireTime = getExpireTime(expireTime);

        Cache<String, Object> cacheContainer = getCacheContainer(expireTime);

        cacheContainer.put(key, obj);
    }

    /**
     * 移除快取
     *
     * @param key 快取鍵 不可為空
     **/
    public void remove(String key) {
        if (StringUtils.isEmpty(key) == true) {
            return;
        }

        long expireTime = getExpireTime(AppConst.CACHE_MINUTE);

        Cache<String, Object> cacheContainer = getCacheContainer(expireTime);

        cacheContainer.invalidate(key);
    }

    /**
     * 是否存在快取
     *
     * @param key 快取鍵 不可為空
     **/
    public boolean contains(String key) {
        boolean exists = false;
        if (StringUtils.isEmpty(key) == true) {
            return exists;
        }

        Object obj = get(key);

        if (obj != null) {
            exists = true;
        }

        return exists;
    }

    private static Lock lock = new ReentrantLock();

    private Cache<String, Object> getCacheContainer(Long expireTime) {

        Cache<String, Object> cacheContainer = null;
        if (expireTime == null) {
            return cacheContainer;
        }

        String mapKey = String.valueOf(expireTime);

        if (_cacheMap.containsKey(mapKey) == true) {
            cacheContainer = _cacheMap.get(mapKey);
            return cacheContainer;
        }

        try {
            lock.lock();
            cacheContainer = CacheBuilder.newBuilder()
                    .maximumSize(AppConst.CACHE_MAXIMUM_SIZE)
                    .expireAfterWrite(expireTime, TimeUnit.MILLISECONDS)//最後一次寫入後的一段時間移出
                    //.expireAfterAccess(AppConst.CACHE_MINUTE, TimeUnit.MILLISECONDS) //最後一次訪問後的一段時間移出
                    .recordStats()//開啟統計功能
                    .build();

            _cacheMap.put(mapKey, cacheContainer);

        } finally {
            lock.unlock();
        }

        return cacheContainer;
    }

    /**
     * 獲取過期時間 單位：毫秒
     *
     * @param expireTime 傳人的過期時間 單位毫秒 如小於1分鐘，預設為10分鐘
     **/
    private Long getExpireTime(Long expireTime) {
        Long result = expireTime;
        if (expireTime == null || expireTime < AppConst.CACHE_MINUTE / 10) {
            result = AppConst.CACHE_MINUTE;
        }

        return result;
    }
}

4、注意事項

Guava Cache初始化容器時，支援快取過期策略，類似FIFO、LRU和LFU等演算法。

• expireAfterWrite：最後一次寫入後的一段時間移出。

• expireAfterAccess：最後一次訪問後的一段時間移出。

Guava Cache對快取過期時間的設定實在不夠友好。常見的應用場景，比如，有些幾乎不變的基礎資料快取1天，有些熱點資料快取2小時，有些會話資料快取5分鐘等等。

通常我們認為設定快取的時候帶上快取的過期時間是非常容易的，而且只要一個快取容器例項即可，比如.NET下的ObjectCache、System.Runtime.Cache等等。

但是Guava Cache不是這個實現思路，如果快取的過期時間不同，Guava的CacheBuilder要初始化多份Cache例項。

好在我在實現的時候注意到了這個問題，並且提供瞭解決方案，可以看到getCacheContainer這個函式，根據過期時長做快取例項判斷，就算不同過期時間的多例項快取也是完全沒有問題的。

三、分散式快取

分散式快取產品非常多，本文使用應用普遍的Redis，在Spring Boot應用中使用Redis非常簡單。

1、什麼是Redis

Redis是一款開源（BSD許可）的、用C語言寫成的高效能的鍵-值儲存（key-value store）。它常被稱作是一款資料結構伺服器（data structure server）。它可以被用作快取、訊息中介軟體和資料庫，在很多應用中，經常看到有人選擇使用Redis做快取，實現分散式鎖和分散式Session等。作為快取系統時，和經典的KV結構的Memcached非常相似，但又有很多不同。

Redis支援豐富的資料型別。Redis的鍵值可以包括字串（strings）型別，同時它還包括雜湊（hashes）、列表（lists）、集合（sets）和有序集合（sorted sets）等資料型別。對於這些資料型別，你可以執行原子操作。例如：對字串進行附加操作（append）；遞增雜湊中的值；向列表中增加元素；計算集合的交集、並集與差集等。

Redis的資料型別：

Keys：非二進位制安全的字元型別（ not binary-safe strings ），由於key不是binary safe的字串，所以像“my key”和“mykey\n”這樣包含空格和換行的key是不允許的。
Values：Strings、Hash、Lists、 Sets、 Sorted sets。考慮到Redis單執行緒操作模式，Value的粒度不應該過大，快取的值越大，越容易造成阻塞和排隊。

為了獲得優異的效能，Redis採用了記憶體中（in-memory）資料集（dataset）的方式。同時，Redis支援資料的持久化，你可以每隔一段時間將資料集轉存到磁碟上（snapshot），或者在日誌尾部追加每一條操作命令（append only file,aof）。

Redis同樣支援主從複製（master-slave replication），並且具有非常快速的非阻塞首次同步（ non-blocking first synchronization）、網路斷開自動重連等功能。

同時Redis還具有其它一些特性，其中包括簡單的事物支援、釋出訂閱 （ pub/sub）、管道（pipeline）和虛擬記憶體（vm）等 。

2、新增依賴

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

3、配置Redis

在application.properties配置檔案中，配置Redis常用引數：

## Redis快取相關配置
#Redis資料庫索引（預設為0）
spring.redis.database=0
#Redis伺服器地址
spring.redis.host=127.0.0.1
#Redis伺服器埠
spring.redis.port=6379  
#Redis伺服器密碼（預設為空）
spring.redis.password=123321
#Redis連線超時時間 預設：5分鐘（單位：毫秒）
spring.redis.timeout=300000ms
#Redis連線池最大連線數（使用負值表示沒有限制）
spring.redis.jedis.pool.max-active=512
#Redis連線池中的最小空閒連線
spring.redis.jedis.pool.min-idle=0
#Redis連線池中的最大空閒連線
spring.redis.jedis.pool.max-idle=8
#Redis連線池最大阻塞等待時間（使用負值表示沒有限制）
spring.redis.jedis.pool.max-wait=-1ms

常見的需要注意的是最大連線數（spring.redis.jedis.pool.max-active ）和超時時間（spring.redis.jedis.pool.max-wait）。Redis在生產環境中出現故障的頻率經常和這兩個引數息息相關。

接著定義一個繼承自CachingConfigurerSupport（請注意cacheManager和keyGenerator這兩個方法在子類的實現）的RedisConfig類：

package com.power.demo.cache.config;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Redis快取配置類
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        return RedisCacheManager.create(connectionFactory);
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();

        //Jedis的Key和Value的序列化器預設值是JdkSerializationRedisSerializer
        //經實驗，JdkSerializationRedisSerializer通過RedisDesktopManager看到的鍵值對不能正常解析

        //設定key的序列化器
        template.setKeySerializer(new StringRedisSerializer());

        ////設定value的序列化器  預設值是JdkSerializationRedisSerializer
        //使用Jackson序列化器的問題是，複雜物件可能序列化失敗，比如JodaTime的DateTime型別

        //        //使用Jackson2，將物件序列化為JSON
        //        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //        //json轉物件類，不設定預設的會將json轉成hashmap
        //        ObjectMapper om = new ObjectMapper();
        //        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        //        jackson2JsonRedisSerializer.setObjectMapper(om);
        //        template.setValueSerializer(jackson2JsonRedisSerializer);

        //將redis連線工廠設定到模板類中
        template.setConnectionFactory(factory);

        return template;
    }

//    //自定義快取key生成策略
//    @Bean
//    public KeyGenerator keyGenerator() {
//        return new KeyGenerator() {
//            @Override
//            public Object generate(Object target, java.lang.reflect.Method method, Object... params) {
//                StringBuffer sb = new StringBuffer();
//                sb.append(target.getClass().getName());
//                sb.append(method.getName());
//                for (Object obj : params) {
//                    if (obj == null) {
//                        continue;
//                    }
//                    sb.append(obj.toString());
//                }
//                return sb.toString();
//            }
//        };
//    }
}

在RedisConfig這個類上加上@EnableCaching這個註解，這個註解會被Spring發現，並且會建立一個切面（aspect） 並觸發Spring快取註解的切點（pointcut）。據所使用的註解以及快取的狀態，這個切面會從快取中獲取資料，將資料新增到快取之中或者從快取中移除某個值。

cacheManager方法，申明一個快取管理器（CacheManager）的bean，作用就是@EnableCaching這個切面在新增快取或者刪除快取的時候會呼叫這個快取管理器的方法。keyGenerator方法，可以根據需求自定義快取key生成策略。

而redisTemplate方法，則主要是設定Redis模板類，比如鍵和值的序列化器（從這裡可以看出，Redis的鍵值對必須可序列化）、redis連線工廠等。

RedisTemplate支援的序列化器主要有如下幾種：

• JdkSerializationRedisSerializer：使用Java序列化；

• StringRedisSerializer：序列化String型別的key和value；

• GenericToStringSerializer：使用Spring轉換服務進行序列化；

• JacksonJsonRedisSerializer：使用Jackson 1，將物件序列化為JSON；

• Jackson2JsonRedisSerializer：使用Jackson 2，將物件序列化為JSON；

• OxmSerializer：使用Spring O/X對映的編排器和解排器（marshaler和unmarshaler）實現序列化，用於XML序列化；

注意：RedisTemplate的鍵和值序列化器，預設情況下都是JdkSerializationRedisSerializer，它們都可以自定義設定序列化器。

推薦將字串鍵使用StringRedisSerializer序列化器，因為運維的時候好排查問題，JDK序列化器的也能識別，但是可讀性稍差(是因為快取伺服器沒有JRE嗎？)，見如下效果：

而值序列化器則要複雜的多，很多人推薦使用Jackson2JsonRedisSerializer序列化器，但是實際開發過程中，經常有人碰到反序列化錯誤，經過排查多數都和Jackson2JsonRedisSerializer這個序列化器有關。

4、實現介面

使用RedisTemplate，在Spring Boot中呼叫Redis介面比直接呼叫Jedis簡單多了。

package com.power.demo.cache.impl;

import com.power.demo.cache.contract.CacheProviderService;
import com.power.demo.common.AppConst;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.io.Serializable;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

@Configuration
@ComponentScan(basePackages = AppConst.BASE_PACKAGE_NAME)
@Qualifier("redisCacheService")
public class RedisCacheProviderImpl implements CacheProviderService {

    @Resource
    private RedisTemplate<Serializable, Object> redisTemplate;

    /**
     * 查詢快取
     *
     * @param key 快取鍵 不可為空
     **/
    public <T extends Object> T get(String key) {
        T obj = get(key, null, null, AppConst.CACHE_MINUTE);

        return obj;
    }

    /**
     * 查詢快取
     *
     * @param key      快取鍵 不可為空
     * @param function 如沒有快取，呼叫該callable函式返回物件 可為空
     **/
    public <T extends Object> T get(String key, Function<String, T> function) {
        T obj = get(key, function, key, AppConst.CACHE_MINUTE);

        return obj;
    }

    /**
     * 查詢快取
     *
     * @param key      快取鍵 不可為空
     * @param function 如沒有快取，呼叫該callable函式返回物件 可為空
     * @param funcParm function函式的呼叫引數
     **/
    public <T extends Object, M extends Object> T get(String key, Function<M, T> function, M funcParm) {
        T obj = get(key, function, funcParm, AppConst.CACHE_MINUTE);

        return obj;
    }

    /**
     * 查詢快取
     *
     * @param key        快取鍵 不可為空
     * @param function   如沒有快取，呼叫該callable函式返回物件 可為空
     * @param expireTime 過期時間（單位：毫秒） 可為空
     **/
    public <T extends Object> T get(String key, Function<String, T> function, Long expireTime) {
        T obj = get(key, function, key, expireTime);

        return obj;
    }

    /**
     * 查詢快取
     *
     * @param key        快取鍵 不可為空
     * @param function   如沒有快取，呼叫該callable函式返回物件 可為空
     * @param funcParm   function函式的呼叫引數
     * @param expireTime 過期時間（單位：毫秒） 可為空
     **/
    public <T extends Object, M extends Object> T get(String key, Function<M, T> function, M funcParm, Long expireTime) {
        T obj = null;
        if (StringUtils.isEmpty(key) == true) {
            return obj;
        }

        expireTime = getExpireTime(expireTime);

        try {

            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            obj = (T) operations.get(key);
            if (function != null && obj == null) {
                obj = function.apply(funcParm);
                if (obj != null) {
                    set(key, obj, expireTime);//設定快取資訊
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return obj;
    }

    /**
     * 設定快取鍵值  直接向快取中插入值，這會直接覆蓋掉給定鍵之前對映的值
     *
     * @param key 快取鍵 不可為空
     * @param obj 快取值 不可為空
     **/
    public <T extends Object> void set(String key, T obj) {

        set(key, obj, AppConst.CACHE_MINUTE);
    }

    /**
     * 設定快取鍵值  直接向快取中插入值，這會直接覆蓋掉給定鍵之前對映的值
     *
     * @param key        快取鍵 不可為空
     * @param obj        快取值 不可為空
     * @param expireTime 過期時間（單位：毫秒） 可為空
     **/
    public <T extends Object> void set(String key, T obj, Long expireTime) {
        if (StringUtils.isEmpty(key) == true) {
            return;
        }

        if (obj == null) {
            return;
        }

        expireTime = getExpireTime(expireTime);

        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();

        operations.set(key, obj);

        redisTemplate.expire(key, expireTime, TimeUnit.MILLISECONDS);
    }

    /**
     * 移除快取
     *
     * @param key 快取鍵 不可為空
     **/
    public void remove(String key) {
        if (StringUtils.isEmpty(key) == true) {
            return;
        }

        redisTemplate.delete(key);
    }

    /**
     * 是否存在快取
     *
     * @param key 快取鍵 不可為空
     **/
    public boolean contains(String key) {
        boolean exists = false;
        if (StringUtils.isEmpty(key) == true) {
            return exists;
        }

        Object obj = get(key);

        if (obj != null) {
            exists = true;
        }

        return exists;
    }

    /**
     * 獲取過期時間 單位：毫秒
     *
     * @param expireTime 傳人的過期時間 單位毫秒 如小於1分鐘，預設為10分鐘
     **/
    private Long getExpireTime(Long expireTime) {
        Long result = expireTime;
        if (expireTime == null || expireTime < AppConst.CACHE_MINUTE / 10) {
            result = AppConst.CACHE_MINUTE;
        }

        return result;
    }
}

注意：很多教程裡都講到通過註解的方式（@Cacheable，@CachePut、@CacheEvict和@Caching）實現資料快取，根據實踐，我個人是不推崇這種使用方式的。

四、快取“及時”過期問題

這個也是開發和運維過程中非常經典的問題。

有些公司寫快取客戶端的時候，會給每個團隊分別定義一個Area，但是這個只能做到快取鍵的分佈區分，不能保證快取“實時”有效的過期。

多年以前我寫過一篇結合實際情況的文章，也就是加上快取版本，請猛擊這裡 ，算是提供了一種相對有效的方案，不過高併發站點要慎重，防止發生雪崩效應。

Redis還有一些其他常見問題，比如：Redis的字串型別Key和Value都有限制，且都是不能超過512M，請猛擊這裡。還有最大連線數和超時時間設定等問題。

五、二級快取

在配置檔案中，加上快取提供者開關：

##是否啟用本地快取
spring.power.isuselocalcache=1
##是否啟用Redis快取
spring.power.isuserediscache=1

快取提供者程式都實現好了，我們會再包裝一個呼叫外觀類PowerCacheBuilder，加上快取版本控制，可以輕鬆自如地控制和切換快取，code talks:

package com.power.demo.cache;

import com.google.common.collect.Lists;
import com.power.demo.cache.contract.CacheProviderService;
import com.power.demo.common.AppConst;
import com.power.demo.common.AppField;
import com.power.demo.util.ConfigUtil;
import com.power.demo.util.PowerLogger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

import java.util.List;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Function;

/*
 * 支援多快取提供程式多級快取的快取幫助類
 * */
@Configuration
@ComponentScan(basePackages = AppConst.BASE_PACKAGE_NAME)
public class PowerCacheBuilder {

    @Autowired
    @Qualifier("localCacheService")
    private CacheProviderService localCacheService;

    @Autowired
    @Qualifier("redisCacheService")
    private CacheProviderService redisCacheService;

    private static List<CacheProviderService> _listCacheProvider = Lists.newArrayList();

    private static final Lock providerLock = new ReentrantLock();

    /**
     * 初始化快取提供者 預設優先順序：先本地快取，後分布式快取
     **/
    private List<CacheProviderService> getCacheProviders() {

        if (_listCacheProvider.size() > 0) {
            return _listCacheProvider;
        }

        //執行緒安全
        try {
            providerLock.tryLock(1000, TimeUnit.MILLISECONDS);

            if (_listCacheProvider.size() > 0) {
                return _listCacheProvider;
            }

            String isUseCache = ConfigUtil.getConfigVal(AppField.IS_USE_LOCAL_CACHE);

            CacheProviderService cacheProviderService = null;

            //啟用本地快取
            if ("1".equalsIgnoreCase(isUseCache)) {
                _listCacheProvider.add(localCacheService);
            }

            isUseCache = ConfigUtil.getConfigVal(AppField.IS_USE_REDIS_CACHE);

            //啟用Redis快取
            if ("1".equalsIgnoreCase(isUseCache)) {
                _listCacheProvider.add(redisCacheService);

                resetCacheVersion();//設定分散式快取版本號
            }

            PowerLogger.info("初始化快取提供者成功，共有" + _listCacheProvider.size() + "個");
        } catch (Exception e) {
            e.printStackTrace();

            _listCacheProvider = Lists.newArrayList();

            PowerLogger.error("初始化快取提供者發生異常：{}", e);
        } finally {
            providerLock.unlock();
        }

        return _listCacheProvider;
    }

    /**
     * 查詢快取
     *
     * @param key 快取鍵 不可為空
     **/
    public <T extends Object> T get(String key) {
        T obj = null;

        //key = generateVerKey(key);//構造帶版本的快取鍵

        for (CacheProviderService provider : getCacheProviders()) {

            obj = provider.get(key);

            if (obj != null) {
                return obj;
            }
        }

        return obj;
    }

    /**
     * 查詢快取
     *
     * @param key      快取鍵 不可為空
     * @param function 如沒有快取，呼叫該callable函式返回物件 可為空
     **/
    public <T extends Object> T get(String key, Function<String, T> function) {
        T obj = null;

        for (CacheProviderService provider : getCacheProviders()) {

            if (obj == null) {
                obj = provider.get(key, function);
            } else if (function != null && obj != null) {//查詢並設定其他快取提供者程式快取
                provider.get(key, function);
            }

            //如果callable函式為空 而快取物件不為空 及時跳出迴圈並返回
            if (function == null && obj != null) {
                return obj;
            }

        }

        return obj;
    }

    /**
     * 查詢快取
     *
     * @param key      快取鍵 不可為空
     * @param function 如沒有快取，呼叫該callable函式返回物件 可為空
     * @param funcParm function函式的呼叫引數
     **/
    public <T extends Object, M extends Object> T get(String key, Function<M, T> function, M funcParm) {
        T obj = null;

        for (CacheProviderService provider : getCacheProviders()) {

            if (obj == null) {
                obj = provider.get(key, function, funcParm);
            } else if (function != null && obj != null) {//查詢並設定其他快取提供者程式快取
                provider.get(key, function, funcParm);
            }

            //如果callable函式為空 而快取物件不為空 及時跳出迴圈並返回
            if (function == null && obj != null) {
                return obj;
            }
        }

        return obj;
    }

    /**
     * 查詢快取
     *
     * @param key        快取鍵 不可為空
     * @param function   如沒有快取，呼叫該callable函式返回物件 可為空
     * @param expireTime 過期時間（單位：毫秒） 可為空
     **/
    public <T extends Object> T get(String key, Function<String, T> function, long expireTime) {
        T obj = null;

        for (CacheProviderService provider : getCacheProviders()) {

            if (obj == null) {
                obj = provider.get(key, function, expireTime);
            } else if (function != null && obj != null) {//查詢並設定其他快取提供者程式快取
                provider.get(key, function, expireTime);
            }

            //如果callable函式為空 而快取物件不為空 及時跳出迴圈並返回
            if (function == null && obj != null) {
                return obj;
            }
        }

        return obj;
    }

    /**
     * 查詢快取
     *
     * @param key        快取鍵 不可為空
     * @param function   如沒有快取，呼叫該callable函式返回物件 可為空
     * @param funcParm   function函式的呼叫引數
     * @param expireTime 過期時間（單位：毫秒） 可為空
     **/
    public <T extends Object, M extends Object> T get(String key, Function<M, T> function, M funcParm, long expireTime) {
        T obj = null;

        for (CacheProviderService provider : getCacheProviders()) {

            if (obj == null) {
                obj = provider.get(key, function, funcParm, expireTime);
            } else if (function != null && obj != null) {//查詢並設定其他快取提供者程式快取
                provider.get(key, function, funcParm, expireTime);
            }

            //如果callable函式為空 而快取物件不為空 及時跳出迴圈並返回
            if (function == null && obj != null) {
                return obj;
            }
        }

        return obj;
    }

    /**
     * 設定快取鍵值  直接向快取中插入或覆蓋值
     *
     * @param key 快取鍵 不可為空
     * @param obj 快取值 不可為空
     **/
    public <T extends Object> void set(String key, T obj) {

        //key = generateVerKey(key);//構造帶版本的快取鍵

        for (CacheProviderService provider : getCacheProviders()) {

            provider.set(key, obj);

        }
    }

    /**
     * 設定快取鍵值  直接向快取中插入或覆蓋值
     *
     * @param key        快取鍵 不可為空
     * @param obj        快取值 不可為空
     * @param expireTime 過期時間（單位：毫秒） 可為空
     **/
    public <T extends Object> void set(String key, T obj, Long expireTime) {

        //key = generateVerKey(key);//構造帶版本的快取鍵

        for (CacheProviderService provider : getCacheProviders()) {

            provider.set(key, obj, expireTime);

        }
    }

    /**
     * 移除快取
     *
     * @param key 快取鍵 不可為空
     **/
    public void remove(String key) {

        //key = generateVerKey(key);//構造帶版本的快取鍵

        if (StringUtils.isEmpty(key) == true) {
            return;
        }

        for (CacheProviderService provider : getCacheProviders()) {

            provider.remove(key);

        }
    }

    /**
     * 是否存在快取
     *
     * @param key 快取鍵 不可為空
     **/
    public boolean contains(String key) {
        boolean exists = false;

        //key = generateVerKey(key);//構造帶版本的快取鍵

        if (StringUtils.isEmpty(key) == true) {
            return exists;
        }

        Object obj = get(key);

        if (obj != null) {
            exists = true;
        }

        return exists;
    }

    /**
     * 獲取分散式快取版本號
     **/
    public String getCacheVersion() {
        String version = "";
        boolean isUseCache = checkUseRedisCache();

        //未啟用Redis快取
        if (isUseCache == false) {
            return version;
        }

        version = redisCacheService.get(AppConst.CACHE_VERSION_KEY);

        return version;
    }

    /**
     * 重置分散式快取版本  如果啟用分散式快取，設定快取版本
     **/
    public String resetCacheVersion() {
        String version = "";
        boolean isUseCache = checkUseRedisCache();

        //未啟用Redis快取
        if (isUseCache == false) {
            return version;
        }

        //設定快取版本
        version = String.valueOf(Math.abs(UUID.randomUUID().hashCode()));
        redisCacheService.set(AppConst.CACHE_VERSION_KEY, version);

        return version;
    }

    /**
     * 如果啟用分散式快取，獲取快取版本，重置查詢的快取key，可以實現相對實時的快取過期控制
     * <p>
     * 如沒有啟用分散式快取，快取key不做修改，直接返回
     **/
    public String generateVerKey(String key) {

        String result = key;
        if (StringUtils.isEmpty(key) == true) {
            return result;
        }

        boolean isUseCache = checkUseRedisCache();

        //沒有啟用分散式快取，快取key不做修改，直接返回
        if (isUseCache == false) {
            return result;
        }

        String version = redisCacheService.get(AppConst.CACHE_VERSION_KEY);
        if (StringUtils.isEmpty(version) == true) {
            return result;
        }

        result = String.format("%s_%s", result, version);

        return result;
    }

    /**
     * 驗證是否啟用分散式快取
     **/
    private boolean checkUseRedisCache() {
        boolean isUseCache = false;
        String strIsUseCache = ConfigUtil.getConfigVal(AppField.IS_USE_REDIS_CACHE);

        isUseCache = "1".equalsIgnoreCase(strIsUseCache);

        return isUseCache;
    }
}

單元測試如下：

@Test
    public void testCacheVerson() throws Exception {

        String version = cacheBuilder.getCacheVersion();
        System.out.println(String.format("當前快取版本：%s", version));

        String cacheKey = cacheBuilder.generateVerKey("goods778899");

        GoodsVO goodsVO = new GoodsVO();
        goodsVO.setGoodsId(UUID.randomUUID().toString());
        goodsVO.setCreateTime(new Date());
        goodsVO.setCreateDate(new DateTime(new Date()));
        goodsVO.setGoodsType(1024);
        goodsVO.setGoodsCode("123456789");
        goodsVO.setGoodsName("我的測試商品");

        cacheBuilder.set(cacheKey, goodsVO);

        GoodsVO goodsVO1 = cacheBuilder.get(cacheKey);

        Assert.assertNotNull(goodsVO1);

        version = cacheBuilder.resetCacheVersion();
        System.out.println(String.format("重置後的快取版本：%s", version));


        cacheKey = cacheBuilder.generateVerKey("goods112233");

        cacheBuilder.set(cacheKey, goodsVO);

        GoodsVO goodsVO2 = cacheBuilder.get(cacheKey);

        Assert.assertNotNull(goodsVO2);

        Assert.assertTrue("兩個快取物件的主鍵相同", goodsVO1.getGoodsId().equals(goodsVO2.getGoodsId()));
    }

一個滿足基本功能的多級快取系統就好了。

在Spring Boot應用中使用快取則非常簡潔，選擇呼叫上面包裝好的快取介面即可。

String cacheKey = _cacheBuilder.generateVerKey("com.power.demo.apiservice.impl.getgoodsbyid." + request.getGoodsId());

GoodsVO goodsVO = _cacheBuilder.get(cacheKey, _goodsService::getGoodsByGoodsId, request.getGo

到這裡Spring Boot業務系統開發中最常用到的ORM，快取和佇列三板斧就介紹完了。

在開發的過程中你會發現，Java真的是非常非常中規中矩的語言，你需要不斷折騰並熟悉常見的開源中介軟體和工具，開源的輪子實在是太豐富，多嘗試幾個，實踐出真知。

預告一下，後面的文章我將繼續學習分享介紹常用中介軟體和工具，如定時任務，MongoDB，ES，分散式檔案系統以及各種實用工具。總之Java下工具鏈非常完備，我們要給自己更多動力。

參考：

http://ifeve.com/google-guava/
http://www.cnblogs.com/luochengqiuse/p/4640932.html