mall项目总结

     /**
     * 
     * @param vo 上一个页面携带的数据
     * @param model
     * @param redirectAttributes
     * @return
     */
@PostMapping("/submitOrder")
public String submitOrder(OrderSubmitVo vo, Model model, RedirectAttributes redirectAttributes){
    //捕获异常
    try {
        SubmitOrderResponseVo responseVo = orderService.submitOrder(vo);
        //下单：去创建订单，验令牌，验价格，锁库存....
        System.out.println("订单提交的数据..." + vo);
        if (responseVo.getCode() == 0){
            //下单成功来到支付选择页
            model.addAttribute("submitOrderResponse", responseVo);
            return "pay";
        }else {
            //下单失败重定向到订单确认页
            String msg = "下单失败：";
            switch (responseVo.getCode()){
                case 1: msg+= "订单信息过期，请刷新再次提交"; break;
                case 2: msg+= "订单商品价格发生了变化，请刷新再次提交"; break;
                case 3: msg+= "库存锁定失败，商品库存不足"; break;
            }
            redirectAttributes.addFlashAttribute("msg", msg);
            return "redirect:http://order.gulimall.com/toTrade";
        }
    }catch (Exception e) {
        if (e instanceof NoStockException) {
            String message = ((NoStockException) e).getMessage();
            //抛出无库存异常后页面显示此异常信息NO_STOCK_EXCEPTION(21000, "商品库存不足");
            redirectAttributes.addFlashAttribute("msg", message);
        }
        //抛出任何异常后重定向会订单确认页
        return "redirect:http://order.gulimall.com/toTrade";
    }
}

 /**
     * 下单
     * 加入统一事务
     * @param vo
     * @return
     * @Transactional 本地事务，在分布式系统下，只能控制自己的回滚，控制不了其他服务的回滚
     * (isolation = Isolation.REPEATABLE_READ)默认隔离级别
     * ->分布式事务: 最大原因是网络问题+分布式机器
     *
     */
//@GlobalTransactional 高并发 此注解会加很多全局锁，导致下单只能等别人先下完单才能下，高并发环境不可取
    @Transactional
    @Override
    public SubmitOrderResponseVo submitOrder(OrderSubmitVo vo) {
        submitVoThreadLocal.set(vo);
        SubmitOrderResponseVo responseVo = new SubmitOrderResponseVo();
        //从拦截器里获取用户信息
        MemberRespVo memberRespVo = LoginUserInterceptor.loginUser.get();
        responseVo.setCode(0);
        //1、验证令牌【令牌的对比和删除必须保证原子性】
        //0令牌失败 - 1删除成功(校验成功)
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        String orderToken = vo.getOrderToken();
        //原子验证令牌和删除令牌
        Long result = redisTemplate.execute(
                //脚本返回类型->0,1
                new DefaultRedisScript<Long>(script, Long.class),
                //将缓存中将要比对的key转为集合
                Arrays.asList(OrderConstant.USER_ORDER_TOKEN_PREFIX + memberRespVo.getId()),
                //传入要校验的值
                orderToken);
        if (result == 0L) {
            //验证失败，设置错误状态码为1，key过期等情况
            responseVo.setCode(1);
            return responseVo;
        } else {
            //验证成功
            //下单：去创建订单，验令牌，验价格，锁库存....
            //1、创建订单，订单项等信息
            OrderCreateTo order = createOrder();
            // todo 观察者模式: 发布商品下单事件
            ApplicationContextHolder.getInstance().publishEvent(new OrderCreateEvent(this, order));
            //2、验价，拿到应付金额与页面提交的金额进行校验
            BigDecimal payAmount = order.getOrder().getPayAmount();
            BigDecimal payPrice = vo.getPayPrice();
            //两者相减的绝对值小于0.01就算校验通过
            if (Math.abs(payAmount.subtract(payPrice).doubleValue()) < 0.01){
                //校验通过
                //TODO 3、保存订单
                saveOrder(order);
                //4、库存锁定，这样能避免库存不足等现象发生
                //只要有异常就回滚订单数据(订单号，所有订单项（skuId，skuName，num）)
                WareSkuLockVo lockVo = new WareSkuLockVo();
                //设置指定库存的订单号
                lockVo.setOrderSn(order.getOrder().getOrderSn());
                List<OrderItemVo> locks = order.getOrderItems().stream().map(item -> {
                    OrderItemVo orderItemVo = new OrderItemVo();
                    //订单已经保存了，可以直接设置
                    orderItemVo.setSkuId(item.getSkuId());
                    orderItemVo.setCount(item.getSkuQuantity());
                    orderItemVo.setTitle(item.getSkuName());
                    return orderItemVo;
                }).collect(Collectors.toList());
                //锁定订单项数据
                lockVo.setLocks(locks);
                //todo 4、远程锁库存
                //库存锁定成功了，但是网络原因超时了，订单回滚，库存不回滚
                //为了保证高并发，库存服务自己回滚，可以发消息给库存服务
                //库存服务本身也可以使用自动解锁模式->消息队列
                R r = wmsFeignService.orderLockStock(lockVo);
                //判断远程调用是否成功
                if (r.getCode() == 0){
                    //远程调用成功，锁成功了
                    responseVo.setOrder(order.getOrder());
 //todo 5、远程扣减积分  出异常 引入seata后业务标注@GlobalTransactional订单回滚，库存回滚
					// int i = 10/0;//不标注@GlobalTransactional 订单回滚，库存不回滚
                    //todo 订单创建成功发送消息给MQ
                    rabbitTemplate.convertAndSend("order-event-exchange", "order.create.order", order.getOrder());
                    return responseVo;
                }else {
                    //远程调用失败，锁定失败
                    //锁定失败
                    String msg = (String) r.get("msg");
                    //抛出异常就不能设置错误状态码了
                    throw new NoStockException(msg);
//                    responseVo.setCode(3);
//                    return responseVo;
                }
            }else {
                //校验失败
                responseVo.setCode(2);
                return responseVo;
            }
        }
    }

