redis锁-注解版

Redis实现分布式锁利用 SETNX 和 SETEX
基本命令主要有：
SETNX(SET If Not Exists)：
当且仅当 Key 不存在时，则可以设置，否则不做任何动作。
当且仅当 key 不存在，将 key 的值设为 value ，并返回1；若给定的 key 已经存在，则 SETNX 不做任何动作，并返回0。
SETEX：
基于SETNX功能外,还可以设置超时时间，防止死锁。
项目图
代码实现
application.yml

# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=192.168.196.129
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=20
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=10
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=1000

RedisLock

/**
* @author lihaozhen
* 互斥性,安全性,可用性,对称性
*/
@Component
@Slf4j
public class RedisLock {

@Autowired
private StringRedisTemplate redisTemplate;
//设置锁的过期时间
private static final long exprise = 5000L;

/**
* @Description 加锁
*/
public boolean lock(String remark, String key, long exprise) {
if (redisTemplate.opsForValue().setIfAbsent(key, "lock", exprise, TimeUnit.MILLISECONDS)) {
log.info("loger加锁:" + remark + "-" + key);
//            System.out.println("loger加锁:" + remark + "-" + key);
return true;
}
log.error("加锁失败！");
return false;
}

/**
* @Description 释放锁
*/
public void unlock(String remark, String key) {
redisTemplate.delete(key);
System.out.println("logger释放锁了:" + remark + ":" + key);
}
}

RedisLockAnn

import java.lang.annotation.*;

/**
* @author lihaozhen
*/
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface RedisLockAnn {
String menthodName() default "";
long  expireTime() default 5000L;
}

RedisLockAspect

/**
* @author lihaozhen
* @title: RedisLockAspect
*/
@Aspect
@Component
@Slf4j
public class RedisLockAspect {

@Autowired(required = false)
private HttpServletRequest request;

@Autowired
RedisLock redisLock;

Logger logger;

@Pointcut("@annotation(com.example.demo.lock.RedisLockAnn)")
public void redisLockAnnotation() {
}

@Around(value = "redisLockAnnotation()")
public Object methodsAnnotationWithRedisLock(final ProceedingJoinPoint joinPoint) throws Throwable {
Object re = null;
MethodSignature sign = (MethodSignature) joinPoint.getSignature();
Method method = sign.getMethod();
String key = method.getName();
long expireTime = method.getAnnotation(RedisLockAnn.class).expireTime();
if (!"".equals(method.getAnnotation(RedisLockAnn.class).menthodName())) {
key = method.getAnnotation(RedisLockAnn.class).menthodName();
}
try {
if (redisLock.lock("", key, expireTime)) {
re = joinPoint.proceed();
redisLock.unlock("", key);
}
} catch (Exception e) {
logger.error("redis锁:"+e.getMessage());
}finally {
redisLock.unlock("", key);
}
return re;
}
}

