SpringBoot配置Redisson分布式锁

Redission配置依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-redis</artifactId>
        <version>1.4.4.RELEASE</version>
      </dependency>
      <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>1.8.1.RELEASE</version>
      </dependency>
      <dependency>
		<groupId>org.redisson</groupId>
		<artifactId>redisson</artifactId>
		<version>3.5.0</version>
</dependency>

SpringBoot-Redission配置文件

package com.regs.tms.common.redis;

@Configuration
@ConfigurationProperties(prefix = "spring.redis")
@ConditionalOnProperty("spring.redis.password")
@Data
public class RedissonAutoConfiguration {

    private int timeout = 3000;
    private String address;
    private String password;
    private int database;
    private int connectionPoolSize = 64;
    private int connectionMinimumIdleSize = 10;
    private int slaveConnectionPoolSize = 250;
    private int masterConnectionPoolSize = 250;

    /**
     * 单机模式自动装配
     *
     * @return
     */
    @Bean
    @ConditionalOnProperty(name = "spring.redis.address")
    RedissonClient redissonSingle() {
        Config config = new Config();
        SingleServerConfig serverConfig = config.useSingleServer().setDatabase(database)
                .setAddress(this.getAddress())
                .setTimeout(this.getTimeout())
                .setConnectionPoolSize(this.getConnectionPoolSize())
                .setConnectionMinimumIdleSize(this.getConnectionMinimumIdleSize());
        if (StringUtils.isNotBlank(this.getPassword())) {
            serverConfig.setPassword(this.getPassword());
        }
        return Redisson.create(config);
    }

    /**
     * 装配locker类，并将实例注入到RedissLockUtil中
     *
     * @return
     */
    @Bean
    DistributedLocker distributedLocker(RedissonClient redissonClient) {
        DistributedLocker locker = new RedissonDistributedLocker();
        locker.setRedissonClient(redissonClient);
        return locker;
    }
}

自定义分布式锁方法

package com.regs.tms.common.redis;

public class RedissonDistributedLocker implements DistributedLocker {
    
    private RedissonClient redissonClient;

    @Override
    public RLock lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
        return lock;
    }

    @Override
    public RLock lock(String lockKey, TimeUnit unit ,int timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
        return lock;
    }
    
    @Override
    public 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;
        }
    }
    
    @Override
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }
    
    @Override
    public void unlock(RLock lock) {
        lock.unlock();
    }

    public void setRedissonClient(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }
}

Redission使用举例

@Scheduled(cron = "0 0/5 * * * ?")   //每5分钟执行一次
    public void finSynOrder() {
            // 1. 最常见的使用方法
            //lock.lock();
            // 2. 支持过期解锁功能,10秒钟以后自动解锁, 无需调用unlock方法手动解锁
            //lock.lock(10, TimeUnit.SECONDS);
            // 3. 尝试加锁，最多等待3秒，上锁以后10秒自动解锁
        RLock putBoxTask = redissonClient.getLock("finSynOrder");
        try {
            boolean lock = putBoxTask.tryLock(3, 10, TimeUnit.SECONDS);
            if (lock) {
                List<Integer> orderList = finPayableMapper.queryOrderList();
                logger.info("订单同步数据=========" + JSON.toJSONString(orderList));
                if (orderList != null && orderList.size() > 0) {
                    this.doOrders(orderList);
                }
                putBoxTask.unlock();
            }
        } catch (InterruptedException e) {
            putBoxTask.unlock();
            e.printStackTrace();
        }
    }

Redission理解参考地址