谷粒商城高级篇 (二十三) --------- 订单业务

忘是亡心i 2024-04-06 12:26 22阅读 0赞

#### 目录 ####

*  一、页面环境搭建
 *   *  1. nginx 动静分离配置
     *  2. 配置 host
     *  3. 配置网关
     *  4. 修改各个页面的静态资源路径
 *  二、整合Spring Session
 *   *  1. 导入依赖
     *  2. 开启 Spring Session
     *  3. 配置 Spring Session 存储方式
     *  4. SpringSession 自定义
 *  三、整合线程池
 *   *  自定义线程池配置
 *  四、订单
 *   *  1. 订单中心
     *  2. 订单的构成
     *  3. 订单状态
     *  4. 订单流程
     *   *  ① 订单创建与支付
         *  ② 逆向流程
 *  五、订单代码
 *   *  1. 订单登录拦截
     *  2. 订单确认页
     *   *  ① 模型抽取
         *  ② 提交确认订单
     *  3. 订单支付页
     *   *  ① 支付环境搭建
         *  ② 整合支付

--------------------

## 一、页面环境搭建 ##

### 1. nginx 动静分离配置 ###

等待付款 ---------> detail

![在这里插入图片描述][cdad77269a6345998c73a0e18d15f009.png]  
订单页 ---------> list

![在这里插入图片描述][cc9a3040f2f24ee19ae183689babf89e.png]

结算页 ---------> confirm

![在这里插入图片描述][8059522ca4814686a5448c56fa50c8f7.png]

收银页 ---------> pay

![在这里插入图片描述][c4280f5bb2b84c1b80c15ae115a4ae7d.png]

将静态页面复制到 template 中。。

![在这里插入图片描述][6eab8c09db4b4074bb36eb653855328f.png]

### 2. 配置 host ###

![在这里插入图片描述][054b30bd399f4f3f8dbb08542d25ba97.png]

### 3. 配置网关 ###

![在这里插入图片描述][aeceb575151c42bab19cef619e94b1fa.png]

### 4. 修改各个页面的静态资源路径 ###

src=" ===>src="/static/order/xxx/
    
    herf=" ===>herf="/static/order/xxx/

## 二、整合Spring Session ##

### 1. 导入依赖 ###

<dependency>
        <groupId>org.springframework.session</groupId>
        <artifactId>spring-session-data-redis</artifactId>
    </dependency>

### 2. 开启 Spring Session ###

@EnableRedisHttpSession  //整合Redis作为session存储

### 3. 配置 Spring Session 存储方式 ###

spring.redis.host=192.168.38.130
    spring.session.store-type=redis

### 4. SpringSession 自定义 ###

package com.fancy.gulimall.order.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.session.web.http.CookieSerializer;
    import org.springframework.session.web.http.DefaultCookieSerializer;
    
    @Configuration
    public class GulimallSessionConfig {
        
    
        @Bean
        public CookieSerializer cookieSerializer(){
        
            DefaultCookieSerializer cookieSerializer = new DefaultCookieSerializer();
    
            cookieSerializer.setDomainName("gulimall.com");
            cookieSerializer.setCookieName("GULISESSION");
    
            return cookieSerializer;
        }
    
        @Bean
        public RedisSerializer<Object> springSessionDefaultRedisSerializer() {
        
            return new GenericJackson2JsonRedisSerializer();
        }
    }

## 三、整合线程池 ##

### 自定义线程池配置 ###

package com.fancy.gulimall.order.config;
    
    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    @ConfigurationProperties(prefix = "gulimall.thread")
    @Component
    @Data
    public class ThreadPoolConfigProperties {
        
        private Integer coreSize;
        private Integer maxSize;
        private Integer keepAliveTime;
    }

![在这里插入图片描述][68220db56d024cf0bcac57a151384fe4.png]

package com.fancy.gulimall.order.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.LinkedBlockingDeque;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    //@EnableConfigurationProperties(ThreadPoolConfigProperties.class)
    @Configuration
    public class MyThreadConfig {
        
    
        @Bean
        public ThreadPoolExecutor threadPoolExecutor(ThreadPoolConfigProperties pool){
        
           return new ThreadPoolExecutor(pool.getCoreSize(),
                    pool.getMaxSize(),pool.getKeepAliveTime(),
                    TimeUnit.SECONDS,new LinkedBlockingDeque<>(100000),
                    Executors.defaultThreadFactory(),
                    new ThreadPoolExecutor.AbortPolicy());
    
        }
    }

## 四、订单 ##

### 1. 订单中心 ###

电商系统涉及到 3 流，分别时信息流，资金流，物流，而订单系统作为中枢将三者有机的集合起来。订单模块是电商系统的枢纽，在订单这个环节上需求获取多个模块的数据和信息，同时对这些信息进行加工处理后流向下个环节，这一系列就构成了订单的信息流通。

### 2. 订单的构成 ###

![在这里插入图片描述][6a47a3b0c3184cc9874cf7578b4e49f7.png]  
**A、用户信息**

用户信息包括用户账号、用户等级、用户的收货地址、收货人、收货人电话等组成，用户账户需要绑定手机号码，但是用户绑定的手机号码不一定是收货信息上的电话。用户可以添加多个收货信息，用户等级信息可以用来和促销系统进行匹配，获取商品折扣，同时用户等级还可以获取积分的奖励等

**B、订单基础信息**

订单基础信息是订单流转的核心，其包括订单类型、父/子订单、订单编号、订单状态、订单流转的时间等。

（1）订单类型包括实体商品订单和虚拟订单商品等，这个根据商城商品和服务类型进行区分。  
（2）同时订单都需要做父子订单处理，之前在初创公司一直只有一个订单，没有做父子订单处理后期需要进行拆单的时候就比较麻烦，尤其是多商户商场，和不同仓库商品的时候，父子订单就是为后期做拆单准备的。  
（3）订单编号不多说了，需要强调的一点是父子订单都需要有订单编号，需要完善的时候可以对订单编号的每个字段进行统一定义和诠释。  
（4）订单状态记录订单每次流转过程，后面会对订单状态进行单独的说明。（5）订单流转时间需要记录下单时间，支付时间，发货时间，结束时间/关闭时间等等

**C、商品信息**  
商品信息从商品库中获取商品的 SKU 信息、图片、名称、属性规格、商品单价、商户信息等，从用户下单行为记录的用户下单数量，商品合计价格等。

