第26天-秒杀服务(秒杀系统设计与实现)

1.秒杀设计


1.1.秒杀业务

秒杀具有瞬间高并发特点,针对这一特点,必须要做限流+异步+缓存(页面静态化)+独立部署

限流方式:

  • 前端限流,一些高并发的网站直接在前端页面开始限流,例如:小米的验证码设计
  • Nginx限流,直接负载部分请求到错误的静态页面:令牌算法,漏斗算法
  • 网关限流,限流过滤器
  • 代码中使用分布式信号量
  • RabbitMQ限流,chanel.basicQos(1),保证发挥所有服务器的性能

1.2.秒杀流程


第26天-秒杀服务(秒杀系统设计与实现)_第1张图片

1.3.秒杀系统设计

1.3.1.秒杀(高并发)系统关注的问题

  • 服务单一职责+独立部署
    • 秒杀服务即使自己扛不住压力,宕机,不要影响别的服务
  • 秒杀链接加密
    • 防止恶意攻击,模拟秒杀请求,1000次/s 攻击
    • 防止链接暴露,自己工作人员,提前秒杀商品
  • 库存预热+快速扣减
    • 秒杀读多写少,无需每次实时校验库存,进行库存预热,放到redis中,信号量控制进来秒杀的请求
    • Redis集群+分片高可用
  • 动静分离
    • nginx做好动静分离,保证秒杀和商品详情页的动态请求才打到后端的服务集群
    • 上线可以使用CDN网络,分担本集群压力
  • 恶意请求拦截
    • 识别非法攻击请求并进行拦截,比如登录拦截器
    • 网关层处理
  • 流程错峰
    • 使用各种手段,将流量分担到大宽度的时间点,比如验证码,加入购物车
  • 限流、熔断、降级
    • 前端限流+后端限流(网关)
    • 限制次数,限制总量,快速失败降级运行,熔断隔离防止雪崩
  • 队列削峰
    • 1万个商品,每个1000件秒杀(信号量)
    • 所有秒杀成功的请求,进入队列,慢慢创建订单,扣减库存即可


2.秒杀服务

2.1.构建秒杀服务


第26天-秒杀服务(秒杀系统设计与实现)_第2张图片

配置域名映射及网关

192.168.139.10 seckill.gmall.com
spring:
  cloud:
	gateway:
	  routes:
	    - id: gmall_seckill_route
		  uri: lb://gmall-seckill
		  predicates:
		  - Host=seckill.gmall.com

2.2.添加秒杀场次

后台管理系统:优惠营销 -> 每日秒杀

第26天-秒杀服务(秒杀系统设计与实现)_第3张图片

2.3.秒杀场次关联秒杀商品

第26天-秒杀服务(秒杀系统设计与实现)_第4张图片

2.4.秒杀商品定时上架

  • 定时任务扫描最近三天需要上架的秒杀商品
  • 库存预热,让秒杀商品缓存到Redis中

SeckillSkuScheduled

package com.atguigu.gmall.seckill.scheduled;

import com.atguigu.gmall.seckill.service.SeckillService;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

/**
 * 秒杀商品定时上架 {@link SeckillSkuScheduled}
 *  每天凌晨3点,上架最近三天需要秒杀商品
 *  当天 00:00:00 - 23:59:59
 *  明天 00:00:00 - 23:59:59
 *  后天 00:00:00 - 23:59:59
 *
 * @author zhangwen
 * @email: [email protected]
 */
@Slf4j
@Service
public class SeckillSkuScheduled {

    private final String UPLOAD_LOCK = "seckill:upload:lock";

    @Autowired
    private SeckillService seckillService;

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 秒杀商品定时上架
     *
     * 幂等处理:
     *  - 1.分布式锁
     *  - 2.缓存数据时判断是否已经存在key
     *      - key不存在就缓存
     *      - key存在不做处理
     */
    @Scheduled(cron = "0 0 3 * * ?")
    public void uploadSeckillSkuLast3Days(){
        log.info("秒杀商品定时上架...");
        // 幂等处理,分布式锁
        // 锁的业务执行完成,状态已经更新完成,释放锁以后,其他人获取到的就是最新的状态
        RLock lock = redissonClient.getLock(UPLOAD_LOCK);
        lock.lock(10, TimeUnit.SECONDS);
        try {
            seckillService.uploadSeckillSkuLast3Days();
        } finally {
            lock.unlock();
        }
    }
}

