前言
我们平时在用微信的时候，经常会用到‘抢红包’的功能。那么这样一个需求给我们的话，具体又应该怎么实现呢？
一、需求分析
- 1、发红包：在db、cache各新增红包记录
- 2、抢红包：有人发红包之后，肯定很多人同时去抢，所以应该请求访问cache，剩余红包个数大于0就可以点击拆开红包；反之提醒红包已经被抢完了
- 3、拆红包：保证该操作是一个CAS操作，总金额的扣减和剩余红包数的扣减。
- 4、查看红包记录：用户直接查db即可。
image.png
用户在微信中抢红包时分成抢包和拆包两个操作。抢包决定红包是否还有剩余金额，但如果行动不够迅速，在拆包阶段可能红包已经被其他用户抢走的情况。
红包的金额是在什么时候算？ 据某架构群腾讯财付通专家反馈，红包的金额是拆的时候实时计算，而不是预先分配，实时计算基于内存，不需要额外存储空间，并且实时计算效率也很高。每次拆红包时，系统取0.01到剩余平均值*2之间作为红包的金额。
为了保证每次操作的原子性，拆包过程中使用了CAS，确保每次只有一个并发用户拆包成功。拆包CAS失败的用户可以由系统自动进行重试。但也有可能在重试过程中被别的用户抢得先机而空手而归，因此严格意义拆包的调用也未能保证用户先到先得。
基于上面的原因，当时在群中提到这种算法有些复杂，微信红包为了减少存储，每次进行了一个理解稍复杂的实时计算。对比大部分架构师想到的预分配金额的做法，预先分配金额需要将金额保存在一个内存队列中，如果红包的份额较多，则需要较大的存储空间。而微信红包仅保存 count:balance 这样2个数字。count指还剩几个人可以抢，balance只还剩下的金额。
但是预分配金额也并不是非得需要额外存储。比如利用随机算法，在种子相同的情况下，随机数实际上返回的随机序列也是固定的。
二、数据库表设计
- 红包信息表主要字段：谁发的红包，发红包时间，红包总个数、总金额、剩余红包信息、最后一次被抢红包时间。
CREATE TABLE `red_packet_info` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`red_packet_id` bigint(11) NOT NULL DEFAULT 0 COMMENT '红包id，采用timestamp+5位随机数',
`total_amount` int(11) NOT NULL DEFAULT 0 COMMENT '红包总金额，单位分',
`total_packet` int(11) NOT NULL DEFAULT 0 COMMENT '红包总个数',
`remaining_amount` int(11) NOT NULL DEFAULT 0 COMMENT '剩余红包金额，单位分',
`remaining_packet` int(11) NOT NULL DEFAULT 0 COMMENT '剩余红包个数',
`uid` int(20) NOT NULL DEFAULT 0 COMMENT '新建红包用户的用户标识',
`create_time` timestamp COMMENT '创建时间',
`update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='红包信息表，新建一个红包插入一条记录';
- 抢红包记录主要字段：红包信息、抢红包人信息，抢红包时间 (主要都是查看抢红包记录列表的那些字段)。
CREATE TABLE `red_packet_record` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`amount` int(11) NOT NULL DEFAULT '0' COMMENT '抢到红包的金额',
`nick_name` varchar(32) NOT NULL DEFAULT '0' COMMENT '抢到红包的用户的用户名',
`img_url` varchar(255) NOT NULL DEFAULT '0' COMMENT '抢到红包的用户的头像',
`uid` int(20) NOT NULL DEFAULT '0' COMMENT '抢到红包用户的用户标识',
`red_packet_id` bigint(11) NOT NULL DEFAULT '0' COMMENT '红包id，采用timestamp+5位随机数',
`create_time` timestamp COMMENT '创建时间',
`update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='抢红包记录表，抢一个红包插入一条记录';
三、编码实现
3.1 发红包
- 发红包之后，肯定立马会有很多人来抢，如果直接操作数据库会有很大的压力，所以我们把数据放到缓存里面去。
/**
* 发红包
* @param userId 用户id
* @param totalAmount 红包总金额
* @param totalPacket 红包总个数
* @return
*/
@PostMapping("/send")
public String sendRedPackage(String userId, Integer totalAmount, Integer totalPacket) {
// 组装数据
RedPacketInfo info = new RedPacketInfo();
info.setUserId(userId);
info.setTotalAmount(totalAmount);
info.setTotalPacket(totalPacket);
info.setRemainingAmount(totalAmount);
info.setRemainingPacket(totalPacket);
info.setCreateTime(new Date());
info.setUpdateTime(new Date());
String redPacketId = IDUtils.getUuid();
info.setRedPacketId(redPacketId);
//TODO 红包保存到数据库
//红包缓存
RedPacketBasic redPacketBasic = new RedPacketBasic();
redPacketBasic.setTotalPacket(totalPacket);
redPacketBasic.setTotalAmount(totalAmount);
// 抢红包资格缓存
redisTemplate.opsForValue().set(RedPacketUtils.GRAB_RED_PACKAGE_KEY + redPacketId, totalAmount, RedPacketUtils.RED_PACKET_EXPIRE, TimeUnit.SECONDS);
// 红包个数和总金额存入缓存
redisTemplate.opsForValue().set(RedPacketUtils.RED_PACKAGE_KEY + redPacketId, redPacketBasic, RedPacketUtils.RED_PACKET_EXPIRE, TimeUnit.SECONDS);
return "success";
}
3.2 抢红包
- 用户点击红包之后，就查看红包数量，如果为0的话，点击拆红包就提示红包被抢完了；反之获取到红包金额数量。
/**
* 抢红包，获取抢红包资格
* @param redPacketId 红包id
* @param userId 用户id
* @return
*/
@PostMapping("/rob")
public String rodRedPackage(String redPacketId, String userId) {
String grabRedPacketId = RedPackageUtils.RED_PACKAGE_CONSUME_KEY + redPacketId;
//1 验证某个用户是否抢过红包
Object redPackage = redisTemplate.opsForHash().get(grabRedPacketId, userId);
if(redPackage != null){
return "errorCode:-2, message: "+"\t"+userId+" 用户你已经抢过红包了";
}
//没有抢过就有资格，否则表示抢过
//红包的缓存key
String redPacketKey = RedPackageUtils.RED_PACKAGE_KEY + redPacketId;
RedPacketBasic redPacketBasic = (RedPacketBasic)redisTemplate.opsForValue().get(redPacketKey);
if(redPacketBasic == null || redPacketBasic.getTotalPacket() <= 0){
//抢完
return "errorCode:-1, 红包抢完了";
}
return "SUCCESS";
}
3.3 拆红包(核心)
这是重点也是难点，我们要保证领取红包的人数不能超过设置的红包个数，还要保证每一个人的红包都能抢到钱、还不能超过总金额。这就会涉及到线程安全问题。现在我们就来来想想，如何合理的生成红包随机金额数量。
- 1、剩余总金额/剩余总个数 = 红包金额平均数
- 2、由于红包是随机金额，我们的红包金额可以在这个平均值左右浮动，总和不变即可
- 这样设计，才能真正保证每个人拆开都能领到钱，而且总金额不会超支
/**
* 拆红包
* @param redPacketId 红包id
* @param userId 用户id
* @return
*/
@PostMapping("/unpack")
public Integer unpackRedPacket(String redPacketId, String userId) {
// 预减获取红包剩余数量，decr原子减来防止领取人数超过红包个数
Long decrement = redisTemplate.opsForValue().decrement(RedPacketUtils.GRAB_RED_PACKAGE_KEY + redPacketId, 1);
if(decrement == null || decrement < 0){
log.info("拆红包失败, redPacketId:{}", redPacketId);
throw new RuntimeException("红包被抢光了");
}
//拆红包
Integer redPacketAmount = redPacketUtils.unpackRedPacket(redPacketId, userId);
if(redPacketAmount == null || redPacketAmount == 0){
log.info("拆红包失败, redPacketId:{}", redPacketId);
throw new RuntimeException("红包被抢光了");
}
//TODO 后续异步进mysql或者MQ进一步处理
//TODO 插入抢红包记录, 并且扣减红包剩余金额和剩余个数
return redPacketAmount;
}
拆红包核心工具类
/**
* @author: huangyibo
* @Date: 2022/6/23 17:59
* @Description: 拆红包工具类 二倍均值法(微信红包采用此法)
* 还是以10元10个红包为例，去除每个红包的最小金额后，红包剩余9.9元，二倍均值计算公式：2 * 剩余金额/剩余红包数
* 第一个红包在[0,1.98]范围随机，假设随机得1.9，则第一个红包金额为2.0，红包剩余8元。
* 第二个红包在[0,2]范围随机，假设随机的1元，则第二个红包金额为1.1元，红包剩余7元。
* 第三个红包在[0,2]范围随机，假设随机的0.5元，则第三个红包金额为0.6元，红包剩余5.5元。
* 以此类推。
*
* 此工具类使用版本——原理
* 剩余红包金额M，剩余人数N，那么：每次抢到金额=随机(0，M/N*2)
* 保证了每次随机金额的平均值是公平的
* 假设10人，红包金额100元
* 第一人：100/10*2=20，随机范围(0,20)，平均可以抢到10元
* 第二人：90/9*2=20，随机范围(0,20)，平均可以抢到10元
* 第三人：80/8*2=20，随机范围(0,20)，平均可以抢到10元
* 以此类推，每次随机范围的均值是相等的
*
* 缺点：除了最后一次，任何一次抢到的金额都不会超过人均金额的两倍，并不是任意的随机
*/
@Component
@Slf4j
public class RedPacketUtils {
/**
* 红包的缓存key
*/
public static final String RED_PACKAGE_KEY = "RED_PACKAGE_KEY_";
/**
* 抢红包资格缓存key
*/
public static final String GRAB_RED_PACKAGE_KEY = "GRAB_RED_PACKAGE_KEY_";
/**
* 拆红包的分布式锁key
*/
public static final String UNPACK_RED_PACKAGE_KEY = "UNPACK_RED_PACKAGE_KEY_";
/**
* 抢中红包的缓存key
*/
public static final String RED_PACKAGE_CONSUME_KEY = "RED_PACKAGE_CONSUME_KEY_";
/**
* 红包缓存时效时间(没人抢、最大为一天, 红包抢完缓存主动删除)，毫秒
*/
public static final int RED_PACKET_EXPIRE = 24 * 60 * 60;
@Autowired
private RedisUtil redisUtil;
/**
* 拆红包核心接口
* @param redPacketId 红包id
* @param userId 用户id
* @return
*/
public Integer unpackRedPacket(String redPacketId, String userId) {
Integer redPacketAmount = null;
try {
boolean tryLock = redisUtil.tryLock(UNPACK_RED_PACKAGE_KEY + redPacketId);
if(!tryLock){
//分布式锁获取失败, 将抢红包资格加回去, 让其他人可以去抢
redisUtil.incr(GRAB_RED_PACKAGE_KEY + redPacketId,1);
return redPacketAmount;
}
//红包信息缓存
String redPackageKey = RED_PACKAGE_KEY + redPacketId;
//获取红包相关信息
RedPacketBasic redPacket = (RedPacketBasic) redisUtil.get(redPackageKey);
if(redPacket == null){
return redPacketAmount;
}
//红包剩下一个
if(redPacket.getTotalPacket() == 1){
redPacket.setTotalPacket(redPacket.getTotalPacket() - 1);
redPacketAmount = redPacket.getTotalAmount();
redPacket.setTotalAmount(0);
}
if(redPacket.getTotalPacket() > 1){
//红包金额以分为单位, 使用random.nextInt(Integer)，最后在再除以100
//这样就可以保证每个人抢到的金额都可以精确到小数点后两位
Integer restAmount = redPacket.getTotalAmount();
Random random = new Random();
// 随机范围：[1，剩余人均金额的两倍)，左闭右开
redPacketAmount = random.nextInt(restAmount / redPacket.getTotalPacket() * 2 - 1) + 1;
//红包数除以100
redPacket.setTotalAmount(redPacket.getTotalAmount() - redPacketAmount);
redPacket.setTotalPacket(redPacket.getTotalPacket() - 1);
}
//成功抢到红包
if(redPacketAmount != null && redPacketAmount > 0){
//加入已抢到红包的hash缓存中
redisUtil.hSet(RED_PACKAGE_CONSUME_KEY + redPacketId, userId, redPacketAmount);
// 将剩余红包个数和剩余总金额存入缓存
redisUtil.set(RedPacketUtils.RED_PACKAGE_KEY + redPacketId, redPacket, RedPacketUtils.RED_PACKET_EXPIRE);
}
//红包被抢完，清除缓存
if (redPacket.getTotalPacket() <= 0){
log.info("红包已被抢完, redPacketId:{}, redPacket:{}", redPacketId, JSON.toJSONString(redPacket));
//抢红包资格缓存key
String grabRedPackageKey = GRAB_RED_PACKAGE_KEY + redPacketId;
//抢中红包的缓存key
String redPackageConsumeKey = RED_PACKAGE_CONSUME_KEY + redPacketId;
//清楚该红包相关的缓存
redisUtil.del(redPackageKey, grabRedPackageKey, redPackageConsumeKey);
}
log.info("抢红包SUCCESS, redPacketId:{}, redPacketAmount:{}", redPacketId, redPacketAmount);
return redPacketAmount;
} catch (Exception e) {
log.error("抢红包发生异常", e);
throw e;
} finally {
redisUtil.unLock(UNPACK_RED_PACKAGE_KEY + redPacketId);
}
}
}
四、完整代码
4.1 红包缓存实体类
@Data
public class RedPacketBasic {
/**
* 红包总金额，单位分
*/
private Integer totalAmount;
/**
* 红包总个数
*/
private Integer totalPacket;
}
4.2 红包控制层
/**
* @author: huangyibo
* @Date: 2022/6/23 17:34
* @Description: 红包控制层
*/
@RestController
@RequestMapping("/redPacket")
@Slf4j
public class RedPacketController {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Autowired
private RedPacketUtils redPacketUtils;
/**
* 发红包
* @param userId 用户id
* @param totalAmount 红包总金额
* @param totalPacket 红包总个数
* @return
*/
@PostMapping("/send")
public String sendRedPackage(String userId, Integer totalAmount, Integer totalPacket) {
// 组装数据
RedPacketInfo info = new RedPacketInfo();
info.setUserId(userId);
info.setTotalAmount(totalAmount);
info.setTotalPacket(totalPacket);
info.setRemainingAmount(totalAmount);
info.setRemainingPacket(totalPacket);
info.setCreateTime(new Date());
info.setUpdateTime(new Date());
String redPacketId = IDUtils.getUuid();
info.setRedPacketId(redPacketId);
//TODO 红包保存到数据库
//红包缓存
RedPacketBasic redPacketBasic = new RedPacketBasic();
redPacketBasic.setTotalPacket(totalPacket);
redPacketBasic.setTotalAmount(totalAmount);
// 抢红包资格缓存
redisTemplate.opsForValue().set(RedPacketUtils.GRAB_RED_PACKAGE_KEY + redPacketId, totalAmount, RedPacketUtils.RED_PACKET_EXPIRE, TimeUnit.SECONDS);
// 红包个数和总金额存入缓存
redisTemplate.opsForValue().set(RedPacketUtils.RED_PACKAGE_KEY + redPacketId, redPacketBasic, RedPacketUtils.RED_PACKET_EXPIRE, TimeUnit.SECONDS);
return "success";
}
/**
* 抢红包，获取抢红包资格
* @param redPacketId 红包id
* @param userId 用户id
* @return
*/
@PostMapping("/rob")
public String rodRedPackage(String redPacketId, String userId) {
String grabRedPacketId = RedPackageUtils.RED_PACKAGE_CONSUME_KEY + redPacketId;
//1 验证某个用户是否抢过红包
Object redPackage = redisTemplate.opsForHash().get(grabRedPacketId, userId);
if(redPackage != null){
return "errorCode:-2, message: "+"\t"+userId+" 用户你已经抢过红包了";
}
//没有抢过就有资格，否则表示抢过
//红包的缓存key
String redPacketKey = RedPackageUtils.RED_PACKAGE_KEY + redPacketId;
RedPacketBasic redPacketBasic = (RedPacketBasic)redisTemplate.opsForValue().get(redPacketKey);
if(redPacketBasic == null || redPacketBasic.getTotalPacket() <= 0){
//抢完
return "errorCode:-1, 红包抢完了";
}
return "SUCCESS";
}
/**
* 拆红包
* @param redPacketId 红包id
* @param userId 用户id
* @return
*/
@PostMapping("/unpack")
public Integer unpackRedPacket(String redPacketId, String userId) {
// 预减获取红包剩余数量，decr原子减来防止领取人数超过红包个数
Long decrement = redisTemplate.opsForValue().decrement(RedPacketUtils.GRAB_RED_PACKAGE_KEY + redPacketId, 1);
if(decrement == null || decrement < 0){
log.info("拆红包失败, redPacketId:{}", redPacketId);
throw new RuntimeException("红包被抢光了");
}
//拆红包
Integer redPacketAmount = redPacketUtils.unpackRedPacket(redPacketId, userId);
if(redPacketAmount == null || redPacketAmount == 0){
log.info("拆红包失败, redPacketId:{}", redPacketId);
throw new RuntimeException("红包被抢光了");
}
//TODO 后续异步进mysql或者MQ进一步处理
//TODO 插入抢红包记录, 并且扣减红包剩余金额和剩余个数
return redPacketAmount;
}
}
4.3 拆红包工具类
/**
* @author: huangyibo
* @Date: 2022/6/23 17:59
* @Description: 拆红包工具类 二倍均值法(微信红包采用此法)
* 还是以10元10个红包为例，去除每个红包的最小金额后，红包剩余9.9元，二倍均值计算公式：2 * 剩余金额/剩余红包数
* 第一个红包在[0,1.98]范围随机，假设随机得1.9，则第一个红包金额为2.0，红包剩余8元。
* 第二个红包在[0,2]范围随机，假设随机的1元，则第二个红包金额为1.1元，红包剩余7元。
* 第三个红包在[0,2]范围随机，假设随机的0.5元，则第三个红包金额为0.6元，红包剩余5.5元。
* 以此类推。
*
* 此工具类使用版本——原理
* 剩余红包金额M，剩余人数N，那么：每次抢到金额=随机(0，M/N*2)
* 保证了每次随机金额的平均值是公平的
* 假设10人，红包金额100元
* 第一人：100/10*2=20，随机范围(0,20)，平均可以抢到10元
* 第二人：90/9*2=20，随机范围(0,20)，平均可以抢到10元
* 第三人：80/8*2=20，随机范围(0,20)，平均可以抢到10元
* 以此类推，每次随机范围的均值是相等的
*
* 缺点：除了最后一次，任何一次抢到的金额都不会超过人均金额的两倍，并不是任意的随机
*/
@Component
@Slf4j
public class RedPacketUtils {
/**
* 红包的缓存key
*/
public static final String RED_PACKAGE_KEY = "RED_PACKAGE_KEY_";
/**
* 抢红包资格缓存key
*/
public static final String GRAB_RED_PACKAGE_KEY = "GRAB_RED_PACKAGE_KEY_";
/**
* 拆红包的分布式锁key
*/
public static final String UNPACK_RED_PACKAGE_KEY = "UNPACK_RED_PACKAGE_KEY_";
/**
* 抢中红包的缓存key
*/
public static final String RED_PACKAGE_CONSUME_KEY = "RED_PACKAGE_CONSUME_KEY_";
/**
* 红包缓存时效时间(没人抢、最大为一天, 红包抢完缓存主动删除)，毫秒
*/
public static final int RED_PACKET_EXPIRE = 24 * 60 * 60;
@Autowired
private RedisUtil redisUtil;
/**
* 拆红包核心接口
* @param redPacketId 红包id
* @param userId 用户id
* @return
*/
public Integer unpackRedPacket(String redPacketId, String userId) {
Integer redPacketAmount = null;
try {
boolean tryLock = redisUtil.tryLock(UNPACK_RED_PACKAGE_KEY + redPacketId);
if(!tryLock){
//分布式锁获取失败, 将抢红包资格加回去, 让其他人可以去抢
redisUtil.incr(GRAB_RED_PACKAGE_KEY + redPacketId,1);
return redPacketAmount;
}
//红包信息缓存
String redPackageKey = RED_PACKAGE_KEY + redPacketId;
//获取红包相关信息
RedPacketBasic redPacket = (RedPacketBasic) redisUtil.get(redPackageKey);
if(redPacket == null){
return redPacketAmount;
}
//红包剩下一个
if(redPacket.getTotalPacket() == 1){
redPacket.setTotalPacket(redPacket.getTotalPacket() - 1);
redPacketAmount = redPacket.getTotalAmount();
redPacket.setTotalAmount(0);
}
if(redPacket.getTotalPacket() > 1){
//红包金额以分为单位, 使用random.nextInt(Integer)，最后在再除以100
//这样就可以保证每个人抢到的金额都可以精确到小数点后两位
Integer restAmount = redPacket.getTotalAmount();
Random random = new Random();
// 随机范围：[1，剩余人均金额的两倍)，左闭右开
redPacketAmount = random.nextInt(restAmount / redPacket.getTotalPacket() * 2 - 1) + 1;
//红包数除以100
redPacket.setTotalAmount(redPacket.getTotalAmount() - redPacketAmount);
redPacket.setTotalPacket(redPacket.getTotalPacket() - 1);
}
//成功抢到红包
if(redPacketAmount != null && redPacketAmount > 0){
//加入已抢到红包的hash缓存中
redisUtil.hSet(RED_PACKAGE_CONSUME_KEY + redPacketId, userId, redPacketAmount);
// 将剩余红包个数和剩余总金额存入缓存
redisUtil.set(RedPacketUtils.RED_PACKAGE_KEY + redPacketId, redPacket, RedPacketUtils.RED_PACKET_EXPIRE);
}
//红包被抢完，清除缓存
if (redPacket.getTotalPacket() <= 0){
log.info("红包已被抢完, redPacketId:{}, redPacket:{}", redPacketId, JSON.toJSONString(redPacket));
//抢红包资格缓存key
String grabRedPackageKey = GRAB_RED_PACKAGE_KEY + redPacketId;
//抢中红包的缓存key
String redPackageConsumeKey = RED_PACKAGE_CONSUME_KEY + redPacketId;
//清楚该红包相关的缓存
redisUtil.del(redPackageKey, grabRedPackageKey, redPackageConsumeKey);
}
log.info("抢红包SUCCESS, redPacketId:{}, redPacketAmount:{}", redPacketId, redPacketAmount);
return redPacketAmount;
} catch (Exception e) {
log.error("抢红包发生异常", e);
throw e;
} finally {
redisUtil.unLock(UNPACK_RED_PACKAGE_KEY + redPacketId);
}
}
}
4.4 Redis工具类
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisClusterConnection;
import org.springframework.data.redis.connection.RedisClusterNode;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisClusterConnection;
import org.springframework.data.redis.connection.jedis.JedisConnection;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* @author: huangyibo
* @Date: 2022/2/22 11:56
* @Description: Redis工具类
*/
@Component
@Slf4j
public class RedisUtil {
//加锁失效时间，毫秒
public static final int LOCK_EXPIRE = 3000; // ms
@Autowired
private RedisTemplate<String, Object> redisTemplate;
// =============================common============================
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @return
*/
public Boolean expire(String key, long time) {
try {
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
log.error("RedisUtils.expire 方法指定缓存失效时间异常, key:{}, time:{}", key, time, e);
return false;
}
}
/**
* 根据 key 获取过期时间
*
* @param key 键(不能为 Null)
* @return 时间(秒) 返回0代表永久有效
*/
public Long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断 key 是否存在
*
* @param key 键(不能为 Null)
* @return true 存在 false 不存在
*/
public Boolean hashKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
log.error("RedisUtils.hashKey 方法判断key是否存在异常, key:{}", key, e);
return false;
}
}
/**
* 获取前缀为prefix的key集合, 慎用此方法, 建议使用scanMatch方法替代该方法
* @param prefix
* @return
*/
public Set<String> keys(String prefix) {
Set<String> result = new HashSet<>();
try {
result = redisTemplate.keys(prefix);
} catch (Exception e) {
log.error("RedisUtils.Keys 方法获取前缀为{}的key集合存在异常", prefix, e);
}
return result;
}
/**
* 使用scan遍历key
* 为什么不使用keys 因为Keys会引发Redis锁，并且增加Redis的CPU占用,特别是数据庞大的情况下。这个命令千万别在生产环境乱用。
* 支持redis单节点和集群调用
* @param matchKey
* @return
*/
public Set<String> scanMatch(String matchKey) {
Set<String> keys = new HashSet<>();
RedisConnectionFactory connectionFactory = redisTemplate.getConnectionFactory();
RedisConnection redisConnection = connectionFactory.getConnection();
Cursor<byte[]> scan = null;
if(redisConnection instanceof JedisClusterConnection){
RedisClusterConnection clusterConnection = connectionFactory.getClusterConnection();
Iterable<RedisClusterNode> redisClusterNodes = clusterConnection.clusterGetNodes();
Iterator<RedisClusterNode> iterator = redisClusterNodes.iterator();
while (iterator.hasNext()) {
RedisClusterNode next = iterator.next();
scan = clusterConnection.scan(next, ScanOptions.scanOptions().match(matchKey).count(Integer.MAX_VALUE).build());
while (scan.hasNext()) {
keys.add(new String(scan.next()));
}
try {
if(scan !=null){
scan.close();
}
} catch (IOException e) {
log.error("scan遍历key关闭游标异常",e);
}
}
return keys;
}
if(redisConnection instanceof JedisConnection){
scan = redisConnection.scan(ScanOptions.scanOptions().match(matchKey).count(Integer.MAX_VALUE).build());
while (scan.hasNext()){
//找到一次就添加一次
keys.add(new String(scan.next()));
}
try {
if(scan !=null){
scan.close();
}
} catch (IOException e) {
log.error("scan遍历key关闭游标异常",e);
}
return keys;
}
return keys;
}
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
public void del(String... key) {
if(key != null && key.length > 0){
if(key.length == 1){
redisTemplate.delete(key[0]);
}
if(key.length > 1) {
redisTemplate.delete(Arrays.asList(key));
}
}
}
//==================================String相关操作====================================
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true 成功 false 失败
*/
public Boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
log.error("RedisUtils.set 设置普通缓存异常, key:{}, value:{}",key, JSON.toJSONString(value), e);
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time > 0 若 time <= 0 将设置无限期
* @return true 成功 false 失败
*/
public boolean set(String key, Object value, long time) {
try {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
log.error("RedisUtils.set 设置普通缓存并设置时间异常, key:{}, value:{}, time:{}",key, JSON.toJSONString(value), time, e);
return false;
}
}
/**
* 递增
*
* @param key 键
* @param delta 要增加几(大于0)
* @return
*/
public Long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @param delta 要减少几(小于0)
* @return
*/
public Long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().decrement(key, delta);
}
// ================================Map相关操作=================================
/**
* HashGet
*
* @param key 键 不能为null
* @param item 项 不能为null
*/
public Object hGet(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
public Map<Object, Object> hmGet(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
*/
public boolean hmSet(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
log.error("RedisUtils.hmSet HashSet设置缓存异常, key:{}, map:{}",key, JSON.toJSONString(map), e);
return false;
}
}
/**
* HashSet 并设置时间
*
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hmSet(String key, Map<String, Object> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
log.error("RedisUtils.hmSet HashSet设置缓存并设置时间异常, key:{}, map:{}, time:{}", key, JSON.toJSONString(map), time, e);
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hSet(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
log.error("RedisUtils.hSet hash表中设置缓存异常,key:{}, item:{}, value:{}", key, item, JSON.toJSONString(value), e);
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hSet(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
log.error("RedisUtils.hSet hash表中设置缓存异常, key:{}, item:{}, value:{}, time:{}", key, item, JSON.toJSONString(value), time, e);
return false;
}
}
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hDel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
*/
public double hIncr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
*
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
*/
public double hDecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set相关操作=============================
/**
* 根据key获取Set中的所有值
*
* @param key 键
*/
public Set<Object> sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
log.error("RedisUtils.sGet 根据key获取Set中的所有值异常, key:{}", key, e);
return new HashSet<>();
}
}
/**
* 根据value从一个set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public Boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
log.error("RedisUtils.sHasKey 方法异常, key:{}, value:{}", key, JSON.toJSONString(value), e);
return false;
}
}
/**
* 将数据放入set缓存
*
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public Long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
log.error("RedisUtils.sSet 方法异常, key:{}, values:{}", key, JSON.toJSONString(values), e);
return 0L;
}
}
/**
* 将set数据放入缓存
*
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public Long sSetAndTime(String key, long time, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > 0) {
expire(key, time);
}
return count;
} catch (Exception e) {
log.error("RedisUtils.sSetAndTime 方法异常, key:{}, time:{}, values:{}", key, time, JSON.toJSONString(values), e);
return 0L;
}
}
/**
* 获取set缓存的长度
*
* @param key 键
*/
public Long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
log.error("RedisUtils.sGetSetSize 方法异常, key:{}", key, e);
return 0L;
}
}
/**
* 移除值为value的
*
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public Long setRemove(String key, Object... values) {
try {
return redisTemplate.opsForSet().remove(key, values);
} catch (Exception e) {
log.error("RedisUtils.setRemove 方法异常, key:{}, values:{}", key, JSON.toJSONString(values), e);
return 0L;
}
}
// ===============================list相关操作=================================
/**
* 获取list缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
*/
public List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
log.error("RedisUtils.lGet 方法异常, key:{}, start:{}, end:{}", key, start, end, e);
return new ArrayList<>();
}
}
/**
* 获取list缓存的长度
*
* @param key 键
*/
public Long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
log.error("RedisUtils.lGetListSize 方法异常, key:{}", key, e);
return 0L;
}
}
/**
* 通过索引 获取list中的值
*
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
log.error("RedisUtils.lGetIndex 方法异常, key:{}, index:{}", key, index, e);
return null;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
log.error("RedisUtils.lSet 方法异常, key:{}, value:{}", key, JSON.toJSONString(value), e);
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
*/
public boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
log.error("RedisUtils.lSet 方法异常, key:{}, value:{}, time:{}", key, JSON.toJSONString(value), time, e);
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
log.error("RedisUtils.lSet 方法异常, key:{}, value:{}", key, JSON.toJSONString(value), e);
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
log.error("RedisUtils.lSet 方法异常, key:{}, value:{}, time:{}", key, JSON.toJSONString(value), time, e);
return false;
}
}
/**
* 根据索引修改list中的某条数据
*
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
log.error("RedisUtils.lUpdateIndex 方法异常, key:{}, index:{}, value:{}", key, index, JSON.toJSONString(value), e);
return false;
}
}
/**
* 移除N个值为value
*
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public Long lRemove(String key, long count, Object value) {
try {
return redisTemplate.opsForList().remove(key, count, value);
} catch (Exception e) {
log.error("RedisUtils.lRemove 方法异常, key:{}, count:{}, value:{}", key, count, JSON.toJSONString(value), e);
return 0L;
}
}
// ===============================ZSet相关操作=================================
/**
* 添加元素,有序集合是按照元素的score值由小到大排列
*
* @param key 键
* @param value 值
* @param score score值
* @return
*/
public Boolean zAdd(String key, String value, double score) {
return redisTemplate.opsForZSet().add(key, value, score);
}
/**
* 添加元素,有序集合是按照元素的score值由小到大排列
* @param key 键
* @param values 值集合
* @return
*/
public Long zAdd(String key, Set<ZSetOperations.TypedTuple<Object>> values) {
return redisTemplate.opsForZSet().add(key, values);
}
/**
* 删除元素，可以删除多个
* @param key 键
* @param values 值集合
* @return
*/
public Long zRemove(String key, Object... values) {
return redisTemplate.opsForZSet().remove(key, values);
}
/**
* 增加元素的score值，并返回增加后的值
*
* @param key 键
* @param value 值
* @param delta 增加的score值
* @return
*/
public Double zIncrementScore(String key, String value, double delta) {
return redisTemplate.opsForZSet().incrementScore(key, value, delta);
}
/**
* 返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
*
* @param key 键
* @param value 值
* @return 0表示第一位
*/
public Long zRank(String key, Object value) {
return redisTemplate.opsForZSet().rank(key, value);
}
/**
* 返回元素在集合的排名,按元素的score值由大到小排列
*
* @param key 键
* @param value 值
* @return
*/
public Long zReverseRank(String key, Object value) {
return redisTemplate.opsForZSet().reverseRank(key, value);
}
/**
* 获取集合的元素, 从小到大排序
*
* @param key 键
* @param start 开始位置
* @param end 结束位置, -1查询所有
* @return
*/
public Set<Object> zRange(String key, long start, long end) {
return redisTemplate.opsForZSet().range(key, start, end);
}
/**
* 获取集合元素, 并且把score值也获取
*
* @param key 键
* @param start 开始位置
* @param end 结束位置, -1查询所有
* @return
*/
public Set<ZSetOperations.TypedTuple<Object>> zRangeWithScores(String key, long start, long end) {
return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
}
/**
* 根据Score值查询集合元素
*
* @param key 键
* @param min 最小值
* @param max 最大值
* @return
*/
public Set<Object> zRangeByScore(String key, double min, double max) {
return redisTemplate.opsForZSet().rangeByScore(key, min, max);
}
/**
* 根据Score值查询集合元素, 从小到大排序
*
* @param key 键
* @param min 最小值
* @param max 最大值
* @return
*/
public Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key, double min, double max) {
return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
}
/**
* 根据Score值查询集合元素, 从小到大排序
* @param key 键
* @param min 最小值
* @param max 最大值
* @param start 开始位置
* @param end 结束位置, -1查询所有
* @return
*/
public Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key, double min, double max, long start, long end) {
return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max, start, end);
}
/**
* 获取集合的元素, 从大到小排序
*
* @param key 键
* @param start 开始位置
* @param end 结束位置, -1查询所有
* @return
*/
public Set<Object> zReverseRange(String key, long start, long end) {
return redisTemplate.opsForZSet().reverseRange(key, start, end);
}
/**
* 获取集合的元素, 从大到小排序, 并返回score值
*
* @param key 键
* @param start 开始位置
* @param end 结束位置, -1查询所有
* @return
*/
public Set<ZSetOperations.TypedTuple<Object>> zReverseRangeWithScores(String key, long start, long end) {
return redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
}
/**
* 根据Score值查询集合元素, 从大到小排序
*
* @param key 键
* @param min 最小值
* @param max 最大值
* @return
*/
public Set<Object> zReverseRangeByScore(String key, double min, double max) {
return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
}
/**
* 根据Score值查询集合元素, 从大到小排序
*
* @param key 键
* @param min 最小值
* @param max 最大值
* @return
*/
public Set<ZSetOperations.TypedTuple<Object>> zReverseRangeByScoreWithScores(
String key, double min, double max) {
return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max);
}
/**
* 根据Score值查询集合元素, 指定下标并从大到小排序
* @param key 键
* @param min 最小值
* @param max 最大值
* @param start 开始位置
* @param end 结束位置, -1查询所有
* @return
*/
public Set<Object> zReverseRangeByScore(String key, double min,
double max, long start, long end) {
return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max, start, end);
}
/**
* 根据score值获取集合元素数量
*
* @param key 键
* @param min 最小值
* @param max 最大值
* @return
*/
public Long zCount(String key, double min, double max) {
return redisTemplate.opsForZSet().count(key, min, max);
}
/**
* 获取集合大小
*
* @param key 键
* @return
*/
public Long zSize(String key) {
return redisTemplate.opsForZSet().size(key);
}
/**
* 获取集合大小
*
* @param key 键
* @return
*/
public Long zZCard(String key) {
return redisTemplate.opsForZSet().zCard(key);
}
/**
* 获取集合中value元素的score值
*
* @param key 键
* @param value 值
* @return
*/
public Double zScore(String key, Object value) {
return redisTemplate.opsForZSet().score(key, value);
}
/**
* 移除指定索引位置的成员
*
* @param key 键
* @param start 开始位置
* @param end 结束位置, -1查询所有
* @return
*/
public Long zRemoveRange(String key, long start, long end) {
return redisTemplate.opsForZSet().removeRange(key, start, end);
}
/**
* 根据指定的score值的范围来移除成员
*
* @param key 键
* @param min 最小值
* @param max 最大值
* @return
*/
public Long zRemoveRangeByScore(String key, double min, double max) {
return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
}
/**
* 获取key和otherKey的并集并存储在destKey中
*
* @param key
* @param otherKey
* @param destKey
* @return
*/
public Long zUnionAndStore(String key, String otherKey, String destKey) {
return redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey);
}
/**
* 获取key和otherKeys的并集并存储在destKey中
* @param key
* @param otherKeys
* @param destKey
* @return
*/
public Long zUnionAndStore(String key, Collection<String> otherKeys, String destKey) {
return redisTemplate.opsForZSet().unionAndStore(key, otherKeys, destKey);
}
/**
* 获取key和otherKey的交集并存储在destKey中
*
* @param key
* @param otherKey
* @param destKey
* @return
*/
public Long zIntersectAndStore(String key, String otherKey, String destKey) {
return redisTemplate.opsForZSet().intersectAndStore(key, otherKey, destKey);
}
/**
* 取key和otherKeys的交集并存储在destKey中
*
* @param key
* @param otherKeys
* @param destKey
* @return
*/
public Long zIntersectAndStore(String key, Collection<String> otherKeys, String destKey) {
return redisTemplate.opsForZSet().intersectAndStore(key, otherKeys, destKey);
}
/**
* 匹配获取键值对，ScanOptions.NONE为获取全部键值对；
* ScanOptions.scanOptions().match("C").build()匹配获取键位map1的键值对,不能模糊匹配。
* @param key
* @param options
* @return
*/
public Cursor<ZSetOperations.TypedTuple<Object>> zScan(String key, ScanOptions options) {
return redisTemplate.opsForZSet().scan(key, options);
}
// ===============================HyperLogLog相关操作=================================
/**
* 将任意数量的元素添加到指定的 HyperLogLog 里面。
* 时间复杂度： 每添加一个元素的复杂度为 O(1) 。
* 如果 HyperLogLog 估计的近似基数（approximated cardinality）在命令执行之后出现了变化， 那么命令返回1， 否则返回0 。
* 如果命令执行时给定的键不存在， 那么程序将先创建一个空的 HyperLogLog 结构， 然后再执行命令。
* @param key
* @param value
* @return
*/
public long pfAdd(String key, String value) {
return redisTemplate.opsForHyperLogLog().add(key, value);
}
/**
* 返回给定 HyperLogLog 的基数估算值。
* PFCOUNT作用于单个key的时候，返回该key的基数。
* PFCOUNT命令作用于多个key时，返回并集的近似数。
* @param key
* @return
*/
public long pfCount(String key) {
return redisTemplate.opsForHyperLogLog().size(key);
}
public void pfRemove(String key) {
redisTemplate.opsForHyperLogLog().delete(key);
}
/**
* 将多个 HyperLogLog 合并为一个 HyperLogLog
* 将多个HyperLogLog合并为一个HyperLogLog。
* 合并后的HyperLogLog的基数接近于全部输入的可见集合的并集。合并得出的hyperLogLog会被存储到destkey中去。
*
* 返回值：成功返回ok。
* @param key1
* @param key2
*/
public void pfMerge(String key1, String key2) {
redisTemplate.opsForHyperLogLog().union(key1, key2);
}
/**
* 尝试获取锁，重试5次，5次仍然获取不到，直接返回失败
* @param lockKey
* @return
*/
public boolean tryLock(String lockKey) {
boolean lock = lock(lockKey);
if (lock) {
return true;
} else {
// 设置失败次数计数器, 当到达5次时, 返回失败
int failCount = 1;
while(failCount <= 5){
// 等待100ms重试
try {
Thread.sleep(100L);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (lock(lockKey)){
return true;
}else{
failCount ++;
}
}
return false;
}
}
/**
* 最终加强分布式锁
*
* @param lockKey key值
* @return 是否获取到
*/
public boolean lock(String lockKey){
if (StringUtils.isEmpty(lockKey)) {
return false;
}
// 利用lambda表达式
return (Boolean) redisTemplate.execute((RedisCallback) connection -> {
long expireAt = System.currentTimeMillis() + LOCK_EXPIRE + 1;
Boolean acquire = connection.setNX(lockKey.getBytes(), String.valueOf(expireAt).getBytes());
if (acquire) {
return true;
} else {
byte[] value = connection.get(lockKey.getBytes());
if (Objects.nonNull(value) && value.length > 0) {
long expireTime = Long.parseLong(new String(value));
// 如果锁已经过期
if (expireTime < System.currentTimeMillis()) {
// 重新加锁，防止死锁
byte[] oldValue = connection.getSet(lockKey.getBytes(), String.valueOf(System.currentTimeMillis() + LOCK_EXPIRE + 1).getBytes());
return Long.parseLong(new String(oldValue)) < System.currentTimeMillis();
}
}
}
return false;
});
}
/**
* 释放锁
*
* @param lockKey 锁名称
*/
public void unLock(String lockKey) {
if(!StringUtils.isEmpty(lockKey)){
redisTemplate.delete(lockKey);
}
}
}
五、另一种实现方案
利用Redis的list数据结构实现抢红包的方案
- 1、发红包时，业务校验通过后，减去钱包中对应的金额，操作成功后开始创建红包
- 2、红包在创建时，根据红包数量分配好金额直接入库拿到红包主id和每个小红包的子id，根据主id生成key将子id集合存入redis list结构的栈空间
- 3、抢红包时，根据客户端传递来的红包主id从栈中推出一个子id(如果推出为null说明该主id的红包已被抢光)，这样就实现了高并发与分布式下数据的原子性。
- 4、抢红包时，抢到红包的用户根据子id，使用异步方式(mq消息队列等)修改红包表记录，并给相应用户增加抢到的金额。
- 6、客户端可以通过红包主id来查询该红包都被谁抢到、抢到的时间、抢到多少钱、谁手气最佳等信息。
注意：此种方案提前分配好红包金额，比较浪费Redis内存。
总结
这里简单描述了一下抢红包的设计思路，一个完整的抢红包功能涉及到方方面面，各种业务逻辑判断还得根据实际情况进行应用!
参考：
https://www.cnblogs.com/wlwl/p/12521166.html
https://blog.csdn.net/u012537411/article/details/118074800
https://blog.csdn.net/qq_43202539/article/details/122172848
https://timyang.net/architecture/wechat-red-packet/
https://www.cnblogs.com/moxiaotao/p/13051687.html
https://wenku.baidu.com/view/e34bf017c8d376eeafaa316d?aggId=3ca8594148649b6648d7c1c708a1284ac85005ee
网友评论