使用redisson实现分布式锁

已于 2023-02-07 16:00:15 修改
阅读量1.1k 收藏 5
点赞数
分类专栏： Java 文章标签： 分布式 java redis
于 2023-02-05 14:30:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44719527/article/details/128889936
版权

在微服务项目中使用redisson实现一个分布式锁
一、引入依赖
spring-boot版本2.3.12.RELEASE

    <dependencies>
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.6.5</version>
        </dependency>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
             <version>5.8.8</version>
        </dependency>
    </dependencies>

二、配置redisson
1、RedissonConfig

@Configuration
public class RedissonConfig {

	@Bean
	public Redisson redisson() {
		Config config = new Config();
		//主从(单机)
		config.useSingleServer()
				.setAddress("redis://" +
						SystemUtils.getProperty("spring.redis.host", "127.0.0.1") + ":" +
						SystemUtils.getProperty("spring.redis.port", "6379"))
				.setConnectTimeout(SystemUtils.getProperty("spring.redis.timeout", 0, Integer.class))
				.setRetryInterval(3000)
				.setPassword(SystemUtils.getProperty("spring.redis.password"))
				.setDatabase(SystemUtils.getProperty("spring.redis.database", 0, Integer.class));
		return (Redisson) Redisson.create(config);
	}


}

2、SystemUtils工具类获取系统配置文件值

import cn.hutool.core.convert.Convert;
import cn.hutool.extra.spring.SpringUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.context.annotation.Configuration;
@Configuration
public class SystemUtils {

    /**
     * 获取系统配置(动态刷新)
     *
     * @param key
     * @return
     */
    public static String getProperty(String key) {
        return SpringUtil.getProperty(key);
    }

    /**
     * 获取系统配置(动态刷新)
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return
     */
    public static String getProperty(String key, String defaultValue) {
        String property = getProperty(key);
        return StringUtils.isBlank(property) ? defaultValue : property;
    }

    /**
     * 获取系统配置(动态刷新)
     *
     * @param key   键
     * @param clazz 返回对象类型
     * @return T
     */
    public static <T> T getProperty(String key, Class<T> clazz) {
        return Convert.convert(clazz, getProperty(key));
    }

    /**
     * 获取系统配置(动态刷新)
     *
     * @param key          键
     * @param defaultValue 默认值
     * @param clazz        返回对象类型
     * @return T
     */
    public static <T> T getProperty(String key, T defaultValue, Class<T> clazz) {
        return Convert.convert(clazz, getProperty(key), defaultValue);
    }

}

3、AssertUtils 判空、抛异常工具类

public class AssertUtils {
    private static final String NULL_STR = "null";
    public static void throwException(String msg) {
        throw new BusinessException(msg);
    }
    public static void throwException(boolean bool, String msg) {
        if (bool) {
            throw new BusinessException(msg);
        }
    }
    public static void isEmpty(Object param, String msg) {
        if (param == null) {
            throw new BusinessException(msg);
        }
    }
}

4、LockUtils 锁工具类

@Slf4j
@Component
public class LockUtils {

    /**
     * 获取锁的等待时间、默认3秒 单位毫秒
     */
    public static final long WAIT_TIME = 3000L;
    /**
     * 获取到锁的持有时间(过期时间)
     * 默认-1 使用看门狗机制，30s会检查业务是否执行完成,未完成会自动续期;
     * 若是大于1 不会使用看门狗机制,到时间就会释放锁
     */
    public static final long LEASE_TIME = -1;

    /**
     * 时间单位
     */
    public static final TimeUnit TIME_UNIT = TimeUnit.MILLISECONDS;

    /**
     * 锁前缀
     */
    public static final String LOCK_PREFIX = "lock:";
    /**
     * 提示信息
     */
    public static final String ERROR_MSG = "服务繁忙,请稍后重试!";

    @Autowired
    private Redisson redisson;

