redis和redisson实现分布式锁

redis 实现分布式锁

介绍三种方式实现分布式锁：

1. Redis原生方式实现分布式锁

2. Redisson实现分布式锁

3. 注解aop的方式加Redisson实现分布式锁（推荐）

一、redis原生方式实现分布式锁

Redis 单线程

SETNX (set if not exists)

setnx key value 若key存在则添加失败，若key不存在才会添加存在

redisTempalte.setIfAbsetn(key,value,time) 设置 key 和 value 和 超时时间

try {
    // todo 业务
    
    } finally {
        // get 值，若 value 与 设置的value相等 则 删除key
        
    }

简单的实现分布式锁：

// 这里使用到了 springboot集成Redis  用到了springboot的 StringRedisTemplate
@GetMapping("/transaction")
    public String transaction() {
        // 锁的键值
        String lockKey = "orderLock";
        // 设置客户端id
        String clientId = UUID.randomUUID().toString();
        try {
            // 设置锁    如果redis中已经存在 lockKey 则会添加失败
            Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, clientId, 30, TimeUnit.SECONDS);

            if (result == null || !result) {
                return "error";
            }
            String stock = stringRedisTemplate.opsForValue().get("stock");
            if (StrUtil.isEmpty(stock)) {
                return ">>>>>>>> 数据异常请稍后重试";
            }
            int number = Integer.parseInt(stock);
            if (number > 0) {
                Long lastNumber = stringRedisTemplate.opsForValue().decrement("stock");
                System.out.println(">>>>>>>>>>> 扣除库存成功，剩余：" + lastNumber);
            } else {
                System.out.println(">>>>>>>>>>> 扣除库存失败，库存不足");
            }
        } finally {
            // 如果客户端id相等
            if (clientId.equals(stringRedisTemplate.opsForValue().get(lockKey))) {
                stringRedisTemplate.delete(lockKey);
            }
        }
        return "success";
    }

二、Redisson实现分布式锁

1.导入jar包

<!-- redisson  -->
<dependency>
     <groupId>org.redisson</groupId>
     <artifactId>redisson</artifactId>
     <version>3.12.0</version>
</dependency>

2.设置连接配置

@Getter
@Setter
@ConfigurationProperties(prefix="redisson")
public class RedissonProperties {

    private int timeout = 3000;

    private String address;

    private String password;

    private int connectionPoolSize = 64;

    private int connectionMinimumIdleSize=10;

    private int slaveConnectionPoolSize = 250;

    private int masterConnectionPoolSize = 250;

    private String[] sentinelAddresses;

    private String masterName;

}

// 自动装配

@Configuration
@ConditionalOnClass(Config.class)
@EnableConfigurationProperties(RedissonProperties.class)
public class RedissonAutoConfiguration {


    @Autowired
    private RedissonProperties redssionProperties;

	//  import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
//    @Autowired
//    private RedisProperties redisProperties;

    /**
     * 哨兵模式自动装配
     *      # 哨兵模式
     *      #redisson:
     *      #  master-name: mymaster
     *      #  password:
     *      #  sentinel-addresses: 10.47.91.83:26379,10.47.91.83:26380,10.47.91.83:26381
     * @return
     */
//    @Bean
//    @ConditionalOnProperty(name="redisson.master-name")
//    RedissonClient redissonSentinel() {
//        Config config = new Config();
//        SentinelServersConfig serverConfig = config.useSentinelServers().addSentinelAddress(redssionProperties.getSentinelAddresses())
//                .setMasterName(redssionProperties.getMasterName())
//                .setTimeout(redssionProperties.getTimeout())
//                .setMasterConnectionPoolSize(redssionProperties.getMasterConnectionPoolSize())
//                .setSlaveConnectionPoolSize(redssionProperties.getSlaveConnectionPoolSize());
//
//        if(StrUtil.isNotBlank(redssionProperties.getPassword())) {
//            serverConfig.setPassword(redssionProperties.getPassword());
//        }
//        return Redisson.create(config);
//    }