RedisUtil

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Component;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
* @Author: 李大本事
* @Date: 2020/6/5 17:09
*/
@Slf4j
@Component
public class RedisUtil {

private StringRedisTemplate redisTemplate;

@Autowired
public RedisUtil(StringRedisTemplate redisTemplate) {
this.redisTemplate = redisTemplate;
}

// 通用操作

/**
* 为给定[key]设置生存时间, 当[key]过期时(生存时间为0), 它会被自动删除
*
* @param key      键
* @param timeout  失效时间
* @param timeUnit 时间粒度
* @return 设置成功为true
*/
public Boolean setExpire(String key, long timeout, TimeUnit timeUnit) {
try {
redisTemplate.expire(key, timeout, timeUnit);
return Boolean.TRUE;
} catch (Exception e) {
log.error("class {RedisUtil} method {setExpire} with parameter {key={},timeout={},timeUnit={}} has error {}", key, timeout, timeUnit, e);
}
return null;
}

/**
* 删除[key]的值
*
* @param key 键
* @return 删除成功为true, 失败为false
*/
public Boolean remove(String key) {
try {
return redisTemplate.delete(key);
} catch (Exception e) {
log.error("class {RedisUtil} method {remove} with parameter {key={}} has error {}", key, e);
}
return null;
}

// String相关操作

/**
* 将字符串[value]关联到[key]
*
* @param key   键
* @param value 值
* @return 赋值成功为true
*/
public Boolean set(String key, String value) {
try {
redisTemplate.opsForValue().set(key, value);
return Boolean.TRUE;
} catch (Exception e) {
log.error("class {RedisUtil} method {set} with parameter {key={},value={}} has error {}", key, value, e);
}
return null;
}

/**
* 将字符串[value]关联到[key], 并设置TTL
*
* @param key      键
* @param value    值
* @param timeout  失效时间
* @param timeUnit 时间粒度
* @return 赋值成功为true
*/
public Boolean set(String key, String value, long timeout, TimeUnit timeUnit) {
try {
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
return Boolean.TRUE;
} catch (Exception e) {
log.error("class {RedisUtil} method {set} with parameter {key={},value={},timeout={},timeUnit={}} has error {}", key, value, timeout, timeUnit, e);
}
return null;
}

/**
* 在键[key]不存在的情况下, 将键[key]的值设置为[value]
*
* @param key   键
* @param value 值
* @return 赋值成功为true, 失败为false
*/
public Boolean setIfNotExist(String key, String value) {
try {
return redisTemplate.opsForValue().setIfAbsent(key, value);
} catch (Exception e) {
log.error("class {RedisUtil} method {setIfNotExist} with parameter {key={},value={}} has error {}", key, value, e);
}
return null;
}

/**
* 在键[key]不存在的情况下, 将键[key]的值设置为[value], 并设置TTL
*
* @param key      键
* @param value    值
* @param timeout  失效时间
* @param timeUnit 时间粒度
* @return 赋值成功为true, 失败为false
*/
public Boolean setIfNotExist(String key, String value, long timeout, TimeUnit timeUnit) {
try {
return redisTemplate.opsForValue().setIfAbsent(key, value, timeout, timeUnit);
} catch (Exception e) {
log.error("class {RedisUtil} method {setIfNotExist} with parameter {key={},value={},timeout={},timeUnit={}} has error {}", key, value, timeout, timeUnit, e);
}
return null;
}

/**
* 键值自增
*
* @param key 键的名称
* @return 自增后的值
*/
public Long increment(String key) {
Long length = -1L;
try {
length = redisTemplate.opsForValue().increment(key);
redisTemplate.expire(key, 3, TimeUnit.DAYS);
} catch (Exception e) {
log.error("class {RedisUtil} method {increment} has error ", e);
}
return length;
}

/**
* 返回与键[key]相关联的字符串值
*
* @param key 键
* @return 返回key的值
*/
public String get(String key) {
try {
return redisTemplate.opsForValue().get(key);
} catch (Exception e) {
log.error("class {RedisUtil} method {set} with parameter {key={}} has error {}", key, e);
}
return null;
}

// Hash相关操作

/**
* 将哈希表[key]中域[field]的值设置为[value]
*
* @param key   键
* @param field 域
* @param value 值
* @return 赋值成功为true
*/
public Boolean setHash(String key, Object field, Object value) {
try {
redisTemplate.setHashValueSerializer(RedisSerializer.json());
redisTemplate.opsForHash().put(key, field, value);
return Boolean.TRUE;
} catch (Exception e) {
log.error("class {RedisUtil} method {setHash} with parameter {key={},field={},value={}} has error {}", key, field, value, e);
}
return null;
}

/**
* 将哈希表[key]中域[field]的值设置为[value], 并设置TTL
*
* @param key      键
* @param field    域
* @param value    值
* @param timeout  失效时间
* @param timeUnit 时间粒度
* @return 赋值成功为true
*/
public Boolean setHash(String key, Object field, Object value, long timeout, TimeUnit timeUnit) {
try {
redisTemplate.opsForHash().put(key, field, value);
setExpire(key, timeout, timeUnit);
return Boolean.TRUE;
} catch (Exception e) {
log.error("class {RedisUtil} method {setHash} with parameter {key={},field={},value={},timeout={},timeUnit={}} has error {}", key, field, value, timeout, timeUnit, e);
}
return null;
}

/**
* 当且仅当域[field]尚未存在于哈希表[key]的情况下, 将它的值设置为[value]
*
* @param key   键
* @param field 值
* @param value 域
* @return 赋值成功为true, 失败为false
*/
public Boolean setHashIfNotExist(String key, Object field, Object value) {
try {
return redisTemplate.opsForHash().putIfAbsent(key, field, value);
} catch (Exception e) {
log.error("class {RedisUtil} method {setHashIfNotExist} with parameter {key={},field={},value={}} has error {}", key, field, value, e);
}
return null;
}

/**
* 当且仅当域[field]尚未存在于哈希表[key]的情况下, 将它的值设置为[value], 并设置TTL
*
* @param key      键
* @param field    值
* @param value    域
* @param timeout  失效时间
* @param timeUnit 时间粒度
* @return 赋值成功为true, 失败为false
*/
public Boolean setHashIfNotExist(String key, Object field, Object value, long timeout, TimeUnit timeUnit) {
try {
setExpire(key, timeout, timeUnit);
return redisTemplate.opsForHash().putIfAbsent(key, field, value) && Boolean.TRUE;
} catch (Exception e) {
log.error("class {RedisUtil} method {setHashIfNotExist} with parameter {key={},field={},value={},timeout={},timeUnit={}} has error {}", key, field, value, timeout, timeUnit, e);
}
return null;
}

/**
* 同时将[map]中多个field-value(域-值)对设置到哈希表[key]中
*
* @param key 键
* @param map 域值对
* @return 赋值成功为true
*/
public Boolean setHashMap(String key, Map<Object, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return Boolean.TRUE;
} catch (Exception e) {
log.error("class {RedisUtil} method {setHashMap} with parameter {key={},map={}} has error {}", key, map, e);
}
return null;
}

