public class UserRegisteredEvent extends ApplicationEvent {
    
    private final String username;
    
    public UserRegisteredEvent(Object source, String username) {
        super(source);
        this.username = username;
    }
    
    public String getUsername() {
        return username;
    }
}

@Component
public class UserRegistrationListener implements ApplicationListener<UserRegisteredEvent> {
    
    private static final Logger logger = LoggerFactory.getLogger(UserRegistrationListener.class);
    
    @Override
    public void onApplicationEvent(UserRegisteredEvent event) {
        logger.info("新用戶注冊: {}, 事件來源: {}", 
                event.getUsername(), event.getSource().toString());
        
        // 處理業(yè)務(wù)邏輯，如發(fā)送歡迎郵件等
        sendWelcomeEmail(event.getUsername());
    }
    
    private void sendWelcomeEmail(String username) {
        // 郵件發(fā)送邏輯
        logger.info("向用戶 {} 發(fā)送歡迎郵件", username);
    }
}

@Service
public class UserService {
    
    private final ApplicationEventPublisher eventPublisher;
    
    @Autowired
    public UserService(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
    
    public void registerUser(String username, String password) {
        // 用戶注冊業(yè)務(wù)邏輯
        logger.info("注冊用戶: {}", username);
        
        // 注冊成功后，發(fā)布事件
        eventPublisher.publishEvent(new UserRegisteredEvent(this, username));
    }
}

// 使用POJO作為事件對象
public class OrderCompletedEvent {
    
    private final String orderId;
    private final BigDecimal amount;
    
    public OrderCompletedEvent(String orderId, BigDecimal amount) {
        this.orderId = orderId;
        this.amount = amount;
    }
    
    // getters
    public String getOrderId() {
        return orderId;
    }
    
    public BigDecimal getAmount() {
        return amount;
    }
}

@Component
public class OrderEventHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(OrderEventHandler.class);
    
    @EventListener
    public void handleOrderCompletedEvent(OrderCompletedEvent event) {
        logger.info("訂單完成: {}, 金額: {}", event.getOrderId(), event.getAmount());
        
        // 處理訂單完成后的業(yè)務(wù)邏輯
        updateInventory(event.getOrderId());
        notifyShipping(event.getOrderId());
    }
    
    // 也可以在同一個(gè)類中處理多種不同類型的事件
    @EventListener
    public void handleUserRegisteredEvent(UserRegisteredEvent event) {
        logger.info("檢測到新用戶注冊: {}", event.getUsername());
        // 其他處理邏輯
    }
    
    private void updateInventory(String orderId) {
        // 更新庫存邏輯
        logger.info("更新訂單 {} 相關(guān)商品的庫存", orderId);
    }
    
    private void notifyShipping(String orderId) {
        // 通知物流部門
        logger.info("通知物流部門處理訂單: {}", orderId);
    }
}

@Service
public class OrderService {
    
    private final ApplicationEventPublisher eventPublisher;
    
    @Autowired
    public OrderService(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
    
    public void completeOrder(String orderId, BigDecimal amount) {
        // 訂單完成業(yè)務(wù)邏輯
        logger.info("完成訂單: {}, 金額: {}", orderId, amount);
        
        // 發(fā)布訂單完成事件
        eventPublisher.publishEvent(new OrderCompletedEvent(orderId, amount));
    }
}

@Component
public class LargeOrderHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(LargeOrderHandler.class);
    
    // 只處理金額大于1000的訂單
    @EventListener(condition = "#event.amount.compareTo(T(java.math.BigDecimal).valueOf(1000)) > 0")
    public void handleLargeOrder(OrderCompletedEvent event) {
        logger.info("檢測到大額訂單: {}, 金額: {}", event.getOrderId(), event.getAmount());
        // 大額訂單特殊處理
        notifyFinanceDepartment(event.getOrderId(), event.getAmount());
    }
    
    private void notifyFinanceDepartment(String orderId, BigDecimal amount) {
        logger.info("通知財(cái)務(wù)部門關(guān)注大額訂單: {}, 金額: {}", orderId, amount);
    }
}

@SpringBootApplication
@EnableAsync
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Configuration
public class AsyncConfig implements AsyncConfigurer {
    
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(25);
        executor.setThreadNamePrefix("Event-Async-");
        executor.initialize();
        return executor;
    }
    
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new SimpleAsyncUncaughtExceptionHandler();
    }
}

