抖音小程序支付Demo

抖音小程序支付Demo

application.yml

1
2
3
4
5
6
7
8
9
10
auth:
  douyin:
    app-id: ${dou_app_id}
    secret: ${dou_secret}

pay:
  douyin:
    msg-page: ${dou_msg_page}
    notify-url: ${dou_notify_url}
    order-detail-url: pages/order/index

BytePayConfig

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 字节支付配置类
 * @date 2023/3/31 9:21 PM
 */
@Data
@Configuration
public class BytePayConfig {

    @Value("${auth.douyin.app-id}")
    private String appId;

    @Value("${auth.douyin.secret}")
    private String secret;

    @Value("${pay.douyin.msg-page}")
    private String msgPage;

    @Value("${pay.douyin.notify-url}")
    private String notifyUrl;

    @Value("${pay.douyin.order-detail-url}")
    private String orderDetailUrl;

    /** 获取 access_token 时值为 client_credential */
    private String grantType = "client_credential";

    /** 获取access_token的接口 */
    private String getAccessTokenApi = "https://developer.toutiao.com/api/apps/v2/token";

    private String token = "dlkahghnlakjytdjdy556nfakhdgk";

    private String SALT = "QmdU86FRk6sL30O5Yn66hFG507BgV9MU10yoYqLq";

    /** app_id 维度限流 150QPS，thirdparty_id 维度限流 150QPS */
    private String createOrderUrl = "https://developer.toutiao.com/api/apps/ecpay/v1/create_order";

    private String queryOrderUrl = "https://developer.toutiao.com/api/apps/ecpay/v1/query_order";

    // 退款
    private String refundUrl = "https://developer.toutiao.com/api/apps/ecpay/v1/create_refund";

    // 同步订单
    private String pushOrderUrl = "https://developer.toutiao.com/api/apps/order/v2/push";
}

Sign

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 字节支付签名类
 * @date 2023/3/31 10:05 PM
 */
public class Sign {

    /**
     * 担保支付请求不参与签名参数
     *
     * <p>app_id 小程序 appID
     *
     * <p>thirdparty_id 代小程序进行该笔交易调用的第三方平台服务商 id
     *
     * <p>sign 签名
     *
     * <p>other_settle_params 其他分账方参数
     *
     * <p>Guaranteed payment requests do not participate in signature parameters
     *
     * <p>app_id Applets appID
     *
     * <p>thirdparty_id The id of the third-party platform service provider that calls the
     * transaction on behalf of the Applets
     *
     * <p>sign sign
     *
     * <p>other_settle_params Other settle params
     */
    public static final List<String> REQUEST_NOT_NEED_SIGN_PARAMS =
            Arrays.asList("app_id", "thirdparty_id", "sign", "other_settle_params");

    /**
     * 支付密钥值，需要替换为自己的密钥 (完成进件后，开发者可在字节开放平台 -【某小程序】-【功能】-【支付】-【担保交易设置】中查看支付系统秘钥 SALT)
     *
     * <p>Payment key value, you need to replace it with your own key
     */
    private static final String SALT = "QmdU86FRk6sL30O5Yn66hFG507BgV9MU10yoYqLq";

    /**
     * RequestSign 担保支付请求签名算法
     *
     * @param paramsMap {@code Map<String, Object>} 所有的请求参数
     * @return：签名字符串
     *     <p>RequestSign Guaranteed payment request signature algorithm
     * @param paramsMap {@code Map<String, Object>} all request parameters
     * @return: Signature string
     */
    public static String requestSign(Map<String, Object> paramsMap) {
        List<String> paramsArr = new ArrayList<>();
        for (Map.Entry<String, Object> entry : paramsMap.entrySet()) {
            String key = entry.getKey();
            if (REQUEST_NOT_NEED_SIGN_PARAMS.contains(key)) {
                continue;
            }
            String value = entry.getValue().toString();

            value = value.trim();
            if (value.startsWith("\"") && value.endsWith("\"") && value.length() > 1) {
                value = value.substring(1, value.length() - 1);
            }
            value = value.trim();
            if (value.equals("") || value.equals("null")) {
                continue;
            }
            paramsArr.add(value);
        }
        paramsArr.add(SALT);
        Collections.sort(paramsArr);
        StringBuilder signStr = new StringBuilder();
        String sep = "";
        for (String s : paramsArr) {
            signStr.append(sep).append(s);
            sep = "&";
        }
        return md5FromStr(signStr.toString());
    }

