乐优商城（14）–订单服务

乐优商城（14）–订单服务

一、创建订单微服务

1.1、创建订单父module

1.2、创建leyou-order-interface

pom文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>leyou-order</artifactId>
        <groupId>com.leyou.order</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>leyou-order-interface</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>persistence-api</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>6.1.6.Final</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.leyou.auth</groupId>
            <artifactId>leyou-auth-common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

1.3、创建leyou-order-service

pom文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>leyou-order</artifactId>
        <groupId>com.leyou.order</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>leyou-order-service</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- mybatis启动器 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!-- 通用Mapper启动器 -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.github.wxpay</groupId>
            <artifactId>wxpay-sdk</artifactId>
            <version>0.0.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.leyou.common</groupId>
            <artifactId>leyou-common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.leyou.auth</groupId>
            <artifactId>leyou-auth-common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.leyou.order</groupId>
            <artifactId>leyou-order-interface</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.leyou.item</groupId>
            <artifactId>leyou-item-interface</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

application.yaml

server:
  port: 8089
spring:
  application:
    name: order-service
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/leyou?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
    username: root
    password: 123456
    hikari:
      max-lifetime: 28830000 # 一个连接的生命时长（毫秒），超时而且没被使用则被释放（retired），缺省:30分钟，建议设置比数据库超时时长少30秒，参考MySQL wait_timeout参数（show variables like '%timeout%';）
      maximum-pool-size: 9 # 连接池中允许的最大连接数。缺省值：10；推荐的公式：((core_count * 2) + effective_spindle_count)
    driver-class-name: com.mysql.jdbc.Driver
  rabbitmq:
    host: IP地址
    username: leyou
    password: leyou
    virtual-host: /leyou
    template:
      retry:
        enabled: true
        initial-interval: 10000ms
        max-interval: 3000000ms
        multiplier: 2
      exchange: leyou.item.exchange
    publisher-confirm-type: correlated
  redis:
    host: IP地址
    port: 8975
  cloud:
    nacos:
      discovery:
        server-addr: IP地址:8848
        username: nacos
        password: nacos
mybatis:
  type-aliases-package: com.leyou.order.pojo
  mapper-locations: mapper/OrderMapper.xml
  configuration:
    map-underscore-to-camel-case: true
mapper:
  not-empty: false
  identity: mysql
leyou:
  worker:
    workerId: 1
    datacenterId: 1
  jwt:
    pubKeyPath: F:\\leyou\\rsa\\rsa.pub # 公钥地址
    cookieName: LY_TOKEN # cookie的名称
  pay:
    appId: wx8397f8696b538317	
    mchId: 1473426802
    key: T6m9iK73b0kn9g5v426MKfHQH7X8rKwb
    connectTimeoutMs: 5000
    readTimeoutMs: 10000

启动类

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class LeyouOrderApplication {

    public static void main(String[] args) {
        SpringApplication.run(LeyouOrderApplication.class,args);
    }
}

导入配置

订单号生成器，拦截器配置，支付配置，swagger配置

属性读取

拦截器

支付工具类

添加网关路由

二、实体类及Mapper

2.1、实体类

2.1.1、Order

@Table(name = "tb_order")
public class Order {

    @Id
    private Long orderId;// id
    @NotNull
    private Long totalPay;// 总金额
    @NotNull
    private Long actualPay;// 实付金额
    @NotNull
    private Integer paymentType; // 支付类型，1、在线支付，2、货到付款

    private String promotionIds; // 参与促销活动的id
    private String postFee;// 邮费
    private Date createTime;// 创建时间
    private String shippingName;// 物流名称
    private String shippingCode;// 物流单号
    private Long userId;// 用户id
    private String buyerMessage;// 买家留言
    private String buyerNick;// 买家昵称
    private Boolean buyerRate;// 买家是否已经评价
    private String receiver; // 收货人全名
    private String receiverMobile; // 移动电话
    private String receiverState; // 省份
    private String receiverCity; // 城市
    private String receiverDistrict; // 区/县
    private String receiverAddress; // 收货地址，如：xx路xx号
    private String receiverZip; // 邮政编码,如：310001
    private Integer invoiceType;// 发票类型，0无发票，1普通发票，2电子发票，3增值税发票
    private Integer sourceType;// 订单来源 1:app端，2：pc端，3：M端，4：微信端，5：手机qq端

