stripe国际支付对接

已于 2023-12-04 16:56:48 修改
阅读量495 收藏 1
点赞数 2
文章标签： java 前端
于 2023-11-28 11:51:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46085718/article/details/134663281
版权

 

   <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.10.1</version>
        </dependency>

        <dependency>
            <groupId>com.stripe</groupId>
            <artifactId>stripe-java</artifactId>
            <version>24.0.0</version>
        </dependency>

 

#stripe配置
stripe:
  publicKey: pk_test_51OFTJTIkpJUW1eOYejtK7ZM3YNnSNc1ELk8D4X2wkXYJoKDtU0Ny7uICL2M4zZerGnNOipTSwyVPmxoKhZE0nmS700zFLJUIAi
  apiKey: sk_test_51OFTJTIkpJUW1eOYDq5k2I6jT74Xn1jAymML11dfFbyeTmoVIdCpgSV8QBRnrdMYDBJ4j7m3O00R3a52VpdmsypF00VVSLNYmC
  cancelUrl: http://stripe.fojia21jia.com/#/pages/index/payFail
  successUrl: http://stripe.foji21ajia.com/#/pages/index/paySuccess
  webhookSecret: whsec_fXgFfbSnxd5x7MGwYrpTIU1euO1Od1yc

package com.ruoyi.web.controller.member;



import com.ruoyi.religious.model.CreateOrderEntity;
import com.ruoyi.religious.model.CreateRefundEntity;

import com.ruoyi.religious.service.StripeOrderService;
import com.stripe.Stripe;
import com.stripe.model.*;
import com.stripe.model.checkout.Session;
import com.stripe.param.*;
import com.stripe.param.checkout.SessionCreateParams;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.util.*;

@Slf4j
@RestController
@AllArgsConstructor
@RequestMapping("/stripe")
public class OrderController {
    @Autowired
    private StripeOrderService orderService;

    /**
     * 创建支付会话
     * 1、创建产品
     * 2、设置价格
     * 3、创建支付信息 得到url
     * @return
     */
    @PostMapping("/order/pay")
    public String pay(@Validated @RequestBody CreateOrderEntity createOrderEntity) {
        return orderService.pay(createOrderEntity);
    }

//    /**
//     *  发放退款
//     * @return
//     */
//    @PostMapping("/order/refund")
//    public void refund(@Validated @RequestBody CreateRefundEntity createRefund) {
//        orderService.refund(createRefund);
//    }
}

package com.ruoyi.religious.service;


import com.ruoyi.religious.model.CreateOrderEntity;
import com.ruoyi.religious.model.CreateRefundEntity;

public interface StripeOrderService {
    String pay(CreateOrderEntity createOrderEntity);

    void refund(CreateRefundEntity createRefund);
}


package com.ruoyi.religious.service.impl;


import com.ruoyi.common.enums.OrderStatusEnum;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.religious.domain.ReligiousCultureOrder;
import com.ruoyi.religious.model.CreateOrderEntity;
import com.ruoyi.religious.model.CreateRefundEntity;
import com.ruoyi.religious.result.ApiResult;
import com.ruoyi.religious.service.IReligiousCultureOrderService;
import com.ruoyi.religious.service.StripeOrderService;
import com.ruoyi.system.service.ISysConfigService;
import com.stripe.Stripe;
import com.stripe.model.Price;
import com.stripe.model.Product;
import com.stripe.model.Refund;
import com.stripe.model.checkout.Session;
import com.stripe.param.RefundCreateParams;
import com.stripe.param.checkout.SessionCreateParams;
import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;


import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.HashMap;
import java.util.Map;

@Slf4j
@Service
public class StripeOrderServiceImpl implements StripeOrderService {

    @Value("${stripe.apiKey}")
    private String apiKey;

    @Value("${stripe.cancelUrl}")
    private String cancelUrl;

    @Value("${stripe.successUrl}")
    private String successUrl;

    @Autowired
    private ISysConfigService sysConfigService;

    @Autowired
    private IReligiousCultureOrderService religiousCultureOrderService;