**D、优惠信息**

优惠信息记录用户参与的优惠活动，包括优惠促销活动，比如满减、满赠、秒杀等，用户使用的优惠券信息，优惠券满足条件的优惠券需要默认展示出来，具体方式已在之前的优惠券篇章做过详细介绍，另外还虚拟币抵扣信息等进行记录。

为什么把优惠信息单独拿出来而不放在支付信息里面呢？

因为优惠信息只是记录用户使用的条目，而支付信息需要加入数据进行计算，所以做为区分。

**E、支付信息**

（1）支付流水单号，这个流水单号是在唤起网关支付后支付通道返回给电商业务平台的支付流水号，财务通过订单号和流水单号与支付通道进行对账使用。  
（2）支付方式用户使用的支付方式，比如微信支付、支付宝支付、钱包支付、快捷支付等。支付方式有时候可能有两个——余额支付+第三方支付。  
（3）商品总金额，每个商品加总后的金额；运费，物流产生的费用；优惠总金额，包括促销活动的优惠金额，优惠券优惠金额，虚拟积分或者虚拟币抵扣的金额，会员折扣的金额等之和；实付金额，用户实际需要付款的金额。用户实付金额=商品总金额+运费-优惠总金额

**F、物流信息**

物流信息包括配送方式，物流公司，物流单号，物流状态，物流状态可以通过第三方接口来获取和向用户展示物流每个状态节点。

### 3. 订单状态 ###

**A、待付款**

用户提交订单后，订单进行预下单，目前主流电商网站都会唤起支付，便于用户快速完成支付，需要注意的是待付款状态下可以对库存进行锁定，锁定库存需要配置支付超时时间，超时后将自动取消订单，订单变更关闭状态。

**B、已付款/待发货**

用户完成订单支付，订单系统需要记录支付时间，支付流水单号便于对账，订单下放到 WMS 系统，仓库进行调拨，配货，分拣，出库等操作。

**C、待收货/已发货**

仓储将商品出库后，订单进入物流环节，订单系统需要同步物流信息，便于用户实时知悉物品物流状态

**D、已完成**

用户确认收货后，订单交易完成。后续支付侧进行结算，如果订单存在问题进入售后状态

**E、已取消**

付款之前取消订单。包括超时未付款或用户商户取消订单都会产生这种订单状态。

**F、售后中**

用户在付款后申请退款，或商家发货后用户申请退换货。售后也同样存在各种状态，当发起售后申请后生成售后订单，售后订单状态为待审核，等待商家审核，商家审核通过后订单状态变更为待退货，等待用户将商品寄回，商家收货后订单状态更新为待退款状态，退款到用户原账户后订单状态更新为售后成功。

### 4. 订单流程 ###

订单流程是指从订单产生到完成整个流转的过程，从而行程了一套标准流程规则。而不同的产品类型或业务类型在系统中的流程会千差万别，比如上面提到的线上实物订单和虚拟订单的流程，线上实物订单与 O2O 订单等，所以需要根据不同的类型进行构建订单流程。不管类型如何订单都包括正向流程和逆向流程，对应的场景就是购买商品和退换货流程，正向流程就是一个正常的网购步骤：订单生成–>支付订单–>卖家发货–>确认收货–>交易成功。而每个步骤的背后，订单是如何在多系统之间交互流转的，可概括如下图

![在这里插入图片描述][46bb278a67c04de49c1d25429c1448f3.png_pic_center]

#### ① 订单创建与支付 ####

(1) 、订单创建前需要预览订单，选择收货信息等  
(2) 、订单创建需要锁定库存，库存有才可创建，否则不能创建  
(3) 、订单创建后超时未支付需要解锁库存  
(4) 、支付成功后，需要进行拆单，根据商品打包方式，所在仓库，物流等进行拆单  
(5) 、支付的每笔流水都需要记录，以待查账  
(6) 、订单创建，支付成功等状态都需要给 MQ 发送消息，方便其他系统感知订阅

#### ② 逆向流程 ####

(1) 、修改订单，用户没有提交订单，可以对订单一些信息进行修改，比如配送信息，优惠信息，及其他一些订单可修改范围的内容，此时只需对数据进行变更即可。  
(2) 、订单取消，用户主动取消订单和用户超时未支付，两种情况下订单都会取消订单，而超时情况是系统自动关闭订单，所以在订单支付的响应机制上面要做支付的限时处理，尤其是在前面说的下单减库存的情形下面，可以保证快速的释放库存。另外需要需要处理的是促销优惠中使用的优惠券，权益等视平台规则，进行相应补回给用户。  
(3) 、退款，在待发货订单状态下取消订单时，分为缺货退款和用户申请退款。如果是全部退款则订单更新为关闭状态，若只是做部分退款则订单仍需进行进行，同时生成一条退款的售后订单，走退款流程。退款金额需原路返回用户的账户。  
(4) 、发货后的退款，发生在仓储货物配送，在配送过程中商品遗失，用户拒收，用户收货后对商品不满意，这样情况下用户发起退款的售后诉求后，需要商户进行退款的审核，双方达成一致后，系统更新退款状态，对订单进行退款操作，金额原路返回用户的账户，同时关闭原订单数据。仅退款情况下暂不考虑仓库系统变化。如果发生双方协调不一致情况下，可以申请平台客服介入。在退款订单商户不处理的情况下，系统需要做限期判断，比如 5 天商户不处理，退款单自动变更同意退款。

## 五、订单代码 ##

### 1. 订单登录拦截 ###

因为订单系统必然涉及到用户信息，因此进入订单系统的请求必须是已经登录的，所以我们需要通过拦截器对未登录订单请求进行拦截。

package com.fancy.gulimall.order.interceptor;
    
    import com.fancy.common.constant.AuthServerConstant;
    import com.fancy.common.vo.MemberRespVo;
    import org.springframework.stereotype.Component;
    import org.springframework.util.AntPathMatcher;
    import org.springframework.web.servlet.HandlerInterceptor;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    
    @Component
    public class LoginUserInterceptor implements HandlerInterceptor {
        
    
    
        public static ThreadLocal<MemberRespVo> loginUser = new ThreadLocal<>();
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        
    
            //  /order/order/status/2948294820984028420
            String uri = request.getRequestURI();
            AntPathMatcher antPathMatcher = new AntPathMatcher();
            boolean match = antPathMatcher.match("/order/order/status/**", uri);
            boolean match1 = antPathMatcher.match("/payed/notify", uri);
            if(match || match1){
        
                return true;
            }
            
            MemberRespVo attribute = (MemberRespVo) request.getSession().getAttribute(AuthServerConstant.LOGIN_USER);
            if(attribute!=null){
        
                loginUser.set(attribute);
                return true;
            }else {
        
                //没登录就去登录
                request.getSession().setAttribute("msg","请先进行登录");
                response.sendRedirect("http://auth.gulimall.com/login.html");
                return false;
            }
    
        }
    }