    @Transient
    private List<OrderDetail> orderDetails; //订单信息集合

    @Transient
    private Integer status;     //订单状态
    //get和set
}

2.1.2、OrderDetail

@Table(name = "tb_order_detail")
public class OrderDetail {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private Long orderId;// 订单id

    private Long skuId;// 商品id

    private Integer num;// 商品购买数量

    private String title;// 商品标题

    private Long price;// 商品单价

    private String ownSpec;// 商品规格数据

    private String image;// 图片
    //get和set
}

2.1.3、OrderStatus

@Table(name = "tb_order_status")
public class OrderStatus {

    @Id
    private Long orderId;
    /**
     * 初始阶段：1、未付款、未发货；初始化所有数据
     * 付款阶段：2、已付款、未发货；更改付款时间
     * 发货阶段：3、已发货，未确认；更改发货时间、物流名称、物流单号
     * 成功阶段：4、已确认，未评价；更改交易结束时间
     * 关闭阶段：5、关闭； 更改更新时间，交易关闭时间。
     * 评价阶段：6、已评价
     */
    private Integer status;

    private Date createTime;// 创建时间

    private Date paymentTime;// 付款时间

    private Date consignTime;// 发货时间

    private Date endTime;// 交易结束时间

    private Date closeTime;// 交易关闭时间

    private Date commentTime;// 评价时间
    
    //get和set
}

一个订单对应好几种状态，通过表tb_order_status来记录订单所处的不同状态；一个订单有好多订单项，即多个商品信息，这个用表tb_order_detail来记录

2.2、Mapper

OrderMapper

/**
 * Order 的通用mapper
 */
public interface OrderMapper extends Mapper<Order> {
}

OrderDetailMapper

/**
 * OrderDetail 的通用mapper
 */
public interface OrderDetailMapper extends Mapper<OrderDetail>, InsertListMapper<OrderDetail> {
}

OrderStatus

/**
 * OrderStatus 的通用mapper
 */
public interface OrderStatusMapper extends Mapper<OrderStatus> {
}

在启动类中添加mapper扫描：

三、订单相关接口

3.1、创建订单

3.1.1、Controller

• 请求方式：POST
• 请求路径：/order
• 请求参数：order对象(包含订单、订单详情等数据的json对象。)
• 返回结果：订单编号

/**
 * 创建订单
 * @param order 订单对象
 * @return 订单编号
 */
@PostMapping
public ResponseEntity<Long> createOrder(@RequestBody @Valid Order order){
    Long id = this.orderService.createOrder(order);
    return new ResponseEntity<>(id, HttpStatus.CREATED);
}

3.1.2、Service

public interface OrderService {

    /**
     * 创建订单
     * @param order 订单对象
     * @return 订单编号
     */
    Long createOrder(Order order);
}

实现类：

@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private IdWorker idWorker;

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private OrderStatusMapper orderStatusMapper;

    @Autowired
    private OrderDetailMapper orderDetailMapper;

    private static final Logger logger = LoggerFactory.getLogger(OrderServiceImpl.class);

    @Transactional(rollbackFor = Exception.class)
    @Override
    public Long createOrder(Order order) {
        //1.生成orderId
        long orderId = idWorker.nextId();
        //2.获取登录的用户
        UserInfo userInfo = LoginInterceptor.getLoginUser();
        //3.初始化数据
        order.setBuyerNick(userInfo.getUsername());
        order.setBuyerRate(false);
        order.setCreateTime(new Date());
        order.setOrderId(orderId);
        order.setUserId(userInfo.getId());
        //4.保存数据
        this.orderMapper.insertSelective(order);

        //5.保存订单状态
        OrderStatus orderStatus = new OrderStatus();
        orderStatus.setOrderId(orderId);
        orderStatus.setCreateTime(order.getCreateTime());
        //初始状态未未付款：1
        orderStatus.setStatus(1);
        //6.保存数据
        this.orderStatusMapper.insertSelective(orderStatus);

        //7.在订单详情中添加orderId
        order.getOrderDetails().forEach(orderDetail -> orderDetail.setOrderId(orderId));
        //8.保存订单详情，使用批量插入功能
        this.orderDetailMapper.insertList(order.getOrderDetails());
        //9.减库存

        logger.debug("生成订单，订单编号：{}，用户id：{}", orderId, userInfo.getId());
        return orderId;
    }
}