    @Override
    public String pay(CreateOrderEntity createOrderEntity) {
        Stripe.apiKey = apiKey;
        try {
            //创建产品
            Map<String, Object> params = new HashMap<>();
            params.put("name", createOrderEntity.getProductName());
            Product product = Product.create(params);
            ReligiousCultureOrder religiousCultureOrder = religiousCultureOrderService.selectReligiousCultureOrderBySerialNumber(createOrderEntity.getOrderId());
            if (religiousCultureOrder == null || !religiousCultureOrder.getStatus().equals(OrderStatusEnum.ADD_GONGDE_WAIT.getCode())) {
                throw new RuntimeException("订单状态错误！");
            }

            String s = sysConfigService.selectConfigByKey("sys.app.virtues.ratio");
            BigDecimal divide = religiousCultureOrder.getPrice().multiply(new BigDecimal(s)).divide(new BigDecimal(1), 2, RoundingMode.UP);
//            BigDecimal price1 = religiousCultureOrder.getPrice();
            //创建价格
            Map<String, Object> priceParams = new HashMap<>();

            BigDecimal actualAmount = divide.multiply(BigDecimal.valueOf(100));  //stripe的默认单位是分，即传入的amount实际上小数点会被左移两位
            //给price绑定元数据并更新price用于检索
            Map<String, Object> metadata = new HashMap<>();
            metadata.put("orderId", createOrderEntity.getOrderId());
            priceParams.put("metadata", metadata);  //通过订单号关联用于检索price信息（可选）
            priceParams.put("unit_amount", actualAmount.intValue());
            priceParams.put("currency", createOrderEntity.getCurrency());
            priceParams.put("product", product.getId());
            Price price = Price.create(priceParams);

            //创建支付信息得到url
            SessionCreateParams params3 = SessionCreateParams.builder()
                    .setMode(SessionCreateParams.Mode.PAYMENT)
                    .setSuccessUrl(successUrl)  //可自定义成功页面
                    .setCancelUrl(cancelUrl)
                    .addLineItem(
                            SessionCreateParams.LineItem.builder()
                                    .setQuantity(createOrderEntity.getQuantity())
                                    .setPrice(price.getId())
                                    .build()).putMetadata("orderId",createOrderEntity.getOrderId())  //通过订单号关联用于检索支付信息（可选）
                    .build();
            Session session = Session.create(params3);
            System.out.println("sessionId:" +session.getId());
            String sessionId = session.getId();  //退款方式1：拿到sessionId入库，退款的时候根据这个id找到PaymentIntent的id然后发起退款
            return session.getUrl();
        }catch (Exception e){
            log.error("创建支付会话出现异常：",e);
        }
        return "";
    }

    @Override
    public void refund(CreateRefundEntity createRefund) {
        try{
            Stripe.apiKey = apiKey;

            if (StringUtils.isNotEmpty(createRefund.getSessionId())){  //根据会话编号退款
                Session session =
                        Session.retrieve(
                                createRefund.getSessionId()
                        );
                RefundCreateParams params;
                if (createRefund.getAmount() != null && createRefund.getAmount().compareTo(BigDecimal.ZERO) != 0){  //指定退款金额
                    BigDecimal actualAmount = createRefund.getAmount().multiply(BigDecimal.valueOf(100));  //api默认单位分
                    params = RefundCreateParams.builder()
                            .setPaymentIntent(session.getPaymentIntent())
                            .setAmount(actualAmount.longValue())
                            .build();
                }else {  //全额退款
                    params = RefundCreateParams.builder()
                            .setPaymentIntent(session.getPaymentIntent())
                            .build();
                }
                Refund.create(params);
                log.info("根据会话编号退款成功");
                return;
            }
            if (StringUtils.isNotEmpty(createRefund.getChargeId())){  //根据退款编号退款
                Map<String, Object> params = new HashMap<>();
                params.put("charge", createRefund.getChargeId());
                if (createRefund.getAmount() != null && createRefund.getAmount().compareTo(BigDecimal.ZERO) != 0){  //指定退款金额，否则全额退款
                    BigDecimal actualAmount = createRefund.getAmount().multiply(BigDecimal.valueOf(100));  //api默认单位分
                    params.put("amount", actualAmount.longValue());
                }
                Refund.create(params);
                log.info("根据退款编号退款成功");
                return;
            }
        }catch (Exception e){
            //e.getMessage.contain("charge_already_refunded") 已退款
            //e.getMessage.contain("resource_missing") 退款编号错误
            //e.getMessage.contain("amount on charge ($n)") 金额应小于n
            log.error("退款异常：",e);
        }
    }
}


package com.ruoyi.web.controller.member;


import com.ruoyi.religious.service.CallbackService;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Slf4j
@RestController
@AllArgsConstructor
@RequestMapping("/stripe")
public class CallbackController {
    @Autowired
    private CallbackService callbackService;

    @GetMapping("/callback/success")
    public void success(String orderId)  {
        System.out.println("调用success成功：" + orderId);
    }