添加拦截器。。。

package com.fancy.gulimall.order.config;
    
    import com.fancy.gulimall.order.interceptor.LoginUserInterceptor;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    
    @Configuration
    public class OrderWebConfiguration implements WebMvcConfigurer {
        
    
    
        @Autowired
        LoginUserInterceptor interceptor;
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
        
            registry.addInterceptor(interceptor).addPathPatterns("/**");
        }
    }

### 2. 订单确认页 ###

#### ① 模型抽取 ####

package com.fancy.gulimall.order.vo;
    
    import lombok.Getter;
    import lombok.Setter;
    
    import java.math.BigDecimal;
    import java.util.List;
    import java.util.Map;
    
    //订单确认页需要用的数据
    public class OrderConfirmVo {
        
    
         收货地址，ums_member_receive_address表
        @Setter @Getter
        List<MemberAddressVo> address;
    
    
        //所有选中的购物项
        @Setter @Getter
        List<OrderItemVo> items;
    
        //发票记录....
    
        //优惠券信息...
        @Setter @Getter
        Integer integration;
    
        @Setter @Getter
        Map<Long,Boolean> stocks;
    
    
        //防重令牌
        @Setter @Getter
        String orderToken;
    
        public Integer getCount(){
        
            Integer i = 0 ;
            if(items!=null){
        
                for (OrderItemVo item : items) {
        
                    i+=item.getCount();
                }
            }
            return i;
        }
    
        //BigDecimal total;//订单总额
    
        public BigDecimal getTotal() {
        
            BigDecimal sum = new BigDecimal("0");
            if(items!=null){
        
                for (OrderItemVo item : items) {
        
                    BigDecimal multiply = item.getPrice().multiply(new BigDecimal(item.getCount().toString()));
                    sum = sum.add(multiply);
                }
            }
    
            return sum;
        }
    
    	//BigDecimal payPrice;
    
        public BigDecimal getPayPrice() {
        
           return  getTotal();
        }
    
        //应付价格
    
    }

#### ② 提交确认订单 ####

**A、订单确认页流程**

![在这里插入图片描述][ea1a0c141d204e21a59707fcae774f49.png_pic_center]

**B、去到订单确认页面**

/**
    1.判断用户登录信息
    2.远程查询所有的收获地址列表
    3.远程查询购物车所有选中的购物项
    4.远程查询商品库存信息
    5.查询用户积分
    6.价格数据自动计算
    7.防重令牌(防止表单重复提交)
    */
    /**
    * 订单确认页返回需要用的数据
    * @return
    */
    @Override
    public OrderConfirmVo confirmOrder() throws ExecutionException, InterruptedException {
        
       //构建OrderConfirmVo
       OrderConfirmVo confirmVo = new OrderConfirmVo();
       //获取当前用户登录的信息
       MemberResponseVo memberResponseVo = LoginUserInterceptor.loginUser.get();
       //TODO :获取当前线程请求头信息(解决Feign异步调用丢失请求头问题)
       RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
       //开启第一个异步任务
       CompletableFuture<Void> addressFuture = CompletableFuture.runAsync(() -> {
        
           //每一个线程都来共享之前的请求数据
           RequestContextHolder.setRequestAttributes(requestAttributes);
           //1、远程查询所有的收获地址列表
           List<MemberAddressVo> address = memberFeignService.getAddress(memberResponseVo.getId());
           confirmVo.setMemberAddressVos(address);
       }, threadPoolExecutor);
    
       //开启第二个异步任务
       CompletableFuture<Void> cartInfoFuture = CompletableFuture.runAsync(() -> {
        
           //每一个线程都来共享之前的请求数据【解决异步ThreadLocal 无法共享数据】
           RequestContextHolder.setRequestAttributes(requestAttributes);
           //2、远程查询购物车所有选中的购物项
           List<OrderItemVo> currentCartItems = cartFeignService.getCurrentCartItems();
           confirmVo.setItems(currentCartItems);
           //feign在远程调用之前要构造请求，调用很多的拦截器
       }, threadPoolExecutor).thenRunAsync(() -> {
        
           List<OrderItemVo> items = confirmVo.getItems();
           //获取全部商品的id
           List<Long> skuIds = items.stream()
                   .map((itemVo -> itemVo.getSkuId()))
                   .collect(Collectors.toList());
    
           //3、远程查询商品库存信息
           R skuHasStock = wmsFeignService.getSkuHasStock(skuIds);
           List<SkuStockVo> skuStockVos = skuHasStock.getData("data", new TypeReference<List<SkuStockVo>>() {
        });
    
           if (skuStockVos != null && skuStockVos.size() > 0) {
        
               //将skuStockVos集合转换为map
               Map<Long, Boolean> skuHasStockMap = skuStockVos.stream().collect(Collectors.toMap(SkuStockVo::getSkuId, SkuStockVo::getHasStock));
               confirmVo.setStocks(skuHasStockMap);
           }
       },threadPoolExecutor);
    
       //4、、查询用户积分
       Integer integration = memberResponseVo.getIntegration();
       confirmVo.setIntegration(integration);
    
       //5、、价格数据自动计算
    
       //TODO 5、防重令牌(防止表单重复提交)
       //为用户设置一个token，三十分钟过期时间（存在redis）
       String token = UUID.randomUUID().toString().replace("-", "");
       redisTemplate.opsForValue().set(USER_ORDER_TOKEN_PREFIX+memberResponseVo.getId(),token,30, TimeUnit.MINUTES);
       confirmVo.setOrderToken(token);
    
       CompletableFuture.allOf(addressFuture,cartInfoFuture).get();
    
       return confirmVo;
    }

**C、Feign远程调用丢失请求头**  
![在这里插入图片描述][a38dd25027b14a1bb83093ca8b840943.png]