// 方法一：基于ApplicationListener接口的異步監(jiān)聽器
@Component
@Async
public class AsyncEmailNotificationListener implements ApplicationListener<UserRegisteredEvent> {
    
    private static final Logger logger = LoggerFactory.getLogger(AsyncEmailNotificationListener.class);
    
    @Override
    public void onApplicationEvent(UserRegisteredEvent event) {
        logger.info("異步處理用戶注冊事件，準(zhǔn)備發(fā)送郵件，線程: {}", 
                Thread.currentThread().getName());
        
        // 模擬耗時(shí)操作
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        logger.info("異步郵件發(fā)送完成，用戶: {}", event.getUsername());
    }
}

// 方法二：基于@EventListener注解的異步監(jiān)聽器
@Component
public class NotificationService {
    
    private static final Logger logger = LoggerFactory.getLogger(NotificationService.class);
    
    @EventListener
    @Async
    public void handleOrderCompletedEventAsync(OrderCompletedEvent event) {
        logger.info("異步處理訂單完成事件，準(zhǔn)備發(fā)送通知，線程: {}", 
                Thread.currentThread().getName());
        
        // 模擬耗時(shí)操作
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        logger.info("異步通知發(fā)送完成，訂單: {}", event.getOrderId());
    }
}

@Component
public class OrderAuditService {
    
    private static final Logger logger = LoggerFactory.getLogger(OrderAuditService.class);
    
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    @Async
    public void auditOrderAfterCommit(OrderCompletedEvent event) {
        logger.info("事務(wù)提交后異步審計(jì)訂單: {}, 線程: {}", 
                event.getOrderId(), Thread.currentThread().getName());
        
        // 記錄審計(jì)日志等操作
        storeAuditRecord(event);
    }
    
    private void storeAuditRecord(OrderCompletedEvent event) {
        // 存儲(chǔ)審計(jì)記錄的邏輯
        logger.info("存儲(chǔ)訂單 {} 的審計(jì)記錄", event.getOrderId());
    }
}

// 事件對象
public class UserRegistrationEvent {
    private final String username;
    private final String email;
    private final LocalDateTime registrationTime;
    
    // 構(gòu)造函數(shù)和getter省略
}

// 事件發(fā)布
@Service
public class UserServiceImpl implements UserService {
    
    private final UserRepository userRepository;
    private final ApplicationEventPublisher eventPublisher;
    
    @Autowired
    public UserServiceImpl(UserRepository userRepository, 
                           ApplicationEventPublisher eventPublisher) {
        this.userRepository = userRepository;
        this.eventPublisher = eventPublisher;
    }
    
    @Transactional
    @Override
    public User registerUser(UserRegistrationDto dto) {
        // 驗(yàn)證用戶數(shù)據(jù)
        validateUserData(dto);
        
        // 創(chuàng)建用戶
        User user = new User();
        user.setUsername(dto.getUsername());
        user.setEmail(dto.getEmail());
        user.setPassword(passwordEncoder.encode(dto.getPassword()));
        
        // 保存用戶
        User savedUser = userRepository.save(user);
        
        // 發(fā)布注冊事件
        eventPublisher.publishEvent(new UserRegistrationEvent(
                savedUser.getUsername(), 
                savedUser.getEmail(), 
                LocalDateTime.now()));
        
        return savedUser;
    }
}

// 異步郵件處理
@Component
public class EmailService {
    
    @EventListener
    @Async
    public void sendWelcomeEmail(UserRegistrationEvent event) {
        logger.info("異步發(fā)送歡迎郵件給: {}", event.getEmail());
        // 郵件發(fā)送邏輯
    }
}

// 審計(jì)日志記錄
@Component
public class AuditService {
    
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void logUserRegistration(UserRegistrationEvent event) {
        logger.info("記錄用戶注冊審計(jì)日志: {}, 時(shí)間: {}", 
                event.getUsername(), event.getRegistrationTime());
        // 審計(jì)日志記錄邏輯
    }
}

// 用戶初始化
@Component
public class UserSetupService {
    
    @EventListener
    public void setupUserDefaults(UserRegistrationEvent event) {
        logger.info("為新用戶 {} 設(shè)置默認(rèn)配置", event.getUsername());
        // 用戶配置初始化邏輯
    }
}