Redisson互斥锁构建缓存

已于 2024-04-09 23:22:41 修改
阅读量102 收藏
点赞数 1
文章标签： 缓存
于 2024-04-09 23:15:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/celan69/article/details/137571865
版权 
package cn.bynav.mower.app.annotation;

import java.lang.annotation.*;

/**
 * 添加redis缓存注解
 *
 * @author JX.LUO
 * @date 2023/9/4 14:02
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedisCacheSave {

    /**
     * redis缓存中的key
     */
    String key() default "";

    /**
     * 过期时间，默认一天过期
     */
    long expire() default 86400L;

    /**
     * 如果注解添加在返回list的方法上，则需要通过该字段指定list中的class类型
     */
    Class<?> type() default Object.class;

}

 

package cn.bynav.mower.app.annotation;

import java.lang.annotation.*;

/**
 * 删除redis缓存注解
 *
 * @author JX.LUO
 * @date 2023/9/4 14:07
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedisCacheRemove {

    String key() default "";

}

 

package cn.bynav.mower.app.aspect;

import cn.bynav.mower.app.annotation.RedisCacheRemove;
import cn.bynav.mower.app.annotation.RedisCacheSave;
import cn.bynav.mower.app.exception.CommonException;
import cn.bynav.mower.app.util.RedisCache;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

import static cn.bynav.mower.app.enums.AppHttpCodeEnum.API_TIMEOUT;

/**
 * redis缓存切面
 *
 * @author JX.LUO
 * @date 2023/9/4 14:10
 */
@Aspect
@Component
@Slf4j
public class RedisCacheAspect {

    // 项目名
    private static final String APP_NAME = "mower:admin";

    // redis分隔符
    private static final String KEY_SEPARATOR = ":";

    // redisson lock
    private static final String REDISSON_LOCK = ":lock";

    // spEl表达式转换器
    private final ExpressionParser parser
            = new SpelExpressionParser();

    // 方法参数名搜索器
    private final LocalVariableTableParameterNameDiscoverer discoverer
            = new LocalVariableTableParameterNameDiscoverer();

    @Autowired
    private RedisCache redisCache;

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 在使用RedisCacheSave注解的地方切入此切点,查询缓存是否在redis中存在，若已存在，则直接返回，否则查询数据库
     *
     * @param joinPoint 切入点信息
     * @return java.lang.Object 方法返回值
     */
    @Around("@annotation(cn.bynav.mower.app.annotation.RedisCacheSave)")
    private Object handleCache(final ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取切入的方法对象
        // 这个method是代理对象的，没有包含注解
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        // this()返回代理对象，target()返回目标对象，目标对象反射获取的method对象才包含注解
        Method methodWithAnnotations = joinPoint
                .getTarget()
                .getClass()
                .getDeclaredMethod(joinPoint.getSignature().getName(), method.getParameterTypes());
        // 根据目标方法对象获取注解对象
        RedisCacheSave cacheAnnotation = methodWithAnnotations.getDeclaredAnnotation(RedisCacheSave.class);
        // 解析key
        String keyExpr = cacheAnnotation.key();
        Object[] args = joinPoint.getArgs();
        String key = getRedisKeyBySpEl(keyExpr, methodWithAnnotations, args);
        // 到redis中获取缓存
        String cache = null;
        try {
            cache = redisCache.getCacheObject(key);
        } catch (Exception e) {
            log.error("key:{},查询redis缓存异常:{}", keyExpr, e.getMessage());
        }

        /*
        缓存未命中
         */
        if (StrUtil.isBlank(cache)) {
            // 使用分布式锁防止缓存击穿
            RLock lock = redissonClient.getLock(key + REDISSON_LOCK);
            // 尝试加锁，等待时间3s，不设置释放时间，redisson自动看门狗机制续期
            boolean isLocked = lock.tryLock(3, TimeUnit.SECONDS);

            // 成功加锁
            if (isLocked) {
                // 再次尝试能否获取到缓存
                cache = redisCache.getCacheObject(key);
                if (StrUtil.isBlank(cache)) {
                    // 若获取不到缓存，说明缓存更新失败，到数据库中去获取，并更新缓存
                    Object result = null;
                    try {
                        result = joinPoint.proceed();
                        // 从数据库获取后存入redis,若有指定过期时间，则设置
                        long expireTime = cacheAnnotation.expire();
                        // 此时result如果为空也将空值存入redis，防止缓存穿透
                        if (expireTime > 0) {
                            redisCache.setCacheObject(key, JSON.toJSONString(result), expireTime, TimeUnit.SECONDS);
                        } else {
                            redisCache.setCacheObject(key, JSON.toJSONString(result));
                        }
                    } catch (Exception e) {
                        log.warn("{} = {},缓存redis异常:{}", keyExpr, e.getMessage(), result);
                    } finally {
                        // 解锁
                        lock.unlock();
                    }
                    return result;
                } else {
                    // 获取到缓存，说明缓存已被更新成功，直接解锁，进入缓存命中流程
                    lock.unlock();
                }
            }
            // 加锁失败 => 返回超时
            else {
                throw new CommonException(API_TIMEOUT);
            }
        }

        /*
        缓存命中
         */
        // 得到被代理的方法上的注解
        Class<?> modelType = cacheAnnotation.type();
        // 得到被代理方法的返回值类型
        Class<?> returnType = ((MethodSignature) joinPoint.getSignature()).getReturnType();
        // 返回反序列化从缓存中拿到的json
        return deserialize(cache, returnType, modelType);
    }