原因：feign 发送请求时构造的 RequestTemplate 没有请求头(该请求头为空)，请求参数等信息【cookie没了】，导致在cart服务中，拦截器拦截获取session中的登录信息，获取不到 userId【没有cookie】

解决：同步新、老请求 (老请求就是/toTrade请求，带有Cookie数据) 的 cookie

原理： feign在远程调用之前要构造请求，调用很多的拦截器(DEBUG，查看到会调用拦截器)

package com.fancy.gulimall.order.config;
    
    import feign.RequestInterceptor;
    import feign.RequestTemplate;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    
    @Configuration
    public class GuliFeignConfig {
        
    
        @Bean("requestInterceptor")
        public RequestInterceptor requestInterceptor(){
        
            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");
                            //给新请求同步了老请求的cookie
                            template.header("Cookie",cookie);
                        }
                    }
                }
            };
        }
    }

**D、Feign异步情况丢失上下文问题**

![在这里插入图片描述][6c418fbb94df426e81fec43fe08449cb.png]  
导致拦截器中 空指针异常

1、先在主线程的ThreadLocal中获取，请求头数据

RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();

2、再在新线程给ThreadLocal 设置 请求头数据【否则获取不到数据，不是同一个线程】

//每一个线程都来共享之前的请求数据【解决异步ThreadLocal 无法共享数据】
    RequestContextHolder.setRequestAttributes(requestAttributes);

**E、创建防重令牌**

令牌前缀常量：

public class OrderConstant {
        
        public static final String USER_ORDER_TOKEN_PREFIX = "order:token";
    }

//TODO 5、防重令牌(防止表单重复提交)
    //为用户设置一个token，三十分钟过期时间（存在redis）
    String token = UUID.randomUUID().toString().replace("-", "");
    redisTemplate.opsForValue().set(USER_ORDER_TOKEN_PREFIX+memberResponseVo.getId(),token,30, TimeUnit.MINUTES);
    confirmVo.setOrderToken(token);

**F、提交订单**

注意:创建的订单号很长,注意将oms\_order与oms\_order\_item数据库表中的order\_sn字段调大至50,否则会报错

下单：去创建订单，验令牌，验价格，锁库存。  
提交订单成功，则携带返回数据转发至支付页面。  
提交订单失败，则携带错误信息重定向至确认页。

@RequestMapping("/submitOrder")
    public String submitOrder(OrderSubmitVo submitVo, Model model, RedirectAttributes attributes) {
        
        try{
        
            SubmitOrderResponseVo responseVo=orderService.submitOrder(submitVo);
            Integer code = responseVo.getCode();
            if (code==0){
        
                model.addAttribute("order", responseVo.getOrder());
                return "pay";
            }else {
        
                String msg = "下单失败;";
                switch (code) {
        
                    case 1:
                        msg += "防重令牌校验失败";
                        break;
                    case 2:
                        msg += "商品价格发生变化";
                        break;
                }
                attributes.addFlashAttribute("msg", msg);
                return "redirect:http://order.gulimall.com/toTrade";
            }
        }catch (Exception e){
        
            if (e instanceof NoStockException){
        
                String msg = "下单失败，商品无库存";
                attributes.addFlashAttribute("msg", msg);
            }
            return "redirect:http://order.gulimall.com/toTrade";
        }
    }

/**
     * 提交订单
     * @param vo
     * @return
     */
    // @Transactional(isolation = Isolation.READ_COMMITTED) 设置事务的隔离级别
    // @Transactional(propagation = Propagation.REQUIRED)   设置事务的传播级别
    // @GlobalTransactional(rollbackFor = Exception.class)
    @Transactional
    @Override
    public SubmitOrderResponseVo submitOrder(OrderSubmitVo vo) {
        
    
        confirmVoThreadLocal.set(vo);
    
        SubmitOrderResponseVo responseVo = new SubmitOrderResponseVo();
        //去创建、下订单、验令牌、验价格、锁定库存...
    
        //获取当前用户登录的信息
        MemberResponseVo memberResponseVo = LoginUserInterceptor.loginUser.get();
        responseVo.setCode(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();
    
        //通过lure脚本原子验证令牌和删除令牌
        Long result = redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class),
                Arrays.asList(USER_ORDER_TOKEN_PREFIX + memberResponseVo.getId()),
                orderToken);
    
        if (result == 0L) {
        
            //令牌验证失败
            responseVo.setCode(1);
            return responseVo;
        } else {
        
            //令牌验证成功
            //1、创建订单、订单项等信息
            OrderCreateTo order = createOrder();
    
            //2、验证价格
            BigDecimal payAmount = order.getOrder().getPayAmount();
            BigDecimal payPrice = vo.getPayPrice();
    
            if (Math.abs(payAmount.subtract(payPrice).doubleValue()) < 0.01) {
        
                //金额对比
                //TODO 3、保存订单
                saveOrder(order);
    
                //4、库存锁定,只要有异常，回滚订单数据
                //订单号、所有订单项信息(skuId,skuNum,skuName)
                WareSkuLockVo lockVo = new WareSkuLockVo();
                lockVo.setOrderSn(order.getOrder().getOrderSn());
    
                //获取出要锁定的商品数据信息【order里面存储的是Entity】
                List<OrderItemVo> orderItemVos = 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(orderItemVos);
    
                //TODO 调用远程锁定库存的方法
                //出现的问题：扣减库存成功了，但是由于网络原因超时，出现异常，导致订单事务回滚，库存事务不回滚(解决方案：seata)
                //为了保证高并发，不推荐使用seata，因为是加锁，并行化，提升不了效率,可以发消息给库存服务
                R r = wmsFeignService.orderLockStock(lockVo);
                if (r.getCode() == 0) {
        
                    //锁定成功
                    responseVo.setOrder(order.getOrder());
                    //int i = 10/0;
    
                    //TODO 订单创建成功，发送消息给MQ
    //                    rabbitTemplate.convertAndSend("order-event-exchange","order.create.order",order.getOrder());
    
                    //删除购物车里的数据
    //                    redisTemplate.delete(CART_PREFIX+memberResponseVo.getId());
                    return responseVo;
                } else {
        
                    //锁定失败
                    String msg = (String) r.get("msg");
                    throw new NoStockException(msg);
                    // responseVo.setCode(3);
                    // return responseVo;
                }
            } else {
        
                responseVo.setCode(2);
                return responseVo;
            }
        }
    }

关于库存锁定相关方法：

