1. Toy模板网首页
  2. > Toy博客

springboot整合pi支付开发

7月前 作者：无语堵上西楼 分类：Toy博客 阅读(25) 违法举报

这篇具有很好参考价值的文章主要介绍了springboot整合pi支付开发。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

pi支付流程图：

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

springboot整合pi支付开发,pi开发,spring boot,后端,java

springboot整合pi支付开发,pi开发,spring boot,后端,java

 引入依赖

  <dependency>
      <groupId>com.squareup.okhttp3</groupId>
      <artifactId>okhttp</artifactId>
      <version>4.10.0-RC1</version>
   </dependency>
   <dependency>
      <groupId>cn.hutool</groupId>
      <artifactId>hutool-all</artifactId>
      <version>5.8.0.M4</version>
   </dependency>
    <dependency>
      <groupId>org.apache.httpcomponents</groupId>
      <artifactId>httpclient</artifactId>
      <version>4.5.13</version>
   </dependency>
        <dependency>
        <groupId>commons-lang</groupId>
        <artifactId>commons-lang</artifactId>
        <version>2.6</version>
   </dependency>

配置api密钥

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

/**
 * 服务器端key
 * @author ThinkPad
 */
@Configuration
@Data
public class CommonConfig {

    @Value("${sdk.serverAccessKey}")
    private String serverAccessKey;
}

springboot整合pi支付开发,pi开发,spring boot,后端,java

 接收和返回数据对象

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

import lombok.Data;

/**
 * @author wzx
 * 登录数据封装类
 */
@Data
public class LoginVO {

    private String userId;
    private String userName;
    private String accessToken;
}

paymentVO接收支付授权的信息

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.math.BigDecimal;

/**
 * @author ThinkPad
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class PaymentVO {




    private String paymentId;
    // 交易金额
    private BigDecimal amount;
    // 名片对应的用户数据
    private String shopUserId;
    // 商品id
    private String shopId;
    // 当前账号用户的id
    private String userId;

}

completeVO接收支付完成的信息

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author ThinkPad
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class CompleteVO {
    // PI支付ID

    private String paymentId;
    // txId

    private String txId;
    // 订单ID【余额支付参数】

    private String orderId;
    // 支付方式：0：PI钱包 1：余额支付

    private String payType;
}

incompleteVO接收未完成订单的信息

/**
 * @author ThinkPad
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class IncompleteVO {

    private String identifier;


    private TransactionVO transaction;
}
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author ThinkPad
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class TransactionVO {


    private String txid;


    private String _link;
}

工具类

发起http请求工具类

import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.ParseException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;


/**
 * @author Ashy.Cheung
 * @http 请求工具类
 * @date 2017.11.10
 */
public class HttpClientUtil {

    public static String sendGet(String url) {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        HttpGet httpget = new HttpGet(url);
        CloseableHttpResponse response = null;
        try {
            response = httpclient.execute(httpget);
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        String result = null;
        try {
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                result = EntityUtils.toString(entity);
            }
        } catch (ParseException | IOException e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    /**
     *
     * @param url
     * @param charsetName 返回字符集
     * @return
     */
    public static String sendGet(String url, String charsetName) {
        InputStream inputStream = null;
        HttpURLConnection urlConnection = null;

        try {
            URL url1 = new URL(url);
            urlConnection = (HttpURLConnection) url1.openConnection();
            // 将返回的输入流转换成字符串
            inputStream = urlConnection.getInputStream();
            // 指定编码格式
            if (StringUtils.isBlank(charsetName)) {
                charsetName = "UTF-8";
            }
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream, charsetName);
            BufferedReader in = new BufferedReader(inputStreamReader);
            String jsonUserStr = in.readLine();
            return jsonUserStr;
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (null != inputStream) {
                    inputStream.close();
                }
                urlConnection.disconnect();
            } catch (Exception e) {

            }
            try {
                if (null != urlConnection) {
                    urlConnection.disconnect();
                }

            } catch (Exception e) {

            }
        }

    }
    /**
     * 发送HttpPost请求，参数为String
     * 接收端以流形式接收
     */
    public static String sendPost(String url, String param) {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        StringEntity strEntity = null;
        try {
            strEntity = new StringEntity(param, "UTF-8");
            strEntity.setContentType("application/json");
        } catch (Exception e1) {

            e1.printStackTrace();
        }
        HttpPost httppost = new HttpPost(url);
        httppost.setEntity(strEntity);
        CloseableHttpResponse response = null;
        String result = null;
        try {
            response = httpclient.execute(httppost);
            HttpEntity entity1 = response.getEntity();
            result = EntityUtils.toString(entity1);

        } catch (IOException e) {
            //  e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (Exception e) {

            }
        }

        return result;
    }

    /**
     * 发送不带参数的HttpPost请求
     */
    public static String sendPost(String url) {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        HttpPost httppost = new HttpPost(url);
        CloseableHttpResponse response = null;
        try {
            response = httpclient.execute(httppost);
        } catch (IOException e) {
            e.printStackTrace();
        }
        HttpEntity entity = response.getEntity();
        String result = null;
        try {
            result = EntityUtils.toString(entity);
        } catch (ParseException | IOException e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (Exception e) {

            }
        }
        return result;
    }

}

 分布式锁工具类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.nio.charset.StandardCharsets;
@Component
public class RedisLockUtil {

    private static final Logger log = LoggerFactory.getLogger(RedisLockUtil.class);

    @Resource
     RedisTemplate<String, Object> redisTemplate;



    /**
     * 释放锁脚本，原子操作，lua脚本
     */
    private static final String UNLOCK_LUA;