    @Around("@annotation(cn.bynav.mower.app.annotation.RedisCacheRemove)")
    private Object handleCacheEvict(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取切入的方法对象
        // 这个m是代理对象的，没有包含注解
        Method m = ((MethodSignature) joinPoint.getSignature()).getMethod();
        // this()返回代理对象，target()返回目标对象，目标对象反射获取的method对象才包含注解
        Method methodWithAnnotations = joinPoint
                .getTarget()
                .getClass()
                .getDeclaredMethod(joinPoint.getSignature().getName(), m.getParameterTypes());
        // 根据目标方法对象获取注解对象
        RedisCacheRemove cacheEvictAnnotation = methodWithAnnotations.getDeclaredAnnotation(RedisCacheRemove.class);
        // 解析key
        String keyExpr = cacheEvictAnnotation.key();
        Object[] args = joinPoint.getArgs();
        String key = getRedisKeyBySpEl(keyExpr, methodWithAnnotations, args);
        // 先操作数据库再删除缓存
        Object result = joinPoint.proceed();
        redisCache.deleteObject(key);
        return result;
    }

    /**
     * 解析注解中的key, 支持spEl表达式的解析
     *
     * @param spElExpress 注解中spEl表达式
     * @param method      方法对象
     * @param params      方法参数
     * @return java.lang.String
     */
    private String getRedisKeyBySpEl(String spElExpress, Method method, Object[] params) {
        String redisKey = APP_NAME + KEY_SEPARATOR + method.getName();
        // 如果为空，则默认服务名:方法名
        if (StrUtil.isBlank(spElExpress)) {
            return redisKey;
        }
        // 如果不是spEl表达式，则直接使用用户传入的key
        if (!spElExpress.contains("#")) {
            return spElExpress;
        }
        // 如果是spEl表达式,但是参数为空，则默认服务名:方法名
        if (params == null) {
            return redisKey;
        }
        // 获取方法的参数名称
        String[] parameterNames = discoverer.getParameterNames(method);
        EvaluationContext context = new StandardEvaluationContext();
        if (parameterNames != null) {
            for (int i = 0; i < parameterNames.length; i++) {
                context.setVariable(parameterNames[i], params[i]);
            }
        }
        // 解析spEl表达式
        try {
            Expression expression = parser.parseExpression(spElExpress);
            Object value = expression.getValue(context);
            // 解析成功redis键 => 项目名:填入表达式
            return APP_NAME + KEY_SEPARATOR + Objects.toString(value, "");
        } catch (Exception e) {
            // 解析错误使用默认redis键 => 服务名:方法名
            return redisKey;
        }
    }

    /**
     * FastJSON反序列化获得对象
     *
     * @param json      从redis缓存中获取的字符串
     * @param clazz     添加注解的方法返回值的class类型
     * @param modelType 转换成list中的class类型
     * @return java.lang.Object
     */
    private Object deserialize(String json, Class<?> clazz, Class<?> modelType) {
        return clazz.isAssignableFrom(List.class) ? JSON.parseArray(json, modelType) : JSON.parseObject(json, clazz);
    }

}