/**
     * 锁定库存
     */
    @PostMapping(value = "/ware/waresku/lock/order")
    R orderLockStock(@RequestBody WareSkuLockVo vo);

/**
    * 下订单时锁库存
    * @param
    * @return
    */
    @RequestMapping("/lock/order")
    public R orderLockStock(@RequestBody WareSkuLockVo lockVo) {
        
       try {
        
           Boolean lock = wareSkuService.orderLockStock(lockVo);
           return R.ok();
       } catch (NoStockException e) {
        
           return R.error(BizCodeEnume.NO_STOCK_EXCEPTION.getCode(), BizCodeEnume.NO_STOCK_EXCEPTION.getMsg());
       }
    }

/**
     * 为某个订单锁定库存
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean orderLockStock(WareSkuLockVo vo) {
        
    
        /**
         * 保存库存工作单详情信息
         * 追溯
         * 如果没有库存，就不会发送消息给mq
         * 【不会进入save(WareOrderTaskDetailEntity)逻辑，也不会发送消息给mq，也不会锁定库存，也不会监听到解锁服务】
         */
        WareOrderTaskEntity wareOrderTaskEntity = new WareOrderTaskEntity();
        wareOrderTaskEntity.setOrderSn(vo.getOrderSn());
        wareOrderTaskEntity.setCreateTime(new Date());
        wareOrderTaskService.save(wareOrderTaskEntity);
    
    
        //1、按照下单的收货地址，找到一个就近仓库，锁定库存
        //2、找到每个商品在哪个仓库都有库存
        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());
            //查询这个商品在哪个仓库有库存 stock-锁定num > 0
            List<Long> wareIdList = wareSkuDao.listWareIdHasSkuStock(skuId);
            stock.setWareId(wareIdList);
    
            return stock;
        }).collect(Collectors.toList());
    
        //2、锁定库存
        for (SkuWareHasStock hasStock : collect) {
        
            boolean skuStocked = false;
            Long skuId = hasStock.getSkuId();
            List<Long> wareIds = hasStock.getWareId();
    
            if (CollectionUtils.isEmpty(wareIds)) {
        
                //没有任何仓库有这个商品的库存
                throw new NoStockException(skuId);
            }
    
            //1、如果每一个商品都锁定成功,将当前商品锁定了几件的工作单记录发给MQ
            //2、锁定失败。前面保存的工作单信息都回滚了。发送出去的消息，即使要解锁库存，由于在数据库查不到指定的id，所有就不用解锁
            for (Long wareId : wareIds) {
        
                //锁定成功就返回1，失败就返回0
                Long count = wareSkuDao.lockSkuStock(skuId,wareId,hasStock.getNum());
                // count==1表示锁定成功
                if (count == 1) {
        
                    skuStocked = true;
    //                    WareOrderTaskDetailEntity taskDetailEntity = WareOrderTaskDetailEntity.builder()
    //                            .skuId(skuId)
    //                            .skuName("")
    //                            .skuNum(hasStock.getNum())
    //                            .taskId(wareOrderTaskEntity.getId())
    //                            .wareId(wareId)
    //                            .lockStatus(1)
    //                            .build();
    //                    wareOrderTaskDetailService.save(taskDetailEntity);
    //
    //                    //TODO 告诉MQ库存锁定成功
    //                    StockLockedTo lockedTo = new StockLockedTo();
    //                    lockedTo.setId(wareOrderTaskEntity.getId());
    //                    StockDetailTo detailTo = new StockDetailTo();
    //                    BeanUtils.copyProperties(taskDetailEntity,detailTo);// 这里直接存entity。但是应该存id更好，数据最好来自DB
    //                    lockedTo.setDetailTo(detailTo);
    //                    rabbitTemplate.convertAndSend("stock-event-exchange","stock.locked",lockedTo);
                    // 锁定成功返回
                    break;
                } else {
        
                    //当前仓库锁失败，重试下一个仓库
                }
            }
            if (skuStocked == false) {
        
                //当前商品所有仓库都没有锁住
                throw new NoStockException(skuId);
            }
        }
        //3、肯定全部都是锁定成功的
        return true;
    }

**G、订单提交的问题 (本地事务在分布式情况下出现的问题)**

分布式情况下，可能出现一些服务事务不一致的情况

*  远程服务假失败
 *  远程服务执行完成后，下面其他方法出现异常

库存扣减成功但是订单业务执行出错,订单业务可以回滚但远程调用的库存服务是办法回滚的

![在这里插入图片描述][1a60caf103ca43a59a61958764bcab17.png]  
解决方案：可以使用 Seata 分布式事务，详见上一篇文章。。。

Seata 代理数据源：

package com.fancy.gulimall.order.config;
    
    import com.zaxxer.hikari.HikariDataSource;
    import io.seata.rm.datasource.DataSourceProxy;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.util.StringUtils;
    
    import javax.sql.DataSource;
    
    @Configuration
    public class MySeataConfig {
        
    
        @Autowired
        DataSourceProperties dataSourceProperties;
    
        @Bean
        public DataSource dataSource(DataSourceProperties dataSourceProperties){
        
            //properties.initializeDataSourceBuilder().type(type).build();
            HikariDataSource dataSource = dataSourceProperties.initializeDataSourceBuilder().type(HikariDataSource.class).build();
            if (StringUtils.hasText(dataSourceProperties.getName())) {
        
                dataSource.setPoolName(dataSourceProperties.getName());
            }
            return new DataSourceProxy(dataSource);
        }
    }

**H、最终一致性库存解锁逻辑：基于消息队列的分布式事务+分布式表【库存自动解锁】**

![在这里插入图片描述][970b7478839d45dab18e6b8c0bfe376e.jpeg_pic_center]

配置 RabbitMQ 确认回调，失败回调