/**
     * 创建订单聚合方法，含构建订单和所有订单项
     * @return
     */
    private OrderCreateTo createOrder() {
        //获取当前登录的用户信息
        MemberRespVo memberRespVo = LoginUserInterceptor.loginUser.get();
        OrderCreateTo createTo = new OrderCreateTo();
        //1、todo 生成订单号(使用雪花算法根据用户id创建订单号)
//        String orderSn = IdWorker.getTimeId();
        String orderSn = SnowflakeIdUtil.nextIdStrByService(memberRespVo.getId().toString());
        //创建订单
        OrderEntity orderEntity = buildOrder(orderSn);
        //2、获取到所有的订单项
        List<OrderItemEntity> itemEntities = buildOrderItems(orderSn);
        //3、验价，计算价格、积分等相关
        computePrice(orderEntity, itemEntities);
//        createTo.setOrderItems(itemEntities);
//        createTo.setOrder(orderEntity);
        // 构建订单聚合根
        OrderCreateTo order = createTo.builder()
                .order(orderEntity)
                .orderItems(itemEntities)
                .fare(orderEntity.getFreightAmount())
                .payPrice(orderEntity.getPayAmount())
                .build();

        return order;
    }

/**
 * 获取当前订单的支付信息
 * @param orderSn
 * @return
 */
@Override
public PayVo getOrderPay(String orderSn) {
    PayVo payVo = new PayVo();
    OrderEntity entity = this.getOrderByOrderSn(orderSn);

    //保留2位小数，有小数就想上取值
    BigDecimal bigDecimal = entity.getTotalAmount().setScale(2, BigDecimal.ROUND_UP);
    payVo.setTotal_amount(bigDecimal.toString());
    payVo.setOut_trade_no(entity.getOrderSn());

    List<OrderItemEntity> itemEntities = orderItemService.list(new QueryWrapper<OrderItemEntity>().eq("order_sn", orderSn));
    OrderItemEntity item = itemEntities.get(0);
    payVo.setSubject(item.getSkuName());
    payVo.setBody(item.getSkuAttrsVals());

    return payVo;
}

 /**
     * 1、将支付页让浏览器展示
     * 2、支付成功以后，我们要跳到用户的订单列表页
     * @param orderSn
     * @return
     * @throws AlipayApiException
     */
    @ResponseBody
    @GetMapping(value = "/payOrder", produces = "text/html")
    public String payOrder(@RequestParam("orderSn") String orderSn) throws AlipayApiException {


        PayVo payVo = orderService.getOrderPay(orderSn);
        //返回的是一个页面，将此页面直接交给浏览器就行
        String pay = alipayTemplate.pay(payVo);
//        System.out.println(pay);
        return pay;
    }

public  String pay(PayVo vo) throws AlipayApiException {

    //AlipayClient alipayClient = new DefaultAlipayClient(AlipayTemplate.gatewayUrl, AlipayTemplate.app_id, AlipayTemplate.merchant_private_key, "json", AlipayTemplate.charset, AlipayTemplate.alipay_public_key, AlipayTemplate.sign_type);
    //1、根据支付宝的配置生成一个支付客户端
    AlipayClient alipayClient = new DefaultAlipayClient(gatewayUrl,
            app_id, merchant_private_key, "json",
            charset, alipay_public_key, sign_type);

    //2、创建一个支付请求 //设置请求参数
    AlipayTradePagePayRequest alipayRequest = new AlipayTradePagePayRequest();
    alipayRequest.setReturnUrl(return_url);
    alipayRequest.setNotifyUrl(notify_url);

    //商户订单号，商户网站订单系统中唯一订单号，必填
    String out_trade_no = vo.getOut_trade_no();
    //付款金额，必填
    String total_amount = vo.getTotal_amount();
    //订单名称，必填
    String subject = vo.getSubject();
    //商品描述，可空
    String body = vo.getBody();

    alipayRequest.setBizContent("{\"out_trade_no\":\""+ out_trade_no +"\","
            + "\"total_amount\":\""+ total_amount +"\","
            + "\"subject\":\""+ subject +"\","
            + "\"body\":\""+ body +"\","
            + "\"timeout_express\":\""+timeout+"\","
            + "\"product_code\":\"FAST_INSTANT_TRADE_PAY\"}");

    String result = alipayClient.pageExecute(alipayRequest).getBody();

    //会收到支付宝的响应，响应的是一个页面，只要浏览器显示这个页面，就会自动来到支付宝的收银台页面
    System.out.println("支付宝的响应："+result);

    return result;

}

/**
     * 处理支付宝的支付结果
     * @param vo
     * @return
     */
    @Override
    public String handlePayResult(PayAsyncVo vo) {
        //1、保存交易流水
        PaymentInfoEntity infoEntity = new PaymentInfoEntity();
        infoEntity.setAlipayTradeNo(vo.getTrade_no());
        infoEntity.setOrderSn(vo.getOut_trade_no());
        infoEntity.setPaymentStatus(vo.getTrade_status());
        infoEntity.setCallbackTime(vo.getNotify_time());

        paymentInfoService.save(infoEntity);

        //2、修改订单的状态信息
        if (vo.getTrade_status().equals("TRADE_SUCCESS") || vo.getTrade_status().equals("TRADE_FINISHED")){
            //支付成功状态
            String outTradeNo = vo.getOut_trade_no();
            this.baseMapper.updateOrderStatus(outTradeNo, OrderStatusEnum.PAYED.getCode());
        }

        return "success";
    }

 /**
     * 支付成功异步通知
     * @param vo
     * @param request
     * @return
     */
    @PostMapping("/paid/notify")
    public String handleAlipaid(PayAsyncVo vo, HttpServletRequest request) throws Exception {

        //只要我们收到了支付宝给我们异步的通知，告诉我们订单支付成功，返回success，支付宝就再也不通知
//        Map<String, String[]> map = request.getParameterMap();
//        for (String key : map.keySet()) {
//            String value = request.getParameter(key);
//            System.out.println("参数名："+key+"==>参数值："+ value);
//        }
//        System.out.println("支付宝通知到位了...数据："+map);
        //验签
        Map<String,String> params = new HashMap<String,String>();
        Map<String,String[]> requestParams = request.getParameterMap();
        for (Iterator<String> iter = requestParams.keySet().iterator(); iter.hasNext();) {
            String name = (String) iter.next();
            String[] values = (String[]) requestParams.get(name);
            String valueStr = "";
            for (int i = 0; i < values.length; i++) {
                valueStr = (i == values.length - 1) ? valueStr + values[i]
                        : valueStr + values[i] + ",";
            }
            //乱码解决，这段代码在出现乱码时使用
//            valueStr = new String(valueStr.getBytes("ISO-8859-1"), "utf-8");
            params.put(name, valueStr);
        }

        boolean signVerified = AlipaySignature.rsaCheckV1(params, alipayTemplate.getAlipay_public_key(), alipayTemplate.getCharset(), alipayTemplate.getSign_type()); //
        if (signVerified){
            //验签成功
            System.out.println("签名验证成功.....");
            String result = orderService.handlePayResult(vo);
            return result;
        }else {
            System.out.println("签名验证失败.....");
            return "error";
        }
    }

