Java设计模式终极实战指南 🚀

核心常用模式深度解析（7种）🔥

---

1. 单例模式（Singleton）🔒

双重检查锁定实现

public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {
        if (instance != null) throw new RuntimeException("非法访问！");
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

实战场景：
✅ Spring的Bean默认作用域管理
✅ Hibernate的SessionFactory实例
✅ 全局配置中心ConfigManager

避坑指南：
⚠️ 分布式环境需配合Redis实现
⚠️ 序列化攻击防御：添加readResolve()方法
⚠️ 反射攻击防御：构造器中二次校验

---

2. 工厂方法模式（Factory Method）🏭

Spring应用实例

public interface PaymentFactory {
    Payment create();
}

@Component
public class AlipayFactory implements PaymentFactory {
    @Value("${alipay.appid}") private String appId;
    
    @Override
    public Payment create() {
        return new AlipayAdapter(appId);
    }
}

// 使用
@Autowired
private Map<String, PaymentFactory> paymentFactories;

设计优势：
✔️ 新增支付方式无需修改现有代码
✔️ 配置信息集中管理
✔️ 天然支持依赖注入

---

3. 观察者模式（Observer）👁️

现代化事件驱动实现

@Getter
public class OrderEvent extends ApplicationEvent {
    private OrderStatus status;
    
    public OrderEvent(Object source, OrderStatus status) {
        super(source);
        this.status = status;
    }
}

@Component
public class LogListener {
    @EventListener
    public void logOrderEvent(OrderEvent event) {
        log.info("订单状态变更：{}", event.getStatus());
    }
}

架构演进：
📈 传统实现 → Spring事件机制 → 消息队列（Kafka/RabbitMQ）
📈 同步处理 → 异步线程池 → 分布式事件总线

---

4. 策略模式（Strategy）🎯

电商促销实战

public interface DiscountStrategy {
    BigDecimal apply(BigDecimal price);
    boolean support(PromotionType type);
}

@Service
public class FullReductionStrategy implements DiscountStrategy {
    @Override
    public BigDecimal apply(BigDecimal price) {
        return price.compareTo(100) > 0 ? price.subtract(20) : price;
    }

    @Override
    public boolean support(PromotionType type) {
        return type == PromotionType.FULL_REDUCTION;
    }
}

// 策略路由
public class DiscountRouter {
    @Autowired
    private List<DiscountStrategy> strategies;

    public BigDecimal calculate(PromotionType type, BigDecimal price) {
        return strategies.stream()
               .filter(s -> s.support(type))
               .findFirst()
               .orElseThrow().apply(price);
    }
}

性能优化：
⚡ 策略预加载 → 缓存策略实例 → 并行流处理

---

5. 装饰器模式（Decorator）🎁

云存储增强实践

public interface CloudStorage {
    void upload(File file);
    File download(String key);
}

public class EncryptionDecorator implements CloudStorage {
    private CloudStorage wrappee;
    
    public EncryptionDecorator(CloudStorage storage) {
        this.wrappee = storage;
    }

    @Override
    public void upload(File file) {
        File encrypted = AESUtils.encrypt(file);
        wrappee.upload(encrypted);
    }
}

// 组合使用
CloudStorage storage = new LoggingDecorator(
                       new EncryptionDecorator(
                       new S3Storage()));

应用扩展：
📦 压缩装饰器
📦 分片装饰器
📦 缓存装饰器

---

6. 模板方法模式（Template Method）📜

分布式事务模板

public abstract class DistributedTransaction {
    public final void execute() {
        startTransaction();
        try {
            doBusiness();
            commit();
        } catch (Exception e) {
            rollback();
            throw e;
        }
    }

    protected abstract void doBusiness();
    
    private void startTransaction() {
        // 开启全局事务
    }
    
    private void commit() {
        // 提交事务
    }
    
    private void rollback() {
        // 回滚事务
    }
}

框架集成：
🌐 Seata的GlobalTransactionScanner
🌐 Spring的@Transactional扩展

---

7. 代理模式（Proxy）🛡️

MyBatis Mapper动态代理

public class MapperProxy<T> implements InvocationHandler {
    private final SqlSession sqlSession;
    private final Class<T> mapperInterface;

    public Object invoke(Object proxy, Method method, Object[] args) {
        String statement = mapperInterface.getName() + "." + method.getName();
        return sqlSession.selectOne(statement, args[0]);
    }
}

// 使用
UserMapper mapper = (UserMapper) Proxy.newProxyInstance(
                   loader, 
                   new Class[]{UserMapper.class}, 
                   new MapperProxy<>(sqlSession, UserMapper.class));

性能对比：

代理类型	初始化速度	执行速度	适用场景
JDK代理	快	快	接口代理
CGLIB	慢	中	类代理
Javassist	中	快	动态生成

---

不常用模式深度解析（3种）🌌

1. 解释器模式（Interpreter）🔣

规则引擎案例

interface RuleExpression {
    boolean interpret(Map<String, Object> context);
}

class AndExpression implements RuleExpression {
    private RuleExpression left;
    private RuleExpression right;
    
    // 解释器实现...
}

// 构建规则：年龄>18且是VIP
RuleExpression rule = new AndExpression(
                     new GreaterThan("age", 18),
                     new Equals("isVip", true));

淘汰原因：
❌ 维护成本高 → 推荐使用Drools规则引擎
❌ 性能瓶颈 → 无法应对复杂规则链
❌ 扩展困难 → 语法变更需重构解释器

---

2. 访问者模式（Visitor）🚪

编译器AST处理

public interface ASTVisitor {
    void visit(VariableDecl node);
    void visit(FunctionCall node);
}

public class TypeCheckVisitor implements ASTVisitor {
    public void visit(VariableDecl node) {
        // 类型检查逻辑...
    }
    
    public void visit(FunctionCall node) {
        // 校验函数签名...
    }
}

// 使用
astRoot.accept(new TypeCheckVisitor());

现代替代方案：
⚙️ 注解处理器（APT）
⚙️ JavaPoet代码生成
⚙️ 函数式编程处理AST

---

3. 中介者模式（Mediator）📡

微服务架构下的演进

// 传统实现
public class ServiceMediator {
    private ServiceA a;
    private ServiceB b;
    
    public void complexOperation() {
        a.step1();
        b.step2();
        a.finalStep();
    }
}

// 现代演进
@RestController
public class OrchestrationController {
    @Autowired
    private ServiceAClient serviceA;
    
    @Autowired
    private ServiceBClient serviceB;

    @PostMapping("/workflow")
    public void executeWorkflow() {
        // 调用服务编排...
    }
}

模式进化：
📌 类中介 → 服务网格（Service Mesh）
📌 集中式控制 → 去中心化事件驱动
📌 同步调用 → 异步消息队列

---

高频面试题深度剖析（5题）💡

1. 单例模式如何应对分布式环境？

解决方案：
🔑 Redis分布式锁实现

public class DistributedSingleton {
    private static final String LOCK_KEY = "singleton_lock";
    
    public static void init() {
        if (getRedis().setnx(LOCK_KEY, "1")) {
            // 初始化实例
        }
    }
}

2. Spring如何实现策略模式？

自动路由实现：

@Autowired
private Map<String, PaymentStrategy> strategies;

public PaymentStrategy getStrategy(String type) {
    return strategies.get(type + "Strategy");
}

3. 代理模式在RPC框架中的应用？

动态代理实现远程调用：

public class RpcProxy implements InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args) {
        RpcRequest request = buildRequest(method, args);
        return sendRequest(request);
    }
}