基本逻辑：

• 生成订单id
• 获取登录用户的信息
• 初始化订单数据：买家昵称、是否评论、创建时间、订单号、用户id
• 保存订单数据
• 初始化订单状态数据：订单id、订单创建时间、订单状态（初始状态：1，未付款）
• 保存订单状态数据
• 为订单详情中的数据添加订单号，因为一个订单下有多个订单项
• 保存订单详情数据
• 减库存

3.2、订单查询

3.2.1、Controller

• 请求方式：GET
• 请求路径：/order/{id}
• 请求参数：id，订单编号
• 返回结果：Order，订单的json对象

/**
 * 根据订单id查询订单
 * @param id 订单编号
 * @return 订单对象
 */
@GetMapping("/{id}")
public ResponseEntity<Order> queryOrderById(@PathVariable("id") Long id){
    Order order = this.orderService.queryOrderById(id);
    if (order == null){
        return ResponseEntity.notFound().build();
    }
    return ResponseEntity.ok(order);
}

3.2.2、Service

/**
 * 根据订单id查询订单
 * @param id 订单编号
 * @return 订单对象
 */
Order queryOrderById(Long id);

实现类：

/**
 * 根据订单id查询订单
 *
 * @param id 订单编号
 * @return 订单对象
 */
@Override
public Order queryOrderById(Long id) {
    //先查询订单
    Order order = this.orderMapper.selectByPrimaryKey(id);
    //再查询订单详细信息
    OrderDetail orderDetail = new OrderDetail();
    orderDetail.setOrderId(id);
    List<OrderDetail> orderDetails = this.orderDetailMapper.select(orderDetail);
    if (CollectionUtils.isEmpty(orderDetails)) return null;
    //order对象填充订单详情
    order.setOrderDetails(orderDetails);
    // 查询订单状态
    OrderStatus orderStatus = this.orderStatusMapper.selectByPrimaryKey(id);
    //order对象设置订单状态
    order.setStatus(orderStatus.getStatus());
    return order;
}

基本逻辑：

• 根据订单号查询订单对象
• 根据订单号查询订单详情
• 根据订单号查询订单状态
• 给已经查询到的订单对象填充订单详情
• 给已经查询到的订单对象设置订单状态

3.3、分页查询用户订单

3.3.1、Controller

• 请求方式：Get
• 请求路径：/order/list
• 请求参数：
  • page：当前页，Integer类型，默认为1
  • rows：每页大小，Integer类型，默认为5
  • status：订单状态，String类型，默认查询全部状态订单
• 返回结果：PageResult 对象，包含下面属性：
  • total：总条数
  • items：当前页订单数组
    • 订单对象

/**
 * 分页查询当前已经登录的用户订单
 * @param page 页数
 * @param rows 每页大小
 * @param status 订单状态
 * @return
 */
@GetMapping("/list")
public ResponseEntity<PageResult<Order>> queryOrderList(
        @RequestParam(value = "page",defaultValue = "1")Integer page,
        @RequestParam(value = "rows",defaultValue = "5")Integer rows,
        @RequestParam(value = "status",required = false)Integer status
){

    PageResult<Order> orders = this.orderService.queryOrderList(page,rows,status);
    if (null == orders){
        return new ResponseEntity<>(HttpStatus.NOT_FOUND);
    }
    return ResponseEntity.ok(orders);
}

3.3.2、Service

/**
 * 分页查询当前已经登录的用户订单
 * @param page 页数
 * @param rows 每页大小
 * @param status 订单状态
 * @return
 */
PageResult<Order> queryOrderList(Integer page, Integer rows, Integer status);

实现类：

/**
 * 分页查询当前已经登录的用户订单
 *
 * @param page   页数
 * @param rows   每页大小
 * @param status 订单状态
 * @return
 */
