微信小程序实现支付

微信小程序实现支付

application.yml

1
2
3
4
5
6
7
8
9
10
auth:
  weixin:
    app-id: ${we_app_id}
    secret: ${we_secret}
    merchant-id: xxx
    api-v3-key: xxx
    private-key-path: static/apiclient_key.pem
    private-key: ${we_private_key}
    merchant-serial-number: xxx
    notify-url: ${we_notify_url}

WePayConfig

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
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2023/4/10 4:51 PM
 */
@Data
@Configuration
public class WePayConfig {

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

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

    @Value("${auth.weixin.merchant-id}")
    private String merchantId;

    @Value("${auth.weixin.api-v3-key}")
    private String apiV3Key;

    @Value("${auth.weixin.private-key-path}")
    private String privateKeyPath;

    @Value("${auth.weixin.private-key}")
    private String privateKey;

    @Value("${auth.weixin.merchant-serial-number}")
    private String merchantSerialNumber;

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

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
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDateTime;
import java.time.ZoneOffset;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 创建订单请求实体——微信侧
 * @date 2023/3/31 11:18 PM
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "CreateOrderReqDto", description = "创建订单请求实体——微信侧")
public class CreateOrderReqDto {

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

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

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

    @ApiModelProperty(value = "用户标识")
    private String openId;

    /** 订单有效时间，15min */
    @ApiModelProperty(value = "订单有效时间，15min")
    @Builder.Default
    private String timeExpire =
            LocalDateTime.now().plusMinutes(15).atOffset(ZoneOffset.of("+08:00")).toString();
}

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
30
31
32
33
34
35
36
37
38
39
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("appId")
    private String appId;

    @ApiModelProperty("timeStamp")
    private String timestamp;

    @ApiModelProperty("nonceStr")
    private String nonceStr;

    @ApiModelProperty("package")
    private String packageVal;

    @ApiModelProperty("signType")
    private String signType;

    @ApiModelProperty("paySign")
    private String paySign;
}

WePayHelper

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
import com.my.memory.base.pay.weixin.config.WePayConfig;
import com.my.memory.base.pay.weixin.model.req.CreateOrderReqDto;
import com.my.memory.base.pay.weixin.model.resp.CreateOrderRespDto;
import com.wechat.pay.java.core.Config;
import com.wechat.pay.java.core.RSAAutoCertificateConfig;
import com.wechat.pay.java.core.exception.HttpException;
import com.wechat.pay.java.core.exception.MalformedMessageException;
import com.wechat.pay.java.core.exception.ServiceException;
import com.wechat.pay.java.core.notification.NotificationConfig;
import com.wechat.pay.java.core.notification.NotificationParser;
import com.wechat.pay.java.core.notification.RequestParam;
import com.wechat.pay.java.service.payments.jsapi.JsapiServiceExtension;
import com.wechat.pay.java.service.payments.jsapi.model.Amount;
import com.wechat.pay.java.service.payments.jsapi.model.Payer;
import com.wechat.pay.java.service.payments.jsapi.model.PrepayRequest;
import com.wechat.pay.java.service.payments.jsapi.model.PrepayWithRequestPaymentResponse;
import com.wechat.pay.java.service.payments.model.Transaction;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.servlet.http.HttpServletRequest;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2023/4/10 5:01 PM
 */
@Component
@Slf4j
public class WePayHelper {

    // 支付服务
    private JsapiServiceExtension serviceExtension;

    /** 注入配置类 */
    private final WePayConfig wePayConfig;

    @Autowired
    public WePayHelper(WePayConfig wePayConfig) {
        this.wePayConfig = wePayConfig;
    }

    /**
     * 只能被初始化一次
     *
     * <p>一个商户号只能初始化一个配置，否则会因为重复的下载任务报错
     */
    private Config config;

