Java使用redission分布式锁--注解方式

最新推荐文章于 2024-09-29 08:52:39 发布
最新推荐文章于 2024-09-29 08:52:39 发布
阅读量590 收藏 4
点赞数 1
文章标签： java 分布式 redis 锁 redission
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43969830/article/details/130370821
版权

一、需求

之前写redission分布式锁的时候都是嵌入到程序中，现在把分布式锁用注解的方式去实现，简单整理一下

二、pom依赖


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

三、定义注解


package com.example.redis;

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedisLock {

    /**
     * redis key
     *
     * @return
     */
    String key() default "";

    /**
     * 是否开启开门狗 开启看门狗后leaseTime默认为30秒，也可自己配置时间
     * 开启看门狗后，只要占锁成功，就会启动一个定时任务【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】,每隔10秒都会自动再续成30秒
     *
     * @return
     */
    boolean watchDog() default false;

    /**
     * 重试时间（重试获取锁自旋时间）
     *
     * @return
     */
    int waitTime() default 3;

    /**
     * 锁的有效时间
     *
     * @return
     */
    int leaseTime() default 3;

    /**
     * 方法结束是否要释放锁 true-方法执行结束释放锁 false-执行结束不释放锁,等待锁过期释放
     *
     * @return
     */
    boolean methodOverUnLock() default true;

    /**
     * 时间单位 默认是：秒
     *
     * @return
     */
    TimeUnit timeUnit() default TimeUnit.SECONDS;
}

四、编写切面

package com.example.redis;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
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.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.concurrent.TimeUnit;

/**
 * @Author:
 * @Description redission分布式锁
 * @Date: 下午5:25 2023/4/25
 */
@Slf4j
@Aspect
@Component
public class RedisLockAspect {

    @Resource
    private RedissonClient redissonClient;

    @Pointcut("@annotation(com.example.redis.RedisLock)")
    public void commitPointCut() {
    }

    @Around("commitPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        return repeatCommit(point);
    }

    private Object repeatCommit(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("*********Redission分布式锁开始执行*********");
        // 获取request对象
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest();
        String ip = getIp(request);
        // 获取方法签名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        //获取方法
        Method method = signature.getMethod();
        // 获取注解
        RedisLock commit = method.getAnnotation(RedisLock.class);
        //redis key
        String redisKey = commit.key();
        //时间单位
        TimeUnit timeUnit = commit.timeUnit();
        //是否开启看门狗
        boolean watchDog = commit.watchDog();
        //方法结束是否要释放锁
        boolean methodOverUnLock = commit.methodOverUnLock();
        //获取锁重试时间
        int waitTime = commit.waitTime();
        //锁的有效时间
        int leaseTime = commit.leaseTime();
        log.info("*********Redission分布式锁各个参数*********redisKey={},waitTime={},leaseTime={},timeUnit={},watchDog={},methodOverUnLock={}", redisKey, waitTime, leaseTime, timeUnit, watchDog, methodOverUnLock);
        if (StringUtils.isBlank(redisKey)) {
            redisKey = getRedisKey(ip, method);
        }
        try {
            //获取重入锁对象
            RLock lock = redissonClient.getLock(redisKey);
            //加锁 如果要开启"看门狗"机制，则leaseTime赋值为"-1"
            boolean locked = lock.tryLock(waitTime, true == watchDog ? -1 : leaseTime, timeUnit);
            if (!locked) {
                log.error("请勿重复提交");
                //补充自己获取锁失败的业务逻辑
            }
            // 继续执行方法
            Object proceed = joinPoint.proceed();
            log.info("*********Redission分布式锁方法执行结束*********redisKey={},waitTime={},leaseTime={},timeUnit={},watchDog={},methodOverUnLock={}", redisKey, waitTime, leaseTime, timeUnit, watchDog, methodOverUnLock);
            return proceed;
        } catch (InterruptedException e) {
            log.error("*********Redission分布式锁方法执行异常*********redisKey={},waitTime={},leaseTime={},timeUnit={},watchDog={},methodOverUnLock={}", redisKey, waitTime, leaseTime, timeUnit, watchDog, methodOverUnLock);
            log.error("*********Redission分布式锁方法执行异常*********e={}", e);
            Thread.currentThread().interrupt();
            throw e;
        } finally {
            if (methodOverUnLock) {
                unLock(redisKey);
                log.info("*********Redission分布式锁释放锁成功*********redisKey={},waitTime={},leaseTime={},timeUnit={},watchDog={},methodOverUnLock={}", redisKey, waitTime, leaseTime, timeUnit, watchDog, methodOverUnLock);
            }
        }
    }

