Spring Boot + Cloud + RocketMQ 实现微信V3支付

码畜sokach

已于 2025-05-08 17:51:36 修改

阅读量505

点赞数 14

文章标签： java-rocketmq spring boot rocketmq

于 2025-05-08 17:45:59 首次发布

本文链接：https://blog.csdn.net/weixin_44006311/article/details/147796055

版权

Spring Boot + Cloud + RocketMQ 实现微信V3支付

下面我将为你提供一个完整的实现方案，使用Spring Boot、Spring Cloud和RocketMQ来实现微信V3支付功能。

1. 项目结构

wxpay-service/
├── src/
│   ├── main/
│   │   ├── java/com/example/wxpay/
│   │   │   ├── config/
│   │   │   │   ├── WxPayConfig.java
│   │   │   │   ├── RocketMQConfig.java
│   │   │   ├── controller/
│   │   │   │   ├── WxPayController.java
│   │   │   ├── service/
│   │   │   │   ├── WxPayService.java
│   │   │   │   ├── impl/
│   │   │   │   │   ├── WxPayServiceImpl.java
│   │   │   ├── mq/
│   │   │   │   ├── producer/
│   │   │   │   │   ├── PayMessageProducer.java
│   │   │   │   ├── consumer/
│   │   │   │   │   ├── PayMessageConsumer.java
│   │   │   ├── dto/
│   │   │   │   ├── PayRequest.java
│   │   │   │   ├── PayNotifyDTO.java
│   │   │   ├── exception/
│   │   │   │   ├── WxPayException.java
│   │   ├── resources/
│   │   │   ├── application.yml
│   │   │   ├── application-dev.yml
│   │   │   ├── wechat/
│   │   │   │   ├── apiclient_cert.pem
│   │   │   │   ├── apiclient_key.pem

2. 主要代码实现

2.1 添加依赖

<!-- pom.xml -->
<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Spring Cloud Starter -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter</artifactId>
    </dependency>
    
    <!-- RocketMQ Starter -->
    <dependency>
        <groupId>org.apache.rocketmq</groupId>
        <artifactId>rocketmq-spring-boot-starter</artifactId>
        <version>2.2.2</version>
    </dependency>
    
    <!-- 微信支付V3 SDK -->
    <dependency>
        <groupId>com.github.wechatpay-apiv3</groupId>
        <artifactId>wechatpay-java</artifactId>
        <version>0.2.17</version>
    </dependency>
    
    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

2.2 微信支付配置类

/**
* WxPayConfig.java
* 
**/
@Configuration
public class WxPayConfig {
    
    // 商户号
    @Value("${wxpay.mchId}")
    private String mchId;
    
    // 商户序列号
    @Value("${wxpay.mchSerialNo}")
    private String mchSerialNo;
    
    // v3密钥
    @Value("${wxpay.apiV3Key}")
    private String apiV3Key;
    
    // 私钥
    @Value("${wxpay.privateKeyPath}")
    private String privateKeyPath;
    
    // 回调地址
    @Value("${wxpay.notifyUrl}")
    private String notifyUrl;
    
    @Bean
    public Credentials credentials() throws IOException {
        // 加载商户私钥
        PrivateKey merchantPrivateKey = PemUtil.loadPrivateKey(new FileInputStream(privateKeyPath));
        
        // 构建Credentials
        return new Credentials(
            mchId,
            new PrivateKeySigner(mchSerialNo, merchantPrivateKey)
        );
    }
    
    @Bean
    public HttpClient httpClient(Credentials credentials) {
        return WechatPayHttpClientBuilder.create()
            .withCredentials(credentials)
            .withValidator(new WechatPay2Validator(apiV3Key.getBytes(StandardCharsets.UTF_8)))
            .build();
    }
    
    @Bean
    public Payments payments(HttpClient httpClient) {
        return new Payments.Builder()
            .httpClient(httpClient)
            .build();
    }
    
}

2.3 支付服务实现

/** 
* WxPayService.java
**/
public interface WxPayService {

    /**
     * 发起JSAPI支付
     */
    JSONObject jsapiPay(PayRequest request);
    
