关键设计原则
-
分离关注点：将并行计算与事务操作分离
-
补偿机制：为并行操作设计回滚策略
-
资源预留：先预占资源，再事务确认
-
超时控制：为并行操作设置合理的超时时间
-
结果聚合：统一处理并行操作的结果
-
优雅降级：部分失败时的处理策略
案例1：分阶段事务处理模式
@Service
public class OrderProcessService {
@Autowired
private OrderRepository orderRepository;
@Autowired
private InventoryService inventoryService;
@Autowired
private TransactionTemplate transactionTemplate;
/**
* 阶段1：并行验证（无事务）
*/
public ValidationResult parallelValidateOrders(List<Order> orders) {
List<CompletableFuture<OrderValidation>> futures = orders.stream()
.map(order -> CompletableFuture.supplyAsync(() -> validateOrder(order)))
.collect(Collectors.toList());
List<OrderValidation> validations = futures.stream()
.map(CompletableFuture::join)
.collect(Collectors.toList());
return new ValidationResult(validations);
}
/**
* 阶段2：事务性批量处理
*/
@Transactional
public BatchProcessResult processValidatedOrders(List<Order> validOrders) {
// 批量库存扣减
inventoryService.batchDeductInventory(validOrders);
// 批量订单状态更新
orderRepository.batchUpdateOrderStatus(validOrders, OrderStatus.PROCESSED);
// 生成处理结果
return new BatchProcessResult(validOrders.size(), System.currentTimeMillis());
}
private OrderValidation validateOrder(Order order) {
// 并行执行的验证逻辑
boolean valid = inventoryService.checkStock(order.getProductId(), order.getQuantity())
&& creditService.validateCredit(order.getCustomerId(), order.getAmount());
return new OrderValidation(order.getId(), valid, valid ? "SUCCESS" : "VALIDATION_FAILED");
}
}
案例2：补偿事务模式
@Service
public class DistributedTransactionService {
@Autowired
private UserService userService;
@Autowired
private OrderService orderService;
@Autowired
private PointService pointService;
/**
* 分布式事务：用户下单 + 扣积分
*/
public TransactionResult createOrderWithCompensation(OrderCreateRequest request) {
List<Operation> operations = new ArrayList<>();
String transactionId = generateTransactionId();
try {
// 步骤1：创建订单（独立事务）
Operation orderOp = executeWithTransaction(() ->
orderService.createOrder(request), "CREATE_ORDER");
operations.add(orderOp);
// 步骤2：并行执行库存和积分操作
CompletableFuture<Operation> inventoryFuture = CompletableFuture.supplyAsync(() ->
executeWithTransaction(() ->
inventoryService.lockInventory(request.getItems()), "LOCK_INVENTORY"));
CompletableFuture<Operation> pointFuture = CompletableFuture.supplyAsync(() ->
executeWithTransaction(() ->
pointService.deductPoints(request.getUserId(), request.getUsedPoints()), "DEDUCT_POINTS"));
// 等待所有并行操作完成
Operation inventoryOp = inventoryFuture.get(10, TimeUnit.SECONDS);
Operation pointOp = pointFuture.get(10, TimeUnit.SECONDS);
operations.add(inventoryOp);
operations.add(pointPoint);
// 所有操作成功，提交事务
return new TransactionResult(transactionId, true, "SUCCESS", operations);
} catch (Exception e) {
// 执行补偿操作
compensateOperations(operations);
return new TransactionResult(transactionId, false, "FAILED: " + e.getMessage(), operations);
}
}
private void compensateOperations(List<Operation> operations) {
operations.parallelStream().forEach(op -> {
switch (op.getType()) {
case "CREATE_ORDER":
executeWithTransaction(() -> orderService.cancelOrder(op.getReferenceId()));
break;
case "LOCK_INVENTORY":
executeWithTransaction(() -> inventoryService.unlockInventory(op.getReferenceId()));
break;
case "DEDUCT_POINTS":
executeWithTransaction(() -> pointService.refundPoints(op.getReferenceId()));
break;
}
});
}
private <T> Operation executeWithTransaction(Supplier<T> operation, String type) {
return transactionTemplate.execute(status -> {
try {
T result = operation.get();
return new Operation(type, result.toString(), true);
} catch (Exception e) {
status.setRollbackOnly();
return new Operation(type, null, false, e.getMessage());
}
});
}
}
案例3：批量数据分片处理
@Service
public class BatchDataProcessor {
private static final int BATCH_SIZE = 100;
private static final int THREAD_POOL_SIZE = 4;
@Autowired
private DataRepository dataRepository;
@Autowired
private TransactionTemplate transactionTemplate;
private final ExecutorService executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
/**
* 大数据量分片并行处理
*/
public BatchProcessResult processLargeDataset(List<DataRecord> records) {
// 数据分片
List<List<DataRecord>> chunks = partitionData(records, BATCH_SIZE);
// 并行处理每个分片
List<CompletableFuture<ChunkResult>> futures = chunks.stream()
.map(chunk -> CompletableFuture.supplyAsync(() -> processChunk(chunk), executor))
.collect(Collectors.toList());
// 汇总结果
List<ChunkResult> results = futures.stream()
.map(CompletableFuture::join)
.collect(Collectors.toList());
return aggregateResults(results);
}
private ChunkResult processChunk(List<DataRecord> chunk) {
return transactionTemplate.execute(status -> {
try {
int successCount = 0;
int failureCount = 0;
List<String> errors = new ArrayList<>();
for (DataRecord record : chunk) {
try {
// 业务处理逻辑
processSingleRecord(record);
successCount++;
} catch (Exception e) {
failureCount++;
errors.add(record.getId() + ": " + e.getMessage());
// 根据业务需求决定是否继续处理当前分片
if (shouldRollbackChunk(e)) {
throw e; // 触发事务回滚
}
}
}
return new ChunkResult(successCount, failureCount, errors);
} catch (Exception e) {
status.setRollbackOnly();
return new ChunkResult(0, chunk.size(), List.of("Chunk failed: " + e.getMessage()));
}
});
}
private List<List<DataRecord>> partitionData(List<DataRecord> records, int batchSize) {
List<List<DataRecord>> chunks = new ArrayList<>();
for (int i = 0; i < records.size(); i += batchSize) {
chunks.add(records.subList(i, Math.min(i + batchSize, records.size())));
}
return chunks;
}
}
案例4：事件驱动的事务模式
@Service
@Transactional
public class EventDrivenTransactionService {
@Autowired
private ApplicationEventPublisher eventPublisher;
@Autowired
private OrderRepository orderRepository;
@Autowired
private TransactionSynchronizationManager transactionManager;
/**
* 事务提交后执行并行操作
*/
public void createOrderWithAsyncPostProcessing(Order order) {
// 主事务操作
orderRepository.save(order);
// 注册事务同步，在事务提交后执行
TransactionSynchronizationManager.registerSynchronization(
new TransactionSynchronizationAdapter() {
@Override
public void afterCommit() {
// 事务提交后并行执行后续操作
CompletableFuture.runAsync(() -> sendNotifications(order));
CompletableFuture.runAsync(() -> updateSearchIndex(order));
CompletableFuture.runAsync(() -> syncToDataWarehouse(order));
}
}
);
}
private void sendNotifications(Order order) {
// 发送邮件、短信等通知
notificationService.sendOrderConfirmation(order);
notificationService.sendToCustomerService(order);
}
private void updateSearchIndex(Order order) {
// 更新搜索索引
searchService.indexOrder(order);
}
private void syncToDataWarehouse(Order order) {
// 同步到数据仓库
dataWarehouseService.syncOrder(order);
}
}
案例5：资源预留模式
@Service
public class ResourceReservationService {
/**
* 阶段1：并行资源预留
*/
public ReservationResult reserveResources(OrderRequest request) {
List<CompletableFuture<Reservation>> futures = Arrays.asList(
CompletableFuture.supplyAsync(() ->
inventoryService.reserve(request.getProductId(), request.getQuantity())),
CompletableFuture.supplyAsync(() ->
couponService.reserve(request.getUserId(), request.getCouponCode())),
CompletableFuture.supplyAsync(() ->
shippingService.reserveSlot(request.getAddress(), request.getDeliveryDate()))
);
// 等待所有预留完成
List<Reservation> reservations = futures.stream()
.map(CompletableFuture::join)
.collect(Collectors.toList());
return new ReservationResult(reservations);
}
/**
* 阶段2：事务性确认
*/
@Transactional
public ConfirmResult confirmResources(ReservationResult reservation) {
try {
// 在事务中确认所有预留
reservation.getReservations().forEach(res -> {
switch (res.getType()) {
case "INVENTORY":
inventoryService.confirm(res.getReservationId());
break;
case "COUPON":
couponService.confirm(res.getReservationId());
break;
case "SHIPPING":
shippingService.confirm(res.getReservationId());
break;
}
});
// 创建订单
Order order = orderService.createOrder(reservation);
return new ConfirmResult(true, order.getId(), "SUCCESS");
} catch (Exception e) {
// 失败时取消所有预留
cancelReservations(reservation);
throw e;
}
}
}
扫一扫
1308
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
