流水记录优化

This commit is contained in:
lu7213 committed 2026-10-14 04:47:06 -04:00
1 parent dcd8eadd20
commit abdafd5c9d
11 files changed
+238 -28

No files matched your search

@@ -37,6 +37,8 @@ public interface AppsBalanceLedgerMapper extends BaseMapper<AppsBalanceLedgerPlu
/** 系统业务幂等写入,重复幂等键不生成新流水。 */
int insertSystemLedgerIgnoreDuplicate(AppsBalanceLedger ledger);
int countByIdempotencyKey(@Param("idempotencyKey") String idempotencyKey);
List<WalletLedgerSummaryVo> selectStatisticsSummary(AppsLedgerStatisticsQuery query);
List<WalletLedgerTrendVo> selectStatisticsTrend(AppsLedgerStatisticsQuery query);
@@ -17,11 +17,18 @@ public interface UsdtOrdersMapper extends BaseMapper<UsdtOrdersPlus>
{
UsdtOrdersPlus selectByIdForUpdate(@Param("id") Long id);
int countPaidByTransactionId(@Param("transactionId") String transactionId,
@Param("excludeOrderId") Long excludeOrderId);
int countByTransactionId(@Param("transactionId") String transactionId,
@Param("excludeOrderId") Long excludeOrderId);
/** 在独立事务中记录链上已确认交易,订单仍保持待支付状态等待账务结算。 */
int markPaymentDetected(@Param("id") Long id, @Param("transactionId") String transactionId,
@Param("updatedAt") java.util.Date updatedAt);
int markOrderPaid(@Param("id") Long id, @Param("transactionId") String transactionId,
@Param("updatedAt") java.util.Date updatedAt);
/** 查询链上已确认待结算或已支付但流水不完整的订单,用于后台幂等补偿。 */
List<Long> selectOrderIdsRequiringSettlement(@Param("limit") int limit);
/**
* 查询订单
*
@@ -37,6 +37,8 @@ public interface WalletAddressLedgerMapper extends BaseMapper<WalletAddressLedge
/** 由系统业务链路幂等写入流水,重复幂等键不产生新记录。 */
int insertSystemLedgerIgnoreDuplicate(WalletAddressLedger walletAddressLedger);
int countByIdempotencyKey(@Param("idempotencyKey") String idempotencyKey);
List<WalletLedgerSummaryVo> selectStatisticsSummary(WalletLedgerStatisticsQuery query);
List<WalletLedgerTrendVo> selectStatisticsTrend(WalletLedgerStatisticsQuery query);
@@ -134,6 +134,8 @@ public class PaymentOrderOpenApiService {
UsdtOrdersPlus previous = ordersMapper.selectOne(new LambdaQueryWrapper<UsdtOrdersPlus>()
.eq(UsdtOrdersPlus::getAppId, appId).eq(UsdtOrdersPlus::getToken, token)
.eq(UsdtOrdersPlus::getActualAmount, amount).eq(UsdtOrdersPlus::getStatus, 1L)
.and(wrapper -> wrapper.isNull(UsdtOrdersPlus::getBlockTransactionId)
.or().eq(UsdtOrdersPlus::getBlockTransactionId, ""))
.isNull(UsdtOrdersPlus::getDeletedAt).orderByDesc(UsdtOrdersPlus::getId).last("limit 1"));
if (previous == null) return null;
previous.setStatus(3L);
@@ -17,10 +17,12 @@ import com.ruoyi.system.mapper.WalletAddressLedgerMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.support.TransactionSynchronization;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import java.util.Date;
import java.util.List;
import java.math.BigDecimal;
/**
@@ -63,28 +65,121 @@ public class WalletLedgerPostingService {
/** 将待支付订单结算为成功,同一订单重复扫描不会重复产生流水。 */
@Transactional(rollbackFor = Exception.class)
public boolean settlePaidOrder(Long orderId, String transactionId) {
if (transactionId == null || transactionId.trim().isEmpty()) {
throw new CustomException("链上交易哈希不能为空");
}
UsdtOrdersPlus order = ordersMapper.selectByIdForUpdate(orderId);
if (order == null) {
throw new CustomException("订单不存在");
}
return settleLockedOrder(order, transactionId);
}
private boolean settleLockedOrder(UsdtOrdersPlus order, String transactionId) {
if (Long.valueOf(STATUS_PAID).equals(order.getStatus())) {
log.warn("订单已经支付 {}",orderId);
return transactionId.equals(order.getBlockTransactionId());
if (order.getBlockTransactionId() == null
|| (transactionId != null && !transactionId.equals(order.getBlockTransactionId()))) {
return false;
}
ensureOrderLedgers(order, order.getBlockTransactionId(), DateUtils.getNowDate());
return true;
}
if (!Long.valueOf(STATUS_PENDING).equals(order.getStatus())) {
log.warn("订单状态不正确 {}",orderId);
log.warn("订单状态不正确 {}", order.getId());
return false;
}
if (ordersMapper.countPaidByTransactionId(transactionId, orderId) > 0) {
log.warn("订单transactionId已经存在 {}",orderId);
String detectedTransactionId = order.getBlockTransactionId();
if (detectedTransactionId != null && !detectedTransactionId.trim().isEmpty()
&& !detectedTransactionId.equals(transactionId)) {
log.warn("订单已绑定其他链上交易,订单ID={}", order.getId());
return false;
}
if (ordersMapper.countByTransactionId(transactionId, order.getId()) > 0) {
log.warn("订单transactionId已经存在 {}", order.getId());
return false;
}
WalletAddressPlus wallet = walletService.getByTokenAndAppId(order.getToken(), order.getAppId());
Date now = DateUtils.getNowDate();
ensureOrderLedgers(order, transactionId, now);
if (ordersMapper.markOrderPaid(order.getId(), transactionId, now) != 1) {
return false;
}
releasePaymentSlotAfterCommit(order);
return true;
}
/**
* 先于账务结算独立保存链上交易哈希。即使后续流水写入失败,补偿任务仍可准确重试,
* 不再依赖 TronScan 下一轮仍返回同一笔交易。
*/
@Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
public boolean recordDetectedPayment(Long orderId, String transactionId) {
if (orderId == null || transactionId == null || transactionId.trim().isEmpty()) {
return false;
}
UsdtOrdersPlus order = ordersMapper.selectByIdForUpdate(orderId);
if (order == null || !Long.valueOf(STATUS_PENDING).equals(order.getStatus())) {
return false;
}
String existing = order.getBlockTransactionId();
if (existing != null && !existing.trim().isEmpty()) {
return existing.equals(transactionId);
}
if (ordersMapper.countByTransactionId(transactionId, orderId) > 0) {
log.warn("链上交易已绑定其他订单,订单ID={}", orderId);
return false;
}
return ordersMapper.markPaymentDetected(orderId, transactionId, DateUtils.getNowDate()) == 1;
}
/** 修复已经支付但流水不完整的订单;该方法可安全重复执行。 */
@Transactional(rollbackFor = Exception.class)
public boolean repairPaidOrderLedgers(Long orderId) {
UsdtOrdersPlus order = ordersMapper.selectByIdForUpdate(orderId);
if (order == null || !Long.valueOf(STATUS_PAID).equals(order.getStatus())
|| order.getBlockTransactionId() == null
|| order.getBlockTransactionId().trim().isEmpty()) {
return false;
}
ensureOrderLedgers(order, order.getBlockTransactionId(), DateUtils.getNowDate());
return true;
}
/** 结算已持久化链上交易的待支付订单,或补齐已支付订单缺失流水。 */
@Transactional(rollbackFor = Exception.class)
public boolean settleDetectedOrRepairPaidOrder(Long orderId) {
UsdtOrdersPlus order = ordersMapper.selectByIdForUpdate(orderId);
if (order == null || order.getBlockTransactionId() == null
|| order.getBlockTransactionId().trim().isEmpty()) {
return false;
}
if (!Long.valueOf(STATUS_PENDING).equals(order.getStatus())
&& !Long.valueOf(STATUS_PAID).equals(order.getStatus())) {
return false;
}
return settleLockedOrder(order, order.getBlockTransactionId());
}
public List<Long> findOrderIdsRequiringSettlement(int limit) {
int safeLimit = Math.max(1, Math.min(limit, 500));
return ordersMapper.selectOrderIdsRequiringSettlement(safeLimit);
}
private void ensureOrderLedgers(UsdtOrdersPlus order, String transactionId, Date now) {
ensureWalletOrderLedger(order, transactionId, now);
postOrderToAppBalance(order, transactionId, now);
}
private void ensureWalletOrderLedger(UsdtOrdersPlus order, String transactionId, Date now) {
String idempotencyKey = "ORDER_RECEIVE:" + order.getId() + ":USDT";
if (ledgerMapper.countByIdempotencyKey(idempotencyKey) > 0) {
return;
}
WalletAddressPlus wallet = walletService.getByTokenAndAppId(order.getToken(), order.getAppId());
WalletAddressLedger ledger = baseLedger(now);
ledger.setTradeNo(order.getTradeId());
ledger.setIdempotencyKey("ORDER_RECEIVE:" + order.getId() + ":USDT");
ledger.setIdempotencyKey(idempotencyKey);
ledger.setAppId(order.getAppId());
ledger.setUserId(order.getUserId());
ledger.setWalletAddressId(wallet == null ? null : wallet.getId());
@@ -99,14 +194,9 @@ public class WalletLedgerPostingService {
ledger.setTransactionId(transactionId);
ledger.setSourceType("ORDER");
ledger.setRemark("订单支付成功");
ledgerMapper.insertSystemLedgerIgnoreDuplicate(ledger);
postOrderToAppBalance(order, transactionId, now);
if (ordersMapper.markOrderPaid(order.getId(), transactionId, now) != 1) {
return false;
if (ledgerMapper.insertSystemLedgerIgnoreDuplicate(ledger) != 1) {
throw new CustomException("钱包订单流水写入失败");
}
releasePaymentSlotAfterCommit(order);
return true;
}
/** 数据库确认支付事务提交后再释放 Redis 槽位,避免回滚时提前开放相同地址和金额。 */
@@ -132,6 +222,13 @@ public class WalletLedgerPostingService {
if (app == null) {
throw new CustomException("订单所属应用不存在");
}
String receiveKey = "ORDER_RECEIVE:" + order.getId() + ":USDT";
String feeKey = "ORDER_FEE:" + order.getId() + ":TRX";
boolean needReceive = appsLedgerMapper.countByIdempotencyKey(receiveKey) == 0;
boolean needFee = appsLedgerMapper.countByIdempotencyKey(feeKey) == 0;
if (!needReceive && !needFee) {
return;
}
UsdtConfig config = configMapper.selectFirstForUpdate();
if (config == null || config.getReceiveUsdtNum() == null) {
throw new CustomException("全局配置未设置订单代收手续费");
@@ -143,17 +240,21 @@ public class WalletLedgerPostingService {
BigDecimal usdtBefore = zeroIfNull(app.getUsdtBalance());
BigDecimal trxBefore = zeroIfNull(app.getTrxBalance());
BigDecimal usdtAfter = usdtBefore.add(order.getActualAmount());
BigDecimal trxAfter = trxBefore.subtract(fee);
BigDecimal usdtAfter = needReceive ? usdtBefore.add(order.getActualAmount()) : usdtBefore;
BigDecimal trxAfter = needFee ? trxBefore.subtract(fee) : trxBefore;
BigDecimal usdtFrozen = zeroIfNull(app.getUsdtFrozenBalance());
BigDecimal trxFrozen = zeroIfNull(app.getTrxFrozenBalance());
appsLedgerMapper.insertSystemLedgerIgnoreDuplicate(buildAppLedger(order, transactionId,
"ORDER_RECEIVE", "USDT", 1, order.getActualAmount(), usdtBefore, usdtAfter,
usdtFrozen, "订单代收到账", now, app.getUserId()));
appsLedgerMapper.insertSystemLedgerIgnoreDuplicate(buildAppLedger(order, transactionId,
"ORDER_FEE", "TRX", 2, fee, trxBefore, trxAfter,
trxFrozen, "订单代收手续费", now, app.getUserId()));
if (needReceive && appsLedgerMapper.insertSystemLedgerIgnoreDuplicate(buildAppLedger(
order, transactionId, "ORDER_RECEIVE", "USDT", 1, order.getActualAmount(),
usdtBefore, usdtAfter, usdtFrozen, "订单代收到账", now, app.getUserId())) != 1) {
throw new CustomException("应用订单收入流水写入失败");
}
if (needFee && appsLedgerMapper.insertSystemLedgerIgnoreDuplicate(buildAppLedger(
order, transactionId, "ORDER_FEE", "TRX", 2, fee, trxBefore, trxAfter,
trxFrozen, "订单代收手续费", now, app.getUserId())) != 1) {
throw new CustomException("应用订单手续费流水写入失败");
}
if (appsMapper.updateAvailableBalances(app.getId(), usdtAfter, trxAfter, now) != 1) {
throw new CustomException("应用余额更新失败");