自定义Starter基于Redissons实现注解版分布式锁

bigegpt 2024-11-21 10:41 4 浏览

1、遗留问题

前面的文章<<自定义Starter扩展SpringCache支持Redis过期策略>>在SpringBoot的启动程序中，过滤了RedisAutoConfiguration和RedissonAutoConfiguration。

这里将会去除该配置，在Stater中实现排除功能。

在RedisCacheConfig类上增加包扫描过滤操作

@ComponentScan(excludeFilters = 
        {
                @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, 
                                      classes = RedisAutoConfiguration.class)
        })

2、在Starter中增加注解版的分布式锁

编写思路

1、编写配置文件类(这里可以增加一个配置项即可，Redis连接列表可以通过Redis缓存配置实现通用)
2、编写自动配置类CustomRedissonAutoConfig
3、编写分布式锁注解
4、编写分布式锁注解的AOP切面实现加锁逻辑
5、编写测试方法进行多线程修改全局变量测试

2.1、编写配置文件类(沿用原来的)

# 缓存相关配置示例
itdl:
  # SpringCache重写之后的写法@Cacheable(cacheNames = "test#10", key = "'mytable'", sync = true)
  # #号后面表示过期时间，sync=true表示当多个请求同时来临时，只有一个会被处理，然后回填缓存，第二个将会从缓存获取。这个可以解决单机的缓存击穿问题。
  cache:
    # 启用本地缓存咖啡因（Caffeine）作为SpringCache缓存
    enableLocalCache: false
    # 本地缓存配置
    localConfig:
      # 过期时间，单位秒
      expire: 600
      # 初始化容量大小
      initialCapacity: 100
      # 最大容量大小，最多存储多少个key.超过之后会执行淘汰机制
      maximumSize: 10000
    # 启用Redis作为SpringCache缓存
    enableRedisCache: true
    # Redis配置
    redisConfig:
      # 是否开启Redis分布式锁，开启之后，将会使用redisHost连接Redis创建RedissonClient
      enableRedisLock: true
      # Redis地址，集群使用ip:port,ip:port使用逗号分隔
      redisHost: 162.14.74.11:7001,162.14.74.11:7002,162.14.74.11:7003,162.14.74.11:7004,162.14.74.11:7005,162.14.74.11:7006
      # Redis连接密码
      redisPassWord: abcAbc123.
      # 连接数据库，如果是集群，不需要该属性
      database: 0
      # key前缀配置 一般可以根据前缀区分页面，方便RedisKey的管理
      keyPrefix: itdl
      # jedis连接池配置
      jedisPoolConfig:
        # 最大连接数
        maxTotal: 8
        # 最大空闲数
        maxIdle: 8
        # 最小空闲数
        minIdle: 0

主要增加了itdl.cache.redisConfig.enableRedisLock=true

表示是否开启Redis分布式锁，开启之后，将会使用redisHost连接Redis创建RedissonClient

2.2、编写自动配置类CustomRedissonAutoConfig

主要是配置RedissonClient

/**
 * @author itdl
 * @version 1.0
 * @date 2022"年"09"月"25"日" 16:49
 * @description Redission自动配置类
 */
@ComponentScan(excludeFilters = {@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = RedissonAutoConfiguration.class)})
@ConditionalOnProperty(prefix = "itdl.cache.redisConfig", value = "enableRedisLock", havingValue = "true")
@Configuration
@Slf4j
public class CustomRedissonAutoConfig {
    @Resource
    private CustomCacheProperties customCacheProperties;

    /**注入Redis相关的实现*/

    @Bean("redisConnectionFactory")
    @ConditionalOnMissingBean(name = {"redisConnectionFactory"})
    public RedisConnectionFactory redisConnectionFactory() {
        return RedisUtil.getJedisConnectionFactory(customCacheProperties);
    }


    /**
     * custom RedisTemplate
     * @param redisConnectionFactory redisConnectionFactory
     * @return RedisTemplate
     */
    @Bean("redisTemplate")
    @ConditionalOnMissingBean(name = {"redisTemplate"})
    public RedisTemplate<Object, Object> redisTemplate(@Autowired RedisConnectionFactory
                                                               redisConnectionFactory) {
        return RedisUtil.getRedisTemplate(redisConnectionFactory);
    }



