请举例说明@EventListener和ApplicationEvent机制是如何完美运用观察者模式的。Spring框架中还有哪些经典设计模式的绝佳实践？

Question

请举例说明@EventListener和ApplicationEvent机制是如何完美运用观察者模式的。Spring框架中还有哪些经典设计模式的绝佳实践？

Answer 1

让【宝码香车】来帮您解答，本回答参考DeepSeek编写，并整理提供。

如果答案能帮助您，请采纳，非常感谢！
.
每日一句正能量，让它带给您好心情：给自己多一点鼓励，少一点否定，你会发现自己很棒。
.

Spring框架中的观察者模式与设计模式实践

@EventListener和ApplicationEvent的观察者模式实现

Spring框架中的ApplicationEvent和@EventListener机制是观察者模式的经典实现，下面通过具体示例说明：

1. 定义自定义事件

// 用户注册事件
public class UserRegisterEvent extends ApplicationEvent {
    private String username;
    private String email;
    
    public UserRegisterEvent(Object source, String username, String email) {
        super(source);
        this.username = username;
        this.email = email;
    }
    
    // getter方法
    public String getUsername() { return username; }
    public String getEmail() { return email; }
}

2. 发布事件

@Service
public class UserService {
    
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    public void registerUser(String username, String email) {
        // 用户注册逻辑
        System.out.println("用户注册成功: " + username);
        
        // 发布用户注册事件
        UserRegisterEvent event = new UserRegisterEvent(this, username, email);
        eventPublisher.publishEvent(event);
    }
}

3. 监听事件

@Component
public class EmailService {
    
    @EventListener
    public void handleUserRegistration(UserRegisterEvent event) {
        System.out.println("发送欢迎邮件给: " + event.getEmail());
        // 实际的邮件发送逻辑
    }
}


@Component
public class PointsService {
    
    @EventListener
    public void addWelcomePoints(UserRegisterEvent event) {
        System.out.println("为新用户 " + event.getUsername() + " 添加欢迎积分");
        // 积分添加逻辑
    }
}


@Component
public class StatisticsService {
    
    @EventListener
    public void updateUserStatistics(UserRegisterEvent event) {
        System.out.println("更新用户统计信息: " + event.getUsername());
        // 统计更新逻辑
    }
}

观察者模式的优势体现

1. 解耦：事件发布者无需知道具体的监听者
2. 扩展性：新增监听者无需修改发布者代码
3. 灵活性：监听者可以按需订阅感兴趣的事件

Spring框架中其他经典设计模式实践

1. 单例模式 (Singleton Pattern)

@Component
public class CacheManager {
    // Spring默认将@Component注解的类作为单例管理
    private Map<String, Object> cache = new ConcurrentHashMap<>();
    
    public void put(String key, Object value) {
        cache.put(key, value);
    }
    
    public Object get(String key) {
        return cache.get(key);
    }
}

2. 工厂模式 (Factory Pattern)

// 产品接口
public interface PaymentService {
    void pay(BigDecimal amount);
}


// 具体产品
@Component("alipay")
public class AlipayService implements PaymentService {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("支付宝支付: " + amount);
    }
}


@Component("wechatPay")
public class WechatPayService implements PaymentService {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("微信支付: " + amount);
    }
}


// 使用工厂
@Service
public class OrderService {
    
    @Autowired
    private Map<String, PaymentService> paymentServices;
    
    public void processPayment(String paymentType, BigDecimal amount) {
        PaymentService paymentService = paymentServices.get(paymentType);
        if (paymentService != null) {
            paymentService.pay(amount);
        }
    }
}

3. 模板方法模式 (Template Method Pattern)

public abstract class DataProcessor {
    
    // 模板方法
    public final void process() {
        validateData();
        transformData();
        saveData();
        afterProcess();
    }
    
    protected void validateData() {
        System.out.println("数据验证...");
    }
    
    protected abstract void transformData();
    
    protected void saveData() {
        System.out.println("保存数据...");
    }
    
    protected void afterProcess() {
        // 钩子方法，子类可选择重写
    }
}


@Component
public class UserDataProcessor extends DataProcessor {
    
    @Override
    protected void transformData() {
        System.out.println("转换用户数据...");
    }
    
    @Override
    protected void afterProcess() {
        System.out.println("用户数据处理完成后的清理工作...");
    }
}

4. 代理模式 (Proxy Pattern)

// AOP实现代理模式
@Aspect
@Component
public class LoggingAspect {
    
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("方法执行前: " + joinPoint.getSignature().getName());
    }
    
    @AfterReturning("execution(* com.example.service.*.*(..))")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("方法执行后: " + joinPoint.getSignature().getName());
    }
}

5. 适配器模式 (Adapter Pattern)

// 现有接口
public interface OldPaymentSystem {
    void makePayment(String account, double amount);
}


// 新接口
public interface NewPaymentSystem {
    void processPayment(PaymentRequest request);
}


// 适配器
@Component
public class PaymentAdapter implements NewPaymentSystem {
    
    @Autowired
    private OldPaymentSystem oldSystem;
    
    @Override
    public void processPayment(PaymentRequest request) {
        // 适配逻辑
        oldSystem.makePayment(request.getAccount(), request.getAmount().doubleValue());
    }
}

6. 策略模式 (Strategy Pattern)

// 策略接口
public interface DiscountStrategy {
    BigDecimal calculateDiscount(BigDecimal amount);
}


// 具体策略
@Component("vipDiscount")
public class VipDiscountStrategy implements DiscountStrategy {
    @Override
    public BigDecimal calculateDiscount(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8")); // 8折
    }
}


@Component("normalDiscount")
public class NormalDiscountStrategy implements DiscountStrategy {
    @Override
    public BigDecimal calculateDiscount(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.95")); // 95折
    }
}


// 上下文
@Service
public class DiscountService {
    
    @Autowired
    private Map<String, DiscountStrategy> strategies;
    
    public BigDecimal applyDiscount(String strategyName, BigDecimal amount) {
        DiscountStrategy strategy = strategies.get(strategyName);
        if (strategy != null) {
            return strategy.calculateDiscount(amount);
        }
        return amount;
    }
}

总结

Spring框架深度集成了多种设计模式，这些模式的运用使得Spring具有高度的灵活性、可扩展性和可维护性。通过合理运用这些模式，开发者可以构建出更加健壮和易于维护的应用程序。