    static {
        StringBuilder sb = new StringBuilder();
        sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
        sb.append("then ");
        sb.append("    return redis.call(\"del\",KEYS[1]) ");
        sb.append("else ");
        sb.append("    return 0 ");
        sb.append("end ");
        UNLOCK_LUA = sb.toString();

    }

    /**
     * 获取分布式锁，原子操作
     *
     * @param lockKey   锁
     * @param lockValue 唯一ID
     * @param leaseTime 过期时间 秒
     * @return 是否枷锁成功
     */
    public  boolean tryLock(String lockKey, String lockValue, long leaseTime) {
        try {
            RedisCallback<Boolean> callback = (connection) -> connection.set(lockKey.getBytes(StandardCharsets.UTF_8),
                    lockValue.getBytes(StandardCharsets.UTF_8), Expiration.seconds(leaseTime),
                    RedisStringCommands.SetOption.SET_IF_ABSENT);
            return redisTemplate.execute(callback);
        } catch (Exception e) {
            log.error("redis lock error ,lock key: {}, value : {}, error info : {}", lockKey, lockValue, e);
        }
        return false;
    }

    /**
     * 释放锁
     *
     * @param lockKey   锁
     * @param lockValue 唯一ID
     * @return 执行结果
     */
    public  boolean unlock(String lockKey, String lockValue) {
        RedisCallback<Boolean> callback = (connection) -> connection.eval(UNLOCK_LUA.getBytes(), ReturnType.BOOLEAN, 1, lockKey.getBytes(StandardCharsets.UTF_8), lockValue.getBytes(StandardCharsets.UTF_8));
        return redisTemplate.execute(callback);
    }

    /**
     * 获取分布式锁，该方法不再使用
     *
     * @param lockKey   锁
     * @param lockValue 唯一ID
     * @param waitTime  等待时间 秒
     * @param leaseTime 过期时间 秒
     * @return 是否枷锁成功
     */
    @Deprecated
    public   boolean tryLock(String lockKey, String lockValue, long waitTime, long leaseTime) {
        try {
            RedisCallback<Boolean> callback = (connection) -> connection.set(lockKey.getBytes(StandardCharsets.UTF_8),
                    lockValue.getBytes(StandardCharsets.UTF_8), Expiration.seconds(leaseTime),
                    RedisStringCommands.SetOption.SET_IF_ABSENT);
            return redisTemplate.execute(callback);
        } catch (Exception e) {
            log.error("redis lock error ,lock key: {}, value : {}, error info : {}", lockKey, lockValue, e);
        }
        return false;
    }
}

生成uuid工具类

import java.text.SimpleDateFormat;
import java.util.Date;

public class UUID {

    public static String randomUUID() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd'T'HH'H'mm'M'ss'S'SSS");
        String id = sdf.format(new Date()) + (int) ((Math.random() * 9 + 1) * 100000000) + (int) ((Math.random() * 9 + 1) * 10);
        return id;
    }

    public static String randomQr() {
        String id = (int) ((Math.random() * 9 + 1) * 1000) + "-" + (int) ((Math.random() * 9 + 1) * 1000) + "-" + (int) ((Math.random() * 9 + 1) * 1000);
        return id;
    }

}

信息返回的枚举

import lombok.AllArgsConstructor;

import lombok.Getter;

/**
 * @author ThinkPad
 */

@Getter
@AllArgsConstructor
public enum PaymentEnum {
    PAYMENT_ENUM_1(1, "订单不存在","失败"),
    PAYMENT_ENUM_2(2,"订单不是待支付状态","失败"),
    PAYMENT_ENUM_3(3,"支付金额少于订单金额","失败"),
    PAYMENT_ENUM_4(4,"调用太快","失败"),
    PAYMENT_ENUM_5(5,"余额不足,请前往充值","失败"),
    PAYMENT_ENUM_6(6,"支付成功","成功"),
    PAYMENT_ENUM_7(7,"处理成功","失败"),
    PAYMENT_ENUM_8(8,"处理失败","失败");
    private final Integer code;
    private final String msg;
    private final String status;

    public static String getMsgByCode(Integer code) {
        for (PaymentEnum value : PaymentEnum.values()) {
            if (value.getCode().equals(code)) {
                return value.getMsg();
            }
        }
        return null;
    }

    public static String getStatusByCode(Integer code) {
        for (PaymentEnum value : PaymentEnum.values()) {
            if (value.getCode().equals(code)) {
                return value.getStatus() ;
            }
        }
        return null;
    }


}