SeckillServcieImpl

	/**
     * 上架最近三天的秒杀商品
     */
    @Override
    public void uploadSeckillSkuLast3Days() {
        // 扫描最近三天需要参与的秒杀活动与商品信息
        R r = couponFeignService.getLast3DaySession();
        if (r.getCode() == 0) {
            // 需要上架的商品
            List<SeckillSessionsWithSkusVO> sessions = r.getData("data",
                    new TypeReference<List<SeckillSessionsWithSkusVO>>() {
            });
            // 缓存秒杀活动信息
            saveSessions(sessions);
            // 缓存秒杀活动关联的商品信息
            saveSessionSkus(sessions);
        } else {
            log.error("远程调用 gmall-coupon 获取秒杀活动失败");
        }
    }
    
    /**
     * 缓存秒杀活动信息
     * @param sessions
     */
    private void saveSessions(List<SeckillSessionsWithSkusVO> sessions) {
        if (sessions != null && sessions.size() > 0) {
            sessions.stream().forEach(session -> {
                Long startTime = session.getStartTime().getTime();
                long endTime = session.getEndTime().getTime();
                String key = SESSIONS_CACHE_PREFIX + startTime + "_" + endTime;
                Boolean hasKey = redisTemplate.hasKey(key);
                if (!hasKey) {
                    // 缓存秒杀活动信息
                    List<String> skuIds = session.getRelationSkus().stream()
                            .map(item -> item.getPromotionSessionId() + "_" + item.getSkuId())
                            .collect(Collectors.toList());
                    redisTemplate.opsForList().leftPushAll(key, skuIds);
                }
            });
        }
    }

    /**
     * 缓存秒杀活动关联的商品信息
     * @param sessions
     */
    private void saveSessionSkus(List<SeckillSessionsWithSkusVO> sessions){
        if (sessions != null && sessions.size() > 0) {
            sessions.stream().forEach(session -> {
                BoundHashOperations<String, Object, Object> hashOps = redisTemplate.boundHashOps(SECKILL_SKU_CACHE_PREFIX);
                session.getRelationSkus().stream().forEach(seckillSkuVO -> {
                    String hashKey = seckillSkuVO.getPromotionSessionId() + "_" + seckillSkuVO.getSkuId();
                    if (!hashOps.hasKey(hashKey)) {
                        // 缓存商品
                        SeckillSkuRedisTO redisTO = new SeckillSkuRedisTO();
                        // 1.sku基本信息
                        R r = productFeignService.getSkuInfo(seckillSkuVO.getSkuId());
                        if (r.getCode() == 0) {
                            SkuInfoVO skuInfo = r.getData("skuInfo", new TypeReference<SkuInfoVO>() {
                            });
                            redisTO.setSkuInfo(skuInfo);
                        }

                        // 2.sku秒杀信息
                        BeanUtils.copyProperties(seckillSkuVO, redisTO);

                        // 3.设置当前商品秒杀时间
                        redisTO.setStartTime(session.getStartTime().getTime());
                        redisTO.setEndTime(session.getEndTime().getTime());

                        // 4.设置随机码,防止恶意攻击
                        String token = UUID.randomUUID().toString().replace("-", "");
                        redisTO.setRandomCode(token);

                        String json = JsonUtils.objectToJson(redisTO);
                        hashOps.put(hashKey, json);
**加粗样式**
                        // 5.使用秒杀商品库存作为分布式的信号量,限流
                        RSemaphore semaphore = redissonClient.getSemaphore(SKU_STOCK_SEMAPHORE + token);
                        semaphore.trySetPermits(seckillSkuVO.getSeckillCount().intValue());
                    }
                });
            });
        }
    }

2.5.展示秒杀商品(首页)

index.html