@Override
public PageResult<Order> queryOrderList(Integer page, Integer rows, Integer status) {
    //订单状态查询，需自定义sql
    //分页条件
    try {
        PageHelper.startPage(page,rows);
        //获取用户id
        UserInfo userInfo = LoginInterceptor.getLoginUser();
        //查询数据
        Page<Order> pageInfo = (Page<Order>)this.orderMapper.queryOrderList(userInfo.getId(), status);

        List<Order> orders = pageInfo.getResult();
        orders.forEach(order -> {
            Example example = new Example(OrderDetail.class);
            //查询该订单下的所有订单项
            example.createCriteria().andEqualTo("orderId",order.getOrderId());
            //获取订单项的具体信息
            List<OrderDetail> orderDetails = this.orderDetailMapper.selectByExample(example);
            order.setOrderDetails(orderDetails);
        });
        return new PageResult<>(pageInfo.getTotal(),pageInfo.getPages(), orders);
    } catch (Exception e) {
        logger.error("查询订单出错",e);
        return null;
    }
}

基本逻辑：

• 对结果进行分页
• 获取登录用户
• 根据用户信息查询订单
• 订单详情填充
• 返回分页结果

3.3.3、Mapper

订单的分页查询需要根据订单状态来筛选，后期要分别对其进行展示，而订单状态是在单独一个表中，要进行分页查询的话，只能是tb_order表和tb_order_status两个表先进行连接，然后对其进行分页查询，查询完毕后再填充订单详情。这里用mybatis的xml配置文件方式来进行查询

对应的mapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.leyou.order.mapper.OrderMapper">

    <resultMap id="orderWithDetail" type="com.leyou.order.pojo.Order" autoMapping="true">
        <id column="order_id" property="orderId" />
        <collection property="orderDetails" javaType="List" ofType="com.leyou.order.pojo.OrderDetail" autoMapping="true">
            <id property="id" column="id" />
        </collection>
    </resultMap>

    <select id="queryOrderList" resultMap="orderWithDetail">
        select o.order_id,o.total_pay,o.actual_pay,o.create_time,os.status,
        od.sku_id,od.num,od.title,od.own_spec,od.price,od.image
        from tb_order o
        left join tb_order_status os on o.order_id = os.order_id
        left join tb_order_detail od on o.order_id = od.order_id
        where o.user_id = #{userId}
        <if test="status != null and status != 0">
            and os.status = #{status}
        </if>
        order by o.create_time desc
    </select>
</mapper>

OrderMapper

/**
 * 分页查询当前用户订单
 * @param userId
 * @param status
 * @return
 */
List<Order> queryOrderList(@Param("userId")Long userId, @Param("status")Integer status);

3.4、更新订单状态

3.4.1、Controller

• 请求参数：PUT
• 请求路径：/order/{id}/{status}
• 请求参数：
  • id：订单编号，String类型，不能为空
  • status：订单状态，不能为空
• 返回结果：null

/**
 * 更新订单状态
 * @param id
 * @param status
 * @return
 */
@PutMapping("/{id}/{status}")
public ResponseEntity<Boolean> updateOrderStatus(@PathVariable("id") Long id,
                                                 @PathVariable("status") Integer status){
    Boolean bool = this.orderService.updateOrderStatus(id,status);
    if (null == bool){
        //返回400
        return ResponseEntity.badRequest().build();
    }
    //返回204
    return ResponseEntity.noContent().build();
}

3.4.2、Service

/**
 * 更新订单状态
 * @param id
 * @param status
 * @return
 */
Boolean updateOrderStatus(Long id, Integer status);

实现类：

/**
 * 更新订单状态
 *
 * @param id
 * @param status
 * @return
 */
@Override
public Boolean updateOrderStatus(Long id, Integer status) {
    OrderStatus orderStatus = new OrderStatus();
    orderStatus.setOrderId(id);
    orderStatus.setStatus(status);
    //根据状态的不同更新不同的字段
    switch (status){
        case 2:
            orderStatus.setPaymentTime(new Date());//2.付款时间
            break;
        case 3:
            orderStatus.setConsignTime(new Date());//3.发货时间
            break;
        case 4:
            orderStatus.setEndTime(new Date());//4.确认收货，订单结束
            break;
        case 5:
            orderStatus.setCloseTime(new Date());//5.交易失败，订单关闭
            break;
        case 6:
            orderStatus.setCommentTime(new Date());//6.评价时间
            break;
        default:
            return null;
    }
    return this.orderStatusMapper.updateByPrimaryKeySelective(orderStatus) == 1;
}