    @GetMapping("/callback/cancel")
    public void cancel(String orderId)  {
        System.out.println("调用cancel成功：" + orderId);
    }

    /**
     * webhook回调
     * @return 返回处理状态（验签不通过拒绝）
     */
    @PostMapping(value = "/callback/webhook")
    public Object webhook(HttpServletRequest request, HttpServletResponse response){
        return callbackService.webhook(request,response);
    }
}


package com.ruoyi.religious.service;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public interface CallbackService {
    Object webhook(HttpServletRequest request, HttpServletResponse response);
}


package com.ruoyi.religious.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.google.gson.JsonSyntaxException;

import com.ruoyi.common.enums.OrderStatusEnum;
import com.ruoyi.common.enums.OrderTypeEnum;
import com.ruoyi.religious.domain.ReligiousCultureOrder;
import com.ruoyi.religious.service.CallbackService;
import com.ruoyi.religious.service.ClientMemberService;
import com.ruoyi.religious.service.IReligiousCultureOrderService;
import com.stripe.exception.SignatureVerificationException;
import com.stripe.model.*;
import com.stripe.net.ApiResource;
import com.stripe.net.Webhook;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.util.stream.Collectors;

@Slf4j
@Service
public class CallbackServiceImpl implements CallbackService {
    @Value("${stripe.webhookSecret}")
    private String webhookSecret;  //webhookSecret配置在Webhook秘钥签名中

    @Autowired
    private IReligiousCultureOrderService orderService;

    @Autowired
    private ClientMemberService clientMemberService;

    @Override
    public Object webhook(HttpServletRequest request, HttpServletResponse response) {
        System.out.println(request);
        InputStream inputStream = null;
        ByteArrayOutputStream output = null;
        try {
            //获取请求体的参数
            inputStream = request.getInputStream();
            output = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024 * 4];
            int n;
            while (-1 != (n = inputStream.read(buffer))) {
                output.write(buffer, 0, n);
            }
            byte[] bytes = output.toByteArray();
            String eventPayload = new String(bytes, "UTF-8");
            System.out.println("获取请求体的参数：" + eventPayload);
            //获取请求头签名
            String sigHeader = request.getHeader("Stripe-Signature");
            System.out.println("获取请求头的签名：" + sigHeader);
            Event event;

            try {
                event = ApiResource.GSON.fromJson(eventPayload, Event.class);
            } catch (JsonSyntaxException e) {
                // Invalid payload
                response.setStatus(400);
                return "";
            }

            // Deserialize the nested object inside the event
            EventDataObjectDeserializer dataObjectDeserializer = event.getDataObjectDeserializer();
            StripeObject stripeObject = null;
            if (dataObjectDeserializer.getObject().isPresent()) {
                stripeObject = dataObjectDeserializer.getObject().get();
            } else {
                // Deserialization failed, probably due to an API version mismatch.
                // Refer to the Javadoc documentation on `EventDataObjectDeserializer` for
                // instructions on how to handle this case, or return an error here.
            }

//            try {
//                System.out.println("webhookSecret"+webhookSecret);
//                event = Webhook.constructEvent(eventPayload, sigHeader, webhookSecret,5000);  //调用webhook进行验签
//                System.out.println(event);
//            } catch (JsonSyntaxException e) {
//                log.error("参数格式有误，解析失败：", e);
//                System.out.println(-1);
//                response.setStatus(400);
//                return "";
//            } catch (SignatureVerificationException e) {
//                log.error("参数被篡改，验签失败：", e);
//                response.setStatus(400);
//                System.out.println(0);
//                return "";
//            }


            // Handle the event
            switch (event.getType()) {
                case "checkout.session.completed"://支付完成
                    System.out.println("---------------success---------------");
                    String s = event.getDataObjectDeserializer().getObject().get().toJson();
                    JSONObject jsonObject = JSONObject.parseObject(s);
                    JSONObject jsonObject2 = (JSONObject)jsonObject.get("metadata");
                    String orderId = jsonObject2.getString("orderId");
                    System.out.println("支付完成，订单号为："+orderId);
                    ReligiousCultureOrder religiousCultureOrder = orderService.selectReligiousCultureOrderBySerialNumber(orderId);
                    if (religiousCultureOrder.getStatus().equals(OrderStatusEnum.ADD_GONGDE_WAIT.getCode())) {
                        if (religiousCultureOrder.getOrderType().equals(OrderTypeEnum.ADD_GONGDE.getCode())){
                            clientMemberService.addSubscriber(religiousCultureOrder);
                        }else {
                            orderService.alipay(religiousCultureOrder);
                        }
                    }
                    break;
                case "checkout.session.expired": {
                    System.out.println("回话过期");
                    // Then define and call a function to handle the event checkout.session.expired
                    break;
                }
                case "payment_intent.canceled": {
                    System.out.println("订单取消");
                    // Then define and call a function to handle the event payment_intent.canceled
                    break;
                }
                case "charge.succeeded": {
                    System.out.println("charge.succeeded");
                    break;
                }
                case "payment_intent.created": {
                    System.out.println("创建支付了");
                    break;
                }
                case "payment_intent.payment_failed": {
                    System.out.println("支付失败");
                    // Then define and call a function to handle the event payment_intent.payment_failed
                    break;
                }
                case "payment_intent.succeeded": {
                    //支付成功
                    PaymentIntent paymentIntent = (PaymentIntent) stripeObject;
                    System.out.println("支付成功，订单chargeId:" + paymentIntent.getLatestCharge());
                    String chargeId = paymentIntent.getLatestCharge();  //退款方式2：回调保存该退款编号用于退款，
                    System.out.println(chargeId);
                    break;
                }
                // ... handle other event types
                default:
                    System.out.println("Unhandled event type: " + event.getType());
            }
            response.setStatus(200);  //处理无异常，返回
        } catch (Exception e) {
            System.out.println(2);
            log.error("webhook异步通知解析异常：", e);
            response.setStatus(400);
            return "";
        } finally {
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
                if (output != null) {
                    output.close();
                }
            } catch (Exception e) {
                log.error("流关闭异常");
            }
        }
        return "";
    }
}


