目錄
封裝常用組件
Redis服務類
分佈式鎖服務類
二級緩存服務類
RabbitMQ服務類
JWT工具包
封裝常用組件
Redis服務類
核心設計
- 將 Redis 封裝到 fw-common 工程下的 fw-common-redis 模塊，提供可插拔使用模式
- 封裝 Redis 常用操作，提供對應方法
- 數據存儲時，key 和 value 均需序列化配置後再存儲
- 集成 Redisson，提供分佈式鎖相關功能
這裏主要是對RedisTemplate 常用的方法進行進一步封裝，並封裝一些帶泛型參數的方法，通過之前封裝的json工具類對類參數進行序列化。
package com.hyldzbg.fwcommonredis;
import com.fasterxml.jackson.core.type.TypeReference;
import com.hyldzbg.fwcommoncore.utils.JsonUtils;
import jakarta.annotation.Resource;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.concurrent.TimeUnit;
@Service
public class RedisService {
@Autowired
private RedisTemplate redisTemplate;
/**
* 設置有效時間
* @param key
* @param timeout
* @param timeUnit
* @return
*/
public Boolean expire(final String key,final long timeout,final TimeUnit timeUnit){
return redisTemplate.expire(key,timeout,timeUnit);
}
/**
* 獲取有效時間
*
* @param key Redis鍵
* @return 有效時間
*/
public long getExpire(final String key) {
return redisTemplate.getExpire(key);
}
/**
* 設置有效時間(默認為秒)
* @param key
* @param timeout
* @return
*/
public Boolean expire(final String key,final long timeout){
return redisTemplate.expire(key,timeout,TimeUnit.SECONDS);
}
/**
* 判斷 key是否存在
*
* @param key 鍵
* @return true=存在；false=不存在
*/
public Boolean hasKey(String key) {
return redisTemplate.hasKey(key);
}
/**
* 根據提供的鍵模式查找 Redis 中匹配的鍵
*
* @param pattern 要查找的鍵的模式
* @return 鍵列表
*/
public Collection<String> keys(final String pattern) {
return redisTemplate.keys(pattern);
}
/**
* 重命名key
*
* @param oldKey 原來key
* @param newKey 新key
*/
public void renameKey(String oldKey, String newKey) {
redisTemplate.rename(oldKey, newKey);
}
/**
* 刪除單個數據
*
* @param key 緩存的鍵值
* @return 是否成功 true=刪除成功；false=刪除失敗
*/
public boolean deleteObject(final String key) {
return redisTemplate.delete(key);
}
/**
* 刪除多個數據
*
* @param collection 多個數據對應的緩存的鍵值
* @return 是否刪除了對象 true=刪除成功；false=刪除失敗
*/
public boolean deleteObject(final Collection collection) {
return redisTemplate.delete(collection) > 0;
}
//************************* 緩存String數據 ******************************\\
/**
* 緩存數據
* @param key
* @param value
* @return
* @param <T>
*/
public <T> boolean setCacheObject(final String key, final T value){
if(StringUtils.isEmpty(key) || value == null){
return false;
}
redisTemplate.opsForValue().set(key,value);
return true;
}
/**
* 緩存數據，並設置過期時間
* @param key
* @param value
* @param timeout
* @param timeUnit
* @return
* @param <T>
*/
public <T> boolean setCacheObject(final String key, final T value, final long timeout, final TimeUnit timeUnit){
if(StringUtils.isEmpty(key) || value == null){
return false;
}
redisTemplate.opsForValue().set(key,value,timeout,timeUnit);
return true;
}
/**
* 緩存數據，如果key已經存在則緩存失敗
* @param key
* @param value
* @return
* @param <T>
*/
public <T> boolean setCacheObjectIfAbsent(final String key, final T value){
if(StringUtils.isEmpty(key) || value == null){
return false;
}
return redisTemplate.opsForValue().setIfAbsent(key,value);
}
/**
* 緩存數據，兵設置過期時間，如果key已經存在則緩存失敗
* @param key
* @param value
* @return
* @param <T>
*/
public <T> boolean setCacheObjectIfAbsent(final String key, final T value, final long timeout, final TimeUnit timeUnit){
if(StringUtils.isEmpty(key) || value == null){
return false;
}
return redisTemplate.opsForValue().setIfAbsent(key,value,timeout,timeUnit);
}
public <T> T getCacheObject(final String key,Class<T> clazz){
Object o = redisTemplate.opsForValue().get(key);
if(o == null){
return null;
}
String json = JsonUtils.objectToJson(o);
return JsonUtils.jsonToObject(json,clazz);
}
public <T> T getCacheObject(final String key,TypeReference<T> typeReference){
Object o = redisTemplate.opsForValue().get(key);
if(o == null){
return null;
}
String json = JsonUtils.objectToJson(o);
return JsonUtils.jsonToObject(json,typeReference);
}
//************************* 緩存list數據 ******************************\\
public <T> Long setCacheList(final String key,final List<T> dataList){
//rightPushAll的返回值是，添加之後，redis中當前操作的這個list的結構長度
Long count = redisTemplate.opsForList().rightPushAll(key,dataList);
return count == null ? 0 : count;
}
/**
* 從List結構左側插⼊數據（頭插、⼊隊）
* @param key key
* @param value 緩存的對象
* @param <T> 值類型
*/
public <T> void leftPushForList(String key, final T value) {
redisTemplate.opsForList().leftPush(key, value);
}
/**
* 從List結構右側插⼊數據（尾插、插⼊單個數據）
* @param key key
* @param value 緩存的對象
* @param <T> 值類型
*/
public <T> void rightPushForList(String key, final T value) {
redisTemplate.opsForList().rightPush(key, value);
}
/**
* 刪除左側第⼀個數據 （頭刪）
* @param key key
*/
public void leftPopForList(String key) {
redisTemplate.opsForList().leftPop(key);
}
/**
* 刪除右側第⼀個數據 （尾刪）
* @param key key
*/
public void rightPopForList(String key) {
redisTemplate.opsForList().rightPop(key);
}
/**
* 移除List第⼀個匹配的元素
*
* @param key key
* @param value 值
* @param <T> 值類型
*/
public <T> void removeForList(final String key, T value) {
//刪除的方式：從左往右，從右往左
//remove的count屬性有兩個意思，刪除方向 & 刪除個數，count>0 從左往右，count<0 從右往左
//count=0，全部刪除
redisTemplate.opsForList().remove(key, 1L, value);
}
/**
* 移除List中匹配的所有列表元素
*
* @param key key
* @param value 值
* @param <T> 值類型
*/
public <T> void removeAllForList(final String key, T value) {
redisTemplate.opsForList().remove(key, 0, value);
}
/**
* 移除key下的所有列表元素
*
* @param key key
*/
public void removeForAllList(final String key) {
//當start > end時，會全刪除
redisTemplate.opsForList().trim(key, -1, 0);
}
/**
* 修改指定下標數據
* @param key key
* @param index 下標
* @param newValue 修改後新值
* @param <T> 值類型
*/
public <T> void setElementAtIndex(final String key, int index, T newValue)
{
redisTemplate.opsForList().set(key, index, newValue);
}
/**
* 獲得緩存的list對象
* @param key key 緩存的鍵值
* @param clazz 對象的類
* @return 列表
* @param <T> 對象類型
*/
public <T> List<T> getCacheList(final String key, Class<T> clazz) {
List list = redisTemplate.opsForList().range(key, 0, -1);
//先轉化為Json格式，再轉化為list
return JsonUtils.stringTOList(JsonUtils.objectToJson(list), clazz);
}
/**
* 獲得緩存的list對象 （⽀持複雜的泛型嵌套）
* @param key key信息
* @param typeReference 類型模板
* @return list對象
* @param <T> 對象類型
*/
public <T> List<T> getCacheList(final String key, TypeReference<List<T>>
typeReference) {
List list = redisTemplate.opsForList().range(key, 0, -1);
List<T> res = JsonUtils.jsonToObject(JsonUtils.objectToJson(list),
typeReference);
return res;
}
/**
* 根據範圍獲取List
*
* @param key key
* @param start 開始位置
* @param end 結束位置
* @param clazz 類信息
* @return List列表
* @param <T> 類型
*/
public <T> List<T> getCacheListByRange(final String key, long start, long
end, Class<T> clazz) {
List range = redisTemplate.opsForList().range(key, start, end);
return JsonUtils.stringTOList(JsonUtils.objectToJson(range), clazz);
}
/**
* 根據範圍獲取List（⽀持複雜的泛型嵌套 ）
*
* @param key key
* @param start 開始
* @param end 結果
* @param typeReference 類型模板
* @return list列表
* @param <T> 類型信息
*/
public <T> List<T> getCacheListByRange(final String key, long start, long
end, TypeReference<List<T>> typeReference) {
List range = redisTemplate.opsForList().range(key, start, end);
return JsonUtils.jsonToObject(JsonUtils.objectToJson(range), typeReference);
}
/**
* 獲取指定列表⻓度
* @param key key信息
* @return 列表⻓度
*/
public long getCacheListSize(final String key) {
Long size = redisTemplate.opsForList().size(key);
return size == null ? 0L : size;
}
//************************ 操作Set類型 ***************************
/**
* set添加元素（批量添加或添加單個元素）
* @param key key
* @param member 元素信息
*/
public void addMember(final String key, Object... member) {
redisTemplate.opsForSet().add(key, member);
}
/**
* 刪除元素
* @param key key
* @param member 元素信息
*/
public void deleteMember(final String key, Object... member) {
redisTemplate.opsForSet().remove(key, member);
}
/**
* 獲取set數據（支持複雜的泛型嵌套）
* @param key key
* @param typeReference 類型模板
* @return set數據
* @param <T> 類型信息
*/
public <T> Set<T> getCacheSet(final String key, TypeReference<Set<T>> typeReference) {
Set data = redisTemplate.opsForSet().members(key);
return JsonUtils.jsonToObject(JsonUtils.objectToJson(data), typeReference);
}
//************************ 操作ZSet類型 ***************************
/**
* 添加元素
* @param key key
* @param value 值
* @param seqNo 分數
*/
public void addMemberZSet(String key, Object value, double seqNo) {
redisTemplate.opsForZSet().add(key, value, seqNo);
}
/**
* 刪除元素
* @param key key
* @param value 值
*/
public void delMemberZSet(String key, Object value) {
redisTemplate.opsForZSet().remove(key, value);
}
/**
* 根據排序分值刪除
*
* @param key key
* @param minScore 最小分
* @param maxScore 最大分
*/
public void removeZSetByScore(final String key, double minScore, double maxScore) {
redisTemplate.opsForZSet().removeRangeByScore(key, minScore, maxScore);
}
/**
* 獲取有序集合數據（支持複雜的泛型嵌套）
*
* @param key key信息
* @param typeReference 類型模板
* @return 有序集合
* @param <T> 對象類型
*/
public <T> Set<T> getCacheZSet(final String key, TypeReference<LinkedHashSet<T>> typeReference) {
Set data = redisTemplate.opsForZSet().range(key, 0, -1);
return JsonUtils.jsonToObject(JsonUtils.objectToJson(data), typeReference);
}
/**
* 降序獲取有序集合（支持複雜的泛型嵌套）
* @param key key信息
* @param typeReference 類型模板
* @return 降序的有序集合
* @param <T> 對象類型信息
*/
public <T> Set<T> getCacheZSetDesc(final String key, TypeReference<LinkedHashSet<T>> typeReference) {
Set data = redisTemplate.opsForZSet().reverseRange(key, 0, -1);
return JsonUtils.jsonToObject(JsonUtils.objectToJson(data), typeReference);
}
//************************ 操作Hash類型 ***************************
/**
* 緩存Map數據
* @param key key
* @param dataMap map
* @param <T> 對象類型
*/
public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
if (dataMap != null) {
redisTemplate.opsForHash().putAll(key, dataMap);
}
}
/**
* 往Hash中存入單個數據
* @param key Redis鍵
* @param hKey Hash鍵
* @param value 值
* @param <T> 對象類型
*/
public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
redisTemplate.opsForHash().put(key, hKey, value);
}
/**
* 刪除Hash中的某條數據
*
* @param key Redis鍵
* @param hKey Hash鍵
* @return 是否成功
*/
public boolean deleteCacheMapValue(final String key, final String hKey) {
return redisTemplate.opsForHash().delete(key, hKey) > 0;
}
/**
* 獲取緩存的map數據（支持複雜的泛型嵌套）
* @param key key
* @param typeReference 類型模板
* @return hash對應的map
* @param <T> 對象類型
*/
public <T> Map<String, T> getCacheMap(final String key, TypeReference<Map<String, T>> typeReference) {
Map data= redisTemplate.opsForHash().entries(key);
return JsonUtils.jsonToObject(JsonUtils.objectToJson(data), typeReference);
}
/**
* 獲取Hash中的單個數據
* @param key Redis鍵
* @param hKey Hash鍵
* @return Hash中的對象
* @param <T> 對象類型
*/
public <T> T getCacheMapValue(final String key, final String hKey) {
HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
return opsForHash.get(key, hKey);
}
/**
* 獲取Hash中的多個數據
*
* @param key Redis鍵
* @param hKeys Hash鍵集合
* @param typeReference 對象模板
* @return 獲取的多個數據的集合
* @param <T> 對象類型
*/
public <T> List<T> getMultiCacheMapValue(final String key, final Collection<String> hKeys, TypeReference<List<T>> typeReference) {
List data = redisTemplate.opsForHash().multiGet(key, hKeys);
return JsonUtils.jsonToObject(JsonUtils.objectToJson(data), typeReference);
}
}lua腳本，通過redis lua腳本可以實現對redis的原子化操作
//******************************** LUA腳本 ***********************************
/**
* 刪除指定值對應的 Redis 中的鍵值（compare and delete）
*
* @param key 緩存key
* @param value value
* @return 是否完成了比較並刪除
*/
public boolean cad(String key, String value) {
if (key.contains(StringUtils.SPACE) || value.contains(StringUtils.SPACE)) {
return false;
}
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
// 通過lua腳本原子驗證令牌和刪除令牌
Long result = (Long) redisTemplate.execute(new DefaultRedisScript<>(script, Long.class),
Collections.singletonList(key),
value);
return !Objects.equals(result, 0L);
}redis相關配置，這裏要對redisTemplate進行序列化配置，不然redisTemplate會以16進制存儲key-value，雖然對於redisTemplate來説可以認識，但是對於開發者來説並不友好而且內存佔用較大，所以這裏要進行序列化配置。（默認是JDK序列化）
package com.hyldzbg.fwcommonredis;
@Configuration
public class RedisConfig {
//完成對redisTemplate的配置
//redisConnectionFactory 通過依賴注入,傳入參數
//key value(hashkey hashvalue)
/**
* 對redisTemplate進行序列化配置
* @param redisConnectionFactory redis連接工廠
* @return
*/
@Bean
@Primary
public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
//設置redis連接工廠
redisTemplate.setConnectionFactory(redisConnectionFactory);
//對key進行序列化設置
redisTemplate.setKeySerializer(new StringRedisSerializer());
//對hashkey進行序列化設置
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//對value和hashvalue進行jackson序列化設置
GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = createJacksonSerializer();
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
//完成一些後續配置操作，保證我們的配置可以配置好
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
/**
* 對jackson進行配置
* @return
*/
public GenericJackson2JsonRedisSerializer createJacksonSerializer(){
//對jackson進行配置
ObjectMapper objectMapper =
JsonMapper.builder().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false)
.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false)
.configure(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE, false)
.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS,
false)
.configure(MapperFeature.USE_ANNOTATIONS, false)
.addModule(new JavaTimeModule())
.defaultDateFormat(new
SimpleDateFormat(CommonConstants.STANDARD_FORMAT))
.serializationInclusion(JsonInclude.Include.NON_NULL)
.build();
return new GenericJackson2JsonRedisSerializer(objectMapper);
}
}增加Nacos配置
spring:
data:
redis:
host: 你的虛擬機內⽹ip/服務器外⽹ip
port: 6379
password: xxxx把這些配置放在nacos中，可以方便之後其他業務程序使用，只需要導入這個包的依賴，然後加上nacos配置就可以實現插拔式使用。
分佈式鎖服務類
併發編程中，鎖用於同步線程對共享資源的訪問，保證同一時刻僅一個線程可操作資源，確保線程安全。把這一機制搬到分佈式環境，讓多節點互斥訪問共享資源，就是分佈式鎖。
下面是一個簡單秒殺功能的代碼
@RestController
@Slf4j
@RequestMapping("/test/redisson")
public class TestRedissonController {
@Autowired
private RedisService redisService;
@PostMapping("/delstock")
public String delStock() {
String proKey = "proKey";
// 嘗試加鎖
Boolean save = redisService.setCacheObjectIfAbsent(proKey, "product");
if (!save) {
return "unLock"; // 未獲取到鎖
}
try {
// 獲取庫存
String stockKey = "stock";
Integer stock = redisService.getCacheObject(stockKey, Integer.class);
if (stock <= 0) {
return "error"; // 秒殺失敗
}
stock--;
redisService.setCacheObject(stockKey, stock);
} finally {
redisService.deleteObject(proKey); // 解鎖
}
return "ok"; // 秒殺成功
}
}這個代碼有五個可以優化的地方
// 問題1：鎖未設置有效時間，如果一個線程卡住了，那麼其他線程都要等他恢復。
// 問題2：減庫存操作時非原子(stock--)（非主要矛盾）
// 問題3：A線程釋放了B線程的鎖，可能當t1線程獲取鎖proKey後這種執行減庫操作時卡住了，然後時間超過了鎖過期時間，此時t2線程也過來成功拿到鎖，結果還沒執行完任務，t1線程恢復了並執行了finally裏的解鎖操作，就把t2線程的鎖給解開了。這裏可以通過uuid生成一個唯一的key。
// 問題4：解鎖邏輯是非原子操作，可以使用Lua腳本處理
// 問題5：鎖的有效時間很難設置一個合理有效的時間，可以使用看門狗（可以定時檢查是否還持有鎖，如果有就延長時間）
@PostMapping("/delStock")
public String delStock() {
String proKey = "proKey";
String uuid = UUID.randomUUID().toString(); // 唯一作為身份標識
// 加鎖，同時設置30秒過期時間
Boolean save = redisService.setCacheObjectIfAbsent(proKey, uuid, 30, TimeUnit.SECONDS);
if (!save) {
return "unlock"; // 未獲取到鎖
}
try {
// 獲取庫存
String stockKey = "stock";
Integer stock = redisService.getCacheObject(stockKey, Integer.class);
if (stock <= 0) {
return "error"; // 秒殺失敗
}
stock--;
redisService.setCacheObject(stockKey, stock);
} finally {
// 使用Lua腳本原子解鎖：僅當value與uuid一致時才刪除key
redisService.cad(proKey, uuid);
}
return "ok"; // 秒殺成功
}在本項目中是藉助Redisson 來完成分佈式鎖的封裝
Redisson 是一個基於Redis的Java客户端，專為分佈式應用設計，它封裝了分佈式鎖、集合、隊列、映射等常用功能，使開發者能夠更高效地構建高性能、高可用的分佈式系統。
package com.hyldzbg.fwcommonredis;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
/**
* 分佈式鎖
*/
@Slf4j
@RequiredArgsConstructor
@Service
public class RedissonLockService {
/**
* redis操作客户端
*/
private final RedissonClient redissonClient;
/**
* 獲取鎖
*
* @param lockKey 鎖的key，唯一標識，建議模塊名+唯一鍵
* @param expire 超時時間，單位毫秒，傳入-1自動續期
* @return 獲取到的RLock實例，為null則獲取失敗
*/
public RLock acquire(String lockKey, long expire,long waitTime) {
try {
final RLock lockInstance = redissonClient.getLock(lockKey);
// 注意：如果tryLock指定了leaseTime>0就不會續期。參考 RedissonLock類的tryAcquireAsync方法的實現
//如果這裏獲取鎖失敗就返回null
if(lockInstance.tryLock(waitTime,expire,TimeUnit.MILLISECONDS) == false){
return null;
}
// lockInstance.lock(expire,TimeUnit.MILLISECONDS);
return lockInstance;
} catch (Exception e) {
return null;
}
}
/**
* 釋放鎖。注意：必須和獲取鎖在一個線程中
*
* @param lockInstance 鎖的實例，acquire返回的
* @return 釋放成功返回true，否則返回false
*/
public boolean releaseLock(RLock lockInstance) {
if (lockInstance.isHeldByCurrentThread()) {
lockInstance.unlock();
return true;
}
return false;
}
}二級緩存服務類
本地緩存的作用
- 提升性能：減少服務器與後端存儲交互次數，降低網絡延遲，加快數據讀取。
- 降低存儲壓力：減輕後端負載，避免因高頻請求導致性能下降，保障系統穩定運行。
- 提高可用性：網絡短暫故障時可依靠本地緩存繼續服務，增強系統可用性。
- 增強安全與健壯性：隔離併發衝擊，保護後端數據源，提升數據安全及系統穩定性。
- 適應複雜業務：兩級緩存可按業務特點靈活配置，進一步優化性能。
- 統一規範：全局一致的緩存策略與接口，降低維護成本。
本地緩存雖快，但容量小、無法共享，仍可能把壓力透給 MySQL；
因此項目裏把它當一級緩存，Redis 做二級緩存，再搭配 MySQL，形成兩級緩存架構，分擔流量、補齊容量，構成完整查詢鏈路。
本地緩存面臨的挑戰
- 緩存一致性
兩級緩存與數據庫的數據要保持一致，一旦數據發生了修改，在修改數據庫的同時，本地緩存、遠程緩存應該同步更新。
- 是否允許存儲空值？
這個確實是需要考慮的點。因為如果某個查詢緩存和數據庫中都沒有，那麼就會導致頻繁查詢數據庫，導致數據庫Down，這也是常説的緩存穿透。
但如果存儲空值呢，因為可能會存儲大量的空值，導致緩存變大，所以這個最好是可配置，按照業務來決定是否開啓。
- 一級緩存存儲數量上限的考慮
一級緩存是服務器內存中的緩存機制，那我們就需要考慮一級緩存存儲的數據的最大值，避免存儲太多的一級緩存導致OOM。
本項目藉助Caffeine構建本地緩存功能
核心設計
- 將本地緩存封裝至 fw-common 工程下的 fw-common-cache 中
- 通過 Caffeine 和 Redis 提供通用的兩級緩存解決方案
- 封裝本地緩存工具類
- 提供動態參數配置調控 Caffeine
配置
package wx.hyldzbg.fwcommoncache.config;
@Configuration
public class CacheConfig {
/**
* 初始容量
*/
@Value("${caffeine.build.initial-capacity:128}")
private Integer initialCapacity;
/**
* 最⼤容量
*/
@Value("${caffeine.build.maximum-size:1024}")
private Long maximumSize;
/**
* 過期時間
*/
@Value("${caffeine.build.expire:60}")
private Long expire;
@Bean
public Cache<String,Object> caffeineCache(){
return Caffeine.newBuilder()
.initialCapacity(initialCapacity)
.maximumSize(maximumSize)
.expireAfterWrite(expire, TimeUnit.SECONDS)
.build();
}
}代碼
package wx.hyldzbg.fwcommoncache.service;
import com.fasterxml.jackson.core.type.TypeReference;
import com.github.benmanes.caffeine.cache.Cache;
import com.hyldzbg.fwcommonredis.RedisService;
import java.util.concurrent.TimeUnit;
public class CacheUtil {
//***********************查詢********************************
public static <T> T getL2Cache(RedisService redisService, String key,
Cache<String,Object> caffeineCache, TypeReference<T> typeReference){
//從一級緩存獲取
//這裏可以直接強轉是因為，在存儲一級緩存的時候並沒有進行序列化，所以獲取數據時也不需要序列化
T ret = (T)caffeineCache.getIfPresent(key);
if(ret != null){
return ret;
}
//一級緩存沒找到，從二級緩存找
//redis要序列化是因為，在存儲數據時，為了消除redis原本的序列化，進行了jackson配置序列化存儲
//所以獲取redis數據時要進行序列化
ret = redisService.getCacheObject(key,typeReference);
if(ret != null){
//存入一級緩存
caffeineCache.put(key,ret);
return ret;
}
//TODO 從db中進行數據查詢 這部分用户需自行提供
return null;
}
//***********************插入********************************
/**
* 存入一級緩存
* @param key
* @param value
* @param caffeineCache
* @param <T>
*/
public static <T> void setL2Cache(String key, T value, Cache<String,Object> caffeineCache){
caffeineCache.put(key,value);//TODO 本地緩存也要設置有效時間
}
/**
* 往一級二級緩存中存儲數據（有過期時間）
* @param redisService
* @param key 插入的key
* @param value 插入的值
* @param caffeineCache
* @param timeout 過期時間
* @param timeUnit 過期時間單位
* @param <T>
*/
public static <T> void setL2Cache(RedisService redisService, String key, T value,
Cache<String,Object> caffeineCache, Long timeout, TimeUnit timeUnit){
redisService.setCacheObject(key,value,timeout,timeUnit);
caffeineCache.put(key,value); //TODO 本地緩存也要設置有效時間
}
/**
* 往一級二級緩存中存儲數據（無過期時間）
* @param redisService
* @param key 插入的key
* @param value 插入的值
* @param caffeineCache
* @param <T>
*/
public static <T> void setL2Cache(RedisService redisService, String key, T value,
Cache<String,Object> caffeineCache){
redisService.setCacheObject(key,value);
caffeineCache.put(key,value);
}
}這裏和redis一樣，可以把配置放在nacos裏，哪個包需要就直接導入依賴和配置就行
RabbitMQ服務類
RabbitMQ作用
- 異步解耦：在業務流程中,一些操作可能非常耗時,但並不需要即時返回結果.可以藉助MQ把這些操作異步化,比如用户註冊後發送註冊短信或郵件通知,可以作為異步任務處理,而不必等待這些操作完成後才告知用户註冊成功.
- 流量削峯：在訪問量劇增的情況下,應用仍然需要繼續發揮作用,但是是這樣的突發流量並不常見.如果以能處理這類峯值為標準而投入資源,無疑是巨大的浪費.使用MQ能夠使關鍵組件支撐突發訪問壓力,不會因為突發流量而崩潰.比如秒殺或者促銷活動,可以使用MQ來控制流量,將請求排隊,然後系統根據自己的處理能力逐步處理這些請求.
- 異步通信：在很多時候應用不需要立即處理消息,MQ提供了異步處理機制,允許應用把一些消息放入MQ中,但並不立即處理它,在需要的時候再慢慢處理.
- 消息分發：當多個系統需要對同一數據做出響應時,可以使用MQ進行消息分發.比如支付成功後,支付系統可以向MQ發送消息,其他系統訂閲該消息,而無需輪詢數據庫.
- 延遲通知：在需要在特定時間後發送通知的場景中,可以使用MQ的延遲消息功能,比如在電子商務平台中，如果用户下單後一定時間內未支付，可以使用延遲隊列在超時後自動取消訂單
核心設計
- 將 RabbitMQ 封裝到 fw-common 工程下的 fw-common-mq 模塊
- 提供常用配置模板，開箱即用
- 通過 Nacos 實現 RabbitMQ 參數動態調控
其中聲明瞭郵件發送的隊列，給之後的郵件服務做鋪墊
package com.hyldzbg.fwcommonrabbitmq.config;
/**
* Rabbitmq配置
*/
@Configuration
public class RabbitMqCommonConfig {
@Bean("testQueue")
public Queue workQueue() {
return QueueBuilder.durable("testQueue").build();
}
@Bean("mailQueue")
public Queue mailQueue() {
return QueueBuilder.durable(RabbitConstant.MAIL_QUEUE_NAME).build();
}
//聲明交換機
@Bean("mailExchange")
public FanoutExchange fanoutExchange() {
return ExchangeBuilder.fanoutExchange(RabbitConstant.MAIL_EXCHANGE_NAME).durable(true).build();
}
//隊列和交換機綁定
@Bean
public Binding queueBinding(@Qualifier("mailExchange") FanoutExchange
exchange, @Qualifier("mailQueue") Queue queue) {
return BindingBuilder.bind(queue).to(exchange);
}
/**
* json 序列化轉換器
* @return 序列化轉換器
*/
@Bean
public MessageConverter jsonToMapMessageConverter() {
return new Jackson2JsonMessageConverter();
}
}本文章為轉載內容，我們尊重原作者對文章享有的著作權。如有內容錯誤或侵權問題，歡迎原作者聯繫我們進行內容更正或刪除文章。