基本逻辑：

• 根据用户id和订单状态构造orderStatus对象
• 根据status的不同判断是哪一个状态，然后修改对应的时间
• 然后返回更新结果

3.5、生成微信支付链接

3.5.1、Controller

• 请求方式：Get
• 请求路径：/order/url/{id}
• 请求参数：id，订单编号
• 返回结果：String类型，生成的微信支付链接

/**
 * 根据订单id生成支付链接
 * @param orderId
 * @return
 */
@GetMapping("/url/{id}")
public ResponseEntity<String> generateUrl(@PathVariable("id") Long orderId){
    //生成付款链接
    String payUrl = this.payHelper.createPayUrl(orderId);
    if (StringUtils.isBlank(payUrl)){
        return ResponseEntity.notFound().build();
    }
    return ResponseEntity.ok(payUrl);
}

3.6、查询付款状态

3.6.1、Controller

• 请求方式： Get
• 请求路径： /state/{id}
• 请求参数： id，订单编号
• 返回结果：0, 未支付 1,支付成功 2,支付失败（查询失败，或者订单过期）

/**
 * 查询付款状态
 * @param orderId
 * @return 0, 状态查询失败 1,支付成功 2,支付失败
 */
@GetMapping("/state/{id}")
public ResponseEntity<Integer> queryPayState(@PathVariable("id") Long orderId){
    PayState payState = this.payHelper.queryOrder(orderId);
    return ResponseEntity.ok(payState.getValue());
}

四、Swagger-UI

4.1、什么是OpenAPI

随着互联网技术的发展，现在的网站架构基本都由原来的后端渲染，变成了：前端渲染、前后端分离的形态，而且前端技术和后端技术在各自的道路上越走越远。 前端和后端的唯一联系，变成了API接口；API文档变成了前后端开发人员联系的纽带，变得越来越重要。

没有API文档工具之前，大家都是手写API文档的，在什么地方书写的都有，而且API文档没有统一规范和格式，每个公司都不一样。这无疑给开发带来了灾难。

OpenAPI规范（OpenAPI Specification 简称OAS）是Linux基金会的一个项目，试图通过定义一种用来描述API格式或API定义的语言，来规范RESTful服务开发过程。目前V3.0版本的OpenAPI规范已经发布并开源在github上 。

官网：https://github.com/OAI/OpenAPI-Specification

4.2、什么是swagger？

OpenAPI是一个编写API文档的规范，然而如果手动去编写OpenAPI规范的文档，是非常麻烦的。而Swagger就是一个实现了OpenAPI规范的工具集。

官网：https://swagger.io/

看官方的说明：

Swagger包含的工具集：

• Swagger编辑器： Swagger Editor允许您在浏览器中编辑YAML中的OpenAPI规范并实时预览文档。
• Swagger UI： Swagger UI是HTML，Javascript和CSS资产的集合，可以从符合OAS标准的API动态生成漂亮的文档。
• **Swagger Codegen：**允许根据OpenAPI规范自动生成API客户端库（SDK生成），服务器存根和文档。
• **Swagger Parser：**用于解析来自Java的OpenAPI定义的独立库
• **Swagger Core：**与Java相关的库，用于创建，使用和使用OpenAPI定义
• Swagger Inspector（免费）： API测试工具，可让您验证您的API并从现有API生成OpenAPI定义
• SwaggerHub（免费和商业）： API设计和文档，为使用OpenAPI的团队构建。

4.3、快速入门

SpringBoot已经集成了Swagger，使用简单注解即可生成swagger的API文档。

引入依赖

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.8.0</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.8.0</version>
</dependency>

编写配置

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .host("localhost:8089")
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.leyou.order.controller"))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("乐优商城订单系统")
                .description("乐优商城订单系统接口文档")
                .version("1.0")
                .build();
    }
}

接口声明

