Redis+Caffeine实现高效两级缓存架构的详细指南

// 按数量淘汰（保留最近使用的1000个）
caffeine.newbuilder().maximumsize(1000)

// 按时间淘汰（数据保存1小时）
caffeine.newbuilder().expireafterwrite(1, timeunit.hours)

// 创建缓存（相当于准备一个储物柜）
cache<string, user> cache = caffeine.newbuilder()
    .maximumsize(100)  // 最多存100个用户
    .expireafterwrite(10, timeunit.minutes) // 10分钟不用就清理
    .build();

// 存数据（往柜子里放东西）
cache.put("user101", new user("张三"));

// 取数据（从柜子拿东西）
user user = cache.getifpresent("user101");

// 取不到时自动加载（柜子没有就去仓库找）
user user = cache.get("user101", key -> userdao.getuser(key));

@override
public order getorderbyid(integer id) {
    string key = cacheconstant.order + id;
    return (order) ordercache.get(key, k -> {
        // 先查询 redis
        object obj = redistemplate.opsforvalue().get(key);
        if (obj != null) {
            log.info("get data from redis");
            if (obj instanceof order) {
                return (order) obj;
            } else {
                log.warn("unexpected type from redis, expected order but got {}", obj.getclass());
            }
        }

        // redis没有或类型不匹配则查询 db
        log.info("get data from database");
        order myorder = ordermapper.getorderbyid(id);
        redistemplate.opsforvalue().set(key, myorder, 120, timeunit.seconds);
        return myorder;
    });
}

@cacheable(value = "users", key = "#userid")  
public user getuserbyid(long userid) {
    // 如果缓存中没有，才执行此方法
    return userrepository.findbyid(userid).orelse(null);
}

@cacheput(value = "users", key = "#user.id")  
public user updateuser(user user) {
    return userrepository.save(user); // 更新数据库后，自动更新缓存
}

@cacheevict(value = "users", key = "#userid")  
public void deleteuser(long userid) {
    userrepository.deletebyid(userid); // 删除数据库数据后，自动删除缓存
}

@cacheable(value = "order", key = "#id")
@override
public order getorderbyid(integer id) {
    string key = cacheconstant.order + id;
    // 先查询 redis
    object obj = redistemplate.opsforvalue().get(key);
    if (obj != null) {
        log.info("get data from redis");
        if (obj instanceof order) {
            return (order) obj;
        } else {
            log.warn("unexpected type from redis, expected order but got {}", obj.getclass());
        }
    }

    // redis没有或类型不匹配则查询 db
    log.info("get data from database");
    order myorder = ordermapper.getorderbyid(id);
    redistemplate.opsforvalue().set(key, myorder, 120, timeunit.seconds);
    return myorder;
}

@override
@cacheput(cachenames = "order",key = "#order.id")
public order updateorder(order order) {
    log.info("update order data");
    ordermapper.updateorderbyid(order);
    //修改 redis
    redistemplate.opsforvalue().set(cacheconstant.order + order.getid(),
                                    order, 120, timeunit.seconds);

    return order;
}

@override
@cacheevict(cachenames = "order",key = "#id")
public void deleteorderbyid(integer id) {
    log.info("delete order");
    ordermapper.deleteorderbyid(id);
    redistemplate.delete(cacheconstant.order + id);
}

/**
 * 双缓存注解，用于标记需要使用双缓存（通常为本地缓存和远程缓存）的方法
 */
@target(elementtype.method)
@retention(retentionpolicy.runtime)
@documented
public @interface doublecache {
    /**
     * 指定缓存的名称
     * @return 缓存名称
     */
    string cachename();

    /**
     * 指定缓存的键，支持spring el表达式
     * @return 缓存键
     */
    string key(); //支持springel表达式

    /**
     * 指定二级缓存的超时时间，单位默认根据实现确定（通常为秒）
     * 默认值为120
     * @return 二级缓存超时时间
     */
    long l2timeout() default 120;

    /**
     * 指定缓存类型
     * 默认值为 cachetype.full
     * @return 缓存类型
     */
    cachetype type() default cachetype.full;
}

public enum cachetype {
    full,   //存取
    put,    //只存
    delete  //删除
}

public class spelexpressionutils {

    /**
     * 解析 spel 表达式并替换变量
     * @param elstring 表达式（如 "user.name"）
     * @param map 变量键值对
     * @return 解析后的字符串
     */
    public static string parse(string elstring, treemap<string, object> map) {
        // 将输入的表达式包装为 spel 表达式格式
        elstring = string.format("#{%s}", elstring);
        // 创建 spel 表达式解析器
        expressionparser parser = new spelexpressionparser();
        // 创建标准的评估上下文，用于存储变量
        evaluationcontext context = new standardevaluationcontext();
        // 将传入的变量键值对设置到评估上下文中
        map.foreach(context::setvariable);
        // 使用解析器解析表达式，使用模板解析上下文
        expression expression = parser.parseexpression(elstring, new templateparsercontext());
        // 在指定上下文中计算表达式的值，并将结果转换为字符串返回
        return expression.getvalue(context, string.class);
    }
}

@slf4j
@component
@aspect
@allargsconstructor
public class cacheaspect {

    private final cache<string, object> cache;
    private final redistemplate<string, object> redistemplate;

    /**
     * 定义切点，匹配使用了 @doublecache 注解的方法
     */
    @pointcut("@annotation(com.example.redis_caffeine.annonation.doublecache)")
    public void cacheaspect() {}