    /**
     * 处理支付结果通知
     */
    String handlePayNotify(HttpServletRequest request);
    
}

/** 
* WxPayServiceImpl.java
**/
@Service
@Slf4j
public class WxPayServiceImpl implements WxPayService {
    
    private final Payments payments;
    private final String notifyUrl;
    private final String mchId;
    private final PayMessageProducer payMessageProducer;
    
    public WxPayServiceImpl(Payments payments, 
                           @Value("${wxpay.notifyUrl}") String notifyUrl,
                           @Value("${wxpay.mchId}") String mchId,
                           PayMessageProducer payMessageProducer) {
        this.payments = payments;
        this.notifyUrl = notifyUrl;
        this.mchId = mchId;
        this.payMessageProducer = payMessageProducer;
    }
    
    @Override
    public JSONObject jsapiPay(PayRequest request) {
        try {
            PrepayRequest prepayRequest = new PrepayRequest();
            prepayRequest.setAppid(request.getAppId());
            prepayRequest.setMchid(mchId);
            prepayRequest.setDescription(request.getDescription());
            prepayRequest.setOutTradeNo(request.getOutTradeNo());
            prepayRequest.setNotifyUrl(notifyUrl);
            
            Amount amount = new Amount();
            amount.setTotal(request.getTotal());
            prepayRequest.setAmount(amount);
            
            Payer payer = new Payer();
            payer.setOpenid(request.getOpenId());
            prepayRequest.setPayer(payer);
            
            // 调用微信支付API
            PrepayResponse response = payments.jsapi(prepayRequest);
			// 检查返回结果
            if (!result.containsKey("prepay_id")) {
            	throw new RuntimeException("微信v3支付统一下单失败");
            }
            
            // 构建前端需要的支付参数
            JSONObject result = new JSONObject();
            result.put("appId", request.getAppId());
            result.put("timeStamp", String.valueOf(System.currentTimeMillis() / 1000));
            result.put("nonceStr", RandomStringUtils.randomAlphanumeric(32));
            result.put("package", "prepay_id=" + response.getPrepayId());
            result.put("signType", "RSA");
            
            // 签名
            String message = String.format("%s\n%s\n%s\n%s\n", 
                request.getAppId(),
                result.getString("timeStamp"),
                result.getString("nonceStr"),
                result.getString("package"));
            
            String sign = Signatures.create().sign(message);
            result.put("paySign", sign);
            
            return result;
        } catch (Exception e) {
            log.error("微信支付失败", e);
            throw new WxPayException("微信支付失败");
        }
    }
    
    @Override
    public String handlePayNotify(HttpServletRequest request) {
        try {
            // 解析通知内容
            String timestamp = request.getHeader("Wechatpay-Timestamp");
            String nonce = request.getHeader("Wechatpay-Nonce");
            String signature = request.getHeader("Wechatpay-Signature");
            String serial = request.getHeader("Wechatpay-Serial");
            String body = IOUtils.toString(request.getInputStream(), StandardCharsets.UTF_8);
            
            // 验证签名
            if (!verifySign(timestamp, nonce, body, signature, serial)) {
                throw new WxPayException("签名验证失败");
            }
            
            // 解析通知内容
            JSONObject result = JSONObject.parseObject(body);
            String outTradeNo = result.getJSONObject("resource")
                .getString("out_trade_no");
            String transactionId = result.getJSONObject("resource")
                .getString("transaction_id");
            String tradeState = result.getJSONObject("resource")
                .getString("trade_state");
            
            // 构建通知DTO
            PayNotifyDTO notifyDTO = new PayNotifyDTO();
            notifyDTO.setOutTradeNo(outTradeNo);
            notifyDTO.setTransactionId(transactionId);
            notifyDTO.setTradeState(tradeState);
            
            // 发送MQ消息异步处理
            payMessageProducer.sendPayNotifyMessage(notifyDTO);
            
            // 返回成功响应
            return buildSuccessResponse();
        } catch (Exception e) {
            log.error("处理支付通知异常", e);
            return buildFailResponse();
        }
    }
    
