Redisson 分布式锁超简封装

Redisson是一个在Redis的基础上实现的Java驻内存数据网格。它几乎提供了Redis所有工具，不仅封装Redis底层数据结构，而且还提供了很多Java类型映射。Redisson支持redis单实例、redis哨兵、redis cluster、redis master-slave等各种部署架构。Redisson除了普通分布式锁还支持 联锁（MultiLock），读写锁（ReadWriteLock），公平锁（Fair Lock），红锁（RedLock），信号量（Semaphore），可过期性信号量（PermitExpirableSemaphore）和闭锁（CountDownLatch）等。

Redisson 虽然功能强大但是它依然不能解决分布式锁有可能锁不住的情况，这不是Redisson或者Redis的问题（目前遇到这种问题只能人工干预）。本篇主要是平时工作中使用对Redisson分布式锁的封装

Maven主要包配置
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.16.6</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.1.9.RELEASE</version>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.11.2</version>
</dependency>
yml 配置
redis:
 server:
  database: 0
  host: redis的ip地址
  maxIdle: 500
  maxTotal: 50
  maxWaitMillis: 10000
  minEvictableIdleTimeMillis: 60000
  minIdle: 10
  numTestsPerEvictionRun: 10
  password: yiwei-redis-666
  port: redis的端口号
  testOnBorrow: true
  testOnReturn: true
  testWhileIdle: true
  timeBetweenEvictionRunsMillis: 30000
  timeOut: 2000
JedisProperties属性配置
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Data
@Component
public class JedisProperties {
    @Value("${redis.server.host}")
    private String host;
    @Value("${redis.server.port}")
    private int port;
    @Value("${redis.server.password}")
    private String password;
    @Value("${redis.server.maxTotal}")
    private int maxTotal;
    @Value("${redis.server.maxIdle}")
    private int maxIdle;
    @Value("${redis.server.minIdle}")
    private int minIdle;
    @Value("${redis.server.maxWaitMillis}")
    private int maxWaitMillis;
    @Value("${redis.server.timeOut}")
    private int timeOut;
    @Value("${redis.server.testOnBorrow}")
    private boolean testOnBorrow;
    @Value("${redis.server.testOnReturn}")
    private boolean testOnReturn;
    @Value("${redis.server.testWhileIdle}")
    private boolean testWhileIdle;
    @Value("${redis.server.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;
    @Value("${redis.server.numTestsPerEvictionRun}")
    private int numTestsPerEvictionRun;
    @Value("${redis.server.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;
    @Value("${redis.server.database}")
    private int database;
}
JedisConfig 相关Bean配置
import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import redis.clients.jedis.JedisPoolConfig;
import javax.annotation.Resource;

@Slf4j
@Configuration
@EnableCaching
public class JedisConfig {
    @Resource
    private JedisProperties prop;
    @Bean(name = "jedisPoolConfig")
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(prop.getMaxTotal());
        config.setMaxIdle(prop.getMaxIdle());
        config.setMinIdle(prop.getMinIdle());
        config.setMaxWaitMillis(prop.getMaxWaitMillis());
        config.setTestOnBorrow(prop.isTestOnBorrow());
        config.setTestOnReturn(prop.isTestOnReturn());
        config.setTestWhileIdle(prop.isTestWhileIdle());
        config.setNumTestsPerEvictionRun(prop.getNumTestsPerEvictionRun());
        config.setMinEvictableIdleTimeMillis(prop.getMinEvictableIdleTimeMillis());
        config.setTimeBetweenEvictionRunsMillis(prop.getTimeBetweenEvictionRunsMillis());
        return config;
    }
    @Bean(name ="jedisConnectionFactory")
    public JedisConnectionFactory jedisConnectionFactory(){
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setPort(prop.getPort());
        redisStandaloneConfiguration.setHostName(prop.getHost());
        redisStandaloneConfiguration.setPassword(RedisPassword.of(prop.getPassword()));
        redisStandaloneConfiguration.setDatabase(prop.getDatabase());
        return new JedisConnectionFactory(redisStandaloneConfiguration);
    }
    @Bean(name ="redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory jedisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(jedisConnectionFactory);
        return template;
    }
}
RedissonConfig 配置类
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource;

@Configuration
public class RedissonConfig {
    @Resource
    private JedisProperties prop;
    @Bean
    public RedissonClient redissonClient(){
        Config config = new Config();
        config.useSingleServer().setAddress("redis://" + prop.getHost() + ":" + prop.getPort())
                .setPassword(prop.getPassword()).setDatabase(prop.getDatabase());
        return Redisson.create(config);
    }
}
函数式接口两个

分布式锁主要采用，模板模式，应为它天生就有业务骨架属性。当我们使用1.8以上的JDK时，针对模板模式，使用方简化了很多操作。只是需要注意定义模板方法时要定义成函数接口

public interface VoidHandle {
    /**
     * 业务处理
     */
    void execute();
}
public interface ReturnHandle<T> {
    /**
     * 业务处理
     * @return
     */
    T execute();
}
分布式锁模板封装
@Slf4j
@Service
public class RedisLock {

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 分布式锁实现
     * @param lockName 锁名称
     * @param businessId 业务ID
     * @param handle 业务处理
     */
    @Transactional(rollbackFor = Exception.class)
    public void lock(String lockName, Object businessId, VoidHandle handle) {
        RLock rLock = getLock(lockName, businessId);
        try {
            rLock.lock();
            log.info("业务ID{}，获取锁成功", businessId);
            handle.execute();
        } finally {
            rLock.unlock();
        }
    }

