點選上方藍色字型，選擇“标星公衆号”
優質文章，第一時間送達
關注公衆号背景回複pay或mall擷取實戰項目資料+視訊
作者：Jeff Wong
來源：cnblogs.com/jeffwongishandsome
緩存是最直接有效提升系統性能的手段之一。個人認為用好用對緩存是優秀程式員的必備基本素質。本文結合實際開發經驗，從簡單概念原理和代碼入手，一步一步搭建一個簡單的二級緩存系統。
一、通用緩存接口
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、實作接口
/*
* 本地緩存提供者服務 (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
redisproperties
常見的需要注意的是最大連接配接數（spring.redis.jedis.pool.max-active ）和逾時時間（spring.redis.jedis.pool.max-wait）。Redis在生産環境中出現故障的頻率經常和這兩個參數息息相關。
接着定義一個繼承自CachingConfigurerSupport（請注意cacheManager和keyGenerator這兩個方法在子類的實作）的RedisConfig類：
/**
* 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嗎？)，見如下效果：
img
而值序列化器則要複雜的多，很多人推薦使用Jackson2JsonRedisSerializer序列化器，但是實際開發過程中，經常有人碰到反序列化錯誤，經過排查多數都和Jackson2JsonRedisSerializer這個序列化器有關。
4、實作接口
使用RedisTemplate，在Spring Boot中調用Redis接口比直接調用Jedis簡單多了。
@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:
/*
* 支援多緩存提供程式多級緩存的緩存幫助類
* */
@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.getGoodsId());
到這裡Spring Boot業務系統開發中最常用到的ORM，緩存和隊列三闆斧就介紹完了。
在開發的過程中你會發現，Java真的是非常非常中規中矩的語言，你需要不斷折騰并熟悉常見的開源中間件和工具，開源的輪子實在是太豐富，多嘗試幾個，實踐出真知。
預告一下，後面的文章我将繼續學習分享介紹常用中間件和工具，如定時任務，MongoDB，ES，分布式檔案系統以及各種實用工具。總之Java下工具鍊非常完備，我們要給自己更多動力。
參考：
“
http://ifeve.com/google-guava/ http://www.cnblogs.com/luochengqiuse/p/4640932.html
”
有熱門推薦????
談談在 Java 中如何優雅地判空 !
面試時寫了5種單例寫法，面試官說我寫的有問題，你們幫忙看下!
為什麼牛逼的程式員都不用 “ ! = null " 做判空？
Spring Boot：企業常用的 Starter以及實作
賊厲害，手撸的 SpringBoot緩存系統，性能杠杠的！
Mybatis接口Mapper内的方法為啥不能重載嗎？
幹貨分享：掃碼關注下面的公衆号擷取面試資料+項目實戰資料（電商/聚合支付）
點選閱讀原文，獲免費JVM+MySQL+設計模式+分布式+微服務完整面試資料