支付的controller层

 /**
     * 处理未完成的订单 （这部十分重要，会影响到后面的操作）
     */
    @PostMapping("payOrder/incomplete")
    @ApiOperation("处理未完成的订单")
    @ApiImplicitParam(name = "Authorization", value = "传入你的令牌",required = true, dataType = "String",paramType="header")
    public ResponseVO incomplete(@RequestBody IncompleteVO incompleteVO) {

        try {

            return orderInfoService.incomplete(incompleteVO);
        } catch (Exception e) {
            log.error("报错如下：{}", e.getMessage());
            throw new BusinessException("支付失败，请联系后台人员"+e.getLocalizedMessage()+e.toString()+e.getCause().toString());
        }

    }

    /**
     * 前端请求支付授权,在本地订单创建后调
     */
    @PostMapping("payOrder/approve")
    @ApiOperation("前端请求支付授权,在本地订单创建后调")
    @ApiImplicitParam(name = "Authorization", value = "传入你的令牌",required = true, dataType = "String",paramType="header")
    public ResponseVO<String> approve(@RequestBody PaymentVO paymentVO) {

        try {

            String orderId = orderInfoService.approve(paymentVO);

            return ResponseVO.getSuccessResponseVo(orderId);
        } catch (Exception e) {
            log.error("报错如下：{}", e.getMessage());
            throw new BusinessException("支付失败，请联系后台人员"+e.getLocalizedMessage()+e.toString()+e.getCause().toString());
        }

    }


    /**
     * 前端支付完成,余额支付直接调用此方法
     */
    @PostMapping("payOrder/complete")
    @ApiOperation("前端支付完成,余额支付直接调用此方法")
    @ApiImplicitParam(name = "Authorization", value = "传入你的令牌",required = true, dataType = "String",paramType="header")
    public ResponseVO complete(@RequestBody CompleteVO completeVO) {

        try {


            return orderInfoService.complete(completeVO);
        } catch (Exception e) {
            log.error("报错如下：{}", e.getMessage());
            throw new BusinessException("支付失败，请联系后台人员"+e.getLocalizedMessage()+e.toString()+e.getCause().toString());
        }

    }

    /**
     * 取消支付,订单关闭
     */
    @PostMapping("payOrder/cancelled")
    @ApiOperation("取消支付,订单关闭")
    @ApiImplicitParam(name = "Authorization", value = "传入你的令牌",required = true, dataType = "String",paramType="header")
    public ResponseVO<String> cancelled(@RequestBody String orderId) {

        try {

            Boolean order = orderInfoService.cancelled(orderId);
//            if (!order){throw  new BusinessException("取消订单失败");}
            return ResponseVO.getSuccessResponseVo("取消订单成功");
        } catch (Exception e) {
            log.error("报错如下：{}", e.getMessage());
            throw new BusinessException("取消失败，请联系后台人员"+e.getLocalizedMessage()+e.toString()+e.getCause().toString());
        }

    }

