<dependency>
      <groupid>redis.clients</groupid>
      <artifactid>jedis</artifactid>
      <version>3.3.0</version>
    </dependency>

spring:
  redis:
    host: localhost
    port: 6379
    password: root
    timeout: 5000
    # redis数据库索引(默认为0）
    database: 0
    # 连接池最大连接数(使用负值表示没有限制)
    jedis:
      pool:
      # 连接池最大连接数(使用负值表示没有限制)
      max-active: 8
      # 连接池最大阻塞等待时间(使用负值表示没有限制)
      max-wait: -1
      # 连接池中的最大空闲连接
      max-idle: 8
      # 连接池中的最小空闲连接
      min-idle: 0
      # 获取连接时检测是否可用
      testonborrow: true

import lombok.extern.slf4j.slf4j;
import org.apache.commons.lang3.stringutils;
import org.springframework.beans.factory.annotation.value;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import redis.clients.jedis.jedispool;
import redis.clients.jedis.jedispoolconfig;
 
/**
 * jedis配置项
 * @autho connorsong
 * @date 2021/1/21 9:55 上午
 */
@configuration
@slf4j
public class jedispoolcinfigration {
 
  @bean
  public jedispoolconfig jedispoolconfig(@value("${spring.redis.jedis.pool.max-active}") int maxactive,
                      @value("${spring.redis.jedis.pool.max-idle}") int maxidle,
                      @value("${spring.redis.jedis.pool.min-idle}") int minidle,
                      @value("${spring.redis.jedis.pool.max-wait}") long maxwaitmillis,
                      @value("${spring.redis.jedis.pool.testonborrow}") boolean testonborrow) {
    jedispoolconfig jedispoolconfig = new jedispoolconfig();
    jedispoolconfig.setmaxtotal(maxactive);
    jedispoolconfig.setmaxidle(maxidle);
    jedispoolconfig.setminidle(minidle);
    jedispoolconfig.setmaxwaitmillis(maxwaitmillis);
    jedispoolconfig.settestonborrow(testonborrow);
 
    return jedispoolconfig;
  }
 
  @bean
  public jedispool jedispool(@value("${spring.redis.host}") string host,
                @value("${spring.redis.password}") string password,
                @value("${spring.redis.port}") int port,
                @value("${spring.redis.timeout}") int timeout, jedispoolconfig jedispoolconfig) {
 
    log.info("=====创建jedispool连接池=====");
    if (stringutils.isnotempty(password)) {
      return new jedispool(jedispoolconfig, host, port, timeout, password);
    }
 
    return new jedispool(jedispoolconfig, host, port, timeout);
 
  }
}

import lombok.extern.slf4j.slf4j;
import redis.clients.jedis.jedis;
import redis.clients.jedis.params.setparams;
 
import java.util.collections;
 
/**
 * jedis分布式锁工具类
 * @autho connorsong
 * @date 2021/1/20 6:26 下午
 */
@slf4j
public class jedislockutils {
 
  private static final string lock_success = "ok";
 
  private static final long release_success = 1l;
  /**
   * 尝试获取分布式锁
   * @param jedis redis客户端
   * @param lockkey 锁
   * @param lockvalue value
   * @param expiretime 超期时间(秒)
   * @return 是否获取成功
   */
  public static boolean trygetlock(jedis jedis, string lockkey, string lockvalue, int expiretime) {
    log.info("----获取jedis分布式锁----lockkey:{}", lockkey);
 
    try {
      //方案一，具有原子性，并且可以设置过期时间，避免拿到锁后，业务代码出现异常，无法释放锁
      string result = jedis.set(lockkey, lockvalue, new setparams().nx().ex(expiretime));
      if (lock_success.equals(result)) {
        return true;
      }
      return false;
      //方案二，setnx()具有原子性，但是有后续判断，整体不具有原子性，不能设置过期时间
//      //setnx(lockkey, 当前时间+过期超时时间)，如果返回 1，则获取锁成功；如果返回 0 则没有获取到锁
//      string value = new date().gettime() + expiretime + "";
//      if(1 == jedis.setnx(lockkey, value)){
//        return true;
//      }else{
//        string oldexpiretime = jedis.get(lockkey);
//        if(long.valueof(oldexpiretime)< new date().gettime()){
//          //锁超时，可以获取锁重新设置锁
//          //计算 newexpiretime = 当前时间+过期超时时间，然后 getset(lockkey, newexpiretime) 会返回当前 lockkey的值currentexpiretime
//          long newexpiretime = new date().gettime() + expiretime;
//          string currentexpiretime = jedis.getset(lockkey, newexpiretime + "");
//          if(currentexpiretime.equals(oldexpiretime)){
//            return true;
//          }
//        }
//        return false;
//      }
    }finally {
      returnresource(jedis);
    }
  }
 
  /**
   * 释放分布式锁
   * @param jedis redis客户端
   * @param lockkey 锁
   * @return 是否释放成功
   */
  public static boolean closelock(jedis jedis, string lockkey, string lockvalue) {
    log.info("----释放jedis分布式锁----lockkey:{}, lockvalue:{}", lockkey, lockvalue);
    try {
      string script = "if redis.call('get', keys[1]) == argv[1] then return redis.call('del', keys[1]) else return 0 end";
      object result = jedis.eval(script, collections.singletonlist(lockkey), collections.singletonlist(lockvalue));
      if (release_success.equals(result)) {
        return true;
      }
      return false;
    }finally {
      returnresource(jedis);
    }
  }
 
  /**
   * 关闭资源
   * @param jedis
   */
  public static void returnresource(final jedis jedis){
    if(null != jedis){
      jedis.close();
    }
  }
}