支付功能

后端

支付流程图

  • 课程分为免费课程和付费课程，如果是免费课程可以直接观看，如果是付费观看的课程，用户需下单支付后才可以观看

image.png

  • 如果是免费课程，在用户选择课程，进入到课程详情页面时候，直接显示 “立即观看”，用户点击立即观看，可以切换到播放列表进行视频播放

image.png

  • 如果是付费课程，在用户选择课程，进入到课程详情页面时候，会显示 “立即购买”

image.png

  • 点击“立即购买”，会生成课程的订单，跳转到订单页面

image.png

  • 点击“去支付”，会跳转到支付页面，生成微信扫描的二维码

image.png

  • 使用微信扫描支付后，会跳转回到课程详情页面，同时显示“立即观看

image.png

搭建环境

  • 创建service-order工程，导入依赖 

    1. <dependencies>
    2.  <dependency>
    3.      <groupId>com.github.wxpay</groupId>
    4.      <artifactId>wxpay-sdk</artifactId>
    5.      <version>0.0.3</version>
    6.  </dependency>
    8.  <dependency>
    9.      <groupId>com.alibaba</groupId>
    10.      <artifactId>fastjson</artifactId>
    11.  </dependency>
    12. </dependencies>

  • 配置文件 

    1. server:
    2. port: 8007             # 服务端口
    3. spring:
    4. application:
    5.  name: service-order  # 微服务名称
    6. profiles:
    7.  active: dev          # 设置为开发环境
    8. datasource:            # 配置数据源
    9.  driver-class-name: com.mysql.cj.jdbc.Driver
    10.  url: jdbc:mysql://localhost:3306/guli_edu?characterEncoding=utf-8&serverTimezone=GMT%2B8
    11.  username: root
    12.  password: root
    13. jackson:                            # 配置json全局时间
    14.  date-format: yyyy-MM-dd HH:mm:ss  # 配置返回json的时间格式
    15.  time-zone: GMT+8                  # json是格林尼治时间，和我们相差8小时，需要加上8
    16. cloud:
    17.  nacos:
    18.    discovery:
    19.      server-addr: 127.0.0.1:8848   # nacos服务地址
    20. redis:
    21.  host: 192.168.241.130             # ip地址
    22.  port: 6379                        # 端口号
    23.  database: 0
    24.  timeout: 1800000                  # 超时时间
    25.  lettuce:
    26.    pool:
    27.      max-active: 20
    28.      max-wait: -1                  # 最大阻塞等待时间(负数表示没限制)
    29.      max-idle: 5
    30.      min-idle: 0
    31. mybatis-plus:                         # mybatis-plus日志
    32. configuration:
    33.  log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    34. mapper-locations: classpath:com/atguigu/orderservice/mapper/xml/*.xml
    35. feign:
    36. hystrix:
    37.  enabled: true                     # 开启熔断机制
    38. wx:
    39. pay:
    40.  appId: wx74862e0dfcf69954   #关联的公众号appid
    41.  partner: 1558950191         #商户号
    42.  partnerkey: T6m9iK73b0kn9g5v426MKfHQH7X8rKwb  # 商户key
    43.  notifyurl: http://guli.shop/api/order/weixinPay/weixinNotify
    44.  spbillCreateIp: 127.0.0.1
    45.  sendAddress: https://api.mch.weixin.qq.com/pay/unifiedorder   # wx提供获取二维码地址的请求地址
    46.  sendAddressPay: https://api.mch.weixin.qq.com/pay/orderquery  # wx提供支付的地址

  • 主启动类 

    1. @SpringBootApplication
    2. @MapperScan("com.atguigu.orderservice.mapper")
    3. @ComponentScan("com.atguigu")
    4. @EnableDiscoveryClient  // 开启nacos注册
    5. @EnableFeignClients
    6. public class OrderApplication {
    7.  public static void main(String[] args) {
    8.      SpringApplication.run(OrderApplication.class, args);
    9.  }
    10. }

  • 代码生成器生成项目结构，表名为t_order，注意添加自动填充字段

生成订单

  • controller创建订单接口 

    1. @PostMapping("saveOrder/{courseId}")
    2. public ResultEntity saveOrder(@PathVariable String courseId, HttpServletRequest request) {
    3.  // 获取用户id
    4.  String memberId = JwtUtils.getMemberIdByJwtToken(request);
    5.  String orderId = orderService.saveOrder(courseId, memberId);
    6.  return ResultEntity.ok().data("orderId", orderId);
    7. }

  • common工程中，创建DO类传输数据 

    1. @Data
    2. @ApiModel(value = "CourseInfo信息对象用于订单", description = "传输CourseInfo信息")
    3. public class CourseInfoDO {
    4.  @ApiModelProperty(value = "课程讲师ID")
    5.  private String teacherId;
    7.  @ApiModelProperty(value = "课程标题")
    8.  private String title;
    10.  @ApiModelProperty(value = "课程销售价格，设置为0则可免费观看")
    11.  private BigDecimal price;
    13.  @ApiModelProperty(value = "总课时")
    14.  private Integer lessonNum;
    16.  @ApiModelProperty(value = "课程封面图片路径")
    17.  private String cover;
    19.  @ApiModelProperty(value = "课程简介")
    20.  private String description;
    21. }

    ```java @Data @ApiModel(value = “TeacherInfo信息对象用于订单和评论”, description = “传输TeacherInfo信息”) public class TeacherInfoDO {

    @ApiModelProperty(value = “讲师姓名”) private String name;

}

  2. -  service_edu工程通过课程id查询课程信息接口  
  3. ```java
  4. @GetMapping("getCourseInfoByCourseId/{courseId}")
  5. public CourseInfoDO getCourseInfoByCourseId(@PathVariable String courseId) {
  6.     CourseInfoVO courseInfoVO = eduCourseService.getCourseInfoVO(courseId);
  7.     CourseInfoDO courseInfoDO = new CourseInfoDO();
  8.     BeanUtils.copyProperties(courseInfoVO, courseInfoDO);
  9.     return courseInfoDO;
  10. }

  • service_ucenter查询信息 

    1. // 用户id获取用户信息
    2. @GetMapping("getLoginInfoById/{memberId}")
    3. public LoginInfoDO getLoginInfoById(@PathVariable String memberId) {
    4.  UcenterMember ucenterMember = ucenterMemberService.getById(memberId);
    5.  LoginInfoDO loginInfoDO = new LoginInfoDO();
    6.  BeanUtils.copyProperties(ucenterMember, loginInfoDO);
    7.  return loginInfoDO;
    8. }

  • 代理接口 

    1. @Component
    2. @FeignClient(name = "service-edu", fallback = com.atguigu.orderservice.client.EduDegradeFeignClient.class)
    3. public interface EduClient {
    4.  @GetMapping("/eduservice/front-course/getCourseInfoByCourseId/{courseId}")
    5.  public CourseInfoDO getCourseInfoByCourseId(@PathVariable("courseId") String courseId);
    7.  @GetMapping("/eduservice/front-teacher/getTeacherName/{teacherId}")
    8.  public TeacherInfoDO getTeacherName(@PathVariable("teacherId") String teacherId);
    9. }
    1. @Component
    2. @FeignClient(name = "service-ucenter", fallback = com.atguigu.orderservice.client.MemberDegradeFeignClient.class)
    3. public interface MemberClient {
    4.  // 用户id获取用户信息
    5.  @GetMapping("/ucenterservice/ucenter-member/getLoginInfoById/{memberId}")
    6.  public LoginInfoDO getLoginInfoById(@PathVariable("memberId") String memberId);
    7. }

  • impl实现订单生成 

    1. @Service
    2. @Transactional(readOnly = true)
    3. public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {
    5.  @Autowired
    6.  private EduClient eduClient;
    8.  @Autowired
    9.  private MemberClient memberClient;
    11.  @Override
    12.  @Transactional(readOnly = false, rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
    13.  public String saveOrder(String courseId, String memberId) {
    14.      // 调用member模块获取用户信息
    15.      LoginInfoDO loginInfoById = memberClient.getLoginInfoById(memberId);
    17.      // 调用edu模块获取课程信息
    18.      CourseInfoDO courseInfoByCourseId = eduClient.getCourseInfoByCourseId(courseId);
    20.      // 调用edu模块获取讲师Name
    21.      TeacherInfoDO teacherName = eduClient.getTeacherName(courseInfoByCourseId.getTeacherId());
    23.      //创建订单
    24.      Order order = new Order();
    25.      order.setOrderNo(OrderNoUtil.getOrderNo()); // 通过工具类生成订单id
    26.      order.setCourseId(courseId);
    27.      order.setCourseTitle(courseInfoByCourseId.getTitle());
    28.      order.setCourseCover(courseInfoByCourseId.getCover());
    29.      order.setTeacherName(teacherName.getName());
    30.      order.setTotalFee(courseInfoByCourseId.getPrice());
    31.      order.setMemberId(memberId);
    32.      order.setMobile(loginInfoById.getMobile());
    33.      order.setNickname(loginInfoById.getNickname());
    34.      order.setStatus(0);
    35.      order.setPayType(1);  // 1代表微信支付，默认为1
    37.      baseMapper.insert(order);
    39.      return order.getOrderNo(); // 返回order_no，注意不是id
    40.  }
    41. }

通过订单id获取订单

  • controller 

    1. @GetMapping("getOrderInfoByOrederNo/{orderNo}")
    2. public ResultEntity getOrderInfoByOrderNo(@PathVariable String orderNo) {
    3.  Order order = orderService.getOrderByOrderNo(orderNo);
    4.  return ResultEntity.ok().data("order", order);
    5. }

  • impl实现 

    1. @Override
    2. public Order getOrderByOrderNo(String orderNo) {
    3.  QueryWrapper<Order> orderQueryWrapper = new QueryWrapper<>();
    4.  orderQueryWrapper.eq("order_no", orderNo);
    5.  Order order = baseMapper.selectOne(orderQueryWrapper);
    6.  return order;
    7. }

生成微信支付二维码

  • controller接口 

    1. @RestController
    2. @RequestMapping("/orderservice/pay-log")
    3. //@CrossOrigin
    4. public class PayLogController {
    6.  @Autowired
    7.  private PayLogService payLogService;
    9.  // 生成二维码
    10.  @GetMapping("createNative/{orderId}")
    11.  public ResultEntity createNative(@PathVariable String orderId) {
    12.      Map map = payLogService.createNative(orderId);
    13.      return ResultEntity.ok().data(map);
    14.  }
    16.  // 根据订单号查询支付状态
    17.  @GetMapping("getOrderStatus/{orderId}")
    18.  public ResultEntity getOrderStatus(@PathVariable String orderId) {
    19.      // 获取返回的结果集
    20.      Map map = payLogService.queryPayStatus(orderId);
    22.      if (map == null) {
    23.          return ResultEntity.error().message("支付失败!");
    24.      }
    26.      // 支付成功
    27.      if (map.get("trade_state").equals("SUCCESS")) {
    28.          // 修改订单的状态
    29.          payLogService.updateOrderStatus(map);
    30.          return ResultEntity.ok().message("支付成功!");
    31.      }
    33.      return ResultEntity.ok().code(25000).message("正在支付!");
    34.  }
    35. }

  • service 

    1. @Service
    2. public class PayLogServiceImpl extends ServiceImpl<PayLogMapper, PayLog> implements PayLogService {
    4.  @Autowired
    5.  private OrderService orderService;
    7.  @Autowired
    8.  private RedisTemplate redisTemplate;
    10.  @Override
    11.  public Map createNative(String orderId) {
    12.      try {
    13.          // 根据订单id获取订单信息
    14.          QueryWrapper<Order> orderQueryWrapper = new QueryWrapper<>();
    15.          orderQueryWrapper.eq("order_no", orderId);
    16.          Order order = orderService.getOne(orderQueryWrapper);
    18.          HashMap<String, String> map = new HashMap<>();
    19.          //1、设置支付参数
    20.          map.put("appid", ConstantPayUtil.APP_ID);
    21.          map.put("mch_id", ConstantPayUtil.PARTNER);
    22.          map.put("nonce_str", WXPayUtil.generateNonceStr());
    23.          map.put("body", order.getCourseTitle());
    24.          map.put("out_trade_no", orderId);
    25.          map.put("total_fee", order.getTotalFee().multiply(new BigDecimal("100")).longValue() + "");
    26.          map.put("spbill_create_ip", ConstantPayUtil.SPBILL_CREATE_IP);
    27.          map.put("notify_url", ConstantPayUtil.NOTIFY_URL);
    28.          map.put("trade_type", "NATIVE");
    30.          // httpclient根据url访问第三方接口，并返回数据
    31.          HttpClient httpClient = new HttpClient(ConstantPayUtil.SEND_ADDRESS);
    33.          // client设置参数
    34.          httpClient.setXmlParam(WXPayUtil.generateSignedXml(map, ConstantPayUtil.PARTNER_KEY));
    35.          httpClient.setHttps(true);
    36.          httpClient.post();
    38.          // 返回第三方数据
    39.          String xml = httpClient.getContent();
    40.          Map<String, String> resultMap = WXPayUtil.xmlToMap(xml);
    42.          HashMap m = new HashMap<>();
    43.          m.put("out_trade_no", orderId);
    44.          m.put("course_id", order.getCourseId());
    45.          m.put("total_fee", order.getTotalFee());
    46.          m.put("result_code", resultMap.get("result_code"));
    47.          m.put("code_url", resultMap.get("code_url"));
    49.          // 返回结果
    50.          return m;
    51.      } catch (Exception exception) {
    52.          exception.printStackTrace();
    53.          return new HashMap();
    54.      }
    55.  }
    57.  @Override
    58.  public Map queryPayStatus(String orderId) {
    60.      try {
    61.          //1、封装参数
    62.          Map map = new HashMap<>();
    63.          map.put("appid", ConstantPayUtil.APP_ID);
    64.          map.put("mch_id", ConstantPayUtil.PARTNER);
    65.          map.put("out_trade_no", orderId);
    66.          map.put("nonce_str", WXPayUtil.generateNonceStr());
    68.          // 发送请求
    69.          HttpClient httpClient = new HttpClient(ConstantPayUtil.SEND_ADDRESS_PAY);
    70.          // 设置参数
    71.          // 根据商户key生成xml密钥
    72.          httpClient.setXmlParam(WXPayUtil.generateSignedXml(map, ConstantPayUtil.PARTNER_KEY));
    73.          httpClient.setHttps(true);
    74.          httpClient.post();
    76.          // 返回第三方数据
    77.          String xml = httpClient.getContent();
    78.          Map<String, String> resultMap = WXPayUtil.xmlToMap(xml);
    80.          return resultMap;
    81.      } catch (Exception exception) {
    82.          exception.printStackTrace();
    83.          return new HashMap();
    84.      }
    85.  }
    87.  @Override
    88.  public void updateOrderStatus(Map<String, String> map) {
    89.      String orderId = map.get("out_trade_no");
    90.      if (StringUtils.isEmpty(orderId)) {
    91.          throw new GuliException(20001, "订单不存在!");
    92.      }
    93.      Order order = orderService.getOrderByOrderNo(orderId);
    95.      // 判断订单的状态
    96.      if (order.getStatus().intValue() != 1) {
    97.          order.setStatus(1);
    98.          orderService.updateById(order);
    99.      }
    101.      // 保存支付日志
    102.      PayLog payLog = new PayLog();
    103.      payLog.setOrderNo(order.getOrderNo());//支付订单号
    104.      payLog.setPayTime(new Date());
    105.      payLog.setPayType(1); //支付类型
    106.      payLog.setTotalFee(order.getTotalFee());//总金额(分)
    107.      payLog.setTradeState(map.get("trade_state"));//支付状态
    108.      payLog.setTransactionId(map.get("transaction_id"));
    109.      payLog.setAttr(JSONObject.toJSONString(map));// 其他信息，使用json字符串的形式存储在数据库
    110.      baseMapper.insert(payLog);//插入到支付日志表
    112.  }
    113. }