在controller的每个handler上添加接口说明注解：

@RestController
@RequestMapping("/order")
@Api("订单服务接口")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @Autowired
    private PayHelper payHelper;

    /**
     * 创建订单
     * @param order 订单对象
     * @return 订单编号
     */
    @PostMapping
    @ApiOperation(value = "创建订单的接口，返回订单编号",notes = "创建订单")
    @ApiImplicitParam(name = "order",required = true,value = "订单的json对象，包含订单条目和物流信息")
    @ApiResponses({
            @ApiResponse(code = 200,message = "购物请求已接受，但是库存不足"),
            @ApiResponse(code = 201,message = "订单成功创建")
    })
    public ResponseEntity<Long> createOrder(@RequestBody @Valid Order order){
        Long id = this.orderService.createOrder(order);
        return new ResponseEntity<>(id, HttpStatus.CREATED);
    }

    /**
     * 根据订单id查询订单
     * @param id 订单编号
     * @return 订单对象
     */
    @GetMapping("/{id}")
    @ApiOperation(value = "根据订单编号查询订单，返回订单对象",notes = "查询订单")
    @ApiImplicitParam(name = "id",required = true,value = "订单的编号")
    @ApiResponses({
            @ApiResponse(code = 200,message = "订单查询成功"),
            @ApiResponse(code = 404,message = "订单未找到")
    })
    public ResponseEntity<Order> queryOrderById(@PathVariable("id") Long id){
        Order order = this.orderService.queryOrderById(id);
        if (order == null){
            return ResponseEntity.notFound().build();
        }
        return ResponseEntity.ok(order);
    }

    /**
     * 分页查询当前已经登录的用户订单
     * @param page 页数
     * @param rows 每页大小
     * @param status 订单状态
     * @return
     */
    @GetMapping("/list")
    @ApiOperation(value = "分页查询当前用户订单，并且可以根据订单状态过滤",notes = "分页查询当前用户订单")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "page", value = "当前页", defaultValue = "1", type = "Integer"),
            @ApiImplicitParam(name = "rows", value = "每页大小", defaultValue = "5", type = "Integer"),
            @ApiImplicitParam(name = "status", value = "订单状态：1未付款，2已付款未发货，3已发货未确认，4已确认未评价，5交易关闭，6交易成功，已评价", type = "Integer")
    })
    @ApiResponses({
            @ApiResponse(code = 200,message = "订单的分页结果"),
            @ApiResponse(code = 404,message = "没有查询到结果"),
            @ApiResponse(code = 500,message = "查询失败")
    })
    public ResponseEntity<PageResult<Order>> queryOrderList(
            @RequestParam(value = "page",defaultValue = "1")Integer page,
            @RequestParam(value = "rows",defaultValue = "5")Integer rows,
            @RequestParam(value = "status",required = false)Integer status
    ){

        PageResult<Order> orders = this.orderService.queryOrderList(page,rows,status);
        if (null == orders){
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
        return ResponseEntity.ok(orders);
    }

    /**
     * 更新订单状态
     * @param id
     * @param status
     * @return
     */
    @PutMapping("/{id}/{status}")
    @ApiOperation(value = "根据订单id更新订单状态",notes = "更新订单状态")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id",value = "订单编号",required = true,type = "Long"),
            @ApiImplicitParam(name = "status",value = "订单状态：1未付款，2已付款未发货，3已发货未确认，4已确认未评价，5交易关闭，6交易成功，已评价",type = "Integer")
    })
    @ApiResponses({
            @ApiResponse(code = 204,message = "true：修改状态成功；false：修改状态失败"),
            @ApiResponse(code = 400,message = "请求参数有误"),
            @ApiResponse(code = 500,message = "查询失败")
    })
    public ResponseEntity<Boolean> updateOrderStatus(@PathVariable("id") Long id,
                                                     @PathVariable("status") Integer status){
        Boolean bool = this.orderService.updateOrderStatus(id,status);
        if (null == bool){
            //返回400
            return ResponseEntity.badRequest().build();
        }
        //返回204
        return ResponseEntity.noContent().build();
    }

    /**
     * 根据订单id生成支付链接
     * @param orderId
     * @return
     */
    @GetMapping("/url/{id}")
    @ApiOperation(value = "根据订单编号生成支付链接",notes = "生成付款链接")
    @ApiImplicitParam(name = "id",value = "订单编号",type = "Long")
    @ApiResponses({
            @ApiResponse(code = 200,message = "成功生成支付链接"),
            @ApiResponse(code = 404,message = "生成支付链接失败"),
            @ApiResponse(code = 500,message = "服务器异常")
    })
    public ResponseEntity<String> generateUrl(@PathVariable("id") Long orderId){
        //生成付款链接
        String payUrl = this.payHelper.createPayUrl(orderId);
        if (StringUtils.isBlank(payUrl)){
            return ResponseEntity.notFound().build();
        }
        return ResponseEntity.ok(payUrl);
    }

    /**
     * 查询付款状态
     * @param orderId
     * @return 0, 状态查询失败 1,支付成功 2,支付失败
     */
    @GetMapping("/state/{id}")
    @ApiOperation(value = "根据订单编号查询扫码支付付款状态",notes = "查询付款状态")
    @ApiImplicitParam(name = "id",value = "订单编号",type = "Long")
    @ApiResponses({
            @ApiResponse(code = 200,message = "0, 状态查询失败 1,支付成功 2,支付失败"),
            @ApiResponse(code = 500,message = "服务器异常")
    })
    public ResponseEntity<Integer> queryPayState(@PathVariable("id") Long orderId){
        PayState payState = this.payHelper.queryOrder(orderId);
        return ResponseEntity.ok(payState.getValue());
    }
}

