分布式锁springboot

工具类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.support.atomic.RedisAtomicLong;
import org.springframework.stereotype.Component;

import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * redis锁常用工具类
 *
 * @author l3667
 */
@Component
public class HC
@Component
public class HXXRedisTemplate {

    private final Logger logger = LoggerFactory.getLogger(HCRedisTemplate.class);

    @Autowired
    private RedisConnectionFactory redisConnectionFactory;

    @Autowired
    private RedisTemplate redisTemplate;

    private StringRedisTemplate jdkRedisTemplate;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public synchronized StringRedisTemplate getJdkRedisTemplate() {

        if (ObjectUtil.isNotEmpty(jdkRedisTemplate)) {
            return jdkRedisTemplate;
        }

        jdkRedisTemplate = new StringRedisTemplate(redisConnectionFactory);
        jdkRedisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());

        return jdkRedisTemplate;
    }

    /**
     * 获取缓存
     *
     * @param <T> the type parameter
     * @param key 键
     * @return 值 object，不存在则返回 null
     */
    public <T> T get(String key) {

        if (Objects.isNull(key)) {
            return null;
        }

        Object object = redisTemplate.opsForValue().get(key);

        if (Objects.isNull(object)) {
            return null;
        }
        return (T) object;
    }

    /**
     * 获取缓存 --stringRedisTemplate
     *
     * @param <T> the type parameter
     * @param key 键
     * @return 值 object，不存在则返回 null
     */
    public <T> T stringGet(String key) {

        if (Objects.isNull(key)) {
            return null;
        }

        Object object = stringRedisTemplate.opsForValue().get(key);

        if (Objects.isNull(object)) {
            return null;
        }
        return (T) object;
    }

    /**
     * 设置缓存
     *
     * @param <T>   the type parameter
     * @param key   键
     * @param value the value
     * @return true|false
     */
    public <T> boolean set(String key, T value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            logger.error("设置缓存异常,异常原因{}", e.getMessage());
            return false;
        }
    }

    /**
     * 设置带有失效时间的缓存
     *
     * @param <T>   the type parameter
     * @param key   键
     * @param value the value
     * @param time  时间(秒) 如果设置成0或负数，会默认变成-1，也就是无失效时间
     * @return the result
     */
    public <T> boolean set(String key, T value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            logger.error("设置带有失效时间的缓存异常：", e.getMessage());
            return false;
        }
    }

    /**
     * 指定对应 Key 的缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)，不要传 0 或负数，0或负数缓存将直接失效
     * @return the result
     */
    public boolean expire(String key, long time) {
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }

    /**
     * 根据 key 获取过期时间
     *
     * @param key 键
     * @return 过期时间 时间(秒)
     */
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 根据 key 设置缓存为不失效
     *
     * @param key 键
     * @return the result
     */
    public boolean persist(String key) {
        return redisTemplate.persist(key);
    }

    /**
     * 判断 key 是否存在
     *
     * @param key 键
     * @return the result
     */
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 删除缓存
     *
     * @param key 键
     * @return the result
     */
    public boolean delete(String key) {
        return redisTemplate.delete(key);
    }


    /**
     * 生成全局唯一自增主键ID
     *
     * @param key
     * @return
     */
    public Long getUniqueId(String key) {

        RedisAtomicLong redisAtomicLong = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
        return redisAtomicLong.incrementAndGet();
    }


    /**
     * 尝试获取锁
     *
     * @param key     加锁唯一标识
     * @param value   释放锁唯一标识（建议使用线程ID作为value）
     * @param timeout 超时时间（单位：S）
     * @return [true: 加锁成功; false: 加锁失败]
     */
    public boolean tryLock(String key, String value, Integer timeout) {
        Boolean result = redisTemplate.opsForValue().setIfAbsent(key, value, timeout, TimeUnit.SECONDS);
        return result != null && result;
    }

    /**
     * 释放锁
     *
     * @param key   加锁唯一标识
     * @param value 释放锁唯一标识（建议使用线程ID作为value）
     */
    public void unLock(String key, String value) {
        // ----- 通过value判断是否是该锁：是则释放；不是则不释放，避免误删
        if (value.equals(redisTemplate.opsForValue().get(key))) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 设置缓存
     *
     * @param <T>   the type parameter
     * @param key   键
     * @param value the value
     * @return true|false
     */
    public <T> boolean stringSet(String key, String value) {
        try {
            stringRedisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            logger.error("设置缓存异常,异常原因{}", e);
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 键
     * @return the result
     */
    public boolean stringDelete(String key) {
        return stringRedisTemplate.delete(key);
    }

}

实现 

    @Autowired
    private HXXRedisTemplate xxRedisTemplate;




调用
  Boolean b = xxRedisTemplate.tryLock(lockey, "ok", 3);

if(b){
//执行逻辑
}
else{
//未取得锁.....
}