第8章支付.md · HANDSOMECHAI/听书

# 谷粒随享

## 1、微信支付

### 1.1 业务介绍

![支付-微信支付](assets/支付-微信支付.gif)

接口文档入口：https://developers.weixin.qq.com/miniprogram/dev/api/payment/wx.requestPayment.html

![](assets/tingshu041.png)

接收前端传递的**支付类型**以及**订单编号**

http://127.0.0.1/api/payment/wxPay/createJsapi/1301/1cfaee570b51477ab319263a4620e238

1301：订单业务

1302：充值业务

先在配置文件中添加支付相关信息配置：

```properties
spring.application.name=service-payment
spring.profiles.active=dev
spring.main.allow-bean-definition-overriding=true
spring.cloud.nacos.discovery.server-addr=192.168.200.130:8848
spring.cloud.nacos.config.server-addr=192.168.200.130:8848
spring.cloud.nacos.config.prefix=${spring.application.name}
spring.cloud.nacos.config.file-extension=yaml
wechat.v3pay.appid=wxcc651fcbab275e33
wechat.v3pay.merchantId=1631833859
wechat.v3pay.privateKeyPath=E:\\tingshu\\apiclient_key.pem
wechat.v3pay.merchantSerialNumber=4AE80B52EBEAB2B96F68E02510A42801E952E889
wechat.v3pay.apiV3key=84dba6dd51cdaf779e55bcabae564b53
wechat.v3pay.notifyUrl=http://127.0.0.1/api/payment/wxPay/notify
```

apiclient_key.pem 商户API私钥路径 的私钥要放入指定位置，让程序读取！

### 1.2 控制器

微信支付成功之后，需要返回一个 map 集合来存储数据给页面使用.

格式如下：

```java
Map<String, Object> result = new HashMap();
result.put("timeStamp", response.getTimeStamp()); // 时间戳
result.put("nonceStr", response.getNonceStr());   // 随机字符串
result.put("package", response.getPackageVal());  // 订单详情扩展字符串
result.put("signType", response.getSignType());   // 签名方式
result.put("paySign", response.getPaySign());     // 签名
```

```java
/**
  * 微信支付
  * @param paymentType
  * @param orderNo
  * @return
  */
@GuiGuLogin
@Operation(summary = "微信下单")
@Parameters({
  @Parameter(name = "paymentType",description = "支付类型：1301-订单 1302-充值",in = ParameterIn.PATH,required = true),
  @Parameter(name = "orderNo",description = "订单号",required = true,in = ParameterIn.PATH),
})
@PostMapping("/createJsapi/{paymentType}/{orderNo}")
public Result createJsapi(@PathVariable String paymentType, @PathVariable String orderNo) {
  //  调用微信支付方法
  Map map = wxPayService.createJsapi(paymentType, orderNo, AuthContextHolder.getUserId());
  return Result.ok(map);
}
```

### 1.3 接口与实现

```java
/**
  * 微信支付
  * @param paymentType
  * @param orderNo
  * @param userId
  * @return
  */
Map createJsapi(String paymentType, String orderNo, Long userId);
```

微信支付：小程序调起支付需要返回的参数