    /**
     * 环绕通知，处理缓存的读写、更新和删除操作
     * 
     * @param point 切入点对象，包含方法执行的相关信息
     * @return 方法执行的返回结果
     * @throws throwable 方法执行过程中可能抛出的异常
     */
    @around("cacheaspect()")
    public object doaround(proceedingjoinpoint point) throws throwable {
        try {
            // 获取方法签名和方法对象
            methodsignature signature = (methodsignature) point.getsignature();
            method method = signature.getmethod();

            // 解析参数，将参数名和参数值存入 treemap 中
            string[] paramnames = signature.getparameternames();
            object[] args = point.getargs();
            treemap<string, object> treemap = new treemap<>();
            for (int i = 0; i < paramnames.length; i++) {
                treemap.put(paramnames[i], args[i]);
            }

            // 获取方法上的 @doublecache 注解
            doublecache annotation = method.getannotation(doublecache.class);
            // 解析 spel 表达式，得到最终的 key 片段
            string elresult = spelexpressionutils.parse(annotation.key(), treemap);
            // 拼接完整的缓存 key
            string realkey = annotation.cachename() + cacheconstant.order + elresult;

            // 处理强制更新操作
            if (annotation.type() == cachetype.put) {
                // 执行目标方法
                object object = point.proceed();
                // 将结果存入 redis，并设置过期时间
                redistemplate.opsforvalue().set(realkey, object, annotation.l2timeout(), timeunit.seconds);
                // 将结果存入 caffeine 缓存
                cache.put(realkey, object);
                return object;
            }

            // 处理删除操作
            if (annotation.type() == cachetype.delete) {
                // 从 redis 中删除缓存
                redistemplate.delete(realkey);
                // 从 caffeine 缓存中删除缓存
                cache.invalidate(realkey);
                return point.proceed();
            }

            // 优先从 caffeine 缓存中获取数据
            object caffeinecache = cache.getifpresent(realkey);
            if (caffeinecache != null) {
                log.info("get data from caffeine");
                return caffeinecache;
            }

            // 其次从 redis 中获取数据
            object rediscache = redistemplate.opsforvalue().get(realkey);
            if (rediscache != null) {
                log.info("get data from redis");
                // 将从 redis 中获取的数据存入 caffeine 缓存
                cache.put(realkey, rediscache);
                return rediscache;
            }

            // 最后查询数据库
            log.info("get data from database");
            object object = point.proceed();
            if (object != null) {
                // 将数据库查询结果存入 redis，并设置过期时间
                redistemplate.opsforvalue().set(realkey, object, annotation.l2timeout(), timeunit.seconds);
                // 将数据库查询结果存入 caffeine 缓存
                cache.put(realkey, object);
            }
            return object;
        } catch (exception e) {
            // 记录缓存切面处理过程中的错误
            log.error("cache aspect error", e);
            throw e;
        }
    }
}

/**
* 根据订单id获取订单信息
* 使用 @doublecache 注解，类型为 full，会执行完整的缓存操作逻辑
* @param id 订单id
* @return 订单对象
*/
@override
@doublecache(cachename = "order", key = "#id",
             type = cachetype.full)
public order getorderbyid(integer id) {
    return ordermapper.getorderbyid(id);
}

/**
* 更新订单信息
* 使用 @doublecache 注解，类型为 put，会执行缓存更新操作
* @param order 订单对象
*/
@override
@doublecache(cachename = "order", key = "#id",
             type = cachetype.put)
public void updateorder(order order) {
    ordermapper.updateorderbyid(order);
}

/**
* 根据订单id删除订单信息
* 使用 @doublecache 注解，类型为 delete，会执行缓存删除操作
* @param id 订单id
*/
@override
@doublecache(cachename = "order", key = "#id",
             type = cachetype.delete)
public void deleteorderbyid(integer id) {
    ordermapper.deleteorderbyid(id);
}

@configuration
@enablecaching
public class caffeineconfig {

    //-----------------------------v1------v3-----------------------------------
    @bean
    public cache<string, object> ordercache() {
        return caffeine.newbuilder()
                .initialcapacity(128)
                .maximumsize(1024)
                .expireafterwrite(60, timeunit.seconds)
                .build();
    }

    //-----------------------------v2------------------------------------------
    @bean
    public cachemanager cachemanager(){
        caffeinecachemanager cachemanager=new caffeinecachemanager();
        cachemanager.setcaffeine(caffeine.newbuilder()
                .initialcapacity(128)
                .maximumsize(1024)
                .expireafterwrite(60, timeunit.seconds));
        return cachemanager;
    }
}

@bean
public redistemplate<string, object> redistemplate(redisconnectionfactory factory) {

    redistemplate<string, object> template = new redistemplate<>();

    template.setconnectionfactory(factory);

    // 创建 objectmapper 实例，用于 json 序列化和反序列化
    objectmapper objectmapper = new objectmapper();
    // 注册 javatimemodule，用于支持 java 8 日期时间类型的序列化和反序列化
    objectmapper.registermodule(new javatimemodule());
    // 禁用将日期写成时间戳的功能
    objectmapper.disable(serializationfeature.write_dates_as_timestamps);
    // 启用默认类型信息，用于处理多态类型的序列化和反序列化
    objectmapper.activatedefaulttyping(objectmapper.getpolymorphictypevalidator(),
                                       objectmapper.defaulttyping.non_final);

    // 创建 genericjackson2jsonredisserializer 实例，使用配置好的 objectmapper
    genericjackson2jsonredisserializer serializer =
        new genericjackson2jsonredisserializer(objectmapper);

    template.setkeyserializer(new stringredisserializer());

    template.setvalueserializer(serializer);

    template.sethashkeyserializer(new stringredisserializer());

    template.sethashvalueserializer(serializer);


    template.afterpropertiesset();
    return template;
}