    /**
     * 获取锁对象
     * @param key
     */
    public RLock getLockObj(String key){
        return redisson.getLock(LOCK_PREFIX + key);
    }

    /**
     * 加锁-未获取到锁不抛出异常
     * @param lock 锁的key
     * @return
     */
    public boolean getLock(RLock lock) {
        return getLock(lock, WAIT_TIME, LEASE_TIME, TIME_UNIT);
    }

    /**
     * 加锁
     * @param lock 锁的key
     * @param waitTime 获取锁的等待时间
     * @param leaseTime 获取到锁的持有时间(过期时间)
     */
    public boolean getLock(RLock lock, long waitTime, long leaseTime, TimeUnit unit) {
        return doLock(lock, waitTime, leaseTime, unit, false);
    }

    /**
     * 加锁-未获取到锁直接抛出异常
     * @param lock 锁的key
     */
    public void tryLock(RLock lock) {
        tryLock(lock, WAIT_TIME, LEASE_TIME, TIME_UNIT);
    }


    /**
     * 加锁-未获取到锁直接抛出异常
     * @param lock 锁的key
     */
    public void tryLock(RLock lock, long waitTime, long leaseTime, TimeUnit unit) {
        doLock(lock, waitTime, leaseTime, unit, true);
    }

    /**
     * 加锁
     * @param lock 锁的key
     * @param waitTime 获取锁的等待时间
     * @param leaseTime 获取到锁的持有时间(过期时间)
     */
    private boolean doLock(RLock lock, long waitTime, long leaseTime, TimeUnit unit, boolean isException) {
        AssertUtils.isEmpty(lock, "锁对象不能为空!");
        log.info("开始获取分布式锁key:{}", lock.getName());
        try {
            boolean leaseLock = lock.tryLock(waitTime, leaseTime, unit);
            if (leaseLock) {
                log.info("获取分布式锁成功key:{}", lock.getName());
            } else {
                log.info("获取分布式锁失败key:{}", lock.getName());
                //是否需要直接抛出异常
                AssertUtils.throwException(isException, ERROR_MSG);
            }
            return leaseLock;
        } catch (InterruptedException e) {
            log.info("获取分布式锁失败key:{}", lock.getName());
            return false;
        }
    }

    /**
     * 解锁
     * @param lock 锁对象
     */
    public void unLock(RLock lock) {
        //锁对象不为空 并且当前存在锁 并且是当前线程的锁
        if (lock != null && lock.isLocked() && lock.isHeldByCurrentThread()){
            log.info("分布式锁解锁key:{}", lock.getName());
            lock.unlock();
        }
    }

}

4、手动使用分布式锁
（1）获取到分布式锁执行业务逻辑，若获取不到直接抛出异常

 @Autowired
    private LockUtils lockUtils;
    
    public void testLock(String key){
        //获取锁对象
        RLock lockObj = lockUtils.getLockObj(key);
        try {
            //尝试获取锁、如果他获取到锁继续执行代码逻辑,若果获取不到会抛出异常
            lockUtils.tryLock(lockObj);
            System.out.println("获取到锁");
        }finally {
            //释放锁
            lockUtils.unLock(lockObj);
        }
    }

（2）获取到分布式锁返回布尔值，true:获取到，false:未获取到

 @Autowired
    private LockUtils lockUtils;

    public void testLock(String key){
        //获取锁对象
        RLock lockObj = lockUtils.getLockObj(key);
        try {
            //尝试获取锁、如果他获取到锁继续执行代码逻辑,若果获取不到会抛出异常
            boolean lock = lockUtils.getLock(lockObj);
            if (lock){
                //获取到锁处理的事(业务逻辑)
                System.out.println("获取到锁");
            }else {
                //没有获取到锁自己想处理的事
                System.out.println("没有获取到锁");
            }
        }finally {
            //释放锁
            lockUtils.unLock(lockObj);
        }
    }