//获取当前秒杀场次商品
$.get('http://seckill.gmall.com/currentSeckillSkus', function(resp){
	if(resp.data.length > 0){
		resp.data.forEach(function(item){
			$('<li onclick="toItemPage('+item.skuId+')"> </li>')
				.append($('<img src="'+item.skuInfo.skuDefaultImg+'"
				style="width: 130px;height: 130px">'))
				.append($('

'+item.skuInfo.skuTitle+'

'
)) .append($(''+item.seckillPrice+'</span>')) .append($(''+item.skuInfo.price+'')) .appendTo($('#seckillSkus')) }) } }) function toItemPage(skuId){ location.href = `http://item.gmall.com/${skuId}.html` }

2.6.商品秒杀预告(详情页)

SkuInfoServiceImpl

   /**
    * 商品详情
    * @param skuId
    * @return
    */
   @Override
   public SkuItemVO item(Long skuId) throws Exception {
       SkuItemVO skuItemVO = new SkuItemVO();

       // 异步编排
       CompletableFuture<SkuInfoEntity> skuInfoFuture = CompletableFuture.supplyAsync(() -> {
           // 1.sku基本信息 pms_sku_info
           SkuInfoEntity skuInfo = getById(skuId);
           skuItemVO.setSkuInfo(skuInfo);
           return skuInfo;
       }, executor);

       CompletableFuture<Void> saleAttrFuture = skuInfoFuture.thenAcceptAsync((res) -> {
           // 2.spu销售属性组合
           List<SkuSaleAttrVO> saleAttrs = skuSaleAttrValueService.getSaleAttrsBySpuId(res.getSpuId());
           skuItemVO.setSaleAttrs(saleAttrs);
       }, executor);

       CompletableFuture<Void> descFuture = skuInfoFuture.thenAcceptAsync((res) -> {
           // 3.spu商品介绍
           SpuInfoDescEntity spuInfoDescEntity = spuInfoDescService.getById(res.getSpuId());
           skuItemVO.setSpuDesc(spuInfoDescEntity);
       }, executor);

       CompletableFuture<Void> baseAttrFuture = skuInfoFuture.thenAcceptAsync((res) -> {
           // 4.spu规格参数
           List<SpuAttrGroupVO> groupAttrs = attrGroupService.getAttrGroupWithAttrsBySpuId(
                   res.getCatalogId(), res.getSpuId());
           skuItemVO.setGroupAttrs(groupAttrs);
       }, executor);

       CompletableFuture<Void> imageFuture = CompletableFuture.runAsync(() -> {
           // 5.sku图片信息 pms_sku_images
           List<SkuImagesEntity> images = skuImagesService.getImagesBySkuId(skuId);
           skuItemVO.setImages(images);
       }, executor);

       CompletableFuture<Void> seckillFuture = CompletableFuture.runAsync(() -> {
           // 查询当前sku是否参与秒杀优惠
           R r = seckillFeignService.getSkuSeckillInfo(skuId);
           if (r.getCode() == 0) {
               SeckillSkuVO seckillSkuVO = r.getData("data", new TypeReference<SeckillSkuVO>() {
               });
               skuItemVO.setSeckillInfo(seckillSkuVO);
           } else {
               log.error("远程调用 gmall-seckill 获取商品秒杀信息失败");
           }
       }, executor);


       // 等待所有任务执行完
       CompletableFuture.allOf(saleAttrFuture, descFuture, baseAttrFuture, imageFuture, seckillFuture).get();

       // TODO 查询库存
       skuItemVO.setHasStock(true);

       return skuItemVO;
   }

item.html

<li th:if="${skuItemVO.seckillInfo!=null}" style="color: red">
	<span th:if="${#dates.createNow().getTime() >
		商品将会在[[${#dates.format(new java.util.Date(skuItemVO.seckillInfo.startTime), 'yyyy-MM-dd HH:mm:ss')}]]进行秒杀
	</span>
	<span th:if="${#dates.createNow().getTime() >= skuItemVO.seckillInfo.startTime && #dates.createNow().getTime() <= skuItemVO.seckillInfo.endTime}">
	    秒杀价:[[${#numbers.formatDecimal(skuItemVO.seckillInfo.seckillPrice,1,2)}]]
	</span>
</li>
<div class="box-btns-two" th:if="${skuItemVO.seckillInfo!=null && (#dates.createNow().getTime() >= skuItemVO.seckillInfo.startTime && #dates.createNow().getTime() <= skuItemVO.seckillInfo.endTime)}">
	<a href="#" id="toSeckill" th:attr="skuId=${skuItemVO.skuInfo.skuId},sessionId=${skuItemVO.seckillInfo.promotionSessionId},code=${skuItemVO.seckillInfo.randomCode}">立即抢购</a>
</div>
<div class="box-btns-two" th:if="${skuItemVO.seckillInfo==null || (#dates.createNow().getTime() < skuItemVO.seckillInfo.startTime || #dates.createNow().getTime() > skuItemVO.seckillInfo.endTime)}">
	<a href="#" id="addToCart" th:attr="skuId=${skuItemVO.skuInfo.skuId}">加入购物车</a>
</div>

<script>
// 立即抢购
	$('#toSeckill').click(function(){
		let isLogin = [[${session.loginUser!=null}]]
		if(isLogin){
			let killId = $(this).attr('sessionId') + "_" + $(this).attr('skuId')
			let code = $(this).attr('code')
			let num = $('#num').val()
			location.href = `http://seckill.gmall.com/seckill?killId=${killId}&key=${code}&num=${num}`
		} else {
			alert('秒杀商品,请先登录!')
			location.href = 'http://auth.gmall.com/login.html'
		}

		return false
	})
</script>

2.7.秒杀核心业务实现

2.7.1.核心流程

第26天-秒杀服务(秒杀系统设计与实现)_第5张图片

2.7.2.秒杀业务

SeckillController

/**
 * 秒杀
 * @param killId sessionId_skuId
 * @param key 商品随机码
 * @param num 秒杀数量
 * @return
 */
@GetMapping("/seckill")
public String seckill(@RequestParam("killId") String killId,
                      @RequestParam("key") String key,
                      @RequestParam("num") Integer num,
                      Model model){
    String orderSn = seckillService.seckill(killId, key, num);
    model.addAttribute("orderSn", orderSn);

    return "success";
}

SeckillServcieImpl

/**
 * 秒杀
 * @param killId 秒杀场次id_商品id
 * @param key 随机码
 * @param num 商品数量
 * @return
 */
@Override
public String seckill(String killId, String key, Integer num) {
    MemberVO memberVO = LoginInterceptor.threadLocal.get();

    // 获取当前秒杀商品信息
    BoundHashOperations<String, String, String> hashOps = redisTemplate.boundHashOps(SECKILL_SKU_CACHE_PREFIX);
    String json = hashOps.get(killId);
    if (StringUtils.isEmpty(json)) {
        return null;
    }

    SeckillSkuRedisTO redisTO = JsonUtils.jsonToPojo(json, SeckillSkuRedisTO.class);

    // 校验合法性
    // 1.校验时间
    long currentTime = System.currentTimeMillis();
    if (currentTime >= redisTO.getStartTime() && currentTime <= redisTO.getEndTime()) {
        // 2.校验随机码和商品id
        String randomCode = redisTO.getRandomCode();
        String skuId = redisTO.getPromotionSessionId() + "_" + redisTO.getSkuId();
        if (randomCode.equals(key) && skuId.equals(killId)) {
            // 3.校验购物数量
            if (num <= redisTO.getSeckillLimit().intValue()) {
                // 4.验证是否购买过
                // 幂等性,只要秒杀成功,就去redis占位 SETNX,userId_sessionId_skuId
                String redisKey = memberVO.getId() + "_" + skuId;
                Long ttl = redisTO.getEndTime() - redisTO.getStartTime();
                Boolean ifAbsent = redisTemplate.opsForValue()
                        .setIfAbsent(redisKey, num.toString(), ttl, TimeUnit.MILLISECONDS);
                if (ifAbsent) {
                    // 占位成功,说明没有购买过
                    RSemaphore semaphore = redissonClient.getSemaphore(SKU_STOCK_SEMAPHORE + randomCode);
                    // 快速尝试
                    boolean acquire = semaphore.tryAcquire(num);
                    if (acquire) {
                        // 秒杀成功,快速下单,发消息到MQ
                        String orderSn = IdWorker.getTimeId();
                        SeckillOrderTO seckillOrderTO = new SeckillOrderTO();
                        seckillOrderTO.setOrderSn(orderSn);
                        seckillOrderTO.setMemberId(memberVO.getId());
                        seckillOrderTO.setNum(num);
                        seckillOrderTO.setPromotionSessionId(redisTO.getPromotionSessionId());
                        seckillOrderTO.setSkuId(redisTO.getSkuId());
                        seckillOrderTO.setSeckillPrice(redisTO.getSeckillPrice());

                        rabbitTemplate.convertAndSend(SECKILL_ORDER_EVENT_EXCHANGE,
                                SECKILL_ORDER_QUEUE_ROUTING_KEY, seckillOrderTO);

                        return  orderSn;
                    }
                }
            }
        }
    }

    return null;
}

2.7.3.秒杀响应页面

  • 秒杀完成后,跳转到success页面,显示秒杀结果
  • 秒杀成功,则自动跳转到支付页面进行支付
  • 秒杀成功,订单服务消费秒杀消息,进行订单处理

success.html

   <div class="main">
       <div class="success-wrap">
            <div class="w" id="result">
               <div class="m succeed-box">
                   <div th:if="${orderSn!=null}" class="mc success-cont">
                        <h3 style="margin: 20px 0px">恭喜,秒杀成功,订单号:[[${orderSn}]]</h3>
                        <p>
                            <a th:href="'http://order.gmall.com/payOrder?orderSn='+${orderSn}" id="pay">
                                正在准备订单数据,请您耐心等待 <span id="payTime">10</span> 秒后进行支付!
                            </a>
                        </p>
                    </div>
                    <div th:if="${orderSn==null}" class="mc success-cont">
                        <h3 style="margin: 20px 0px">手气不佳,秒杀失败,下次再来!</h3>
                    </div>
                </div>
            </div>
        </div>
    </div>

    <script type="text/javascript">
        // 倒计时跳转支付
        $(function () {
            let href = $('#pay').attr('href')
            $('#pay').removeAttr('href')
            $('#pay').attr('disabled', true)
            let orderSn = [[${orderSn}]]
            let count = 10
            let countdown = setInterval(CountDown, 1000)
            function CountDown() {
                $("#payTime").text(count)
                if (count == 0) {
                    clearInterval(countdown)
                    $('#pay').text('支付订单')
                    $('#pay').attr('href', href)
                    $('#pay').removeAttr('disabled')
                }
                count--;
            }
        });
    </script>


3.定时任务

  • Quartz:http://www.quartz-scheduler.org/
  • Timer
  • Spring @Scheduled

3.1.cron表达式

语法: 秒 分 时 日 月 周 年 (年,Spring不支持)

http://www.quartz-scheduler.org/documentation/quartz-2.3.0/tutorials/crontrigger.html

第26天-秒杀服务(秒杀系统设计与实现)_第6张图片
特殊字符:

  1. , :枚举
    corn=“7,9,23 * * * * ?” :任意时刻的 7,9,23 秒启动这个任务
  2. - :范围
    corn=“7-20 * * * * ?” :任意时刻的7-20秒之间,每秒启动一次
  3. *:任意
    指定位置的任意时刻都可以
  4. / :步长
    corn=“7/5 * * * * ?” :第7秒启动,每5秒一次
    corn=“*/5 * * * * ?” :任意秒启动,每5秒一次
  5. ? :出现在日和周几的位置,为了防止日和周冲突,在日和周上如果要写通配符使用?
    corn=" * * * 1 * ?" :每月的1号,而且必须是周二,然后启动这个任务
  6. L :出现在日和周的位置
    Last:最后一个
    corn=" * * * ? * 3L" :每月的最后一个周二
  7. W
    Work Day:工作日
    cron=“* * * W * ?” :每个月的工作日触发
    cron=“* * * LW * ?” :每个月的最后一个工作日触发
  8. #:第几个
    cron=“* * * ? * 5#2” :每个月的第2个周4

3.2.cron示例

http://www.quartz-scheduler.org/documentation/quartz-2.3.0/tutorials/crontrigger.html

第26天-秒杀服务(秒杀系统设计与实现)_第7张图片

3.3.Spring Boot整合定时任务

@Slf4j
@Component
@EnableScheduling //开启定时任务
public class MyScheduled {
	/**
	 * 1.Spring中6位组成,不允许第7位的年
	 * 2.在周几的位置,1-7表示周一到周日,和quartz有区别(1-7表示周日到周六)
	 */
	@Scheduled(cron = "* * * ? * 5")
	public void hello(){
		log.info("hello ю ")
	}
}

注意:

  • Spring中6位组成,不允许第7位的年

  • 在周几的位置,1-7表示周一到周日,和quartz有区别(1-7表示周日到周六)

  • 解决定时任务不阻塞,默认是阻塞的

    • 可以让业务方法以异步的方式运行,自己提交到线程池
@Scheduled(cron = "* * * ? * 5")
public void hello(){
	log.info("hello ю ");
	//异步方式运行
	CompletableFuture.runAsync(() Ѷ ۏ {
		xxxServcie.method();
	});
}
    • 让定时任务异步执行
@Slf4j
@Component
@EnableAsync //开启异步任务
@EnableScheduling //开启定时任务
public class MyScheduled {
	/**
	 * 1.Spring中6位组成,不允许第7位的年
	 * 2.在周几的位置,1-7表示周一到周日,和quartz有区别(1-7表示周日到周六)
	 */
	@Async
	@Scheduled(cron = "* * * ? * 5")
	public void hello(){
		log.info("hello ... ");
	}
}

你可能感兴趣的:(谷粒商城,java)