Redis Incr 命令将 key 中储存的数字值增一。 如果 key 不存在,那么 key 的值会先被初始化为 0 ,然后再执行 INCR 操作。且将key的有效时间设置为长期有效 。
2.1.1 常见使用场景 2.1.1.1 计数我们可能常会统计网站页面每天访问量,通过incr命令在redis中设置key,每次增加1,设置24小时过期。
2.1.1.2 限流日常的开放平台API一般常有限流,利用redis的incr命令可以实现一般的限流操作。如限制某接口每分钟请求次数上限1000次
2.1.1.3 幂等MQ防止重复消费也可以利用INCR命令实现,如订单防重,订单5分钟之内只能被消费一次,订单号作为redis的key
2.2 sexnxRedis使用setnx命令实现分布式锁;
2.1.1 加锁版本一#但是这种方式的缺点是容易产生死锁,因为客户端有可能忘记解锁,或者解锁失败。
setnx key value
版本二#给锁增加了过期时间,避免出现死锁。但这两个命令不是原子的,第二步可能会失败,依然无法避免死锁问题。
setnx key value
expire key seconds
版本三(推荐)#通过“set...nx...”命令,将加锁、过期命令编排到一起,它们是原子操作了,可以避免死锁。
set key value nx ex seconds
2.1.2 解锁
解锁就是删除代表锁的那份数据。
del key
参考博客:https://blog.csdn.net/weixin_45525272/article/details/126562119
3、实现代码主要是抢购的业务;
3.1模块分析 3.2 web模块 3.2.1 application.yml 点击查看代码# 端口
server:
port: 8106
# 服务名
spring:
application:
name: edocmall-seckill-web
# redis 配置
redis:
host: 127.0.0.1
port: 6379
# eureka 注册中心的配置
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:8096/eureka # 注册中心的地址
# 秒杀抢购自定义配置
kh96:
seckill:
buy-user-count-prefix: seckill-buy-user-count # 请求用户数量的限制头标识
buy-prod-stock-count: 100 # 初始化腔骨商品的库存数量,存入redis,实际开发中,没有此配置(初始化商品库存,在洗头膏添加抢购商品是)
buy-prod-stock-prefix: seckill-buy-prod-stock # 抢购商品数量 头标识
buy-user-lock-prefix: seckill-buy-user-lock # 锁定抢购用户的头标识
buy-prod-lock-prefix: seckill-buy-prod-lock # 锁定商品库存锁头标识
3.2.2 SeckillConfig 配置类 点击查看代码
/**
* Created On : 9/11/2022.
*
* Author : huayu
*
* Description: SeckillConfig
*/
@Data
@Component
@ConfigurationProperties(prefix = "kh96.seckill")
public class SeckillConfig {
/*
请求用户数量的限制头标识
*/
private String buyUserCountPrefix;
/*
初始化抢购商品的库存数量
*/
private Integer buyProdStockCount;
/*
抢购商品数量 头标识
*/
private String buyProdStockPrefix;
/*
锁定抢购用户的头标识
*/
private String buyUserLockPrefix;
/*
锁定商品库存锁头标识
*/
private String buyProdLockPrefix;
}
3.2.3 抢购接口和实现类 3.2.3.1 接口 点击查看代码
/**
* Created On : 9/11/2022.
*
* Author : huayu
*
* Description: 秒杀抢购的业务接口
*/
public interface SeckillService {
/**
* @author : huayu
* @date : 9/11/2022
* @param : [prodId, stockCount]
* @return : void
* @description : 初始化商品库存到缓存
*/
boolean initProdStock2Redis(String prodId,Integer stockCount);
/**
* @author : huayu
* @date : 9/11/2022
* @param : [productId]
* @return : boolean
* @description : 校验抢购商品的请求数量是否达到上限
*/
boolean checkBuyUserCount(String productId);
/**
* @author : huayu
* @date : 9/11/2022
* @param : [prodId, buyCount]
* @return : boolean
* @description : 校验商品库存是否充足
*/
boolean checkProdStockEnough(String prodId,Integer buyCount);
/**
* @author : huayu
* @date : 9/11/2022
* @param : [userId, prodId]
* @return : boolean
* @description : 校验用户是否已经抢购过当前商品
*/
boolean checkBuyUserBought(String userId,String prodId);
/**
* @author : huayu
* @date : 9/11/2022
* @param : [userId]
* @return : boolean
* @description : 校验商品库存是否锁定
*/
boolean checkProdStockLocked(String prodId);
/**
* @author : huayu
* @date : 9/11/2022
* @param : [prodId]
* @return : boolean
* @description : 释放库存锁
*/
void unLockProdStock(String prodId);
/**
* @author : huayu
* @date : 9/11/2022
* @param : [prodId, butCount]
* @return : void
* @description : 扣减库存
*/
void subProdStockCount(String prodId, Integer butCount);
}
3.2.3.2 实现类 点击查看代码
/**
* Created On : 9/11/2022.
*
* Author : huayu
*
* Description: 抢购业务接口实现类
*/
@Service
public class SeckillServiceImpl implements SeckillService {
@Autowired
private RedisUtils redisUtils;
@Autowired
private SeckillConfig seckillConfig;
@Override
public boolean initProdStock2Redis(String prodId, Integer stockCount) {
// 判断redis中,是否存在已经初始化的商品库存数据,如果已经存在,不需要再次初始化
if (ObjectUtils.isEmpty(redisUtils.get(seckillConfig.getBuyProdStockPrefix() + ":" + prodId))){
// 将商品库存添加到redis中
return redisUtils.set(seckillConfig.getBuyProdStockPrefix() + ":" + prodId, stockCount);
}
// 已经存在商品库存,不需要设置
return false;
}
@Override
public boolean checkBuyUserCount(String prodId) {
// 使用redis的incr操作,校验当前商品的抢购用户数是否达到上限
return redisUtils.incr(seckillConfig.getBuyUserCountPrefix() + ":" + prodId, 1)
> Integer.parseInt(redisUtils.get(seckillConfig.getBuyProdStockPrefix() + ":" + prodId).toString()) * 2;
}
@Override
public boolean checkProdStockEnough(String prodId, Integer buyCount) {
//校验商品库存,是否大于等于用户抢购数量,如果小于,代表库存不足
//TODO 如果redis 没有查到库存(库存没初始化,或者后台误删,必须要进行数据库查询操作,获取库存,
// 要加锁,只有一个线程取操作),再同步到redis
return Integer.parseInt(redisUtils.get(seckillConfig.getBuyProdStockPrefix() + ":" + prodId).toString())
>= buyCount;
}
@Override
public boolean checkBuyUserBought(String userId, String prodId) {
//使用redis的分布式锁,sexnx,
// 如果上锁成功,代表没有买过,可以继续购买,如果上锁失败,表示购买过不能继续购买
//锁时长为正抢购活动时长
return ! redisUtils.lock( seckillConfig.getBuyUserLockPrefix()+":"+userId,
null,
15*60); //模拟 抢购时长
}
@Override
public boolean checkProdStockLocked(String prodId) {
//使用redis的分布式锁,sexnx,如果上锁成功,代表库存没有被锁,如果上锁失败代表库存被其他用户锁定不能购买
//锁库存必须要增加时长限制,防止库存锁释放失败,导致用户无法抢购,过期仍然会释放
return ! redisUtils.lock(seckillConfig.getBuyProdLockPrefix()+":"+prodId,
null,
2*60); //模拟锁2分钟
}
@Override
public void unLockProdStock(String prodId) {
//删除redis中的 库存锁
redisUtils.del(seckillConfig.getBuyProdLockPrefix()+":"+prodId);
}
@Override
public void subProdStockCount(String prodId, Integer butCount) {
//扣减 redis中缓存的商品库存数量
//TODO redis缓存中操成功后,要发异步消息 到队列 更新数据库中商品库存呢
redisUtils.decr(seckillConfig.getBuyProdStockPrefix() + ":" + prodId,
butCount);
}
}
3.2.4 远程调用订单模块进行下单 点击查看代码
/**
* Created On : 10/11/2022.
*
* Author : huayu
*
* Description: SeckillOrderFeignService
*/
@FeignClient(value = "edocmall-seckill-order")
public interface SeckillOrderFeignService {
/**
* @author : huayu
* @date : 10/11/2022
* @param : [userId, prodId, buyCount]
* @return : java.lang.String
* @description : 远程调用订单中心,生成秒杀抢购订单的接口
*/
@GetMapping("/createSeckillOrder")
String feignInvokeCreateSeckillOrder(@RequestParam(value = "userId") String userId,
@RequestParam(value = "prodId") String prodId,
@RequestParam(value = "buyCount") Integer buyCount);
}
3.2.5 抢购 控制层 点击查看代码
/**
* Created On : 9/11/2022.
*
* Author : huayu
*
* Description: 秒杀操作入口
*/
@Slf4j
@RestController
@Api(tags = "秒杀操作")
public class SeckillController {
@Autowired
private SeckillService seckillService;
@Autowired
private SeckillOrderFeignService seckillOrderFeignService;
/**
* @author : zhukang
* @date : 2022/11/9
* @param : [userId, prodId, buyCount]
* @return : com.kgc.scd.util.RequestResult>
* @description : 模拟初始化商品库存,实际开发中,没有此操作,是在后台添加抢购商品预热是,直接同步到redis
*/
@GetMapping("/initProdStock")
@ApiOperation(value = "1 初始库存", notes = "抢购商品预热,初始化商品库存数量到redis中")
@ApiImplicitParams({
@ApiImplicitParam(value = "初始化商品id",name = "prodId"),
@ApiImplicitParam(value = "初始化商品数量",name = "stockCount")
})
public RequestResult> initProdStock(@RequestParam String prodId,
@RequestParam Integer stockCount){
log.info("------ 初始化商品:{},库存数量:{},到redis缓存中 ------", prodId, stockCount);
// 增加业务逻辑处理:防止瞬时请求过多,使用redis的incr原子操作,进行请求用户数的统计计数,如果请求已经达到了上限(比如:设定请求用户数最多是抢购商品库存的2倍),其它后续所有的请求都默认无效,返回失败:当前请求用户过多,请稍后重试
if(seckillService.initProdStock2Redis(prodId, stockCount)){
return ResultBuildUtil.success("初始化商品库存成功!");
}
// 初始化商品库存失败
return ResultBuildUtil.fail("601", "初始化商品库存失败,请确认redis库存是否已初始化!");
}
@GetMapping("/seckillBuy")
@ApiOperation(value = "2 开始秒杀", notes = "基于redis,RabbitMQ消息队列,实现有序秒杀抢购功能")
@ApiImplicitParams({
@ApiImplicitParam(value = "用户id",name = "userId"),
@ApiImplicitParam(value = "商品id",name = "prodId"),
@ApiImplicitParam(value = "抢购数量",name = "buyCount")
})
public RequestResult> seckillBuy(@RequestParam String userId,
@RequestParam String prodId,
@RequestParam Integer buyCount){
log.info("------ 用户:{},购买商品:{},购买数量:{},开始抢购 ------", userId, prodId, buyCount);
// TODO 增加请求许可校验(自定义注解+拦截器),校验请求此接口的所有用户是否是已登录用户,如果没有登录,提示请登录
// TODO 增加接口参数的校验,判断用户是否是系统正常用户,不能是状态异常用户,判断商品的数据是否正确(切记:涉及系统内数据不要信任请求参数,要信任系统的缓存的数据库)
// TODO 为了提高抢购入口的并发处理能力,要减少数据库交互,可以设计为根据商品编号,从redis缓存中查询商品,如果商品信息存在,则参与抢购,如果不存在,还是需要到数据库查询商品,如果数据库中存在,将商品信息存入redis缓存,如果数据库不存在,则直接提示抢购失败。
// TODO 此种场景,正常情况,没有问题,可能存在的问题,某个商品,是首次参与抢购,缓存中没有数据,但是数据库有,虽然上面的处理方式,可以解决,但是在高并发场景下,同一时刻会有大批量的请求来秒杀此商品,此时同时去缓存中获取商品数据,没有获取到,又同时去数据库查询,就会导致数据库扛不住压力,可能直接数据库挂掉。
// TODO 解决方式:缓存商品数据一般都是在后台添加抢购商品时,直接对商品进行预热处理,即:事先把参与抢购的商品直接同步到redis缓存中,这样当抢购开始,直接从redis缓存就可以获取到商品,而不会出现缓存击穿问题。
// TODO 虽然商品数据预热方式,可以解决此类问题,但是可能还会存在例外(比如:缓存中的商品由于后台失误操作,导致设置的过期时间不对,缓存时间提前过期,或者缓存数据误删除),此种情况还是需要当缓存不存在商品数据,从数据库查询,放入缓存的逻辑。
// TODO 解决方式:可以进行加锁,限制在高并发的情况下访问数据库,如果同一时刻,缓存中没有获取到商品数据库,就进入查询数据库操作,但是在进入查询前,增加分布式锁,只有获取到锁的请求,才可以查询数据库并加入到缓存中(加完就释放锁),获取不到锁的请求,直接返回失败(损失当前请求,后续请求进行弥补,只要一个操作成功,缓存中的数据就存在,后续的请求自然可以获取到数据)
// TODO 极端情况:redis无法使用,必须要增加redis的高可用,确保redis永远是有效的,考虑的模式就是集群模式下的哨兵机制。或者把大批量的请求直接放到消息队列,进行缓冲处理。
log.info("------------------------------ 进行请求用户数的统计计数,防止请求过多 -----------------------------------------");
// 增加业务逻辑处理:防止瞬时请求过多,使用redis的incr原子操作,进行请求用户数的统计计数,如果请求已经达到了上限(比如:设定请求用户数最多是抢购商品库存的2倍),其它后续所有的请求都默认无效,返回失败:当前请求用户过多,请稍后重试
if(seckillService.checkBuyUserCount(prodId)){
return ResultBuildUtil.fail("602", "抢购失败,当前抢购用户过多,请稍后重试!");
}
log.info("------------------------------ 查看库存是否充足 -----------------------------------------");
//校验商品库存数量是否充足,可以进行后续抢购,日过不足,直接抢购失败
log.info("------ 用户:{},购买商品:{},购买数量:{},库存校验 ------", userId, prodId, buyCount);
if(!seckillService.checkProdStockEnough(prodId,buyCount)){
//库存不足,返回抢购失败
log.info("------ 用户:{},购买商品:{},购买数量:{},库存不足 ------", userId, prodId, buyCount);
return ResultBuildUtil.fail("603", "抢购失败,库存不足,缺货!");
}
log.info("------------------------------ 判断用户是否抢购过 -----------------------------------------");
//增加幂等操作:当前抢购用户只能抢购一次,如果已经抢购过商品,不允许再次抢购(限制一个用户同一个抢购商品,整个抢购期间只能抢购一次)
log.info("------ 用户:{},购买商品:{},购买数量:{},锁定抢购用户,如果 已经抢购过商品,不允许再次抢购 ------", userId, prodId, buyCount);
if(seckillService.checkBuyUserBought(userId,prodId)){
//用户抢购过,返回抢购失败
log.info("------ 用户:{},购买商品:{},购买数量:{},重复抢购 ------", userId, prodId, buyCount);
return ResultBuildUtil.fail("604", "抢购失败,重复抢购!");
}
log.info("------------------------------ 用户获取库存锁 -----------------------------------------");
//执行抢购业务,先给商品库存上锁(锁库存),如果上锁成功,代表当前用户继续抢购商品,如果上锁失败,说明有人抢购,进行等待
log.info("------ 用户:{},购买商品:{},购买数量:{},(尝试获取库存锁) 执行抢购业务,先给商品库存上锁(锁库存),拿到 库存锁 才可以开始下单 ------", userId, prodId, buyCount);
while (true){
//死循环,尝试锁库存,如果锁库存成功,代表库存所已经被释放
if(!seckillService.checkProdStockLocked(prodId)){
log.info("------ 用户:{},购买商品:{},购买数量:{},锁库存成功,拿到 库存锁 ,开始下单------", userId, prodId, buyCount);
//结束循环,执行抢购下单
break;
}
log.debug("------ 用户:{},购买商品:{},购买数量:{},锁库存成功失败,等待。。。------", userId, prodId, buyCount);
}
log.info("------------------------------ 已经获得库存锁,再次判断库存是否充足 -----------------------------------------");
//考虑高并发的场景:
//多人同时校验库存成功,但是进入到抢购下单业务时,库存呢只够部分人购买,需要再确定库存是否足够
//校验商品库存数量是否充足,可以进行后续抢购,日过不足,直接抢购失败
log.info("------ 用户:{},购买商品:{},购买数量:{},锁库存后(拿到库存锁后) 再次 库存校验 ------",userId, prodId, buyCount);
if(!seckillService.checkProdStockEnough(prodId,buyCount)){
//释放库存锁,后续用户继续尝试购买
//库存剩余2两,还有三个人买,库存不足,后续两个人各买一件
//释放库存锁
seckillService.unLockProdStock(prodId);
log.info("------ 用户:{},购买商品:{},购买数量:{},再次 库存校验,库存不足 ------", userId, prodId, buyCount);
//库存不足,返回抢购失败
log.info("------ 用户:{},购买商品:{},购买数量:{},抢购下单中,库存不足 ------", userId, prodId, buyCount);
return ResultBuildUtil.fail("605", "抢购失败,库存不足,缺货!");
}
log.info("------------------------------ 开始扣减库存 -----------------------------------------");
//执行扣减商品库存
log.info("------ 用户:{},购买商品:{},购买数量:{},扣减库存 ------", userId, prodId, buyCount);
seckillService.subProdStockCount(prodId,buyCount);
log.info("------------------------------ 开始下单 -----------------------------------------");
//开始调用订单中心的生成抢购订单接口,下单并返回给前端,抢购结果
//先模拟下单成功,返回一个抢购订单号
log.info("------ 用户:{},购买商品:{},购买数量:{},开始下单 ------", userId, prodId, buyCount);
// String seckillOrderNo = "SK"+ LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"))
// + UUID.randomUUID().toString().substring(0,5);
String seckillOrder = seckillOrderFeignService.feignInvokeCreateSeckillOrder(userId, prodId, buyCount);
log.info("------------------------------ 下单成功 主动释放库存锁 -----------------------------------------");
//生成抢购订单成功,立刻释放库存锁,给其他抢购用户购买
log.info("------ 用户:{},购买商品:{},购买数量:{},下单成功,释放库存锁 ------", userId, prodId, buyCount);
seckillService.unLockProdStock(prodId);
log.info("------ 用户:{},购买商品:{},购买数量:{},抢购成功 ------", userId, prodId, buyCount);
//返回抢购成功,实际开发不能返回此种格式的数据
//必须使用key和value的返回,方便前端获取订单号
return ResultBuildUtil.success("抢购成功,抢购订单"+seckillOrder);
}
}
3.3 订单模块
3.3.1 application.yml 点击查看代码
# 端口
server:
port: 8107
# 服务名
spring:
application:
name: edocmall-seckill-order
# redis
redis:
host: 127.0.0.1
port: 6379
# RabbitMQ
rabbitmq:
host: 1.117.75.57
port: 5672
username: admin
password: admin
# eureka 注册中心的配置
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:8096/eureka # 注册中心的地址
3.3.2 OrderMQDirectConfig 点击查看代码
/**
* Created On : 1/11/2022.
*
* Author : huayu
*
* Description: Direct直连模式,自动配置类,自动创建队列,交换机,并将队列绑定到交换机,指定唯一路由
*/
@Configuration
public class OrderMQDirectConfig {
/**
* @author : huayu
* @date : 1/11/2022
* @param : []
* @return : org.springframework.amqp.core.Queue
* @description : directQueue
*/
@Bean
public Queue directQueue(){
return new Queue(OrderMQConstant.SECKILL_SAVE_ORDER_QUEUE_KH96,true);
}
/**
* @author : huayu
* @date : 1/11/2022
* @param : []
* @return : org.springframework.amqp.core.DirectExchange
* @description : 创建直连交换机
*/
@Bean
public DirectExchange directExchange(){
// 创建支持持久化的直连交换机,指定交换机的名称
return new DirectExchange(OrderMQConstant.SECKILL_SAVE_ORDER_EXCHANGE_KH96U);
}
/**
* @author : huayu
* @date : 1/11/2022
* @param : []
* @return : org.springframework.amqp.core.Binding
* @description : 将直连队列和直连交换机进行绑定,并指定绑定的唯一路由键
*/
@Bean
public Binding directBinding(){
// 将直连队列和直连交换机进行绑定,并指定绑定的唯一路由键
return BindingBuilder.bind(directQueue())
.to(directExchange())
.with(OrderMQConstant.SECKILL_SAVE_ORDER_ROUTING_KH96);
}
}
3.3.3 OrderMQConstant 点击查看代码
/**
* Created On : 1/11/2022.
*
* Author : huayu
*
* Description: RabbitMQ 常量类,系统的所有队列名,交换机名,路由键名等,统一进行配置管理
*/
public class OrderMQConstant {
//========================== 直连模式
/**
* Direct直连模式 队列名
*/
public static final String SECKILL_SAVE_ORDER_QUEUE_KH96 ="seckill_save_order_queue_kh96";
/**
* Direct直连模式 交换机名
*/
public static final String SECKILL_SAVE_ORDER_EXCHANGE_KH96U ="seckill_save_order_exchange_kh96";
/**
* Direct直连模式 路由键
*/
public static final String SECKILL_SAVE_ORDER_ROUTING_KH96 ="seckill_save_order_routing_kh96";
//========================== 扇形模式
/**
* Fanout 扇形模式 队列名
*/
public static final String ACCOUNT_FANOUT_QUEUE_KH96 ="account_pay_result_queue_kh96";
}
3.3.4 下订单业务层 3.3.4.1 接口 点击查看代码
/**
* Created On : 10/11/2022.
*
* Author : huayu
*
* Description:
*/
public interface SeckillOrderService {
/**
* @author : huayu
* @date : 11/11/2022
* @param : [seckillOrder]
* @return : void
* @description : 生成秒杀订单
*/
void saveSeckillOrder(Map seckillOrder);
}
3.3.4.2实现类 点击查看代码
/**
* Created On : 10/11/2022.
*
* Author : huayu
*
* Description: SeckillOrderServiceImpl
*/
@Service
@Slf4j
public class SeckillOrderServiceImpl implements SeckillOrderService {
@Autowired
private RabbitTemplate rabbitTemplate;
@Autowired
private RedisUtils redisUtils;
@Override
public void saveSeckillOrder(Map seckillOrder) {
//发送生成抢购订单的消息到消息队列,并在redis中添加此订单的记录,模拟交互
//0 正在生成
if(redisUtils.set(seckillOrder.get("seckillOrderNo").toString(),0)){
//发送生成订单的消息
rabbitTemplate.convertAndSend(OrderMQConstant.SECKILL_SAVE_ORDER_EXCHANGE_KH96U,
OrderMQConstant.SECKILL_SAVE_ORDER_ROUTING_KH96,
seckillOrder);
}
}
}
3.3.5 SeckillOrderSaveListener 点击查看代码
/**
* Created On : 1/11/2022.
*
* Author : huayu
*
* Description: Direct 直连模式消费者 One
*/
@Slf4j
@Component
//指定接听的 消息队列 名字
@RabbitListener(queues = OrderMQConstant.SECKILL_SAVE_ORDER_QUEUE_KH96)
public class SeckillOrderSaveListener {
@Autowired
private RedisUtils redisUtils;
/**
* @author : huayu
* @date : 1/11/2022
* @param : [directMsgJson]
* @return : void
* @description : Direct 直连模式消费者One,消费信息
*/
//指定消息队列中的消息,交给对应的方法处理
@RabbitHandler
public void saveSeckillOrder(Map seckillOrder){
log.info("***** 秒杀抢购订单:{},开始入库 ******",seckillOrder.get("seckillOrderNo"));
//TODO 将消息中的订单实体对象,调入业务接口,插入到数据库
redisUtils.set(seckillOrder.get("seckillOrderNo").toString(),1);
log.info("***** 秒杀抢购订单:{},入库成功 ******",seckillOrder.get("seckillOrderNo"));
}
}
3.3.6 下单 控制层 点击查看代码
/**
* Created On : 10/11/2022.
*
* Author : huayu
*
* Description: 秒杀抢购订单入口
*/
@Slf4j
@RestController
public class SeckillOrderController {
@Autowired
private SeckillOrderService seckillOrderService;
/**
* @author : huayu
* @date : 10/11/2022
* @param : [userId, prodId, buyCount]
* @return : java.lang.String
* @description : 生成秒杀抢购订单
*/
@GetMapping("/createSeckillOrder")
public String createSeckillOrder(@RequestParam String userId,
@RequestParam String prodId,
@RequestParam Integer buyCount){
log.info("****** 用户:{},购买商品:{},购买数量:{},生成抢购订单 ******", userId, prodId, buyCount);
//TODO 必须要有参数校验,必须要有用户,商品信息的校验,确定用户是否正常,商品是否还在抢购中
//TODO 再次强调所有的中心模块,数据来源,不能信任外部接口来源的参数,都必须从数据库或者缓存中获取,尤其是跟金钱相关
//TODO 所有的接口必需要校验结束,通过获取的数据,封装订单实体对象,用户不关系订单的生成业务,可以使用异步消息队列,实现晓峰,并快速响应
//模拟生成一个抢购订单号,并封装成订单实体对象,通过map集合模拟
String seckillOrderNo = "SK"+ LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"))
+ UUID.randomUUID().toString().substring(0,5);
//创建订单实体对象
Map seckillOrder = new HashMap<>();
seckillOrder.put("userId",userId);
seckillOrder.put("prodId",prodId);
seckillOrder.put("buyCount",buyCount);
//TODO 其他的订单属性封装,比如收货人,总价格,优惠,时间等
seckillOrder.put("seckillOrderNo",seckillOrderNo);
//发送到生成订单的消息队列中,使用异步处理
seckillOrderService.saveSeckillOrder(seckillOrder);
//返回抢购订单
return seckillOrder.toString();
}
}
3.4 查询订单状态和订单支付部分不再赘述 4、测试 4.1 初始化库存
4.2 抢购 4.2.1 抢购情况
4.2.2 redis中数据变化情况
4.3 查看订单详情 4.4 订单支付支付的时候数注意穿透的路径;
总结以上是真正的电脑专家为你收集整理的SpringCloud(十一)- 秒杀 抢购的全部内容,希望文章能够帮你解决所遇到的问题。
如果觉得真正的电脑专家网站内容还不错,欢迎将真正的电脑专家推荐给好友。
有话要说...