    /**
     * 带返回值分布式锁实现
     * @param lockName 锁名称
     * @param businessId 业务ID
     * @param handle 业务处理
     * @param <T> 返回值
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public <T> T lock(String lockName, Object businessId, ReturnHandle<T> handle) {
        RLock rLock = getLock(lockName, businessId);
        try {
            rLock.lock();
            log.info("业务ID{}，获取锁成功", businessId);
            return handle.execute();
        } finally {
            rLock.unlock();
        }
    }

    /**
     * 分布式锁实现
     * @param lockName 锁名称
     * @param businessId 业务ID
     * @param handle 业务处理
     */
    @Transactional(rollbackFor = Exception.class)
    public void tryLock(String lockName, Object businessId, VoidHandle handle) {
        RLock rLock = getLock(lockName, businessId);
        if (!rLock.tryLock()) {
            log.info("业务ID{}，获取锁失败，返回", businessId);
            return;
        }

        try {
            log.info("业务ID{}，获取锁成功", businessId);
            handle.execute();
        } finally {
            rLock.unlock();
        }
    }

    /**
     * 带返回值分布式锁实现
     * @param lockName 锁名称
     * @param businessId 业务ID
     * @param handle 业务处理
     * @param <T> 返回值
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public <T> T tryLock(String lockName, Object businessId, ReturnHandle<T> handle) {
        RLock rLock = getLock(lockName, businessId);
        if (!rLock.tryLock()) {
            log.info("业务ID{}，获取锁失败，返回null", businessId);
            return null;
        }

        try {
            log.info("业务ID{}，获取锁成功", businessId);
            return handle.execute();
        } finally {
            rLock.unlock();
        }
    }

    /**
     * 分布式锁实现
     * @param lockName 锁名称
     * @param businessId 业务ID
     * @param handle 业务处理
     */
    @Transactional(rollbackFor = Exception.class)
    public void tryLockException(String lockName, Object businessId, VoidHandle handle) {
        RLock rLock = getLock(lockName, businessId);
        if (!rLock.tryLock()) {
            log.info("业务ID{}，获取锁失败，抛异常处理", businessId);
            throw new RuntimeException("处理中");
        }

        try {
            log.info("业务ID{}，获取锁成功", businessId);
            handle.execute();
        } finally {
            rLock.unlock();
        }
    }