/**
* 同时将[map]中多个field-value(域-值)对设置到哈希表[key]中, 并设置TTL, 时间粒度为 秒
*
* @param key 键
* @param map 域值对
* @return 赋值成功为true
*/
public Boolean setHashMap(String key, Map<Object, Object> map, long timeout) {
return setHashMap(key, map, timeout, TimeUnit.SECONDS);
}

/**
* 同时将[map]中多个field-value(域-值)对设置到哈希表[key]中, 并设置TTL
*
* @param key 键
* @param map 域值对
* @return 赋值成功为true
*/
public Boolean setHashMap(String key, Map<Object, Object> map, long timeout, TimeUnit timeUnit) {
try {
redisTemplate.setHashValueSerializer(RedisSerializer.json());
redisTemplate.opsForHash().putAll(key, map);
setExpire(key, timeout, timeUnit);
return Boolean.TRUE;
} catch (Exception e) {
log.error("class {RedisUtil} method {setHashMap} with parameter {key={},map={},timeout={},timeUnit={}} has error {}", key, map, timeout, timeUnit, e);
}
return null;
}

/**
* 返回哈希表[key]中给定域[field]的值
*
* @param key   键
* @param field 域
* @return 指定域的值
*/
public Object getHash(String key, Object field) {
try {
redisTemplate.setHashValueSerializer(RedisSerializer.json());
return redisTemplate.opsForHash().get(key, field);
} catch (Exception e) {
log.error("class {RedisUtil} method {getHash} with parameter {key={},field={}} has error {}", key, field, e);
}
return null;
}

