package com.ruoyi.payment.application.service;
|
|
import com.alibaba.fastjson.JSON;
|
import com.ruoyi.payment.domain.event.PaymentSuccessEvent;
|
import com.ruoyi.payment.domain.model.BizCallbackLog;
|
import com.ruoyi.payment.domain.model.PaymentOrder;
|
import com.ruoyi.payment.domain.model.PaymentTransaction;
|
import com.ruoyi.payment.infrastructure.config.BusinessCallbackConfig;
|
import com.ruoyi.payment.infrastructure.persistence.mapper.BizCallbackLogMapper;
|
import com.ruoyi.payment.infrastructure.util.SignUtil;
|
import com.ruoyi.payment.infrastructure.util.SnowflakeIdGenerator;
|
import com.ruoyi.payment.interfaces.callback.PaymentCallback;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.http.client.methods.CloseableHttpResponse;
|
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 org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.ApplicationContext;
|
import org.springframework.scheduling.annotation.Async;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.StringUtils;
|
|
import java.time.LocalDateTime;
|
import java.util.HashMap;
|
import java.util.Map;
|
import java.util.UUID;
|
|
/**
|
* 业务回调服务
|
*
|
* 支持三种回调方式：
|
* 1. Spring事件：发布 PaymentSuccessEvent 事件（推荐用于jar包集成）
|
* 2. 接口回调：调用所有实现了 PaymentCallback 接口的Bean（推荐用于jar包集成）
|
* 3. HTTP回调：向指定URL发送POST请求（用于独立部署或跨服务调用）
|
*
|
* @author ruoyi
|
*/
|
@Slf4j
|
@Service
|
public class BizCallbackService {
|
|
@Autowired
|
private BizCallbackLogMapper bizCallbackLogMapper;
|
|
@Autowired
|
private BusinessCallbackConfig businessCallbackConfig;
|
|
@Autowired
|
private ApplicationContext applicationContext;
|
|
/**
|
* 触发业务回调（异步）
|
*
|
* 优先级：
|
* 1. 发布Spring事件（同步，在同一事务中）
|
* 2. 调用PaymentCallback接口实现（同步，在同一事务中）
|
* 3. HTTP回调（异步，支持重试）
|
*/
|
@Async
|
public void triggerCallback(PaymentOrder order, PaymentTransaction transaction) {
|
log.info("触发业务回调，订单ID: {}, bizOrderId: {}", order.getId(), order.getBizOrderId());
|
|
// 方式1: 发布Spring事件（jar包集成时，主项目可以监听此事件）
|
publishPaymentEvent(order, transaction);
|
|
// 方式2: 调用PaymentCallback接口实现（jar包集成时，主项目实现此接口）
|
invokeCallbackInterface(order, transaction);
|
|
// 方式3: HTTP回调（独立部署时使用，需要配置callbackUrl）
|
if (StringUtils.hasText(order.getCallbackUrl())) {
|
executeHttpCallback(order, transaction);
|
} else {
|
log.info("未配置HTTP回调URL，跳过HTTP回调");
|
}
|
}
|
|
/**
|
* 发布支付成功事件
|
*/
|
private void publishPaymentEvent(PaymentOrder order, PaymentTransaction transaction) {
|
try {
|
PaymentSuccessEvent event = new PaymentSuccessEvent(this, order, transaction);
|
applicationContext.publishEvent(event);
|
log.info("发布支付成功事件，订单ID: {}", order.getId());
|
} catch (Exception e) {
|
log.error("发布支付事件失败", e);
|
}
|
}
|
|
/**
|
* 调用PaymentCallback接口实现
|
*/
|
private void invokeCallbackInterface(PaymentOrder order, PaymentTransaction transaction) {
|
try {
|
Map<String, PaymentCallback> callbacks = applicationContext.getBeansOfType(PaymentCallback.class);
|
if (callbacks.isEmpty()) {
|
log.info("未找到PaymentCallback接口实现，跳过接口回调");
|
return;
|
}
|
|
for (Map.Entry<String, PaymentCallback> entry : callbacks.entrySet()) {
|
try {
|
log.info("调用PaymentCallback: {}", entry.getKey());
|
entry.getValue().onPaymentSuccess(order, transaction);
|
} catch (Exception e) {
|
log.error("调用PaymentCallback失败: {}", entry.getKey(), e);
|
}
|
}
|
} catch (Exception e) {
|
log.error("调用PaymentCallback接口失败", e);
|
}
|
}
|
|
/**
|
* 执行HTTP回调
|
*/
|
private void executeHttpCallback(PaymentOrder order, PaymentTransaction transaction) {
|
log.info("执行HTTP回调，订单ID: {}, 回调URL: {}", order.getId(), order.getCallbackUrl());
|
|
// 构造回调参数
|
Map<String, Object> callbackData = new HashMap<>();
|
callbackData.put("tradeId", transaction.getId());
|
callbackData.put("orderId", order.getId());
|
callbackData.put("bizOrderId", order.getBizOrderId());
|
callbackData.put("channel", order.getChannel());
|
callbackData.put("amount", order.getAmount());
|
callbackData.put("currency", order.getCurrency());
|
callbackData.put("status", order.getStatus());
|
callbackData.put("channelTradeNo", order.getChannelTradeNo());
|
callbackData.put("paidAt", order.getPaidAt() != null ? order.getPaidAt().toString() : null);
|
callbackData.put("subject", order.getSubject());
|
callbackData.put("description", order.getDescription());
|
|
String payload = JSON.toJSONString(callbackData);
|
|
// 生成签名
|
String nonce = UUID.randomUUID().toString().replace("-", "");
|
String timestamp = String.valueOf(System.currentTimeMillis());
|
String signData = payload + nonce + timestamp;
|
String signature = SignUtil.hmacSha256(signData, businessCallbackConfig.getCallbackSignSecret());
|
|
// 记录回调日志
|
BizCallbackLog callbackLog = new BizCallbackLog();
|
callbackLog.setId(SnowflakeIdGenerator.generateId());
|
callbackLog.setOrderId(order.getId());
|
callbackLog.setTransactionId(transaction.getId());
|
callbackLog.setCallbackUrl(order.getCallbackUrl());
|
callbackLog.setPayload(payload);
|
callbackLog.setSuccess(false);
|
callbackLog.setRetryCount(0);
|
callbackLog.setCreatedAt(LocalDateTime.now());
|
bizCallbackLogMapper.insert(callbackLog);
|
|
// 执行HTTP回调
|
executeHttpRequest(callbackLog, payload, signature, nonce, timestamp, 0);
|
}
|
|
/**
|
* 执行HTTP回调请求
|
*/
|
private void executeHttpRequest(BizCallbackLog callbackLog, String payload, String signature,
|
String nonce, String timestamp, int retryCount) {
|
try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
|
HttpPost httpPost = new HttpPost(callbackLog.getCallbackUrl());
|
|
// 设置请求头
|
httpPost.setHeader("Content-Type", "application/json");
|
httpPost.setHeader("X-Signature", signature);
|
httpPost.setHeader("X-Nonce", nonce);
|
httpPost.setHeader("X-Timestamp", timestamp);
|
|
// 设置请求体
|
httpPost.setEntity(new StringEntity(payload, "UTF-8"));
|
|
// 发送请求
|
try (CloseableHttpResponse response = httpClient.execute(httpPost)) {
|
int statusCode = response.getStatusLine().getStatusCode();
|
String responseBody = EntityUtils.toString(response.getEntity(), "UTF-8");
|
|
log.info("业务回调响应，状态码: {}, 响应: {}", statusCode, responseBody);
|
|
// 更新回调日志
|
callbackLog.setHttpStatus(statusCode);
|
callbackLog.setResponse(responseBody);
|
callbackLog.setRetryCount(retryCount);
|
callbackLog.setLastRetryAt(LocalDateTime.now());
|
|
if (statusCode >= 200 && statusCode < 300) {
|
callbackLog.setSuccess(true);
|
bizCallbackLogMapper.update(callbackLog);
|
log.info("业务回调成功，订单ID: {}", callbackLog.getOrderId());
|
} else {
|
callbackLog.setSuccess(false);
|
bizCallbackLogMapper.update(callbackLog);
|
|
// 重试逻辑
|
scheduleRetry(callbackLog, payload, signature, nonce, timestamp, retryCount);
|
}
|
}
|
} catch (Exception e) {
|
log.error("业务回调异常，订单ID: {}", callbackLog.getOrderId(), e);
|
|
// 更新失败记录
|
callbackLog.setSuccess(false);
|
callbackLog.setResponse("异常: " + e.getMessage());
|
callbackLog.setRetryCount(retryCount);
|
callbackLog.setLastRetryAt(LocalDateTime.now());
|
bizCallbackLogMapper.update(callbackLog);
|
|
// 重试逻辑
|
scheduleRetry(callbackLog, payload, signature, nonce, timestamp, retryCount);
|
}
|
}
|
|
/**
|
* 安排重试
|
*/
|
private void scheduleRetry(BizCallbackLog callbackLog, String payload, String signature,
|
String nonce, String timestamp, int retryCount) {
|
int maxRetry = businessCallbackConfig.getCallbackRetryMaxCount();
|
if (retryCount >= maxRetry) {
|
log.warn("业务回调重试次数已达上限，订单ID: {}", callbackLog.getOrderId());
|
return;
|
}
|
|
int[] intervals = businessCallbackConfig.getRetryIntervalsArray();
|
int nextRetry = retryCount + 1;
|
int delayMinutes = nextRetry < intervals.length ? intervals[nextRetry] : intervals[intervals.length - 1];
|
|
log.info("安排业务回调重试，订单ID: {}, 第{}次重试，延迟{}分钟",
|
callbackLog.getOrderId(), nextRetry, delayMinutes);
|
|
// TODO: 使用定时任务或延迟队列实现重试
|
// 这里简化处理，实际应使用 @Scheduled 或消息队列
|
}
|
|
/**
|
* 手工重发回调
|
*/
|
public void resendCallback(Long orderId) {
|
// TODO: 实现手工重发逻辑
|
log.info("手工重发业务回调，订单ID: {}", orderId);
|
}
|
}
|
