SpringBoot自定义Redis代码实践指南

import com.fasterxml.jackson.annotation.jsontypeinfo;
import com.fasterxml.jackson.databind.objectmapper;
import com.fasterxml.jackson.databind.jsontype.impl.laissezfairesubtypevalidator;
import com.fasterxml.jackson.datatype.jsr310.javatimemodule;
import org.springframework.cache.annotation.enablecaching;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import org.springframework.data.redis.cache.rediscacheconfiguration;
import org.springframework.data.redis.serializer.genericjackson2jsonredisserializer;
import org.springframework.data.redis.serializer.redisserializationcontext;
import org.springframework.data.redis.serializer.stringredisserializer;
import java.time.duration;
@configuration
@enablecaching // 开启缓存注解支持
public class redisconfig {
    /**
     * 自定义 rediscacheconfiguration
     * 作用：定制 key/value 的序列化方式、过期时间、key 前缀格式
     */
    @bean
    public rediscacheconfiguration rediscacheconfiguration() {
        // 1. 构造 json 序列化器
        // 使用 genericjackson2jsonredisserializer 替换默认序列化
        genericjackson2jsonredisserializer jsonserializer = buildjsonserializer();
        // 2. 构建配置
        return rediscacheconfiguration.defaultcacheconfig()
                // 【核心 1】设置默认过期时间：1 小时
                .entryttl(duration.ofhours(1))
                // 【核心 2】定制 key 的序列化：使用 string (默认就是 string，显式指定更清晰)
                .serializekeyswith(redisserializationcontext.serializationpair.fromserializer(new stringredisserializer()))
                // 【核心 3】定制 value 的序列化：使用 json
                .serializevalueswith(redisserializationcontext.serializationpair.fromserializer(jsonserializer))
                // 【核心 4】定制 key 前缀策略：cachename + ":" + key
                // 默认是 "::"，这里改为 ":"，避免 rdm 工具出现空目录
                .computeprefixwith(name -> name + ":")
                // 【可选】禁止缓存 null 值 (根据业务需求决定是否开启)
                // .disablecachingnullvalues()
                ;
    }
    /**
     * 辅助方法：构建支持 java8 时间和类型信息的 json 序列化器
     */
    private genericjackson2jsonredisserializer buildjsonserializer() {
        objectmapper objectmapper = new objectmapper();
        // 1. 注册 javatimemodule，解决 localdatetime 等时间类序列化问题
        objectmapper.registermodule(new javatimemodule());
        // 2. 启用多态类型验证，将类信息 (@class) 写入 json
        // 这样从 redis 读出来时，才能自动转回具体的 java 对象，而不仅仅是 map
        objectmapper.activatedefaulttyping(
                laissezfairesubtypevalidator.instance,
                objectmapper.defaulttyping.non_final,
                jsontypeinfo.as.property
        );
        return new genericjackson2jsonredisserializer(objectmapper);
    }
}

{
  "@class": "com.example.user",
  "id": 1001,
  "username": "admin",
  "createtime": [2023, 10, 1, 12, 0, 0]
}