    /**
     * 带返回值分布式锁实现
     * @param lockName 锁名称
     * @param businessId 业务ID
     * @param handle 业务处理
     * @param <T> 返回值
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public <T> T tryLockException(String lockName, Object businessId, ReturnHandle<T> handle) {
        RLock rLock = getLock(lockName, businessId);
        if (!rLock.tryLock()) {
            log.info("业务ID{}，获取锁失败，抛异常处理", businessId);
            throw new RuntimeException("处理中");
        }

        try {
            log.info("业务ID{}，获取锁成功", businessId);
            return handle.execute();
        } finally {
            rLock.unlock();
        }
    }

    /**
     * 获取锁
     * @param lockName
     * @param businessId
     * @return
     */
    private RLock getLock(String lockName, Object businessId) {
        log.info("获取分布式锁lockName:{},businessId:{}", lockName, businessId);
        if (StringUtils.isEmpty(lockName)) {
            throw new RuntimeException("分布式锁KEY为空");
        }
        if (StringUtils.isEmpty(businessId)) {
            throw new RuntimeException("业务ID为空");
        }

        String lockKey = lockName + businessId.toString();
        return redissonClient.getLock(lockKey);
    }

}
使用例子
@Autowired
private RedisLock redisLock;

@Test
public void test() {
    redisLock.tryLock("order:pay:", 1, () -> {
        // 业务逻辑
    });

    Boolean payResult = redisLock.tryLock("order:pay:", 2, () -> {
        // 业务逻辑
        return true;
    });

    Integer payResult2 = redisLock.tryLock("order:pay:", 2, () -> {
        // 业务逻辑
        return 0;
    });

    String payResult3 = redisLock.tryLock("order:pay:", 2, () -> {
        // 业务逻辑
        return "";
    });
}

测试方法没有粘类，不过已经可以看出用起来还是超方便的。

原文地址：https://www.cnblogs.com/yuanjiangnan/p/12670430.html

时间： 2024-11-05 20:32:33

Redisson 分布式锁超简封装的相关文章

SpringBoot集成redisson分布式锁

官方文档:https://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95 1.引用redisson的pom <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.5.0</version> </dependency> 2.定义Lo

springboot整合redisson分布式锁

一.通过maven引入redisson的jar包 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.6.5</version> </dependency> 二.在yaml文件中引入redis的相关配置(redis单节点可以读取原有redis配置拼装,如果是主从需另外独立配置,相关属性

Java使用Redisson分布式锁实现原理

本篇文章摘自:https://www.jb51.net/article/149353.htm 由于时间有限,暂未验证 仅先做记录.有大家注意下哈(会尽快抽时间进行验证) 1. 基本用法 添加依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.8.2</version> </depend

[转帖]SpringBoot集成redisson分布式锁

https://www.cnblogs.com/yangzhilong/p/7605807.html 前几天同事刚让增加上这一块东西. 百度查一下 啥意思.. 学习一下. 官方文档:https://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95 20180226更新:增加tryLock方法,建议后面去掉DistributedLocker接口和其实现类,直接在RedissLockUtil中注入RedissonClient实现类(简单但会丢失

redisson实现分布式锁原理

Redisson分布式锁 之前的基于注解的锁有一种锁是基本redis的分布式锁,锁的实现我是基于redisson组件提供的RLock,这篇来看看redisson是如何实现锁的. 不同版本实现锁的机制并不相同 引用的redisson最近发布的版本3.2.3,不同的版本可能实现锁的机制并不相同,早期版本好像是采用简单的setnx,getset等常规命令来配置完成,而后期由于redis支持了脚本Lua变更了实现原理. <dependency> <groupId>org.redisson&

Redisson实现分布式锁—RedissonLock

Redisson实现分布式锁-RedissonLock 有关Redisson实现分布式锁上一篇博客讲了分布式的锁原理:Redisson实现分布式锁---原理 这篇主要讲RedissonLock和RLock.Redisson分布式锁的实现是基于RLock接口,RedissonLock实现RLock接口. 一.RLock接口 1.概念 public interface RLock extends Lock, RExpirable, RLockAsync 很明显RLock是继承Lock锁,所以他有Lo

Redisson获取分布式锁

1. maven <!-- redisson 分布式锁 --> <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.11.2</version> </dependency> 2. redisson客户端配置类 package com.harara.redis; import

不为人所知的分布式锁实现全都在这里了！

1.引入业务场景 首先来由一个场景引入: 最近老板接了一个大单子,允许在某终端设备安装我们的APP,终端设备厂商日活起码得几十万到百万级别,这个APP也是近期产品根据市场竞品分析设计出来的,几个小码农通宵达旦开发出来的,主要功能是在线购物一站式服务,后台可以给各个商家分配权限,来维护需要售卖的商品信息. 老板大O:谈下来不容易,接下来就是考虑如何吸引终端设备上更多的用户注册上来,如何引导用户购买,这块就交给小P去负责了,需求尽快做,我明天出差! 产品小P:嘿嘿~,眼珠一转儿,很容易就想到了,心里

整理分布式锁：业务场景&amp;分布式锁家族&amp;实现原理

1.引入业务场景 业务场景一出现: 因为小T刚接手项目,正在吭哧吭哧对熟悉着代码.部署架构.在看代码过程中发现,下单这块代码可能会出现问题,这可是分布式部署的,如果多个用户同时购买同一个商品,就可能导致商品出现 库存超卖 (数据不一致) 现象,对于这种情况代码中并没有做任何控制. 原来一问才知道,以前他们都是售卖的虚拟商品,没啥库存一说,所以当时没有考虑那么多... 这次不一样啊,这次是售卖的实体商品,那就有库存这么一说了,起码要保证不能超过库存设定的数量吧. 小T大眼对着屏幕,屏住呼吸,还好提