    /**
     * 单机模式自动装配
     * @return
     */
    @Bean
    @ConditionalOnProperty(name="redisson.address")
    RedissonClient redissonClient() {
        Config config = new Config();
        SingleServerConfig serverConfig = config.useSingleServer()
                .setAddress(redssionProperties.getAddress())
                .setTimeout(redssionProperties.getTimeout())
                .setDatabase(0)
                .setConnectionPoolSize(redssionProperties.getConnectionPoolSize())
                .setConnectionMinimumIdleSize(redssionProperties.getConnectionMinimumIdleSize());
        if(StrUtil.isNotBlank(redssionProperties.getPassword())) {
            serverConfig.setPassword(redssionProperties.getPassword());
        }

        return Redisson.create(config);
    }
}

/**
     *  redis集群下的配置  cluster
     * @return
     */
//    @Bean
//    public RedissonClient redisson() {
//        //redisson版本是3.5，集群的ip前面要加上“redis://”，不然会报错，3.2版本可不加
//        List<String> clusterNodes = new ArrayList<>();
//        for (int i = 0; i < redisProperties.getCluster().getNodes().size(); i++) {
//            clusterNodes.add("redis://" + redisProperties.getCluster().getNodes().get(i));
//        }
//        Config config = new Config();
//        // 采用集群模式
//        ClusterServersConfig clusterServersConfig = config.useClusterServers()
//                .addNodeAddress(clusterNodes.toArray(new String[clusterNodes.size()]));
//        //设置密码  注意这里集群的 redis 密码都必须一致
//        clusterServersConfig.setPassword(redisProperties.getPassword());
//        return Redisson.create(config);
//    }

yaml中的配置文件

# 哨兵模式
#redisson:
#  master-name: mymaster
#  password:
#  sentinel-addresses: 10.47.91.83:26379,10.47.91.83:26380,10.47.91.83:26381


# redis单机模式
redisson:
  address: redis://81.69.43.66:6379
  password: root

3.编写代码实现分布式锁

// 实现分布式锁

@GetMapping("/redisson")
    public String redisson() {
        String lockKey = "orderLock";
        // 获取锁
        RLock lock = redissonClient.getLock(lockKey);
        try {
            // 加锁
            lock.lock();

            String stock = stringRedisTemplate.opsForValue().get("stock");
            if (StrUtil.isEmpty(stock)) {
                return ">>>>>>>> 数据异常请稍后重试";
            }
            int number = Integer.parseInt(stock);
            if (number > 0) {
                Long lastNumber = stringRedisTemplate.opsForValue().decrement("stock");
                System.out.println(">>>>>>>>>>> 扣除库存成功，剩余：" + lastNumber);
            } else {
                System.out.println(">>>>>>>>>>> 扣除库存失败，库存不足");
            }

        } finally {
            System.out.println(">>>>>>>>>>>>>>>>> 解除锁定");
            // 解锁
            lock.unlock();
        }
        return "success";
    }

三、注解aop的方式加Redisson实现分布式锁（推荐）

// 定义注解类

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface LockAction {

    /**
     * 锁的名称
     */
    String value() default "";

    /**
     * 描述
     */
    String description() default "";

    /**
     * 等待锁超时时间，默认 30
     * @return
     */
    long waitTime() default 30;

    /**
     *  自动解锁时间，自动解锁时间一定得大于方法执行时间，否则会导致锁提前释放，默认100
     * @return
     */
    long leaseTime() default 100;

    /**
     * 时间单位，默认为 秒
     * @return
     */
    TimeUnit timeUnit() default TimeUnit.SECONDS;

    /**
     *  默认：可重入锁
     * @return
     */
    LockTypeEnum lockType() default LockTypeEnum.REENTRANT_LOCK;

}

// 定义AOP

@Slf4j
@Aspect
@Component
@Order(1)   //order越小越是最先执行，但更重要的是最先执行的最后结束。order默认值是2147483647
public class LockAspect implements ApplicationContextAware {