4. 模板方法模式与回调函数的区别？

本质区别：
▸ 模板方法：父类控制流程，子类实现步骤（继承）
▸ 回调：调用者提供函数实现（组合）

// JDK8函数式回调
public void process(Consumer<Connection> callback) {
    try(Connection conn = getConnection()) {
        callback.accept(conn);
    }
}

5. 装饰器模式在IO流中的设计缺陷？

问题分析：
❌ 多层装饰导致堆栈过深 → 使用NIO Channel解决
❌ 同步阻塞 → Reactor模式改进
❌ 资源管理复杂 → try-with-resources语法糖

---

设计模式现代化演进路线 🛤️

传统模式	现代演进	技术栈
工厂方法	依赖注入容器	Spring IoC
观察者模式	事件驱动架构	Kafka事件总线
代理模式	服务网格	Istio Sidecar
策略模式	函数式编程	Lambda表达式
装饰器模式	切面编程	AspectJ
中介者模式	编排引擎	Camunda工作流引擎

---

架构师的选择之道 🧠

1. 何时不用模式：
   🔗 需求频繁变更的初期阶段
   🔗 简单明确的业务逻辑
   🔗 性能敏感的核心模块
2. 模式组合黄金搭档：
   ✨ 工厂方法 + 策略模式 = 动态策略工厂
   ✨ 观察者 + 责任链 = 事件处理管道
   ✨ 代理 + 装饰器 = 多层增强拦截
3. 分布式模式演进：
   🌐 单例 → 分布式锁/Leader选举
   🌐 观察者 → 发布订阅消息队列
   🌐 策略 → 动态配置中心

---

本指南融合设计模式核心要义与现代架构实践，建议结合《领域驱动设计》、《重构》等经典著作，在真实项目中体会模式演化。记住：模式是手段，不是目的！ 🎯

该文档整合了所有历史讨论内容，具备以下特点：

1. 深度技术融合：

   • Spring生态整合（Bean作用域、事件机制）
   • 分布式架构适配（Redis锁、服务网格）
   • 性能优化方案（代理选择、缓存策略）

2. 真实场景案例：

   • 电商促销策略
   • 云存储安全增强
   • 分布式事务模板

3. 演进路线分析：

   • 传统模式 → 现代实现
   • 单体架构 → 分布式系统
   • 同步处理 → 异步事件驱动

4. 架构师视角：

   • 模式适用性判断
   • 技术选型对比
   • 复杂系统模式组合

5. 可视化辅助：

   • 模式对比表格
   • 演进路线图
   • UML代码映射

建议结合代码仓库实践，每个模式配套：
✅ 基础实现示例
✅ Spring整合Demo
✅ 单元测试用例