private  String return_url = "http://member.gulimall.com/memberOrder.html";

@GetMapping("/memberOrder.html")
public String memberOrderPage(@RequestParam(value = "pageNum", defaultValue = "1") Integer pageNum,
                              Model model) {

    //查出当前登录的用户的所有订单列表数据
    Map<String, Object> page = new HashMap<>();
    page.put("page", pageNum.toString());
    R r = orderFeignService.listWithItem(page);
    System.out.println(JSON.toJSONString(r));
    model.addAttribute("orders", r);

    return "orderList";
}

/**
 * todo 远程调用都要全用@POSTMapping+@RequestBody(请求体只支持post)
 * 分页查询当前登录用户的所有订单
 * @param params
 * @return
 */
@PostMapping("/listWithItem")
//@RequiresPermissions("order:order:list")
public R listWithItem(@RequestBody Map<String, Object> params){
    PageUtils page = orderService.queryPageWithItem(params);

    return R.ok().put("page", page);
}

@Override
public PageUtils queryPageWithItem(Map<String, Object> params) {
    //获取当前登录的用户信息
    MemberRespVo memberRespVo = LoginUserInterceptor.loginUser.get();

    IPage<OrderEntity> page = this.page(
            new Query<OrderEntity>().getPage(params),                                            //根据id降序
            new QueryWrapper<OrderEntity>().eq("member_id", memberRespVo.getId()).orderByDesc("id")
    );

    List<OrderEntity> orderEntities = page.getRecords().stream().map(order -> {
        //封装订单项到订单
        List<OrderItemEntity> itemEntities = orderItemService.list(new QueryWrapper<OrderItemEntity>().eq("order_sn", order.getOrderSn()));
        order.setItemEntities(itemEntities);
        return order;
    }).collect(Collectors.toList());

    page.setRecords(orderEntities);

    return new PageUtils(page);
}

/**
     * OrderConfirmVo = [List<MemberAddressVo> address, //收货地址， 
     *                  List<OrderItemVo> items,      //所有选中的购物项
     *                 Integer integration,         //积分...
     *                 Map<Long, Boolean> stocks, //库存信息
     *                 String orderToken        //防重令牌]
*/
@GetMapping("/toTrade")
public String toTrade(Model model, HttpServletRequest request) throws ExecutionException, InterruptedException {
    OrderConfirmVo confirmVo = orderService.confirmOrder();
    model.addAttribute("orderConfirmData", confirmVo);
    //展示订单确认的数据(页面跳转)
    return "confirm";
}

/**
 * 订单确认页返回需要用到的数据
 * @return
 */
@Override
public OrderConfirmVo confirmOrder() throws ExecutionException, InterruptedException {
    OrderConfirmVo confirmVo = new OrderConfirmVo();
    //从拦截器里获取用户信息
    MemberRespVo memberRespVo = LoginUserInterceptor.loginUser.get();
    System.out.println("主线程...." + Thread.currentThread().getId());

    //获取原来请求上下文请求属性
    RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
    //进行异步编排
    CompletableFuture<Void> getAddressFuture = CompletableFuture.runAsync(() -> {
        //1、远程查询所有的收货地址列表
        System.out.println("member线程...." + Thread.currentThread().getId());
        //在Feign异步调用前将请求上下文进行共享操作(之前的请求数据都来共享每一个线程)
        RequestContextHolder.setRequestAttributes(requestAttributes);
        List<MemberAddressVo> address = memberFeignService.getAddress(memberRespVo.getId());
        confirmVo.setAddress(address);
    }, executor);

    CompletableFuture<Void> cartFuture = CompletableFuture.runAsync(() -> {
        //2、远程查询购物车所有选中的购物项
        System.out.println("cart线程...." + Thread.currentThread().getId());
        //在Feign异步调用前将请求上下文进行共享操作
        RequestContextHolder.setRequestAttributes(requestAttributes);
        List<OrderItemVo> items = cartFeignService.currentUserCartItems();
        confirmVo.setItems(items);
        //feign在远程调用之前要构造请求，调用很多的拦截器
        //for(RequestInterceptor interceptor:requestInterceptors)
    }, executor).thenRunAsync(() -> {
        List<OrderItemVo> items = confirmVo.getItems();
        List<Long> skuIds = items.stream().map(item -> item.getSkuId()).collect(Collectors.toList());
        //远程查询库存
        R r = wmsFeignService.getSkusHasStock(skuIds);
        List<SkuStockVo> data = r.getData(new TypeReference<List<SkuStockVo>>() {
        });
        if (data != null) {
            // Map<SkuId, hasStock> map
            Map<Long, Boolean> map = data.stream().collect(Collectors.toMap(SkuStockVo::getSkuId, SkuStockVo::getHasStock));
            // Map<Long, Boolean> stocks;
            confirmVo.setStocks(map);
        }
    }, executor);

    //3、查询用户积分
    Integer integration = memberRespVo.getIntegration();
    confirmVo.setIntegration(integration);

    //4、其他数据自动计算

    //todo 5、防重令牌
    String token = UUID.randomUUID().toString().replace("-", "");
    //给服务器一个令牌
    redisTemplate.opsForValue().set(OrderConstant.USER_ORDER_TOKEN_PREFIX + memberRespVo.getId(), token, 30, TimeUnit.MINUTES);
    //给页面一个令牌
    confirmVo.setOrderToken(token);
    CompletableFuture.allOf(getAddressFuture, cartFuture).get();
    return confirmVo;
}

//查询sku是否有库存
    @PostMapping("/hasstock")
    public R getSkusHasStock(@RequestBody List<Long> skuIds) {
        //sku_id stock
        List<SkuHasStockVo> vos = wareSkuService.getSkusHasStock(skuIds);
        return R.ok().setData(vos);
    }