import cn.hutool.core.util.strutil; // 示例使用了 hutool 工具类，也可使用原生 string 方法
import org.springframework.data.redis.cache.rediscache;
import org.springframework.data.redis.cache.rediscacheconfiguration;
import org.springframework.data.redis.cache.rediscachemanager;
import org.springframework.data.redis.cache.rediscachewriter;
import java.time.duration;
public class timeoutrediscachemanager extends rediscachemanager {
    private static final string split_flag = "#";
    public timeoutrediscachemanager(rediscachewriter cachewriter, rediscacheconfiguration defaultcacheconfiguration) {
        super(cachewriter, defaultcacheconfiguration);
    }
    /**
     * 核心重写方法：在创建 cache 对象时介入
     */
    @override
    protected rediscache createrediscache(string name, rediscacheconfiguration cacheconfig) {
        // 1. 如果名称为空或不包含分隔符，直接使用父类逻辑（应用全局默认配置）
        if (strutil.isempty(name) || !name.contains(split_flag)) {
            return super.createrediscache(name, cacheconfig);
        }
        // 2. 切割字符串
        // 格式约定：cachename#ttl，例如 "system_users#30m"
        string[] parts = name.split(split_flag);
        if (parts.length != 2) {
            return super.createrediscache(name, cacheconfig);
        }
        // 3. 提取真实缓存名和时间字符串
        string realname = parts[0]; // "system_users"
        string ttlstr = parts[1];   // "30m"
        // 4. 解析时间，并修改配置
        // 注意：rediscacheconfiguration 是不可变的，entryttl 会返回新实例
        duration duration = parseduration(ttlstr);
        if (cacheconfig != null) {
            cacheconfig = cacheconfig.entryttl(duration);
        }
        // 5. 使用真实的名称和定制后的配置创建缓存
        // 这样 redis 中的 key 就是 "prefix:system_users:key"，不会带上 "#30m"
        return super.createrediscache(realname, cacheconfig);
    }
    /**
     * 辅助方法：解析时间字符串
     * 支持格式：1d, 4h, 30m, 60s
     */
    private duration parseduration(string ttlstr) {
        string timeunit = strutil.subsuf(ttlstr, -1).tolowercase(); // 获取最后一位单位
        long timevalue = long.parselong(strutil.sub(ttlstr, 0, ttlstr.length() - 1)); // 获取数值
        switch (timeunit) {
            case "d":
                return duration.ofdays(timevalue);
            case "h":
                return duration.ofhours(timevalue);
            case "m":
                return duration.ofminutes(timevalue);
            case "s":
                return duration.ofseconds(timevalue);
            default:
                // 默认单位为秒，或者根据业务需求抛出异常
                return duration.ofseconds(long.parselong(ttlstr));
        }
    }
}

@bean
public rediscachemanager rediscachemanager(redistemplate<string, object> redistemplate,
                                           rediscacheconfiguration rediscacheconfiguration) {
    // 1. 获取连接工厂
    redisconnectionfactory factory = objects.requirenonnull(redistemplate.getconnectionfactory());
    // 2. 创建无锁的 cachewriter
    // batchstrategies.scan(1000) 是为了在使用 evict(allentries=true) 时
    // 使用 scan 命令代替 keys 命令，防止阻塞 redis 主线程
    rediscachewriter cachewriter = rediscachewriter.nonlockingrediscachewriter(factory,
            batchstrategies.scan(1000));
    // 3. 返回自定义的 timeoutrediscachemanager
    return new timeoutrediscachemanager(cachewriter, rediscacheconfiguration);
}

// 不带后缀，使用 rediscacheconfiguration 配置的全局默认时间（如 1 小时）
@cacheable(value = "system_dict", key = "#type")
public list<dict> getdictbytype(string type) { ... }

// 后缀 #60s，指定 60 秒过期
@cacheable(value = "sms_code#60s", key = "#mobile")
public string getverifycode(string mobile) { ... }

// 后缀 #1d，指定 1 天过期
@cacheable(value = "daily_ranking#1d", key = "#date")
public ranking getdailyranking(string date) { ... }

import org.springframework.data.redis.cache.rediscache;
import org.springframework.data.redis.cache.rediscacheconfiguration;
import org.springframework.data.redis.cache.rediscachewriter;
import java.util.map;
import java.util.concurrent.concurrenthashmap;
/**
 * 自定义二级缓存实现
 * l1: jvm 本地内存 (使用 concurrenthashmap 模拟，生产建议使用 caffeine)
 * l2: redis (使用父类逻辑)
 */