    /**
     * 如果用户不指定key 则默认获取用户ip+类名+方法名
     *
     * @param ip
     * @param method
     * @return
     */
    private String getRedisKey(String ip, Method method) {
        String className = method.getDeclaringClass().getName();
        String methodName = method.getName();
        return String.format("%s#%s", ip + className, methodName);
    }

    /**
     * 释放锁
     *
     * @param lockKey 锁的值
     */
    public boolean unLock(String lockKey) {
        try {
            RLock lock = redissonClient.getLock(lockKey);
            if (null != lock && lock.isHeldByCurrentThread()) { //判断锁是否存在，并且判断是否当前线程加的锁。
                lock.unlock();
                return true;
            }
        } catch (Exception e) {
            log.error(String.format("释放锁%s异常", lockKey));
        }
        return false;
    }

    /**
     * 获取ip
     *
     * @param request
     * @return
     */
    public static String getIp(HttpServletRequest request) {
        String unknown = "unknown";
        if (request == null) {
            return unknown;
        }

        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }

        if (ip == null || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Forwarded-For");
        }

        if (ip == null || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }

        if (ip == null || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Real-IP");
        }

        if (ip == null || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }

        return ip;
    }
}

五、测试类

package com.example.service;

import com.example.redis.RedisLock;
import org.springframework.stereotype.Service;

/**
 * @Author: han tao
 * @Description
 * @Date: 下午5:34 2023/4/25
 */
@Service
public class RedisLockService {