5、自定义注解方式使用(支持spring spel表达式获取值作为锁的key)
（1）自定义注解

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

    /**
     * 锁的key 默认类型_方法名 spel表达式示例
     * 对象: #{#obj.value}   Map: #{#map['key']}
     */
    String key() default "";

    /**
     * 获取到锁的持有时间(过期时间) 默认60秒
     */
    long leaseTime() default LockUtils.LEASE_TIME;

    /**
     * 获取锁的等待时间 默认3秒
     */
    long waitTime() default LockUtils.WAIT_TIME;

    /**
     * 时间单位 默认毫秒
     */
    TimeUnit timeUnit() default TimeUnit.MILLISECONDS;

    /**
     * 未获取到锁的提示信息
     */
    String errorMessage() default LockUtils.ERROR_MSG;
}

（2）、解析spel表达式

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.common.TemplateParserContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

import java.util.Map;

public class SpelParserUtils {

    public static String parse(String elString, JoinPoint point) {
        return (String)parse(String.class, elString, point);
    }

    public static <R> R parse(Class<R> r, String elString, JoinPoint point) {
        String[] paramNames = ((MethodSignature)point.getSignature()).getParameterNames();
        Object[] args = point.getArgs();
        EvaluationContext context = new StandardEvaluationContext();

        for(int i = 0; i < paramNames.length; ++i) {
            context.setVariable(paramNames[i], args[i]);
        }

        return parse(r, elString, (EvaluationContext)context);
    }

    public static String parse(String elString, Map<String, Object> map) {
        EvaluationContext context = new StandardEvaluationContext();
        map.forEach(context::setVariable);
        return parse(elString, (EvaluationContext)context);
    }

    public static String parse(String elString, EvaluationContext context) {
        return (String)parse(String.class, elString, context);
    }

    public static <R> R parse(Class<R> r, String elString, EvaluationContext context) {
        SpelExpressionParser parser = new SpelExpressionParser();
        Expression expression = parser.parseExpression(elString, new TemplateParserContext());
        return expression.getValue(context, r);
    }
}

(2) AOP解析注解

@Slf4j
@Aspect
@Component
@EnableAspectJAutoProxy
public class LockAspect {

    @Autowired
    private LockUtils lockUtils;
	//com.base.annotation.Lock 是注解全包名
    @Pointcut("@annotation(com.base.annotation.Lock)")
    public void pointcut() {
    }

    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method signatureMethod = signature.getMethod();
        Lock lock = signatureMethod.getAnnotation(Lock.class);
        Object result = null;
        if (lock != null) {
            //加锁
            String key = lock.key();
            if (StringUtils.isBlank(key)) {
                String clazzName = joinPoint.getTarget().getClass().getName();
                String methodName = signatureMethod.getName();
                key = clazzName + "_" + methodName;
            } else {
                key = SpelParserUtils.parse(key, joinPoint);
            }
            RLock rLock = lockUtils.getLockObj(key);
            try {
                //获取不到锁会抛出异常
                boolean getLock = lockUtils.getLock(rLock, lock.waitTime(), lock.leaseTime(), lock.timeUnit());
                if (getLock) {
                    //执行方法
                    result = joinPoint.proceed();
                } else {
                    AssertUtils.throwException(lock.errorMessage());
                }
            } finally {
                //解锁
                lockUtils.unLock(rLock);
            }
        } else {
            //没有添加锁注解
            result = joinPoint.proceed();
        }
        return result;
    }

}

使用注解

	//默认锁的key是类名_方法名
	//使用时最好指定key
	@Lock
    public void testAnnotationLock() {
        
    }
	//自定义key
 	@Lock(key = "#{#obj.title}")
    @ResponseBody
    @PostMapping("/testAnnotationLock")
    public void testAnnotationLock(@RequestBody Subject obj) {

    }
@Data
@TableName("t_subject")
@ApiModel("题目")
public class Subject {


    @TableId
    @ApiModelProperty(value = "主键")
    private int id;

    @ApiModelProperty(value = "标题")
    private String title;