    /**
     * CallbackSign 担保支付回调签名算法
     *
     * @param params {@code List<String>} 所有字段（验证时注意不包含 sign 签名本身，不包含空字段与 type 常量字段）内容与平台上配置的 token
     * @return：签名字符串
     *     <p>CallbackSign Guaranteed payment callback signature algorithm
     * @param params {@code List<String>} The content of all fields (note that the sign signature
     *     itself is not included during verification, and does not include empty fields and type
     *     constant fields) content and the token configured on the platform
     * @return: signature string
     */
    public static String callbackSign(List<String> params) {
        try {
            String concat = params.stream().sorted().collect(Collectors.joining(""));
            byte[] arrayByte = concat.getBytes(StandardCharsets.UTF_8);
            MessageDigest mDigest = MessageDigest.getInstance("SHA1");
            byte[] digestByte = mDigest.digest(arrayByte);

            StringBuffer signBuilder = new StringBuffer();
            for (byte b : digestByte) {
                signBuilder.append(Integer.toString((b & 0xff) + 0x100, 16).substring(1));
            }
            return signBuilder.toString();
        } catch (Exception exp) {
            return "";
        }
    }

    /**
     * md5FromStr md5 算法对该字符串计算摘要
     *
     * @param inStr {@code String} 需要签名的字符串
     * @return：签名字符串
     *     <p>md5FromStr The md5 algorithm computes a digest of the string
     * @param inStr {@code String} String to be signed
     * @return: signature string
     */
    private static String md5FromStr(String inStr) {
        MessageDigest md5;
        try {
            md5 = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return "";
        }

        byte[] byteArray = inStr.getBytes(StandardCharsets.UTF_8);
        byte[] md5Bytes = md5.digest(byteArray);
        StringBuilder hexValue = new StringBuilder();
        for (byte md5Byte : md5Bytes) {
            int val = ((int) md5Byte) & 0xff;
            if (val < 16) {
                hexValue.append("0");
            }
            hexValue.append(Integer.toHexString(val));
        }
        return hexValue.toString();
    }
}

AccessToken

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.my.memory.base.http.HttpClientHelper;
import com.my.memory.base.pay.byteDance.config.BytePayConfig;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description access_token 是小程序的全局唯一调用凭据，开发者调用小程序支付时需要使用 access_token。access_token 的有效期为 2
 *     个小时，需要定时刷新 access_token，重复获取会导致之前一次获取的 access_token 的有效期缩短为 5 分钟。
 * @date 2023/3/31 9:20 PM
 */
@Component
@Slf4j
public class AccessToken {

    /** 注入支付配置类 */
    private final BytePayConfig bytePayConfig;

    @Autowired
    public AccessToken(BytePayConfig bytePayConfig) {
        this.bytePayConfig = bytePayConfig;
    }

    public String getAccessToken() {

        // 构造请求JSON
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("appid", bytePayConfig.getAppId());
        jsonObject.put("secret", bytePayConfig.getSecret());
        jsonObject.put("grant_type", bytePayConfig.getGrantType());

        // 发送请求
        String result =
                HttpClientHelper.doPostJson(
                        bytePayConfig.getGetAccessTokenApi(), jsonObject.toJSONString());
        // 检查是否为空
        if (StringUtils.isBlank(result)) {
            log.error("获取access_token失败，返回结果为空");
        }

        // 解析返回结果
        JSONObject resultJson = JSON.parseObject(result);
        // 检查是否成功
        if (resultJson.getInteger("err_no") != 0) {
            log.error("获取access_token失败，返回结果为：{}", result);
        }

        // 返回access_token
        return JSON.parseObject(resultJson.getString("data")).getString("access_token");
    }
}

CreateOrderReqDto

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 创建订单请求实体——抖音侧
 *     <p>不使用驼峰命名 因为第三方订单参数的原因
 * @date 2023/3/31 11:18 PM
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "CreateOrderReqDto", description = "创建订单请求实体——抖音侧")
public class CreateOrderReqDto {