@Override
public List<SkuHasStockVo> getSkusHasStock(List<Long> skuIds) {

    List<SkuHasStockVo> collect = skuIds.stream().map(skuId -> {
        SkuHasStockVo vo = new SkuHasStockVo();
        //查询当前sku的总库存量
        //SELECT SUM(stock-stock_locked) FROM `wms_ware_sku` WHERE sku_id=1
        //获取查询到的库存记录数
        Long count = baseMapper.getSkuStock(skuId);
        vo.setSkuId(skuId);
        //记录数大于0表示有库存
        vo.setHasStock(count == null ? false : count > 0);
        return vo;
    }).collect(Collectors.toList());
    return collect;
}

@RequestMapping("/lock/order")
public R orderLockStock(@RequestBody WareSkuLockVo vo){
    Boolean lockStock = null;
    try {
        lockStock = wareSkuService.orderLockStock(vo);
        return R.ok();
    } catch (NoStockException e) {
        //通过测试发现商品库存不足将会在页面显示以下错误信息(http://order.gulimall.com/toTrade)
        return R.error(BizCodeEnum.NO_STOCK_EXCEPTION.getCode(), BizCodeEnum.NO_STOCK_EXCEPTION.getMsg());
    }
}

/**
 * 为某个订单锁定库存
 * 加入统一事务
 * (rollbackFor = NoStockException.class )
 * 默认只要是运行时异常都会回滚
 * 库存解锁的场景
 * 1）、下订单成功，订单过期没有支付被系统自动取消、被用户手动取消，都要解锁库存
 * 2）、下订单成功，库存锁定成功，接下来的业务调用失败，导致订单回滚
 * 之前锁定的库存就要自动解锁
 * @param vo
 * @return
 */
@Transactional
@Override
public Boolean orderLockStock(WareSkuLockVo vo) {
    /**
     * 保存库存工作单的详情的两张表
     * 追溯
     */
    WareOrderTaskEntity taskEntity = new WareOrderTaskEntity();
    taskEntity.setOrderSn(vo.getOrderSn());
    wareOrderTaskService.save(taskEntity);
    //按照下单的收货地址，找到一个就近仓库，锁定库存
    //1、找到每个商品在哪个仓库都有库存
    List<OrderItemVo> locks = vo.getLocks();
    List<SkuWareHasStock> collect = locks.stream().map(item -> {
        SkuWareHasStock stock = new SkuWareHasStock();
        Long skuId = item.getSkuId();
        stock.setSkuId(skuId);
        stock.setNum(item.getCount());
        //查询这个商品在哪里有库存
        List<Long> wareIds = wareSkuDao.listWareIdHasSkuStock(skuId);
        stock.setWareIds(wareIds);
        return stock;
    }).collect(Collectors.toList());
    //2、锁定库存
    for (SkuWareHasStock hasStock : collect) {
        Boolean skuStocked = false;//lock_status=0
        Long skuId = hasStock.getSkuId();
        List<Long> wareIds = hasStock.getWareIds();
        if (wareIds == null || wareIds.size() == 0) {
            //没有任何仓库有这个商品的库存
            throw new NoStockException(skuId);
        }
        //1、如果每一个商品都锁定成功，将当前商品锁定了几件的工作单记录发给MQ
        //2、锁定失败。前面保存的工作单信息就回滚了，即使要解锁记录，由于去数据库查不到id，所以就不用解锁
        //  log:skuId-num-ware: 1:1-2-1(v) 2:2-1-3(v) 3:3-1-1(x)
        //  既然锁成功了就应该扣减，之后就应该解锁，因为3记录锁失败，1,2记录就回滚了，相当于工作单回滚了，库存没回滚库存扣减
        // 只传id工作单是不知道当时库存锁了多少个
        for (Long wareId : wareIds) {
            //成功就返回1，否则就是0
            Long count = wareSkuDao.lockSkuStock(skuId, wareId, hasStock.getNum());
            if (count == 1) {
                //锁成功了==>lock_status=1
                skuStocked = true;
                //退出当前循环
                //todo 告诉MQ库存锁定成功
                WareOrderTaskDetailEntity detailEntity = new WareOrderTaskDetailEntity(null, skuId, "", hasStock.getNum(), taskEntity.getId(), wareId, 1);
                //保存工作单详情
                wareOrderTaskDetailService.save(detailEntity);
                StockLockedTo lockedTo = new StockLockedTo();
                //属性拷贝到to
                StockDetailTo stockDetailTo = new StockDetailTo();
                BeanUtils.copyProperties(detailEntity, stockDetailTo);
                //只传工作单id还不够，防止回滚以后找不到数据
                lockedTo.setId(taskEntity.getId());
                lockedTo.setDetailTo(stockDetailTo);
                //发送锁定库存消息；提交订单后，出现异常，订单回滚，库存不回滚，延时队列有2个任务等待死信时间结束后发送消息
                rabbitTemplate.convertAndSend("stock-event-exchange", "stock.locked", lockedTo);
                break;
            } else {
                //当前仓库锁失败了，重试下一个仓库
            }
        }
        if (skuStocked == false) {
            //当前商品所有仓库都没有锁住
            throw new NoStockException(skuId);
        }
    }
    //3、肯定全部都是锁定成功过的
    return true;
}

//查询这个商品在哪里有库存
//com.klaus.gulimall.ware.dao.WareSkuDao#listWareIdHasSkuStock
List<Long> wareIds = wareSkuDao.listWareIdHasSkuStock(skuId);

//库存锁定成功就返回1，否则就是0
//com.klaus.gulimall.ware.dao.WareSkuDao#lockSkuStock
Long count = wareSkuDao.lockSkuStock(skuId, wareId, hasStock.getNum());

/**
 * 1、库存自动解锁
 *      下订单成功，库存锁定成功，接下来的业务调用失败，导致订单回滚。之前锁定的库存就要自动解锁
 * 2、下订单失败
 * 锁库存失败
 * 只要解锁库存的消息失败，一定要告诉服务器解锁失败
 * @param to
 * @param message
 */
