Redission集成

引入redission包

    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson</artifactId>
        <version>3.11.3</version>
    </dependency>

配置redission 客户端

@Bean("redissonClient")
public RedissonClient redissonClient() {
	Config config = new Config();
	String host = hostName;
	int port = this.port;
	SingleServerConfig serverConfig = config.useSingleServer().setAddress("redis://" + host + ":" + port)
		.setTimeout(this.timeout)
		.setDatabase(this.database)
		.setPassword(this.password);
	return Redisson.create(config);
}

定义redission接口

package com.peppa.agent.domain.service.common;

import org.redisson.api.RLock;

import java.util.concurrent.TimeUnit;

/**

• Redisson Lock

• @author herongyun

• @create 2021-03-04 上午10:28
  **/
  public interface RedissonLocker {

  /**

  • 可重入锁
  • 自己设置超时时间
  • @param lockKey 锁的key
  • @param timeUnit 锁时间单位
  • @param timeout 超时时间

  **/
  RLock lock(String lockKey, TimeUnit timeUnit, int timeout);

  /**

  • 尝试加锁，最多等待waitTime，上锁以后leaseTime自动解锁
  • @param lockKey 锁key
  • @param unit 锁时间单位
  • @param waitTime 等到最大时间，强制获取锁
  • @param leaseTime 锁失效时间
  • @return 如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false
    */
    boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime);

  /**

  • 尝试加锁，最多等待waitTime，上锁以后leaseTime自动解锁
  • @param lockKey 锁key
  • @param unit 锁时间单位
  • @param waitTime 等到最大时间，强制获取锁
  • @param leaseTime 锁失效时间
  • @return 如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false
    */
    boolean fairLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime);

  /**

  • 释放锁
  • @param lockKey 锁key
    */
    void unlock(String lockKey);

  /**

  • 释放锁
    */
    void unlock(RLock lock);
    }

实现redission接口

package com.peppa.agent.domain.service.common.impl;

import com.peppa.agent.domain.service.common.RedissonLocker;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

/**

• redisson lock

• @author herongyun

• @create 2021-03-02 上午9:38
  **/
  @Slf4j
  @Service
  public class RedissonLockerImpl implements RedissonLocker {

  private RedissonClient redissonClient;

  @Autowired
  public RedissonLockerImpl(RedissonClient redissonClient) {
  this.redissonClient = redissonClient;
  }

  @Override
  public RLock lock(String lockKey, TimeUnit timeUnit, int timeout) {
  RLock lock = redissonClient.getLock(lockKey);
  lock.lock(timeout, timeUnit);
  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) {
  log.warn(“获取锁tryLock失败，key:{}”,lockKey);
  }
  return false;
  }

  @Override
  public boolean fairLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
  RLock fairLock = redissonClient.getFairLock(lockKey);
  try {
  return fairLock.tryLock(waitTime, leaseTime, unit);
  } catch (InterruptedException e) {
  log.warn(“获取公平锁fairLock失败，key:{}”,lockKey);
  }
  return false;
  }

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

  @Override
  public void unlock(RLock lock) {
  lock.unlock();
  }

}