    /** 初始化服务 */
    @PostConstruct
    @Async
    public void init() {

        // 初始化商户配置
        //        RSAConfig config =
        //                new RSAConfig.Builder()
        //                        .merchantId(wePayConfig.getMerchantId())
        //                        // 使用 com.wechat.pay.java.core.util
        // 中的函数从本地文件中加载商户私钥，商户私钥会用来生成请求的签名
        //                        // .privateKeyFromPath(privateKeyPath)
        //                        .privateKey(wePayConfig.getPrivateKey())
        //                        .merchantSerialNumber(wePayConfig.getMerchantSerialNumber())
        //
        // .wechatPayCertificatesFromPath(wePayConfig.getWechatPayCertificatePath())
        //                        // .wechatPayCertificates(wePayConfig.getWechatPayCertificate())
        //                        .build();

        // 初始化商户配置
        // 使用自动更新平台证书的RSA配置
        // 一个商户号只能初始化一个配置，否则会因为重复的下载任务报错
        config =
                new RSAAutoCertificateConfig.Builder()
                        .merchantId(wePayConfig.getMerchantId())
                        // .privateKeyFromPath(privateKeyPath)
                        .privateKey(wePayConfig.getPrivateKey())
                        .merchantSerialNumber(wePayConfig.getMerchantSerialNumber())
                        .apiV3Key(wePayConfig.getApiV3Key())
                        .build();

        // 初始化服务
        serviceExtension =
                new JsapiServiceExtension.Builder()
                        .config(config)
                        // 不填默认为 RSA
                        .signType("RSA")
                        .build();

        log.info("微信支付服务初始化成功");
    }

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

        try {
            /** JSAPI 支付下单 */
            PrepayRequest request = new PrepayRequest();

            // 设置请求参数
            request.setAppid(wePayConfig.getAppId());
            request.setMchid(wePayConfig.getMerchantId());
            request.setOutTradeNo(createOrderReqDto.getOutTradeNo());
            request.setDescription(createOrderReqDto.getDescription());
            request.setTimeExpire(createOrderReqDto.getTimeExpire());
            request.setNotifyUrl(wePayConfig.getNotifyUrl());

            Amount amount = new Amount();
            amount.setTotal(createOrderReqDto.getTotal());
            request.setAmount(amount);

            Payer payer = new Payer();
            payer.setOpenid(createOrderReqDto.getOpenId());
            request.setPayer(payer);

            // 发送请求
            PrepayWithRequestPaymentResponse response =
                    serviceExtension.prepayWithRequestPayment(request);

            // Bean拷贝
            CreateOrderRespDto createOrderRespDto = new CreateOrderRespDto();
            BeanUtils.copyProperties(response, createOrderRespDto);
            createOrderRespDto.setTimestamp(response.getTimeStamp());

            // 返回结果
            return createOrderRespDto;

        } catch (HttpException | ServiceException | MalformedMessageException e) {
            // 发送 HTTP 请求失败
            // 调用 e.getHttpRequest () 获取请求打印日志或上报监控，更多方法见 HttpException 定义
            // 服务返回状态小于 200 或大于等于 300，例如 500
            // 调用 e.getResponseBody () 获取返回体打印日志或上报监控，更多方法见 ServiceException 定义
            // 服务返回成功，返回体类型不合法，或者解析返回体失败
            // 调用 e.getMessage () 获取信息打印日志或上报监控，更多方法见 MalformedMessageException 定义
            log.error("微信支付预下单失败，原因：{}", e.getMessage());

            return null;
        }
    }

    /** 回调校验 */
    public Transaction verifyCallbackByNotification(HttpServletRequest request, String bodyStr) {

        // 构造 RequestParam
        RequestParam requestParam =
                new RequestParam.Builder()
                        .serialNumber(request.getHeader("Wechatpay-Serial"))
                        .nonce(request.getHeader("Wechatpay-Nonce"))
                        .signature(request.getHeader("Wechatpay-Signature"))
                        .timestamp(request.getHeader("Wechatpay-Timestamp"))
                        .body(bodyStr)
                        .build();

        /// 如果已经初始化了 RSAAutoCertificateConfig，可直接使用
        // 初始化RSAAutoCertificateConfig
        // 一个商户号只能初始化一个配置，否则会因为重复的下载任务报错
        //        NotificationConfig notificationConfig =
        //                new RSAAutoCertificateConfig.Builder()
        //                        .merchantId(wePayConfig.getMerchantId())
        //                        .privateKey(wePayConfig.getPrivateKey())
        //                        .merchantSerialNumber(wePayConfig.getMerchantSerialNumber())
        //                        .apiV3Key(wePayConfig.getApiV3Key())
        //                        .build();

        // 初始化 NotificationParser
        NotificationParser notificationParser = new NotificationParser((NotificationConfig) config);

        // 以支付通知回调为例，验签、解密并转换成 Transaction
        return notificationParser.parse(requestParam, Transaction.class);
    }
}

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import com.my.memory.base.response.PageData;
import com.my.memory.base.response.Result;
import com.my.memory.base.tokenLogin.annotation.CurrentUser;
import com.my.memory.base.tokenLogin.annotation.DisableToken;
import com.my.memory.base.tokenLogin.model.UserDto;
import com.my.memory.biz.purchase.model.req.BytePayCreateOrderReq;
import com.my.memory.biz.purchase.model.req.CancelOrderReq;
import com.my.memory.biz.purchase.model.req.WePayCreateOrderReq;
import com.my.memory.biz.purchase.model.resp.BytePayCreateOrderResp;
import com.my.memory.biz.purchase.model.resp.CancelOrderResp;
import com.my.memory.biz.purchase.model.resp.GetPackageResp;
import com.my.memory.biz.purchase.model.resp.WePayCreateOrderResp;
import com.my.memory.biz.purchase.service.PricePackageService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

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