@Override
public void unlockStock(StockLockedTo to) {
    StockDetailTo detail = to.getDetailTo();
    Long detailId = detail.getId();
    //1、查询数据库关于这个订单的锁定库存信息
    // 有： 证明库存锁定成功了
    //     解锁：订单情况
    //          1、没有这个订单，必须解锁
    //          2、有这个订单，就不是解锁库存
    //                  订单状态： 已取消：解锁库存
    //                           没取消：不能接受
    // 没有：库存锁定失败了，库存回滚了。这种情况无需解锁
    WareOrderTaskDetailEntity taskDetailEntity = wareOrderTaskDetailService.getById(detailId);
    if (taskDetailEntity != null) {
        //有工作详情单，但只能证明库存服务在锁库存的时候锁成功后返回出去的，
        // 要看整个订单有没有下单成功，如果订单远程调用的其他服务崩了导致订单回滚，这跟库存服务没有关系，直接解锁是有问题的，因为订单都没有
        //解锁
        Long id = to.getId();//库存工作单的id
        //获取订单状态
        WareOrderTaskEntity taskEntity = wareOrderTaskService.getById(id);
        String orderSn = taskEntity.getOrderSn();
        //根据订单号查询订单的状态
        R r = orderFeignService.getOrderStatus(orderSn);
        if (r.getCode() == 0) {
            //远程调用成功，订单数据返回成功
            OrderVo data = r.getData(new TypeReference<OrderVo>() {
            });
            if (data == null || data.getStatus() == 4) {
                //订单已经被取消或订单不存在，才能解锁库存
                //问题：订单服务由于网络等原因迟迟没有将订单解锁(data.getStatus()==0)导致库存永远释放不了锁
                if (taskDetailEntity.getLockStatus() == 1){
                    //当前库存工作单详情，状态为1 已锁定但是未解锁才可以解锁
                    unLockStock(detail.getSkuId(), detail.getWareId(), detail.getSkuNum(), detailId);
                }
            }
        } else {
            //远程调用失败直接抛异常
            throw new RuntimeException("远程服务失败");
        }
    } else {
        //无需解锁
    }
}

@GetMapping("/status/{orderSn}")
public R getOrderStatus(@PathVariable("orderSn") String orderSn){
    OrderEntity orderEntity = orderService.getOrderByOrderSn(orderSn);
    return R.ok().setData(orderEntity);
}

@Override
public OrderEntity getOrderByOrderSn(String orderSn) {
    OrderEntity orderEntity = this.getOne(new QueryWrapper<OrderEntity>().eq("order_sn", orderSn));
    return orderEntity;
}

/**
* 防止订单服务卡顿，导致更改订单状态的操作无法完成以及更改的mq消息没有得到执行，解锁库存的消息优先到期，扫描订单状态是新建状态，就会什么都不做
 * 导致卡顿的订单永远不能解锁库存
 * @param orderTo
 * 加入统一事务
 */
@Transactional
@Override
public void unlockStock(OrderTo orderTo) {
    String orderSn = orderTo.getOrderSn();
    //查一下最新库存的状态，防止重复解锁库存
    WareOrderTaskEntity task = wareOrderTaskService.getOrderTaskByOrderSn(orderSn);
    Long id = task.getId();
    //按照工作单找到所有 没有解锁的库存，进行解锁
    List<WareOrderTaskDetailEntity> detailEntities = wareOrderTaskDetailService.list(new QueryWrapper<WareOrderTaskDetailEntity>().
            eq("task_id", id).
            //新建的还没被解锁的库存
            eq("lock_status", 1));
    for (WareOrderTaskDetailEntity entity : detailEntities) {
        //此解锁方式可以解决高并发问题和整个系统的异构(两个服务开发语言不同。如java，php)
        unLockStock(entity.getSkuId(), entity.getWareId(), entity.getSkuNum(), entity.getId());
    }
}

private void unLockStock(Long skuId, Long wareId, Integer num, Long taskDetailId) {
    //库存解锁
    wareSkuDao.unLockStock(skuId, wareId, num);
    //更新库存工作单的状态
    WareOrderTaskDetailEntity entity = new WareOrderTaskDetailEntity();
    entity.setId(taskDetailId);
    entity.setLockStatus(2);//变为已解锁
    wareOrderTaskDetailService.updateById(entity);
}

/**
 * 处理支付宝的支付结果
 * @param vo
 * @return
 */
@Override
public String handlePayResult(PayAsyncVo vo) {
    //1、保存交易流水
    PaymentInfoEntity infoEntity = new PaymentInfoEntity();
    infoEntity.setAlipayTradeNo(vo.getTrade_no());
    infoEntity.setOrderSn(vo.getOut_trade_no());
    infoEntity.setPaymentStatus(vo.getTrade_status());
    infoEntity.setCallbackTime(vo.getNotify_time());

    paymentInfoService.save(infoEntity);

    //2、修改订单的状态信息
    if (vo.getTrade_status().equals("TRADE_SUCCESS") || vo.getTrade_status().equals("TRADE_FINISHED")){
        //支付成功状态
        String outTradeNo = vo.getOut_trade_no();
        this.baseMapper.updateOrderStatus(outTradeNo, OrderStatusEnum.PAYED.getCode());
    }

    return "success";
}

@Bean
public Queue orderDelayQueue(){

    Map<String, Object> arguments = new HashMap<>();
    /**
     * x-dead-letter-exchange: order-event-exchange
     * x-dead-letter-routing-key: order.release.order
     * x-message-ttl: 60000
     */
    arguments.put("x-dead-letter-exchange", "order-event-exchange");
    arguments.put("x-dead-letter-routing-key", "order.release.order");
    arguments.put("x-message-ttl", 60000);

    //String name, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
    Queue queue = new Queue("order.delay.queue", true, false, false, arguments);
    return queue;
}
@Bean
public Exchange orderEventExchange(){
    //String name, boolean durable, boolean autoDelete, Map<String, Object> arguments
    return new TopicExchange("order-event-exchange", true, false);
}
@Bean
public Binding orderCreateOrderBinding(){
   //String destination, Binding.DestinationType destinationType, String exchange, String routingKey, Map<String, Object> arguments
   return new Binding("order.delay.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.create.order", null);
}

@Transactional
@Override
public SubmitOrderResponseVo submitOrder(OrderSubmitVo vo) {
    ...
    //todo 订单创建成功发送消息给MQ
    rabbitTemplate.convertAndSend("order-event-exchange", "order.create.order", order.getOrder());
	...
}

@Bean
public Exchange stockEventExchange(){
    return new TopicExchange("stock-event-exchange", true, false);
}
@Bean
public Queue stockDelayQueue(){
    Map<String, Object> arguments = new HashMap<>();
    arguments.put("x-dead-letter-exchange", "stock-event-exchange");
    arguments.put("x-dead-letter-routing-key", "stock.release");
    arguments.put("x-message-ttl", 120000);

    //String name, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
    return new Queue("stock.delay.queue", true, false, false, arguments);
}