    private final String LOCK_CODE = "lockCode";

    private final RedissonClient redissonClient;

    private ApplicationContext applicationContext;

    public LockAspect(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    /**
     *  定义公共的切点
     */
    @Pointcut("@annotation(LockAction)")
    public void log(){

    }

    /**
     *  环绕通知
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around(value = "@annotation(lockAction)")
    public Object around(ProceedingJoinPoint joinPoint,LockAction lockAction) throws Throwable {

        String code = IdUtil.fastSimpleUUID();
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder
                .getRequestAttributes();
        HttpServletRequest request = Objects.requireNonNull(attributes).getRequest();
        String remoteUser = request.getRemoteUser();
        log.info(">>>>>>>>>>>> remoteUser 远程用户：{}",remoteUser);
        String requestURI = request.getRequestURI();
        log.info(">>>>>>>>>>>> requestURI 请求地址：{}",requestURI);
        request.setAttribute(LOCK_CODE, code);

        RLock lock = redissonClient.getLock(lockAction.value());
        Object proceed = null;
        try {
        // lock.lock();  // 这种方式最稳妥，框架自动续期
        // 采用自定义时间的方式，注意时间长短
            boolean b = lock.tryLock(lockAction.waitTime(), lockAction.leaseTime(), lockAction.timeUnit());
            if (b) {
                // 类似于  method.invoke 方法
                System.out.println(">>>>>>>>>>>>>>>>>>> 加锁成功");
                proceed = joinPoint.proceed();
            }
        } finally {
            lock.unlock();
            System.out.println(">>>>>>>>>>>>>>>>>>> 解锁成功");
        }

        // 第一个参数
//        String seckillId = joinPoint.getArgs()[0].toString();
        // 方法名
//        String name = joinPoint.getSignature().getName();
//        Class declaringType = joinPoint.getSignature().getDeclaringType();
//        Method[] methods = declaringType.getMethods();
//        Object proceed = null;
//        for (Method method : methods) {
//            if(name.equals(method.getName())){
//                // 获得方法上面的注解
//                String value = AnnotationUtil
//                        .getAnnotationValue(method, LockAction.class, "value");
//                if (StrUtil.isEmpty(value)){
//                    throw new RuntimeException("运行时发生异常");
//                }
//                // 获取锁
//                RLock lock = redissonClient.getLock(value);
//                try {
//                    // 加锁,加锁结果
//                    lock.lock();
//                    System.out.println(">>>>>>>>>>>>>>>>>>> 枷锁成功");
//                    // 类似于  method.invoke 方法
//                    proceed = joinPoint.proceed();
//                } finally {
//                    System.out.println(">>>>>>>>>>>>>>>>  解除锁定");
//                    lock.unlock();
//                }
//            }
//        }
        return proceed;
    }

    /**
     *  异常通知，当目标方法抛出异常时，该方法会被触发
     * @param joinPoint
     */
    @AfterThrowing(value = "log()",throwing = "e")
    public void afterThrowing(JoinPoint joinPoint, Exception e){
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = Objects.requireNonNull(attributes).getRequest();
        String code = (String) request.getAttribute(LOCK_CODE);
        log.info(">>>>>>>>>>  错误码：{}", code);
    }


    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

// 分布式锁 注解实战使用

 @LockAction(value = "lockey")
    @GetMapping("/order/{parameter}")
    public String order(@PathVariable("parameter") String parameter) {
        String stock = stringRedisTemplate.opsForValue().get("stock");
        int number = Integer.parseInt(stock);
        if (number > 0) {
            Long lastNumber = stringRedisTemplate.opsForValue().decrement("stock");
            System.out.println(">>>>>>>>>>> 扣除库存成功，剩余：" + lastNumber);
        } else {
            System.out.println(">>>>>>>>>>> 扣除库存失败，库存不足");
        }
        return "success";
    }