两行代码完成分布式锁

今天药忘吃喽~ 2022-05-23 13:16 149阅读 0赞

# springboot + lombock + redission 实现分布式 #

*  springboot + lombock + redission 实现分布式
    
     *  1 缘起
     *  2 效果
     *  3 实现
        
         *  3.1 二话不说，直接导包
         *  3.2 RedissonProperties rediss配置类
         *  3.3 RedisstionConfig
         *  3.4 RedissLockUtil 分布式锁工具类
         *  3.5 配置
     *  4 好的代码一定要有测试
        
         *  4.1 测试代码
         *  4.2 输出
     *  5 进阶修炼
     *  6 结束

## 1 缘起 ##

> 由于工作中需要用到分布式锁，在查看很多博客以后，发现很多博客都是错误的，于是就完成了 《Java 正确实现 redis 分布式锁》（下面有链接） ，但是心中一直不大满意，直到我发现了 redission， 爱折腾的我有了下面的故事。。。

*    
    
 *  通过 jedis 实现的分布式锁， 参照之前的文章

> Java 正确实现 redis 分布式锁 [https://blog.csdn.net/qq\_35704236/article/details/80406916][https_blog.csdn.net_qq_35704236_article_details_80406916]

## 2 效果 ##

技术服务业务，当然是越简单越好

RedissLockUtil.lock("ORDER_123456");
    
    // TODO 业务逻辑
    
    RedissLockUtil.unlock("ORDER_123456");

## 3 实现 ##

### 3.1 二话不说，直接导包 ###

<dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson</artifactId>
        <version>3.5.0</version>
    </dependency>
    
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.18</version>
        <scope>provided</scope>
    </dependency>

### 3.2 RedissonProperties rediss配置类 ###

package com.study.redission;
    
    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    /** * rediss 配置类 请根据实际情况调整 */
    @Data
    @ConfigurationProperties(prefix = "redisson")
    public class RedissonProperties { 
    
        /** * Redis服务器响应超时 */
        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;
    }

### 3.3 RedisstionConfig ###

package com.study.redission;
    
    import org.redisson.Redisson;
    import org.redisson.api.RedissonClient;
    import org.redisson.config.Config;
    import org.redisson.config.SingleServerConfig;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /** * @Author: huangwenjun * @Description: * @Date: Created in 18:09 2018/6/8 **/
    @Configuration
    @EnableConfigurationProperties(RedissonProperties.class)
    public class RedisstionConfig {
    
        @Autowired
        private RedissonProperties redssionProperties;
    
        /** * 单机模式自动装配 * @return */
        @Bean
        RedissonClient redissonSingle() {
            Config config = new Config();
            SingleServerConfig serverConfig = config.useSingleServer()
                    .setAddress(redssionProperties.getAddress())
                    .setTimeout(redssionProperties.getTimeout())
                    .setConnectionPoolSize(redssionProperties.getConnectionPoolSize())
                    .setConnectionMinimumIdleSize(redssionProperties.getConnectionMinimumIdleSize());
    
            if(redssionProperties.getPassword() != null && !"".equals(redssionProperties.getPassword().trim())) {
                serverConfig.setPassword(redssionProperties.getPassword());
            }
    
            RedissonClient redissonClient = Redisson.create(config);
            // 将client注入
            RedissLockUtil.setLocker(redissonClient);
    
            return redissonClient;
        }
    }

### 3.4 RedissLockUtil 分布式锁工具类 ###

package com.study.redission;
    
    import java.util.concurrent.TimeUnit;
    
    import org.redisson.api.RLock;
    import org.redisson.api.RedissonClient;
    
    
    /** * @Author: huangwenjun * @Description: * @Date: Created in 18:15 2018/6/8 **/
    public class RedissLockUtil { 
    
        private static RedissonClient redissonClient;
    
        protected static void setLocker(RedissonClient locker) {
            redissonClient = locker;
        }
    
        /** * 加锁 * @param lockKey * @return */
        public static RLock lock(String lockKey) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock();
    
            return lock;
        }
    
        /** * 释放锁 * @param lockKey */
        public static void unlock(String lockKey) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.unlock();
        }
    
        /** * 释放锁 * @param lock */
        public static void unlock(RLock lock) {
            lock.unlock();
        }
    
        /** * 带超时的锁 * @param lockKey * @param timeout 超时时间 单位：秒 */
        public static RLock lock(String lockKey, int timeout) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock(timeout, TimeUnit.SECONDS);
            return lock;
        }
    
        /** * 带超时的锁 * @param lockKey * @param unit 时间单位 * @param timeout 超时时间 */
        public static RLock lock(String lockKey, TimeUnit unit ,int timeout) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock(timeout, unit);
            return lock;
        }
    
        /** * 尝试获取锁 * @param lockKey * @param unit 时间单位 * @param waitTime 最多等待时间 * @param leaseTime 上锁后自动释放锁时间 * @return */
        public static boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
            RLock lock = redissonClient.getLock(lockKey);
            try {
                return lock.tryLock(waitTime, leaseTime, unit);
            } catch (InterruptedException e) {
                return false;
            }
        }
    }

### 3.5 配置 ###

redisson.address=redis://127.0.0.1:6379
    redisson.password=

--------------------

## 4 好的代码一定要有测试 ##

### 4.1 测试代码 ###

@RequestMapping("lock")
    public void lock() {
        System.out.println(Thread.currentThread().getName() + ",抢占锁");
    
        RedissLockUtil.lock("ORDER_123456");
        System.out.println(Thread.currentThread().getName() + ", 获取锁");
    
        // TODO 业务逻辑
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    
        RedissLockUtil.unlock("ORDER_123456");
        System.out.println(Thread.currentThread().getName() + ", 释放锁");
    }

### 4.2 输出 ###

http-nio-8080-exec-1,抢占锁
    http-nio-8080-exec-1, 获取锁
    http-nio-8080-exec-5,抢占锁
    http-nio-8080-exec-1, 释放锁
    http-nio-8080-exec-5, 获取锁
    http-nio-8080-exec-2,抢占锁
    http-nio-8080-exec-5, 释放锁
    http-nio-8080-exec-2, 获取锁
    http-nio-8080-exec-2, 释放锁

## 5 进阶修炼 ##

当然身为高手的你肯定你仅仅满足与此, 下面安利一下 redisson 的官网

> [https://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95][https_github.com_redisson_redisson_wiki_E7_9B_AE_E5_BD_95]

## 6 结束 ##

> 搞完收工，如果你喜欢博主的文章的话麻烦点一下关注，如果发现博主文章的错误的话 麻烦指出， 谢谢大家。

ref:

> [https://www.cnblogs.com/yangzhilong/p/7605807.html][https_www.cnblogs.com_yangzhilong_p_7605807.html]

[https_blog.csdn.net_qq_35704236_article_details_80406916]: https://blog.csdn.net/qq_35704236/article/details/80406916
[https_github.com_redisson_redisson_wiki_E7_9B_AE_E5_BD_95]: https://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95
[https_www.cnblogs.com_yangzhilong_p_7605807.html]: https://www.cnblogs.com/yangzhilong/p/7605807.html