celan69
关注
Redis与Redisson的分布式锁
桐花思雨
09-18 846
目录什么是分布式锁 什么是分布式锁 分布式锁：要这么念，首先得是『分布式』，然后才是『锁』 分布式：这里的分布式指的是分布式系统，涉及到好多技术和理论，包括 CAP 理论、分布式存储、分布式事务、分布式锁 线程锁：synchronized 是用在方法或代码块中的，我们把它叫『线程锁』，线程锁的实现其实是靠线程之间共享内存实现的，说白了就是内存中的一个整型数，有空闲、上锁这类状态，比如 synchronized 是在对象头中的 Mark Word 有个锁状态标志，Lock 的实现类大部分都有个叫 volat
阿里云专访Redisson作者Rui Gu：构建开源企业级Redis客户端之路
maoreyou的博客
07-02 1817
摘要： 本文为阿里云同学在RedisConf2018上对Redisson开源客户端作者Rui Gu做的一个专访，主要介绍了Rui Gu参与开启Redisson客户端开发的历程，同时也详细介绍了Redisson的架构模型还有在分布式锁上的工作，最后Rui Gu介绍了Redisson和开源的协作，同时介绍了后续Redisson客户端的长期发展目标。笔者代表阿里云参加了RedisConf 2018的会议...
redisson实现基于业务的互斥锁
weixin_30955341的博客
12-01 526
虽然数据库有锁的实现，但是有时候对于数据的操作更需要业务层控制。 这个解决的问题有次面试被问到过，当时不知道怎么解决，乱说一通，今天也算是有个解决方案了 项目中有个需求，就是订单需要经过一层一层的审核，审核过程中当前审核人有权限审核，上一审核人有权限撤销上一步的审核。这样在审核过程中就需要对订单审核权限进行控制： 只有当前审核人和上一审核人可以进行操作 当前审核人审核后上一审核人就不能...
2.【Redisson源码】可重入锁互斥流程
weixiaohuai的博客
12-08 578
当获取锁失败之后，首先会通过subscribe()订阅【"redisson_lock__channel" + 锁key】的消息，也就是订阅锁释放的消息，当前持有锁的线程在释放锁之后，会通过publish指令发布一条消息，这样之前获取锁失败的那些线程就知道锁已经被释放了，可以获取了。Redisson可重入锁实现互斥的关键，就是上述的第三种情况，获取锁失败后，返回锁剩余的过期时间。如上代码，可以看到，lock()方法加锁成功后，会返回nil，此处会判断为 null，直接返回。
关于Redisson中并发读出现读锁 读读互斥现象
weixin_49973957的博客
11-29 414
Redisson中并发读出现读锁 读读互斥现象
Redis机制-Redis互斥锁、分布式锁
hangegedecs的博客
05-21 1659
如上图，执行add1( )时，Thread1第一次加锁时，value会被改成1，当add2( )想获取锁时，此时Redis会进行判断，你是不是线程1来的，发现add2( )的线程名为Thread1，那么此时该锁可以重入的，value值会变成2，当add2( )执行完以后，释放锁，value又变为1，add1( )执行完以后，value变成0，此时的锁才是真正被线程1所释放了。如图，当8080的线程1进行访问时，其余的端口和线程都不可以进行访问，此时就达到了分布式锁的效果，有效的解决了超卖问题。
Springboot实战：redisson分布式缓存、分布式锁详细教程（附git源码）
dingdingdandan
05-28 1201
Springboot-cli 开发脚手架系列 文章目录Springboot-cli 开发脚手架系列简介1. 环境2. 客户端配置3. 模拟产品业务实战4. 效果演示5. 分布式锁6. 源码分享 简介 Redisson在基于NIO的Netty框架上，充分的利用了Redis键值数据库提供的一系列优势，在Java实用工具包中常用接口的基础上，为使用者提供了一系列具有分布式特性的常用工具类。 优势： 自带分布式锁 watch dog自动延期机制，无需手动对锁时间进行续期 缓存存储结构丰富 支持队列、延时队列
redis基础篇——Redis客户端（Jedis，Lettuce，Redisson）
石灰聪的博客
12-01 1262
Redis客户端 通信协议 Redis监听默认6379的端口号，可以通过TCP方式建立连接。 服务端约定了一种特殊的消息格式，每个命令都是以rn（CRLF回车+换行）结尾。这种编码格式我们之前在AOF文件里面见到了，叫做Redis Serialization Protocol（RESP，Redis序列化协议），发消息或者响应消息需要按这种格式编码，接收消息需要按这种格式解码。Redis设计这种格式的原因：容易实现、解析快、可读性强。Redis6.0新特性里面说的RESP协议升级到了3.0版本，其实就是
缓存与分布式锁
海涛帅帅的博客
08-17 441
缓存与分布式锁 缓存 缓存使用 为了系统性能的提升，我们一般都会将部分数据放入缓存中，加速访问。而db承担数据落盘工作。 哪些数据适合放入缓存？ 即时性、数据致性要求不高的 访问量大且更新频率不高的数据（读多，写少） 举例：电商类应用，商品分类，商品列表等适合缓存并加一个失效时间（根据数据更新频率来定），后台如果发布一个商品，买家需要5分钟才能看到新的商品一般还是可以接受的。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Rv6faiiF-1597635087323)(谷
使用Redisson实现分布式锁：配置与使用详解
在分布式系统中，由于多台服务器同时处理请求，为了确保数据的一致性和避免并发访问带来的问题，常常需要使用分布式锁来实现对共享资源的互斥访问。分布式锁在多个节点上可以协调对共享资源的访问，确保在同一时间...
对redis、redisson、springcache总结
qq_44985699的博客
08-15 2149
对redis-缓存中间件、redisson-分布式锁框架、springcache-分布式缓存框架总结
redis7高级篇-基于redission在多机模式下实现分布式锁
健康平安的活着的专栏
07-07 4124
其实只要客户端A一旦加锁成功，就会启动一个watch dog看门狗，它是一个后台线程，会每隔10秒检查一下，如果客户端A还持有锁key，那么就会不断的延长锁key的生存时间。紧接着就会发送一段lua脚本到redis上，比如加锁的那个锁key就是"mylock"，并且设置的时间是30秒，30秒后，mylock锁就会被释放。只要线程一加锁成功，就会启动一个watch dog看门狗，它是一个后台线程，会每隔10秒检查一下，如果线程1还持有锁，那么就会不断的延长锁key的生存时间。
玩转Redis！非常强大的Redisson分布式集合，少写60%代码
最新发布
wjianwei666的专栏
06-07 752
Redisson 是 Redis Java 客户端和实时数据平台。它为使用 Redis 提供了更方便、更简单的方法。Redisson 对象提供了关注点分离功能，可让你专注于数据建模和应用逻辑。在Java中，为我们提供了丰富的集合类，如List、Set、Map等，这些集合类在单机应用或单个JVM进程中是非常强大和有效的工具。然而，在分布式系统下，数据需要在多个JVM进程或节点之间共享和同步。
使用redisson提供分布式锁
qq_47155894的博客
11-20 2576
Redisson提供的分布式锁
Redisson--分布式锁的原理--续期/释放/互斥/可重入
IT利刃出鞘的博客
09-25 5842
本文介绍Redis的Redisson客户端的分布式锁的原理。
基于redisson实现快速缓存
ly199108171231的博客
06-13 6292
package com.*.servicecore; import com.google.common.collect.*; import org.redisson.api.*; import java.util.*; import java.util.concurrent.TimeUnit; /** * @desc redis缓存工具类 * @author ly * @date 20...
分布式Redis锁 - RedissonClient
占星安啦的博客
10-18 1万+
Redis Java Client选型-Jedis Lettuce Redisson 可重入锁（Reentrant Lock） 先写个单元测试试一下 public class RedisLockTest { private RedissonClient redissonClient; //请求的key private static final String demo ...
用RedissonClient 的锁机制,在加锁前检测锁状态，一直说是锁定状态！原因及解决方案！
qq_42799000的博客
12-15 3625
代码 RLock lock = redissonClient.getLock("KEY"); if (lock.isLocked()) { return "您已有任务正在进行中！请稍后再用！"; } //加锁 lock.lock(10, TimeUnit.MINUTES); 查询redis服务器后： get asyncTaskHeadquarters_key "0" 解决方案 del asyncTaskHeadqu
redis客户端redisson实战
热门推荐
猿类崛起
10-16 20万+
  redis 学习问题总结 http://aperise.iteye.com/blog/2310639 ehcache memcached redis 缓存技术总结 http://aperise.iteye.com/blog/2296219 redis-stat 离线安装 http://aperise.iteye.com/blo...
redisson 互斥锁
11-29
Redisson提供了多种类型的锁，其中互斥锁是其中一种。在Redisson中，互斥锁是通过RLock接口实现的。下面是一个使用Redisson互斥锁的例子： ```java RLock lock = redisson.getLock("myLock"); lock.lock(); try { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值