package com.fancy.gulimall.order.config;
    
    import org.springframework.amqp.core.Message;
    import org.springframework.amqp.rabbit.connection.ConnectionFactory;
    import org.springframework.amqp.rabbit.connection.CorrelationData;
    import org.springframework.amqp.rabbit.core.RabbitTemplate;
    import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
    import org.springframework.amqp.support.converter.MessageConverter;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;
    
    import javax.annotation.PostConstruct;
    
    @Configuration
    public class MyRabbitConfig {
        
    
    //
    //    @Autowired
        RabbitTemplate rabbitTemplate;
    
    
    //    public MyRabbitConfig(RabbitTemplate rabbitTemplate){
        
    //        this.rabbitTemplate = rabbitTemplate;
    //        initRabbitTemplate();
    //    }
        //TODO
        @Primary
        @Bean
        public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){
        
            RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
            this.rabbitTemplate = rabbitTemplate;
            rabbitTemplate.setMessageConverter(messageConverter());
            initRabbitTemplate();
            return rabbitTemplate;
        }
    
        /**
         * 使用JSON序列化机制，进行消息转换
         */
        @Bean
        public MessageConverter messageConverter(){
        
    
            return new Jackson2JsonMessageConverter();
        }
    
        /**
         * 定制RabbitTemplate
         * 1、服务器收到消息就回调
         *      1、spring.rabbitmq.publisher-confirms=true
         *      2、设置确认回调ConfirmCallback
         * 2、消息正确抵达队列进行回调
         *      1、 spring.rabbitmq.publisher-returns=true
         *          spring.rabbitmq.template.mandatory=true
         *      2、设置确认回调ReturnCallback
         *
         * 3、消费端确认（保证每个消息被正确消费，此时才可以broker删除这个消息）。
         *      spring.rabbitmq.listener.simple.acknowledge-mode=manual 手动签收
         *      1、默认是自动确认的，只要消息接收到，客户端会自动确认，服务端就会移除这个消息
         *          问题：
         *              我们收到很多消息，自动回复给服务器ack，只有一个消息处理成功，宕机了。就会发生消息丢失；
         *              消费者手动确认模式。只要我们没有明确告诉MQ，货物被签收。没有Ack，
         *                  消息就一直是unacked状态。即使Consumer宕机。消息不会丢失，会重新变为Ready，下一次有新的Consumer连接进来就发给他
         *      2、如何签收:
         *          channel.basicAck(deliveryTag,false);签收；业务成功完成就应该签收
         *          channel.basicNack(deliveryTag,false,true);拒签；业务失败，拒签
         */
    //    @PostConstruct //MyRabbitConfig对象创建完成以后，执行这个方法
        public void initRabbitTemplate(){
        
            //设置确认回调
            rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
        
    
                /**
                 *
                 * 1、只要消息抵达Broker就ack=true
                 * @param correlationData 当前消息的唯一关联数据（这个是消息的唯一id）
                 * @param ack  消息是否成功收到
                 * @param cause 失败的原因
                 */
                @Override
                public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        
    
                    /**
                     * 1、做好消息确认机制（pulisher，consumer【手动ack】）
                     * 2、每一个发送的消息都在数据库做好记录。定期将失败的消息再次发送一遍
                     */
                    //服务器收到了；
                    //修改消息的状态
                    System.out.println("confirm...correlationData["+correlationData+"]==>ack["+ack+"]==>cause["+cause+"]");
                }
            });
    
            //设置消息抵达队列的确认回调
            rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
        
                /**
                 * 只要消息没有投递给指定的队列，就触发这个失败回调
                 * @param message   投递失败的消息详细信息
                 * @param replyCode 回复的状态码
                 * @param replyText 回复的文本内容
                 * @param exchange  当时这个消息发给哪个交换机
                 * @param routingKey 当时这个消息用哪个路由键
                 */
                @Override
                public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        
                    //报错误了。修改数据库当前消息的状态->错误。
                    System.out.println("Fail Message["+message+"]==>replyCode["+replyCode+"]==>replyText["+replyText+"]===>exchange["+exchange+"]===>routingKey["+routingKey+"]");
                }
            });
        }
    
    }

创建库存解锁延时队列及交换机，绑定

package com.fancy.gulimall.order.config;
    
    import org.springframework.amqp.core.*;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.util.HashMap;
    import java.util.Map;
    
    @Configuration
    public class MyMQConfig {
        
    
    
    
        //@Bean Binding，Queue，Exchange
    
        /**
         * 容器中的 Binding，Queue，Exchange 都会自动创建（RabbitMQ没有的情况）
         * RabbitMQ 只要有。@Bean声明属性发生变化也不会覆盖
         * @return
         */
        @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 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 orderCreateOrderBingding() {
        
            //String destination, 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);
    
        }
    
        @Bean
        public Binding orderReleaseOrderBingding() {
        
            return new Binding("order.release.order.queue",
                    Binding.DestinationType.QUEUE,
                    "order-event-exchange",
                    "order.release.order",
                    null);
        }
    
    
        /**
         * 订单释放直接和库存释放进行绑定
         * @return
         */
        @Bean
        public Binding orderReleaseOtherBingding() {
        
            return new Binding("stock.release.stock.queue",
                    Binding.DestinationType.QUEUE,
                    "order-event-exchange",
                    "order.release.other.#",
                    null);
        }
    
    
        @Bean
        public Queue orderSeckillOrderQueue(){
        
            //String name, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
            return new Queue("order.seckill.order.queue",true,false,false);
        }
    
        @Bean
        public Binding orderSeckillOrderQueueBinding(){
        
            /**
             * String destination, DestinationType destinationType, String exchange, String routingKey,
             * 			Map<String, Object> arguments
             */
            return new Binding("order.seckill.order.queue",
                    Binding.DestinationType.QUEUE,
                    "order-event-exchange",
                    "order.seckill.order",
                    null);
        }
    }

锁定库存时向库存延时队列发送一条库存工作单记录

![在这里插入图片描述][f5b79bd3f8384277a082f8aa250b9055.png]

监听库存死信队列，解锁库存