[微信支付-开发者文档 (qq.com)](https://pay.weixin.qq.com/wiki/doc/apiv3/apis/chapter3_5_4.shtml)

![](assets/tingshu042.png)

```java
@Autowired
private RSAAutoCertificateConfig rsaAutoCertificateConfig;

//	支付文档入口：https://developers.weixin.qq.com/miniprogram/dev/api/payment/wx.requestPayment.html
//	对接方式：https://github.com/wechatpay-apiv3/wechatpay-java
@Override
public Map createJsapi(String paymentType, String orderNo, Long userId) {
	try {
      	//	根据业务判断类型：
	    //	充值业务不需要判断当前订单是否取消
	    if (!paymentType.equals(SystemConstant.PAYMENT_TYPE_RECHARGE)){
	    	//	查询当前订单状态，如果订单状态已经取消，则不能生成二维码！
	    	Result<OrderInfo> orderInfoResult = this.orderInfoFeignClient.getOrderInfo(orderNo);
	    	OrderInfo orderInfo = orderInfoResult.getData();
	    	if (SystemConstant.ORDER_STATUS_CANCEL.equals(orderInfo.getOrderStatus())){
	    		//	此时订单已取消，不能生成二维码！
	    		return null;
	    	}
	    }
		// 保存支付记录
		PaymentInfo paymentInfo = paymentInfoService.savePaymentInfo(paymentType, orderNo);
		//	构建service
		JsapiServiceExtension service = new JsapiServiceExtension.Builder().config(rsaAutoCertificateConfig).build();
		PrepayRequest request = new PrepayRequest();
        // 注意在这个包下 com.wechat.pay.java.service.payments.jsapi.model.Amount
		Amount amount = new Amount();
		amount.setTotal(1);
		request.setAmount(amount);
		request.setAppid(wxPayV3Config.getAppid());
		request.setMchid(wxPayV3Config.getMerchantId());
		request.setDescription(paymentInfo.getContent());
		request.setNotifyUrl(wxPayV3Config.getNotifyUrl());
		request.setOutTradeNo(paymentInfo.getOrderNo());
		//	获取用户信息
		Result<UserInfoVo> userInfoVoResult = userInfoFeignClient.getUserInfoVo(paymentInfo.getUserId());
		Assert.notNull(userInfoVoResult,"返回用户结果集对象不能为空");
		UserInfoVo userInfoVo = userInfoVoResult.getData();
		Assert.notNull(userInfoVo,"用户对象不能为空");
		String openid = userInfoVo.getWxOpenId();
		Payer payer = new Payer();
		payer.setOpenid(openid);
		request.setPayer(payer);

// 调用下单方法，得到应答
		// response包含了调起支付所需的所有参数，可直接用于前端调起支付
		PrepayWithRequestPaymentResponse response = service.prepayWithRequestPayment(request);
		log.info("微信支付下单返回参数：{}", JSON.toJSONString(response));
		Map<String, Object> result = new HashMap();
		result.put("timeStamp", response.getTimeStamp());
		result.put("nonceStr", response.getNonceStr());
		result.put("package", response.getPackageVal());
		result.put("signType", response.getSignType());
		result.put("paySign", response.getPaySign());
		//	返回数据
		return result;
	} catch (ServiceException e) {
        e.printStackTrace();
        throw new GuiguException( 201, e.getErrorMessage());
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
        throw new GuiguException( 201, "订单号不存在");
    } catch (Exception e) {
        e.printStackTrace();
        throw new GuiguException( 201, "微信下单异常");
    }
}
```
注意：RSAAutoCertificateConfig 对象必须在配置文件中注入到spring 容器中，不要直接使用原生的，否则会报错！

```java
package com.atguigu.tingshu.payment.config;

import com.wechat.pay.java.core.RSAAutoCertificateConfig;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix="wechat.v3pay") //读取节点
@Data
public class WxPayV3Config {

private String appid;
    /** 商户号 */
    public String merchantId;
    /** 商户API私钥路径 */
    public String privateKeyPath;
    /** 商户证书序列号 */
    public String merchantSerialNumber;
    /** 商户APIV3密钥 */
    public String apiV3key;
    /** 回调地址 */
    private String notifyUrl;

@Bean
    public RSAAutoCertificateConfig rsaAutoCertificateConfig(){
        return new RSAAutoCertificateConfig.Builder()
                .merchantId(this.merchantId)
                .privateKeyFromPath(privateKeyPath)
                .merchantSerialNumber(merchantSerialNumber)
                .apiV3Key(apiV3key)
                .build();
    }
}
```
### 1.4 保存交易记录

#### 1.4.1 接口与实现

```java
public interface PaymentInfoService extends IService<PaymentInfo> {

/**
     * 保存交易记录
     * @param paymentType
     * @param orderNo
     * @return
     */
    PaymentInfo savePaymentInfo(String paymentType, String orderNo);
}
```

```java
@Override
public PaymentInfo savePaymentInfo(String paymentType, String orderNo) {
  //  获取到交易记录对象
  PaymentInfo paymentInfo = this.getOne(new LambdaQueryWrapper<PaymentInfo>().eq(PaymentInfo::getOrderNo, orderNo));
  if (null == paymentInfo){
    //  创建对象
    paymentInfo = new PaymentInfo();
    //  支付信息
    if(paymentType.equals(SystemConstant.PAYMENT_TYPE_ORDER)){
      //  远程调用获取到订单对象
      Result<OrderInfo> orderInfoResult = orderInfoFeignClient.getOrderInfo(orderNo);
      Assert.notNull(orderInfoResult,"返回订单对象不能为空");
      OrderInfo orderInfo = orderInfoResult.getData();
      Assert.notNull(orderInfo,"返回订单对象不能为空");
      paymentInfo.setUserId(orderInfo.getUserId());
      paymentInfo.setContent(orderInfo.getOrderTitle());
      paymentInfo.setAmount(orderInfo.getOrderAmount());
    } else {
      //  充值信息
      Result<RechargeInfo> rechargeInfoResult =  rechargeInfoFeignClient.getRechargeInfo(orderNo);
      Assert.notNull(rechargeInfoResult,"返回充值对象不能不为空");
      RechargeInfo rechargeInfo = rechargeInfoResult.getData();
      Assert.notNull(rechargeInfo,"返回充值对象不能不为空");
      paymentInfo.setUserId(rechargeInfo.getUserId());
      paymentInfo.setContent("充值");
      paymentInfo.setAmount(rechargeInfo.getRechargeAmount());
    }
    paymentInfo.setPaymentType(paymentType);
    paymentInfo.setOrderNo(orderNo);
    paymentInfo.setPaymentStatus(SystemConstant.PAYMENT_STATUS_UNPAID);
    this.save(paymentInfo);
  }
  return paymentInfo;
}
```

##### 1.4.1.1 远程调用获取订单对象

service-order 订单微服务已经有这个方法了，直接编写一个远程调用即可

```java
@FeignClient(value = "service-order", fallback = OrderInfoDegradeFeignClient.class)
public interface OrderInfoFeignClient {
    /**
     * 根据订单号获取订单信息
     * @param orderNo
     * @return
     */
    @GetMapping("api/order/orderInfo/getOrderInfo/{orderNo}")
    Result<OrderInfo> getOrderInfo(@PathVariable("orderNo") String orderNo);
}
```

熔断类：

```java
@Component
public class OrderInfoDegradeFeignClient implements OrderInfoFeignClient {

@Override
    public Result<OrderInfo> getOrderInfo(String orderNo) {
        return null;
    }
}
```

##### 1.4.1.2 远程调用获取充值记录信息

```java
@FeignClient(value = "service-account", fallback = RechargeInfoDegradeFeignClient.class)
public interface RechargeInfoFeignClient {

/**
     * 根据订单号获取充值信息
     * @param orderNo
     * @return
     */
    @GetMapping("api/account/rechargeInfo/getRechargeInfo/{orderNo}")
    Result<RechargeInfo> getRechargeInfo(@PathVariable("orderNo") String orderNo);
}
```

熔断类：

```java
@Component
public class RechargeInfoDegradeFeignClient implements RechargeInfoFeignClient {
    @Override
    public Result<RechargeInfo> getRechargeInfo(String orderNo) {
        return null;
    }
}
```

service-account 微服务控制器中添加

```java
/**
 * 根据订单号获取充值信息
 * @param orderNo
 * @return
 */
@GuiGuLogin
@Operation(summary = "根据订单号获取充值信息")
@GetMapping("/getRechargeInfo/{orderNo}")
public Result<RechargeInfo> getRechargeInfo(@PathVariable("orderNo") String orderNo){
   // 调用服务层方法
   RechargeInfo rechargeInfo = rechargeInfoService.getRechargeInfoByOrderNo(orderNo);
   // 返回对象
   return Result.ok(rechargeInfo);
}
```

接口与实现

```java
public interface RechargeInfoService extends IService<RechargeInfo> {

/**
     * 根据订单号获取充值信息
     * @param orderNo
     * @return
     */
    RechargeInfo getRechargeInfoByOrderNo(String orderNo);

}
```

```java
package com.atguigu.tingshu.account.service.impl;

import com.atguigu.tingshu.account.mapper.RechargeInfoMapper;
import com.atguigu.tingshu.account.service.RechargeInfoService;
import com.atguigu.tingshu.model.account.RechargeInfo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class RechargeInfoServiceImpl extends ServiceImpl<RechargeInfoMapper, RechargeInfo> implements RechargeInfoService {

@Autowired
   private RechargeInfoMapper rechargeInfoMapper;
   @Override
   public RechargeInfo getRechargeInfoByOrderNo(String orderNo) {
      // 根据订单号查询对象
      return this.getOne(new LambdaQueryWrapper<RechargeInfo>().eq(RechargeInfo::getOrderNo,orderNo));
   }
}
```

### 1.5 查询支付状态

页面有个主动查询支付状态的接口，检查用户是否支付成功

http://127.0.0.1/api/payment/wxPay/queryPayStatus/0d7e74b3a17040adb89dc252e189ed19

![](assets/tingshu043.png)

#### 1.5.1 控制器

思路：

1. 调用接口查询数据得到Transaction对象{这个对象能够获取到支付状态}
2. 当这个对象不为空的时候并且支付状态是成功时，则调用更新交易状态方法

```java
/**
  * 查询支付状态 https://pay.weixin.qq.com/wiki/doc/apiv3/apis/chapter3_5_2.shtml
  * @param orderNo
  * @return
  */
@Operation(summary = "支付状态查询")
@GetMapping("/queryPayStatus/{orderNo}")
public Result queryPayStatus(@PathVariable String orderNo) {
  try {
    // 调用查询接口 com.wechat.pay.java.service.payments.model.Transaction;
    Transaction transaction = wxPayService.queryPayStatus(orderNo);
    System.out.println("queryPayStatus: "+ JSON.toJSONString(transaction));
    if(null != transaction && transaction.getTradeState() == Transaction.TradeStateEnum.SUCCESS) {
      //更改订单状态
      paymentInfoService.updatePaymentStatus(transaction);
      return Result.ok(true);
    }
  } catch (Exception e) {
    e.printStackTrace();
  }
  return Result.ok(false);
}
```

#### 1.5.2 接口与实现

```java
/**
  * 根据orderNo 查询数据
  * @param orderNo
  * @return
  */
Transaction queryPayStatus(String orderNo);
```

```java
@Override
public Transaction queryPayStatus(String orderNo) {
  try {
    //	构建service
    JsapiServiceExtension service = new JsapiServiceExtension.Builder().config(rsaAutoCertificateConfig).build();
    QueryOrderByOutTradeNoRequest queryRequest = new QueryOrderByOutTradeNoRequest();
    queryRequest.setMchid(wxPayV3Config.getMerchantId());
    queryRequest.setOutTradeNo(orderNo);

Transaction result = service.queryOrderByOutTradeNo(queryRequest);
    log.info("Transaction:\t"+JSON.toJSONString(result));
    return result ;
  } catch (ServiceException e){
    // API返回失败, 例如ORDER_NOT_EXISTS
    System.out.printf("code=[%s], message=[%s]\n", e.getErrorCode(), e.getErrorMessage());
    System.out.printf("reponse body=[%s]\n", e.getResponseBody());
    e.printStackTrace();
  }
  return null;
}
```

##### 1.5.2.1 更新状态接口

```java
/**
 *	更改订单状态
 * @param transaction
 */
void updatePaymentStatus(Transaction transaction);
```

```java
@Override
public void updatePaymentStatus(Transaction transaction) {
  PaymentInfo paymentInfo = this.getOne(new LambdaQueryWrapper<PaymentInfo>().eq(PaymentInfo::getOrderNo, transaction.getOutTradeNo()));
  if (paymentInfo.getPaymentStatus() == SystemConstant.PAYMENT_STATUS_PAID) {
    return;
  }

//更新支付信息
  paymentInfo.setPaymentStatus(SystemConstant.PAYMENT_STATUS_PAID);
  paymentInfo.setOrderNo(transaction.getOutTradeNo());
  paymentInfo.setOutTradeNo(transaction.getTransactionId());
  paymentInfo.setCallbackTime(new Date());
  paymentInfo.setCallbackContent(JSON.toJSONString(transaction));
  this.updateById(paymentInfo);
  // 表示交易成功！

// 后续更新订单状态！ 使用消息队列！
  String routing = paymentInfo.getPaymentType().equals(SystemConstant.PAYMENT_TYPE_ORDER)? MqConst.ROUTING_ORDER_PAY_SUCCESS : MqConst.ROUTING_RECHARGE_PAY_SUCCESS;
  rabbitService.sendMessage(MqConst.EXCHANGE_ORDER, routing, paymentInfo.getOrderNo());
}
```

##### 1.5.2.2 监听信息修改订单状态

监听支付发送的消息，充值状态监听消息，在后面的充值业务中体现

在这个OrderReceiver类中添加

```java
@SneakyThrows
@RabbitListener(bindings = @QueueBinding(
        exchange = @Exchange(value = MqConst.EXCHANGE_ORDER, durable = "true"),
        value = @Queue(value = MqConst.QUEUE_ORDER_PAY_SUCCESS, durable = "true"),
        key = {MqConst.ROUTING_ORDER_PAY_SUCCESS}
))
public void orderPaySuccess(String orderNo, Message message, Channel channel) {
    //业务处理
    if (StringUtils.hasText(orderNo)) {
        orderInfoService.orderPaySuccess(orderNo);
    }

//手动应答
    channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
}
```

```java
// 完善orderPaySuccess 代码
@Override
public void orderPaySuccess(String orderNo) {
    //  查询对象
    //  OrderInfo orderInfo = this.getOne(new LambdaQueryWrapper<OrderInfo>().eq(OrderInfo::getOrderNo, orderNo));
    OrderInfo orderInfo = this.getOrderInfoByOrderNo(orderNo);
    //  如果已经修改为支付，那么就不需要再修改了.
    if (orderInfo.getOrderStatus().equals(SystemConstant.ORDER_STATUS_PAID)){
        return;
    }
    //  赋值为已支付
    orderInfo.setOrderStatus(SystemConstant.ORDER_STATUS_PAID);
    //  修改状态
    this.updateById(orderInfo);
    //  记录用户购买信息: 微信支付就需要再次调用；余额支付不需要！
    if (orderInfo.getPayWay().equals(SystemConstant.ORDER_PAY_WAY_WEIXIN)){
        //  添加一个判断：
        //  保存用户购买记录：
        UserPaidRecordVo userPaidRecordVo = new UserPaidRecordVo();
        userPaidRecordVo.setOrderNo(orderNo);
        userPaidRecordVo.setUserId(orderInfo.getUserId());
        userPaidRecordVo.setItemType(orderInfo.getItemType());
        //  [专辑Id;vip服务配置Id;下单的时候只能购买一个，这个明细数据就是一条] 声音Id{应该是集合}
        //  以上Id都在? orderInfoVo.getOrderDetailVoList(); 订单明细表中有itemId;
        //  List<Long> itemIdList = orderInfoVo.getOrderDetailVoList().stream().map(OrderDetailVo::getItemId).collect(Collectors.toList());
        //  声音只支持余额支付！
        List<Long> itemIdList = orderInfo.getOrderDetailList().stream().map(OrderDetail::getItemId).collect(Collectors.toList());
        userPaidRecordVo.setItemIdList(itemIdList);
        //  远程调用保存用户交易记录。
        this.userInfoFeignClient.savePaidRecord(userPaidRecordVo);
    }

}
```

### 1.6 支付异步回调

#### 1.6.1 控制器

```java
//  https://pay.weixin.qq.com/wiki/doc/apiv3/apis/chapter3_5_5.shtml
/**
  * 异步回调
  * @param request
  * @return
  */
@Operation(summary = "微信支付异步通知接口")
@PostMapping("/notify")
public Map<String,Object> notify(HttpServletRequest request){
  Map<String,Object> result = new HashMap<>();
  try {
    //  调用方法
    wxPayService.wxnotify(request);
    //返回成功
    result.put("code", "SUCCESS");
    result.put("message", "成功");
    return result;
  } catch (Exception e) {
    e.printStackTrace();
  }

//返回失败
  result.put("code", "FAIL");
  result.put("message", "失败");
  return result;
}
```

#### 1.6.2 接口与实现

```java
void wxnotify(HttpServletRequest request);
```

```java
@Override
public void wxnotify(HttpServletRequest request) {
  //1.回调通知的验签与解密
  //从request头信息获取参数
  //HTTP 头 Wechatpay-Signature
  // HTTP 头 Wechatpay-Nonce
  //HTTP 头 Wechatpay-Timestamp
  //HTTP 头 Wechatpay-Serial
  //HTTP 头 Wechatpay-Signature-Type
  //HTTP 请求体 body。切记使用原始报文，不要用 JSON 对象序列化后的字符串，避免验签的 body 和原文不一致。
  String wechatPaySerial = request.getHeader("Wechatpay-Serial");
  String nonce = request.getHeader("Wechatpay-Nonce");
  String timestamp = request.getHeader("Wechatpay-Timestamp");
  String signature = request.getHeader("Wechatpay-Signature");
  // 调用工具类来获取请求体数据
  String requestBody = PayUtil.readData(request);

//2.构造 RequestParam
  RequestParam requestParam = new RequestParam.Builder()
    .serialNumber(wechatPaySerial)
    .nonce(nonce)
    .signature(signature)
    .timestamp(timestamp)
    .body(requestBody)
    .build();

//3.初始化 NotificationParser
  NotificationParser parser = new NotificationParser(rsaAutoCertificateConfig);
  //4.以支付通知回调为例，验签、解密并转换成 Transaction
  Transaction transaction = parser.parse(requestParam, Transaction.class);
  log.info("成功解析：{}", JSON.toJSONString(transaction));
  if(null != transaction && transaction.getTradeState() == Transaction.TradeStateEnum.SUCCESS) {
    // 5.处理支付业务
    paymentInfoService.updatePaymentStatus(transaction);
  }
}
```

### 1.7 支付测试

微信小程序支付，需加入微信开发者，才可以测试支付；由于学员未加入开发者，故不能测试微信小程序支付；微信Native支付无开发限制，二者只是微信下单方式不一样，支付回调接口一致，因此未加入微信开发者人员，可使用微信Native支付测试微信支付相关业务。

#### 1.7.1、控制器

WxPayApiController

```java
@GuiguLogin
@Operation(summary = "微信Native下单")
@Parameters({
        @Parameter(name = "paymentType",description = "支付类型：1301-订单 1302-充值",in = ParameterIn.PATH,required = true),
        @Parameter(name = "orderNo",description = "订单号",required = true,in = ParameterIn.PATH),
})
@PostMapping("/createNative/{paymentType}/{orderNo}")
public Result<Map<String, Object>> createNative(@PathVariable String paymentType, @PathVariable String orderNo) {
    Map<String, Object> map = wxPayService.createNative(paymentType, orderNo, AuthContextHolder.getUserId());
    return Result.ok(map);
}
```

#### 1.7.2、接口与实现

WxPayService

```java
Map<String, Object> createNative(String paymentType, String orderNo, Long userId);
```

WxPayServiceImpl

```java
@Override
public Map<String, Object> createNative(String paymentType, String orderNo, Long userId) {
   try {
      //保存支付记录
      PaymentInfo paymentInfo = paymentInfoService.savePaymentInfo(paymentType, orderNo);

// 构建service
      NativePayService service = new NativePayService.Builder().config(rsaAutoCertificateConfig).build();
      // request.setXxx(val)设置所需参数，具体参数可见Request定义
      com.wechat.pay.java.service.payments.nativepay.model.PrepayRequest request = new com.wechat.pay.java.service.payments.nativepay.model.PrepayRequest();
      com.wechat.pay.java.service.payments.nativepay.model.Amount amount = new com.wechat.pay.java.service.payments.nativepay.model.Amount();
      amount.setTotal(1);
      request.setAmount(amount);
      request.setAppid(wxPayV3Config.getAppid());
      request.setMchid(wxPayV3Config.getMerchantId());
      request.setDescription(paymentInfo.getContent());
      request.setNotifyUrl(wxPayV3Config.getNotifyUrl());
      request.setOutTradeNo(paymentInfo.getOrderNo());

// 调用下单方法，得到应答
      com.wechat.pay.java.service.payments.nativepay.model.PrepayResponse response = service.prepay(request);
      // 使用微信扫描 code_url 对应的二维码，即可体验Native支付
      System.out.println(response.getCodeUrl());

Map result = new HashMap<>();
      result.put("codeUrl", response.getCodeUrl());
      return result;
   } catch (ServiceException e) {
      e.printStackTrace();
      throw new GuiguException( 201, e.getErrorMessage());
   } catch (IllegalArgumentException e) {
      e.printStackTrace();
      throw new GuiguException( 201, "订单号不存在");
   } catch (Exception e) {
      e.printStackTrace();
      throw new GuiguException( 201, "微信下单异常");
   }
}
```

#### 1.7.3、测试

![支付-测试](assets/pay_test.gif)

说明：购买专辑下单后，复制订单号在此测试微信支付业务。如果提示“201 商户订单号重复”，那么修改订单表订单号，然后再次复制订单号，生成支付二维码，扫码支付。

### 1.8 关闭订单

#### 1.8.1 控制器

```java
/**
 * 关闭交易记录
 * @param orderNo
 * @return
 */
@Operation(summary = "关闭交易记录")
@GetMapping("/closePayment/{orderNo}")
public Result closePayment(@PathVariable String orderNo){
    //  调用服务层方法.
    boolean flag = this.paymentInfoService.closePayment(orderNo);
    //  返回结果
    return Result.ok(flag);
}
```

#### 1.8.2 接口与实现

```java
/**
 * 关闭交易记录
 * @param orderNo
 * @return
 */
boolean closePayment(String orderNo);
```

```java
@Override
public boolean closePayment(String orderNo) {
    //  创建对象
    PaymentInfo paymentInfo = new PaymentInfo();
    paymentInfo.setPaymentStatus(SystemConstant.PAYMENT_STATUS_CANCEL);
    //  设置更新条件
    boolean result = this.update(paymentInfo, new LambdaQueryWrapper<PaymentInfo>().eq(PaymentInfo::getOrderNo, orderNo));
    //  返回
    return result;
}
```

测试：直接访问url地址进行测试即可！

### 1.9 退款

#### 1.9.1 控制器

```java
/**
 * 退款
 * @param orderNo
 * @return
 */
@Operation(summary = "退款")
@GetMapping("/refund/{orderNo}")
public Result refund(@PathVariable String orderNo){
    //  调用服务层方法.
    boolean flag = this.wxPayService.refund(orderNo);
    //  返回结果
    return Result.ok(flag);
}
```

#### 1.9.2 接口与实现

```java
/**
 * 退款
 * @param orderNo
 * @return
 */
boolean refund(String orderNo);
```

```java
@Override
public boolean refund(String orderNo) {
    //  创建退款对象
    RefundService refundService = new RefundService.Builder().config(config).build();
    //  创建退款请求对象
    CreateRequest createRequest = new CreateRequest();
    createRequest.setOutTradeNo(orderNo);
    createRequest.setOutRefundNo(orderNo);
    AmountReq amountReq = new AmountReq();
    amountReq.setRefund(1l);
    amountReq.setTotal(1l);
    amountReq.setCurrency("CNY");
    createRequest.setAmount(amountReq);
    Refund refund = refundService.create(createRequest);
    //  判断
    if (refund.getStatus().equals(Status.SUCCESS)){
        //  关闭交易记录
        this.paymentInfoService.closePayment(orderNo);
        //  修改订单状态.
        return true;
    }
    return false;
}
```

## 2、充值业务

### 2.1 业务分析

![支付-充值金额](assets/支付-充值金额.gif)

点击我的---->我的钱包

![](assets/tingshu044.png)

http://127.0.0.1/api/account/rechargeInfo/submitRecharge

在service-account 模块中添加控制器

### 2.2 功能实现 控制器

充值时，将前端页面数据封装到 RechargeInfoVo 对象中，充值成功之后保存orderNo 到map 集合中并将map 放入result类中返回

```java
package com.atguigu.tingshu.vo.account;

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import java.math.BigDecimal;

@Data
@Schema(description = "充值对象")
public class RechargeInfoVo {

@Schema(description = "充值金额")
   private BigDecimal amount;

@Schema(description = "支付方式：1101-微信 1102-支付宝")
   private String payWay;

}
```

RechargeInfoApiController

```java
/**
  * 给用户充值
  * @param rechargeInfoVo
  * @return
  */
@GuiGuLogin
@Operation(summary = "充值")
@PostMapping("submitRecharge")
public Result submitRecharge(@RequestBody RechargeInfoVo rechargeInfoVo){
  //	获取到用户Id
  Long userId = AuthContextHolder.getUserId();
  //	调用充值方法
  String orderNo = this.rechargeInfoService.submitRecharge(rechargeInfoVo,userId);
  //	创建map 集合对象
  HashMap<String, Object> map = new HashMap<>();
  //	存储订单Id
  map.put("orderNo",orderNo);
  //	返回数据
  return Result.ok(map);
}
```

#### 2.2.1 接口与实现

```java
/**
  * 用户充值接口
  * @param rechargeInfoVo
  * @param userId
  * @return
  */
String submitRecharge(RechargeInfoVo rechargeInfoVo, Long userId);
```

```java
@Override
public String submitRecharge(RechargeInfoVo rechargeInfoVo, Long userId) {
  //	创建对象
  RechargeInfo rechargeInfo = new RechargeInfo();
  //	赋值操作
  rechargeInfo.setUserId(userId);
  rechargeInfo.setRechargeStatus(SystemConstant.ORDER_STATUS_UNPAID);
  rechargeInfo.setRechargeAmount(rechargeInfoVo.getAmount());
  rechargeInfo.setPayWay(rechargeInfoVo.getPayWay());
  rechargeInfo.setOrderNo(UUID.randomUUID().toString().replaceAll("-",""));
  //	插入数据库
  rechargeInfoMapper.insert(rechargeInfo);
  //	返回订单编号
  return rechargeInfo.getOrderNo();
}
```

#### 2.2.2 充值成功业务处理

在支付成功之后，会在updatePaymentStatus方法中发送充值成功消息。所以我们要在在service-account 模块添加监听器中

在这个AccountReceiver类中添加数据

```java
/**
 * 充值成功通知
 * @param orderNo
 * @param message
 * @param channel
 */
@SneakyThrows
@RabbitListener(bindings = @QueueBinding(
        exchange = @Exchange(value = MqConst.EXCHANGE_ORDER, durable = "true"),
        value = @Queue(value = MqConst.QUEUE_RECHARGE_PAY_SUCCESS, durable = "true"),
        key = {MqConst.ROUTING_RECHARGE_PAY_SUCCESS}
))
public void rechargePaySuccess(String orderNo, Message message, Channel channel) {
    log.info("充值成功通知: {}", orderNo);
    //业务处理
    if (StringUtils.hasText(orderNo)){
        //通知更新用户账号
        rechargeInfoService.rechargePaySuccess(orderNo);
    }

//手动应答
    channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
}
```

```java
/**
 * 充值成功
 * @param orderNo
 */
void rechargePaySuccess(String orderNo);
```

```java
@Override
@Transactional
public void rechargePaySuccess(String orderNo) {
   // 获取到充值信息对象
   RechargeInfo rechargeInfo = this.getRechargeInfoByOrderNo(orderNo);
   // 如果当前状态是已支付，则直接返回
   if (SystemConstant.ORDER_STATUS_PAID.equals(rechargeInfo.getRechargeStatus())) return;
   // 否则赋值为已支付状态
   rechargeInfo.setRechargeStatus(SystemConstant.ORDER_STATUS_PAID);
   // 更新数据
   this.updateById(rechargeInfo);
   // 更新余额
  userAccountService.add(rechargeInfo.getUserId(),rechargeInfo.getRechargeAmount(),rechargeInfo.getOrderNo(),SystemConstant.ACCOUNT_TRADE_TYPE_DEPOSIT,"充值");
}
```

新增 user_account 与 user_account_detail 表数据

```java
/**
 * 充值
 * @param userId
 * @param amount
 * @param orderNo
 * @param tradeType
 * @param title
 */
void add(Long userId, BigDecimal amount, String orderNo, String tradeType, String title);
```

```java
@Override
public void add(Long userId, BigDecimal amount, String orderNo, String tradeType, String title) {
   // 查看是否有当前对象
   long count = userAccountDetailMapper.selectCount(new LambdaQueryWrapper<UserAccountDetail>().eq(UserAccountDetail::getOrderNo, orderNo));
   if(count > 0) return;
   //添加账号金额
   userAccountMapper.add(userId, amount);
   //添加账户明细
   this.log(userId, title, tradeType, amount, orderNo);
}
```

UserAccountMapper.java

```java
/**
 * 充值
 * @param userId
 * @param amount
 */
Integer add(@Param("userId") Long userId, @Param("amount") BigDecimal amount);
```

UserAccountMapper.xml

```xml
<update id="add">
   update user_account
   set total_amount = total_amount + #{amount}, available_amount = available_amount + #{amount}, total_income_amount = total_income_amount + #{amount}
   where user_id = #{userId}
</update>
```

### 2.3 充值记录

![](assets/tingshu045.png)

http://127.0.0.1/api/account/userAccount/findUserRechargePage/1/10

#### 2.3.1 控制器

用户充值记录回显信息保存到实体类：

```java
package com.atguigu.tingshu.model.account;

import com.atguigu.tingshu.model.base.BaseEntity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import java.math.BigDecimal;

@Data
@Schema(description = "UserAccountDetail")
@TableName("user_account_detail")
public class UserAccountDetail extends BaseEntity {

private static final long serialVersionUID = 1L;

@Schema(description = "用户id")
   @TableField("user_id")
   private Long userId;

@Schema(description = "交易标题")
   @TableField("title")
   private String title;

@Schema(description = "交易类型：1201-充值 1202-锁定 1203-解锁 1204-消费")
   @TableField("trade_type")
   private String tradeType;

@Schema(description = "金额")
   @TableField("amount")
   private BigDecimal amount;

@Schema(description = "订单编号")
   @TableField("order_no")
   private String orderNo;

}
```

在service-account 微服务 UserAccountApiController 控制器添加

```java
/**
 * 用户充值记录
 * @param page
 * @param limit
 * @return
 */
@GuiGuLogin
@Operation(summary = "获取用户充值记录")
@GetMapping("/findUserRechargePage/{page}/{limit}")
public Result findUserRechargePage(
      @Parameter(name = "page", description = "当前页码", required = true)
      @PathVariable Long page,

@Parameter(name = "limit", description = "每页记录数", required = true)
      @PathVariable Long limit) {
   // 获取到用户Id
   Long userId = AuthContextHolder.getUserId();
   // 构建Page对象
   Page<UserAccountDetail> pageParam = new Page<>(page, limit);
   // 调用服务层方法
   IPage<UserAccountDetail> pageModel = userAccountService.findUserRechargePage(pageParam, userId);
   // 返回数据
   return Result.ok(pageModel);
}
```

#### 2.3.2 接口与实现

```java
/**
 * 查看用户充值记录
 * @param pageParam
 * @param userId
 * @return
 */
IPage<UserAccountDetail> findUserRechargePage(Page<UserAccountDetail> pageParam, Long userId);
```

```java
@Override
public IPage<UserAccountDetail> findUserRechargePage(Page<UserAccountDetail> pageParam, Long userId) {
   // 调用mapper 方法
   return userAccountDetailMapper.selectUserRechargePage(pageParam,userId);
}
```

UserAccountDetailMapper.java

```java
@Mapper
public interface UserAccountDetailMapper extends BaseMapper<UserAccountDetail> {
    /**
     *
     * @param pageParam
     * @param userId
     * @return
     */
    IPage<UserAccountDetail> selectUserRechargePage(Page<UserAccountDetail> pageParam, Long userId);
}
```

UserAccountDetailMapper.xml

```xml

<select id="selectUserRechargePage" resultMap="RechargeInfoMap">
   select <include refid="columns" />
   from user_account_detail
   where user_id = #{userId} and trade_type = '1201'
   and is_deleted = 0
   order by id desc
</select>
```

### 2.4 消费记录

![](assets/tingshu046.png)

消费记录

http://127.0.0.1/api/account/userAccount/findUserConsumePage/1/10

#### 2.4.1 控制器

返回消费记录的时候，也是将数据封装到 UserAccountDetail 对象中！

在service-account 微服务中添加

```java
@GuiGuLogin
@Operation(summary = "获取用户消费记录")
@GetMapping("findUserConsumePage/{page}/{limit}")
public Result findUserConsumePage(
      @Parameter(name = "page", description = "当前页码", required = true)
      @PathVariable Long page,

@Parameter(name = "limit", description = "每页记录数", required = true)
      @PathVariable Long limit) {
   // 获取到用户Id
   Long userId = AuthContextHolder.getUserId();
   Page<UserAccountDetail> pageParam = new Page<>(page, limit);
   IPage<UserAccountDetail> pageModel = userAccountService.findUserConsumePage(pageParam, userId);
   return Result.ok(pageModel);
}
```

#### 2.4.2 接口与实现

```java
/**
 * 消费记录
 * @param pageParam
 * @param userId
 * @return
 */
IPage<UserAccountDetail> findUserConsumePage(Page<UserAccountDetail> pageParam, Long userId);
```

```java
@Override
public IPage<UserAccountDetail> findUserConsumePage(Page<UserAccountDetail> pageParam, Long userId) {
   // 调用mapper 层方法
   return userAccountDetailMapper.selectUserConsumePage(pageParam, userId);
}
```

UserAccountDetailMapper.java

```java
/**
 * 消费记录
 * @param pageParam
 * @param userId
 * @return
 */
IPage<UserAccountDetail> selectUserConsumePage(Page<UserAccountDetail> pageParam, Long userId);
```

UserAccountDetailMapper.xml

```xml
<select id="selectUserConsumePage" resultMap="RechargeInfoMap">
   select <include refid="columns" />
   from user_account_detail
   where user_id = #{userId} and trade_type = '1204'
   and is_deleted = 0
   order by id desc
</select>
```

测试：充值一百元之后，查看余额与

![](assets/tingshu047.png)

充值记录：

![](assets/tingshu048.png)

HANDSOMECHAI/听书

简介

发行版

贡献者

近期动态

HANDSOMECHAI/听书 .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

HANDSOMECHAI/听书