    /**
     * app_id : tt07e3715e98c9aac0
     *
     * <p>out_order_no : out_order_no_1
     *
     * <p>total_amount : 12800
     *
     * <p>subject : 测试商品
     *
     * <p>body : 测试商品
     *
     * <p>valid_time : 180
     *
     * <p>sign : d716027b7b5a91a3319a061d818cc9cc
     *
     * <p>cp_extra : 一些附加信息
     *
     * <p>notify_url : https://api.iiyyeixin.com/Notify/bytedancePay
     */
    @ApiModelProperty(value = "应用ID")
    private String app_id;

    @ApiModelProperty(value = "商户订单号")
    private String out_order_no;

    @ApiModelProperty(value = "订单金额，单位分")
    private int total_amount;

    @ApiModelProperty(value = "商品标题")
    private String subject;

    @ApiModelProperty(value = "商品描述")
    private String body;

    /** 订单有效时间，单位秒，15min */
    @ApiModelProperty(value = "订单有效时间，单位秒，15min")
    @Builder.Default
    private int valid_time = 900;

    @ApiModelProperty(value = "签名")
    private String sign;

    @ApiModelProperty(value = "支付成功回调地址")
    private String notify_url;

    /** 担保支付消息跳转页 小程序页面路径 */
    // @ApiModelProperty(value = "担保支付消息跳转页 小程序页面路径")
    private String msg_page;

    // private String cp_extra;

    // 第三方平台服务商 id，非服务商模式留空
    // private String thirdparty_id;

    @Builder.Default private Integer disable_msg = 0;
}

CreateOrderRespDto

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.my.memory.base.pay.byteDance.model.resp;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2023/3/31 11:35 PM
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "CreateOrderRespDto", description = "创建订单返回实体——抖音侧")
public class CreateOrderRespDto {

    @ApiModelProperty(value = "订单ID")
    private String orderId;

    @ApiModelProperty(value = "订单token")
    private String orderToken;
}

BytePayHelper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.my.memory.base.http.HttpClientHelper;
import com.my.memory.base.pay.byteDance.config.BytePayConfig;
import com.my.memory.base.pay.byteDance.model.req.CreateOrderReqDto;
import com.my.memory.base.pay.byteDance.model.resp.CreateOrderRespDto;
import com.my.memory.base.pay.byteDance.sign.BytePaySign;
import com.my.memory.base.redis.helper.RedisHelper;
import com.my.memory.biz.purchase.model.entity.BuyOrderEntity;
import com.my.memory.biz.purchase.model.entity.BuyOrderItemEntity;
import com.my.memory.biz.purchase.model.entity.PricePackageEntity;
import com.my.memory.biz.user.model.entity.UserEntity;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.time.ZoneOffset;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2023/3/31 11:40 PM
 */
@Component
@Slf4j
public class BytePayHelper {

    /** 注入支付配置类 */
    private BytePayConfig bytePayConfig;

    @Autowired
    public BytePayHelper(BytePayConfig bytePayConfig) {
        this.bytePayConfig = bytePayConfig;
    }

    /** 注入Redis */
    private RedisHelper redisHelper;

    @Autowired
    public void setRedisHelper(RedisHelper redisHelper) {
        this.redisHelper = redisHelper;
    }

    /**
     * 支付预下单
     *
     * @param createOrderReqDto
     * @return
     */
    public CreateOrderRespDto createOrder(CreateOrderReqDto createOrderReqDto) {

        // 添加appID参数
        createOrderReqDto.setApp_id(bytePayConfig.getAppId());

        /// 添加页面跳转参数 前端传参
        // createOrderReqDto.setMsg_page(bytePayConfig.getMsgPage());

        // 设置支付通知地址
        createOrderReqDto.setNotify_url(bytePayConfig.getNotifyUrl());

        // Entity转Map
        Map<String, Object> map =
                (Map<String, Object>)
                        JSON.parseObject(JSON.toJSONString(createOrderReqDto), Map.class);

        // 添加签名数据
        createOrderReqDto.setSign(BytePaySign.requestSign(map));

        // 执行预下单请求
        String result =
                HttpClientHelper.doPayPostJson(
                        bytePayConfig.getCreateOrderUrl(), JSON.toJSONString(createOrderReqDto));
        // 判断返回结果是否为空
        if (StringUtils.isBlank(result)) {
            log.error("支付预下单失败，返回结果为空");

            return null;
        }

        // 解析返回结果
        JSONObject jsonObject = JSON.parseObject(result);
        // 判断返回结果是否成功
        if (jsonObject.getInteger("err_no") != 0) {
            log.error("支付预下单失败，返回结果：{}", result);

            return null;
        }

        // 返回结果
        return CreateOrderRespDto.builder()
                .orderId(JSON.parseObject(jsonObject.getString("data")).getString("order_id"))
                .orderToken(JSON.parseObject(jsonObject.getString("data")).getString("order_token"))
                .build();
    }

