目录

封装常用组件

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作用

1. 异步解耦：在业务流程中,一些操作可能非常耗时,但并不需要即时返回结果.可以借助MQ把这些操作异步化,比如用户注册后发送注册短信或邮件通知,可以作为异步任务处理,而不必等待这些操作完成后才告知用户注册成功.  
2. 流量削峰：在访问量剧增的情况下,应用仍然需要继续发挥作用,但是是这样的突发流量并不常见.如果以能处理这类峰值为标准而投入资源,无疑是巨大的浪费.使用MQ能够使关键组件支撑突发访问压力,不会因为突发流量而崩溃.比如秒杀或者促销活动,可以使用MQ来控制流量,将请求排队,然后系统根据自己的处理能力逐步处理这些请求.  
3. 异步通信：在很多时候应用不需要立即处理消息,MQ提供了异步处理机制,允许应用把一些消息放入MQ中,但并不立即处理它,在需要的时候再慢慢处理.  
4. 消息分发：当多个系统需要对同一数据做出响应时,可以使用MQ进行消息分发.比如支付成功后,支付系统可以向MQ发送消息,其他系统订阅该消息,而无需轮询数据库.  
5. 延迟通知：在需要在特定时间后发送通知的场景中,可以使用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();
    }
}