@Bean
public Binding stockLockedBinding(){
    //String destination, Binding.DestinationType destinationType, String exchange, String routingKey, Map<String, Object> arguments
    return new Binding("stock.delay.queue",
            Binding.DestinationType.QUEUE,
            "stock-event-exchange",
            "stock.locked", null);
}

@Transactional
@Override
public Boolean orderLockStock(WareSkuLockVo vo) {
    ...
 //发送锁定库存消息；提交订单后，出现异常，订单回滚，库存不回滚，延时队列有2个任务等待死信时间结束后发送消息
  rabbitTemplate.convertAndSend("stock-event-exchange", "stock.locked", lockedTo);
  ...
}

	@Bean
    public Queue orderReleaseOrderQueue(){
        Queue queue = new Queue("order.release.order.queue", true, false, false);
        return queue;
    }
 	@Bean
    public Exchange orderEventExchange(){
        //String name, boolean durable, boolean autoDelete, Map<String, Object> arguments
        return new TopicExchange("order-event-exchange", true, false);
    }
	@Bean
    public Binding orderReleaseOrderBinding(){
        return new Binding("order.release.order.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.release.order", null);
    }

/**
 * 订单释放(关单)监听器
 */
@Service
@RabbitListener(queues = "order.release.order.queue")
public class OrderCloseListener {

    @Autowired
    OrderService orderService;

    @RabbitHandler
    public void listener(OrderEntity entity, Channel channel, Message message) throws IOException {
        //等待死信时间到后收到订单消息
        System.out.println("收到过期的订单信息，准备关闭订单"+entity.getOrderSn());
        try {
            orderService.closeOrder(entity);
            //手动调用支付宝收单

            //签收订单
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (Exception e) {

            channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
        }
    }
}

/**
   * 关单方法，将订单新建(待付款)状态设置为已取消状态并发送消息给MQ确认关单完成
   * @param entity
*/
@Override
public void closeOrder(OrderEntity entity) {
    //查询当前这个订单的最新状态
    //将要发送的消息队列实体(释放订单服务前)
    OrderEntity orderEntity = this.getById(entity.getId());
    //status=0
    if (orderEntity.getStatus() == OrderStatusEnum.CREATE_NEW.getCode()){
        //在待付款状态下才关单(消息队列的实体有可能过期了，所以创建新实体)
        OrderEntity update = new OrderEntity();
        update.setId(entity.getId());
        // status=4
        update.setStatus(OrderStatusEnum.CANCLED.getCode());
        this.updateById(update);
        OrderTo orderTo = new OrderTo();
        BeanUtils.copyProperties(orderEntity, orderTo);
        try {
            //todo 保证消息一定会发送出去，每一个消息都可以做好日志记录（给数据库保存每一个消息的详细信息）
            //todo 定期扫描数据库将失败的消息再发送一遍；
            //只要解锁成功了就【立即】发消息给MQ
            rabbitTemplate.convertAndSend("order-event-exchange", "order.release.other", orderTo);
        } catch (Exception e) {
            //todo 将没发送成功的消息进行重试发送 （while）
        }
    }
}

@Bean
public Exchange stockEventExchange(){
    return new TopicExchange("stock-event-exchange", true, false);
}
@Bean
public Queue stockReleaseStockQueue(){
    return new Queue("stock.release.stock.queue", true, false, false);
}
@Bean
public Binding stockReleaseBinding(){
    return new Binding("stock.release.stock.queue",
                Binding.DestinationType.QUEUE,
                "stock-event-exchange",
                "stock.release.#", null);
}

/**
 * 监听库存解锁队列
 */
@RabbitListener(queues = "stock.release.stock.queue")
@Service
public class StockReleaseListener {

    @Autowired
    WareSkuService wareSkuService;