package com.fancy.gulimall.ware.listener;
    
    import com.rabbitmq.client.Channel;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.amqp.core.Message;
    import org.springframework.amqp.rabbit.annotation.RabbitHandler;
    import org.springframework.amqp.rabbit.annotation.RabbitListener;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import com.fancy.common.to.mq.StockLockedTo;
    import com.fancy.gulimall.ware.service.WareSkuService;
    
    import java.io.IOException;
    
    /**
     * 监听死信队列，解锁库存
     *
     * @date 2021/12/29 15:22
     */
    @Slf4j
    @RabbitListener(queues = "stock.release.stock.queue")
    @Service
    public class StockReleaseListener {
        
    
        @Autowired
        private WareSkuService wareSkuService;
    
        /**
         * 这个是监听死信消息
         * 1、库存自动解锁
         *  下订单成功，库存锁定成功，接下来的业务调用失败，导致订单回滚。之前锁定的库存就要自动解锁
         *
         * 2、订单失败
         *   库存锁定失败
         *
         *   只要解锁库存的消息失败，一定要告诉服务解锁失败
         */
        @RabbitHandler
        public void handleStockLockedRelease(StockLockedTo to, Message message, Channel channel) throws IOException {
        
            System.out.println("******收到解锁库存的延时信息******，准备解锁" + to.getDetailTo().getId());
            try {
        
    
                //当前消息是否被第二次及以后（重新）派发过来了
                // Boolean redelivered = message.getMessageProperties().getRedelivered();
    
                //解锁库存
                wareSkuService.unlockStock(to);
                // 手动删除消息
                channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
            } catch (Exception e) {
        
                // 解锁失败 将消息重新放回队列，让别人消费
                channel.basicReject(message.getMessageProperties().getDeliveryTag(),true);
            }
        }
        /**
         * 客户取消订单，监听到消息
         */
        @RabbitHandler
        public void handleOrderCloseRelease(OrderTo orderTo, Message message, Channel channel) throws IOException {
        
            System.out.println("******收到订单关闭，准备解锁库存的信息******订单号：" + orderTo.getOrderSn());
            try {
        
                wareSkuService.unlockStock(orderTo);
                // 手动删除消息
                channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
            } catch (Exception e) {
        
                // 解锁失败 将消息重新放回队列，让别人消费
                channel.basicReject(message.getMessageProperties().getDeliveryTag(),true);
            }
        }
    }

监听订单自动关单

package com.fancy.gulimall.order.listener;
    
    import com.fancy.gulimall.order.entity.OrderEntity;
    import com.fancy.gulimall.order.service.OrderService;
    import com.rabbitmq.client.Channel;
    import org.springframework.amqp.core.Message;
    import org.springframework.amqp.rabbit.annotation.RabbitHandler;
    import org.springframework.amqp.rabbit.annotation.RabbitListener;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.io.IOException;
    
    @RabbitListener(queues = "order.release.order.queue")
    @Service
    public class OrderCloseListener {
        
    
        @Autowired
        OrderService orderService;
        @RabbitHandler
        public void listener(OrderEntity entity, Channel channel, Message message) throws IOException {
        
            System.out.println("收到过期的订单信息：准备关闭订单"+entity.getOrderSn()+"==>"+entity.getId());
            try{
        
                orderService.closeOrder(entity);
                //手动调用支付宝收单；
                channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
            }catch (Exception e){
        
                channel.basicReject(message.getMessageProperties().getDeliveryTag(),true);
            }
    
        }
    }

### 3. 订单支付页 ###

#### ① 支付环境搭建 ####

详见上一篇文章。。。

#### ② 整合支付 ####

**A、导入依赖**

gulimall-order/pom.xml

<dependency>
        <groupId>com.alipay.sdk</groupId>
        <artifactId>alipay-sdk-java</artifactId>
        <version>4.10.111.ALL</version>
    </dependency>

**B、抽取阿里云支付模板**

import com.alipay.api.AlipayApiException;
    import com.alipay.api.AlipayClient;
    import com.alipay.api.DefaultAlipayClient;
    import com.alipay.api.request.AlipayTradePagePayRequest;
    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    @ConfigurationProperties(prefix = "alipay")
    @Component
    @Data
    public class AlipayTemplate {
        
    
        // 应用ID,您的APPID，收款账号既是您的APPID对应支付宝账号
        public String app_id;
    
        // 商户私钥，您的PKCS8格式RSA2私钥
        public String merchant_private_key;
    
        // 支付宝公钥,查看地址：https://openhome.alipay.com/platform/keyManage.htm 对应APPID下的支付宝公钥。
        public String alipay_public_key;
    
        // 服务器[异步通知]页面路径  需http://格式的完整路径，不能加?id=123这类自定义参数，必须外网可以正常访问
        // 支付宝会悄悄的给我们发送一个请求，告诉我们支付成功的信息
        public String notify_url;
    
        // 页面跳转同步通知页面路径 需http://格式的完整路径，不能加?id=123这类自定义参数，必须外网可以正常访问
        //同步通知，支付成功，一般跳转到成功页
        public String return_url;
    
        // 签名方式
        private  String sign_type;
    
        // 字符编码格式
        private  String charset;
    
        //订单超时时间
        private String timeout = "1m";
    
        // 支付宝网关； https://openapi.alipaydev.com/gateway.do
        public String gatewayUrl;
    
        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("支付宝响应：登录页面的代码\n"+result);
    
            return result;
        }
    
        @Data
        public static class PayVo {
        
    
            private String out_trade_no; // 商户订单号 必填
            private String subject; // 订单名称 必填
            private String total_amount;  // 付款金额 必填
            private String body; // 商品描述 可空
        }
    }

**C、配置模板所需相关配置**

alipay:
      alipay_public_key: xxx
      app_id: 2021000117672854
      charset: utf-8
      gatewayUrl: https://openapi.alipaydev.com/gateway.do
      merchant_private_key: xxxx
      #此处先使用demo的回调接口页面
      notify_url: http://4wa8cx.natappfree.cc/alipay_trade_wap_pay_java_utf_8_Web_exploded/notify_url.jsp
      return_url: http://4wa8cx.natappfree.cc/alipay_trade_wap_pay_java_utf_8_Web_exploded/return_url.jsp
      sign_type: RSA2

**D、支付宝支付接口**

package com.fancy.gulimall.order.web;
    
    import com.alipay.api.AlipayApiException;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.ResponseBody;
    import com.fancy.gulimall.order.config.AlipayTemplate;
    import com.fancy.gulimall.order.service.OrderService;
    
    @Slf4j
    @Controller
    public class PayWebController {
        
        @Autowired
        private AlipayTemplate alipayTemplate;
        @Autowired
        private OrderService orderService;
        /**
         * 用户下单:支付宝支付
         * 1、让支付页让浏览器展示
         * 2、支付成功以后，跳转到用户的订单列表页
         * @param orderSn
         * @return
         * @throws AlipayApiException
         */
        @ResponseBody
        @GetMapping(value = "/aliPayOrder",produces = "text/html")
        public String aliPayOrder(@RequestParam("orderSn") String orderSn) throws AlipayApiException {
        
    
            AlipayTemplate.PayVo payVo = orderService.getOrderPay(orderSn);
            // 支付宝返回一个页面【支付宝账户登录的html页面】
            String pay = alipayTemplate.pay(payVo);
            System.out.println(pay);
            return pay;
        }
    }