    /**
     * 支付回调验证
     *
     * @return
     */
    public Boolean verifyCallback(String timestamp, String nonce, String msg, String msgSignature) {

        List<String> sortedString = Arrays.asList(bytePayConfig.getToken(), timestamp, nonce, msg);
        String signature = BytePaySign.callbackSign(sortedString);
        if (!signature.equals(msgSignature)) {
            log.error("支付回调验证失败，签名不一致");
            return false;
        } else {
            return true;
        }
    }

    /**
     * 订单同步
     *
     * <p>仅支持1条子订单
     */
    public void pushOrder(
            BuyOrderEntity buyOrderEntity,
            BuyOrderItemEntity buyOrderItemEntity,
            PricePackageEntity pricePackageEntity,
            UserEntity userEntity) {

        // 获取access_token
        String key = "douyin_access_token:";
        String accessToken = redisHelper.get(key);
        if (StringUtils.isBlank(accessToken)) {
            log.error("推送订单失败，原因：获取抖音access_token失败");

            return;
        }

        // 构造请求 参数
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("access_token", accessToken);
        jsonObject.put("app_name", "douyin");
        jsonObject.put("open_id", userEntity.getOpenId());
        jsonObject.put("order_type", 0);
        jsonObject.put(
                "update_time",
                buyOrderItemEntity.getUpdateTime().toInstant(ZoneOffset.of("+8")).toEpochMilli());
        /// jsonObject.put("extra", "");

        // 构造订单详情
        JSONObject orderDetail = new JSONObject();
        orderDetail.put("order_id", buyOrderItemEntity.getParentOrderId());
        // 创建时间 LocalDateTime 修改为 时间戳
        orderDetail.put(
                "create_time",
                buyOrderItemEntity.getCreateTime().toInstant(ZoneOffset.of("+8")).toEpochMilli());
        orderDetail.put("amount", buyOrderEntity.getTotalNum());
        orderDetail.put(
                "total_price",
                buyOrderEntity.getPayMoney().multiply(BigDecimal.valueOf(100)).intValue());
        orderDetail.put("detail_url", bytePayConfig.getOrderDetailUrl());

        // 设置订单状态
        switch (buyOrderItemEntity.getStatus()) {
            case 0:
                jsonObject.put("order_status", 0);
                orderDetail.put("status", "待支付");
                break;

            case 1:
                /// jsonObject.put("order_status", 1);
                jsonObject.put("order_status", 4);
                orderDetail.put("status", "已支付");
                break;

            case 2:
                jsonObject.put("order_status", 2);
                orderDetail.put("status", "已取消");
                break;

            case 3:
                jsonObject.put("order_status", 2);
                orderDetail.put("status", "已超时");
                break;

            default:
                break;
        }

        // 构造子订单商品列表
        // List<JSONObject> goodsList = Lists.newArrayList();

        // 构造子订单商品
        JSONObject goods = new JSONObject();
        goods.put("item_code", pricePackageEntity.getId().toString());
        goods.put("img", pricePackageEntity.getUrl());
        goods.put("title", pricePackageEntity.getPayTitle());
        goods.put("sub_title", pricePackageEntity.getName());
        goods.put("amount", buyOrderItemEntity.getNumber());
        goods.put(
                "price",
                pricePackageEntity
                        .getPreferentialPrice()
                        .multiply(BigDecimal.valueOf(100))
                        .intValue());

        // 添加子订单商品
        // goodsList.add(goods);

        // 添加子订单商品列表
        orderDetail.put("item_list", Collections.singletonList(goods));

        // 添加订单详情
        jsonObject.put("order_detail", orderDetail.toJSONString());

        // 执行推送订单请求
        String result =
                HttpClientHelper.doDouyinSubPostJson(
                        bytePayConfig.getPushOrderUrl(), jsonObject.toJSONString());
        // 判断返回结果是否为空
        if (StringUtils.isBlank(result)) {
            log.error("推送订单失败，返回结果为空");

            return;
        }

        // 解析返回结果
        JSONObject resultJson = JSON.parseObject(result);
        // 判断返回结果是否成功
        if (resultJson.getInteger("err_code") != 0) {
            log.error("推送订单失败，返回结果：{}", result);

            return;
        }

        log.info("推送订单成功，返回结果：{}", result);
    }
}