/**
* 返回哈希表[key]中, 一个或多个给定域的值
*
* @param key 键
* @return 域值对
*/
public Map<Object, Object> getHashMap(String key) {
try {
redisTemplate.setHashValueSerializer(RedisSerializer.json());
return redisTemplate.opsForHash().entries(key);
} catch (Exception e) {
log.error("class {RedisUtil} method {getHash} with parameter {key={}} has error {}", key, e);
}
return null;
}

/**
* 批量获取keyList中的所有key的值
*
* @param keyList key值集合
* @return key值集合中所有值的集合
*/
public List<Object> getHashAll(List<String> keyList) {
try {
return redisTemplate.executePipelined((RedisCallback<LinkedHashMap<Object, Object>>) connection -> {
connection.openPipeline();
for (String key : keyList) {
byte[] keyByte = key.getBytes();
connection.hGetAll(keyByte);
}
return null;
});
} catch (Exception e) {
log.error("class {RedisUtil} method {getAll} with parameter {keyList={}} has error {}", keyList, e);
}
return null;
}

// List相关操作

/**
* 将[value]插入到列表[key]的表头(最左边)
*
* @param key   列表的名称
* @param value 值
* @return 表的长度
*/
public Long leftPush(String key, String value) {
try {
redisTemplate.setHashValueSerializer(RedisSerializer.json());
return redisTemplate.opsForList().leftPush(key, value);
} catch (Exception e) {
e.printStackTrace();
log.error("class {RedisUtil} method {leftPush} with parameter {key={},value={}} has error {}", key, value, e);
}
return null;
}

public Long removeValueOfList(String key, String value) {
try {
return redisTemplate.opsForList().remove(key, 0, value);
} catch (Exception e) {
e.printStackTrace();
log.error("class {RedisUtil} method {leftPush} with parameter {key={},value={}} has error {}", key, value, e);
}
return null;
}

/**
* 将[value]插入到列表[key]的表尾(最右边)
*
* @param key   列表的名称
* @param value 值
* @return 表的长度
*/
public Long rightPush(String key, String value) {
try {
return redisTemplate.opsForList().rightPush(key, value);
} catch (Exception e) {
log.error("class {RedisUtil} method {rightPush} with parameter {key={},value={}} has error {}", key, value, e);
}
return null;
}

/**
* 移除并返回列表[key]的头元素
*
* @param key 列表的名称
* @return 列表的头元素
*/
public String leftPop(String key) {
try {
return redisTemplate.opsForList().leftPop(key);
} catch (Exception e) {
log.error("class {RedisUtil} method {leftPop} with parameter {key={}} has error {}", key, e);
}
return null;
}

/**
* 移除并返回列表key的尾元素
*
* @param key 列表的名称
* @return 列表的尾元素
*/
public String rightPop(String key) {
try {
return redisTemplate.opsForList().rightPop(key);
} catch (Exception e) {
log.error("class {RedisUtil} method {rightPop} with parameter {key={}} has error {}", key, e);
}
return null;
}

/**
* 获取列表key的长度
*
* @param key 列表的名称
* @return 列表的长度
*/
public Long getListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
log.error("class {RedisUtil} method {getListSize} with parameter {key={}} has error {}", key, e);
}
return null;
}

public List<String> getAllList(String key) {
try {
Long end = redisTemplate.opsForList().size(key);
return redisTemplate.opsForList().range(key, 0, end);
} catch (Exception e) {
log.error("class {RedisUtil} method {getListSize} with parameter {key={}} has error {}", key, e);
}
return null;
}

public Long removeHashKey(String Key, String field) {
try {
return redisTemplate.opsForHash().delete(Key, field);

} catch (Exception e) {

log.error("class {RedisUtil} method {removeHashKey} with parameter {key={}} has error {}", Key, field, e);
}
return null;
}

public List<String> getListByCount(String key, Long size) {
try {
if (size > 0) {
--size;
}
return redisTemplate.opsForList().range(key, 0, size);
} catch (Exception e) {
log.error("class {RedisUtil} method {getListSize} with parameter {key={}} has error {}", key, e);
}
return null;

}
}

测试效果如下图