常用注解说明：

/**
 @Api：修饰整个类，描述Controller的作用
 @ApiOperation：描述一个类的一个方法，或者说一个接口
 @ApiParam：单个参数描述
 @ApiModel：用对象来接收参数
 @ApiProperty：用对象接收参数时，描述对象的一个字段
 @ApiResponse：HTTP响应其中1个描述
 @ApiResponses：HTTP响应整体描述
 @ApiIgnore：使用该注解忽略这个API
 @ApiError ：发生错误返回的信息
 @ApiImplicitParam：一个请求参数
 @ApiImplicitParams：多个请求参数
 */

4.4、启动测试

4.4.1、错误解决

错误1

返回401，未授权。因为订单服务配置了拦截器，来获取用户信息，所以会拦截所有访问该端口的请求，当访问swagger-ui时直接将请求发送到controller中，导致访问失败。

具体看拦截器配置：

这里是拦截了所有请求，这里将该路径排除拦截即可：

再次访问http://localhost:8089/swagger-ui.html，不会引发401错误了

注意：导致401错误还有可能有该注解：@EnableWebMvc

后期在处理Long类型数据以json形式返回时的问题，会配置一个转换器，要用到这个注解。在进行接口测试时将其注释掉。

错误2

打开浏览器查看，可以发现产生这个问题的原因是无法加载swagger的ui文件：

还是因为拦截器的问题，那么过滤掉即可：

错误三

打开浏览器控制台查看，还存在一些资源有401错误，仔细观察都是在请求webjars路径下的资源，拦截器过滤即可：

总结

无法访问swagger-ui最主要的原因是拦截器的问题：

@Override
public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(loginInterceptor)
            .addPathPatterns("/**")
            .excludePathPatterns("/swagger-ui.html")
            .excludePathPatterns("/swagger-resources/**")
            .excludePathPatterns("/webjars/**");
}

4.4.2、查看接口信息

点击任意一个接口，即可看到详细信。

4.5、测试接口

4.5.1、创建订单接口

可以通过页面看到接口信息：

• 请求方式：POST
• 请求路径：/order
• 请求参数：包含订单、订单详情等数据的json对象。
• 返回结果：订单编号

点击Try It Out来测试：

输入数据：