    @Bean("redissonClient")
    @ConditionalOnMissingBean(name = {"redissonClient"})
    public RedissonClient redissonClient(){
        final Config config = new Config();

        // redis host
        final CustomCacheProperties.RedisConfig redisConfig = customCacheProperties.getRedisConfig();

        if (StringUtils.isBlank(redisConfig.getRedisHost())){
            throw new RuntimeException("redis host is not null");
        }

        Set<String> hosts = org.springframework.util.StringUtils.commaDelimitedListToSet(redisConfig.getRedisHost());
        // 只有一个host, 表示是单机host
        if (hosts.size() == 1){
            String hostPort = hosts.stream().findFirst().get();
            String[] split = hostPort.split(":");
            if (split.length != 2){
                throw new RuntimeException("host or port err");
            }

            config.useSingleServer()
                    .setAddress("redis://" + hostPort.trim())
                    .setDatabase(redisConfig.getDatabase())
                    .setPassword(redisConfig.getRedisPassWord())
                    ;
            return Redisson.create(config);
        }

        String[] redisHosts = new String[hosts.size()];
        int i = 0;
        for (String host : hosts) {
            String[] split = host.split(":");
            if (split.length != 2){
                throw new RuntimeException("host or port err");
            }
            redisHosts[i] = "redis://" + host.trim();
            i++;
        }

        // config cluster
        config.useClusterServers()
                .addNodeAddress(redisHosts)
                .setPassword(redisConfig.getRedisPassWord())
                // 解决Not all slots covered! Only 10922 slots are available
                .setCheckSlotsCoverage(false);

        RedissonClient redissonClient = Redisson.create(config);
        log.info("=======>>>创建redisClient成功");
        return redissonClient;
    }
}

2.3、编写分布式锁注解

主要就是锁名称，锁类型，等待时间，自动释放锁时间等

/**
 * @author itdl
 * @version 1.0
 * @date 2022"年"09"月"25"日" 21:14
 * @description 分布式锁注解
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DistributionLock {

    /**分布式锁的名称，支持el表达式*/
    String lockName() default "";

    /**锁类型 默认为可重入锁*/
    LockType lockType() default REENTRANT_LOCK;

    /**获取锁等待时间，默认30秒*/
    long waitTime() default 30000L;

    /** 锁自动释放时间，默认30秒*/
    long leaseTime() default 30000L;

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

2.4、编写分布式锁注解的AOP切面实现加锁逻辑

也就是定义切入点为分布式锁的注解，切入的逻辑就是先获取锁，获取锁成功之后执行业务逻辑，最后释放锁。获取失败，则抛出获取锁异常。

/**
 * @author itdl
 * @version 1.0
 * @date 2022"年"10"月"01"日" 21:10
 * @description 分布式锁的切面逻辑实现
 */
@Aspect
@Component
@Slf4j
public class DistributionAspect {

    @Autowired(required = false)
    private RedissonClient redissonClient;

    /**
     * 切点
     */
    @Pointcut("@annotation(com.itdl.cache.lock.DistributionLock)")
    public void pointcut(){

    }

    /**
     * 环绕通知 注解针对的是方法，这里切点也获取方法进行处理就可以了
     */
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        if (redissonClient == null){
            log.warn("=========>>>redissonClient为空，没有配置分布式锁, 不需要分布式锁的不关注");
            return joinPoint.proceed();
        }

        // 获取方法
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();

        // 获取方法上的分布式锁注解
        DistributionLock distributionLock = method.getDeclaredAnnotation(DistributionLock.class);

        // 获取注解的参数
        // 锁名称
        String lockName = distributionLock.lockName();
        // 锁类型
        LockType lockType = distributionLock.lockType();

        // 获取RedissonClient的Lock
        RLock lock = getRLock(lockName, lockType);

        // 首先尝试获取锁，如果没有获取到锁，直接抛出异常
        try {
            boolean b = lock.tryLock(distributionLock.waitTime(), distributionLock.leaseTime(), distributionLock.timeUnit());
        } catch (InterruptedException e) {
            log.error("======>>>获取锁失败，原因：{}", e.getMessage());
            e.printStackTrace();
            throw new DistributionLockException(DistributionLockErrCode.WAIT_TIMEOUT);
        }

        //获取到锁后, 开始执行方法，执行完毕后释放锁
        log.debug("=========>>>获取锁成功, 即将执行业务逻辑：{}", lockName);
        try {
            Object proceed = joinPoint.proceed();
            log.debug("=========>>>获取锁成功且执行业务逻辑成功：{}", lockName);
            return proceed;
        } catch (Exception e) {
            log.error("=========>>>获取锁成功但执行业务逻辑失败：{}", lockName);
            e.printStackTrace();
            throw new DistributionLockException(DistributionLockErrCode.EXEC_BUSINESS_ERR);
        }finally {
            lock.unlock();
            log.debug("=========>>>释放锁成功：{}", lockName);
        }
    }

    /**
     * 根据锁名称和类型创建锁
     * @param lockName 锁名称
     * @param lockType 锁类型
     * @return 锁
     */
    private RLock getRLock(String lockName, LockType lockType) {
        RLock lock;
        switch (lockType){
            case FAIR_LOCK:
                lock = redissonClient.getFairLock(lockName);
                break;
            case READ_LOCK:
                lock = redissonClient.getReadWriteLock(lockName).readLock();
                break;
            case WRITE_LOCK:
                lock = redissonClient.getReadWriteLock(lockName).writeLock();
                break;
            default:
                // 默认加可重入锁，也就是普通的分布式锁
                lock = redissonClient.getLock(lockName);
                break;
        }
        return lock;
    }
}