获取当前订单的支付信息

/**
     * 获取当前订单的支付信息
     * @param orderSn
     * @return
     */
    AlipayTemplate.PayVo getOrderPay(String orderSn);

/**
     * 获取当前订单的支付信息
     */
    @Override
    public AlipayTemplate.PayVo getOrderPay(String orderSn) {
        
    
        AlipayTemplate.PayVo payVo = new AlipayTemplate.PayVo();
        OrderEntity orderInfo = this.getOrderByOrderSn(orderSn);
    
        //保留两位小数点，向上取值
        BigDecimal payAmount = orderInfo.getPayAmount().setScale(2, BigDecimal.ROUND_UP);
        payVo.setTotal_amount(payAmount.toString());
        payVo.setOut_trade_no(orderInfo.getOrderSn());
    
        //查询订单项的数据
        List<OrderItemEntity> orderItemInfo = orderItemService.list(
                new QueryWrapper<OrderItemEntity>().eq("order_sn", orderSn));
        OrderItemEntity orderItemEntity = orderItemInfo.get(0);
        payVo.setBody(orderItemEntity.getSkuAttrsVals());
    
        payVo.setSubject(orderItemEntity.getSkuName());
    
        return payVo;
    }

设置支付成功回调接口：  
修改return\_url地址为member服务的订单列表页请求地址

gulimall-order/src/main/resources/application.yaml

return_url: http://member.gulimall.com/memberOrder.html

**E、获取支付宝异步通知**

订单支付成功后支付宝会回调商户接口，这个时候需要修改订单状态  
由于同步跳转可能由于网络问题失败，所以使用异步通知  
支付宝使用的是最大努力通知方案，保障数据一致性，隔一段时间会通知商户支付成功，直到返回success

接收支付宝异步通知接口：

package com.fancy.gulimall.order.listener;
    
    import com.alipay.api.AlipayApiException;
    import com.alipay.api.internal.util.AlipaySignature;
    import com.fancy.gulimall.order.config.AlipayTemplate;
    import com.fancy.gulimall.order.service.OrderService;
    import com.fancy.gulimall.order.vo.PayAsyncVo;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.servlet.http.HttpServletRequest;
    import java.io.UnsupportedEncodingException;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    
    @RestController
    public class OrderPayedListener {
        
    
    
        @Autowired
        AlipayTemplate alipayTemplate;
    
        @Autowired
        OrderService orderService;
        /**
         * 支付宝成功异步通知
         * @param request
         * @return
         */
        @PostMapping("/payed/notify")
        public String handleAlipayed(PayAsyncVo vo,HttpServletRequest request) throws AlipayApiException, UnsupportedEncodingException {
        
            //只要我们收到了支付宝给我们异步的通知，告诉我们订单支付成功。返回success，支付宝就再也不通知
    //        Map<String, String[]> map = request.getParameterMap();
    //        for (String key : map.keySet()) {
        
    //            String value = request.getParameter(key);
    //            System.out.println("参数名："+key+"==>参数值："+value);
    //        }
            //验签
            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()); //调用SDK验证签名
            if(signVerified){
        
                System.out.println("签名验证成功...");
                String result = orderService.handlePayResult(vo);
                return result;
            }else {
        
                System.out.println("签名验证失败...");
                return "error";
            }
    
        }
    }

**F、收单**

*  订单在支付页，不支付，一直刷新，订单过期了才支付，订单状态改为已支付了，但是库存解锁了。
    
     *  使用支付宝自动收单功能解决。只要一段时间不支付，就不能支付了。

![在这里插入图片描述][524dbc575006487789018fd37946299a.png]

![在这里插入图片描述][f170e3ff35bf4b50a2ea3dd94bdd3a78.png]

*  由于时延等问题。订单解锁完成，正在解锁库存的时候，异步通知才到
    
     *  订单解锁，手动调用收单
 *  网络阻塞问题，订单支付成功的异步通知一直不到达
    
     *  查询订单列表时，ajax获取当前未支付的订单状态，查询订单状态时，再获取一下支付宝此订单的状态其他各种问题
 *  每天晚上闲时下载支付宝对账单，一一进行对账

[cdad77269a6345998c73a0e18d15f009.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/c70c963ca1e04719b02e6bf07c5f811a.png
[cc9a3040f2f24ee19ae183689babf89e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/bab5ce15c4b34238ae0cfaa055e749f4.png
[8059522ca4814686a5448c56fa50c8f7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/f2235c0108524b0a8c44c95e5792cc6e.png
[c4280f5bb2b84c1b80c15ae115a4ae7d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/30896be9213a45608f44a0f9cb71a959.png
[6eab8c09db4b4074bb36eb653855328f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/2fa2f1cde6fc434a9a2ea92c164fa6eb.png
[054b30bd399f4f3f8dbb08542d25ba97.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/8a49d21b862d46fdbe9ee0b49c2a66d4.png
[aeceb575151c42bab19cef619e94b1fa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/13a27158d585405abebedcf52982c773.png
[68220db56d024cf0bcac57a151384fe4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/ef8d64f24f174de19c2a88815c642b5c.png
[6a47a3b0c3184cc9874cf7578b4e49f7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/98806068cb7c4a479cd5e8b94d1887dc.png
[46bb278a67c04de49c1d25429c1448f3.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/c08673f20ab24294b62b2723b604cfad.png
[ea1a0c141d204e21a59707fcae774f49.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/d9febd97d94a48a5b4a5ed903f91c848.png
[a38dd25027b14a1bb83093ca8b840943.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/1c54693201bf46768678da3ec372ff8d.png
[6c418fbb94df426e81fec43fe08449cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/7146c99ae7064129a98e70a73bc87981.png
[1a60caf103ca43a59a61958764bcab17.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/4ed89f0ba67a4cf996a296cceabebe0b.png
[970b7478839d45dab18e6b8c0bfe376e.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/65c2032e94ad4e6783fe12fda0680c5e.jpeg
[f5b79bd3f8384277a082f8aa250b9055.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/87ffc9ab919348e59e09fff2f750e3c8.png
[524dbc575006487789018fd37946299a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/b70d748e42204456891d23d90142addc.png
[f170e3ff35bf4b50a2ea3dd94bdd3a78.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/41902ae822ab43e78f8f8ddadfe86393.png