Redis锁的一种形式

小鱼儿 2022-01-23 14:53 244阅读 0赞

基于Redis实现的简单分布式锁  
通常在业务开发时候，尽量保证接口的调用幂等。比如，对同一个订单用户只能评价一次，如果用户评价两次则第二次应该返回异常。 但客户端存在短时间内按钮重复点击问题。这个时候由于后台集群部署，两个请求发送到不同的实例进行处理。那么在查询数据库进行判断是否已经评价会存在并问题。 简单的方案是采用redis实现一个简单的分布式锁，在第一个请求拿到之后，先获取锁，第二个请求再获取锁将失败，这样保证一个只处理一个请求。

本项目基于Spring Boot开发的starter，使用条件项目必须注入RedisTemplate对象。

*  jar包引用

<dependency>
       <groupId>com.tianba</groupId>
       <artifactId>cluster-lock-spring-boot-starter</artifactId>
       <version>1.0-SNAPSHOT</version>
    </dependency>

*  在需要进行分布式锁控制的方法添加@ClusterLock注解，value值基于SPEL表达式策略生成锁的键。

@ClusterLock("@testService.value+#user.name+#user.loves[1]+#max")
    public String test(User user, int max) {
        System.out.println("service-test:" + Thread.currentThread().getName());
        return "test";
    }

*  基本配置

cluster.lock.order=15 //配置AOP代理顺序
    cluster.lock.prefix-lock-key=TEST_CLUSTER_LOCK //配置锁键前缀

或则  
![在这里插入图片描述][20190604103315599.png]

### @ClusterLock说明 ###

*  value： SPEL表达式，可以使用@name引用SpringContext内的Bean对象，使用\#name引用方法参数
 *  key: 锁键区分，可以多个ClusterLock对应一个Key,暂时无用，后期可以进行锁策略处理
 *  invalidTime： 锁自动释放时间(秒)
 *  waitTime：等待锁时间(秒)， -1不等待

##### 实现原理 #####

Spring aop  
Spring el Expression

###### feature ######

添加锁的可重入支持  
分布式锁的实现加入本地，zookeeper等支持，类似于SpringCache

项目中的运用

import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 为方法打上该注解，在进入方法时会自动申请Redis锁，在退出方法时，会自动释放Redis锁
     */
    @Target({ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface ClusterLock {
        /**
         * Redis中的Key值(支持SpEL表达式)
         */
        String value();
    
        /**
         * 获取锁等待超时时间，默认为 120 秒
         */
        int timeout() default 120;
    
        /**
         * 锁持有时长，超过该时长将自动释放Redis锁，默认为 300 秒
         */
        int duration() default 300;
    }

切片配置类

import com.mahaha.mama.core.annotation.ClusterLock;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.Signature;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.expression.MethodBasedEvaluationContext;
    import org.springframework.core.DefaultParameterNameDiscoverer;
    import org.springframework.core.ParameterNameDiscoverer;
    import org.springframework.core.annotation.Order;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.expression.EvaluationContext;
    import org.springframework.expression.spel.standard.SpelExpressionParser;
    
    import java.lang.reflect.Method;
    import java.util.concurrent.TimeUnit;
    
    /**
     * Redis分布式锁处理切片
     * 对所有带有 @RedisLock 注解的方法进行拦截
     * 方法执行前，自动获取锁资源，并在方法执行完毕后释放锁资源
     */
    @Aspect
    @Order
    public class RedisLockAware {
        private static Logger logger = LoggerFactory.getLogger(RedisLockAware.class);
    
        @Autowired(required = false)
        private RedisTemplate<String, String> redisTemplate;
    
        private final SpelExpressionParser spelExpressionParser = new SpelExpressionParser();
    
        private final ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
    
        public RedisLockAware() {
            logger.info("RedisLock开启...");
        }
    
    
        @Pointcut("@annotation(com.mahaha.mama.core.annotation.ClusterLock)")
        private void allRedisLockAnnotationMethods() {
        }
    
        @Around("allRedisLockAnnotationMethods()")
        public Object lock(ProceedingJoinPoint joinPoint) throws Throwable {
            Signature signature = joinPoint.getSignature();
            MethodSignature methodSignature = (MethodSignature) signature;
            Method method = methodSignature.getMethod();
            Object[] args = joinPoint.getArgs();
            Object target = joinPoint.getTarget();
    
            ClusterLock annotation = method.getAnnotation(ClusterLock.class);
            int duration = annotation.duration();
            int timeout = annotation.timeout();
            String spelExpression = annotation.value();
    
            // 根据SpEL表达式计算Key
            EvaluationContext evaluationContext = new MethodBasedEvaluationContext(target, method, args, this.parameterNameDiscoverer);
            String key = spelExpressionParser.parseExpression(spelExpression).getValue(evaluationContext, String.class);
    
            logger.info("开始申请锁资源 - " + key);
    
            RedisLock redisLock = new RedisLock(key, duration, redisTemplate);
            try {
                // 上锁
                redisLock.lock(timeout, TimeUnit.SECONDS);
                logger.info("获取锁资源成功 - " + key);
                // 执行方法
                return joinPoint.proceed(args);
            } finally {
                // 解锁
                logger.info("释放锁资源 - " + key);
                redisLock.unlock();
            }
        }
    }

代码中的具体使用  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODI5NDk5OQ_size_16_color_FFFFFF_t_70]  
解释：  
注解的参数

@ClusterLock("'mmashop:shopDataUpdateLock:' + #p0.shopId")
    是什么意思

[20190604103315599.png]: /images/20220123/5235e7c3252f4d0286400a378261639c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODI5NDk5OQ_size_16_color_FFFFFF_t_70]: /images/20220123/a3db1e1d45ee4ac5bd7d1a9490f87c4b.png