/**
 * @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 = "/wePay/createOrder")
    @ApiOperation(value = "微信支付预下单", notes = "微信支付预下单")
    public Result<WePayCreateOrderResp> wePayCreateOrder(
            @CurrentUser UserDto currentUser,
            @Valid @RequestBody WePayCreateOrderReq wePayCreateOrderReq) {
        return Result.success(
                pricePackageService.wePayCreateOrder(currentUser, wePayCreateOrderReq));
    }

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

WePayCreateOrderResp

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
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 = "WePayCreateOrderResp", description = "创建订单返回实体——微信侧")
public class WePayCreateOrderResp {

    /// @ApiModelProperty("appId")
    // private String appId;

    @ApiModelProperty("timeStamp")
    private String timestamp;

    @ApiModelProperty("nonceStr")
    private String nonceStr;

    @ApiModelProperty("package")
    private String packageVal;

    @ApiModelProperty("signType")
    private String signType;

    @ApiModelProperty("paySign")
    private String paySign;
}

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
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
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.my.memory.base.exception.AiException;
import com.my.memory.base.mail.MailHelper;
import com.my.memory.base.pay.byteDance.helper.BytePayHelper;
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.weixin.helper.WePayHelper;
import com.my.memory.base.rabbitmq.sender.MqSender;
import com.my.memory.base.redis.helper.RedisHelper;
import com.my.memory.base.redis.helper.RedisLockHelper;
import com.my.memory.base.redis.redisson.delayQueue.UnpaidOrderQueue;
import com.my.memory.base.response.PageData;
import com.my.memory.base.tokenLogin.model.UserDto;
import com.my.memory.biz.purchase.mapper.PricePackageMapper;
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.purchase.model.req.BytePayCreateOrderReq;
import com.my.memory.biz.purchase.model.req.CancelOrderReq;
import com.my.memory.biz.purchase.model.req.WePayCreateOrderReq;
import com.my.memory.biz.purchase.model.resp.BytePayCreateOrderResp;
import com.my.memory.biz.purchase.model.resp.CancelOrderResp;
import com.my.memory.biz.purchase.model.resp.GetPackageResp;
import com.my.memory.biz.purchase.model.resp.WePayCreateOrderResp;
import com.my.memory.biz.purchase.service.BuyOrderItemService;
import com.my.memory.biz.purchase.service.BuyOrderService;
import com.my.memory.biz.purchase.service.PricePackageService;
import com.my.memory.biz.user.mapper.UserMapper;
import com.my.memory.biz.user.model.entity.UserEntity;
import com.wechat.pay.java.service.payments.model.Transaction;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

/**
 * 价格套餐表 服务实现类
 *
 * @author 曳戈泰尔
 * @since 2023-03-30
 */