PurchaseController

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 套餐包类
 * @date 2023/3/14 3:34 PM
 */
@RestController
@RequestMapping(value = "/purchase")
@Api(tags = "套餐包模块")
public class PurchaseController {

    /** 注入服务类 */
    private PricePackageService pricePackageService;

    @Autowired
    public void setPricePackageService(PricePackageService pricePackageService) {
        this.pricePackageService = pricePackageService;
    }

    @PostMapping(value = "/bytePay/createOrder")
    @ApiOperation(value = "字节支付预下单", notes = "字节支付预下单")
    public Result<CreateOrderResp> bytePayCreateOrder(
            @CurrentUser UserDto currentUser, @Valid @RequestBody CreateOrderReq createOrderReq) {
        return Result.success(pricePackageService.bytePayCreateOrder(currentUser, createOrderReq));
    }

    @DisableToken
    @PostMapping(value = "/bytePay/callback")
    @ApiOperation(value = "字节支付回调", notes = "字节支付回调")
    public void bytePayCallback(
            HttpServletRequest request,
            @RequestBody(required = false) String data,
            HttpServletResponse response) {
        pricePackageService.bytePayCallback(request, data, response);
    }
}

PricePackageServiceImpl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
// 请求抖音支付
        CreateOrderReqDto createOrderReqDto =
                CreateOrderReqDto.builder()
                        .out_order_no(buyOrderId)
                        .subject(pricePackage.getName())
                        .body(pricePackage.getName())
                        .total_amount(
                                pricePackage
                                        .getPreferentialPrice()
                                        .multiply(
                                                BigDecimal.valueOf(createOrderReq.getPackageNum()))
                                        .multiply(BigDecimal.valueOf(100))
                                        .intValue())
                        .msg_page(createOrderReq.getSuccessRedirectUrl())
                        .build();
        CreateOrderRespDto createOrderRespDto = bytePayHelper.createOrder(createOrderReqDto);
        // 判断抖音支付是否成功
        if (createOrderRespDto == null) {
            log.error(
                    "抖音支付预下单失败，用户ID：{}，套餐ID：{}",
                    currentUser.getUserId(),
                    createOrderReq.getPackageId());

            throw new AiException("创建订单失败，请重试");
        }


    @Override
    public void bytePayCallback(
            HttpServletRequest request, String data, HttpServletResponse response) {

        // 从请求参数中获取支付结果
        JSONObject jsonObject = JSON.parseObject(data);
        String timestamp = jsonObject.getString("timestamp");
        String nonce = jsonObject.getString("nonce");
        String msg = jsonObject.getString("msg");
        String type = jsonObject.getString("type");
        String msgSignature = jsonObject.getString("msg_signature");

        // 验签
        boolean checkSign = bytePayHelper.verifyCallback(timestamp, nonce, msg, msgSignature);
        if (!checkSign) {
            log.error("抖音支付回调验签失败，参数：{}", data);

            return;
        }

        // 判断是否支付成功
        if (!"payment".equals(type)) {
            // 支付失败
            log.error("抖音支付回调，支付失败，参数：{}", data);

            return;
        }

        // 解析支付成功回调内容
        JSONObject jsonMsgObject = JSON.parseObject(msg);
        // 本侧订单号
        String buyOrderId = jsonMsgObject.getString("cp_orderno");

        // 考虑回写延迟等，设置Redis拦截，保证同一订单回调入队列只有一次，避免重复处理订单数据
        String key = "bytePay:callback:orderId" + buyOrderId;
        if (StringUtils.isNotBlank(redisHelper.get(key))) {
            log.error("抖音支付回调，重复回调，参数：{}", data);

            try {
                // 支付成功回调内容，回写
                JSONObject jsonObjectWrite = new JSONObject();
                jsonObjectWrite.put("err_no", 0);
                jsonObjectWrite.put("err_tips", "success");
                ServletOutputStream output = response.getOutputStream();
                output.write(jsonObjectWrite.toJSONString().getBytes());
                output.flush();

            } catch (IOException e) {
                log.error("抖音支付成功，回写失败，原因：{}", e.getMessage());
            }

            return;
        }

        // 支付成功处理
        // 异步处理
        // 消息队列削峰填谷
        unpaidOrderQueue.addUnpaidDelay("CALLBACK:" + buyOrderId, 5);

        // 设置Redis缓存
        redisHelper.set(key, buyOrderId, 15 * 60L);

        try {
            // 支付成功回调内容，回写
            JSONObject jsonObjectWrite = new JSONObject();
            jsonObjectWrite.put("err_no", 0);
            jsonObjectWrite.put("err_tips", "success");
            ServletOutputStream output = response.getOutputStream();
            output.write(jsonObjectWrite.toJSONString().getBytes());
            output.flush();

        } catch (IOException e) {
            log.error("抖音支付成功，回写失败，原因：{}", e.getMessage());
        }

        //        try {
        //            // 支付失败回调内容，回写
        //            JSONObject jsonObject = new JSONObject();
        //            jsonObject.put("err_no", 400);
        //            jsonObject.put("err_tips", "business fail");
        //            ServletOutputStream output = response.getOutputStream();
        //            output.write(jsonObject.toJSONString().getBytes());
        //            output.flush();
        //
        //        } catch (IOException e) {
        //            log.error("抖音支付失败，回写失败，原因：{}", e.getMessage());
        //        }
    }