public class level2rediscache extends rediscache {
    // 一级缓存容器
    private final map<object, object> localcache = new concurrenthashmap<>();
    // 统计指标（可选）
    private final string name;
    public level2rediscache(string name, rediscachewriter cachewriter, rediscacheconfiguration cacheconfig) {
        super(name, cachewriter, cacheconfig);
        this.name = name;
    }
    /**
     * 重写查询逻辑 (核心)
     * 对应 @cacheable 注解的读取操作
     */
    @override
    protected object lookup(object key) {
        // 1. 【l1】先检查本地内存
        object localvalue = localcache.get(key);
        if (localvalue != null) {
            // log.debug("l1 缓存命中: key={}", key);
            return localvalue;
        }
        // 2. 【l2】本地没有，调用父类方法查 redis
        // super.lookup() 内部会处理序列化和反序列化
        object redisvalue = super.lookup(key);
        // 3. 【回填】如果 redis 查到了，回写到本地内存
        if (redisvalue != null) {
            // log.debug("l2 缓存命中并回填 l1: key={}", key);
            localcache.put(key, redisvalue);
        }
        return redisvalue;
    }
    /**
     * 重写写入逻辑
     * 对应 @cacheable 的写入和 @cacheput
     */
    @override
    public void put(object key, object value) {
        // 1. 【l2】先写 redis (保证远程数据的强一致性)
        super.put(key, value);
        // 2. 【l1】再写本地内存
        // 注意：如果是集群环境，这里只更新了当前节点的 l1。
        // 生产环境通常需要结合 redis pub/sub 通知其他节点失效 l1。
        if (value != null) {
            localcache.put(key, value);
        }
    }
    /**
     * 重写删除逻辑
     * 对应 @cacheevict
     */
    @override
    public void evict(object key) {
        // 1. 【l2】删 redis
        super.evict(key);
        // 2. 【l1】删本地
        localcache.remove(key);
    }
    /**
     * 重写清空逻辑
     * 对应 @cacheevict(allentries = true)
     */
    @override
    public void clear() {
        super.clear();
        localcache.clear();
    }
}

public class multilevelcachemanager extends rediscachemanager {
    public multilevelcachemanager(rediscachewriter cachewriter, rediscacheconfiguration defaultcacheconfiguration) {
        super(cachewriter, defaultcacheconfiguration);
    }
    @override
    protected rediscache createrediscache(string name, rediscacheconfiguration cacheconfig) {
        // 这里可以结合上一章的逻辑，先处理 cacheconfig 的 ttl
        // ... (省略 ttl 解析逻辑) ...
        // 【关键】返回自定义的 level2rediscache 实例
        // 这里的 super.createrediscache 只是为了复用父类的一些初始化检查，
        // 但我们直接 new 自己的对象是最直接的。
        return new level2rediscache(name, getcachewriter(), cacheconfig);
    }
}

@override
protected object lookup(object key) {
    long start = system.nanotime();
    try {
        object value = super.lookup(key);
        recordmetrics(key, value != null, system.nanotime() - start);
        return value;
    } catch (exception e) {
        // 容错降级：如果 redis 挂了，记录日志，返回 null 让业务查库
        // log.error("redis 异常", e);
        return null; 
    }
}
private void recordmetrics(object key, boolean hit, long durationns) {
    // 伪代码：上报给 prometheus 或 micrometer
    // metrics.counter("cache.requests", "name", this.name, "hit", string.valueof(hit)).increment();
    // metrics.timer("cache.latency", "name", this.name).record(durationns, timeunit.nanoseconds);
}

@bean("md5keygenerator")
public keygenerator keygenerator() {
    return (target, method, params) -> {
        // 自定义逻辑：拼接类名+方法名+参数md5
        return method.getname() + "_" + arrays.tostring(params);
    };
}
// 使用：@cacheable(keygenerator = "md5keygenerator")

@configuration
public class cacheconfig extends cachingconfigurersupport {
    @override
    public cacheerrorhandler errorhandler() {
        return new cacheerrorhandler() {
            @override
            public void handlecachegeterror(runtimeexception exception, cache cache, object key) {
                // 仅打印日志，不抛出异常 -> 视为未命中，自动穿透到数据库
                log.error("redis get failed, key: {}", key, exception);
            }
            // ... handleputerror, handleevicterror, handleclearerror
        };
    }
}

@bean
public lettuceconnectionfactory redisconnectionfactory() {
    lettuceclientconfiguration clientconfig = lettuceclientconfiguration.builder()
            // 优先从从节点读取，如果没有从节点则读主节点
            .readfrom(readfrom.replica_preferred) 
            .build();
    return new lettuceconnectionfactory(new redisstandaloneconfiguration(), clientconfig);
}

@bean
redismessagelistenercontainer container(redisconnectionfactory connectionfactory) {
    redismessagelistenercontainer container = new redismessagelistenercontainer();
    container.setconnectionfactory(connectionfactory);
    return container;
}
// 然后监听 __keyevent@0__:expired 频道