@Service
@Slf4j
public class PricePackageServiceImpl extends ServiceImpl<PricePackageMapper, PricePackageEntity>
        implements PricePackageService {

    /** 注入用户Mapper */
    private UserMapper userMapper;

    @Autowired
    public void setUserMapper(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    /** 注入支付父订单 Service */
    private BuyOrderService buyOrderService;

    @Autowired
    public void setBuyOrderService(BuyOrderService buyOrderService) {
        this.buyOrderService = buyOrderService;
    }

    /** 注入支付子订单 Service */
    private BuyOrderItemService buyOrderItemService;

    @Autowired
    public void setBuyOrderItemService(BuyOrderItemService buyOrderItemService) {
        this.buyOrderItemService = buyOrderItemService;
    }

    /** 注入字节支付工具类 */
    private BytePayHelper bytePayHelper;

    @Autowired
    public void setBytePayHelper(BytePayHelper bytePayHelper) {
        this.bytePayHelper = bytePayHelper;
    }

    private UnpaidOrderQueue unpaidOrderQueue;

    @Autowired
    public void setUnpaidOrderQueue(UnpaidOrderQueue unpaidOrderQueue) {
        this.unpaidOrderQueue = unpaidOrderQueue;
    }

    /** 注入redis锁 */
    private RedisLockHelper redisLockHelper;

    @Autowired
    public void setRedisLockHelper(RedisLockHelper redisLockHelper) {
        this.redisLockHelper = redisLockHelper;
    }

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

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

    /** 注入MQ生产者 */
    private MqSender mqSender;

    @Autowired
    public void setMqSender(MqSender mqSender) {
        this.mqSender = mqSender;
    }

    /** 注入微信支付 */
    private WePayHelper wePayHelper;

    @Autowired
    public void setWePayHelper(WePayHelper wePayHelper) {
        this.wePayHelper = wePayHelper;
    }

    /** 注入邮件服务 */
    private MailHelper mailHelper;

    @Autowired
    public void setMailHelper(MailHelper mailHelper) {
        this.mailHelper = mailHelper;
    }

    @Override
    public WePayCreateOrderResp wePayCreateOrder(
            UserDto currentUser, WePayCreateOrderReq wePayCreateOrderReq) {

        // 设置流控，每分钟3次
        if (Boolean.TRUE.equals(
                redisHelper.airDropCount("wePayCreateOrder", currentUser.getUserId(), 5L))) {
            log.error("微信支付预下单，触发流控，用户ID：{}", currentUser.getUserId());

            // 发送邮件通知
            mailHelper.sendSimpleMail("微信支付预下单，流控报警，非法用户ID：" + currentUser.getUserId());

            throw new AiException("操作太频繁，请休息一会儿！");
        }

        // 查询用户信息
        LambdaQueryWrapper<UserEntity> lqwUser = new LambdaQueryWrapper<>();
        lqwUser.select(UserEntity::getId, UserEntity::getDel, UserEntity::getOpenId);
        lqwUser.eq(UserEntity::getId, currentUser.getUserId());
        UserEntity user = userMapper.selectOne(lqwUser);
        // 判断用户是否存在
        if (user == null) {
            log.error("用户不存在，用户ID：{}", currentUser.getUserId());

            throw new AiException("用户不存在");
        }
        // 用户黑名单校验
        if (user.getDel() == 1) {
            log.error("用户已被拉黑，用户ID：{}", currentUser.getUserId());

            throw new AiException("账户已被冻结，请联系客服解冻！");
        }

        // 查询价格套餐信息
        LambdaQueryWrapper<PricePackageEntity> lqwPrice = new LambdaQueryWrapper<>();
        lqwPrice.select(
                PricePackageEntity::getId,
                PricePackageEntity::getName,
                PricePackageEntity::getPayTitle,
                PricePackageEntity::getOriginalPrice,
                PricePackageEntity::getPreferentialPrice);
        lqwPrice.eq(PricePackageEntity::getId, wePayCreateOrderReq.getPackageId());
        lqwPrice.eq(PricePackageEntity::getStatus, 1);
        lqwPrice.eq(PricePackageEntity::getDel, 0);
        PricePackageEntity pricePackage = this.getOne(lqwPrice);
        // 判断价格套餐是否存在
        if (pricePackage == null) {
            log.error("价格套餐不存在，套餐ID：{}", wePayCreateOrderReq.getPackageId());

            throw new AiException("价格套餐不存在");
        }

        // 生成父订单
        String buyOrderId = IdWorker.getIdStr() + "b";

        // 请求微信支付
        com.my.memory.base.pay.weixin.model.req.CreateOrderReqDto createOrderReqDto =
                com.my.memory.base.pay.weixin.model.req.CreateOrderReqDto.builder()
                        .outTradeNo(buyOrderId)
                        .openId(user.getOpenId())
                        .description(pricePackage.getPayTitle() + "：" + pricePackage.getName())
                        .total(
                                pricePackage
                                        .getPreferentialPrice()
                                        .multiply(
                                                BigDecimal.valueOf(
                                                        wePayCreateOrderReq.getPackageNum()))
                                        .multiply(BigDecimal.valueOf(100))
                                        .intValue())
                        .build();
        com.my.memory.base.pay.weixin.model.resp.CreateOrderRespDto createOrderRespDto =
                wePayHelper.createOrder(createOrderReqDto);
        // 判断微信支付是否成功
        if (createOrderRespDto == null) {
            log.error(
                    "微信支付预下单失败，用户ID：{}，套餐ID：{}",
                    currentUser.getUserId(),
                    wePayCreateOrderReq.getPackageId());

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

        BuyOrderEntity buyOrderEntity =
                BuyOrderEntity.builder()
                        .orderId(buyOrderId)
                        .userId(currentUser.getUserId())
                        // 微信支付方式
                        .payType(1)
                        .totalNum(wePayCreateOrderReq.getPackageNum())
                        .totalMoney(
                                pricePackage
                                        .getPreferentialPrice()
                                        .multiply(
                                                BigDecimal.valueOf(
                                                        wePayCreateOrderReq.getPackageNum())))
                        .payMoney(
                                pricePackage
                                        .getPreferentialPrice()
                                        .multiply(
                                                BigDecimal.valueOf(
                                                        wePayCreateOrderReq.getPackageNum())))
                        .createTime(LocalDateTime.now())
                        .updateTime(LocalDateTime.now())
                        .build();

        // 生成子订单
        String buyOrderItemId = IdWorker.getIdStr() + "bi";
        BuyOrderItemEntity buyOrderItemEntity =
                BuyOrderItemEntity.builder()
                        .orderItemId(buyOrderItemId)
                        .parentOrderId(buyOrderId)
                        .userId(currentUser.getUserId())
                        .pricePackageId(pricePackage.getId())
                        .goodsName(pricePackage.getPayTitle() + "：" + pricePackage.getName())
                        .number(wePayCreateOrderReq.getPackageNum())
                        .price(pricePackage.getPreferentialPrice())
                        .money(
                                pricePackage
                                        .getPreferentialPrice()
                                        .multiply(
                                                BigDecimal.valueOf(
                                                        wePayCreateOrderReq.getPackageNum())))
                        .payMoney(
                                pricePackage
                                        .getPreferentialPrice()
                                        .multiply(
                                                BigDecimal.valueOf(
                                                        wePayCreateOrderReq.getPackageNum())))
                        .createTime(LocalDateTime.now())
                        .updateTime(LocalDateTime.now())
                        .build();

        // 保存父订单
        if (!buyOrderService.save(buyOrderEntity)) {
            log.error("保存父订单失败，父订单ID：{}", buyOrderId);

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

        // 保存子订单
        if (!buyOrderItemService.save(buyOrderItemEntity)) {
            log.error("保存子订单失败，子订单ID：{}", buyOrderItemId);

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

        // 发送超时消息到Redisson
        // unpaidOrderQueue.addUnpaidDelay("TIMEOUT:" + buyOrderId, 15 * 60 * 1000);
        mqSender.sendPayTimeoutMsg(buyOrderId);

        // 返回小程序预下单数据
        WePayCreateOrderResp wePayCreateOrderResp = new WePayCreateOrderResp();
        BeanUtils.copyProperties(createOrderRespDto, wePayCreateOrderResp);
        return wePayCreateOrderResp;
    }

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

        // 从请求参数中获取资源Resource
        // JSONObject jsonObject = JSON.parseObject(data);
        /// 获取支付状态
        // String eventType = jsonObject.getString("event_type");
        // 获取resource
        // String resource = jsonObject.getString("resource");

        // 检查resource是否为空
        // if (StringUtils.isBlank(resource)) {
        //     log.error("微信支付回调，支付失败，参数：{}", data);

        //     return;
        // }

        // 验签
        Transaction transaction;
        try {
            transaction = wePayHelper.verifyCallbackByNotification(request, data);
        } catch (Exception e) {
            log.error("微信支付回调验签失败，参数：{}", data);

            return;
        }

        // 判断是否支付成功
        if (!"SUCCESS".equals(transaction.getTradeState().toString())) {
            // 支付失败
            log.error("微信支付回调，支付失败，参数：{}", data);

            return;
        }

        // 本侧订单号
        String buyOrderId = transaction.getOutTradeNo();

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

            try {
                // 支付成功回调内容，回写
                response.setStatus(200);
                ServletOutputStream output = response.getOutputStream();
                output.flush();

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

            return;
        }

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

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

        try {
            // 支付成功回调内容，回写
            response.setStatus(200);
            ServletOutputStream output = response.getOutputStream();
            output.flush();

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

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>