• springboot整合pi支付开发

    pi支付流程图：

    1. 使用Pi SDK功能发起支付
    2. 由 Pi SDK 自动调用的回调函数（让您的应用服务器知道它需要发出批准 API 请求）
    3. 从您的应用程序服务器到 Pi 服务器的 API 请求以批准付款（让 Pi 服务器知道您知道此付款）
    4. Pi浏览器向用户显示付款详细信息页面，我们正在等待用户签署交易
    5. 由 Pi SDK 自动调用的回调函数（让您的应用服务器知道它需要发出完整的 API 请求）
    6. 从您的应用服务器到 Pi 服务器的 API 请求以完成付款（让 Pi 服务器知道您已完成此付款）

    支付流程

     引入依赖

    1.   <dependency>
    2.       <groupId>com.squareup.okhttp3</groupId>
    3.       <artifactId>okhttp</artifactId>
    4.       <version>4.10.0-RC1</version>
    5.    </dependency>
    6.    <dependency>
    7.       <groupId>cn.hutool</groupId>
    8.       <artifactId>hutool-all</artifactId>
    9.       <version>5.8.0.M4</version>
    10.    </dependency>
    11.     <dependency>
    12.       <groupId>org.apache.httpcomponents</groupId>
    13.       <artifactId>httpclient</artifactId>
    14.       <version>4.5.13</version>
    15.    </dependency>
    16.         <dependency>
    17.         <groupId>commons-lang</groupId>
    18.         <artifactId>commons-lang</artifactId>
    19.         <version>2.6</version>
    20.    </dependency>

    配置api密钥

    1. import lombok.Data;
    2. import org.springframework.beans.factory.annotation.Value;
    3. import org.springframework.context.annotation.Configuration;
    4.  
    5. /**
    6.  * 服务器端key
    7.  * @author ThinkPad
    8.  */
    9. @Configuration
    10. @Data
    11. public class CommonConfig {
    12.  
    13.     @Value("${sdk.serverAccessKey}")
    14.     private String serverAccessKey;
    15. }

     接收和返回数据对象

    loginVO接收pi中心来的用户信息

    1. import lombok.Data;
    2.  
    3. /**
    4.  * @author wzx
    5.  * 登录数据封装类
    6.  */
    7. @Data
    8. public class LoginVO {
    9.  
    10.     private String userId;
    11.     private String userName;
    12.     private String accessToken;
    13. }

    paymentVO接收支付授权的信息

    1. import lombok.AllArgsConstructor;
    2. import lombok.Data;
    3. import lombok.NoArgsConstructor;
    4.  
    5. import java.math.BigDecimal;
    6.  
    7. /**
    8.  * @author ThinkPad
    9.  */
    10. @Data
    11. @AllArgsConstructor
    12. @NoArgsConstructor
    13. public class PaymentVO {
    14.  
    15.  
    16.  
    17.  
    18.     private String paymentId;
    19.     // 交易金额
    20.     private BigDecimal amount;
    21.     // 名片对应的用户数据
    22.     private String shopUserId;
    23.     // 商品id
    24.     private String shopId;
    25.     // 当前账号用户的id
    26.     private String userId;
    27.  
    28. }

    completeVO接收支付完成的信息

    1. import lombok.AllArgsConstructor;
    2. import lombok.Data;
    3. import lombok.NoArgsConstructor;
    4.  
    5. /**
    6.  * @author ThinkPad
    7.  */
    8. @Data
    9. @NoArgsConstructor
    10. @AllArgsConstructor
    11. public class CompleteVO {
    12.     // PI支付ID
    13.  
    14.     private String paymentId;
    15.     // txId
    16.  
    17.     private String txId;
    18.     // 订单ID【余额支付参数】
    19.  
    20.     private String orderId;
    21.     // 支付方式：0：PI钱包 1：余额支付
    22.  
    23.     private String payType;
    24. }

    incompleteVO接收未完成订单的信息

    1. /**
    2.  * @author ThinkPad
    3.  */
    4. @Data
    5. @NoArgsConstructor
    6. @AllArgsConstructor
    7. public class IncompleteVO {
    8.  
    9.     private String identifier;
    10.  
    11.  
    12.     private TransactionVO transaction;
    13. }
    1. import lombok.AllArgsConstructor;
    2. import lombok.Data;
    3. import lombok.NoArgsConstructor;
    4.  
    5. /**
    6.  * @author ThinkPad
    7.  */
    8. @Data
    9. @NoArgsConstructor
    10. @AllArgsConstructor
    11. public class TransactionVO {
    12.  
    13.  
    14.     private String txid;
    15.  
    16.  
    17.     private String _link;
    18. }

    工具类

    发起http请求工具类

    1. import org.apache.commons.lang.StringUtils;
    2. import org.apache.http.HttpEntity;
    3. import org.apache.http.ParseException;
    4. import org.apache.http.client.methods.CloseableHttpResponse;
    5. import org.apache.http.client.methods.HttpGet;
    6. import org.apache.http.client.methods.HttpPost;
    7. import org.apache.http.entity.StringEntity;
    8. import org.apache.http.impl.client.CloseableHttpClient;
    9. import org.apache.http.impl.client.HttpClients;
    10. import org.apache.http.util.EntityUtils;
    11.  
    12. import java.io.BufferedReader;
    13. import java.io.IOException;
    14. import java.io.InputStream;
    15. import java.io.InputStreamReader;
    16. import java.net.HttpURLConnection;
    17. import java.net.URL;
    18.  
    19.  
    20. /**
    21.  * @author Ashy.Cheung
    22.  * @http 请求工具类
    23.  * @date 2017.11.10
    24.  */
    25. public class HttpClientUtil {
    26.  
    27.     public static String sendGet(String url) {
    28.         CloseableHttpClient httpclient = HttpClients.createDefault();
    29.         HttpGet httpget = new HttpGet(url);
    30.         CloseableHttpResponse response = null;
    31.         try {
    32.             response = httpclient.execute(httpget);
    33.         } catch (IOException e1) {
    34.             e1.printStackTrace();
    35.         }
    36.         String result = null;
    37.         try {
    38.             HttpEntity entity = response.getEntity();
    39.             if (entity != null) {
    40.                 result = EntityUtils.toString(entity);
    41.             }
    42.         } catch (ParseException | IOException e) {
    43.             e.printStackTrace();
    44.         } finally {
    45.             try {
    46.                 response.close();
    47.             } catch (IOException e) {
    48.                 e.printStackTrace();
    49.             }
    50.         }
    51.         return result;
    52.     }
    53.  
    54.     /**
    55.      *
    56.      * @param url
    57.      * @param charsetName 返回字符集
    58.      * @return
    59.      */
    60.     public static String sendGet(String url, String charsetName) {
    61.         InputStream inputStream = null;
    62.         HttpURLConnection urlConnection = null;
    63.  
    64.         try {
    65.             URL url1 = new URL(url);
    66.             urlConnection = (HttpURLConnection) url1.openConnection();
    67.             // 将返回的输入流转换成字符串
    68.             inputStream = urlConnection.getInputStream();
    69.             // 指定编码格式
    70.             if (StringUtils.isBlank(charsetName)) {
    71.                 charsetName = "UTF-8";
    72.             }
    73.             InputStreamReader inputStreamReader = new InputStreamReader(inputStream, charsetName);
    74.             BufferedReader in = new BufferedReader(inputStreamReader);
    75.             String jsonUserStr = in.readLine();
    76.             return jsonUserStr;
    77.         } catch (Exception e) {
    78.             throw new RuntimeException(e);
    79.         } finally {
    80.             try {
    81.                 if (null != inputStream) {
    82.                     inputStream.close();
    83.                 }
    84.                 urlConnection.disconnect();
    85.             } catch (Exception e) {
    86.  
    87.             }
    88.             try {
    89.                 if (null != urlConnection) {
    90.                     urlConnection.disconnect();
    91.                 }
    92.  
    93.             } catch (Exception e) {
    94.  
    95.             }
    96.         }
    97.  
    98.     }
    99.     /**
    100.      * 发送HttpPost请求，参数为String
    101.      * 接收端以流形式接收
    102.      */
    103.     public static String sendPost(String url, String param) {
    104.         CloseableHttpClient httpclient = HttpClients.createDefault();
    105.         StringEntity strEntity = null;
    106.         try {
    107.             strEntity = new StringEntity(param, "UTF-8");
    108.             strEntity.setContentType("application/json");
    109.         } catch (Exception e1) {
    110.  
    111.             e1.printStackTrace();
    112.         }
    113.         HttpPost httppost = new HttpPost(url);
    114.         httppost.setEntity(strEntity);
    115.         CloseableHttpResponse response = null;
    116.         String result = null;
    117.         try {
    118.             response = httpclient.execute(httppost);
    119.             HttpEntity entity1 = response.getEntity();
    120.             result = EntityUtils.toString(entity1);
    121.  
    122.         } catch (IOException e) {
    123.             //  e.printStackTrace();
    124.         } finally {
    125.             try {
    126.                 response.close();
    127.             } catch (Exception e) {
    128.  
    129.             }
    130.         }
    131.  
    132.         return result;
    133.     }
    134.  
    135.     /**
    136.      * 发送不带参数的HttpPost请求
    137.      */
    138.     public static String sendPost(String url) {
    139.         CloseableHttpClient httpclient = HttpClients.createDefault();
    140.         HttpPost httppost = new HttpPost(url);
    141.         CloseableHttpResponse response = null;
    142.         try {
    143.             response = httpclient.execute(httppost);
    144.         } catch (IOException e) {
    145.             e.printStackTrace();
    146.         }
    147.         HttpEntity entity = response.getEntity();
    148.         String result = null;
    149.         try {
    150.             result = EntityUtils.toString(entity);
    151.         } catch (ParseException | IOException e) {
    152.             e.printStackTrace();
    153.         } finally {
    154.             try {
    155.                 response.close();
    156.             } catch (Exception e) {
    157.  
    158.             }
    159.         }
    160.         return result;
    161.     }
    162.  
    163. }

     分布式锁工具类

    1. import org.slf4j.Logger;
    2. import org.slf4j.LoggerFactory;
    3. import org.springframework.data.redis.connection.RedisStringCommands;
    4. import org.springframework.data.redis.connection.ReturnType;
    5. import org.springframework.data.redis.core.RedisCallback;
    6. import org.springframework.data.redis.core.RedisTemplate;
    7. import org.springframework.data.redis.core.types.Expiration;
    8. import org.springframework.stereotype.Component;
    9.  
    10. import javax.annotation.Resource;
    11. import java.nio.charset.StandardCharsets;
    12. @Component
    13. public class RedisLockUtil {
    14.  
    15.     private static final Logger log = LoggerFactory.getLogger(RedisLockUtil.class);
    16.  
    17.     @Resource
    18.      RedisTemplate redisTemplate;
    19.  
    20.  
    21.  
    22.     /**
    23.      * 释放锁脚本，原子操作，lua脚本
    24.      */
    25.     private static final String UNLOCK_LUA;
    26.  
    27.     static {
    28.         StringBuilder sb = new StringBuilder();
    29.         sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
    30.         sb.append("then ");
    31.         sb.append("    return redis.call(\"del\",KEYS[1]) ");
    32.         sb.append("else ");
    33.         sb.append("    return 0 ");
    34.         sb.append("end ");
    35.         UNLOCK_LUA = sb.toString();
    36.  
    37.     }
    38.  
    39.     /**
    40.      * 获取分布式锁，原子操作
    41.      *
    42.      * @param lockKey   锁
    43.      * @param lockValue 唯一ID
    44.      * @param leaseTime 过期时间 秒
    45.      * @return 是否枷锁成功
    46.      */
    47.     public  boolean tryLock(String lockKey, String lockValue, long leaseTime) {
    48.         try {
    49.             RedisCallback callback = (connection) -> connection.set(lockKey.getBytes(StandardCharsets.UTF_8),
    50.                     lockValue.getBytes(StandardCharsets.UTF_8), Expiration.seconds(leaseTime),
    51.                     RedisStringCommands.SetOption.SET_IF_ABSENT);
    52.             return redisTemplate.execute(callback);
    53.         } catch (Exception e) {
    54.             log.error("redis lock error ,lock key: {}, value : {}, error info : {}", lockKey, lockValue, e);
    55.         }
    56.         return false;
    57.     }
    58.  
    59.     /**
    60.      * 释放锁
    61.      *
    62.      * @param lockKey   锁
    63.      * @param lockValue 唯一ID
    64.      * @return 执行结果
    65.      */
    66.     public  boolean unlock(String lockKey, String lockValue) {
    67.         RedisCallback callback = (connection) -> connection.eval(UNLOCK_LUA.getBytes(), ReturnType.BOOLEAN, 1, lockKey.getBytes(StandardCharsets.UTF_8), lockValue.getBytes(StandardCharsets.UTF_8));
    68.         return redisTemplate.execute(callback);
    69.     }
    70.  
    71.     /**
    72.      * 获取分布式锁，该方法不再使用
    73.      *
    74.      * @param lockKey   锁
    75.      * @param lockValue 唯一ID
    76.      * @param waitTime  等待时间 秒
    77.      * @param leaseTime 过期时间 秒
    78.      * @return 是否枷锁成功
    79.      */
    80.     @Deprecated
    81.     public   boolean tryLock(String lockKey, String lockValue, long waitTime, long leaseTime) {
    82.         try {
    83.             RedisCallback callback = (connection) -> connection.set(lockKey.getBytes(StandardCharsets.UTF_8),
    84.                     lockValue.getBytes(StandardCharsets.UTF_8), Expiration.seconds(leaseTime),
    85.                     RedisStringCommands.SetOption.SET_IF_ABSENT);
    86.             return redisTemplate.execute(callback);
    87.         } catch (Exception e) {
    88.             log.error("redis lock error ,lock key: {}, value : {}, error info : {}", lockKey, lockValue, e);
    89.         }
    90.         return false;
    91.     }
    92. }

    生成uuid工具类

    1. import java.text.SimpleDateFormat;
    2. import java.util.Date;
    3.  
    4. public class UUID {
    5.  
    6.     public static String randomUUID() {
    7.         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd'T'HH'H'mm'M'ss'S'SSS");
    8.         String id = sdf.format(new Date()) + (int) ((Math.random() * 9 + 1) * 100000000) + (int) ((Math.random() * 9 + 1) * 10);
    9.         return id;
    10.     }
    11.  
    12.     public static String randomQr() {
    13.         String id = (int) ((Math.random() * 9 + 1) * 1000) + "-" + (int) ((Math.random() * 9 + 1) * 1000) + "-" + (int) ((Math.random() * 9 + 1) * 1000);
    14.         return id;
    15.     }
    16.  
    17. }

    信息返回的枚举

    1. import lombok.AllArgsConstructor;
    2.  
    3. import lombok.Getter;
    4.  
    5. /**
    6.  * @author ThinkPad
    7.  */
    8.  
    9. @Getter
    10. @AllArgsConstructor
    11. public enum PaymentEnum {
    12.     PAYMENT_ENUM_1(1, "订单不存在","失败"),
    13.     PAYMENT_ENUM_2(2,"订单不是待支付状态","失败"),
    14.     PAYMENT_ENUM_3(3,"支付金额少于订单金额","失败"),
    15.     PAYMENT_ENUM_4(4,"调用太快","失败"),
    16.     PAYMENT_ENUM_5(5,"余额不足,请前往充值","失败"),
    17.     PAYMENT_ENUM_6(6,"支付成功","成功"),
    18.     PAYMENT_ENUM_7(7,"处理成功","失败"),
    19.     PAYMENT_ENUM_8(8,"处理失败","失败");
    20.     private final Integer code;
    21.     private final String msg;
    22.     private final String status;
    23.  
    24.     public static String getMsgByCode(Integer code) {
    25.         for (PaymentEnum value : PaymentEnum.values()) {
    26.             if (value.getCode().equals(code)) {
    27.                 return value.getMsg();
    28.             }
    29.         }
    30.         return null;
    31.     }
    32.  
    33.     public static String getStatusByCode(Integer code) {
    34.         for (PaymentEnum value : PaymentEnum.values()) {
    35.             if (value.getCode().equals(code)) {
    36.                 return value.getStatus() ;
    37.             }
    38.         }
    39.         return null;
    40.     }
    41.  
    42.  
    43. }

    支付的controller层

    1.  /**
    2.      * 处理未完成的订单 （这部十分重要，会影响到后面的操作）
    3.      */
    4.     @PostMapping("payOrder/incomplete")
    5.     @ApiOperation("处理未完成的订单")
    6.     @ApiImplicitParam(name = "Authorization", value = "传入你的令牌",required = true, dataType = "String",paramType="header")
    7.     public ResponseVO incomplete(@RequestBody IncompleteVO incompleteVO) {
    8.  
    9.         try {
    10.  
    11.             return orderInfoService.incomplete(incompleteVO);
    12.         } catch (Exception e) {
    13.             log.error("报错如下：{}", e.getMessage());
    14.             throw new BusinessException("支付失败，请联系后台人员"+e.getLocalizedMessage()+e.toString()+e.getCause().toString());
    15.         }
    16.  
    17.     }
    18.  
    19.     /**
    20.      * 前端请求支付授权,在本地订单创建后调
    21.      */
    22.     @PostMapping("payOrder/approve")
    23.     @ApiOperation("前端请求支付授权,在本地订单创建后调")
    24.     @ApiImplicitParam(name = "Authorization", value = "传入你的令牌",required = true, dataType = "String",paramType="header")
    25.     public ResponseVO approve(@RequestBody PaymentVO paymentVO) {
    26.  
    27.         try {
    28.  
    29.             String orderId = orderInfoService.approve(paymentVO);
    30.  
    31.             return ResponseVO.getSuccessResponseVo(orderId);
    32.         } catch (Exception e) {
    33.             log.error("报错如下：{}", e.getMessage());
    34.             throw new BusinessException("支付失败，请联系后台人员"+e.getLocalizedMessage()+e.toString()+e.getCause().toString());
    35.         }
    36.  
    37.     }
    38.  
    39.  
    40.     /**
    41.      * 前端支付完成,余额支付直接调用此方法
    42.      */
    43.     @PostMapping("payOrder/complete")
    44.     @ApiOperation("前端支付完成,余额支付直接调用此方法")
    45.     @ApiImplicitParam(name = "Authorization", value = "传入你的令牌",required = true, dataType = "String",paramType="header")
    46.     public ResponseVO complete(@RequestBody CompleteVO completeVO) {
    47.  
    48.         try {
    49.  
    50.  
    51.             return orderInfoService.complete(completeVO);
    52.         } catch (Exception e) {
    53.             log.error("报错如下：{}", e.getMessage());
    54.             throw new BusinessException("支付失败，请联系后台人员"+e.getLocalizedMessage()+e.toString()+e.getCause().toString());
    55.         }
    56.  
    57.     }
    58.  
    59.     /**
    60.      * 取消支付,订单关闭
    61.      */
    62.     @PostMapping("payOrder/cancelled")
    63.     @ApiOperation("取消支付,订单关闭")
    64.     @ApiImplicitParam(name = "Authorization", value = "传入你的令牌",required = true, dataType = "String",paramType="header")
    65.     public ResponseVO cancelled(@RequestBody String orderId) {
    66.  
    67.         try {
    68.  
    69.             Boolean order = orderInfoService.cancelled(orderId);
    70. //            if (!order){throw  new BusinessException("取消订单失败");}
    71.             return ResponseVO.getSuccessResponseVo("取消订单成功");
    72.         } catch (Exception e) {
    73.             log.error("报错如下：{}", e.getMessage());
    74.             throw new BusinessException("取消失败，请联系后台人员"+e.getLocalizedMessage()+e.toString()+e.getCause().toString());
    75.         }
    76.  
    77.     }

    支付的service层

    1.     /**
    2.      * 请求支付授权，创建order。返回orderId
    3.      * @param paymentVO
    4.      * @return
    5.      */
    6.     @Override
    7.     @Transactional(rollbackFor = Exception.class)
    8.     public String approve(PaymentVO paymentVO) {
    9.         log.error("approve-------------------------------------------------------------");
    10.         OrderInfo orderInfo;
    11.         log.error("paymentVO----------------------------------"+paymentVO);
    12.         //获取付款信息
    13.         OkHttpClient client = new OkHttpClient();
    14.         Request request = new Request.Builder()
    15.                 .url("https://api.minepi.com/v2/payments/" + paymentVO.getPaymentId())
    16.                 .addHeader("Authorization", "Key " + commonConfig.getServerAccessKey())
    17.                 .build();
    18.         try (Response response = client.newCall(request).execute()) {
    19.             if (!response.isSuccessful()) {
    20.                 String string = response.body().string();
    21.                 JSONObject jsonObject1 = JSON.parseObject(string);
    22.                 log.error("!response-------------------------------------------------------------"+commonConfig.getServerAccessKey());
    23.                 throw new RuntimeException("payments error " + jsonObject1.getString("error_message"));
    24.             }
    25.             String string = response.body().string();
    26.             log.error("response-------------------------------------------------------------"+string);
    27.  
    28.             JSONObject jsonObject1 = JSON.parseObject(string);
    29.             //校验实际支付金额
    30.             BigDecimal userFinalPrice = paymentVO.getAmount();
    31.  
    32.  
    33.             if (userFinalPrice.compareTo(jsonObject1.getBigDecimal("amount")) < 0) {
    34.                 log.error(userFinalPrice+"response-------------------------------------------------------------"+jsonObject1.getBigDecimal("amount"));
    35.                 throw new RuntimeException("支付金额少于订单金额");
    36.             }
    37.  
    38.  
    39.         } catch (Exception e) {
    40.             throw  new BusinessException("支付失败，请联系后台人员"+e.getLocalizedMessage()+e.toString()+e.getCause().toString());
    41.         }
    42.  
    43.  
    44.         OkHttpClient client1 = new OkHttpClient();
    45.         //信息真实，通知PI我准备好了，可以付款了
    46.         Request request1 = new Request.Builder()
    47.                 .url("https://api.minepi.com/v2/payments/" + paymentVO.getPaymentId() + "/approve")
    48.                 .addHeader("Content-Type", "application/json")
    49.                 .addHeader("Access-Control-Allow-Origin", "*")
    50.                 .addHeader("Authorization", "Key " + commonConfig.getServerAccessKey())
    51.                 .post(RequestBody.create("", MediaType.parse("application/json")))
    52.                 .build();
    53.         try (Response response1 = client1.newCall(request1).execute()) {
    54.             if (!response1.isSuccessful()) {
    55.                 throw new RuntimeException("approve error: ");
    56.             }
    57.             log.error("response1-------------------------------------------------------------");
    58.  
    59.             //更新支付报文
    60. //                    tMerStoreGoodsOrderEntity.setPayOrderId(paymentDto.getPaymentId());
    61. //                    tMerStoreGoodsOrderEntity.setPayStatusType("10007002");//支付中
    62. //                    itMerStoreGoodsOrderService.updateById(tMerStoreGoodsOrderEntity);
    63.             log.error("return-------------------------------------------------------------");
    64.         } catch (RuntimeException | IOException e) {
    65.             log.error("error-------------------------------------------------------------");
    66.             e.printStackTrace();
    67.         }
    68.         // 生成订单
    69.         orderInfo = new OrderInfo();
    70.         orderInfo.setOrderId(StringUtil.generateShortId());
    71.         orderInfo.setShopId(paymentVO.getShopId());
    72.         orderInfo.setUserId(paymentVO.getUserId());
    73.         orderInfo.setShopUserId(paymentVO.getShopUserId());
    74.         orderInfo.setAmount(paymentVO.getAmount());
    75.         orderInfoMapper.insert(orderInfo);
    76.         log.error("生成订单-------------------------------------------------------------");
    77.         return orderInfo.getOrderId();
    78.     }
    79.     /**
    80.      * 前端支付完成,余额支付直接调用此方法
    81.      */
    82.     @Override
    83.     @Transactional(rollbackFor = Exception.class)
    84.     public ResponseVO complete(CompleteVO completeVO) {
    85.         String payType = completeVO.getPayType();
    86.         log.error("complete------------------------------------------------------------"+completeVO);
    87.         if ("1".equals(payType)) {
    88.             //余额支付
    89.             String orderId = completeVO.getOrderId();
    90.             String lockName = "access:lock:complete:" + orderId;
    91.             String lockId = UUID.randomUUID();
    92.             if (!redisLockUtil.tryLock(lockName, lockId, 20L)) {
    93.                 // 调用太快
    94.                 return new ResponseVO(PaymentEnum.getStatusByCode(4),4,PaymentEnum.getMsgByCode(4));
    95.             }
    96.             // 获取订单信息
    97.             OrderInfo orderInfo = orderInfoMapper.selectOne(new QueryWrapper().eq("order_id", orderId));
    98.  
    99.             if ((orderInfo.getOrderStatus() != 0)) {
    100.                 // 订单不是待支付状态
    101.                 return new ResponseVO(PaymentEnum.getStatusByCode(2),2,PaymentEnum.getMsgByCode(2));
    102.             }
    103.             String userId = orderInfo.getUserId();
    104.             AccountInfo accountInfo = accountInfoMapper.selectOne(new QueryWrapper()
    105.                                                                         .eq("user_id", userId));
    106.  
    107.             BigDecimal balance = accountInfo.getPiBalance();
    108.             if (balance.compareTo(orderInfo.getAmount()) < 0) {
    109.                 // 余额不足，请前往充值
    110.                 return new ResponseVO(PaymentEnum.getStatusByCode(5),5,PaymentEnum.getMsgByCode(5));
    111.             }
    112.             int update = orderInfoMapper.update(null,new UpdateWrapper()
    113.                                                                 .eq("order_id",orderId)
    114.                                                                 .set("order_status",1));
    115.             balance=balance.subtract(orderInfo.getAmount());
    116.             int update1 = accountInfoMapper.update(null, new UpdateWrapper()
    117.                                                                     .eq("user_id", userId)
    118.                                                                     .set("pi_balance", balance));
    119.             // 支付成功
    120.             return new ResponseVO(PaymentEnum.getStatusByCode(6),6,PaymentEnum.getMsgByCode(6));
    121.         }
    122.         //PI钱包支付
    123.         String paymentId = completeVO.getPaymentId();//PI订单号
    124.         String lockName = "access:lock:complete:" + paymentId;
    125.         String lockId = UUID.randomUUID();
    126.         log.error(paymentId+"-----------------"+lockName+"---------------------"+lockId);
    127.         if (!redisLockUtil.tryLock(lockName, lockId, 20L)) {
    128.             // 调用太快
    129.             log.error("!RedisLockUtil---------------------------------------------------------调用太快");
    130.             return new ResponseVO(PaymentEnum.getStatusByCode(4),4,PaymentEnum.getMsgByCode(4));
    131.         }
    132.         OrderInfo orderInfo = orderInfoMapper.selectOne(new QueryWrapper()
    133.                                                             .eq("order_id", completeVO.getOrderId()));
    134.         log.error("orderId--------------------------------------------------------------"+orderInfo);
    135.         if (null == orderInfo) {
    136.             // 订单不存在
    137.             log.error("!orderinfo--------------------------------------------------------不存在");
    138.             return new ResponseVO(PaymentEnum.getStatusByCode(1),1,PaymentEnum.getMsgByCode(1));
    139.         }
    140.         log.error("orderinfo------------------------------------------------------------------"+orderInfo);
    141.         if (orderInfo.getOrderStatus() != 0) {
    142.             // 订单不是待支付状态
    143.             log.error("!order---------------------------------------------------------pay");
    144.             return  new ResponseVO(PaymentEnum.getStatusByCode(2),2,PaymentEnum.getMsgByCode(2));
    145.         }
    146.  
    147.  
    148.         //通知PI完成交易
    149.         JSONObject jsonObject = new JSONObject();
    150.         jsonObject.put("txid", completeVO.getTxId());
    151.  
    152.         Map heads = new HashMap<>();
    153.         heads.put("Content-Type", "application/json;charset=UTF-8");
    154.         heads.put("Authorization", "Key " + commonConfig.getServerAccessKey());
    155.         log.error("pi-----------------------------------------"+jsonObject);
    156.         try {
    157.             HttpResponse response = HttpRequest.post("https://api.minepi.com/v2/payments/" + paymentId + "/complete")
    158.                     .headerMap(heads, false)
    159.                     .body(String.valueOf(jsonObject))
    160.                     .timeout(5 * 60 * 1000)
    161.                     .execute();
    162.             String body = response.body();
    163.             JSONObject jsonObject1 = JSON.parseObject(body);
    164.             String error = jsonObject1.getString("error");
    165.             if (!StringUtils.isEmpty(error)) {
    166.                 log.error("!strinutils-----------------------------"+body);
    167.                 throw new RuntimeException("订单完成异常!");
    168.             }
    169.             orderInfo.setOrderStatus(1);
    170.             // 更新订单
    171.             orderInfoMapper.updateById(orderInfo);
    172.             log.error("支付成功------------------------------------------------------");
    173.             // 支付成功
    174.             return  new ResponseVO(PaymentEnum.getStatusByCode(6),6,PaymentEnum.getMsgByCode(6));
    175.         } catch (Exception e) {
    176.             throw e;
    177.         }
    178.  
    179.     }
    180.  
    181.     @Override
    182.     @Transactional(rollbackFor = Exception.class)
    183.     public Boolean cancelled(String orderId) {
    184.         int update = orderInfoMapper.update(null, new UpdateWrapper()
    185.                                                         .eq("order_id", orderId)
    186.                                                         .set("order_status", 3));
    187.         return update > 0;
    188.     }
    189.  
    190.     @Override
    191.     public ResponseVO incomplete(IncompleteVO incompleteVO) {
    192.         log.error("incomplete--------------------------------");
    193.         try {
    194.             //先处理未完成的订单
    195.             String oldpaymentId = incompleteVO.getIdentifier();
    196.             TransactionVO transaction = incompleteVO.getTransaction();
    197.             log.error("?transation--------------------"+transaction);
    198.             log.error("?oldpaymentId------------------"+oldpaymentId);
    199.             if (null != transaction) {
    200.                 log.error("transation--------------------"+transaction);
    201.                 log.error("oldpaymentId------------------"+oldpaymentId);
    202.                 String txid = transaction.getTxid();
    203.                 String txURL = transaction.get_link();
    204.  
    205. //                OrderInfo orderInfo = orderInfoMapper.selectOne(new QueryWrapper().eq("order_id", oldpaymentId));
    206. //                if (null == orderInfo) {
    207. //                    log.error("order-----------------null");
    208. //                    throw new RuntimeException("旧订单不存在");
    209. //                }
    210. //
    211. //                if (orderInfo.getOrderStatus()==1) {
    212. //                    log.error("orderStatus---------------------"+orderInfo.getOrderStatus());
    213. //                    throw new RuntimeException("订单是已支付状态");
    214. //                }
    215.  
    216.                 String get = HttpClientUtil.sendGet(txURL);
    217.                 JSONObject jsonObject1 = JSON.parseObject(get);
    218.                 String piOrderId = jsonObject1.getString("memo");//我方订单ID
    219.  
    220.                 log.error("memo---------------------"+piOrderId);
    221.  
    222.                 JSONObject jsonObject = new JSONObject();
    223.                 jsonObject.put("txid", txid);
    224.  
    225.                 Map heads = new HashMap<>();
    226.                 heads.put("Content-Type", "application/json;charset=UTF-8");
    227.                 heads.put("Authorization", "Key " + commonConfig.getServerAccessKey());
    228.  
    229.                 try {
    230.                     HttpResponse response = HttpRequest.post("https://api.minepi.com/v2/payments/" + piOrderId + "/complete")
    231.                             .headerMap(heads, false)
    232.                             .body(String.valueOf(jsonObject))
    233.                             .timeout(5 * 60 * 1000)
    234.                             .execute();
    235.                     String body = response.body();
    236.                     JSONObject jsonObject2 = JSON.parseObject(body);
    237.                     String error = jsonObject2.getString("error");
    238.                     if (!StringUtils.isEmpty(error)) {
    239.                         log.error("!response------------------"+error);
    240.                         throw new RuntimeException("订单完成异常!");
    241.                     }
    242.  
    243.                     return new ResponseVO(PaymentEnum.getStatusByCode(7),7,PaymentEnum.getMsgByCode(7));
    244.                 } catch (Exception e) {
    245.                     throw e;
    246.                 }
    247.             }
    248.         } catch (Exception e) {
    249.             return new ResponseVO(PaymentEnum.getStatusByCode(8),8,PaymentEnum.getMsgByCode(8));
    250.         }
    251.         return new ResponseVO(PaymentEnum.getStatusByCode(8),8,PaymentEnum.getMsgByCode(8));
    252.     }

     前端代码

    前端路由 

    1. API
    2. // 授权
    3. import request from "@/api/http";
    4. import axios from "axios";
    5.  
    6. // 支付授权
    7. export function payAuth(data){
    8.   return request({
    9.     url: "/api/order/payOrder/approve",
    10.     method: "post",
    11.     data,
    12.   });
    13. }
    14.  
    15. //未完成订单
    16. export function payIncomplete(data){
    17.   return request({
    18.     url: "/api/order/payOrder/incomplete",
    19.     method: "post",
    20.     data,
    21.   });
    22. }
    23.  
    24. //支付成功
    25. export function payDone(data){
    26.   return request({
    27.     url: "/api/order/payOrder/complete",
    28.     method: "post",
    29.     data,
    30.   });
    31. }
    32. //支付取消
    33. export function payCancel(data){
    34.   return request({
    35.     url: "/api/order/payOrder/cancelled",
    36.     method: "post",
    37.     data,
    38.   })
    39. }

    支付前端代码

    1.  test(){
    2.       const pay_message = this.pay_message
    3.       let orderid = ''
    4.       console.log({
    5.         amount: pay_message.amount,
    6.         shopUserId: pay_message.shopUserId,
    7.         shopId: pay_message.shopId,
    8.         userId: pay_message.userId
    9.       })
    10.       Pi.createPayment({
    11.         // Amount of π to be paid:
    12.         amount: 3.14,
    13.         // An explanation of the payment - will be shown to the user:
    14.         memo: "购买特殊数据", // e.g: "Digital kitten #1234",
    15.         // An arbitrary developer-provided metadata object - for your own usage:
    16.         metadata: { productID : 'apple_pie_1'  }, // e.g: { kittenId: 1234 }
    17.       }, {
    18.         // Callbacks you need to implement - read more about those in the detailed docs linked below:
    19.  
    20.         // 授权
    21.         async onReadyForServerApproval(paymentId) {
    22.           console.log('paymentId',paymentId)
    23.           payAuth({
    24.             paymentId: paymentId,
    25.             amount: pay_message.amount,
    26.             shopUserId: pay_message.shopUserId,
    27.             shopId: pay_message.shopId,
    28.             userId: pay_message.userId
    29.           }).then((data) => {
    30.             orderid = data.data
    31.             console.log('orderId',orderid)
    32.           }).catch(error => {
    33.             console.log(error)
    34.           })
    35.         },
    36.         //支付成功
    37.         onReadyForServerCompletion: function(paymentId, txid) {
    38.           alert(1111)
    39.           console.log(paymentId, 'paymentId', 'txid', txid,'orderid',orderid )
    40.           payDone({paymentId: paymentId, txId: txid, orderId: orderid,payType:'0'}).then(res => {
    41.             console.log(res)
    42.             // if (res && res.code === 0) {
    43.             //   this.payDoneJump();
    44.             // }
    45.           })
    46.         },
    47.         //支付取消
    48.         onCancel: function(orderid) {
    49.           console.log('onCancel' + orderid)
    50.             payCancel(orderid).then((data) => {
    51.               console.log(data)
    52.             })
    53.         },
    54.         //支付失败
    55.         onError: function(error, payment) {console.log('error:',error);console.log('payment:',payment)}
    56.       });
    57.     },

    登录自动调用未支付订单，这个十分重要因为会影响支付授权。 

    1. const loginFun = () => {
    2.   Pi.init({ version: "2.0", sandbox: true });
    3.  
    4.   const scopes = ["payments", "username", "wallet_address"];
    5.  
    6.   function onIncompletePaymentFound(payment) {
    7.     alert(1111111)
    8.     console.log("payment", payment);
    9.     return payIncomplete({
    10.       identifier:payment.identifier,
    11.       transaction:{
    12.         _link:payment.transaction._link,
    13.         txid:res.transaction.txid
    14.       }
    15.     })
    16.   }
    17.   Pi.authenticate(scopes, onIncompletePaymentFound).then(function (auth) {
    18.       console.log("auth", auth);
    19.       let userInfo = {
    20.         accessToken: auth.accessToken,
    21.         userId: auth.user.uid,
    22.         userName: auth.user.username,
    23.       };
    24.  
    25.       // userGetPush().then((data) => {
    26.       //   console.log(data);
    27.       //   userStore().userGetPush = data.data;
    28.       // });
    29.  
    30.       Login(userInfo).then((data) => {
    31.         console.log(data);
    32.  
    33.         if (data.status == "success") {
    34.           // 将用户信息存入pinia
    35.           userStore().userInfoChange(data.data);
    36.  
    37.           // 发布消息到socket Login() 存入userId
    38.           // this.$socket.emit("login", data.data.userInfo.userId);
    39.  
    40.           router.push("/home");
    41.         }
    42.       });
    43.     })
    44.     .catch(function (error) {
    45.       console.error(error);
    46.     });
    47. };

    详细流程

    使用Pi-SDK功能发起支付

     由Pi SDK自动调用的回调函数，发出支付批准请求

     

     路由到后端的支付授权接口

     后端服务器向Pi服务器发起支付授权

    1.  @Override
    2.     @Transactional(rollbackFor = Exception.class)
    3.     public String approve(PaymentVO paymentVO) {
    4.         log.error("approve-------------------------------------------------------------");
    5.         OrderInfo orderInfo;
    6.         log.error("paymentVO----------------------------------"+paymentVO);
    7.         //获取付款信息
    8.         OkHttpClient client = new OkHttpClient();
    9.         Request request = new Request.Builder()
    10.                 .url("https://api.minepi.com/v2/payments/" + paymentVO.getPaymentId())
    11.                 .addHeader("Authorization", "Key " + commonConfig.getServerAccessKey())
    12.                 .build();
    13.         try (Response response = client.newCall(request).execute()) {
    14.             if (!response.isSuccessful()) {
    15.                 String string = response.body().string();
    16.                 JSONObject jsonObject1 = JSON.parseObject(string);
    17.                 log.error("!response-------------------------------------------------------------"+commonConfig.getServerAccessKey());
    18.                 throw new RuntimeException("payments error " + jsonObject1.getString("error_message"));
    19.             }
    20.             String string = response.body().string();
    21.             log.error("response-------------------------------------------------------------"+string);
    22.  
    23.             JSONObject jsonObject1 = JSON.parseObject(string);
    24.             //校验实际支付金额
    25.             BigDecimal userFinalPrice = paymentVO.getAmount();
    26.  
    27.  
    28.             if (userFinalPrice.compareTo(jsonObject1.getBigDecimal("amount")) < 0) {
    29.                 log.error(userFinalPrice+"response-------------------------------------------------------------"+jsonObject1.getBigDecimal("amount"));
    30.                 throw new RuntimeException("支付金额少于订单金额");
    31.             }
    32.  
    33.  
    34.         } catch (Exception e) {
    35.             throw  new BusinessException("支付失败，请联系后台人员"+e.getLocalizedMessage()+e.toString()+e.getCause().toString());
    36.         }
    37.  
    38.  
    39.         OkHttpClient client1 = new OkHttpClient();
    40.         //信息真实，通知PI我准备好了，可以付款了
    41.         Request request1 = new Request.Builder()
    42.                 .url("https://api.minepi.com/v2/payments/" + paymentVO.getPaymentId() + "/approve")
    43.                 .addHeader("Content-Type", "application/json")
    44.                 .addHeader("Access-Control-Allow-Origin", "*")
    45.                 .addHeader("Authorization", "Key " + commonConfig.getServerAccessKey())
    46.                 .post(RequestBody.create("", MediaType.parse("application/json")))
    47.                 .build();
    48.         try (Response response1 = client1.newCall(request1).execute()) {
    49.             if (!response1.isSuccessful()) {
    50.                 throw new RuntimeException("approve error: ");
    51.             }
    52.             log.error("response1-------------------------------------------------------------");
    53.  
    54.             //更新支付报文
    55. //                    tMerStoreGoodsOrderEntity.setPayOrderId(paymentDto.getPaymentId());
    56. //                    tMerStoreGoodsOrderEntity.setPayStatusType("10007002");//支付中
    57. //                    itMerStoreGoodsOrderService.updateById(tMerStoreGoodsOrderEntity);
    58.             log.error("return-------------------------------------------------------------");
    59.         } catch (RuntimeException | IOException e) {
    60.             log.error("error-------------------------------------------------------------");
    61.             e.printStackTrace();
    62.         }
    63.         // 生成订单
    64.         orderInfo = new OrderInfo();
    65.         orderInfo.setOrderId(StringUtil.generateShortId());
    66.         orderInfo.setShopId(paymentVO.getShopId());
    67.         orderInfo.setUserId(paymentVO.getUserId());
    68.         orderInfo.setShopUserId(paymentVO.getShopUserId());
    69.         orderInfo.setAmount(paymentVO.getAmount());
    70.         orderInfoMapper.insert(orderInfo);
    71.         log.error("生成订单-------------------------------------------------------------");
    72.         return orderInfo.getOrderId();
    73.     }

    PI游览器向用户显示付款详细信息页面，我们等待用户签署交易

     由Pi SDK自动调用完成的回调函数

     从你的后端服务器到Pi服务器的API请求以完成付款（让pi服务器知道你完成此付款）

    1.  /**
    2.      * 前端支付完成,余额支付直接调用此方法
    3.      */
    4.     @Override
    5.     @Transactional(rollbackFor = Exception.class)
    6.     public ResponseVO complete(CompleteVO completeVO) {
    7.         String payType = completeVO.getPayType();
    8.         log.error("complete------------------------------------------------------------"+completeVO);
    9.         if ("1".equals(payType)) {
    10.             //余额支付
    11.             String orderId = completeVO.getOrderId();
    12.             String lockName = "access:lock:complete:" + orderId;
    13.             String lockId = UUID.randomUUID();
    14.             if (!redisLockUtil.tryLock(lockName, lockId, 20L)) {
    15.                 // 调用太快
    16.                 return new ResponseVO(PaymentEnum.getStatusByCode(4),4,PaymentEnum.getMsgByCode(4));
    17.             }
    18.             // 获取订单信息
    19.             OrderInfo orderInfo = orderInfoMapper.selectOne(new QueryWrapper<OrderInfo>().eq("order_id", orderId));
    20.  
    21.             if ((orderInfo.getOrderStatus() != 0)) {
    22.                 // 订单不是待支付状态
    23.                 return new ResponseVO(PaymentEnum.getStatusByCode(2),2,PaymentEnum.getMsgByCode(2));
    24.             }
    25.             String userId = orderInfo.getUserId();
    26.             AccountInfo accountInfo = accountInfoMapper.selectOne(new QueryWrapper<AccountInfo>()
    27.                                                                         .eq("user_id", userId));
    28.  
    29.             BigDecimal balance = accountInfo.getPiBalance();
    30.             if (balance.compareTo(orderInfo.getAmount()) < 0) {
    31.                 // 余额不足，请前往充值
    32.                 return new ResponseVO(PaymentEnum.getStatusByCode(5),5,PaymentEnum.getMsgByCode(5));
    33.             }
    34.             int update = orderInfoMapper.update(null,new UpdateWrapper<OrderInfo>()
    35.                                                                 .eq("order_id",orderId)
    36.                                                                 .set("order_status",1));
    37.             balance=balance.subtract(orderInfo.getAmount());
    38.             int update1 = accountInfoMapper.update(null, new UpdateWrapper<AccountInfo>()
    39.                                                                     .eq("user_id", userId)
    40.                                                                     .set("pi_balance", balance));
    41.             // 支付成功
    42.             return new ResponseVO(PaymentEnum.getStatusByCode(6),6,PaymentEnum.getMsgByCode(6));
    43.         }
    44.         //PI钱包支付
    45.         String paymentId = completeVO.getPaymentId();//PI订单号
    46.         String lockName = "access:lock:complete:" + paymentId;
    47.         String lockId = UUID.randomUUID();
    48.         log.error(paymentId+"-----------------"+lockName+"---------------------"+lockId);
    49.         if (!redisLockUtil.tryLock(lockName, lockId, 20L)) {
    50.             // 调用太快
    51.             log.error("!RedisLockUtil---------------------------------------------------------调用太快");
    52.             return new ResponseVO(PaymentEnum.getStatusByCode(4),4,PaymentEnum.getMsgByCode(4));
    53.         }
    54.         OrderInfo orderInfo = orderInfoMapper.selectOne(new QueryWrapper<OrderInfo>()
    55.                                                             .eq("order_id", completeVO.getOrderId()));
    56.         log.error("orderId--------------------------------------------------------------"+orderInfo);
    57.         if (null == orderInfo) {
    58.             // 订单不存在
    59.             log.error("!orderinfo--------------------------------------------------------不存在");
    60.             return new ResponseVO(PaymentEnum.getStatusByCode(1),1,PaymentEnum.getMsgByCode(1));
    61.         }
    62.         log.error("orderinfo------------------------------------------------------------------"+orderInfo);
    63.         if (orderInfo.getOrderStatus() != 0) {
    64.             // 订单不是待支付状态
    65.             log.error("!order---------------------------------------------------------pay");
    66.             return  new ResponseVO(PaymentEnum.getStatusByCode(2),2,PaymentEnum.getMsgByCode(2));
    67.         }
    68.  
    69.  
    70.         //通知PI完成交易
    71.         JSONObject jsonObject = new JSONObject();
    72.         jsonObject.put("txid", completeVO.getTxId());
    73.  
    74.         Map<String, String> heads = new HashMap<>();
    75.         heads.put("Content-Type", "application/json;charset=UTF-8");
    76.         heads.put("Authorization", "Key " + commonConfig.getServerAccessKey());
    77.         log.error("pi-----------------------------------------"+jsonObject);
    78.         try {
    79.             HttpResponse response = HttpRequest.post("https://api.minepi.com/v2/payments/" + paymentId + "/complete")
    80.                     .headerMap(heads, false)
    81.                     .body(String.valueOf(jsonObject))
    82.                     .timeout(5 * 60 * 1000)
    83.                     .execute();
    84.             String body = response.body();
    85.             JSONObject jsonObject1 = JSON.parseObject(body);
    86.             String error = jsonObject1.getString("error");
    87.             if (!StringUtils.isEmpty(error)) {
    88.                 log.error("!strinutils-----------------------------"+body);
    89.                 throw new RuntimeException("订单完成异常!");
    90.             }
    91.             orderInfo.setOrderStatus(1);
    92.             // 更新订单
    93.             orderInfoMapper.updateById(orderInfo);
    94.             log.error("支付成功------------------------------------------------------");
    95.             // 支付成功
    96.             return  new ResponseVO(PaymentEnum.getStatusByCode(6),6,PaymentEnum.getMsgByCode(6));
    97.         } catch (Exception e) {
    98.             throw e;
    99.         }
    100.  
    101.     }

    注意，如果用户有未处理的订单，会导致用户重新创建支付失败，需要有个接口去处理未完成的订单

    前端一初始化就去执行处理未完成的订单

    路由到后端的接口 

     

     后端接口代码

    1. @Override
    2.     public ResponseVO incomplete(IncompleteVO incompleteVO) {
    3.         log.error("incomplete--------------------------------");
    4.         try {
    5.             //先处理未完成的订单
    6.             String oldpaymentId = incompleteVO.getIdentifier();
    7.             TransactionVO transaction = incompleteVO.getTransaction();
    8.             log.error("?transation--------------------"+transaction);
    9.             log.error("?oldpaymentId------------------"+oldpaymentId);
    10.             if (null != transaction) {
    11.                 log.error("transation--------------------"+transaction);
    12.                 log.error("oldpaymentId------------------"+oldpaymentId);
    13.                 String txid = transaction.getTxid();
    14.                 String txURL = transaction.get_link();
    15.  
    16. //                OrderInfo orderInfo = orderInfoMapper.selectOne(new QueryWrapper<OrderInfo>().eq("order_id", oldpaymentId));
    17. //                if (null == orderInfo) {
    18. //                    log.error("order-----------------null");
    19. //                    throw new RuntimeException("旧订单不存在");
    20. //                }
    21. //
    22. //                if (orderInfo.getOrderStatus()==1) {
    23. //                    log.error("orderStatus---------------------"+orderInfo.getOrderStatus());
    24. //                    throw new RuntimeException("订单是已支付状态");
    25. //                }
    26.  
    27.                 String get = HttpClientUtil.sendGet(txURL);
    28.                 JSONObject jsonObject1 = JSON.parseObject(get);
    29.                 String piOrderId = jsonObject1.getString("memo");//我方订单ID
    30.  
    31.                 log.error("memo---------------------"+piOrderId);
    32.  
    33.                 JSONObject jsonObject = new JSONObject();
    34.                 jsonObject.put("txid", txid);
    35.  
    36.                 Map<String, String> heads = new HashMap<>();
    37.                 heads.put("Content-Type", "application/json;charset=UTF-8");
    38.                 heads.put("Authorization", "Key " + commonConfig.getServerAccessKey());
    39.  
    40.                 try {
    41.                     HttpResponse response = HttpRequest.post("https://api.minepi.com/v2/payments/" + piOrderId + "/complete")
    42.                             .headerMap(heads, false)
    43.                             .body(String.valueOf(jsonObject))
    44.                             .timeout(5 * 60 * 1000)
    45.                             .execute();
    46.                     String body = response.body();
    47.                     JSONObject jsonObject2 = JSON.parseObject(body);
    48.                     String error = jsonObject2.getString("error");
    49.                     if (!StringUtils.isEmpty(error)) {
    50.                         log.error("!response------------------"+error);
    51.                         throw new RuntimeException("订单完成异常!");
    52.                     }
    53.  
    54.                     return new ResponseVO(PaymentEnum.getStatusByCode(7),7,PaymentEnum.getMsgByCode(7));
    55.                 } catch (Exception e) {
    56.                     throw e;
    57.                 }
    58.             }
    59.         } catch (Exception e) {
    60.             return new ResponseVO(PaymentEnum.getStatusByCode(8),8,PaymentEnum.getMsgByCode(8));
    61.         }
    62.         return new ResponseVO(PaymentEnum.getStatusByCode(8),8,PaymentEnum.getMsgByCode(8));
    63.     }

  • 相关阅读:
    【STM32】标准库-读写内部Flash及用户选项字节
    一个UI设计师自学编程的经历
    关于 Vue3 响应式 API 以及 reactive 和 ref 的用法
    2000-2021年各省GDP包括名义GDP、实际GDP、GDP平减指数（以2000年为基期）
    vue3.0中使用echarts，鼠标悬浮无法显示数据框的问题
    【leetcode热题Hot100】——LRU缓存
    字符串的认识
    Zookeeper系列——1Zookeeper简介及部署
    【支付宝生态质量验收与检测技术】
    Seaborn绘制热力图的子图
  • 原文地址：https://blog.csdn.net/qq_63431773/article/details/132129639