    @RedisLock(key = "LOCK_TEST:", watchDog = true, methodOverUnLock = true)
    public void testRedisLock() {
        try {
            Thread.sleep(20000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

六、接口类

package com.example.api;

import com.example.service.RedisLockService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author:
 * @Description
 * @Date: 下午5:32 2023/4/25
 */
@RestController
@RequestMapping("/redis-lock")
public class RedisLockApi {


    @Autowired
    private RedisLockService redisLockService;

    /**
     * 直接输出到前端
     *
     * @param
     */
    @GetMapping("/test")
    public void testRedisLock() {

        redisLockService.testRedisLock();

    }

}

七、结果

启动项目后，浏览器重复访问：http://localhost:8080/redis-lock/test
查看后台日志即可

愛～杦辷个訾
关注
SpringBoot使用Redisson实现分布式锁
12程序猿的博客
03-13 557
SpringBoot使用Redisson实现分布式锁
Redisson之——使用Redisson通过自定义注解实现分布式锁，使用Spring AOP简化分布式锁
2401_84009929的博客
04-18 657
这份面试题几乎包含了他在一年内遇到的所有面试题以及答案，甚至包括面试中的细节对话以及语录，可谓是细节到极致，甚至简历优化和怎么投简历更容易得到面试机会也包括在内！也包括教你怎么去获得一些大厂，比如阿里，腾讯的内推名额！某位名人说过成功是靠99%的汗水和1%的机遇得到的，而你想获得那1%的机遇你首先就得付出99%的汗水！你只有朝着你的目标一步一步坚持不懈的走下去你才能有机会获得成功！成功只会留给那些有准备的人！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》
Java注解如何基于Redission实现分布式锁
08-25
主要介绍了Java注解如何基于Redission实现分布式锁,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
redission java_Java注解如何基于Redission实现分布式锁
weixin_35308269的博客
02-16 290
这篇文章主要介绍了Java注解如何基于Redission实现分布式锁,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1、定义注解类@Target({ ElementType.METHOD })@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface DistributedLock...
Redission · 可重入锁（Reentrant Lock）
最新发布
不惑
09-29 1346
下面的代码是单节点 Redis 的配置。/*** 对 Redisson 的使用都是通过 RedissonClient 对象* @return*/@Bean(destroyMethod="shutdown") // 服务停止后调用 shutdown 方法。// 创建配置// 集群模式。
基于Redission实现分布式锁（注解版）
长沙老码农
04-28 2140
起两个或者更多的服务实例，操作同一个数据库（比如扣库存），然后通过nginx将这些服务实例进行负载均衡配置，通过jmeter或者其他压力测试工具实现并发访问，比较Service方法上加@Dislock和不加的区别。我们想通过注解方式无感实现分布式锁，必须要用到AOP的功能，而且是环绕通知（有do 有 return）生成lockKey，保证锁定资源的唯一性，并且只能解锁自己加的锁。主要是将RedissonClient与Redis数据库关联起来。
使用Redission自定义注解实现分布式锁（声明式）
qq_45502554的博客
06-26 694
1.主要依赖。
这样写redission分布式锁才优雅-自定义redission分布式锁注解（含spel表达式）
怪力乌龟的博客
03-09 962
一个优雅的分布式锁实现方法，开箱即用
记录redisson实现redis分布式事务锁
04-24
Redisson是基于Redis的Java客户端，它提供了丰富的数据结构和服务，包括分布式锁、信号量、队列、计数器等，极大地扩展了Redis在分布式系统中的应用能力。本篇文章将详细探讨如何使用Redisson实现Redis分布式事务锁...
Spring Boot 集成 Redisson分布式锁（注解版）
热门推荐
Ascend1977的博客
06-09 1万+
在 Spring Boot 应用程序中使用 Redisson 可以方便地实现分布式应用程序的某些方面，例如分布式锁、分布式集合、分布式事件发布和订阅等。本篇是一个使用 Redisson 实现分布式锁的详细示例，在这个示例中，我们定义了DistributedLock注解，它可以标注在方法上，配合DistributedLockAspect切面以及IDistributedLock分布式锁封装的接口，来实现redisson 分布式锁的 API 调用。
java - 注解实现分布式锁
m0_73478445的博客
02-02 1081
分布式锁是分布式环境中解决资源共享问题的一种机制。在一个分布式系统中，有时多个进程，可能会同时访问同一份资源，例如，读写同一个数据库记录，或者获取和修改同一个文件。为了避免并发访问引起的数据不一致问题，我们需要用到分布式锁。一次只有一个进程能够获得锁，进而保证有序地、原子性地操作资源。
java分布式锁详解
weixin_46685039的博客
02-09 656
一、什么是分布式锁 二、分布式锁的实现 三、分布式锁的优缺点
redission 发音_Java注解方式基于Redission实现分布式锁
weixin_39928686的博客
01-12 132
@Aspect@Component@Slf4jpublic classDistributedLockAspect {@AutowiredprivateRedissonClient redissonClient;//这里需要修改对应的包名@Pointcut("@annotation(com.utils.annotation.DistributedLock)")public voidRlockAspe...
基于注解实现的分布式锁Java组件
瞌睡虫的博客
05-07 453
基于注解实现的分布式锁Java组件，可实现快速简单添加分布式锁能力。
一个注解实现分布式锁加锁
fhey的博客
07-23 781
首先，我们定义一个注解key：redis 锁的键，支持 SpEL 表达式。waitTime：等待时间，默认为 0 毫秒。expireTime：过期秒数，默认为 -1，使用 watchDog。timeUnit：超时时间单位。errorMsg：报错信息。
java 实现redission分布式锁 笔记
qq_50526617的博客
05-13 511
4、lock 注解 哪里用放哪里。2、redis yml文件。
redission java_java:redission
weixin_39669638的博客
02-16 494
RBucket=client.getRBucket(key, new StringCodec())，操作kv键值对RList，client.getList(key)，操作list结构，可用于消息队列RMap，client.getMap(key)，操作map结构，分布式映射RSet，操作set结构RSortedSet，操作sortedsetRQueue=client.getQueue(key)，队列...
java-redis-redission
weixin_45149147的博客
06-03 703
优势 底层是netty框架，线程安全，支持分布式锁和分布式集合 依赖 配置bean 工具类
java整合Redission
z1299236067的博客
09-05 439
spring boot 简单整合Redission流程，记录整合Redission的操作
java封装Redission分布式锁
05-17
下面是使用 Redisson 实现分布式锁的示例代码： 1. 引入 Redisson 依赖 ```xml <groupId>org.redisson <artifactId>redisson <version>3.12.5 ``` 2. 创建 Redisson 客户端 ```java Config config = new ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值