Spring事件驱动架构详解
目录
Spring事件机制概述
事件驱动架构优势
Spring事件机制提供了松耦合的组件间通信解决方案：
核心优势：
- 松耦合：发布者和监听者之间无直接依赖
- 可扩展性：支持多个监听器处理同一事件
- 异步处理：支持异步事件处理提高性能
- 事务集成：与Spring事务机制完美集成
事件处理流程
事件发布 → ApplicationEventPublisher → 事件监听器 → 业务处理
↓ ↓ ↓
异步处理 ← 事件广播器 ← 事件源 ← 领域事件 ← 持久化
基础配置
事件配置类：
@Configuration
@EnableAsync
@EnableScheduling
public class EventConfig {
@Bean
public TaskExecutor eventTaskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(5);
executor.setMaxPoolSize(20);
executor.setQueueCapacity(100);
executor.setThreadNamePrefix("Event-");
executor.setWaitForTasksToCompleteOnShutdown(true);
executor.setAwaitTerminationSeconds(60);
executor.initialize();
return executor;
}
@Bean
public ApplicationEventMulticaster simpleApplicationEventMulticaster() {
SimpleApplicationEventMulticaster multicast = new SimpleApplicationEventMulticaster();
multicast.setTaskExecutor(eventTaskExecutor());
multicast.setErrorHandler(new EventErrorHandler());
return multicast;
}
}
ApplicationEvent基础
内置事件类型
Spring框架内置事件：
@Component
public class FrameworkEventListeners {
private static final Logger logger = LoggerFactory.getLogger(FrameworkEventListeners.class);
@EventListener
public void onApplicationStarted(ContextRefreshedEvent event) {
logger.info("应用程序启动完成: {}", event.getSource().getClass().getName());
// 应用启动后的初始化操作
initializeApplicationData();
}
@EventListener
public void onApplicationReady(ApplicationReadyEvent event) {
logger.info("应用程序准备就绪，所有组件已加载完成");
// 发送应用就绪通知
sendApplicationReadyNotification();
}
@EventListener
public void onContextClosed(ContextClosedEvent event) {
logger.info("应用程序上下文正在关闭");
// 清理资源
cleanupResources();
}
@EventListener
public void onContextFailed(ContextFailedEvent event) {
logger.error("应用程序上下文启动失败: ", event.getException());
// 错误处理
handleContextFailure(event.getException());
}
private void initializeApplicationData() {
// 缓存预热
cacheService.warmUpCache();
// 定时任务启动
scheduledTaskService.startAllTasks();
// 外部资源检查
healthIndicator.checkExternalServices();
}
private void sendApplicationReadyNotification() {
// 发送应用就绪消息
notificationService.sendApplicationReadyAlert();
// 启动后台服务
backgroundService.startAllServices();
}
private void cleanupResources() {
// 优雅关闭数据连接
connectionPool.closeAllConnections();
// 清理临时文件
fileService.cleanupTempFiles();
// 保存应用状态
applicationStateRepository.saveApplicationState();
}
}
通用事件基类
事件基类定义：
@Getter
@NoArgsConstructor
public abstract class BaseDomainEvent extends ApplicationEvent {
private final String eventId;
private final String eventType;
private final LocalDateTime eventTime;
private final String userId;
private final String correlationId;
private final Map<String, Object> metadata;
protected BaseDomainEvent(Object source, String userId, Map<String, Object> metadata) {
super(source);
this.eventId = UUID.randomUUID().toString();
this.eventType = this.getClass().getSimpleName();
this.eventTime = LocalDateTime.now();
this.userId = userId;
this.correlationId = generateCorrelationId();
this.metadata = metadata != null ? metadata : new HashMap<>();
}
protected BaseDomainEvent(Object source, String userId) {
this(source, userId, null);
}
protected BaseDomainEvent(Object source) {
this(source, SecurityUtils.getCurrentUserId(), null);
}
private String generateCorrelationId() {
return MDC.get("correlationId");
}
public String getDescription() {
StringBuilder sb = new StringBuilder();
sb.append("Event[");
sb.append("id=").append(eventId);
sb.append(", type=").append(eventType);
sb.append(", time=").append(eventTime);
sb.append(", userId=").append(userId);
sb.append("]");
return sb.toString();
}
public Object getMetadataValue(String key) {
return metadata.get(key);
}
public void addMetadata(String key, Object value) {
metadata.put(key, value);
}
}
异步事件处理
异步事件监听器
异步事件监听实现：
@Component
public class AsyncEventListeners {
private static final Logger logger = LoggerFactory.getLogger(AsyncEventListeners.class);
@Autowired
private EmailService emailService;
@Autowired
private SmsService smsService;
@Autowired
private PushNotificationService pushNotificationService;
@Autowired
private AuditLogService auditLogService;
// 用户注册事件异步处理
@Async("eventTaskExecutor")
@EventListener
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void handleUserRegistered(UserRegisteredEvent event) {
logger.info("处理用户注册事件: {}", event.getDescription());
try {
// 发送欢迎邮件
sendWelcomeEmail(event);
// 发送欢迎短信
sendWelcomeSms(event);
// 创建用户档案
createUserProfile(event);
// 分配合适权限
assignDefaultPermissions(event);
logger.info("用户注册事件处理完成: userId={}", event.getUserId());
} catch (Exception e) {
logger.error("用户注册事件处理失败: userId=" + event.getUserId(), e);
handleEventProcessingError(event, e);
}
}
// 订单创建事件异步处理
@Async("eventTaskExecutor")
@EventListener
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void handleOrderCreated(OrderCreatedEvent event) {
logger.info("处理订单创建事件: {}", event.getDescription());
try {
// 发送订单确认邮件
sendOrderConfirmationEmail(event);
// 发送订单通知短信
sendOrderNotificationSms(event);
// 更新商品库存
updateProductInventory(event);
// 触发支付流程
if (event.getOrder().getPaymentMethod() == PaymentMethod.ONLINE) {
triggerPaymentProcess(event);
}
// 生成发货计划
scheduleDelivery(event);
// 记录审计日志
auditLogService.logOrderCreated(new AuditLogEntry()
.setAction("ORDER_CREATED")
.setEntityType("Order")
.setEntityId(event.getOrder().getId())
.setUserId(event.getUserId())
.setDetails(event.getMetadata()));
logger.info("订单创建事件处理完成: orderId={}", event.getOrder().getId());
} catch (Exception e) {
logger.error("订单创建事件处理失败: orderId=" + event.getOrder().getId(), e);
handleEventProcessingError(event, e);
}
}
// 支付状态变更事件处理
@Async("eventTaskExecutor")
@EventListener
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void handlePaymentStatusChanged(PaymentStatusChangedEvent event) {
logger.info("处理支付状态变更事件: {}", event.getDescription());
try {
switch (event.getNewStatus()) {
case SUCCESS:
handlePaymentSuccess(event);
break;
case FAILED:
handlePaymentFailed(event);
break;
case REFUNDED:
handlePaymentRefunded(event);
break;
case CANCELLED:
handlePaymentCancelled(event);
break;
}
// 发送状态变更通知
sendPaymentStatusNotification(event);
logger.info("支付状态变更事件处理完成: paymentId={}", event.getPaymentId());
} catch (Exception e) {
logger.error("支付状态变更事件处理失败: paymentId=" + event.getPaymentId(), e);
handleEventProcessingError(event, e);
}
}
private void sendWelcomeEmail(UserRegisteredEvent event) {
EmailTemplate template = EmailTemplate.WELCOME;
Map<String, Object> variables = Map.of(
"username", event.getUsername(),
"firstName", event.getFirstName(),
"loginUrl", applicationConfig.getLoginUrl()
);
emailService.sendTemplateEmail(
event.getEmail(),
template.getSubject(),
template.getName(),
variables
);
}
private void sendWelcomeSms(UserRegisteredEvent event) {
SmsTemplate template = SmsTemplate.WELCOME;
Map<String, Object> variables = Map.of(
"username", event.getUsername(),
"platform", applicationConfig.getAppName()
);
smsService.sendTemplateSms(
event.getPhone(),
template.getName(),
variables
);
}
private void handlePaymentSuccess(PaymentStatusChangedEvent event) {
// 更新订单状态为已支付
orderService.updateOrderStatus(event.getOrderId(), OrderStatus.PAID);
// 触发发货流程
fulfillmentService.processPaymentSuccess(event.getOrderId());
// 更新财务报表
financialReportService.recordPayment(event.getPaymentId());
// 积分奖励
loyaltyService.addPoints(event.getUserId(), calculatePoints(event.getAmount()));
}
private void handlePaymentFailed(PaymentStatusChangedEvent event) {
// 释放商品库存
inventoryService.releaseReservedInventory(event.getOrderId());
// 发送支付失败通知
notificationService.sendPaymentFailedNotification(event.getUserId(), event.getOrderId());
// 记录失败原因
paymentFailureService.logFailure(event.getPaymentId(), event.getFailureReason());
// 更新订单状态为支付失败
orderService.updateOrderStatus(event.getOrderId(), OrderStatus.PAYMENT_FAILED);
}
private void handleEventProcessingError(BaseDomainEvent event, Exception error) {
// 将失败的事件放入重试队列
retryEventService.enqueueForRetry(event, error);
// 发送告警通知
alertService.sendEventProcessingFailureAlert(event, error);
// 记录失败事件
failedEventRepository.save(FailedEventEntity.builder()
.eventId(event.getEventId())
.eventType(event.getEventType())
.eventData(JsonUtils.toJson(event))
.errorMessage(error.getMessage())
.stackTrace(ExceptionUtils.getStackTrace(error))
.retryCount(0)
.createdTime(LocalDateTime.now())
.build());
}
}
自定义异步执行器
任务执行器配置：
@Configuration
public class AsyncExecutorConfig {
@Bean("mailTaskExecutor")
public TaskExecutor mailTaskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(3);
executor.setMaxPoolSize(10);
executor.setQueueCapacity(50);
executor.setThreadNamePrefix("Mail-");
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
executor.setWaitForTasksToCompleteOnShutdown(true);
executor.setAwaitTerminationSeconds(30);
executor.initialize();
return executor;
}
@Bean("smsTaskExecutor")
public TaskExecutor smsTaskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(2);
executor.setMaxPoolSize(8);
executor.setQueueCapacity(30);
executor.setThreadNamePrefix("SMS-");
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
executor.initialize();
return executor;
}
@Bean("notificationTaskExecutor")
public TaskExecutor notificationTaskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(4);
executor.setMaxPoolSize(12);
executor.setQueueCapacity(100);
executor.setThreadNamePrefix("Notification-");
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());
executor.initialize();
return executor;
}
}
// 专用邮件事件处理器
@Component
public class MailEventProcessor {
@Async("mailTaskExecutor")
@EventListener
public void processEmailEvent(EmailEvent event) {
// 邮件事件专用处理
mailService.sendEmail(event.getEmailRequest());
}
}
// 专用短信事件处理器
@Component
public class SmsEventProcessor {
@Async("smsTaskExecutor")
@EventListener
public void processSmsEvent(SmsEvent event) {
// 短信事件专用处理
smsService.sendSms(event.getSmsRequest());
}
}
事件监听器实现
基于条件的事件监听
条件事件监听器：
@Component
public class ConditionalEventListeners {
@Autowired
private OrderService orderService;
@Autowired
private UserService userService;
@Autowired
private NotificationService notificationService;
// 根据事件元数据条件监听
@EventListener(condition = "#event.eventType == 'OrderCreatedEvent' and #event.metadata['urgency'] == 'HIGH'")
public void handleUrgentOrderCreated(BaseDomainEvent event) {
logger.info("处理高优先级订单创建事件");
// 高优先级订单特殊处理
notificationService.sendUrgentOrderAlert(event.getMetadata());
// 分配专门的处理团队
orderService.assignToPriorityTeam(event.getMetadata().get("orderId").toString());
}
// 根据用户类型条件监听
@EventListener(condition = "#event.userType == T(com.ecommerce.enums.UserType).VIP")
public void handleVipUserEvent(BaseDomainEvent event) {
logger.info("处理VIP用户事件: {}", event.getEventType());
// VIP用户特殊待遇
provideVipBenefits(event);
// 专属客服
assignVipCustomerService(event);
}
// 根据时间条件监听
@EventListener(condition = "@dailySchedule.isBusinessHour() and #event.eventTime.hour >= 9 and #event.eventTime.hour <= 18")
public void handleBusinessHourEvent(BaseDomainEvent event) {
logger.info("工作时间事件处理");
// 工作时间内的特殊处理逻辑
processBusinessHourEvent(event);
}
// 根据事件来源条件监听
@EventListener(condition = "#event.source != null and 'OrderService'.equals(T(java.lang.String).valueOf(#event.source).split('@')[0])")
public void handleOrderServiceEvent(BaseDomainEvent event) {
logger.info("订单服务相关事件处理");
// 记录订单服务事件指标
orderMetricsService.incrementEventCounter(event.getEventType());
}
private void provideVipBenefits(BaseDomainEvent event) {
Map<String, Object> vipMetadata = event.getMetadata();
vipMetadata.put("freeShipping", true);
vipMetadata.put("priorityProcessing", true);
vipMetadata.put("extendedWarranty", true);
}
private void assignVipCustomerService(BaseDomainEvent event) {
CustomerServiceAssignment assignment = CustomerServiceAssignment.builder()
.userId(event.getUserId())
.priority(CustomerServicePriority.VIP)
.teamType(CustomerServiceTeam.PREMIUM)
.assignedTime(LocalDateTime.now())
.build();
customerServiceService.assignVipService(assignment);
}
}
事件监听器优先级
优先级事件监听器：
@Configuration
public class EventListenerPriorityConfig {
// 高优先级事件监听器
@Order(Ordered.HIGHEST_PRECEDENCE)
@Component
public class HighPriorityEventListener {
@EventListener(UserDataChangedEvent.class)
public void handleUserDataChangeFirst(UserDataChangedEvent event) {
logger.info("高优先级处理用户数据变更事件");
// 关键业务逻辑处理
validateUserDataChange(event);
// 安全检查
performSecurityCheck(event);
}
private void validateUserDataChange(UserDataChangedEvent event) {
// 数据完整性检查
if (!userValidationService.isDataValid(event.getUserData())) {
throw new IllegalStateException("用户数据验证失败");
}
}
private void performSecurityCheck(UserDataChangedEvent event) {
// 敏感数据变更的安全检查
if (containsSensitiveData(event.getChangedFields())) {
securityAuditService.logSensitiveDataChange(event);
}
}
}
// 中等优先级事件监听器
@Order(Ordered.DEFAULT_PRECEDENCE)
@Component
public class MediumPriorityEventListener {
@EventListener(UserDataChangedEvent.class)
public void handleUserDataChangeSecond(UserDataChangedEvent event) {
logger.info("中优先级处理用户数据变更事件");
// 业务逻辑处理
updateRelatedEntities(event);
// 缓存更新
invalidateRelatedCaches(event);
}
private void updateRelatedEntities(UserDataChangedEvent event) {
// 更新相关实体
userRelationService.updateUserRelations(event.getUserId());
userPreferenceService.updatePreferences(event.getUserId());
}
private void invalidateRelatedCaches(UserDataChangedEvent event) {
// 清理相关缓存
cacheService.invalidateUserCache(event.getUserId());
cacheService.invalidateUserProfileCache(event.getUserId());
}
}
// 低优先级事件监听器
@Order(Ordered.LOWEST_PRECEDENCE)
@Component
public class LowPriorityEventListener {
@EventListener(UserDataChangedEvent.class)
public void handleUserDataChangeLast(UserDataChangedEvent event) {
logger.info("低优先级处理用户数据变更事件");
// 统计和分析
analyticsService.recordUserChange(event);
// 报告生成
reportService.generateUserActivityReport(event);
// 第三方系统同步
thirdPartySyncService.syncUserData(event);
}
}
}
自定义事件类型
业务事件定义
订单相关事件：
public class OrderCreatedEvent extends BaseDomainEvent {
private final Order order;
private final BigDecimal totalAmount;
private final List<OrderItem> items;
private final Address shippingAddress;
public OrderCreatedEvent(Object source, Order order) {
super(source, order.getUser().getId());
this.order = order;
this.totalAmount = order.getTotalAmount();
this.items = new ArrayList<>(order.getItems());
this.shippingAddress = order.getShippingAddress();
this.addMetadata("orderNumber", order.getOrderNumber());
this.addMetadata("paymentMethod", order.getPaymentMethod().name());
this.addMetadata("itemCount", order.getItems().size());
this.addMetadata("urgency", determineUrgency(order));
}
private String determineUrgency(Order order) {
// 根据订单特征确定紧急程度
if (order.getTotalAmount().compareTo(new BigDecimal("1000")) > 0) {
return "HIGH";
} else if (order.getItems().stream().anyMatch(item ->
productCategoryService.isExpressCategory(item.getProduct().getCategory()))) {
return "NORMAL";
} else {
return "LOW";
}
}
// getters
public Order getOrder() { return order; }
public BigDecimal getTotalAmount() { return totalAmount; }
public List<OrderItem> getItems() { return items; }
public Address getShippingAddress() { return shippingAddress; }
}
public class OrderStatusChangedEvent extends BaseDomainEvent {
private final Long orderId;
private final OrderStatus previousStatus;
private final OrderStatus currentStatus;
private final String reason;
private final String operatorId;
public OrderStatusChangedEvent(Object source, Long orderId,
OrderStatus previousStatus, OrderStatus currentStatus,
String reason, String operatorId) {
super(source, operatorId);
this.orderId = orderId;
this.previousStatus = previousStatus;
this.currentStatus = currentStatus;
this.reason = reason;
this.operatorId = operatorId;
this.addMetadata("orderId", orderId);
this.addMetadata("statusTransition", previousStatus.name() + " -> " + currentStatus.name());
this.addMetadata("changeReason", reason);
}
// getters
}
public class PaymentCompletedEvent extends BaseDomainEvent {
private final Long orderId;
private final Long paymentId;
private final String paymentMethod;
private final BigDecimal amount;
private final String transactionId;
public PaymentCompletedEvent(Object source, Order order, Payment payment) {
super(source, order.getUser().getId());
this.orderId = order.getId();
this.paymentId = payment.getId();
this.paymentMethod = payment.getMethod().name();
this.amount = payment.getAmount();
this.transactionId = payment.getTransactionId();
this.addMetadata("paymentProvider", payment.getProvider());
this.addMetadata("isRefundable", payment.isRefundable());
this.addMetadata("fraudRisk", payment.getFraudRiskLevel());
}
// getters
}
用户相关事件
用户生命周期事件：
public class UserRegisteredEvent extends BaseDomainEvent {
private final String username;
private final String email;
private final String phone;
private final String firstName;
private final String lastName;
private final String referralCode;
private final UserRegistrationSource registrationSource;
public UserRegisteredEvent(Object source, User user, String referralCode) {
super(source, user.getId().toString());
this.username = user.getUsername();
this.email = user.getEmail();
this.phone = user.getPhone();
this.firstName = user.getFirstName();
this.lastName = user.getLastName();
this.referralCode = referralCode;
this.registrationSource = determineRegistrationSource();
this.addMetadata("registrationIp", getCurrentUserIp());
this.addMetadata("registrationDevice", getUserAgent());
this.addMetadata("geographicRegion", getUserLocation());
}
private UserRegistrationSource determineRegistrationSource() {
// 根据来源渠道确定注册类型
String userAgent = getUserAgent();
if (userAgent.contains("Mobile")) {
return UserRegistrationSource.MOBILE_APP;
} else if (userAgent.contains("Tablet")) {
return UserRegistrationSource.TABLET_APP;
} else {
return UserRegistrationSource.WEB;
}
}
private String getCurrentUserIp() {
return RequestContextHolder.currentRequestAttributes()
.getAttribute("clientIp", RequestAttributes.SCOPE_REQUEST);
}
private String getUserAgent() {
return RequestContextHolder.currentRequestAttributes()
.getAttribute("userAgent", RequestAttributes.SCOPE_REQUEST);
}
private String getUserLocation() {
return locationService.getLocationByIp(getCurrentUserIp());
}
// getters
}
public class UserLoginEvent extends BaseDomainEvent {
private final String loginType; // PASSWORD, SMS, EMAIL_VERIFICATION
private final boolean isSuccessful;
private final String failureReason;
private final String ipAddress;
private final String userAgent;
private final String geographicalLocation;
private final boolean isNewDevice;
public UserLoginEvent(Object source, String userId, String loginType,
boolean isSuccessful, String failureReason) {
super(source, userId);
this.loginType = loginType;
this.isSuccessful = isSuccessful;
this.reason = failureReason;
this.ipAddress = getCurrentUserIp();
this.userAgent = getUserAgent();
this.geographicalLocation = getUserLocation();
this.isNewDevice = checkIsNewDevice();
this.addMetadata("loginTimestamp", LocalDateTime.now());
this.addMetadata("securityAttemp", !isSuccessful);
}
// getters
}
public class UserProfileUpdatedEvent extends BaseDomainEvent {
private final Set<String> changedFields;
private final Map<String, Object> oldValues;
private final Map<String, Object> newValues;
private final ProfileChangeCategory changeCategory;
private final boolean isVerifiedChange;
public UserProfileUpdatedEvent(Object source, String userId,
Set<String> changedFields,
Map<String, Object> oldValues,
Map<String, Object> newValues) {
super(source, userId);
this.changedFields = changedFields;
this.oldValues = oldValues;
this.newValues = newValues;
this.changeCategory = determineChangeCategory(changedFields);
this.isVerifiedChange = checkIfVerifiedChange(changedFields);
this.addMetadata("fieldsChanged", String.join(",", changedFields));
this.addMetadata("changeSeverity", determineChangeSeverity());
this.addMetadata("requiresNotification", requiresNotification());
}
private ProfileChangeCategory determineChangeCategory(Set<String> fields) {
if (fields.contains("email") || fields.contains("phone")) {
return ProfileChangeCategory.CONTACT_INFO;
} else if (fields.contains("address")) {
return ProfileChangeCategory.ADDRESS;
} else if (fields.contains("preferences")) {
return ProfileChangeCategory.PREFERENCES;
} else {
return ProfileChangeCategory.GENERAL;
}
}
private boolean checkIfVerifiedChange(Set<String> fields) {
// 检查是否为已验证的敏感字段变更
Set<String> sensitiveFields = Set.of("email", "phone", "bankAccount");
return fields.stream().anyMatch(sensitiveFields::contains);
}
private String determineChangeSeverity() {
Set<String> criticalFields = Set.of("email", "phone", "address", "idNumber");
return changedFields.stream().anyMatch(criticalFields::contains) ? "HIGH" : "NORMAL";
}
private boolean requiresNotification() {
return changeCategory != ProfileChangeCategory.GENERAL || isVerifiedChange;
}
// getters
}
事务事件处理
事务相关事件监听
事务事件处理机制：
@Component
public class TransactionalEventHandlers {
@Autowired
private OrderService orderService;
@Autowired
private InventoryService inventoryService;
// 在事务提交后处理事件
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void handleOrderCreatedAfterCommit(OrderCreatedEvent event) {
logger.info("事务提交后处理订单创建事件");
// 异步任务（如发送通知、外部API调用）
sendOrderConfirmationNotification(event);
// 记录审计日志
auditLogService.logOrderCreation(event);
// 更新统计分析
statisticsService.incrementOrderCount(event);
}
// 在事务提交失败后处理事件
@TransactionalEventListener(phase = TransactionPhase.AFTER_ROLLBACK)
public void handleOrderCreationRollback(OrderCreatedEvent event) {
logger.info("事务回滚后处理订单创建事件");
// 清理可能产生的副作用
cleanupPartialOrderData(event);
// 发送失败通知
notificationService.sendOrderCreationFailureNotification(event);
// 记录失败原因
failureAnalysisService.logOrderCreationFailure(event);
}
// 在事务同步阶段处理事件（同一事务内）
@TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
public void handleOrderCreatedBeforeCommit(OrderCreatedEvent event) {
logger.info("事务提交前处理订单创建事件");
// 必须与主事务同步的操作
validateOrderBeforeCommit(event);
// 预先扣除库存（确保事务一致性）
inventoryService.reserveInventory(event.getOrder());
// 预生成订单号（确保唯一性）
ensureOrderNumberUniqueness(event);
}
// 在事务完成后的清理阶段处理
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMPLETION)
public void handleOrderCreatedAfterCompletion(OrderCreatedEvent event, TransactionTransaction transaction) {
logger.info("事务完成后处理订单创建事件, 状态: {}", transaction.wasCommitted() ? "COMMITTED" : "ROLLED_BACK");
if (transaction.wasCommitted()) {
// 事务成功提交后的后处理
postCommitProcessing(event);
} else {
// 事务回滚后的清理处理
rollbackCleanup(event);
}
}
private void validateOrderBeforeCommit(OrderCreatedEvent event) {
Order order = event.getOrder();
// 验证用户状态
if (!userService.isUserActive(order.getUser().getId())) {
throw new IllegalStateException("用户状态异常，无法创建订单");
}
// 验证商品状态
for (OrderItem item : order.getItems()) {
if (!productService.isProductAvailable(item.getProduct())) {
throw new IllegalStateException("商品不可用: " + item.getProduct().getSku());
}
}
// 验证地址有效性
if (!addressService.isAddressValid(order.getShippingAddress())) {
throw new IllegalStateException("收货地址无效");
}
}
private void postCommitProcessing(OrderCreatedEvent event) {
// 触发后续业务流程
workflowService.startOrderFulfillmentWorkflow(event.getOrder().getId());
// 更新缓存
cacheService.invalidateUserOrderCache(event.getOrder().getUser().getId());
// 触发商业智能数据更新
bIservice.updateOrderMetrics(event.getOrder());
}
private void rollbackCleanup(OrderCreatedEvent event) {
// 清理临时数据
tempDataService.cleanupOrderTempData(event.getOrder().getId());
// 重置锁定的资源
resourceLockService.releaseOrderLocks(event.getOrder().getId());
// 回滚预分配的资源
resourceAllocationService.rollbackPreAllocatedResources(event.getOrder());
}
}
事务事件配置
事务事件配置：
@Configuration
@EnableTransactionManagement
public class TransactionEventConfig {
@Bean
public TransactionalEventListenerFactory transactionalEventListenerFactory() {
return new TransactionalEventListenerFactory();
}
@Bean
public TransactionTemplate transactionTemplate(PlatformTransactionManager transactionManager) {
return new TransactionTemplate(transactionManager);
}
@Bean
public TransactionSynchronizationManager synchronizationManager() {
return new TransactionSynchronizationManager();
}
}
性能优化
事件处理优化
事件处理性能优化：
@Configuration
public class EventPerformanceConfig {
@Bean
public ApplicationEventMulticaster optimizedEventMulticaster() {
SimpleApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();
// 优化线程池
ThreadPoolTaskExecutor executor = createOptimizedExecutor();
multicaster.setTaskExecutor(executor);
// 设置错误处理
multicaster.setErrorHandler(new EventErrorHandler());
return multicaster;
}
private ThreadPoolTaskExecutor createOptimizedExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
// 根据系统资源动态调整
executor.setCorePoolSize(Math.max(2, Runtime.getRuntime().availableProcessors()));
executor.setMaxPoolSize(Runtime.getRuntime().availableProcessors() * 4);
executor.setQueueCapacity(1000);
executor.setKeepAliveSeconds(300);
// 优化拒绝策略
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
// 优雅关闭
executor.setWaitForTasksToCompleteOnShutdown(true);
executor.setAwaitTerminationSeconds(60);
executor.setThreadNamePrefix("EventAsync-");
executor.initialize();
return executor;
}
// 事件批量处理器
@Component
public class BatchEventProcessor {
private final Map<Class<?>, List<BaseDomainEvent>> eventBatch = new ConcurrentHashMap<>();
private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
@PostConstruct
public void initBatchProcessor() {
// 定期处理批量事件
scheduler.scheduleWithFixedDelay(this::processBatchEvents, 5, 5, TimeUnit.SECONDS);
}
@EventListener
public void collectEvents(BaseDomainEvent event) {
Class<?> eventClass = event.getClass();
eventBatch.computeIfAbsent(eventClass, k -> new CopyOnWriteArrayList<>()).add(event);
// 达到批量大小时立即处理
if (eventBatch.get(eventClass).size() >= 100) {
processBatchEvents(eventClass);
}
}
@Scheduled(fixedDelay = 5000) // 每5秒处理一次
public void processBatchEvents() {
Set<Class<?>> eventTypes = new HashSet<>(eventBatch.keySet());
eventTypes.forEach(this::processBatchEvents);
}
private void processBatchEvents(Class<?> eventType) {
List<BaseDomainEvent> events = eventBatch.remove(eventType);
if (events != null && !events.isEmpty()) {
logger.info("批量处理事件: {}, 数量: {}", eventType.getSimpleName(), events.size());
try {
// 批量处理逻辑
processEventsInBatch(events);
} catch (Exception e) {
logger.error("批量事件处理失败", e);
// 失败的事件重新放回队列
eventBatch.computeIfAbsent(eventType, k -> new ArrayList<>()).addAll(events);
}
}
}
private void processEventsInBatch(List<BaseDomainEvent> events) {
// 按事件类型分组处理
Map<Class<?>, List<BaseDomainEvent>> eventsByType = events.stream()
.collect(Collectors.groupingBy(BaseDomainEvent::getClass));
eventsByType.forEach((eventClass, eventList) -> {
switch (eventClass.getSimpleName()) {
case "UserRegisteredEvent":
batchProcessUserRegistration(eventList);
break;
case "OrderCreatedEvent":
batchProcessOrderCreation(eventList);
break;
case "PaymentCompletedEvent":
batchProcessPayment(eventList);
break;
}
});
}
}
}
事件监控与调试
事件追踪
事件监控和调试工具：
@Component
public class EventMonitoringService {
private final MeterRegistry meterRegistry;
private final Counter eventCounter;
private final Timer eventTimer;
private final Histogram eventSizeDistribution;
public EventMonitoringService(MeterRegistry meterRegistry) {
this.meterRegistry = meterRegistry;
this.eventCounter = Counter.builder("events.total")
.description("总事件数量")
.tag("source", "application")
.register(meterRegistry);
this.eventTimer = Timer.builder("events.processing.time")
.description("事件处理时间")
.register(meterRegistry);
this.eventSizeDistribution = Miscrometer.more(meterRegistry)
.histogram("events.size")
.description("事件大小分布")
.register(meterRegistry);
}
@EventListener
@Timed(description = "事件发布监控")
public void monitorEventPublication(BaseDomainEvent event) {
eventCounter.increment(
Tags.of("eventType", event.getEventType())
);
// 记录事件大小
int eventSize = calculateEventSize(event);
eventSizeDistribution.record(eventSize);
logger.debug("事件发布: {}, 大小: {} bytes", event.getEventType(), eventSize);
}
@EventListener
@Timed(description = "事件处理监控")
public void monitorEventProcessing(EventProcessedEvent eventProcessingEvent) {
Timer.Sample sample = Timer.start(meterRegistry);
try {
// 记录处理开始
Object event = eventProcessingEvent.getEvent();
logger.info("开始处理事件: {}, 事件ID: {}",
event.getClass().getSimpleName(),
((BaseDomainEvent) event).getEventId());
// 模拟事件处理
processEventWithMetrics(eventProcessingEvent);
} finally {
sample.stop(Timer.builder("events.processing.success")
.tag("eventType", eventProcessingEvent.getEvent().getClass().getSimpleName())
.register(meterRegistry));
}
}
private int calculateEventSize(BaseDomainEvent event) {
try {
return JsonUtils.toJson(event).getBytes().length;
} catch (Exception e) {
return 0;
}
}
}
@Component
@Slf4j
public class EventDebugger {
@Autowired
private EventRepository eventRepository;
@EventListener
public void logAllEvents(BaseDomainEvent event) {
if (log.isDebugEnabled()) {
log.debug("事件发布详情: {} - {}",
event.getClass().getSimpleName(),
FormatUtils.formatEvent(event));
}
// 保存事件到调试存储
saveEventForDebugging(event);
}
@EventListener
public void debugEventListenerMetrics(BaseDomainEvent event) {
// 记录监听器执行指标
recordListenerMetrics(event);
// 检查监听器性能问题
checkListenerPerformance(event);
}
private void saveEventForDebugging(BaseDomainEvent event) {
EventDebugEntity entity = EventDebugEntity.builder()
.eventId(event.getEventId())
.eventType(event.getEventType())
.eventData(JsonUtils.toJson(event))
.userId(event.getUserId())
.correlationId(event.getCorrelationId())
.timestamp(event.getEventTime())
.build();
try {
eventRepository.save(entity);
} catch (Exception e) {
log.warn("事件调试数据保存失败", e);
}
}
private void recordListenerMetrics(BaseDomainEvent event) {
Gauge.Builder.builder("event.listeners.active",
this::getActiveListenerCount)
.description("活跃事件监听器数量")
.tag("eventType", event.getEventType())
.register(meterRegistry);
}
private void checkListenerPerformance(BaseDomainEvent event) {
// 检查是否有监听器执行时间过长
Map<String, Duration> listenerExecutionTimes = getListenerExecutionTimes(event.getEventId());
listenerExecutionTimes.forEach((listenerName, duration) -> {
if (duration.toMillis() > 10000) { // 超过10秒
log.warn("监听器 {} 执行时间过长: {}", listenerName, duration);
// 发送性能告警
alertService.sendListenerPerformanceAlert(listenerName, duration);
}
});
}
}
总结
Spring事务驱动架构为企业级应用提供了强大的事件处理能力：
核心技术要点
- 事件机制 - ApplicationEvent和ApplicationListener基础
- 异步处理 - 基于@Async的异步事件处理
- 事务集成 - 事务事件的生命周期管理
- 条件监听 - 基于条件的事件监听器
- 优先级控制 - 事件处理顺序和优先级管理
- 性能优化 - 批量处理和线程池优化
- 监控调试 - 事件追踪和性能监控
企业级应用价值
- 解耦架构：事件驱动实现松耦合的设计模式
- 异步处理：提高应用响应性能和用户体验
- 可靠处理：事务保障确保事件处理的原子性
- 可观测性：完善的监控和调试能力
最佳实践建议
- 事件设计：明确事件边界和职责
- 异步策略：合理使用异步处理提高性能
- 错误处理：建立完善的事件处理错误恢复机制
- 性能监控：持续监控事件处理性能
- 事务管理：正确处理事件与事务的关系
核心优势总结
- 灵活扩展：事件机制使系统更容易扩展新功能
- 性能优化：异步处理显著提升系统性能和吞吐量
- 可靠性：事务集成保证数据一致性和系统稳定性
- 可观测性：完善的监控体系便于运维和问题排查
通过Spring事件驱动架构，您可以构建更加灵活、高性能、可扩展的企业级应用系统！
扫一扫
168万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