package com.ruoyi.religious.model;

import lombok.Data;

import javax.validation.constraints.NotEmpty;
import java.math.BigDecimal;

@Data
public class CreateOrderEntity {
    /** 本地订单号 */
//    @NotEmpty(message = "订单编号不允许为空")
    private String orderId;

    /** 商品名称 */
//    @NotEmpty(message = "商品名称不允许为空")
    private String productName;


    /** 货币类型 */
    private String currency;

    /** 购买数量 */
    private long quantity;
}


package com.ruoyi.religious.model;

import lombok.Data;

import java.math.BigDecimal;

@Data
public class CreateRefundEntity {
    /** 退款金额，支持多次退款，sessionId或者chargeId不会更改 */
    private BigDecimal amount;

    /** 会话编号 */
    private String sessionId;

    /** 退款编号 */
    private String chargeId;
}


package com.ruoyi.religious.model;

public class StripeConstant {
    /**
     * pending      刚刚准备好订单;
     * chargeable   Source对象变成chargeable客户已授权和验证的付款后。
     * failed       Source对象未能成为收费为你的客户拒绝授权支付。
     * canceled     Source对象过期，并且不能用于创建电荷。
     * succeeded    收费成功，付款完成。
     * created      发送客户投诉，从Stripe余额中扣除争议金额。
     */


    public static final String PAY_STRIPE_STATUS_PENDING = "pending";
    public static final String PAY_STRIPE_STATUS_CHARGEABLE = "chargeable";
    public static final String PAY_STRIPE_STATUS_FAILED = "failed";
    public static final String PAY_STRIPE_STATUS_CANCELED = "canceled";
    public static final String PAY_STRIPE_STATUS_SUCCEEDED = "succeeded";
    public static final String PAY_STRIPE_STATUS_CREATED = "created";
    //授权完成，但用户余额不足
    public static final String PAY_STRIPE_STATUS_INSUFFICIENT_FUNDS = "insufficient_funds";
    //授权完成，订单收费金额大于支付宝支持的费用
    public static final String PAY_STRIPE_STATUS_INVALID_AMOUNT = "invalid_amount";
    //授权完成，创建收费订单失败
    public static final String PAY_STRIPE_STATUS_CHARGE_ERROR = "charge_error";

    //支付回调状态，支付成功的事件类型
    public static final String PAY_STRIPE_STATUS_CALL_BACK_SUCCESSED = "payment_intent.succeeded";

    //支付回调状态，支付方式附加事件（当前的支付模式不会返回该支付状态）
    public static final String PAY_STRIPE_STATUS_CALL_BACK_ATTACHED = "payment_method.attached";

    //支付回调状态，取消订单
    public static final String PAY_STRIPE_STATUS_CALL_BACK_CANCELED = "payment_method.canceled";

    //支付回调状态，支付失败
    public static final String PAY_STRIPE_STATUS_CALL_BACK_FAILED = "payment_method.payment_failed";
}

 

 

 

 

评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

想买CT5的小曹

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值