BuyOrderServiceImpl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
@Override
    @Async
    public void bytePayPushOrder(String orderId) {

        // 查询父订单信息
        LambdaQueryWrapper<BuyOrderEntity> buyOrderEntityLambdaQueryWrapper =
                new LambdaQueryWrapper<>();
        buyOrderEntityLambdaQueryWrapper.eq(BuyOrderEntity::getOrderId, orderId);
        BuyOrderEntity buyOrderEntity = this.getOne(buyOrderEntityLambdaQueryWrapper);
        if (buyOrderEntity == null) {
            log.error("抖音支付推送订单同步，父订单不存在，订单号：{}", orderId);

            return;
        }

        // 查询子订单信息
        LambdaQueryWrapper<BuyOrderItemEntity> buyOrderItemEntityLambdaQueryWrapper =
                new LambdaQueryWrapper<>();
        buyOrderItemEntityLambdaQueryWrapper.eq(BuyOrderItemEntity::getParentOrderId, orderId);
        BuyOrderItemEntity buyOrderItemEntity =
                buyOrderItemService.getOne(buyOrderItemEntityLambdaQueryWrapper);
        if (buyOrderItemEntity == null) {
            log.error("抖音支付推送订单同步，子订单不存在，订单号：{}", orderId);

            return;
        }

        // 查询商品信息
        LambdaQueryWrapper<PricePackageEntity> pricePackageEntityLambdaQueryWrapper =
                new LambdaQueryWrapper<>();
        pricePackageEntityLambdaQueryWrapper.eq(
                PricePackageEntity::getId, buyOrderItemEntity.getPricePackageId());
        PricePackageEntity pricePackageEntity =
                pricePackageMapper.selectOne(pricePackageEntityLambdaQueryWrapper);
        if (pricePackageEntity == null) {
            log.error("抖音支付推送订单同步，商品不存在，订单号：{}", orderId);

            return;
        }

        // 查询用户信息
        LambdaQueryWrapper<UserEntity> userEntityLambdaQueryWrapper = new LambdaQueryWrapper<>();
        userEntityLambdaQueryWrapper.eq(UserEntity::getId, buyOrderEntity.getUserId());
        UserEntity userEntity = userService.getOne(userEntityLambdaQueryWrapper);
        if (userEntity == null) {
            log.error("抖音支付推送订单同步，用户不存在，订单号：{}", orderId);

            return;
        }

        // 同步订单
        bytePayHelper.pushOrder(buyOrderEntity, buyOrderItemEntity, pricePackageEntity, userEntity);
    }

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

徘徊在原子与字节的边缘<br><br>将更好的自己呈现给世界<br><br><br><br>修心至要，事上磨练<br><br>一蓑衣，一壶酒，一曲长歌，一剑天涯<br><br>见自己，见天地，见众生<br><br>