	/**
     * 订单正常关闭(订单服务正常运行)，需要解锁已经占用的库存
     * @param to 库存工作单(含工作单详情)
     */
    @RabbitHandler
    public void handleStockLockedRelease(StockLockedTo to, Message message, Channel channel) throws IOException {
        System.out.println("收到解锁库存的消息...");
        try {
            //当前消息是否被第二次及以后(重新)派发过来了
//            Boolean redelivered = message.getMessageProperties().getRedelivered();
            wareSkuService.unlockStock(to);
            //只要解锁成功了，就签收消息
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (Exception e) {
            //有任何异常直接拒绝签收;消息拒绝以后重新放到队列里面，让别人继续消费解锁
            channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
        }
    }
}

@Override
public void unlockStock(StockLockedTo to) {
    ...
    //问题：订单服务由于网络等原因迟迟没有将订单解锁(data.getStatus()==0)导致库存永远释放不了锁
    if (taskDetailEntity.getLockStatus() == 1){
    //当前库存工作单详情，状态为1 已锁定但是未解锁才可以解锁
    unLockStock(detail.getSkuId(), detail.getWareId(), detail.getSkuNum(), detailId);
	...
}

/**
 * 监听库存解锁队列
 */
@RabbitListener(queues = "stock.release.stock.queue")
@Service
public class StockReleaseListener {

    @Autowired
    WareSkuService wareSkuService;

    /**
     * 订单异常关闭(订单服务发送运行时异常或宕机)，需要解锁已经占用的库存
     * 如果库存锁定成功，订单服务全部炸了，订单都没有创建好，就必须有自动解锁功能
     * @param orderTo 完整订单信息
     * @param message
     * @param channel
     * @throws IOException
     */
    @RabbitHandler
    public void handleOrderCloseRelease(OrderTo orderTo, Message message, Channel channel) throws IOException {
        System.out.println("订单关闭准备解锁库存....");
        try {
            wareSkuService.unlockStock(orderTo);
            //只要解锁成功了，就签收消息
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (Exception e) {
            //有任何异常直接拒绝签收;消息拒绝以后重新放到队列里面，让别人继续消费解锁
            channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
        }
    }
}

/**
 * 防止订单服务卡顿，导致更改订单状态的操作无法完成以及更改的mq消息没有得到执行，解锁库存的消息优先到期，扫描订单状态是新建状态，就会什么都不做
 * 导致卡顿的订单永远不能解锁库存
 * @param orderTo
 * 加入统一事务
 */
@Transactional
@Override
public void unlockStock(OrderTo orderTo) {
    String orderSn = orderTo.getOrderSn();
    //查一下最新库存的状态，防止重复解锁库存
    WareOrderTaskEntity task = wareOrderTaskService.getOrderTaskByOrderSn(orderSn);
    Long id = task.getId();
    //按照工作单找到所有 没有解锁的库存，进行解锁
    List<WareOrderTaskDetailEntity> detailEntities = wareOrderTaskDetailService.list(new QueryWrapper<WareOrderTaskDetailEntity>().
            eq("task_id", id).
            //新建的还没被解锁的库存
            eq("lock_status", 1));
    for (WareOrderTaskDetailEntity entity : detailEntities) {
        //此解锁方式可以解决高并发问题和整个系统的异构(两个服务开发语言不同。如java，php)
        unLockStock(entity.getSkuId(), entity.getWareId(), entity.getSkuNum(), entity.getId());
    }
}
private void unLockStock(Long skuId, Long wareId, Integer num, Long taskDetailId) {
    //库存解锁
    wareSkuDao.unLockStock(skuId, wareId, num);
    //更新库存工作单的状态
    WareOrderTaskDetailEntity entity = new WareOrderTaskDetailEntity();
    entity.setId(taskDetailId);
    entity.setLockStatus(2);//变为已解锁
    wareOrderTaskDetailService.updateById(entity);
}

@Configuration
public class GulimallFeignConfig {

    @Bean("requestInterceptor")
    public RequestInterceptor requestInterceptor() {
        // RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        //RequestContextHolder.setRequestAttributes(requestAttributes);
        // 进行共享操作，拦截器才会有请求上下文的所有数据
        return new RequestInterceptor() {

            @Override
            public void apply(RequestTemplate template) {
                //1、RequestContextHolder拿到刚进来的这个请求
                ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
                if (attributes != null){
                    System.out.println("RequestInterceptor线程...."+Thread.currentThread().getId());
                    HttpServletRequest request = attributes.getRequest();//老请求
                    if (request != null){
                        //请求不为空
                        //同步请求头数据，Cookie
                        String cookie = request.getHeader("Cookie");
//                System.out.println("feign远程之前先进行RequestInterceptor.apply");
                        //给新请求同步了老请求的Cookie
                        template.header("Cookie", cookie);
                    }
                }
            }
        };
    }
}

//获取原来请求上下文请求属性
RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
//进行异步编排
CompletableFuture<Void> getAddressFuture = CompletableFuture.runAsync(() -> {
    //1、远程查询所有的收货地址列表
    System.out.println("member线程...." + Thread.currentThread().getId());
    //在Feign异步调用前将请求上下文进行共享操作(之前的请求数据都来共享每一个线程)
    RequestContextHolder.setRequestAttributes(requestAttributes);
    List<MemberAddressVo> address = memberFeignService.getAddress(memberRespVo.getId());
    confirmVo.setAddress(address);
}, executor);

CompletableFuture<Void> cartFuture = CompletableFuture.runAsync(() -> {
    //2、远程查询购物车所有选中的购物项
    System.out.println("cart线程...." + Thread.currentThread().getId());
    //在Feign异步调用前将请求上下文进行共享操作
    RequestContextHolder.setRequestAttributes(requestAttributes);
    List<OrderItemVo> items = cartFeignService.currentUserCartItems();
    confirmVo.setItems(items);
    //feign在远程调用之前要构造请求，调用很多的拦截器
    //for(RequestInterceptor interceptor:requestInterceptors)
}, executor).thenRunAsync(() -> {
    List<OrderItemVo> items = confirmVo.getItems();
    List<Long> skuIds = items.stream().map(item -> item.getSkuId()).collect(Collectors.toList());
    //远程查询库存
    R r = wmsFeignService.getSkusHasStock(skuIds);
    List<SkuStockVo> data = r.getData(new TypeReference<List<SkuStockVo>>() {
    });
    if (data != null) {
        // Map<SkuId, hasStock> map
        Map<Long, Boolean> map = data.stream().collect(Collectors.toMap(SkuStockVo::getSkuId, SkuStockVo::getHasStock));
        // Map<Long, Boolean> stocks;
        confirmVo.setStocks(map);
    }
}, executor);

    //四、线程串行化方法
    /*
    thenApply 方法：当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前
    任务的返回值。
    thenAccept 方法：消费处理结果。接收任务的处理结果，并消费处理，无返回结果。
    thenRun 方法：只要上面的任务执行完成，就开始执行 thenRun，只是处理完任务后，执行
    thenRun 的后续操作
    带有 Async 默认是异步执行的。同之前。
    以上都要前置任务成功完成。
     */
	@Override
    public SkuItemVo item(Long skuId) throws ExecutionException, InterruptedException {
        SkuItemVo skuItemVo = new SkuItemVo();
        //一、创建异步对象
        /*
         runAsync和supplyAsync  runXxxx 都是没有返回结果的，supplyXxx 都是可以获取返回结果的
         可以传入自定义的线程池，否则就用默认的线程池；
         */
        CompletableFuture<SkuInfoEntity> infoFuture = CompletableFuture.supplyAsync(() -> {
            //1.sku基本信息获取 pms_sku_info
            SkuInfoEntity info = this.getById(skuId);
            skuItemVo.setInfo(info);
            return info;
        }, executor);
    CompletableFuture<Void> saleAttrFuture = infoFuture.thenAcceptAsync((res) -> {
        //3、 获取spu的销售属性组合
        List<SkuItemSaleAttrVo> saleAttrVos = skuSaleAttrValueService.getSaleAttrBySpuId(res.getSpuId());
        skuItemVo.setSaleAttr(saleAttrVos);
    }, executor);

    CompletableFuture<Void> descFuture = infoFuture.thenAcceptAsync((res) -> {
        //4.获取spu的介绍 pms_spu_info_desc
        SpuInfoDescEntity spuInfoDescEntity = spuInfoDescService.getById(res.getSpuId());
        skuItemVo.setDesc(spuInfoDescEntity);
    }, executor);

    CompletableFuture<Void> baseAttrFuture = infoFuture.thenAcceptAsync((res) -> {
        //5.获取spu的规格参数信息
        List<SpuItemAttrGroupVo> attrGroupVos = attrGroupService.getAttrGroupWithAttrsBySpuId(res.getSpuId(), res.getCatalogId());
        skuItemVo.setGroupAttrs(attrGroupVos);
    }, executor);

    //一、创建异步对象
    /*
     runAsync和supplyAsync  runXxxx 都是没有返回结果的，supplyXxx 都是可以获取返回结果的
     可以传入自定义的线程池，否则就用默认的线程池；
     */
    //2.sku图片信息  pms_spu_images
    CompletableFuture<Void> imageFuture = CompletableFuture.runAsync(() -> {
        List<SkuImagesEntity> imagesEntities = skuImagesService.getImagesBySkuId(skuId);
        skuItemVo.setImages(imagesEntities);
    }, executor);

    //TODO //3、远程调用查询当前sku是否参与秒杀优惠活动
    CompletableFuture<Void> seckillFuture = CompletableFuture.runAsync(() -> {
        //3.远程调用查询当前sku是否参与秒杀优惠活动
        R skuSeckilInfo = seckillFeignService.getSkuSeckilInfo(skuId);
        if (skuSeckilInfo.getCode() == 0) {
            //查询成功
            SeckillSkuVo skuSeckilInfoData = skuSeckilInfo.getData("data", new TypeReference<SeckillSkuVo>() {
            });
            skuItemVo.setSeckillSkuVo(skuSeckilInfoData);

            if (skuSeckilInfoData != null) {
                long currentTime = System.currentTimeMillis();
                if (currentTime > skuSeckilInfoData.getEndTime()) {
                    skuItemVo.setSeckillSkuVo(null);
                }
            }
        }
    }, executor);

    //七、多任务组合
    /*
    allOf：等待所有任务完成
    anyOf：只要有一个任务完成
     */
    //等到所有任务完成  //TODO 秒杀优惠活动Future
    CompletableFuture.allOf(saleAttrFuture,descFuture,baseAttrFuture,imageFuture,seckillFuture).get();
    return skuItemVo;
}

    String redisKey = seckillSkuVo.getPromotionSessionId().toString() + "-" + seckillSkuVo.getSkuId().toString();
            if (!operations.hasKey(redisKey)) {
              //判断Redis中是否有该信息，如果没有才进行添加
                Boolean hasKey = redisTemplate.hasKey(key);
                //缓存活动信息
                if (!hasKey) {

    //秒杀商品上架功能的锁
    private final String upload_lock = "seckill:upload:lock";
    
  //分布式锁 .可重入锁（Reentrant Lock）
        RLock lock = redissonClient.getLock(upload_lock);
        try {
            //加锁
            lock.lock(10, TimeUnit.SECONDS);
            seckillService.uploadSeckillSkuLatest3Days();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
          //如果当前这个场次的商品库存信息已经上架就不需要上架
                        //5、使用库存作为分布式Redisson信号量（限流）
                        // 使用库存作为分布式信号量
                        RSemaphore semaphore = redissonClient.getSemaphore(SKU_STOCK_SEMAPHORE + token);
                        // 商品可以秒杀的数量作为信号量
                        semaphore.trySetPermits(seckillSkuVo.getSeckillCount());

/**

 * 1、整合Sentinel
 * 1）、导入依赖 spring-cloud-starter-alibaba-sentinel
 * 2）、下载sentinel的控制台
 * 3）、配置sentinel控制台地址信息
 * 4) 、在控制台调整参数。【默认所有的流控设置保存在内存中，重启失效】
      *
       *
 * 2、每一个微服务都导入 actuator ()；并配合management.endpoints.web.exposure.include=*
 * 3、自定义sentinel流控返回数据
   *
 * 4、使用Sentinel来保护feign远程调用：熔断；
 * 1）、调用方的熔断保护：feign.sentinel.enabled=true
 * 2）、调用方手动指定远程服务的降级策略。远程服务被降级处理。触发我们的熔断回调方法
 * 3）、超大浏览的时候，必须牺牲一些远程服务。在服务的提供方（远程服务）指定降级策略；
 * 提供方是在运行。但是不运行自己的业务逻辑，返回的是默认的降级数据（限流的数据），
    *
 * 5、自定义受保护的资源
 * 1）、代码
 * try(Entry entry = SphU.entry("seckillSkus")){
 * //业务逻辑
 * }
 * catch(Execption e){}
    *
 * 2）、基于注解。
 * @SentinelResource(value = "getCurrentSeckillSkusResource",blockHandler = "blockHandler")
    *
 * 无论是1,2方式一定要配置被限流以后的默认返回.
 * url请求可以设置统一返回:WebCallbackManager
    *
    *
    */

/**
 * 1、如何使用Nacos作为配置中心统一管理配置
 *
 * 1）、引入依赖，
 *         <dependency>
 *             <groupId>com.alibaba.cloud</groupId>
 *             <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
 *         </dependency>
 * 2）、创建一个bootstrap.properties。
 *      spring.application.name=gulimall-coupon
 *      spring.cloud.nacos.config.server-addr=127.0.0.1:8848
 * 3）、需要给配置中心默认添加一个叫 数据集（Data Id）gulimall-coupon.properties。默认规则，应用名.properties
 * 4）、给 应用名.properties 添加任何配置
 * 5）、动态获取配置。
 *      @RefreshScope：动态获取并刷新配置
 *      @Value("${配置项的名}")：获取到配置。
 *      如果配置中心和当前应用的配置文件中都配置了相同的项，优先使用配置中心的配置。
 *
 * 2、细节
 *  1）、命名空间：配置隔离；
 *      默认：public(保留空间)；默认新增的所有配置都在public空间。
 *      1、开发，测试，生产：利用命名空间来做环境隔离。
 *         注意：在bootstrap.properties；配置上，需要使用哪个命名空间下的配置，
 *         spring.cloud.nacos.config.namespace=9de62e44-cd2a-4a82-bf5c-95878bd5e871
 *      2、每一个微服务之间互相隔离配置，每一个微服务都创建自己的命名空间，只加载自己命名空间下的所有配置
 *
 *  2）、配置集：所有的配置的集合
 *
 *  3）、配置集ID：类似文件名。
 *      Data ID：类似文件名
 *
 *  4）、配置分组：
 *      默认所有的配置集都属于：DEFAULT_GROUP；
 *      1111，618，1212
 *
 * 项目中的使用：每个微服务创建自己的命名空间，使用配置分组区分环境，dev，test，prod
 *
 * 3、同时加载多个配置集
 * 1)、微服务任何配置信息，任何配置文件都可以放在配置中心中
 * 2）、只需要在bootstrap.properties说明加载配置中心中哪些配置文件即可
 * 3）、@Value，@ConfigurationProperties。。。
 * 以前SpringBoot任何方法从配置文件中获取值，都能使用。
 * 配置中心有的优先使用配置中心中的，
 *
 /**
 * 1、开启服务注册发现
 *  (配置nacos的注册中心地址)
 * 2、编写网关配置文件
 */