2.5、编写测试方法进行多线程修改全局变量测试

service层实现

这里需要添加分布式锁来保证全局的线程安全问题。

其实就是修改全局变量的一个service层方法，controller层使用多线程调用。如果没有锁，将会导致线程安全问题。

/**
 * @author itdl
 * @version 1.0
 * @date 2022"年"09"月"27"日" 21:15
 * @description 一句话描述
 */
@Service
public class DemoService {

    /**定义一个静态的全局变量，并且不加锁*/
    private static Integer count = 20;

    /**
     * 使用分布式锁执行测试
     */
    @DistributionLock(lockName = "lock:test")
    public void testLock(){
        System.out.println("=========>>>线程-" + Thread.currentThread().getName() + "，数量为：" + count);
        count--;
    }

}

Controller层实现

/**
 * @author itdl
 * @version 1.0
 * @date 2022"年"09"月"27"日" 21:17
 * @description 一句话描述
 */
@RestController
@RequestMapping("/demo")
public class DemoController {

    @Autowired
    private DemoService demoService;
    
    @RequestMapping("testLock")
    public Object testLock(){

        for (int i = 0; i < 20; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    demoService.testLock();
                }
            }).start();
        }

        return "success";
    }
    
}

测试结果

=========>>>线程-Thread-58，数量为：20
=========>>>线程-Thread-68，数量为：19
=========>>>线程-Thread-66，数量为：18
=========>>>线程-Thread-63，数量为：17
=========>>>线程-Thread-61，数量为：16
=========>>>线程-Thread-64，数量为：15
=========>>>线程-Thread-59，数量为：14
=========>>>线程-Thread-67，数量为：13
=========>>>线程-Thread-69，数量为：12
=========>>>线程-Thread-56，数量为：11
=========>>>线程-Thread-65，数量为：10
=========>>>线程-Thread-72，数量为：9
=========>>>线程-Thread-70，数量为：8
=========>>>线程-Thread-71，数量为：7
=========>>>线程-Thread-62，数量为：6
=========>>>线程-Thread-55，数量为：5
=========>>>线程-Thread-73，数量为：4
=========>>>线程-Thread-57，数量为：3
=========>>>线程-Thread-74，数量为：2
=========>>>线程-Thread-60，数量为：1

3、小结

注解版本的分布式锁，其实就是简单的对Redisson进行封装而已。底层实现还是使用Redisson。这里把它放在Stater里面，并且和缓存使用同一个stater.是因为底层使用的中间件都是Redis。并且都是公共的组件。

项目中，一些公共的东西，我们最好可以封装起来，方便后面统一管理，规范化。写一些公共的东西可以让自己学会以设计的方式去处理代码，形成自己的代码风格。

学无止境，大家一起加油。

4、相关文章

本人还写了Redis缓存的其他相关文章，有兴趣的可以点击查看！

jedisconnectionfactory

上一篇：分布式锁、
下一篇：6K字详解:快速上手Spring Cache 整合 Redis 做缓存使用

自定义Starter基于Redissons实现注解版分布式锁

1、遗留问题

2、在Starter中增加注解版的分布式锁

2.1、编写配置文件类(沿用原来的)

2.2、编写自动配置类CustomRedissonAutoConfig

2.3、编写分布式锁注解

2.4、编写分布式锁注解的AOP切面实现加锁逻辑

2.5、编写测试方法进行多线程修改全局变量测试

3、小结

4、相关文章

相关推荐

idea本地配置连接远程hadoop集群的一些网络问题解决汇总

无缓存不行?例行升级的入门级阿斯加特AN2 SSD装机点评

Ceph运维手册(基于P版本)

大数据开发前要做什么准备?8台Hadoop服务器进行集群规划前配置

Tensorflow分类loss函数总结 tensorflow绘制loss曲线

R语言学习笔记(七) -离散型数据的模型预测2

iOS Runtime详解

7 个对 Java 意义重大的性能指标，你知道几个?

PHP 远程调试最佳实践

Laravel框架使用图片处理简单教程