    private boolean verifySign(String timestamp, String nonce, String body, 
                             String signature, String serial) {
        // 实现签名验证逻辑
        // ...
    }
    
    private String buildSuccessResponse() {
        JSONObject response = new JSONObject();
        response.put("code", "SUCCESS");
        response.put("message", "成功");
        return response.toJSONString();
    }
    
    private String buildFailResponse() {
        JSONObject response = new JSONObject();
        response.put("code", "FAIL");
        response.put("message", "失败");
        return response.toJSONString();
    }
}

2.4 RocketMQ生产者

/**
* PayMessageProducer.java
**/
@Component
@Slf4j
public class PayMessageProducer {
    
    private final RocketMQTemplate rocketMQTemplate;
    
    // mq主题
    @Value("${rocketmq.topic.pay-notify}")
    private String payNotifyTopic;
    
    public PayMessageProducer(RocketMQTemplate rocketMQTemplate) {
        this.rocketMQTemplate = rocketMQTemplate;
    }
    
    public void sendPayNotifyMessage(PayNotifyDTO notifyDTO) {
        try {
            Message<PayNotifyDTO> message = MessageBuilder.withPayload(notifyDTO)
                .build();
            
            rocketMQTemplate.send(payNotifyTopic, message);
            log.info("发送支付通知消息成功: {}", notifyDTO);
        } catch (Exception e) {
            log.error("发送支付通知消息失败", e);
            throw new RuntimeException("发送支付通知消息失败", e);
        }
    }
}

2.5 RocketMQ消费者

/** 
* PayMessageConsumer.java
**/
@Slf4j
@Component
@RocketMQMessageListener(
    topic = "${rocketmq.topic.pay-notify}",
    consumerGroup = "${rocketmq.consumer-group.pay-notify}"
)
public class PayMessageConsumer implements RocketMQListener<PayNotifyDTO> {
    
    @Override
    public void onMessage(PayNotifyDTO notifyDTO) {
        try {
            log.info("收到支付通知消息: {}", notifyDTO);
            
            // 处理支付结果
            if ("SUCCESS".equals(notifyDTO.getTradeState())) {
                // 支付成功逻辑
                handlePaySuccess(notifyDTO);
            } else {
                // 支付失败逻辑
                handlePayFail(notifyDTO);
            }
        } catch (Exception e) {
            log.error("处理支付通知消息异常", e);
            // 可以添加重试逻辑
        }
    }
    
    private void handlePaySuccess(PayNotifyDTO notifyDTO) {
        // 实现支付成功业务逻辑
        // 1. 更新订单状态
        // 2. 记录支付流水
        // 3. 其他业务处理
    }
    
    private void handlePayFail(PayNotifyDTO notifyDTO) {
        // 实现支付失败业务逻辑
    }
}

2.6 控制器

/**
* WxPayController.java
**/
@RestController
@RequestMapping("/api/wxpay")
@Slf4j
public class WxPayController {
    
    private final WxPayService wxPayService;
    
    public WxPayController(WxPayService wxPayService) {
        this.wxPayService = wxPayService;
    }
    
    @PostMapping("/jsapi")
    public Result<JSONObject> jsapiPay(@RequestBody PayRequest request) {
        JSONObject result = wxPayService.jsapiPay(request);
        return Result.success(result);
    }
    
    @PostMapping("/notify")
    public String payNotify(HttpServletRequest request) {
        return wxPayService.handlePayNotify(request);
    }
}

2.7 配置文件

# application.yml
server:
  port: 8080

spring:
  application:
    name: wxpay-service
  rocketmq:
    name-server: 127.0.0.1:9876
    producer:
      group: wxpay-producer-group

wxpay:
  mchId: your_mch_id
  mchSerialNo: your_mch_serial_no
  apiV3Key: your_api_v3_key
  privateKeyPath: classpath:wechat/apiclient_key.pem
  notifyUrl: https://yourdomain.com/api/wxpay/notify

rocketmq:
  topic:
    pay-notify: PAY_NOTIFY_TOPIC
  consumer-group:
    pay-notify: PAY_NOTIFY_CONSUMER_GROUP