    @ApiModelProperty(value = "选项A")
    private String option1;

    @ApiModelProperty(value = "选项B")
    private String option2;

    @ApiModelProperty(value = "选项C")
    private String option3;

    @ApiModelProperty(value = "选项D")
    private String option4;

    @ApiModelProperty(value = "答案")
    private String answer;
}

在这里插入图片描述

Redisson实现分布式锁
余生一个帆的博客
07-05 363
Redisson是什么？ 如果你之前是在用 Redis 的话，那使用 Redisson 的话将会事半功倍，Redisson 提供了使用 Redis的最简单和最便捷的方法。 Redisson的宗旨是促进使用者对 Redis 的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。 Redisson 是一个在 Redis 的基础上实现的 Java 驻内存数据网格（In-Memory Data Grid） 分布式锁必须要满足的四个条件 首先，为了确保分
[springboot专栏]使用redisson实现分布式锁
字母哥博客
08-25 2250
Redisson是Redis官方推荐的Java版的Redis客户端（Jedis、letture也是官方推荐的java版本redis客户端程序）。它提供的功能非常多，也非常强大，特别是它默认提供的分布式锁支持功能。，包含多个子项目，对于我们本节比较有用的是集成redisson-spring-data-2x之后能够支持Spring Data redis及RedisTemplate。...
Redisson实现分布式锁原理
程序猿进阶
12-09 2612
Redisson实现分布式锁原理 一、高效分布式锁 当我们在设计分布式锁的时候，我们应该考虑分布式锁至少要满足的一些条件，同时考虑如何高效的设计分布式锁，这里我认为以下几点是必须要考虑的。 1、互斥 在分布式高并发的条件下，我们最需要保证，同一时刻只能有一个线程获得锁，这是最基本的一点。 2、防止死锁 在分布式高并发的条件下，比如有个线程获得锁的同时，还没有来得及去释放锁，就因为系统故障或者其它原因使它无法执行释放锁的命令,导致其它线程都无法获得锁，造成死锁。所以分布式非常有必要设置锁的有效时间，确保系统
Redisson分布式锁全攻略：用法、场景与要点
最新发布
shitou的博客
04-15 509
Redisson分布式锁深度解析，介绍多种锁的用法以及应用场景
Redisson 实现分布式锁
Hello World
08-06 1155
对于大多数的场景而言，使用 Redisson 的普通锁就可以了，如果项目对分布式锁的安全性要求很高，推荐使用基于 Raft 或 Paxos 算法的 etcd 或 ZooKeeper，他们在设计时充分考虑了分布式环境下的一致性和可靠性问题，提供了比 RedLock 更为健壮的解决方案。我们可以将一个长时间执行的任务拆分为多个独立的较短的小任务，每个步骤都有自己独立的分布式锁，这样就可以减少锁定资源的时间，同时确保每个阶段都能在适当的时间内完成。公平锁与 JUC 中的公平锁一致，遵循先到先得的原则。
Redisson 是如何实现分布式锁的？
程序猿DD
08-27 485
点击上方蓝色“程序猿DD”，选择“设为星标”回复“资源”获取独家整理的学习资料！作者 |bravoban来源 |tech.lede.com/2017/03/08/rd/server/...
SpringBoot使用Redisson实现分布式锁（秒杀系统）
08-25
主要为大家详细介绍了SpringBoot使用Redisson实现分布式锁，秒杀系统，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
redisson实现分布式锁
12-16
在本例中，"redisson实现分布式锁"是通过AOP（面向切面编程）注解的方式进行使用的。AOP允许我们在不修改业务代码的情况下，对代码进行横切关注点的处理，如日志记录、事务管理、权限控制等。在分布式锁场景中，我们...
SpringBoot使用Redisson实现分布式锁
12程序猿的博客
03-13 633
SpringBoot使用Redisson实现分布式锁
SpringBoot集成Redisson实现分布式锁的方法示例
08-25
在使用Redisson实现分布式锁时，还需要注意以下几点： 1. Redisson是基于NIO的Netty框架上，利用了Redis键值数据库，具有非常强大的功能。 2. Redisson提供了多种集成方式，包括 SpringBoot、 Spring Cloud、Dubbo ...
Redisson分布式锁实现
猫小妖的专栏
07-20 1017
一、锁的实现原理 在一些场景中，我们希望一个方法同一时间只被一个线程执行，如果在单机环境下我们可以通过使用Java提供的并发API来限制访问，同一个JVM的线程可以通过共享堆内存中的变量来标记，这个标记其实就是锁，synchronized是通过对象头来标记；Lock接口的实现类是通过一个volatile的int型变量state来实现多线程的可见性和有序性(防止指令被重排序)；linux 内核中也...
Redisson实现分布式锁代码实现
文雯的博客
09-06 773
Redisson实现分布式锁代码实现
Redission实现分布式锁
m0_64116616的博客
05-18 6928
redission实现分布式锁，根据底层源码，分析重入锁原理，锁重试机制和锁续约（WatchDog机制）
【Redis】基于Redisson实现分布式锁（代码实现）
m0_64210833的博客
06-19 2223
基于Redisson实现分布式锁解决商品秒杀超卖的场景,包含测试代码。
分布式锁-这一篇全了解(Redis实现分布式锁完美方案)
热门推荐
Franco的博客
12-31 2万+
前言 在某些场景中，多个进程必须以互斥的方式独占共享资源，这时用分布式锁是最直接有效的。 随着技术快速发展，数据规模增大，分布式系统越来越普及，一个应用往往会部署在多台机器上（多节点），在有些场景中，为了保证数据不重复，要求在同一时刻，同一任务只在一个节点上运行，即保证某一方法同一时刻只能被一个线程执行。在单机环境中，应用是在同一进程下的，只需要保证单进程多线程环境中的线程安全性，通过 JAV...
集成后使用Redisson 实现分布式锁
07-15
使用Redisson实现分布式锁可以确保在分布式环境中对共享资源的访问是互斥的。下面是使用Redisson实现分布式锁的步骤： 1. 添加Redisson依赖：在`pom.xml`文件中添加Redisson依赖。 ```xml <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.15.5</version> </dependency> ``` 2. 配置Redisson连接信息：在`application.properties`文件中配置Redis连接信息。 ```properties spring.redis.host=127.0.0.1 spring.redis.port=6379 ``` 3. 创建RedissonClient Bean：在配置类中创建RedissonClient Bean，用于获取分布式锁实例。 ```java @Configuration public class RedissonConfig { @Value("${spring.redis.host}") private String redisHost; @Value("${spring.redis.port}") private String redisPort; @Bean(destroyMethod = "shutdown") public RedissonClient redissonClient() { Config config = new Config(); config.useSingleServer().setAddress("redis://" + redisHost + ":" + redisPort); return Redisson.create(config); } } ``` 4. 使用分布式锁：在需要进行互斥访问的代码块中使用分布式锁。 ```java @Autowired private RedissonClient redissonClient; public void doSomething() { RLock lock = redissonClient.getLock("myLock"); try { // 尝试获取锁，等待10秒，锁自动释放时间为30秒 boolean isLocked = lock.tryLock(10, 30, TimeUnit.SECONDS); if (isLocked) { // 获得锁之后执行业务逻辑 // ... } else { // 获取锁失败，处理异常情况 // ... } } catch (InterruptedException e) { // 处理异常 // ... } finally { // 释放锁 lock.unlock(); } } ``` 在以上示例中，我们使用Redisson的RLock对象来获取分布式锁。使用`tryLock`方法可以尝试获取锁，如果获取成功，则执行相应的业务逻辑；如果获取失败，则根据实际情况处理异常。最后，使用`unlock`方法释放锁。 通过以上步骤，就可以使用Redisson实现分布式锁，确保在分布式环境中对共享资源的互斥访问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值