{
  "totalPay": 236800,
  "postFee": 0,
  "paymentType": 2,
  "actualPay": 236800,
  "buyerMessage": null,
  "buyerNick": "huge",
  "orderDetails": [
    {
      "skuId": 3893493,
      "num": 1,
      "title": "苹果（Apple）iPhone 6 (A1586) 16GB 金色 移动联通电信4G手机3",
      "price": 236800,
      "ownSpec": "{\"机身颜色\":\"钻雕蓝\",\"内存\":\"4GB\",\"机身存储\":\"64GB\"}",
      "image": "http://image.leyou.com/images/9/4/1524297342728.jpg"
    }
  ],
  "receiver": "销户",
  "receiverMobile": "15800000000",
  "receiverState": "上海",
  "receiverCity": "上海",
  "receiverDistrict": "浦东新签",
  "receiverAddress": "航头镇航头路18号塞上3号楼",
  "receiverZip": "210000",
  "invoiceType": 0,
  "sourceType":2
}

然后点击execute：

查看结果：

401 未授权，因为下订单需要用户登录，要携带token

通过ApiPost登录生成token

把token的值手动加入到浏览器的cookie中

再次执行

添加成功，响应订单编号

查看数据库：

有数据，但是数据不一致，出现了精度损失，后面解决

4.5.2、生成ID的方式

订单id的特殊性

订单数据非常庞大，将来一定会做分库分表。那么这种情况下， 要保证id的唯一，就不能靠数据库自增，而是自己来实现算法，生成唯一id。

雪花算法

这里的订单id是通过一个工具类生成的：

而工具类所采用的生成id算法，是由Twitter公司开源的snowflake（雪花）算法。

简单原理

雪花算法会生成一个64位的二进制数据，为一个Long型。(转换成字符串后长度最多19) ，其基本结构：

第一位：为未使用

第二部分：41位为毫秒级时间(41位的长度可以使用69年)

第三部分：5位datacenterId和5位workerId(10位的长度最多支持部署1024个节点）

第四部分：最后12位是毫秒内的计数（12位的计数顺序号支持每个节点每毫秒产生4096个ID序号）

snowflake生成的ID整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞（由datacenter和workerId作区分），并且效率较高。经测试snowflake每秒能够产生26万个ID。

使用

需要机器id和序列号：

加载属性：

@ConfigurationProperties(prefix = "leyou.worker")
public class IdWorkerProperties {

    private long workerId;// 当前机器id

    private long datacenterId;// 序列号

    public long getWorkerId() {
        return workerId;
    }

    public void setWorkerId(long workerId) {
        this.workerId = workerId;
    }

    public long getDatacenterId() {
        return datacenterId;
    }

    public void setDatacenterId(long datacenterId) {
        this.datacenterId = datacenterId;
    }
}

编写配置类：

使用：

4.5.3、查询订单接口

接口说明：

• 请求方式：GET
• 请求路径：/order/{id}
• 请求参数：id，订单编号
• 返回结果：Order，订单的json对象

输入数据的订单id，测试：

结果：

4.5.4、更新订单状态

• 请求参数：PUT
• 请求路径：/order/{id}/{status}
• 请求参数：
  • id：订单编号，String类型，不能为空
  • status：订单状态，不能为空
• 返回结果：null

测试：

结果

数据库中也发生了改变：

4.5.5、分页查询订单

接口说明：

• 请求方式：Get
• 请求路径：/order/list
• 请求参数：
  • page：当前页，Integer类型，默认为1
  • rows：每页大小，Integer类型，默认为5
  • status：订单状态，String类型，默认查询全部状态订单
• 返回结果：PageResult 对象，包含下面属性：
  • total：总条数
  • items：当前页订单数组
    • 订单对象

测试

这里status参数未填写，默认查询所有订单

4.5.6、生成微信付款链接

接口说明：

• 请求方式：Get
• 请求路径：/order/url/{id}
• 请求参数：id，订单编号
• 返回结果：String类型，生成的微信支付链接

测试

结果

微信支付相关

PayHelper支付工具类，PayStatue支付状态枚举类

4.5.7、查询支付状态

接口说明：

• 请求方式： Get
• 请求路径： /state/{id}
• 请求参数： id，订单编号
• 返回结果：0, 未支付 1,支付成功 2,支付失败（查询失败，或者订单过期）

未付款查询

结果

因为尚未付款，所以查询返回0

已付款查询

这里打开index.html，输入生成的微信支付链接，会生成一个二维码：

扫码支付，然后再次查询.

这里需要真实付款，就不演示了 0.0，略…