支付的service层

    /**
     * 请求支付授权，创建order。返回orderId
     * @param paymentVO
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String approve(PaymentVO paymentVO) {
        log.error("approve-------------------------------------------------------------");
        OrderInfo orderInfo;
        log.error("paymentVO----------------------------------"+paymentVO);
        //获取付款信息
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("https://api.minepi.com/v2/payments/" + paymentVO.getPaymentId())
                .addHeader("Authorization", "Key " + commonConfig.getServerAccessKey())
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                String string = response.body().string();
                JSONObject jsonObject1 = JSON.parseObject(string);
                log.error("!response-------------------------------------------------------------"+commonConfig.getServerAccessKey());
                throw new RuntimeException("payments error " + jsonObject1.getString("error_message"));
            }
            String string = response.body().string();
            log.error("response-------------------------------------------------------------"+string);

            JSONObject jsonObject1 = JSON.parseObject(string);
            //校验实际支付金额
            BigDecimal userFinalPrice = paymentVO.getAmount();


            if (userFinalPrice.compareTo(jsonObject1.getBigDecimal("amount")) < 0) {
                log.error(userFinalPrice+"response-------------------------------------------------------------"+jsonObject1.getBigDecimal("amount"));
                throw new RuntimeException("支付金额少于订单金额");
            }


        } catch (Exception e) {
            throw  new BusinessException("支付失败，请联系后台人员"+e.getLocalizedMessage()+e.toString()+e.getCause().toString());
        }


        OkHttpClient client1 = new OkHttpClient();
        //信息真实，通知PI我准备好了，可以付款了
        Request request1 = new Request.Builder()
                .url("https://api.minepi.com/v2/payments/" + paymentVO.getPaymentId() + "/approve")
                .addHeader("Content-Type", "application/json")
                .addHeader("Access-Control-Allow-Origin", "*")
                .addHeader("Authorization", "Key " + commonConfig.getServerAccessKey())
                .post(RequestBody.create("", MediaType.parse("application/json")))
                .build();
        try (Response response1 = client1.newCall(request1).execute()) {
            if (!response1.isSuccessful()) {
                throw new RuntimeException("approve error: ");
            }
            log.error("response1-------------------------------------------------------------");

            //更新支付报文
//                    tMerStoreGoodsOrderEntity.setPayOrderId(paymentDto.getPaymentId());
//                    tMerStoreGoodsOrderEntity.setPayStatusType("10007002");//支付中
//                    itMerStoreGoodsOrderService.updateById(tMerStoreGoodsOrderEntity);
            log.error("return-------------------------------------------------------------");
        } catch (RuntimeException | IOException e) {
            log.error("error-------------------------------------------------------------");
            e.printStackTrace();
        }
        // 生成订单
        orderInfo = new OrderInfo();
        orderInfo.setOrderId(StringUtil.generateShortId());
        orderInfo.setShopId(paymentVO.getShopId());
        orderInfo.setUserId(paymentVO.getUserId());
        orderInfo.setShopUserId(paymentVO.getShopUserId());
        orderInfo.setAmount(paymentVO.getAmount());
        orderInfoMapper.insert(orderInfo);
        log.error("生成订单-------------------------------------------------------------");
        return orderInfo.getOrderId();
    }
    /**
     * 前端支付完成,余额支付直接调用此方法
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseVO complete(CompleteVO completeVO) {
        String payType = completeVO.getPayType();
        log.error("complete------------------------------------------------------------"+completeVO);
        if ("1".equals(payType)) {
            //余额支付
            String orderId = completeVO.getOrderId();
            String lockName = "access:lock:complete:" + orderId;
            String lockId = UUID.randomUUID();
            if (!redisLockUtil.tryLock(lockName, lockId, 20L)) {
                // 调用太快
                return new ResponseVO(PaymentEnum.getStatusByCode(4),4,PaymentEnum.getMsgByCode(4));
            }
            // 获取订单信息
            OrderInfo orderInfo = orderInfoMapper.selectOne(new QueryWrapper<OrderInfo>().eq("order_id", orderId));

            if ((orderInfo.getOrderStatus() != 0)) {
                // 订单不是待支付状态
                return new ResponseVO(PaymentEnum.getStatusByCode(2),2,PaymentEnum.getMsgByCode(2));
            }
            String userId = orderInfo.getUserId();
            AccountInfo accountInfo = accountInfoMapper.selectOne(new QueryWrapper<AccountInfo>()
                                                                        .eq("user_id", userId));

            BigDecimal balance = accountInfo.getPiBalance();
            if (balance.compareTo(orderInfo.getAmount()) < 0) {
                // 余额不足，请前往充值
                return new ResponseVO(PaymentEnum.getStatusByCode(5),5,PaymentEnum.getMsgByCode(5));
            }
            int update = orderInfoMapper.update(null,new UpdateWrapper<OrderInfo>()
                                                                .eq("order_id",orderId)
                                                                .set("order_status",1));
            balance=balance.subtract(orderInfo.getAmount());
            int update1 = accountInfoMapper.update(null, new UpdateWrapper<AccountInfo>()
                                                                    .eq("user_id", userId)
                                                                    .set("pi_balance", balance));
            // 支付成功
            return new ResponseVO(PaymentEnum.getStatusByCode(6),6,PaymentEnum.getMsgByCode(6));
        }
        //PI钱包支付
        String paymentId = completeVO.getPaymentId();//PI订单号
        String lockName = "access:lock:complete:" + paymentId;
        String lockId = UUID.randomUUID();
        log.error(paymentId+"-----------------"+lockName+"---------------------"+lockId);
        if (!redisLockUtil.tryLock(lockName, lockId, 20L)) {
            // 调用太快
            log.error("!RedisLockUtil---------------------------------------------------------调用太快");
            return new ResponseVO(PaymentEnum.getStatusByCode(4),4,PaymentEnum.getMsgByCode(4));
        }
        OrderInfo orderInfo = orderInfoMapper.selectOne(new QueryWrapper<OrderInfo>()
                                                            .eq("order_id", completeVO.getOrderId()));
        log.error("orderId--------------------------------------------------------------"+orderInfo);
        if (null == orderInfo) {
            // 订单不存在
            log.error("!orderinfo--------------------------------------------------------不存在");
            return new ResponseVO(PaymentEnum.getStatusByCode(1),1,PaymentEnum.getMsgByCode(1));
        }
        log.error("orderinfo------------------------------------------------------------------"+orderInfo);
        if (orderInfo.getOrderStatus() != 0) {
            // 订单不是待支付状态
            log.error("!order---------------------------------------------------------pay");
            return  new ResponseVO(PaymentEnum.getStatusByCode(2),2,PaymentEnum.getMsgByCode(2));
        }


        //通知PI完成交易
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("txid", completeVO.getTxId());

        Map<String, String> heads = new HashMap<>();
        heads.put("Content-Type", "application/json;charset=UTF-8");
        heads.put("Authorization", "Key " + commonConfig.getServerAccessKey());
        log.error("pi-----------------------------------------"+jsonObject);
        try {
            HttpResponse response = HttpRequest.post("https://api.minepi.com/v2/payments/" + paymentId + "/complete")
                    .headerMap(heads, false)
                    .body(String.valueOf(jsonObject))
                    .timeout(5 * 60 * 1000)
                    .execute();
            String body = response.body();
            JSONObject jsonObject1 = JSON.parseObject(body);
            String error = jsonObject1.getString("error");
            if (!StringUtils.isEmpty(error)) {
                log.error("!strinutils-----------------------------"+body);
                throw new RuntimeException("订单完成异常!");
            }
            orderInfo.setOrderStatus(1);
            // 更新订单
            orderInfoMapper.updateById(orderInfo);
            log.error("支付成功------------------------------------------------------");
            // 支付成功
            return  new ResponseVO(PaymentEnum.getStatusByCode(6),6,PaymentEnum.getMsgByCode(6));
        } catch (Exception e) {
            throw e;
        }

    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean cancelled(String orderId) {
        int update = orderInfoMapper.update(null, new UpdateWrapper<OrderInfo>()
                                                        .eq("order_id", orderId)
                                                        .set("order_status", 3));
        return update > 0;
    }

    @Override
    public ResponseVO incomplete(IncompleteVO incompleteVO) {
        log.error("incomplete--------------------------------");
        try {
            //先处理未完成的订单
            String oldpaymentId = incompleteVO.getIdentifier();
            TransactionVO transaction = incompleteVO.getTransaction();
            log.error("?transation--------------------"+transaction);
            log.error("?oldpaymentId------------------"+oldpaymentId);
            if (null != transaction) {
                log.error("transation--------------------"+transaction);
                log.error("oldpaymentId------------------"+oldpaymentId);
                String txid = transaction.getTxid();
                String txURL = transaction.get_link();

//                OrderInfo orderInfo = orderInfoMapper.selectOne(new QueryWrapper<OrderInfo>().eq("order_id", oldpaymentId));
//                if (null == orderInfo) {
//                    log.error("order-----------------null");
//                    throw new RuntimeException("旧订单不存在");
//                }
//
//                if (orderInfo.getOrderStatus()==1) {
//                    log.error("orderStatus---------------------"+orderInfo.getOrderStatus());
//                    throw new RuntimeException("订单是已支付状态");
//                }

                String get = HttpClientUtil.sendGet(txURL);
                JSONObject jsonObject1 = JSON.parseObject(get);
                String piOrderId = jsonObject1.getString("memo");//我方订单ID

                log.error("memo---------------------"+piOrderId);

                JSONObject jsonObject = new JSONObject();
                jsonObject.put("txid", txid);

                Map<String, String> heads = new HashMap<>();
                heads.put("Content-Type", "application/json;charset=UTF-8");
                heads.put("Authorization", "Key " + commonConfig.getServerAccessKey());

                try {
                    HttpResponse response = HttpRequest.post("https://api.minepi.com/v2/payments/" + piOrderId + "/complete")
                            .headerMap(heads, false)
                            .body(String.valueOf(jsonObject))
                            .timeout(5 * 60 * 1000)
                            .execute();
                    String body = response.body();
                    JSONObject jsonObject2 = JSON.parseObject(body);
                    String error = jsonObject2.getString("error");
                    if (!StringUtils.isEmpty(error)) {
                        log.error("!response------------------"+error);
                        throw new RuntimeException("订单完成异常!");
                    }

                    return new ResponseVO(PaymentEnum.getStatusByCode(7),7,PaymentEnum.getMsgByCode(7));
                } catch (Exception e) {
                    throw e;
                }
            }
        } catch (Exception e) {
            return new ResponseVO(PaymentEnum.getStatusByCode(8),8,PaymentEnum.getMsgByCode(8));
        }
        return new ResponseVO(PaymentEnum.getStatusByCode(8),8,PaymentEnum.getMsgByCode(8));
    }

 前端代码

前端路由 

API
// 授权
import request from "@/api/http";
import axios from "axios";

// 支付授权
export function payAuth(data){
  return request({
    url: "/api/order/payOrder/approve",
    method: "post",
    data,
  });
}

//未完成订单
export function payIncomplete(data){
  return request({
    url: "/api/order/payOrder/incomplete",
    method: "post",
    data,
  });
}

//支付成功
export function payDone(data){
  return request({
    url: "/api/order/payOrder/complete",
    method: "post",
    data,
  });
}
//支付取消
export function payCancel(data){
  return request({
    url: "/api/order/payOrder/cancelled",
    method: "post",
    data,
  })
}

支付前端代码

 test(){
      const pay_message = this.pay_message
      let orderid = ''
      console.log({
        amount: pay_message.amount,
        shopUserId: pay_message.shopUserId,
        shopId: pay_message.shopId,
        userId: pay_message.userId
      })
      Pi.createPayment({
        // Amount of π to be paid:
        amount: 3.14,
        // An explanation of the payment - will be shown to the user:
        memo: "购买特殊数据", // e.g: "Digital kitten #1234",
        // An arbitrary developer-provided metadata object - for your own usage:
        metadata: { productID : 'apple_pie_1'  }, // e.g: { kittenId: 1234 }
      }, {
        // Callbacks you need to implement - read more about those in the detailed docs linked below:

        // 授权
        async onReadyForServerApproval(paymentId) {
          console.log('paymentId',paymentId)
          payAuth({
            paymentId: paymentId,
            amount: pay_message.amount,
            shopUserId: pay_message.shopUserId,
            shopId: pay_message.shopId,
            userId: pay_message.userId
          }).then((data) => {
            orderid = data.data
            console.log('orderId',orderid)
          }).catch(error => {
            console.log(error)
          })
        },
        //支付成功
        onReadyForServerCompletion: function(paymentId, txid) {
          alert(1111)
          console.log(paymentId, 'paymentId', 'txid', txid,'orderid',orderid )
          payDone({paymentId: paymentId, txId: txid, orderId: orderid,payType:'0'}).then(res => {
            console.log(res)
            // if (res && res.code === 0) {
            //   this.payDoneJump();
            // }
          })
        },
        //支付取消
        onCancel: function(orderid) {
          console.log('onCancel' + orderid)
            payCancel(orderid).then((data) => {
              console.log(data)
            })
        },
        //支付失败
        onError: function(error, payment) {console.log('error:',error);console.log('payment:',payment)}
      });
    },

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

const loginFun = () => {
  Pi.init({ version: "2.0", sandbox: true });

  const scopes = ["payments", "username", "wallet_address"];

  function onIncompletePaymentFound(payment) {
    alert(1111111)
    console.log("payment", payment);
    return payIncomplete({
      identifier:payment.identifier,
      transaction:{
        _link:payment.transaction._link,
        txid:res.transaction.txid
      }
    })
  }
  Pi.authenticate(scopes, onIncompletePaymentFound).then(function (auth) {
      console.log("auth", auth);
      let userInfo = {
        accessToken: auth.accessToken,
        userId: auth.user.uid,
        userName: auth.user.username,
      };

      // userGetPush().then((data) => {
      //   console.log(data);
      //   userStore().userGetPush = data.data;
      // });

      Login(userInfo).then((data) => {
        console.log(data);

        if (data.status == "success") {
          // 将用户信息存入pinia
          userStore().userInfoChange(data.data);

          // 发布消息到socket Login() 存入userId
          // this.$socket.emit("login", data.data.userInfo.userId);

          router.push("/home");
        }
      });
    })
    .catch(function (error) {
      console.error(error);
    });
};

详细流程

使用Pi-SDK功能发起支付

springboot整合pi支付开发,pi开发,spring boot,后端,java

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

 springboot整合pi支付开发,pi开发,spring boot,后端,java

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

springboot整合pi支付开发,pi开发,spring boot,后端,java

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

 @Override
    @Transactional(rollbackFor = Exception.class)
    public String approve(PaymentVO paymentVO) {
        log.error("approve-------------------------------------------------------------");
        OrderInfo orderInfo;
        log.error("paymentVO----------------------------------"+paymentVO);
        //获取付款信息
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("https://api.minepi.com/v2/payments/" + paymentVO.getPaymentId())
                .addHeader("Authorization", "Key " + commonConfig.getServerAccessKey())
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                String string = response.body().string();
                JSONObject jsonObject1 = JSON.parseObject(string);
                log.error("!response-------------------------------------------------------------"+commonConfig.getServerAccessKey());
                throw new RuntimeException("payments error " + jsonObject1.getString("error_message"));
            }
            String string = response.body().string();
            log.error("response-------------------------------------------------------------"+string);

            JSONObject jsonObject1 = JSON.parseObject(string);
            //校验实际支付金额
            BigDecimal userFinalPrice = paymentVO.getAmount();


            if (userFinalPrice.compareTo(jsonObject1.getBigDecimal("amount")) < 0) {
                log.error(userFinalPrice+"response-------------------------------------------------------------"+jsonObject1.getBigDecimal("amount"));
                throw new RuntimeException("支付金额少于订单金额");
            }


        } catch (Exception e) {
            throw  new BusinessException("支付失败，请联系后台人员"+e.getLocalizedMessage()+e.toString()+e.getCause().toString());
        }


        OkHttpClient client1 = new OkHttpClient();
        //信息真实，通知PI我准备好了，可以付款了
        Request request1 = new Request.Builder()
                .url("https://api.minepi.com/v2/payments/" + paymentVO.getPaymentId() + "/approve")
                .addHeader("Content-Type", "application/json")
                .addHeader("Access-Control-Allow-Origin", "*")
                .addHeader("Authorization", "Key " + commonConfig.getServerAccessKey())
                .post(RequestBody.create("", MediaType.parse("application/json")))
                .build();
        try (Response response1 = client1.newCall(request1).execute()) {
            if (!response1.isSuccessful()) {
                throw new RuntimeException("approve error: ");
            }
            log.error("response1-------------------------------------------------------------");

            //更新支付报文
//                    tMerStoreGoodsOrderEntity.setPayOrderId(paymentDto.getPaymentId());
//                    tMerStoreGoodsOrderEntity.setPayStatusType("10007002");//支付中
//                    itMerStoreGoodsOrderService.updateById(tMerStoreGoodsOrderEntity);
            log.error("return-------------------------------------------------------------");
        } catch (RuntimeException | IOException e) {
            log.error("error-------------------------------------------------------------");
            e.printStackTrace();
        }
        // 生成订单
        orderInfo = new OrderInfo();
        orderInfo.setOrderId(StringUtil.generateShortId());
        orderInfo.setShopId(paymentVO.getShopId());
        orderInfo.setUserId(paymentVO.getUserId());
        orderInfo.setShopUserId(paymentVO.getShopUserId());
        orderInfo.setAmount(paymentVO.getAmount());
        orderInfoMapper.insert(orderInfo);
        log.error("生成订单-------------------------------------------------------------");
        return orderInfo.getOrderId();
    }

PI游览器向用户显示付款详细信息页面，我们等待用户签署交易springboot整合pi支付开发,pi开发,spring boot,后端,java

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

springboot整合pi支付开发,pi开发,spring boot,后端,java

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

 /**
     * 前端支付完成,余额支付直接调用此方法
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseVO complete(CompleteVO completeVO) {
        String payType = completeVO.getPayType();
        log.error("complete------------------------------------------------------------"+completeVO);
        if ("1".equals(payType)) {
            //余额支付
            String orderId = completeVO.getOrderId();
            String lockName = "access:lock:complete:" + orderId;
            String lockId = UUID.randomUUID();
            if (!redisLockUtil.tryLock(lockName, lockId, 20L)) {
                // 调用太快
                return new ResponseVO(PaymentEnum.getStatusByCode(4),4,PaymentEnum.getMsgByCode(4));
            }
            // 获取订单信息
            OrderInfo orderInfo = orderInfoMapper.selectOne(new QueryWrapper<OrderInfo>().eq("order_id", orderId));

            if ((orderInfo.getOrderStatus() != 0)) {
                // 订单不是待支付状态
                return new ResponseVO(PaymentEnum.getStatusByCode(2),2,PaymentEnum.getMsgByCode(2));
            }
            String userId = orderInfo.getUserId();
            AccountInfo accountInfo = accountInfoMapper.selectOne(new QueryWrapper<AccountInfo>()
                                                                        .eq("user_id", userId));

            BigDecimal balance = accountInfo.getPiBalance();
            if (balance.compareTo(orderInfo.getAmount()) < 0) {
                // 余额不足，请前往充值
                return new ResponseVO(PaymentEnum.getStatusByCode(5),5,PaymentEnum.getMsgByCode(5));
            }
            int update = orderInfoMapper.update(null,new UpdateWrapper<OrderInfo>()
                                                                .eq("order_id",orderId)
                                                                .set("order_status",1));
            balance=balance.subtract(orderInfo.getAmount());
            int update1 = accountInfoMapper.update(null, new UpdateWrapper<AccountInfo>()
                                                                    .eq("user_id", userId)
                                                                    .set("pi_balance", balance));
            // 支付成功
            return new ResponseVO(PaymentEnum.getStatusByCode(6),6,PaymentEnum.getMsgByCode(6));
        }
        //PI钱包支付
        String paymentId = completeVO.getPaymentId();//PI订单号
        String lockName = "access:lock:complete:" + paymentId;
        String lockId = UUID.randomUUID();
        log.error(paymentId+"-----------------"+lockName+"---------------------"+lockId);
        if (!redisLockUtil.tryLock(lockName, lockId, 20L)) {
            // 调用太快
            log.error("!RedisLockUtil---------------------------------------------------------调用太快");
            return new ResponseVO(PaymentEnum.getStatusByCode(4),4,PaymentEnum.getMsgByCode(4));
        }
        OrderInfo orderInfo = orderInfoMapper.selectOne(new QueryWrapper<OrderInfo>()
                                                            .eq("order_id", completeVO.getOrderId()));
        log.error("orderId--------------------------------------------------------------"+orderInfo);
        if (null == orderInfo) {
            // 订单不存在
            log.error("!orderinfo--------------------------------------------------------不存在");
            return new ResponseVO(PaymentEnum.getStatusByCode(1),1,PaymentEnum.getMsgByCode(1));
        }
        log.error("orderinfo------------------------------------------------------------------"+orderInfo);
        if (orderInfo.getOrderStatus() != 0) {
            // 订单不是待支付状态
            log.error("!order---------------------------------------------------------pay");
            return  new ResponseVO(PaymentEnum.getStatusByCode(2),2,PaymentEnum.getMsgByCode(2));
        }


        //通知PI完成交易
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("txid", completeVO.getTxId());

        Map<String, String> heads = new HashMap<>();
        heads.put("Content-Type", "application/json;charset=UTF-8");
        heads.put("Authorization", "Key " + commonConfig.getServerAccessKey());
        log.error("pi-----------------------------------------"+jsonObject);
        try {
            HttpResponse response = HttpRequest.post("https://api.minepi.com/v2/payments/" + paymentId + "/complete")
                    .headerMap(heads, false)
                    .body(String.valueOf(jsonObject))
                    .timeout(5 * 60 * 1000)
                    .execute();
            String body = response.body();
            JSONObject jsonObject1 = JSON.parseObject(body);
            String error = jsonObject1.getString("error");
            if (!StringUtils.isEmpty(error)) {
                log.error("!strinutils-----------------------------"+body);
                throw new RuntimeException("订单完成异常!");
            }
            orderInfo.setOrderStatus(1);
            // 更新订单
            orderInfoMapper.updateById(orderInfo);
            log.error("支付成功------------------------------------------------------");
            // 支付成功
            return  new ResponseVO(PaymentEnum.getStatusByCode(6),6,PaymentEnum.getMsgByCode(6));
        } catch (Exception e) {
            throw e;
        }

    }

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

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

springboot整合pi支付开发,pi开发,spring boot,后端,java

路由到后端的接口 

 springboot整合pi支付开发,pi开发,spring boot,后端,java

 后端接口代码文章来源地址https://www.toymoban.com/news/detail-728220.html

@Override
    public ResponseVO incomplete(IncompleteVO incompleteVO) {
        log.error("incomplete--------------------------------");
        try {
            //先处理未完成的订单
            String oldpaymentId = incompleteVO.getIdentifier();
            TransactionVO transaction = incompleteVO.getTransaction();
            log.error("?transation--------------------"+transaction);
            log.error("?oldpaymentId------------------"+oldpaymentId);
            if (null != transaction) {
                log.error("transation--------------------"+transaction);
                log.error("oldpaymentId------------------"+oldpaymentId);
                String txid = transaction.getTxid();
                String txURL = transaction.get_link();

//                OrderInfo orderInfo = orderInfoMapper.selectOne(new QueryWrapper<OrderInfo>().eq("order_id", oldpaymentId));
//                if (null == orderInfo) {
//                    log.error("order-----------------null");
//                    throw new RuntimeException("旧订单不存在");
//                }
//
//                if (orderInfo.getOrderStatus()==1) {
//                    log.error("orderStatus---------------------"+orderInfo.getOrderStatus());
//                    throw new RuntimeException("订单是已支付状态");
//                }

                String get = HttpClientUtil.sendGet(txURL);
                JSONObject jsonObject1 = JSON.parseObject(get);
                String piOrderId = jsonObject1.getString("memo");//我方订单ID

                log.error("memo---------------------"+piOrderId);

                JSONObject jsonObject = new JSONObject();
                jsonObject.put("txid", txid);

                Map<String, String> heads = new HashMap<>();
                heads.put("Content-Type", "application/json;charset=UTF-8");
                heads.put("Authorization", "Key " + commonConfig.getServerAccessKey());

                try {
                    HttpResponse response = HttpRequest.post("https://api.minepi.com/v2/payments/" + piOrderId + "/complete")
                            .headerMap(heads, false)
                            .body(String.valueOf(jsonObject))
                            .timeout(5 * 60 * 1000)
                            .execute();
                    String body = response.body();
                    JSONObject jsonObject2 = JSON.parseObject(body);
                    String error = jsonObject2.getString("error");
                    if (!StringUtils.isEmpty(error)) {
                        log.error("!response------------------"+error);
                        throw new RuntimeException("订单完成异常!");
                    }

                    return new ResponseVO(PaymentEnum.getStatusByCode(7),7,PaymentEnum.getMsgByCode(7));
                } catch (Exception e) {
                    throw e;
                }
            }
        } catch (Exception e) {
            return new ResponseVO(PaymentEnum.getStatusByCode(8),8,PaymentEnum.getMsgByCode(8));
        }
        return new ResponseVO(PaymentEnum.getStatusByCode(8),8,PaymentEnum.getMsgByCode(8));
    }

到了这里，关于springboot整合pi支付开发的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 基于 Spring Boot 支付宝沙箱支付（Java 版本）

    基于 Spring Boot 支付宝沙箱支付（Java 版本）

    打开沙箱地址：https://open.alipay.com/develop/sandbox/app 需要获取 ：AppId、支付宝网关地址、应用私钥、支付宝公钥 注册 https://natapp.cn/ 购买免费隧道 注意：需要记住这个 authtoken，配置文件用得到 配置隧道 文件 config 配置 配置文件需要与 natapp 放在同级目录下 启动 natapp 为什么要

    2024年01月23日
    浏览(39)
  • spring boot整合第三方微信开发工具 weixin-java-miniapp 实现小程序微信登录

    spring boot整合第三方微信开发工具 weixin-java-miniapp 实现小程序微信登录

    有时候项目需要用到微信登录或获取用户的手机号码，weixin-java-miniapp是一个好用的第三方工具，不用我们自己写httpcline调用。 导入jar包 添加一个resource.properties文件，写上小程序的appid和secret 添加两个配置文件 WxMaProperties.java WxMaConfiguration.java 如何使用 小程序给微信发送消息

    2024年02月16日
    浏览(33)

  • Springboot 实践（13）spring boot 整合RabbitMq

    前文讲解了RabbitMQ的下载和安装，此文讲解springboot整合RabbitMq实现消息的发送和消费。 1、创建web project项目，名称为“SpringbootAction-RabbitMQ” 2、修改pom.xml文件，添加amqp使用jar包    !--  RabbitMQ --         dependency             groupIdorg.springframework.boot/groupId         

    2024年02月09日
    浏览(41)

  • 【SpringBoot】Spring Boot 项目中整合 MyBatis 和 PageHelper

    目录 前言         步骤 1: 添加依赖 步骤 2: 配置数据源和 MyBatis 步骤 3: 配置 PageHelper 步骤 4: 使用 PageHelper 进行分页查询 IDEA指定端口启动 总结         Spring Boot 与 MyBatis 的整合是 Java 开发中常见的需求，特别是在使用分页插件如 PageHelper 时。PageHelper 是一个针对 MyBat

    2024年04月25日
    浏览(32)
  • 【Spring Boot】SpringBoot 优雅整合Swagger Api 自动生成文档

    【Spring Boot】SpringBoot 优雅整合Swagger Api 自动生成文档

    Swagger 是一套 RESTful API 文档生成工具，可以方便地生成 API 文档并提供 API 调试页面。 而 Spring Boot 是一款非常优秀的 Java Web 开发框架，它可以非常方便地构建 Web 应用程序。 在本文中，我们将介绍如何使用 Swagger 以及如何在 Spring Boot 中整合 Swagger 。 首先，在 pom.xml 文件中添

    2023年04月22日
    浏览(34)
  • SSMP整合案例(2) Spring Boot整合Lombok简化实体类开发

    SSMP整合案例(2) Spring Boot整合Lombok简化实体类开发

    好啊 接着我们上文SSMP整合案例(1) 构建 Spring Boot Vue MySql项目环境 我们继续 接下来 我们要在java项目中 建立出数据库表对应的实体类 我们还是先看看自己上文中 创建的这个 book表 其中四个字段 主键id 数字枚举类型的type 字符串类型name 字符串类型 description 我们打开idea 找到上

    2024年02月09日
    浏览(37)
  • SpringBoot + Vue前后端分离项目实战 || 三：Spring Boot后端与Vue前端连接

    SpringBoot + Vue前后端分离项目实战 || 三：Spring Boot后端与Vue前端连接

    系列文章： SpringBoot + Vue前后端分离项目实战 || 一：Vue前端设计 SpringBoot + Vue前后端分离项目实战 || 二：Spring Boot后端与数据库连接 SpringBoot + Vue前后端分离项目实战 || 三：Spring Boot后端与Vue前端连接 SpringBoot + Vue前后端分离项目实战 || 四：用户管理功能实现 SpringBoot + Vue前后

    2024年02月12日
    浏览(55)
  • SpringBoot + Vue前后端分离项目实战 || 二：Spring Boot后端与数据库连接

    SpringBoot + Vue前后端分离项目实战 || 二：Spring Boot后端与数据库连接

    系列文章： SpringBoot + Vue前后端分离项目实战 || 一：Vue前端设计 SpringBoot + Vue前后端分离项目实战 || 二：Spring Boot后端与数据库连接 SpringBoot + Vue前后端分离项目实战 || 三：Spring Boot后端与Vue前端连接 SpringBoot + Vue前后端分离项目实战 || 四：用户管理功能实现 SpringBoot + Vue前后

    2024年02月11日
    浏览(50)
  • Spring Boot整合区块链—区块链服务开发实例

    Spring Boot整合区块链—区块链服务开发实例

    本实例主要是将企业信息添加进区块链，然后实现对企业信息进行查询溯源，对区块链有新增、查询、修改、删除、查看历史等功能。 pom.xml 下载: https://yuyunyaohui.lanzoul.com/iwnMXxuxm2f 密码:hk9i 项目下新建一个 lib 目录，将jar包放入 然后再pom.xml文件引入该jar包 方法一：新建con

    2023年04月09日
    浏览(40)
  • Spring Boot：Web开发之视图模板技术的整合

    Spring Boot：Web开发之视图模板技术的整合

    在 Web 开发中， 视图模板技术 （如 JSP 、FreeMarker 、Thymeleaf 等）用于呈现动态内容到用户界面的工具。这些技术允许开发者使用特定的标记和语法来定义页面布局和动态内容插入点，然后由后端框架（如 Spring Boot ）在运行时填充数据并生成最终的 HTML 页面。 JSP ( JavaServer Pa

    2024年04月16日
    浏览(26)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包