Java设计模式深度解析：瓦学弟的架构修炼之路（2025版）

前言：瓦学弟初入职场的惊魂之旅 🏛️

在2025年的某个春日，瓦学弟怀着忐忑不安的心情踏进了新公司的大门。刚入职第一天，导师就让他接手一个"传奇"项目——一个有着三年历史的电商系统。当瓦学弟打开代码库的那一瞬间，内心就像在寻找妈妈一样焦急无助。

眼前的代码就像一座巨大的屎山：一个类3000行代码，if-else嵌套8层深，全局变量满天飞，复制粘贴遍地都是。看着这些代码，瓦学弟的内心如同找不到妈妈的孩子一般慌乱无助。

"这特么什么鬼代码？"瓦学弟在心里默默吐槽。

正当他准备摆烂时，技术大佬老王走了过来，拍了拍他的肩膀说：“小伙子，看起来你遇到设计模式的问题了。记住一句话：代码是没有后悔药的，设计是不可重来的，重构的成本是巨大的。”

从那天起，瓦学弟开始了设计模式的修炼之路…

---

第一章：创建型模式 - “对象诞生的艺术” 🐣

1.1 单例模式 - “瓦学弟的独孤求败人生”

在公司里，瓦学弟总是独来独往，就像单例模式一样——整个系统中只能有一个他。但这种"孤独"却有着深刻的技术内涵。

/**
 * 单例模式演示 - 瓦学弟版本
 * 确保整个公司只有一个瓦学弟实例
 * 这个实现在2025年面试中绝对得MVP！
 */
public class ValStudent {
    // volatile关键字保证多线程环境下的可见性和有序性
    private static volatile ValStudent instance;
    
    // 焦虑程度 - 私有属性，体现封装性
    private int anxietyLevel = 0;
    private String currentTask = "摸鱼中...";
    
    // 私有构造函数 - 瓦学弟不能被随意复制
    private ValStudent() {
        System.out.println("🎮 瓦学弟带着忐忑的心情入职了...");
        this.anxietyLevel = 50; // 初始焦虑值
        // 模拟初始化耗时操作
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    
    /**
     * 双重检查锁定 - 获取瓦学弟实例
     * 这个实现在2025年绝对得了MVP！
     * 
     * 为什么要双重检查？
     * 1. 第一次检查：避免不必要的同步开销
     * 2. 同步块：保证线程安全
     * 3. 第二次检查：防止多个线程同时通过第一次检查
     */
    public static ValStudent getInstance() {
        if (instance == null) { // 第一次检查 - 性能优化
            synchronized (ValStudent.class) { // 同步块 - 线程安全
                if (instance == null) { // 第二次检查 - 防重复创建
                    instance = new ValStudent();
                    System.out.println("✅ 瓦学弟单例创建成功，这波操作得了MVP！");
                }
            }
        }
        return instance;
    }
    
    /**
     * 增加焦虑值 - 模拟工作压力
     * 展示单例状态的变化
     */
    public synchronized void increaseAnxiety(String reason) {
        this.anxietyLevel += 10;
        this.currentTask = "处理: " + reason;
        System.out.println("😰 瓦学弟因为" + reason + "焦虑值+10，当前：" + anxietyLevel);
        
        if (anxietyLevel > 100) {
            System.out.println("💥 瓦学弟焦虑爆表！但单例保证系统中只有一个他在崩溃");
            // 重置状态而不是创建新实例
            this.anxietyLevel = 80;
            this.currentTask = "寻找妈妈中...";
        }
    }
    
    /**
     * 释放压力 - 通过摸鱼放松
     */
    public synchronized void relax() {
        this.anxietyLevel = Math.max(0, anxietyLevel - 20);
        this.currentTask = "快乐摸鱼中";
        System.out.println("🎯 瓦学弟摸了一会鱼，焦虑值-20，当前：" + anxietyLevel);
    }
    
    /**
     * 获取当前状态 - 展示单例的状态共享
     */
    public String getStatus() {
        return String.format("瓦学弟状态: %s (焦虑值: %d)", currentTask, anxietyLevel);
    }
    
    // Getter方法
    public int getAnxietyLevel() { return anxietyLevel; }
}

/**
 * 枚举实现单例 - 2025年推荐的最佳实践
 * 天然线程安全，防反射攻击，支持序列化
 */
enum ValStudentEnum {
    INSTANCE;
    
    private int anxietyLevel = 50;
    
    public void doWork(String task) {
        System.out.println("📋 枚举瓦学弟开始工作：" + task);
        anxietyLevel += 5;
    }
    
    public void getStatus() {
        System.out.println("🔍 枚举瓦学弟状态：焦虑值=" + anxietyLevel);
    }
}

/**
 * 静态内部类实现 - 懒加载且线程安全的优雅方案
 */
class ValStudentInnerClass {
    private ValStudentInnerClass() {
        System.out.println("🏗️ 静态内部类瓦学弟诞生了");
    }
    
    // 静态内部类只有在被调用时才会加载
    private static class Holder {
        private static final ValStudentInnerClass INSTANCE = new ValStudentInnerClass();
    }
    
    public static ValStudentInnerClass getInstance() {
        return Holder.INSTANCE;
    }
    
    public void coding() {
        System.out.println("⌨️ 静态内部类瓦学弟在认真编码");
    }
}

/**
 * 使用示例 - 公司日常生活
 */
public class CompanyLife {
    public static void main(String[] args) {
        System.out.println("🏢 2025年，公司开始营业了...");
        
        // 演示1：基本单例使用
        demonstrateSingletonBasics();
        
        // 演示2：多线程环境测试
        demonstrateMultiThreading();
        
        // 演示3：不同实现方式对比
        demonstrateDifferentImplementations();
        
        // 演示4：面试常考场景
        demonstrateInterviewScenarios();
    }
    
    /**
     * 基本单例演示
     */
    private static void demonstrateSingletonBasics() {
        System.out.println("\n=== 基本单例演示 ===");
        
        // 多个部门都想要瓦学弟，但只能有一个实例
        ValStudent dev1 = ValStudent.getInstance();
        ValStudent dev2 = ValStudent.getInstance();
        ValStudent dev3 = ValStudent.getInstance();
        
        // 验证确实是同一个实例
        System.out.println("🔍 验证单例：" + (dev1 == dev2 && dev2 == dev3));
        System.out.println("🔢 实例哈希码：dev1=" + dev1.hashCode() + 
                         ", dev2=" + dev2.hashCode() + ", dev3=" + dev3.hashCode());
        
        // 模拟工作场景 - 所有引用都指向同一个对象
        dev1.increaseAnxiety("需求又改了");
        System.out.println("📊 dev2的状态：" + dev2.getStatus()); // 状态已改变
        
        dev2.increaseAnxiety("线上出bug了");
        System.out.println("📊 dev3的状态：" + dev3.getStatus()); // 状态继续改变
        
        dev3.relax(); // 同一个瓦学弟在放松
        System.out.println("📊 最终状态：" + dev1.getStatus());
    }
    
    /**
     * 多线程环境测试 - 2025年面试必考
     */
    private static void demonstrateMultiThreading() {
        System.out.println("\n=== 多线程安全测试 ===");
        
        // 创建多个线程同时获取单例
        final int THREAD_COUNT = 10;
        final CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
        final Set<ValStudent> instances = new ConcurrentHashMap<ValStudent, Boolean>().keySet(ConcurrentHashMap.newKeySet());
        
        for (int i = 0; i < THREAD_COUNT; i++) {
            final int threadNum = i + 1;
            new Thread(() -> {
                try {
                    // 模拟并发获取单例
                    ValStudent student = ValStudent.getInstance();
                    instances.add(student);
                    
                    System.out.println("🧵 线程" + threadNum + 
                                     "获取到瓦学弟：" + student.hashCode());
                    
                    // 模拟并发操作
                    student.increaseAnxiety("线程" + threadNum + "的任务");
                    
                } finally {
                    latch.countDown();
                }
            }, "Worker-" + i).start();
        }
        
        try {
            latch.await(); // 等待所有线程完成
            System.out.println("🏆 多线程测试结果：共创建了 " + instances.size() + " 个实例");
            if (instances.size() == 1) {
                System.out.println("✅ 单例模式在多线程环境下得了MVP！");
            } else {
                System.out.println("❌ 单例模式线程安全测试失败！");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    
    /**
     * 不同实现方式对比
     */
    private static void demonstrateDifferentImplementations() {
        System.out.println("\n=== 单例实现方式对比 ===");
        
        // 枚举单例测试
        System.out.println("📋 枚举单例测试：");
        ValStudentEnum.INSTANCE.doWork("设计模式学习");
        ValStudentEnum.INSTANCE.getStatus();
        
        // 静态内部类测试
        System.out.println("🏗️ 静态内部类测试：");
        ValStudentInnerClass innerInstance1 = ValStudentInnerClass.getInstance();
        ValStudentInnerClass innerInstance2 = ValStudentInnerClass.getInstance();
        System.out.println("🔍 静态内部类单例验证：" + (innerInstance1 == innerInstance2));
        innerInstance1.coding();
        
        System.out.println("🏆 各种单例实现都表现得了MVP！");
    }
    
    /**
     * 面试常考场景演示
     */
    private static void demonstrateInterviewScenarios() {
        System.out.println("\n=== 面试常考场景 ===");
        
        // 场景1：反射攻击防护（枚举天然防护）
        System.out.println("🛡️ 反射攻击测试：");
        try {
            Constructor<ValStudentEnum> constructor = ValStudentEnum.class.getDeclaredConstructor();
            constructor.setAccessible(true);
            // 这里会抛出异常，因为枚举天然防反射
        } catch (Exception e) {
            System.out.println("✅ 枚举单例成功防护反射攻击！得了MVP！");
        }
        
        // 场景2：序列化安全性
        System.out.println("💾 序列化安全测试：");
        System.out.println("✅ 枚举单例天然支持序列化，无需额外处理！");
        
        // 场景3：性能对比
        System.out.println("⚡ 性能测试：");
        long startTime = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            ValStudent.getInstance();
        }
        long endTime = System.nanoTime();
        System.out.println("📊 100万次getInstance调用耗时：" + 
                         (endTime - startTime) / 1000000 + "ms");
        System.out.println("🏆 双重检查锁定性能表现得了MVP！");
    }
}

/* 预期输出示例：
🏢 2025年，公司开始营业了...

=== 基本单例演示 ===
🎮 瓦学弟带着忐忑的心情入职了...
✅ 瓦学弟单例创建成功，这波操作得了MVP！
🔍 验证单例：true
🔢 实例哈希码：dev1=123456, dev2=123456, dev3=123456
😰 瓦学弟因为需求又改了焦虑值+10，当前：60
📊 dev2的状态：瓦学弟状态: 处理: 需求又改了 (焦虑值: 60)
😰 瓦学弟因为线上出bug了焦虑值+10，当前：70
📊 dev3的状态：瓦学弟状态: 处理: 线上出bug了 (焦虑值: 70)
🎯 瓦学弟摸了一会鱼，焦虑值-20，当前：50
📊 最终状态：瓦学弟状态: 快乐摸鱼中 (焦虑值: 50)
...
*/

🎯 单例模式2025年面试考点总结：

1. 为什么使用volatile关键字？

   • 防止指令重排序
   • 保证多线程环境下的可见性
   • 避免返回半初始化的对象

2. 双重检查锁定的原理？

   • 第一次检查：性能优化，避免不必要的同步
   • 同步块：保证线程安全
   • 第二次检查：防止多个线程同时创建实例

3. 枚举实现的优势？

   • 天然线程安全
   • 防反射攻击
   • 支持序列化
   • 代码简洁

1.2 工厂模式 - “瓦学弟制造工厂的奥秘”

想象一下，公司需要根据不同项目创建不同类型的瓦学弟：有专门写前端的瓦学弟，有专门搞后端的瓦学弟，还有专门做测试的瓦学弟。这时候就需要一个"瓦学弟制造工厂"了！

/**
 * 工厂模式演示 - 瓦学弟制造工厂
 * 2025年最新升级版，支持多种瓦学弟类型
 */

// 抽象产品 - 瓦学弟基类
abstract class ValStudent {
    protected String name;
    protected String specialty; // 专业特长
    protected int skillLevel;   // 技能等级
    
    public ValStudent(String name, String specialty) {
        this.name = name;
        this.specialty = specialty;
        this.skillLevel = 1; // 初始技能等级
    }
    
    // 抽象方法 - 工作内容
    public abstract void work();
    public abstract void upgradeSkill();
    public abstract String getJobDescription();
    
    // 通用方法
    public void introduce() {
        System.out.println("👋 大家好，我是" + name + "，专业：" + specialty + 
                         "，技能等级：" + skillLevel);
    }
    
    public String getName() { return name; }
    public String getSpecialty() { return specialty; }
    public int getSkillLevel() { return skillLevel; }
}

// 具体产品1 - 前端瓦学弟
class FrontendValStudent extends ValStudent {
    private String[] frameworks = {"Vue3", "React18", "Angular15"};
    
    public FrontendValStudent(String name) {
        super(name, "前端开发");
    }
    
    @Override
    public void work() {
        System.out.println("💻 " + name + "正在用" + frameworks[skillLevel-1] + "开发炫酷界面");
        System.out.println("🎨 CSS动画效果拉满，用户体验得了MVP！");
    }
    
    @Override
    public void upgradeSkill() {
        if (skillLevel < frameworks.length) {
            skillLevel++;
            System.out.println("⬆️ " + name + "升级了！现在会用" + frameworks[skillLevel-1]);
        } else {
            System.out.println("🏆 " + name + "已经是前端大神了！");
        }
    }
    
    @Override
    public String getJobDescription() {
        return "负责用户界面开发，让用户看到的每一个像素都完美无缺";
    }
    
    public void debugCSS() {
        System.out.println("🐛 " + name + "：CSS又出bug了，这个div为什么不居中？");
        System.out.println("💡 经过3小时调试，终于发现少了一个分号...");
    }
}

// 具体产品2 - 后端瓦学弟
class BackendValStudent extends ValStudent {
    private String[] technologies = {"Spring Boot", "Spring Cloud", "Kubernetes"};
    
    public BackendValStudent(String name) {
        super(name, "后端开发");
    }
    
    @Override
    public void work() {
        System.out.println("⚙️ " + name + "正在用" + technologies[skillLevel-1] + "构建后端服务");
        System.out.println("🚀 API性能优化完成，QPS提升200%，这波操作得了MVP！");
    }
    
    @Override
    public void upgradeSkill() {
        if (skillLevel < technologies.length) {
            skillLevel++;
            System.out.println("⬆️ " + name + "进阶了！掌握了" + technologies[skillLevel-1]);
        } else {
            System.out.println("🏆 " + name + "已经是架构师级别了！");
        }
    }
    
    @Override
    public String getJobDescription() {
        return "负责系统核心逻辑，数据库设计，API接口开发";
    }
    
    public void optimizeDatabase() {
        System.out.println("🗄️ " + name + "：数据库查询太慢了，开始优化SQL");
        System.out.println("⚡ 加了索引后查询速度提升10倍！");
    }
}

// 具体产品3 - 测试瓦学弟
class TestValStudent extends ValStudent {
    private String[] testTypes = {"功能测试", "性能测试", "自动化测试"};
    
    public TestValStudent(String name) {
        super(name, "测试工程师");
    }
    
    @Override
    public void work() {
        System.out.println("🔍 " + name + "正在进行" + testTypes[skillLevel-1]);
        System.out.println("🐛 又发现了3个bug，质量把关得了MVP！");
    }
    
    @Override
    public void upgradeSkill() {
        if (skillLevel < testTypes.length) {
            skillLevel++;
            System.out.println("⬆️ " + name + "学会了" + testTypes[skillLevel-1]);
        } else {
            System.out.println("🏆 " + name + "已经是测试专家了！");
        }
    }
    
    @Override
    public String getJobDescription() {
        return "负责软件质量保证，确保产品稳定可靠";
    }
    
    public void findBugs() {
        System.out.println("🔍 " + name + "：开始地毯式搜索bug");
        System.out.println("🎯 发现边界条件处理有问题，立即报告！");
    }
}

// 抽象工厂 - 瓦学弟工厂接口
interface ValStudentFactory {
    ValStudent createValStudent(String name);
    String getFactoryType();
}

// 具体工厂1 - 前端瓦学弟工厂
class FrontendValStudentFactory implements ValStudentFactory {
    @Override
    public ValStudent createValStudent(String name) {
        System.out.println("🏭 前端工厂开始制造瓦学弟：" + name);
        FrontendValStudent student = new FrontendValStudent(name);
        
        // 工厂可以进行一些初始化配置
        System.out.println("🛠️ 为" + name + "配置开发环境：VSCode + Node.js");
        System.out.println("📚 安装必备插件：Vue DevTools, Prettier");
        
        return student;
    }
    
    @Override
    public String getFactoryType() {
        return "前端瓦学弟制造工厂";
    }
}

// 具体工厂2 - 后端瓦学弟工厂
class BackendValStudentFactory implements ValStudentFactory {
    @Override
    public ValStudent createValStudent(String name) {
        System.out.println("🏭 后端工厂开始制造瓦学弟：" + name);
        BackendValStudent student = new BackendValStudent(name);
        
        // 后端特殊配置
        System.out.println("🛠️ 为" + name + "配置服务器环境：IDEA + Maven");
        System.out.println("🗄️ 连接数据库：MySQL + Redis");
        
        return student;
    }
    
    @Override
    public String getFactoryType() {
        return "后端瓦学弟制造工厂";
    }
}

// 具体工厂3 - 测试瓦学弟工厂
class TestValStudentFactory implements ValStudentFactory {
    @Override
    public ValStudent createValStudent(String name) {
        System.out.println("🏭 测试工厂开始制造瓦学弟：" + name);
        TestValStudent student = new TestValStudent(name);
        
        // 测试环境配置
        System.out.println("🛠️ 为" + name + "配置测试环境：Selenium + JMeter");
        System.out.println("📋 准备测试用例模板和bug报告模板");
        
        return student;
    }
    
    @Override
    public String getFactoryType() {
        return "测试瓦学弟制造工厂";
    }
}

// 工厂管理器 - 简单工厂的升级版
class ValStudentFactoryManager {
    private static final Map<String, ValStudentFactory> factories = new HashMap<>();
    
    static {
        // 注册所有工厂
        factories.put("frontend", new FrontendValStudentFactory());
        factories.put("backend", new BackendValStudentFactory());
        factories.put("test", new TestValStudentFactory());
    }
    
    public static ValStudent createValStudent(String type, String name) {
        ValStudentFactory factory = factories.get(type.toLowerCase());
        if (factory == null) {
            System.out.println("🤦♂️ 吴京摇脑袋：不支持的瓦学弟类型！");
            throw new IllegalArgumentException("未知的瓦学弟类型: " + type);
        }
        
        return factory.createValStudent(name);
    }
    
    public static void showAvailableTypes() {
        System.out.println("🏭 可用的瓦学弟工厂类型：");
        factories.forEach((type, factory) -> {
            System.out.println("   " + type + " -> " + factory.getFactoryType());
        });
    }
    
    // 2025年新增：动态注册工厂
    public static void registerFactory(String type, ValStudentFactory factory) {
        factories.put(type, factory);
        System.out.println("✅ 新工厂注册成功：" + type + " -> " + factory.getFactoryType());
    }
}

/**
 * 使用示例 - 公司招聘大会
 */
public class ValStudentFactoryDemo {
    public static void main(String[] args) {
        System.out.println("🏢 2025年瓦学弟制造工厂开业啦！");
        
        // 展示可用工厂类型
        ValStudentFactoryManager.showAvailableTypes();
        
        System.out.println("\n=== 开始批量生产瓦学弟 ===");
        
        // 创建不同类型的瓦学弟
        try {
            // 前端瓦学弟
            ValStudent frontend1 = ValStudentFactoryManager.createValStudent("frontend", "Vue瓦学弟");
            ValStudent frontend2 = ValStudentFactoryManager.createValStudent("frontend", "React瓦学弟");
            
            // 后端瓦学弟
            ValStudent backend1 = ValStudentFactoryManager.createValStudent("backend", "Spring瓦学弟");
            ValStudent backend2 = ValStudentFactoryManager.createValStudent("backend", "微服务瓦学弟");
            
            // 测试瓦学弟
            ValStudent tester1 = ValStudentFactoryManager.createValStudent("test", "Bug终结者瓦学弟");
            
            System.out.println("\n=== 瓦学弟们开始工作 ===");
            
            // 让他们各自工作
            List<ValStudent> team = Arrays.asList(frontend1, frontend2, backend1, backend2, tester1);
            
            team.forEach(student -> {
                student.introduce();
                student.work();
                System.out.println("📝 工作描述：" + student.getJobDescription());
                System.out.println();
            });
            
            System.out.println("=== 技能提升训练 ===");
            team.forEach(student -> {
                student.upgradeSkill();
                student.work(); // 展示提升后的能力
                System.out.println();
            });
            
            // 展示专业技能
            demonstrateSpecialSkills(team);
            
            // 错误处理演示
            System.out.println("=== 错误处理演示 ===");
            try {
                ValStudentFactoryManager.createValStudent("unknown", "神秘瓦学弟");
            } catch (IllegalArgumentException e) {
                System.out.println("❌ 捕获异常：" + e.getMessage());
            }
            
        } catch (Exception e) {
            System.out.println("💥 工厂生产异常：" + e.getMessage());
        }
        
        System.out.println("🏆 工厂模式在瓦学弟生产线上表现得了MVP！");
    }
    
    /**
     * 展示不同瓦学弟的专业技能
     */
    private static void demonstrateSpecialSkills(List<ValStudent> team) {
        System.out.println("=== 专业技能展示 ===");
        
        for (ValStudent student : team) {
            if (student instanceof FrontendValStudent) {
                ((FrontendValStudent) student).debugCSS();
            } else if (student instanceof BackendValStudent) {
                ((BackendValStudent) student).optimizeDatabase();
            } else if (student instanceof TestValStudent) {
                ((TestValStudent) student).findBugs();
            }
            System.out.println();
        }
    }
}

继续完成文章的剩余部分：

```java
/* 预期输出示例：
🏢 2025年瓦学弟制造工厂开业啦！
🏭 可用的瓦学弟工厂类型：
   frontend -> 前端瓦学弟制造工厂
   backend -> 后端瓦学弟制造工厂  
   test -> 测试瓦学弟制造工厂
...
*/

🎯 工厂模式2025年面试考点总结：

1. 简单工厂 vs 工厂方法 vs 抽象工厂？

   • 简单工厂：一个工厂类负责创建所有产品
   • 工厂方法：每个产品都有对应的工厂类
   • 抽象工厂：创建一系列相关的产品族

2. 工厂模式的优势？

   • 解耦对象创建和使用
   • 便于扩展新产品类型
   • 集中管理对象创建逻辑

1.3 建造者模式 - “组装完美瓦学弟的艺术”

就像DIY组装电脑一样，有时候我们需要一步步构建一个复杂的瓦学弟对象。建造者模式就像是一个贴心的装机师傅，帮你按照指定步骤组装出完美的瓦学弟。

/**
 * 建造者模式演示 - 完美瓦学弟组装系统
 * 2025年升级版：支持链式调用和多种配置
 */

// 产品类 - 瓦学弟
class ValStudent {
    // 基本属性
    private String name;
    private int age;
    private String major;
    
    // 技能属性
    private List<String> programmingLanguages;
    private List<String> frameworks;
    private List<String> databases;
    
    // 个性属性
    private String personality;
    private int anxietyLevel;
    private List<String> hobbies;
    
    // 工作属性
    private String workStyle;
    private boolean hasGitSkill;
    private int codingHours;
    
    // 私有构造函数，只能通过建造者创建
    private ValStudent(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
        this.major = builder.major;
        this.programmingLanguages = new ArrayList<>(builder.programmingLanguages);
        this.frameworks = new ArrayList<>(builder.frameworks);
        this.databases = new ArrayList<>(builder.databases);
        this.personality = builder.personality;
        this.anxietyLevel = builder.anxietyLevel;
        this.hobbies = new ArrayList<>(builder.hobbies);
        this.workStyle = builder.workStyle;
        this.hasGitSkill = builder.hasGitSkill;
        this.codingHours = builder.codingHours;
        
        // 创建完成后的初始化
        System.out.println("🎯 瓦学弟组装完成：" + this.name);
    }
    
    /**
     * 静态内部建造者类 - 2025年推荐实现方式
     */
    public static class Builder {
        // 必需参数
        private final String name;
        private final int age;
        
        // 可选参数 - 使用默认值初始化
        private String major = "计算机科学";
        private List<String> programmingLanguages = new ArrayList<>();
        private List<String> frameworks = new ArrayList<>();
        private List<String> databases = new ArrayList<>();
        private String personality = "内向但热爱技术";
        private int anxietyLevel = 30;
        private List<String> hobbies = new ArrayList<>();
        private String workStyle = "认真负责";
        private boolean hasGitSkill = false;
        private int codingHours = 8;
        
        /**
         * 构造函数 - 只接收必需参数
         */
        public Builder(String name, int age) {
            this.name = name;
            this.age = age;
            System.out.println("🏗️ 开始组装瓦学弟：" + name + "(" + age + "岁)");
        }
        
        /**
         * 设置专业 - 支持链式调用
         */
        public Builder major(String major) {
            this.major = major;
            System.out.println("📚 设置专业：" + major);
            return this;
        }
        
        /**
         * 添加编程语言技能
         */
        public Builder addProgrammingLanguage(String language) {
            this.programmingLanguages.add(language);
            System.out.println("💻 学会编程语言：" + language);
            return this;
        }
        
        /**
         * 批量添加编程语言
         */
        public Builder programmingLanguages(String... languages) {
            Collections.addAll(this.programmingLanguages, languages);
            System.out.println("💻 批量学习编程语言：" + Arrays.toString(languages));
            return this;
        }
        
        /**
         * 添加框架技能
         */
        public Builder addFramework(String framework) {
            this.frameworks.add(framework);
            System.out.println("🚀 掌握框架：" + framework);
            return this;
        }
        
        /**
         * 批量添加框架
         */
        public Builder frameworks(String... frameworks) {
            Collections.addAll(this.frameworks, frameworks);
            System.out.println("🚀 批量学习框架：" + Arrays.toString(frameworks));
            return this;
        }
        
        /**
         * 添加数据库技能
         */
        public Builder addDatabase(String database) {
            this.databases.add(database);
            System.out.println("🗄️ 学会数据库：" + database);
            return this;
        }
        
        /**
         * 设置个性特征
         */
        public Builder personality(String personality) {
            this.personality = personality;
            System.out.println("😊 个性设定：" + personality);
            return this;
        }
        
        /**
         * 设置焦虑水平
         */
        public Builder anxietyLevel(int level) {
            this.anxietyLevel = Math.max(0, Math.min(100, level)); // 限制范围0-100
            System.out.println("😰 焦虑等级：" + this.anxietyLevel + "/100");
            return this;
        }
        
        /**
         * 添加爱好
         */
        public Builder addHobby(String hobby) {
            this.hobbies.add(hobby);
            System.out.println("🎮 添加爱好：" + hobby);
            return this;
        }
        
        /**
         * 设置工作风格
         */
        public Builder workStyle(String style) {
            this.workStyle = style;
            System.out.println("💼 工作风格：" + style);
            return this;
        }
        
        /**
         * 设置Git技能
         */
        public Builder withGitSkill() {
            this.hasGitSkill = true;
            System.out.println("🌿 掌握Git版本控制技能");
            return this;
        }
        
        /**
         * 设置每日编码时长
         */
        public Builder codingHours(int hours) {
            this.codingHours = Math.max(1, Math.min(24, hours)); // 限制1-24小时
            System.out.println("⏰ 每日编码时长：" + this.codingHours + "小时");
            return this;
        }
        
        /**
         * 预设配置 - 前端瓦学弟
         */
        public Builder frontendPreset() {
            return this.major("前端开发")
                      .programmingLanguages("JavaScript", "TypeScript", "HTML", "CSS")
                      .frameworks("Vue3", "React", "Angular")
                      .personality("追求完美的UI控")
                      .anxietyLevel(40)
                      .addHobby("研究新的前端技术")
                      .workStyle("注重用户体验")
                      .withGitSkill()
                      .codingHours(10);
        }
        
        /**
         * 预设配置 - 后端瓦学弟
         */
        public Builder backendPreset() {
            return this.major("后端开发")
                      .programmingLanguages("Java", "Python", "Go")
                      .frameworks("Spring Boot", "Django", "Gin")
                      .addDatabase("MySQL").addDatabase("Redis").addDatabase("MongoDB")
                      .personality("逻辑思维强的技术宅")
                      .anxietyLevel(25)
                      .addHobby("优化系统性能")
                      .workStyle("注重代码质量和性能")
                      .withGitSkill()
                      .codingHours(12);
        }
        
        /**
         * 预设配置 - 全栈瓦学弟
         */
        public Builder fullStackPreset() {
            return this.major("全栈开发")
                      .programmingLanguages("JavaScript", "Java", "Python", "TypeScript")
                      .frameworks("Vue3", "Spring Boot", "Express.js")
                      .addDatabase("MySQL").addDatabase("MongoDB")
                      .personality("什么都会一点的技术通才")
                      .anxietyLevel(60) // 全栈压力更大
                      .addHobby("学习新技术").addHobby("架构设计")
                      .workStyle("快速迭代，全面发展")
                      .withGitSkill()
                      .codingHours(14);
        }
        
        /**
         * 验证配置有效性
         */
        private void validate() {
            if (name == null || name.trim().isEmpty()) {
                throw new IllegalArgumentException("瓦学弟姓名不能为空！");
            }
            if (age < 18 || age > 35) {
                throw new IllegalArgumentException("瓦学弟年龄应在18-35岁之间！");
            }
            if (programmingLanguages.isEmpty()) {
                System.out.println("⚠️  警告：瓦学弟居然不会任何编程语言！");
            }
        }
        
        /**
         * 构建最终的瓦学弟对象
         */
        public ValStudent build() {
            validate(); // 构建前验证
            
            System.out.println("🔨 最终检查配置...");
            System.out.println("✅ 瓦学弟配置验证通过！");
            
            return new ValStudent(this);
        }
    }
    
    /**
     * 展示瓦学弟信息
     */
    public void showInfo() {
        System.out.println("\n👤 ==========瓦学弟档案==========");
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age + "岁");
        System.out.println("专业：" + major);
        System.out.println("编程语言：" + programmingLanguages);
        System.out.println("框架技能：" + frameworks);
        System.out.println("数据库：" + databases);
        System.out.println("个性特征：" + personality);
        System.out.println("焦虑等级：" + anxietyLevel + "/100");
        System.out.println("兴趣爱好：" + hobbies);
        System.out.println("工作风格：" + workStyle);
        System.out.println("Git技能：" + (hasGitSkill ? "✅掌握" : "❌未掌握"));
        System.out.println("每日编码：" + codingHours + "小时");
        System.out.println("=================================");
    }
    
    /**
     * 瓦学弟工作
     */
    public void work() {
        System.out.println("💻 " + name + "开始了" + codingHours + "小时的编码工作");
        if (hasGitSkill) {
            System.out.println("🌿 熟练使用Git管理代码版本");
        }
        if (!frameworks.isEmpty()) {
            System.out.println("🚀 使用" + frameworks.get(0) + "框架快速开发");
        }
    }
    
    /**
     * 评估瓦学弟能力
     */
    public int calculateSkillLevel() {
        int score = 0;
        score += programmingLanguages.size() * 10; // 每种语言10分
        score += frameworks.size() * 15;           // 每种框架15分
        score += databases.size() * 12;            // 每种数据库12分
        score += hasGitSkill ? 20 : 0;            // Git技能20分
        score += Math.max(0, codingHours - 8) * 5; // 超过8小时的部分每小时5分
        score -= anxietyLevel / 2;                 // 焦虑会影响发挥
        
        return Math.max(0, score);
    }
    
    // Getter方法
    public String getName() { return name; }
    public List<String> getProgrammingLanguages() { return new ArrayList<>(programmingLanguages); }
    public int getAnxietyLevel() { return anxietyLevel; }
}

/**
 * 瓦学弟建造指导员 - 提供专业建造建议
 */
class ValStudentBuildDirector {
    
    /**
     * 构建入门级瓦学弟
     */
    public static ValStudent buildBeginnerStudent(String name, int age) {
        System.out.println("🎓 构建入门级瓦学弟...");
        return new ValStudent.Builder(name, age)
                .major("软件工程")
                .addProgrammingLanguage("Java")
                .addFramework("Spring Boot")
                .addDatabase("MySQL")
                .personality("初来乍到，充满求知欲")
                .anxietyLevel(70)
                .addHobby("刷LeetCode")
                .workStyle("勤奋好学")
                .codingHours(6)
                .build();
    }
    
    /**
     * 构建资深瓦学弟
     */
    public static ValStudent buildSeniorStudent(String name, int age) {
        System.out.println("🏆 构建资深瓦学弟...");
        return new ValStudent.Builder(name, age)
                .fullStackPreset()
                .anxietyLevel(20) // 经验丰富，焦虑更低
                .addHobby("技术分享").addHobby("带新人")
                .workStyle("经验丰富，游刃有余")
                .build();
    }
    
    /**
     * 构建特定技术栈瓦学弟
     */
    public static ValStudent buildSpecializedStudent(String name, int age, String specialty) {
        System.out.println("🎯 构建" + specialty + "专精瓦学弟...");
        ValStudent.Builder builder = new ValStudent.Builder(name, age);
        
        switch (specialty.toLowerCase()) {
            case "ai":
                return builder.major("人工智能")
                        .programmingLanguages("Python", "R", "Julia")
                        .frameworks("TensorFlow", "PyTorch", "Scikit-learn")
                        .addDatabase("Vector DB")
                        .personality("对AI充满热情的研究者")
                        .anxietyLevel(35)
                        .addHobby("研究最新AI论文")
                        .workStyle("实验驱动，数据导向")
                        .withGitSkill()
                        .codingHours(10)
                        .build();
                        
            case "mobile":
                return builder.major("移动开发")
                        .programmingLanguages("Kotlin", "Swift", "Dart")
                        .frameworks("Android SDK", "iOS SDK", "Flutter")
                        .addDatabase("SQLite")
                        .personality("追求流畅用户体验")
                        .anxietyLevel(45)
                        .addHobby("体验新App")
                        .workStyle("注重性能和用户体验")
                        .withGitSkill()
                        .codingHours(9)
                        .build();
                        
            default:
                return builder.backendPreset().build();
        }
    }
}

/**
 * 使用示例 - 瓦学弟制造车间
 */
public class ValStudentBuilderDemo {
    public static void main(String[] args) {
        System.out.println("🏭 2025年瓦学弟建造车间开始运营！\n");
        
        // 演示1：基础建造者使用
        demonstrateBasicBuilder();
        
        // 演示2：预设配置使用
        demonstratePresetConfigurations();
        
        // 演示3：建造指导员使用
        demonstrateBuildDirector();
        
        // 演示4：错误处理
        demonstrateErrorHandling();
        
        // 演示5：能力评估
        demonstrateSkillEvaluation();
    }
    
    /**
     * 基础建造者演示
     */
    private static void demonstrateBasicBuilder() {
        System.out.println("=== 基础建造者演示 ===");
        
        ValStudent basicStudent = new ValStudent.Builder("小明", 22)
                .major("计算机科学与技术")
                .addProgrammingLanguage("Java")
                .addProgrammingLanguage("Python")
                .addFramework("Spring Boot")
                .addFramework("Django")
                .addDatabase("MySQL")
                .personality("认真负责的技术新人")
                .anxietyLevel(50)
                .addHobby("打游戏")
                .addHobby("看技术博客")
                .workStyle("稳扎稳打")
                .withGitSkill()
                .codingHours(8)
                .build();
        
        basicStudent.showInfo();
        basicStudent.work();
        System.out.println("🏆 基础建造者使用得了MVP！\n");
    }
    
    /**
     * 预设配置演示
     */
    private static void demonstratePresetConfigurations() {
        System.out.println("=== 预设配置演示 ===");
        
        // 前端瓦学弟
        ValStudent frontendStudent = new ValStudent.Builder("Vue小王", 24)
                .frontendPreset()
                .build();
        frontendStudent.showInfo();
        
        // 后端瓦学弟
        ValStudent backendStudent = new ValStudent.Builder("Spring小李", 26)
                .backendPreset()
                .build();
        backendStudent.showInfo();
        
        // 全栈瓦学弟
        ValStudent fullStackStudent = new ValStudent.Builder("全栈小张", 28)
                .fullStackPreset()
                .build();
        fullStackStudent.showInfo();
        
        System.out.println("🏆 预设配置使用得了MVP！\n");
    }
    
    /**
     * 建造指导员演示
     */
    private static void demonstrateBuildDirector() {
        System.out.println("=== 建造指导员演示 ===");
        
        // 入门级瓦学弟
        ValStudent beginner = ValStudentBuildDirector.buildBeginnerStudent("新人小陈", 21);
        beginner.showInfo();
        
        // 资深瓦学弟
        ValStudent senior = ValStudentBuildDirector.buildSeniorStudent("大佬老刘", 30);
        senior.showInfo();
        
        // AI专精瓦学弟
        ValStudent aiExpert = ValStudentBuildDirector.buildSpecializedStudent("AI小周", 27, "ai");
        aiExpert.showInfo();
        
        System.out.println("🏆 建造指导员模式得了MVP！\n");
    }
    
    /**
     * 错误处理演示
     */
    private static void demonstrateErrorHandling() {
        System.out.println("=== 错误处理演示 ===");
        
        try {
            // 尝试创建无效瓦学弟
            new ValStudent.Builder("", 50).build();
        } catch (IllegalArgumentException e) {
            System.out.println("❌ 捕获错误：" + e.getMessage());
        }
        
        // 创建没有编程技能的瓦学弟（警告但不阻止）
        ValStudent noSkillStudent = new ValStudent.Builder("摸鱼小王", 25)
                .personality("只想摸鱼的咸鱼")
                .anxietyLevel(80)
                .addHobby("摸鱼")
                .build();
        
        System.out.println("🤦♂️ 吴京摇脑袋：这样的瓦学弟怎么能胜任工作！\n");
    }
    
    /**
     * 能力评估演示
     */
    private static void demonstrateSkillEvaluation() {
        System.out.println("=== 能力评估演示 ===");
        
        List<ValStudent> students = Arrays.asList(
            ValStudentBuildDirector.buildBeginnerStudent("新手", 22),
            ValStudentBuildDirector.buildSeniorStudent("大佬", 29),
            ValStudentBuildDirector.buildSpecializedStudent("AI专家", 26, "ai")
        );
        
        students.forEach(student -> {
            int skillLevel = student.calculateSkillLevel();
            System.out.println("📊 " + student.getName() + " 技能评分：" + skillLevel);
            
            if (skillLevel >= 100) {
                System.out.println("🏆 " + student.getName() + " 技能水平得了MVP！");
            } else if (skillLevel >= 60) {
                System.out.println("✅ " + student.getName() + " 技能水平合格");
            } else {
                System.out.println("⚠️ " + student.getName() + " 需要继续努力");
            }
        });
        
        System.out.println("\n🏆 建造者模式在瓦学弟培养上表现得了MVP！");
    }
}

/* 预期输出示例：
🏭 2025年瓦学弟建造车间开始运营！

=== 基础建造者演示 ===
🏗️ 开始组装瓦学弟：小明(22岁)
📚 设置专业：计算机科学与技术
💻 学会编程语言：Java
💻 学会编程语言：Python
🚀 掌握框架：Spring Boot
🚀 掌握框架：Django
🗄️ 学会数据库：MySQL
😊 个性设定：认真负责的技术新人
😰 焦虑等级：50/100
🎮 添加爱好：打游戏
🎮 添加爱好：看技术博客
💼 工作风格：稳扎稳打
🌿 掌握Git版本控制技能
⏰ 每日编码时长：8小时
🔨 最终检查配置...
✅ 瓦学弟配置验证通过！
🎯 瓦学弟组装完成：小明
...
*/

🎯 建造者模式2025年面试考点总结：

1. 建造者模式 vs 工厂模式？

   • 建造者：逐步构建复杂对象，关注构建过程
   • 工厂：直接创建对象，关注创建结果

2. 何时使用建造者模式？

   • 对象构造复杂，需要多个步骤
   • 对象有很多可选参数
   • 需要创建不同配置的同类对象

3. 链式调用的优势？

   • 代码可读性强
   • 参数设置灵活
   • 支持流式编程风格

---

第二章：结构型模式 - “对象关系的哲学” 🏗️

2.1 适配器模式 - “让不兼容的接口和谐共处”

想象一下，瓦学弟需要使用一个老旧的打印机系统，但这个系统的接口和现在的标准完全不兼容。这时候就需要一个"万能转换器"——适配器模式！

/**
 * 适配器模式演示 - 瓦学弟的万能接口转换器
 * 解决新老系统接口不兼容问题
 */

// 目标接口 - 现代化的打印接口
interface ModernPrinter {
    void print(String content);
    void printColor(String content, String color);
    void printWithFormat(String content, String format);
}

// 被适配者 - 老旧的打印机系统
class LegacyPrinter {
    public void oldPrint(String text) {
        System.out.println("🖨️ 老式打印机工作中: " + text);
    }
    
    public void oldPrintWithColor(String text, int colorCode) {
        String color = convertColorCode(colorCode);
        System.out.println("🌈 老式彩色打印: [" + color + "] " + text);
    }
    
    private String convertColorCode(int code) {
        switch (code) {
            case 1: return "红色";
            case 2: return "绿色";
            case 3: return "蓝色";
            default: return "黑色";
        }
    }
    
    public void oldPrintBold(String text) {
        System.out.println("🔤 老式粗体打印: **" + text + "**");
    }
}

// 适配器类 - 将老式打印机适配到现代接口
class PrinterAdapter implements ModernPrinter {
    private LegacyPrinter legacyPrinter;
    
    public PrinterAdapter(LegacyPrinter legacyPrinter) {
        this.legacyPrinter = legacyPrinter;
        System.out.println("🔌 打印机适配器已连接老式打印机");
    }
    
    @Override
    public void print(String content) {
        System.out.println("🔄 适配器转换中...");
        legacyPrinter.oldPrint(content);
    }
    
    @Override
    public void printColor(String content, String color) {
        System.out.println("🔄 适配器转换颜色中...");
        int colorCode = convertColorToCode(color);
        legacyPrinter.oldPrintWithColor(content, colorCode);
    }
    
    @Override
    public void printWithFormat(String content, String format) {
        System.out.println("🔄 适配器转换格式中...");
        if ("bold".equalsIgnoreCase(format)) {
            legacyPrinter.oldPrintBold(content);
        } else {
            legacyPrinter.oldPrint(content);
        }
    }
    
    private int convertColorToCode(String color) {
        switch (color.toLowerCase()) {
            case "红色": case "red": return 1;
            case "绿色": case "green": return 2;
            case "蓝色": case "blue": return 3;
            default: return 0;
        }
    }
}

/**
 * 另一个适配器示例 - 瓦学弟的数据库适配器
 */

// 现代数据库接口
interface ModernDatabase {
    void connect(String connectionString);
    List<Map<String, Object>> query(String sql);
    boolean execute(String sql);
    void disconnect();
}

// 老式数据库系统
class LegacyDatabase {
    private boolean connected = false;
    
    public void openConnection(String host, int port, String database, String user, String password) {
        System.out.println("🔗 老式数据库连接: " + host + ":" + port + "/" + database);
        this.connected = true;
    }
    
    public String[] executeQuery(String query) {
        if (!connected) {
            throw new RuntimeException("数据库未连接");
        }
        System.out.println("📊 老式查询执行: " + query);
        return new String[]{"result1", "result2", "result3"};
    }
    
    public int executeUpdate(String update) {
        if (!connected) {
            throw new RuntimeException("数据库未连接");
        }
        System.out.println("📝 老式更新执行: " + update);
        return 1; // 影响行数
    }
    
    public void closeConnection() {
        System.out.println("🔐 老式数据库连接已关闭");
        this.connected = false;
    }
}

// 数据库适配器
class DatabaseAdapter implements ModernDatabase {
    private LegacyDatabase legacyDb;
    
    public DatabaseAdapter(LegacyDatabase legacyDb) {
        this.legacyDb = legacyDb;
        System.out.println("🔌 数据库适配器已装载老式数据库");
    }
    
继续完成代理模式部分：

```java
        // 解析 "mysql://localhost:3306/testdb?user=root&password=123456"
        String[] parts = connectionString.split("://")[1].split("\\?");
        String[] hostAndDb = parts[0].split("/");
        String[] hostAndPort = hostAndDb[0].split(":");
        
        String host = hostAndPort[0];
        int port = Integer.parseInt(hostAndPort[1]);
        String database = hostAndDb[1];
        
        // 解析参数
        String[] params = parts[1].split("&");
        String user = "";
        String password = "";
        
        for (String param : params) {
            String[] kv = param.split("=");
            if ("user".equals(kv[0])) user = kv[1];
            if ("password".equals(kv[0])) password = kv[1];
        }
        
        legacyDb.openConnection(host, port, database, user, password);
    }
    
    @Override
    public List<Map<String, Object>> query(String sql) {
        System.out.println("🔄 适配器转换查询语句...");
        String[] results = legacyDb.executeQuery(sql);
        
        // 将字符串数组转换为现代格式
        List<Map<String, Object>> modernResults = new ArrayList<>();
        for (String result : results) {
            Map<String, Object> row = new HashMap<>();
            row.put("data", result);
            modernResults.add(row);
        }
        
        return modernResults;
    }
    
    @Override
    public boolean execute(String sql) {
        System.out.println("🔄 适配器转换执行语句...");
        try {
            int affectedRows = legacyDb.executeUpdate(sql);
            return affectedRows > 0;
        } catch (Exception e) {
            return false;
        }
    }
    
    @Override
    public void disconnect() {
        System.out.println("🔄 适配器关闭连接...");
        legacyDb.closeConnection();
    }
}

/**
 * 使用示例 - 瓦学弟的接口兼容挑战
 */
public class AdapterPatternDemo {
    public static void main(String[] args) {
        System.out.println("🔌 瓦学弟的接口适配挑战开始！\n");
        
        // 演示1：打印机适配器
        demonstratePrinterAdapter();
        
        // 演示2：数据库适配器
        demonstrateDatabaseAdapter();
        
        // 演示3：多层适配链
        demonstrateAdapterChain();
        
        System.out.println("🏆 适配器模式在系统集成中表现得了MVP！");
    }
    
    private static void demonstratePrinterAdapter() {
        System.out.println("=== 打印机适配器演示 ===");
        
        // 老式打印机
        LegacyPrinter legacyPrinter = new LegacyPrinter();
        
        // 通过适配器使用现代接口
        ModernPrinter modernPrinter = new PrinterAdapter(legacyPrinter);
        
        // 瓦学弟使用现代接口打印
        System.out.println("📄 瓦学弟开始打印文档...");
        modernPrinter.print("瓦学弟的求职简历");
        modernPrinter.printColor("重要提醒：面试时间变更", "红色");
        modernPrinter.printWithFormat("项目经验：设计模式应用", "bold");
        
        System.out.println("✅ 打印机适配器工作完美！\n");
    }
    
    private static void demonstrateDatabaseAdapter() {
        System.out.println("=== 数据库适配器演示 ===");
        
        // 老式数据库
        LegacyDatabase legacyDb = new LegacyDatabase();
        
        // 通过适配器使用现代接口
        ModernDatabase modernDb = new DatabaseAdapter(legacyDb);
        
        try {
            // 瓦学弟连接数据库
            System.out.println("💾 瓦学弟连接公司数据库...");
            modernDb.connect("mysql://localhost:3306/company?user=valstudent&password=123456");
            
            // 查询数据
            System.out.println("🔍 查询员工信息...");
            List<Map<String, Object>> results = modernDb.query("SELECT * FROM employees WHERE department='IT'");
            results.forEach(row -> System.out.println("📊 查询结果：" + row));
            
            // 执行更新
            System.out.println("📝 更新员工信息...");
            boolean success = modernDb.execute("UPDATE employees SET skill_level = skill_level + 1 WHERE name = '瓦学弟'");
            System.out.println("✅ 更新" + (success ? "成功" : "失败"));
            
            // 断开连接
            modernDb.disconnect();
            
        } catch (Exception e) {
            System.out.println("❌ 数据库操作异常：" + e.getMessage());
        }
        
        System.out.println("✅ 数据库适配器工作完美！\n");
    }
    
    private static void demonstrateAdapterChain() {
        System.out.println("=== 多层适配链演示 ===");
        
        // 这种场景常见于系统迁移过程中
        System.out.println("🔄 瓦学弟处理复杂的系统迁移场景...");
        System.out.println("   老系统 -> 适配器1 -> 中间层 -> 适配器2 -> 新系统");
        System.out.println("🏆 多层适配确保了系统的平滑过渡！");
    }
}

2.2 装饰者模式 - “给瓦学弟加buff的技术”

想象瓦学弟就像游戏角色一样，可以通过各种装备和技能来增强自己的能力。装饰者模式就是给瓦学弟"加buff"的神奇技术！

/**
 * 装饰者模式演示 - 瓦学弟的技能加成系统
 * 动态为瓦学弟添加各种技能buff，实现能力的灵活组合
 */

// 抽象组件 - 瓦学弟基础接口
interface ValStudent {
    String work();           // 工作能力
    int getProductivity();   // 生产力数值
    String getSkillSet();    // 技能描述
}

// 具体组件 - 基础瓦学弟
class BasicValStudent implements ValStudent {
    private String name;
    
    public BasicValStudent(String name) {
        this.name = name;
        System.out.println("🎮 基础瓦学弟 " + name + " 入职了");
    }
    
    @Override
    public String work() {
        return name + "正在进行基础编程工作";
    }
    
    @Override
    public int getProductivity() {
        return 50; // 基础生产力50
    }
    
    @Override
    public String getSkillSet() {
        return "基础编程技能";
    }
}

// 抽象装饰者
abstract class ValStudentDecorator implements ValStudent {
    protected ValStudent valStudent;
    
    public ValStudentDecorator(ValStudent valStudent) {
        this.valStudent = valStudent;
    }
    
    @Override
    public String work() {
        return valStudent.work();
    }
    
    @Override
    public int getProductivity() {
        return valStudent.getProductivity();
    }
    
    @Override
    public String getSkillSet() {
        return valStudent.getSkillSet();
    }
}

// 具体装饰者1 - 前端技能装饰器
class FrontendSkillDecorator extends ValStudentDecorator {
    
    public FrontendSkillDecorator(ValStudent valStudent) {
        super(valStudent);
        System.out.println("🎨 为瓦学弟添加前端技能buff！");
    }
    
    @Override
    public String work() {
        return super.work() + " + 开发精美的用户界面";
    }
    
    @Override
    public int getProductivity() {
        return super.getProductivity() + 30; // 前端技能+30生产力
    }
    
    @Override
    public String getSkillSet() {
        return super.getSkillSet() + " + 前端开发(Vue3/React/CSS3)";
    }
    
    // 前端特有功能
    public String designUI() {
        return "✨ 设计了一个让用户惊艳的界面，这波UI设计得了MVP！";
    }
}

// 具体装饰者2 - 后端技能装饰器
class BackendSkillDecorator extends ValStudentDecorator {
    
    public BackendSkillDecorator(ValStudent valStudent) {
        super(valStudent);
        System.out.println("⚙️ 为瓦学弟添加后端技能buff！");
    }
    
    @Override
    public String work() {
        return super.work() + " + 构建高性能后端服务";
    }
    
    @Override
    public int getProductivity() {
        return super.getProductivity() + 35; // 后端技能+35生产力
    }
    
    @Override
    public String getSkillSet() {
        return super.getSkillSet() + " + 后端开发(Spring Boot/微服务/数据库)";
    }
    
    // 后端特有功能
    public String optimizePerformance() {
        return "🚀 优化了系统性能，QPS提升500%，这波优化得了MVP！";
    }
}

// 具体装饰者3 - AI技能装饰器
class AISkillDecorator extends ValStudentDecorator {
    
    public AISkillDecorator(ValStudent valStudent) {
        super(valStudent);
        System.out.println("🤖 为瓦学弟添加AI技能buff！");
    }
    
    @Override
    public String work() {
        return super.work() + " + 开发智能AI应用";
    }
    
    @Override
    public int getProductivity() {
        return super.getProductivity() + 50; // AI技能+50生产力
    }
    
    @Override
    public String getSkillSet() {
        return super.getSkillSet() + " + AI开发(机器学习/深度学习/NLP)";
    }
    
    // AI特有功能
    public String trainModel() {
        return "🧠 训练了一个准确率99%的模型，这波AI算法得了MVP！";
    }
}

// 具体装饰者4 - 领导力装饰器
class LeadershipDecorator extends ValStudentDecorator {
    
    public LeadershipDecorator(ValStudent valStudent) {
        super(valStudent);
        System.out.println("👑 为瓦学弟添加领导力buff！");
    }
    
    @Override
    public String work() {
        return super.work() + " + 带领团队高效协作";
    }
    
    @Override
    public int getProductivity() {
        int baseProductivity = super.getProductivity();
        // 领导力不仅增加固定值，还有乘法效应
        return baseProductivity + (int)(baseProductivity * 0.3) + 20;
    }
    
    @Override
    public String getSkillSet() {
        return super.getSkillSet() + " + 领导力(团队管理/项目规划/沟通协调)";
    }
    
    // 领导力特有功能
    public String motivateTeam() {
        return "📣 激励团队士气，团队整体效率提升40%，这波领导力得了MVP！";
    }
}

// 具体装饰者5 - 学习能力装饰器
class LearningAbilityDecorator extends ValStudentDecorator {
    
    public LearningAbilityDecorator(ValStudent valStudent) {
        super(valStudent);
        System.out.println("📚 为瓦学弟添加超强学习能力buff！");
    }
    
    @Override
    public String work() {
        return super.work() + " + 快速掌握新技术并应用";
    }
    
    @Override
    public int getProductivity() {
        return super.getProductivity() + 25; // 学习能力+25生产力
    }
    
    @Override
    public String getSkillSet() {
        return super.getSkillSet() + " + 超强学习能力(快速上手/技术敏感度高)";
    }
    
    // 学习能力特有功能
    public String learnNewTech() {
        return "🔥 一周内掌握了最新的技术栈，这波学习能力得了MVP！";
    }
}

// 具体装饰者6 - 抗压能力装饰器
class StressResistanceDecorator extends ValStudentDecorator {
    
    public StressResistanceDecorator(ValStudent valStudent) {
        super(valStudent);
        System.out.println("💪 为瓦学弟添加抗压能力buff！");
    }
    
    @Override
    public String work() {
        return super.work() + " + 在高压环境下保持高效";
    }
    
    @Override
    public int getProductivity() {
        return super.getProductivity() + 20; // 抗压能力+20生产力
    }
    
    @Override
    public String getSkillSet() {
        return super.getSkillSet() + " + 强大抗压能力(压力下不掉链子)";
    }
    
    // 抗压能力特有功能
    public String handlePressure() {
        return "😤 在996的压力下依然保持高质量输出，这波抗压能力得了MVP！";
    }
}

/**
 * 装饰器管理器 - 2025年升级版
 */
class DecoratorManager {
    
    /**
     * 创建全栈瓦学弟 - 预设装饰器组合
     */
    public static ValStudent createFullStackValStudent(String name) {
        System.out.println("🚀 正在打造全栈瓦学弟：" + name);
        
        ValStudent student = new BasicValStudent(name);
        student = new FrontendSkillDecorator(student);
        student = new BackendSkillDecorator(student);
        student = new LearningAbilityDecorator(student);
        
        System.out.println("✅ 全栈瓦学弟打造完成！");
        return student;
    }
    
    /**
     * 创建技术大牛瓦学弟
     */
    public static ValStudent createTechExpertValStudent(String name) {
        System.out.println("🏆 正在打造技术大牛瓦学弟：" + name);
        
        ValStudent student = new BasicValStudent(name);
        student = new BackendSkillDecorator(student);
        student = new AISkillDecorator(student);
        student = new LearningAbilityDecorator(student);
        student = new StressResistanceDecorator(student);
        
        System.out.println("✅ 技术大牛瓦学弟打造完成！");
        return student;
    }
    
    /**
     * 创建团队领袖瓦学弟
     */
    public static ValStudent createTeamLeaderValStudent(String name) {
        System.out.println("👑 正在打造团队领袖瓦学弟：" + name);
        
        ValStudent student = new BasicValStudent(name);
        student = new BackendSkillDecorator(student);
        student = new LeadershipDecorator(student);
        student = new StressResistanceDecorator(student);
        student = new LearningAbilityDecorator(student);
        
        System.out.println("✅ 团队领袖瓦学弟打造完成！");
        return student;
    }
    
    /**
     * 动态装饰器链构建
     */
    public static class DecoratorChainBuilder {
        private ValStudent student;
        
        public DecoratorChainBuilder(String name) {
            this.student = new BasicValStudent(name);
        }
        
        public DecoratorChainBuilder addFrontendSkill() {
            this.student = new FrontendSkillDecorator(student);
            return this;
        }
        
        public DecoratorChainBuilder addBackendSkill() {
            this.student = new BackendSkillDecorator(student);
            return this;
        }
        
        public DecoratorChainBuilder addAISkill() {
            this.student = new AISkillDecorator(student);
            return this;
        }
        
        public DecoratorChainBuilder addLeadership() {
            this.student = new LeadershipDecorator(student);
            return this;
        }
        
        public DecoratorChainBuilder addLearningAbility() {
            this.student = new LearningAbilityDecorator(student);
            return this;
        }
        
        public DecoratorChainBuilder addStressResistance() {
            this.student = new StressResistanceDecorator(student);
            return this;
        }
        
        public ValStudent build() {
            return student;
        }
    }
}

/**
 * 使用示例 - 瓦学弟的职场成长之路
 */
public class DecoratorPatternDemo {
    public static void main(String[] args) {
        System.out.println("🎮 瓦学弟技能加成系统启动！\n");
        
        // 演示1：基础装饰器使用
        demonstrateBasicDecorator();
        
        // 演示2：复杂装饰器链
        demonstrateComplexDecoratorChain();
        
        // 演示3：预设装饰器组合
        demonstratePresetCombinations();
        
        // 演示4：动态装饰器构建
        demonstrateDynamicBuilder();
        
        // 演示5：装饰器性能对比
        demonstratePerformanceComparison();
        
        System.out.println("🏆 装饰者模式在瓦学弟能力提升上表现得了MVP！");
    }
    
    private static void demonstrateBasicDecorator() {
        System.out.println("=== 基础装饰器演示 ===");
        
        // 基础瓦学弟
        ValStudent basicStudent = new BasicValStudent("小白");
        showStudentInfo(basicStudent);
        
        // 添加前端技能
        ValStudent frontendStudent = new FrontendSkillDecorator(basicStudent);
        showStudentInfo(frontendStudent);
        
        // 再添加后端技能
        ValStudent fullStackStudent = new BackendSkillDecorator(frontendStudent);
        showStudentInfo(fullStackStudent);
        
        System.out.println();
    }
    
    private static void demonstrateComplexDecoratorChain() {
        System.out.println("=== 复杂装饰器链演示 ===");
        
        // 层层装饰，打造超级瓦学弟
        ValStudent superStudent = new BasicValStudent("超级瓦学弟");
        superStudent = new FrontendSkillDecorator(superStudent);
        superStudent = new BackendSkillDecorator(superStudent);
        superStudent = new AISkillDecorator(superStudent);
        superStudent = new LeadershipDecorator(superStudent);
        superStudent = new LearningAbilityDecorator(superStudent);
        superStudent = new StressResistanceDecorator(superStudent);
        
        showStudentInfo(superStudent);
        
        // 展示特殊技能
        if (superStudent instanceof StressResistanceDecorator) {
            System.out.println(((StressResistanceDecorator) superStudent).handlePressure());
        }
        
        System.out.println();
    }
    
    private static void demonstratePresetCombinations() {
        System.out.println("=== 预设装饰器组合演示 ===");
        
        // 全栈瓦学弟
        ValStudent fullStackStudent = DecoratorManager.createFullStackValStudent("全栈小王");
        showStudentInfo(fullStackStudent);
        
        // 技术大牛瓦学弟
        ValStudent techExpert = DecoratorManager.createTechExpertValStudent("大牛老李");
        showStudentInfo(techExpert);
        
        // 团队领袖瓦学弟
        ValStudent teamLeader = DecoratorManager.createTeamLeaderValStudent("领袖小张");
        showStudentInfo(teamLeader);
        
        System.out.println();
    }
    
    private static void demonstrateDynamicBuilder() {
        System.out.println("=== 动态装饰器构建演示 ===");
        
        ValStudent customStudent = new DecoratorManager.DecoratorChainBuilder("定制瓦学弟")
                .addBackendSkill()
                .addAISkill()
                .addLeadership()
                .addStressResistance()
                .build();
        
        showStudentInfo(customStudent);
        System.out.println();
    }
    
    private static void demonstratePerformanceComparison() {
        System.out.println("=== 装饰器性能对比 ===");
        
        List<ValStudent> students = Arrays.asList(
            new BasicValStudent("基础瓦学弟"),
            DecoratorManager.createFullStackValStudent("全栈瓦学弟"),
            DecoratorManager.createTechExpertValStudent("大牛瓦学弟"),
            DecoratorManager.createTeamLeaderValStudent("领袖瓦学弟")
        );
        
        System.out.println("📊 生产力排行榜：");
        students.stream()
                .sorted((s1, s2) -> Integer.compare(s2.getProductivity(), s1.getProductivity()))
                .forEach(student -> {
                    int productivity = student.getProductivity();
                    String rank = productivity >= 200 ? "🏆S级" : 
                                 productivity >= 150 ? "🥇A级" : 
                                 productivity >= 100 ? "🥈B级" : "🥉C级";
                    System.out.println(rank + " 生产力: " + productivity + " - " + 
                                     student.getSkillSet().split(" \\+ ")[0]);
                });
        
        System.out.println();
    }
    
    private static void showStudentInfo(ValStudent student) {
        System.out.println("👤 ==========瓦学弟状态==========");
        System.out.println("🔧 工作内容: " + student.work());
        System.out.println("📊 生产力: " + student.getProductivity());
        System.out.println("🎯 技能树: " + student.getSkillSet());
        System.out.println("================================\n");
    }
}

/* 预期输出示例：
🎮 瓦学弟技能加成系统启动！

=== 基础装饰器演示 ===
🎮 基础瓦学弟 小白 入职了
👤 ==========瓦学弟状态==========
🔧 工作内容: 小白正在进行基础编程工作
📊 生产力: 50
🎯 技能树: 基础编程技能
================================

🎨 为瓦学弟添加前端技能buff！
👤 ==========瓦学弟状态==========
🔧 工作内容: 小白正在进行基础编程工作 + 开发精美的用户界面
📊 生产力: 80
🎯 技能树: 基础编程技能 + 前端开发(Vue3/React/CSS3)
================================
...
*/

2.3 代理模式 - “瓦学弟的经纪人”

基于最新搜索到的代理模式资料，让我们看看瓦学弟如何通过"经纪人"来管理自己的工作！

/**
 * 代理模式演示 - 瓦学弟的智能经纪人系统
 * 2025年最新版：融合静态代理、JDK动态代理和CGLIB代理
 */

// 抽象主题接口 - 瓦学弟工作接口
interface WorkService {
    String coding(String project);
    String debugging(String bug);
    String learning(String technology);
    String meeting(String topic);
}

// 真实主题 - 实际工作的瓦学弟
class RealValStudent implements WorkService {
    private String name;
    private int workLoad = 0; // 工作负载
    
    public RealValStudent(String name) {
        this.name = name;
        System.out.println("👨‍💻 真实瓦学弟 " + name + " 准备开始工作");
    }
    
    @Override
    public String coding(String project) {
        workLoad += 30;
        System.out.println("⌨️ " + name + " 正在专心编写 " + project + " 代码...");
        
        // 模拟编码时间
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        return name + " 完成了 " + project + " 的核心功能开发";
    }
    
    @Override
    public String debugging(String bug) {
        workLoad += 20;
        System.out.println("🐛 " + name + " 正在调试 " + bug + " 问题...");
        
        // 模拟调试时间
        try {
            Thread.sleep(80);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        return name + " 成功修复了 " + bug + " bug";
    }
    
    @Override
    public String learning(String technology) {
        workLoad += 15;
        System.out.println("📚 " + name + " 正在学习 " + technology + "...");
        
        try {
            Thread.sleep(60);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        return name + " 掌握了 " + technology + " 技术";
    }
    
    @Override
    public String meeting(String topic) {
        workLoad += 10;
        System.out.println("🤝 " + name + " 正在参加 " + topic + " 会议...");
        
        try {
            Thread.sleep(40);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        return name + " 参与了 " + topic + " 讨论";
    }
    
    public int getWorkLoad() {
        return workLoad;
    }
    
    public String getName() {
        return name;
    }
}

// 静态代理 - 瓦学弟的保护型经纪人
class ProtectionProxy implements WorkService {
    private RealValStudent realStudent;
    private String clientRole;
    
    public ProtectionProxy(RealValStudent realStudent, String clientRole) {
        this.realStudent = realStudent;
        this.clientRole = clientRole;
        System.out.println("🛡️ 保护代理已为 " + realStudent.getName() + " 激活");
    }
    
    @Override
    public String coding(String project) {
        if (checkPermission("coding")) {
            return realStudent.coding(project);
        } else {
            return "❌ 权限不足：" + clientRole + " 无法安排编码任务";
        }
    }
    
    @Override
    public String debugging(String bug) {
        if (checkPermission("debugging")) {
            return realStudent.debugging(bug);
        } else {
            return "❌ 权限不足：" + clientRole + " 无法安排调试任务";
        }
    }
    
    @Override
    public String learning(String technology) {
        if (checkPermission("learning")) {
            return realStudent.learning(technology);
        } else {
            return "❌ 权限不足：" + clientRole + " 无法安排学习任务";
        }
    }
    
    @Override
    public String meeting(String topic) {
        if (checkPermission("meeting")) {
            return realStudent.meeting(topic);
        } else {
            return "❌ 权限不足：" + clientRole + " 无法安排会议";
        }
    }
    
    private boolean checkPermission(String operation) {
        switch (clientRole.toLowerCase()) {
            case "manager":
                return true; // 管理员有所有权限
            case "teammate":
                return !operation.equals("meeting"); // 同事不能安排会议
            case "intern":
                return operation.equals("learning"); // 实习生只能安排学习
            default:
                return false;
        }
    }
}

继续完成代理模式部分：

```java
// 虚拟代理 - 延迟加载瓦学弟
class VirtualProxy implements WorkService {
    private RealValStudent realStudent;
    private String studentName;
    private boolean isLoaded = false;
    
    public VirtualProxy(String studentName) {
        this.studentName = studentName;
        System.out.println("🔮 虚拟代理已创建，瓦学弟 " + studentName + " 尚未实际加载");
    }
    
    private void loadRealStudentIfNeeded() {
        if (!isLoaded) {
            System.out.println("⏳ 首次访问，正在加载真实瓦学弟...");
            realStudent = new RealValStudent(studentName);
            isLoaded = true;
            System.out.println("✅ 真实瓦学弟加载完成！");
        }
    }
    
    @Override
    public String coding(String project) {
        loadRealStudentIfNeeded();
        return realStudent.coding(project);
    }
    
    @Override
    public String debugging(String bug) {
        loadRealStudentIfNeeded();
        return realStudent.debugging(bug);
    }
    
    @Override
    public String learning(String technology) {
        loadRealStudentIfNeeded();
        return realStudent.learning(technology);
    }
    
    @Override
    public String meeting(String topic) {
        loadRealStudentIfNeeded();
        return realStudent.meeting(topic);
    }
}

// 智能代理 - 日志记录和性能监控
class SmartProxy implements WorkService {
    private WorkService target;
    private String proxyName;
    
    public SmartProxy(WorkService target, String proxyName) {
        this.target = target;
        this.proxyName = proxyName;
        System.out.println("🤖 智能代理 " + proxyName + " 已激活");
    }
    
    @Override
    public String coding(String project) {
        return executeWithMonitoring("编码", project, () -> target.coding(project));
    }
    
    @Override
    public String debugging(String bug) {
        return executeWithMonitoring("调试", bug, () -> target.debugging(bug));
    }
    
    @Override
    public String learning(String technology) {
        return executeWithMonitoring("学习", technology, () -> target.learning(technology));
    }
    
    @Override
    public String meeting(String topic) {
        return executeWithMonitoring("会议", topic, () -> target.meeting(topic));
    }
    
    private String executeWithMonitoring(String operation, String param, Supplier<String> action) {
        System.out.println("📊 [" + proxyName + "] 开始监控: " + operation + "(" + param + ")");
        long startTime = System.currentTimeMillis();
        
        try {
            String result = action.get();
            long endTime = System.currentTimeMillis();
            System.out.println("✅ [" + proxyName + "] " + operation + "完成，耗时: " + (endTime - startTime) + "ms");
            return result;
        } catch (Exception e) {
            System.out.println("❌ [" + proxyName + "] " + operation + "执行失败: " + e.getMessage());
            throw e;
        }
    }
}

// JDK动态代理 - 2025年最新实现
class JDKDynamicProxyHandler implements InvocationHandler {
    private Object target;
    private String proxyType;
    
    public JDKDynamicProxyHandler(Object target, String proxyType) {
        this.target = target;
        this.proxyType = proxyType;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("🌟 [JDK动态代理-" + proxyType + "] 拦截方法: " + method.getName());
        
        long startTime = System.currentTimeMillis();
        
        // 前置处理
        beforeMethod(method, args);
        
        try {
            // 执行原方法
            Object result = method.invoke(target, args);
            
            // 后置处理
            afterMethod(method, args, result, startTime);
            
            return result;
        } catch (Exception e) {
            // 异常处理
            handleException(method, args, e);
            throw e;
        }
    }
    
    private void beforeMethod(Method method, Object[] args) {
        System.out.println("🔄 前置处理: 准备执行 " + method.getName());
        if (args != null && args.length > 0) {
            System.out.println("📝 参数: " + Arrays.toString(args));
        }
    }
    
    private void afterMethod(Method method, Object[] args, Object result, long startTime) {
        long endTime = System.currentTimeMillis();
        System.out.println("✅ 后置处理: " + method.getName() + " 执行完成");
        System.out.println("⏱️ 执行时间: " + (endTime - startTime) + "ms");
        System.out.println("📤 返回结果: " + result);
    }
    
    private void handleException(Method method, Object[] args, Exception e) {
        System.out.println("💥 异常处理: " + method.getName() + " 执行异常");
        System.out.println("🚨 异常信息: " + e.getMessage());
    }
    
    /**
     * 创建JDK动态代理实例
     */
    public static <T> T createProxy(T target, String proxyType, Class<T> interfaceClass) {
        return (T) Proxy.newProxyInstance(
            interfaceClass.getClassLoader(),
            new Class[]{interfaceClass},
            new JDKDynamicProxyHandler(target, proxyType)
        );
    }
}

// CGLIB动态代理 - 2025年升级版（模拟实现，实际需要cglib依赖）
class CGLIBProxyHandler {
    
    /**
     * 模拟CGLIB代理创建过程
     * 实际使用时需要引入cglib依赖
     */
    public static <T> T createProxy(T target, String proxyType) {
        System.out.println("🔧 [CGLIB代理-" + proxyType + "] 创建基于类的代理");
        System.out.println("💡 CGLIB可以代理没有接口的类，通过继承实现");
        
        // 这里简化实现，实际CGLIB会生成字节码
        return (T) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces().length > 0 ? 
                target.getClass().getInterfaces() : 
                new Class[]{Object.class},
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("🧬 [CGLIB] 拦截方法: " + method.getName());
                    
                    long startTime = System.currentTimeMillis();
                    Object result = method.invoke(target, args);
                    long endTime = System.currentTimeMillis();
                    
                    System.out.println("🧬 [CGLIB] 方法执行完成，耗时: " + (endTime - startTime) + "ms");
                    return result;
                }
            }
        );
    }
}

// 代理管理器 - 2025年企业级代理管理
class ProxyManager {
    private static final Map<String, WorkService> proxyCache = new ConcurrentHashMap<>();
    
    /**
     * 创建保护代理
     */
    public static WorkService createProtectionProxy(String studentName, String clientRole) {
        String key = "protection_" + studentName + "_" + clientRole;
        return proxyCache.computeIfAbsent(key, k -> {
            RealValStudent realStudent = new RealValStudent(studentName);
            return new ProtectionProxy(realStudent, clientRole);
        });
    }
    
    /**
     * 创建虚拟代理
     */
    public static WorkService createVirtualProxy(String studentName) {
        String key = "virtual_" + studentName;
        return proxyCache.computeIfAbsent(key, k -> new VirtualProxy(studentName));
    }
    
    /**
     * 创建智能代理
     */
    public static WorkService createSmartProxy(WorkService target, String proxyName) {
        return new SmartProxy(target, proxyName);
    }
    
    /**
     * 创建JDK动态代理
     */
    public static WorkService createJDKProxy(WorkService target, String proxyType) {
        return JDKDynamicProxyHandler.createProxy(target, proxyType, WorkService.class);
    }
    
    /**
     * 创建CGLIB代理
     */
    public static WorkService createCGLIBProxy(WorkService target, String proxyType) {
        return CGLIBProxyHandler.createProxy(target, proxyType);
    }
    
    /**
     * 创建代理链 - 多个代理组合
     */
    public static WorkService createProxyChain(String studentName, String clientRole) {
        // 创建真实对象
        RealValStudent realStudent = new RealValStudent(studentName);
        
        // 第一层：保护代理
        WorkService protectionProxy = new ProtectionProxy(realStudent, clientRole);
        
        // 第二层：智能代理（监控）
        WorkService smartProxy = new SmartProxy(protectionProxy, "智能监控");
        
        // 第三层：JDK动态代理（日志）
        WorkService jdkProxy = createJDKProxy(smartProxy, "日志记录");
        
        System.out.println("🔗 代理链创建完成: 真实对象 -> 保护代理 -> 智能代理 -> JDK代理");
        return jdkProxy;
    }
    
    /**
     * 获取代理缓存统计
     */
    public static void printCacheStats() {
        System.out.println("📊 代理缓存统计:");
        System.out.println("   缓存大小: " + proxyCache.size());
        proxyCache.keySet().forEach(key -> System.out.println("   - " + key));
    }
}

/**
 * 使用示例 - 瓦学弟的代理人生
 */
public class ProxyPatternDemo {
    public static void main(String[] args) {
        System.out.println("🎭 瓦学弟的代理人生开始了！\n");
        
        // 演示1：静态代理
        demonstrateStaticProxy();
        
        // 演示2：虚拟代理
        demonstrateVirtualProxy();
        
        // 演示3：动态代理对比
        demonstrateDynamicProxy();
        
        // 演示4：代理链
        demonstrateProxyChain();
        
        // 演示5：性能对比
        demonstratePerformanceComparison();
        
        // 演示6：代理管理
        demonstrateProxyManagement();
        
        System.out.println("🏆 代理模式在瓦学弟管理系统中表现得了MVP！");
    }
    
    private static void demonstrateStaticProxy() {
        System.out.println("=== 静态代理演示 ===");
        
        // 创建真实瓦学弟
        RealValStudent realStudent = new RealValStudent("勤奋小王");
        
        // 不同角色的保护代理测试
        System.out.println("👨‍💼 管理员访问:");
        WorkService managerProxy = new ProtectionProxy(realStudent, "manager");
        System.out.println(managerProxy.coding("电商系统"));
        System.out.println(managerProxy.meeting("项目评审"));
        
        System.out.println("\n👥 同事访问:");
        WorkService teammateProxy = new ProtectionProxy(realStudent, "teammate");
        System.out.println(teammateProxy.coding("bug修复"));
        System.out.println(teammateProxy.meeting("团队会议")); // 应该被拒绝
        
        System.out.println("\n🎓 实习生访问:");
        WorkService internProxy = new ProtectionProxy(realStudent, "intern");
        System.out.println(internProxy.learning("Spring Boot"));
        System.out.println(internProxy.coding("项目开发")); // 应该被拒绝
        
        System.out.println();
    }
    
    private static void demonstrateVirtualProxy() {
        System.out.println("=== 虚拟代理演示 ===");
        
        // 创建虚拟代理，此时真实对象尚未创建
        WorkService virtualProxy = new VirtualProxy("懒加载小李");
        
        System.out.println("💤 虚拟代理已创建，但真实对象还未加载");
        System.out.println("🔍 现在访问第一个方法...");
        System.out.println(virtualProxy.learning("设计模式"));
        
        System.out.println("\n🔍 再次访问其他方法...");
        System.out.println(virtualProxy.coding("单例模式实现"));
        
        System.out.println();
    }
    
    private static void demonstrateDynamicProxy() {
        System.out.println("=== 动态代理对比演示 ===");
        
        RealValStudent realStudent = new RealValStudent("动态小张");
        
        // JDK动态代理
        System.out.println("🌟 JDK动态代理测试:");
        WorkService jdkProxy = ProxyManager.createJDKProxy(realStudent, "日志增强");
        System.out.println(jdkProxy.coding("用户管理模块"));
        
        System.out.println("\n🧬 CGLIB动态代理测试:");
        WorkService cglibProxy = ProxyManager.createCGLIBProxy(realStudent, "性能监控");
        System.out.println(cglibProxy.debugging("内存泄漏问题"));
        
        System.out.println("\n💡 JDK vs CGLIB 对比:");
        System.out.println("   JDK动态代理: 基于接口，运行时生成代理类");
        System.out.println("   CGLIB代理: 基于继承，使用字节码技术");
        System.out.println("   Spring框架会根据情况自动选择合适的代理方式");
        
        System.out.println();
    }
    
    private static void demonstrateProxyChain() {
        System.out.println("=== 代理链演示 ===");
        
        // 创建代理链
        WorkService proxyChain = ProxyManager.createProxyChain("代理链小赵", "manager");
        
        System.out.println("🔗 代理链访问测试:");
        System.out.println(proxyChain.coding("微服务架构"));
        
        System.out.println("\n💡 代理链的优势:");
        System.out.println("   ✅ 职责分离: 每个代理专注一个功能");
        System.out.println("   ✅ 灵活组合: 可以根据需要组合不同代理");
        System.out.println("   ✅ 易于扩展: 新增功能只需添加新的代理层");
        
        System.out.println();
    }
    
    private static void demonstratePerformanceComparison() {
        System.out.println("=== 性能对比演示 ===");
        
        RealValStudent realStudent = new RealValStudent("性能测试员");
        
        // 直接调用
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            realStudent.coding("性能测试-" + i);
        }
        long directTime = System.currentTimeMillis() - startTime;
        
        // 代理调用
        WorkService smartProxy = new SmartProxy(realStudent, "性能代理");
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            smartProxy.coding("代理测试-" + i);
        }
        long proxyTime = System.currentTimeMillis() - startTime;
        
        System.out.println("📊 性能对比结果:");
        System.out.println("   直接调用1000次耗时: " + directTime + "ms");
        System.out.println("   代理调用1000次耗时: " + proxyTime + "ms");
        System.out.println("   代理开销: " + (proxyTime - directTime) + "ms");
        System.out.println("   性能影响: " + String.format("%.2f%%", 
            (double)(proxyTime - directTime) / directTime * 100));
        
        System.out.println();
    }
    
    private static void demonstrateProxyManagement() {
        System.out.println("=== 代理管理演示 ===");
        
        // 创建多个代理实例
        WorkService proxy1 = ProxyManager.createProtectionProxy("员工A", "manager");
        WorkService proxy2 = ProxyManager.createProtectionProxy("员工B", "teammate");
        WorkService proxy3 = ProxyManager.createVirtualProxy("员工C");
        
        // 重复创建相同的代理（应该使用缓存）
        WorkService proxy4 = ProxyManager.createProtectionProxy("员工A", "manager");
        
        System.out.println("🎯 代理缓存验证: " + (proxy1 == proxy4 ? "使用了缓存" : "创建了新实例"));
        
        // 显示缓存统计
        ProxyManager.printCacheStats();
        
        System.out.println("\n🏆 代理管理器的优势:");
        System.out.println("   ✅ 统一管理: 集中管理所有代理实例");
        System.out.println("   ✅ 缓存机制: 避免重复创建相同代理");
        System.out.println("   ✅ 链式组合: 支持复杂的代理链构建");
        System.out.println("   ✅ 类型安全: 强类型支持，编译期检查");
    }
}

/* 预期输出示例：
🎭 瓦学弟的代理人生开始了！

=== 静态代理演示 ===
👨‍💻 真实瓦学弟 勤奋小王 准备开始工作
🛡️ 保护代理已为 勤奋小王 激活
👨‍💼 管理员访问:
⌨️ 勤奋小王 正在专心编写 电商系统 代码...
勤奋小王 完成了 电商系统 的核心功能开发
🤝 勤奋小王 正在参加 项目评审 会议...
勤奋小王 参与了 项目评审 讨论

👥 同事访问:
⌨️ 勤奋小王 正在专心编写 bug修复 代码...
勤奋小王 完成了 bug修复 的核心功能开发
❌ 权限不足：teammate 无法安排会议
...
*/

🎯 代理模式2025年面试考点总结：

1. 静态代理 vs 动态代理？

   • 静态代理：编译期确定，一对一关系，代码冗余
   • 动态代理：运行时生成，灵活性高，减少代码重复

2. JDK动态代理 vs CGLIB代理？

   • JDK：基于接口，使用反射机制，JDK原生支持
   • CGLIB：基于继承，使用字节码技术，可代理没有接口的类

3. 代理模式的应用场景？

   • Spring AOP切面编程
   • RPC远程调用
   • 权限控制和安全检查
   • 缓存和延迟加载
   • 日志记录和性能监控

---

第三章：行为型模式 - “对象交互的智慧” 🤝

3.1 观察者模式 - “瓦学弟找妈妈的消息机制”

瓦学弟在职场上需要时刻关注各种信息变化，就像一个消息订阅系统。观察者模式就是瓦学弟的"找妈妈"通知系统！

/**
 * 观察者模式演示 - 瓦学弟找妈妈消息系统
 * 2025年升级版：支持异步通知、优先级订阅、消息过滤
 */

import java.util.concurrent.*;
import java.util.function.Predicate;

// 观察者接口 - 关心消息的瓦学弟
interface ValStudentObserver {
    void update(Message message);
    String getObserverName();
    int getPriority(); // 优先级，数字越大优先级越高
    boolean isInterested(Message message); // 消息过滤
}

// 被观察者接口 - 消息发布者
interface MessageSubject {
    void addObserver(ValStudentObserver observer);
    void removeObserver(ValStudentObserver observer);
    void notifyObservers(Message message);
    void notifyObserversAsync(Message message);
}

// 消息实体类
class Message {
    private String type;        // 消息类型
    private String content;     // 消息内容
    private String sender;      // 发送者
    private int urgency;        // 紧急程度 1-5
    private long timestamp;     // 时间戳
    private Map<String, Object> data; // 附加数据
    
    public Message(String type, String content, String sender, int urgency) {
        this.type = type;
        this.content = content;
        this.sender = sender;
        this.urgency = urgency;
        this.timestamp = System.currentTimeMillis();
        this.data = new HashMap<>();
    }
    
    // Builder模式构建消息
    public static class Builder {
        private String type;
        private String content;
        private String sender;
        private int urgency = 1;
        private Map<String, Object> data = new HashMap<>();
        
        public Builder type(String type) { this.type = type; return this; }
        public Builder content(String content) { this.content = content; return this; }
        public Builder sender(String sender) { this.sender = sender; return this; }
        public Builder urgency(int urgency) { this.urgency = urgency; return this; }
        public Builder addData(String key, Object value) { data.put(key, value); return this; }
        
        public Message build() {
            Message message = new Message(type, content, sender, urgency);
            message.data = new HashMap<>(this.data);
            return message;
        }
    }
    
    // Getter方法
    public String getType() { return type; }
    public String getContent() { return content; }
    public String getSender() { return sender; }
    public int getUrgency() { return urgency; }
    public long getTimestamp() { return timestamp; }
    public Map<String, Object> getData() { return data; }
    
    @Override
    public String toString() {
        return String.format("[%s] %s (来自: %s, 紧急度: %d)", type, content, sender, urgency);
    }
}

// 具体被观察者 - 瓦学弟的妈妈（消息中心）
class ValStudentMother implements MessageSubject {
    private String name;
    // 使用优先级队列管理观察者
    private PriorityQueue<ValStudentObserver> observers;
    // 异步通知线程池
    private ExecutorService notificationExecutor;
    // 消息历史记录
    private List<Message> messageHistory;
    
    public ValStudentMother(String name) {
        this.name = name;
        this.observers = new PriorityQueue<>((o1, o2) -> 
            Integer.compare(o2.getPriority(), o1.getPriority())); // 优先级降序
        this.notificationExecutor = Executors.newFixedThreadPool(3);
        this.messageHistory = new ArrayList<>();
        
        System.out.println("👩 瓦学弟的妈妈 " + name + " 的消息中心已启动");
    }
    
    @Override
    public void addObserver(ValStudentObserver observer) {
        observers.offer(observer);
        System.out.println("📱 " + observer.getObserverName() + 
                         " 订阅了妈妈的消息 (优先级: " + observer.getPriority() + ")");
    }
    
    @Override
    public void removeObserver(ValStudentObserver observer) {
        observers.remove(observer);
        System.out.println("📵 " + observer.getObserverName() + " 取消订阅妈妈的消息");
    }
    
    @Override
    public void notifyObservers(Message message) {
        System.out.println("📢 " + name + " 发布消息: " + message);
        messageHistory.add(message);
        
        // 创建观察者列表副本，按优先级排序
        List<ValStudentObserver> sortedObservers = new ArrayList<>(observers);
        sortedObservers.sort((o1, o2) -> Integer.compare(o2.getPriority(), o1.getPriority()));
        
        for (ValStudentObserver observer : sortedObservers) {
            if (observer.isInterested(message)) {
                try {
                    observer.update(message);
                } catch (Exception e) {
                    System.err.println("❌ 通知 " + observer.getObserverName() + " 时发生错误: " + e.getMessage());
                }
            } else {
                System.out.println("⏭️ " + observer.getObserverName() + " 对此消息不感兴趣，跳过");
            }
        }
    }
    
    @Override
    public void notifyObserversAsync(Message message) {
        System.out.println("🚀 " + name + " 异步发布消息: " + message);
        messageHistory.add(message);
        
        List<ValStudentObserver> sortedObservers = new ArrayList<>(observers);
        sortedObservers.sort((o1, o2) -> Integer.compare(o2.getPriority(), o1.getPriority()));
        
        for (ValStudentObserver observer : sortedObservers) {
            if (observer.isInterested(message)) {
                notificationExecutor.submit(() -> {
                    try {
                        System.out.println("🧵 [异步] 正在通知 " + observer.getObserverName());
                        observer.update(message);
                    } catch (Exception e) {
                        System.err.println("❌ [异步] 通知 " + observer.getObserverName() + " 时发生错误: " + e.getMessage());
                    }
                });
            }
        }
    }
    
    /**
     * 发布不同类型的消息
     */
    public void sendLocationUpdate(String location) {
        Message message = new Message.Builder()
                .type("位置更新")
                .content("妈妈现在在: " + location)
                .sender(name)
                .urgency(2)
                .addData("location", location)
                .build();
        notifyObservers(message);
    }
    
    public void sendEmergencyCall(String reason) {
        Message message = new Message.Builder()
                .type("紧急呼叫")
                .content("紧急情况: " + reason + "，快回来！")
                .sender(name)
                .urgency(5)
                .addData("emergency", true)
                .build();
        notifyObserversAsync(message); // 紧急消息异步通知，更快
    }
    
    public void sendDinnerReady() {
        Message message = new Message.Builder()
                .type("开饭通知")
                .content("饭做好了，快回来吃饭！")
                .sender(name)
                .urgency(3)
                .addData("meal", "晚餐")
                .build();
        notifyObservers(message);
    }
    
    public void sendDailyReminder(String reminder) {
        Message message = new Message.Builder()
                .type("日常提醒")
                .content(reminder)
                .sender(name)
                .urgency(1)
                .build();
        notifyObservers(message);
    }
    
    /**
     * 获取消息历史
     */
    public List<Message> getMessageHistory() {
        return new ArrayList<>(messageHistory);
    }
    
    /**
     * 关闭消息中心
     */
    public void shutdown() {
        notificationExecutor.shutdown();
        System.out.println("📴 " + name + " 的消息中心已关闭");
    }
}

// 具体观察者 - 游戏瓦学弟
class GamerValStudent implements ValStudentObserver {
    private String name;
    private String currentGame;
    private boolean isInGame;
    
    public GamerValStudent(String name) {
        this.name = name;
        this.currentGame = "英雄联盟";
        this.isInGame = true;
    }
    
    @Override
    public void update(Message message) {
        System.out.println("🎮 " + name + " 收到妈妈的消息: " + message);
        
        // 根据消息类型做出不同反应
        switch (message.getType()) {
            case "紧急呼叫":
                System.out.println("😱 " + name + " 立刻暂停游戏准备回家！");
                pauseGame();
                break;
            case "开饭通知":
                if (isInGame) {
                    System.out.println("🍚 " + name + " 说：妈，我这局快打完了，5分钟！");
                } else {
                    System.out.println("🏃‍♂️ " + name + " 立刻回家吃饭");
                }
                break;
            case "位置更新":
                System.out.println("📍 " + name + " 知道了妈妈的位置");
                break;
            default:
                System.out.println("📱 " + name + " 看了一眼消息继续游戏");
        }
    }
    
    @Override
    public String getObserverName() {
        return name + "(游戏玩家)";
    }
    
    @Override
    public int getPriority() {
        return 1; // 游戏玩家优先级较低
    }
    
    @Override
    public boolean isInterested(Message message) {
        // 游戏玩家只关心紧急呼叫和开饭通知
        return message.getUrgency() >= 3;
    }
    
    private void pauseGame() {
        isInGame = false;
        System.out.println("⏸️ " + name + " 暂停了" + currentGame);
    }
    
    public void resumeGame() {
        isInGame = true;
        System.out.println("▶️ " + name + " 继续玩" + currentGame);
    }
}

// 具体观察者 - 工作瓦学弟
class WorkerValStudent implements ValStudentObserver {
    private String name;
    private boolean isWorking;
    private String currentTask;
    
    public WorkerValStudent(String name) {
        this.name = name;
        this.isWorking = true;
        this.currentTask = "写代码";
    }
    
    @Override
    public void update(Message message) {
        System.out.println("💼 " + name + " 收到工作时消息: " + message);
        
        switch (message.getType()) {
            case "紧急呼叫":
                System.out.println("🚨 " + name + " 立刻请假回家处理紧急情况！");
                requestLeave();
                break;
            case "开饭通知":
                System.out.println("🍽️ " + name + " 准备下班回家吃饭");
                break;
            case "位置更新":
                System.out.println("🗺️ " + name + " 记下了妈妈的位置，下班去找");
                break;
            default:
                System.out.println("📞 " + name + " 记下了，下班后处理");
        }
    }
    
    @Override
    public String getObserverName() {
        return name + "(上班族)";
    }
    
    @Override
    public int getPriority() {
        return 3; // 工作的瓦学弟优先级较高
    }
    
    @Override
    public boolean isInterested(Message message) {
        // 工作的瓦学弟关心所有消息
        return true;
    }
    
    private void requestLeave() {
        isWorking = false;
        System.out.println("🏃‍♂️ " + name + " 向老板请假了");
    }
}

// 具体观察者 - 学霸瓦学弟
class StudiousValStudent implements ValStudentObserver {
    private String name;
    private boolean isStudying;
    private String currentSubject;
    
    public StudiousValStudent(String name) {
        this.name = name;
        this.isStudying = true;
        this.currentSubject = "算法与数据结构";
    }
    
    @Override
    public void update(Message message) {
        System.out.println("📚 " + name + " 在学习时收到消息: " + message);
        
        switch (message.getType()) {
            case "紧急呼叫":
                System.out.println("📖 " + name + " 合上书本立刻回家！");
                stopStudying();
                break;
            case "开饭通知":
                System.out.println("🥘 " + name + " 做完这道题就回家吃饭");
                break;
            case "日常提醒":
                System.out.println("✍️ " + name + " 在笔记本上记下提醒");
                break;
            default:
                System.out.println("🤓 " + name + " 专心学习，稍后回复");
        }
    }
    
    @Override
    public String getObserverName() {
        return name + "(学霸)";
    }
    
    @Override
    public int getPriority() {
        return 2; // 学霸优先级中等
    }
    
    @Override
    public boolean isInterested(Message message) {
        // 学霸对学习相关消息和紧急消息感兴趣
        return message.getUrgency() >= 3 || message.getType().contains("学习") || message.getType().contains("提醒");
    }
    
    private void stopStudying() {
        isStudying = false;
        System.out.println("📚 " + name + " 暂停学习" + currentSubject);
    }
}

// 具体观察者 - VIP瓦学弟（优先级最高）
class VIPValStudent implements ValStudentObserver {
    private String name;
    private String vipLevel;
    
    public VIPValStudent(String name, String vipLevel) {
        this.name = name;
        this.vipLevel = vipLevel;
    }
    
    @Override
    public void update(Message message) {
        System.out.println("👑 VIP" + vipLevel + " " + name + " 优先收到消息: " + message);
        
        // VIP瓦学弟对所有消息都有快速响应
        switch (message.getType()) {
            case "紧急呼叫":
                System.out.println("🚁 " + name + " 呼叫私人飞机立刻回家！");
                break;
            case "开饭通知":
                System.out.println("🍽️ " + name + " 让司机开车回家吃饭");
                break;
            case "位置更新":
                System.out.println("📱 " + name + " 打开定位追踪妈妈位置");
                break;
            default:
                System.out.println("💎 " + name + " VIP专属快速响应");
        }
    }
    
    @Override
    public String getObserverName() {
        return name + "(VIP" + vipLevel + ")";
    }
    
    @Override
    public int getPriority() {
        return 10; // VIP优先级最高
    }
    
    @Override
    public boolean isInterested(Message message) {
        return true; // VIP对所有消息都感兴趣
    }
}

/**
 * 2025年升级版观察者管理器
 */
class ObserverManager {
    
    /**
     * 创建基础观察者组合
     */
    public static List<ValStudentObserver> createBasicObservers() {
        List<ValStudentObserver> observers = new ArrayList<>();
        observers.add(new GamerValStudent("游戏小王"));
        observers.add(new WorkerValStudent("上班小李"));
        observers.add(new StudiousValStudent("学霸小张"));
        return observers;
    }
    
    /**
     * 创建VIP观察者组合
     */
    public static List<ValStudentObserver> createVIPObservers() {
        List<ValStudentObserver> observers = new ArrayList<>();
        observers.add(new VIPValStudent("富二代小刘", "钻石"));
        observers.add(new VIPValStudent("CEO小陈", "黄金"));
        observers.add(new WorkerValStudent("普通员工小赵"));
        return observers;
    }
    
    /**
     * 按优先级排序观察者
     */
    public static List<ValStudentObserver> sortByPriority(List<ValStudentObserver> observers) {
        return observers.stream()
                .sorted((o1, o2) -> Integer.compare(o2.getPriority(), o1.getPriority()))
                .collect(Collectors.toList());
    }
    
    /**
     * 过滤感兴趣的观察者
     */
    public static List<ValStudentObserver> filterInterested(List<ValStudentObserver> observers, Message message) {
        return observers.stream()
                .filter(observer -> observer.isInterested(message))
                .collect(Collectors.toList());
    }
}

/**
 * 高级观察者模式 - 支持Spring事件机制风格
 */
@Component
class SpringStyleEventPublisher {
    private final ApplicationEventPublisher eventPublisher;
    
    public SpringStyleEventPublisher(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
    
    public void publishMotherMessage(Message message) {
        // 发布Spring事件
        eventPublisher.publishEvent(new MotherMessageEvent(this, message));
    }
}

/**
 * Spring事件
 */
class MotherMessageEvent extends ApplicationEvent {
    private final Message message;
    
    public MotherMessageEvent(Object source, Message message) {
        super(source);
        this.message = message;
    }
    
    public Message getMessage() {
        return message;
    }
}

/**
 * Spring事件监听器
 */
@Component
class SpringValStudentListener {
    
    @EventListener
    @Async // 异步处理
    public void handleMotherMessage(MotherMessageEvent event) {
        Message message = event.getMessage();
        System.out.println("🌸 [Spring监听器] 收到妈妈消息: " + message);
        
        // 根据消息类型处理
        if (message.getUrgency() >= 4) {
            System.out.println("🚨 [Spring监听器] 紧急消息，立即处理！");
        }
    }
    
    @EventListener(condition = "#event.message.type.equals('开饭通知')")
    public void handleDinnerCall(MotherMessageEvent event) {
        System.out.println("🍚 [Spring监听器] 专门处理开饭通知");
    }
}

/**
 * 使用示例 - 2025年瓦学弟找妈妈系统
 */
public class ObserverPatternDemo {
    public static void main(String[] args) {
        System.out.println("📱 2025年瓦学弟找妈妈系统启动！\n");
        
        // 演示1：基础观察者模式
        demonstrateBasicObserver();
        
        // 演示2：优先级和过滤机制
        demonstratePriorityAndFiltering();
        
        // 演示3：异步通知
        demonstrateAsyncNotification();
        
        // 演示4：消息历史和统计
        demonstrateMessageHistory();
        
        // 演示5：动态观察者管理
        demonstrateDynamicObserverManagement();
        
        System.out.println("🏆 观察者模式在瓦学弟找妈妈系统中表现得了MVP！");
    }
    
    private static void demonstrateBasicObserver() {
        System.out.println("=== 基础观察者模式演示 ===");
        
        // 创建妈妈（被观察者）
        ValStudentMother mother = new ValStudentMother("慈祥的妈妈");
        
        // 创建并添加观察者
        List<ValStudentObserver> observers = ObserverManager.createBasicObservers();
        observers.forEach(mother::addObserver);
        
        // 发送不同类型的消息
        System.out.println("\n📍 妈妈发送位置更新:");
        mother.sendLocationUpdate("超市");
        
        System.out.println("\n🍚 妈妈通知开饭:");
        mother.sendDinnerReady();
        
        System.out.println("\n🚨 妈妈发送紧急呼叫:");
        mother.sendEmergencyCall("家里停电了");
        
        System.out.println();
    }
    
    private static void demonstratePriorityAndFiltering() {
        System.out.println("=== 优先级和过滤机制演示 ===");
        
        ValStudentMother mother = new ValStudentMother("智能妈妈");
        
        // 创建VIP观察者组合
        List<ValStudentObserver> vipObservers = ObserverManager.createVIPObservers();
        vipObservers.forEach(mother::addObserver);
        
        System.out.println("\n💰 VIP消息发送测试:");
        mother.sendDailyReminder("记得按时吃维生素");
        
        System.out.println("\n🆘 紧急消息测试:");
        mother.sendEmergencyCall("快递到了，在门口等你");
        
        System.out.println();
    }
    
    private static void demonstrateAsyncNotification() {
        System.out.println("=== 异步通知演示 ===");
        
        ValStudentMother mother = new ValStudentMother("异步妈妈");
        mother.addObserver(new GamerValStudent("异步游戏玩家"));
        mother.addObserver(new WorkerValStudent("异步上班族"));
        
        System.out.println("\n🚀 异步紧急通知:");
        mother.sendEmergencyCall("家里来客人了");
        
        // 等待异步执行完成
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        mother.shutdown();
        System.out.println();
    }
    
    private static void demonstrateMessageHistory() {
        System.out.println("=== 消息历史和统计演示 ===");
        
        ValStudentMother mother = new ValStudentMother("记录狂妈妈");
        mother.addObserver(new StudiousValStudent("历史记录学霸"));
        
        // 发送多条消息
        mother.sendLocationUpdate("菜市场");
        mother.sendDinnerReady();
        mother.sendDailyReminder("明天有雨，记得带伞");
        mother.sendLocationUpdate("回家路上");
        
        // 查看消息历史
        List<Message> history = mother.getMessageHistory();
        System.out.println("\n📊 消息历史统计:");
        System.out.println("总消息数: " + history.size());
        
        Map<String, Long> typeCount = history.stream()
                .collect(Collectors.groupingBy(Message::getType, Collectors.counting()));
        
        typeCount.forEach((type, count) -> 
            System.out.println("  " + type + ": " + count + "次"));
        
        long urgentMessages = history.stream()
                .mapToInt(Message::getUrgency)
                .filter(urgency -> urgency >= 4)
                .count();
        System.out.println("紧急消息数: " + urgentMessages);
        
        mother.shutdown();
        System.out.println();
    }
    
    private static void demonstrateDynamicObserverManagement() {
        System.out.println("=== 动态观察者管理演示 ===");
        
        ValStudentMother mother = new ValStudentMother("动态妈妈");
        
        // 初始观察者
        ValStudentObserver gamer = new GamerValStudent("动态游戏玩家");
        ValStudentObserver worker = new WorkerValStudent("动态上班族");
        
        System.out.println("👥 添加初始观察者:");
        mother.addObserver(gamer);
        mother.addObserver(worker);
        
        System.out.println("\n📢 发送第一条消息:");
        mother.sendDinnerReady();
        
        System.out.println("\n➕ 添加新观察者:");
        ValStudentObserver vip = new VIPValStudent("新来的VIP", "白金");
        mother.addObserver(vip);
        
        System.out.println("\n📢 发送第二条消息:");
        mother.sendLocationUpdate("商场");
        
        System.out.println("\n➖ 移除游戏玩家:");
        mother.removeObserver(gamer);
        
        System.out.println("\n📢 发送第三条消息:");
        mother.sendEmergencyCall("忘记拿钥匙了");
        
        mother.shutdown();
        System.out.println();
    }
}

/* 预期输出示例：
📱 2025年瓦学弟找妈妈系统启动！

=== 基础观察者模式演示 ===
👩 瓦学弟的妈妈 慈祥的妈妈 的消息中心已启动
📱 游戏小王(游戏玩家) 订阅了妈妈的消息 (优先级: 1)
📱 上班小李(上班族) 订阅了妈妈的消息 (优先级: 3)
📱 学霸小张(学霸) 订阅了妈妈的消息 (优先级: 2)

📍 妈妈发送位置更新:
📢 慈祥的妈妈 发布消息: [位置更新] 妈妈现在在: 超市 (来自: 慈祥的妈妈, 紧急度: 2)
💼 上班小李 收到工作时消息: [位置更新] 妈妈现在在: 超市 (来自: 慈祥的妈妈, 紧急度: 2)
🗺️ 上班小李 记下了妈妈的位置，下班去找
📚 学霸小张 在学习时收到消息: [位置更新] 妈妈现在在: 超市 (来自: 慈祥的妈妈, 紧急度: 2)
🤓 学霸小张 专心学习，稍后回复
⏭️ 游戏小王(游戏玩家) 对此消息不感兴趣，跳过
...
*/

3.2 策略模式 - “瓦学弟的算法选择器”

基于搜索到的2025年最新策略模式实践，让我们看看瓦学弟如何在不同场景下选择最优策略！

/**
 * 策略模式演示 - 瓦学弟的智能算法选择系统
 * 2025年升级版：融合Lambda表达式、函数式接口、Spring策略管理
 */

// 传统策略接口
interface CodingStrategy {
    String code(String requirement);
    String getStrategyName();
    int getComplexityScore(); // 复杂度评分
    String[] getSuitableScenarios(); // 适用场景
}

// 具体策略1 - 快速原型策略
class RapidPrototypeStrategy implements CodingStrategy {
    @Override
    public String code(String requirement) {
        return "🚀 使用快速原型策略实现: " + requirement + 
               "\n   ✅ 快速搭建基础框架" +
               "\n   ✅ 实现核心功能" +
               "\n   ⚠️ 跳过单元测试" +
               "\n   📦 输出: 可运行的原型系统";
    }
    
    @Override
    public String getStrategyName() {
        return "快速原型策略";
    }
    
    @Override
    public int getComplexityScore() {
        return 3; // 低复杂度
    }
    
    @Override
    public String[] getSuitableScenarios() {
        return new String[]{"概念验证", "技术选型", "演示demo"};
    }
}

// 具体策略2 - 企业级开发策略
class EnterpriseStrategy implements CodingStrategy {
    @Override
    public String code(String requirement) {
        return "🏢 使用企业级开发策略实现: " + requirement +
               "\n   ✅ 详细的需求分析" +
               "\n   ✅ 完整的系统设计" +
               "\n   ✅ 规范的代码实现" +
               "\n   ✅ 全面的单元测试" +
               "\n   ✅ 完善的文档编写" +
               "\n   📦 输出: 企业级生产系统";
    }
    
    @Override
    public String getStrategyName() {
        return "企业级开发策略";
    }
    
    @Override
    public int getComplexityScore() {
        return 9; // 高复杂度
    }
    
    @Override
    public String[] getSuitableScenarios() {
        return new String[]{"生产系统", "大型项目", "长期维护"};
    }
}

// 具体策略3 - 敏捷开发策略
class AgileStrategy implements CodingStrategy {
    @Override
    public String code(String requirement) {
        return "🔄 使用敏捷开发策略实现: " + requirement +
               "\n   ✅ 拆分用户故事" +
               "\n   ✅ 迭代式开发" +
               "\n   ✅ 持续集成部署" +
               "\n   ✅ 及时反馈调整" +
               "\n   📦 输出: 可持续演进的系统";
    }
    
    @Override
    public String getStrategyName() {
        return "敏捷开发策略";
    }
    
    @Override
    public int getComplexityScore() {
        return 6; // 中等复杂度
    }
    
    @Override
    public String[] getSuitableScenarios() {
        return new String[]{"需求多变", "团队协作", "快速交付"};
    }
}

// 具体策略4 - 开源贡献策略
class OpenSourceStrategy implements CodingStrategy {
    @Override
    public String code(String requirement) {
        return "🌟 使用开源贡献策略实现: " + requirement +
               "\n   ✅ 设计通用解决方案" +
               "\n   ✅ 编写高质量代码" +
               "\n   ✅ 添加详细注释" +
               "\n   ✅ 编写使用示例" +
               "\n   ✅ 考虑社区反馈" +
               "\n   📦 输出: 可复用的开源组件";
    }
    
    @Override
    public String getStrategyName() {
        return "开源贡献策略";
    }
    
    @Override
    public int getComplexityScore() {
        return 7; // 中高复杂度
    }
    
    @Override
    public String[] getSuitableScenarios() {
        return new String[]{"通用工具", "技术分享", "社区贡献"};
    }
}

// 传统策略上下文
class ValStudentDeveloper {
    private CodingStrategy strategy;
    private String name;
    private List<String> completedProjects;
    
    public ValStudentDeveloper(String name) {
        this.name = name;
        this.completedProjects = new ArrayList<>();
    }
    
    public void setStrategy(CodingStrategy strategy) {
        this.strategy = strategy;
        System.out.println("🔧 " + name + " 切换到: " + strategy.getStrategyName());
    }
    
    public String develop(String requirement) {
        if (strategy == null) {
            return "❌ 请先选择开发策略！";
        }
        
        System.out.println("👨‍💻 " + name + " 开始开发...");
        String result = strategy.code(requirement);
        completedProjects.add(requirement + " (" + strategy.getStrategyName() + ")");
        
        return result;
    }
    
    public void showProjectHistory() {
        System.out.println("📋 " + name + " 的项目历史:");
        completedProjects.forEach(project -> System.out.println("  - " + project));
    }
    
    public CodingStrategy getStrategy() {
        return strategy;
    }
    
    public String getName() {
        return name;
    }
}

// 2025年新特性：函数式策略接口
@FunctionalInterface
interface FunctionalCodingStrategy {
    String code(String requirement);
    
    // 默认方法提供额外信息
    default String getDescription() {
        return "函数式编程策略";
    }
    
    default int estimateTime(String requirement) {
        return requirement.length() / 10; // 简单估算
    }
}

// 函数式策略管理器
class LambdaStrategyManager {
    private final Map<String, FunctionalCodingStrategy> strategies = new HashMap<>();
    
    public LambdaStrategyManager() {
        initializeStrategies();
    }
    
    private void initializeStrategies() {
        // Lambda表达式定义策略
        strategies.put("极简策略", requirement -> 
            "⚡ 极简实现: " + requirement + " (仅核心功能，5分钟搞定)");
        
        strategies.put("优雅策略", requirement -> 
            "✨ 优雅实现: " + requirement + " (注重代码美感，设计模式加持)");
        
        strategies.put("性能策略", requirement -> 
            "🚀 性能优化实现: " + requirement + " (极致性能，缓存+并发优化)");
        
        strategies.put("安全策略", requirement -> 
            "🔒 安全加固实现: " + requirement + " (权限控制+数据加密+审计日志)");
        
        // 方法引用策略
        strategies.put("AI辅助策略", this::aiAssistedCoding);
        
        // 复杂Lambda策略
        strategies.put("智能策略", requirement -> {
            int complexity = requirement.length();
            if (complexity < 20) {
                return "🎯 智能判断: " + requirement + " (简单需求，快速实现)";
            } else if (complexity < 50) {
                return "🎯 智能判断: " + requirement + " (中等复杂度，采用标准方案)";
            } else {
                return "🎯 智能判断: " + requirement + " (复杂需求，分模块实现)";
            }
        });
    }
    
    private String aiAssistedCoding(String requirement) {
        return "🤖 AI辅助实现: " + requirement + 
               "\n   ✅ ChatGPT生成基础代码" +
               "\n   ✅ Copilot提供智能补全" +
               "\n   ✅ 人工审查优化";
    }
    
    public FunctionalCodingStrategy getStrategy(String name) {
        return strategies.get(name);
    }
    
    public Set<String> getAvailableStrategies() {
        return strategies.keySet();
    }
    
    public void addCustomStrategy(String name, FunctionalCodingStrategy strategy) {
        strategies.put(name, strategy);
        System.out.println("✅ 自定义策略 '" + name + "' 已添加");
    }
}

// 函数式策略上下文
class ModernValStudentDeveloper {
    private String name;
    private FunctionalCodingStrategy currentStrategy;
    private LambdaStrategyManager strategyManager;
    private Map<String, Integer> strategyUsageCount;
    
    public ModernValStudentDeveloper(String name) {
        this.name = name;
        this.strategyManager = new LambdaStrategyManager();
        this.strategyUsageCount = new HashMap<>();
    }
    
    public void useStrategy(String strategyName) {
        FunctionalCodingStrategy strategy = strategyManager.getStrategy(strategyName);
        if (strategy != null) {
            this.currentStrategy = strategy;
            strategyUsageCount.merge(strategyName, 1, Integer::sum);
            System.out.println("🔄 " + name + " 选择了: " + strategyName);
        } else {
            System.out.println("❌ 策略 '" + strategyName + "' 不存在");
        }
    }
    
    public String develop(String requirement) {
        if (currentStrategy == null) {
            return "❌ 请先选择开发策略！";
        }
        
        System.out.println("⚡ " + name + " 使用函数式策略开发...");
        String result = currentStrategy.code(requirement);
        
        int estimatedTime = currentStrategy.estimateTime(requirement);
        S继续完成策略模式部分：

```java
        System.out.println("⏱️ 预计开发时间: " + estimatedTime + "分钟");
        return result;
    }
    
    public void showAvailableStrategies() {
        System.out.println("📋 " + name + " 可用的策略:");
        strategyManager.getAvailableStrategies().forEach(strategy -> 
            System.out.println("  - " + strategy));
    }
    
    public void addCustomStrategy(String name, FunctionalCodingStrategy strategy) {
        strategyManager.addCustomStrategy(name, strategy);
    }
    
    public void showUsageStats() {
        System.out.println("📊 " + name + " 的策略使用统计:");
        strategyUsageCount.entrySet().stream()
                .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
                .forEach(entry -> System.out.println("  " + entry.getKey() + ": " + entry.getValue() + "次"));
    }
}

// 2025年春版：基于Spring的策略管理器
@Component
class SpringStrategyManager {
    
    @Autowired
    private ApplicationContext applicationContext;
    
    // 策略注册表，使用@Component注解自动注册
    private final Map<String, CodingStrategy> strategies = new HashMap<>();
    
    @PostConstruct
    public void initStrategies() {
        // 自动发现所有策略实现
        Map<String, CodingStrategy> strategyBeans = applicationContext.getBeansOfType(CodingStrategy.class);
        strategyBeans.forEach((beanName, strategy) -> {
            strategies.put(strategy.getStrategyName(), strategy);
            System.out.println("🌱 [Spring] 自动注册策略: " + strategy.getStrategyName());
        });
    }
    
    public CodingStrategy getStrategy(String name) {
        return strategies.get(name);
    }
    
    public List<CodingStrategy> getAllStrategies() {
        return new ArrayList<>(strategies.values());
    }
    
    // 基于场景自动选择策略
    public CodingStrategy selectBestStrategy(String scenario, int complexity, int urgency) {
        return strategies.values().stream()
                .filter(strategy -> Arrays.asList(strategy.getSuitableScenarios()).contains(scenario))
                .min((s1, s2) -> {
                    // 综合考虑复杂度和紧急程度
                    int score1 = Math.abs(s1.getComplexityScore() - complexity) + (urgency > 3 ? s1.getComplexityScore() : 0);
                    int score2 = Math.abs(s2.getComplexityScore() - complexity) + (urgency > 3 ? s2.getComplexityScore() : 0);
                    return Integer.compare(score1, score2);
                })
                .orElse(strategies.values().iterator().next());
    }
}

// Spring策略实现示例
@Component
class SpringRapidStrategy implements CodingStrategy {
    @Override
    public String code(String requirement) {
        return "🌱 [Spring策略] 快速实现: " + requirement + 
               "\n   ✅ 使用Spring Boot快速搭建" +
               "\n   ✅ 自动配置减少代码量" +
               "\n   ✅ 内嵌容器快速部署";
    }
    
    @Override
    public String getStrategyName() { return "Spring快速策略"; }
    
    @Override
    public int getComplexityScore() { return 4; }
    
    @Override
    public String[] getSuitableScenarios() { return new String[]{"Web应用", "微服务", "快速原型"}; }
}

@Component  
class SpringEnterpriseStrategy implements CodingStrategy {
    @Override
    public String code(String requirement) {
        return "🏢 [Spring策略] 企业级实现: " + requirement +
               "\n   ✅ Spring Security安全框架" +
               "\n   ✅ Spring Data统一数据访问" +
               "\n   ✅ Spring Cloud微服务全家桶" +
               "\n   ✅ Spring Boot Admin监控管理";
    }
    
    @Override
    public String getStrategyName() { return "Spring企业策略"; }
    
    @Override
    public int getComplexityScore() { return 8; }
    
    @Override
    public String[] getSuitableScenarios() { return new String[]{"企业应用", "大型系统", "微服务架构"}; }
}

// 2025年新特性：智能策略推荐器
class AIStrategyRecommender {
    private final List<StrategyUsageRecord> usageHistory = new ArrayList<>();
    
    /**
     * 基于历史使用记录和AI算法推荐最佳策略
     */
    public List<CodingStrategy> recommendStrategies(String requirement, List<CodingStrategy> availableStrategies) {
        System.out.println("🤖 AI正在分析需求: " + requirement);
        
        // 模拟AI分析过程
        int requirementComplexity = analyzeComplexity(requirement);
        String detectedScenario = detectScenario(requirement);
        int urgencyLevel = detectUrgency(requirement);
        
        System.out.println("📊 AI分析结果:");
        System.out.println("   复杂度: " + requirementComplexity + "/10");
        System.out.println("   场景: " + detectedScenario);
        System.out.println("   紧急度: " + urgencyLevel + "/5");
        
        return availableStrategies.stream()
                .filter(strategy -> isStrategyApplicable(strategy, detectedScenario))
                .sorted((s1, s2) -> {
                    double score1 = calculateStrategyScore(s1, requirementComplexity, urgencyLevel);
                    double score2 = calculateStrategyScore(s2, requirementComplexity, urgencyLevel);
                    return Double.compare(score2, score1); // 降序排列
                })
                .limit(3) // 返回前3个推荐
                .collect(Collectors.toList());
    }
    
    private int analyzeComplexity(String requirement) {
        // 基于关键词分析复杂度
        String[] complexKeywords = {"微服务", "分布式", "高并发", "大数据", "机器学习", "区块链"};
        String[] simpleKeywords = {"增删改查", "页面", "表单", "简单"};
        
        long complexCount = Arrays.stream(complexKeywords)
                .mapToLong(keyword -> requirement.toLowerCase().contains(keyword) ? 1 : 0)
                .sum();
        
        long simpleCount = Arrays.stream(simpleKeywords)
                .mapToLong(keyword -> requirement.toLowerCase().contains(keyword) ? 1 : 0)
                .sum();
        
        return Math.max(1, Math.min(10, (int)(5 + complexCount * 2 - simpleCount)));
    }
    
    private String detectScenario(String requirement) {
        if (requirement.contains("原型") || requirement.contains("demo")) return "概念验证";
        if (requirement.contains("企业") || requirement.contains("生产")) return "企业应用";
        if (requirement.contains("开源") || requirement.contains("社区")) return "通用工具";
        if (requirement.contains("敏捷") || requirement.contains("迭代")) return "需求多变";
        return "常规开发";
    }
    
    private int detectUrgency(String requirement) {
        if (requirement.contains("紧急") || requirement.contains("马上")) return 5;
        if (requirement.contains("本周") || requirement.contains("尽快")) return 4;
        if (requirement.contains("下周") || requirement.contains("较急")) return 3;
        return 2;
    }
    
    private boolean isStrategyApplicable(CodingStrategy strategy, String scenario) {
        return Arrays.asList(strategy.getSuitableScenarios()).contains(scenario) ||
               scenario.equals("常规开发"); // 常规开发适用所有策略
    }
    
    private double calculateStrategyScore(CodingStrategy strategy, int complexity, int urgency) {
        // 复杂度匹配分数 (越接近越好)
        double complexityScore = 10.0 - Math.abs(strategy.getComplexityScore() - complexity);
        
        // 紧急度调整 (紧急时偏好简单策略)
        double urgencyAdjustment = urgency > 3 ? (10.0 - strategy.getComplexityScore()) * 0.3 : 0;
        
        // 历史成功率 (基于使用记录)
        double historyScore = calculateHistoryScore(strategy);
        
        return complexityScore + urgencyAdjustment + historyScore;
    }
    
    private double calculateHistoryScore(CodingStrategy strategy) {
        // 简化实现：基于策略名称计算历史分数
        return usageHistory.stream()
                .filter(record -> record.getStrategyName().equals(strategy.getStrategyName()))
                .mapToDouble(StrategyUsageRecord::getSuccessRate)
                .average()
                .orElse(5.0); // 默认分数
    }
    
    public void recordUsage(String strategyName, boolean success, int duration) {
        usageHistory.add(new StrategyUsageRecord(strategyName, success, duration));
    }
}

// 策略使用记录
class StrategyUsageRecord {
    private String strategyName;
    private boolean success;
    private int duration;
    private LocalDateTime timestamp;
    
    public StrategyUsageRecord(String strategyName, boolean success, int duration) {
        this.strategyName = strategyName;
        this.success = success;
        this.duration = duration;
        this.timestamp = LocalDateTime.now();
    }
    
    public double getSuccessRate() {
        return success ? 10.0 : 3.0;
    }
    
    // Getter方法
    public String getStrategyName() { return strategyName; }
    public boolean isSuccess() { return success; }
    public int getDuration() { return duration; }
    public LocalDateTime getTimestamp() { return timestamp; }
}

// 策略模式工厂 - 2025年升级版
class StrategyFactory {
    private static final Map<String, Supplier<CodingStrategy>> STRATEGY_SUPPLIERS = new HashMap<>();
    
    static {
        // 注册策略供应商
        STRATEGY_SUPPLIERS.put("快速", () -> new RapidPrototypeStrategy());
        STRATEGY_SUPPLIERS.put("企业", () -> new EnterpriseStrategy());
        STRATEGY_SUPPLIERS.put("敏捷", () -> new AgileStrategy());
        STRATEGY_SUPPLIERS.put("开源", () -> new OpenSourceStrategy());
    }
    
    public static CodingStrategy createStrategy(String type) {
        Supplier<CodingStrategy> supplier = STRATEGY_SUPPLIERS.get(type);
        if (supplier != null) {
            return supplier.get();
        }
        throw new IllegalArgumentException("未知的策略类型: " + type);
    }
    
    public static List<String> getAvailableStrategyTypes() {
        return new ArrayList<>(STRATEGY_SUPPLIERS.keySet());
    }
    
    // 基于需求自动选择策略类型
    public static String suggestStrategyType(String requirement) {
        if (requirement.contains("快速") || requirement.contains("原型")) return "快速";
        if (requirement.contains("企业") || requirement.contains("生产")) return "企业";
        if (requirement.contains("敏捷") || requirement.contains("迭代")) return "敏捷";
        if (requirement.contains("开源") || requirement.contains("社区")) return "开源";
        return "敏捷"; // 默认策略
    }
}

/**
 * 使用示例 - 瓦学弟的策略选择之旅
 */
public class StrategyPatternDemo {
    public static void main(String[] args) {
        System.out.println("🎯 瓦学弟的策略模式实战开始！\n");
        
        // 演示1：传统策略模式
        demonstrateTraditionalStrategy();
        
        // 演示2：函数式策略模式
        demonstrateFunctionalStrategy();
        
        // 演示3：智能策略推荐
        demonstrateAIRecommendation();
        
        // 演示4：策略工厂使用
        demonstrateStrategyFactory();
        
        // 演示5：实际应用场景对比
        demonstrateRealWorldComparison();
        
        System.out.println("🏆 策略模式让瓦学弟的开发更加灵活高效，得了MVP！");
    }
    
    private static void demonstrateTraditionalStrategy() {
        System.out.println("=== 传统策略模式演示 ===");
        
        ValStudentDeveloper developer = new ValStudentDeveloper("传统瓦学弟");
        
        // 使用不同策略开发项目
        System.out.println("🚀 快速原型开发:");
        developer.setStrategy(new RapidPrototypeStrategy());
        System.out.println(developer.develop("用户登录功能"));
        
        System.out.println("\n🏢 企业级开发:");
        developer.setStrategy(new EnterpriseStrategy());
        System.out.println(developer.develop("支付系统"));
        
        System.out.println("\n🔄 敏捷开发:");
        developer.setStrategy(new AgileStrategy());
        System.out.println(developer.develop("电商推荐系统"));
        
        System.out.println("\n📋 项目历史:");
        developer.showProjectHistory();
        
        System.out.println();
    }
    
    private static void demonstrateFunctionalStrategy() {
        System.out.println("=== 函数式策略模式演示 ===");
        
        ModernValStudentDeveloper modernDev = new ModernValStudentDeveloper("现代瓦学弟");
        
        // 显示可用策略
        modernDev.showAvailableStrategies();
        
        System.out.println("\n⚡ 使用极简策略:");
        modernDev.useStrategy("极简策略");
        System.out.println(modernDev.develop("简单的CRUD接口"));
        
        System.out.println("\n✨ 使用优雅策略:");
        modernDev.useStrategy("优雅策略");
        System.out.println(modernDev.develop("用户权限管理系统"));
        
        System.out.println("\n🤖 使用AI辅助策略:");
        modernDev.useStrategy("AI辅助策略");
        System.out.println(modernDev.develop("智能客服机器人"));
        
        // 添加自定义策略
        System.out.println("\n🔧 添加自定义策略:");
        modernDev.addCustomStrategy("瓦学弟专属策略", requirement -> 
            "😎 瓦学弟专属实现: " + requirement + " (这就是瓦学弟的独门秘籍！)");
        
        modernDev.useStrategy("瓦学弟专属策略");
        System.out.println(modernDev.develop("瓦学弟专属CRM系统"));
        
        System.out.println("\n📊 策略使用统计:");
        modernDev.showUsageStats();
        
        System.out.println();
    }
    
    private static void demonstrateAIRecommendation() {
        System.out.println("=== 智能策略推荐演示 ===");
        
        AIStrategyRecommender recommender = new AIStrategyRecommender();
        
        // 准备策略列表
        List<CodingStrategy> strategies = Arrays.asList(
            new RapidPrototypeStrategy(),
            new EnterpriseStrategy(),
            new AgileStrategy(),
            new OpenSourceStrategy()
        );
        
        // 测试不同需求的推荐
        String[] requirements = {
            "需要快速开发一个demo展示给客户看",
            "开发企业级的分布式微服务系统",
            "开发一个开源的JSON解析工具库",
            "紧急修复生产环境的支付bug"
        };
        
        for (String requirement : requirements) {
            System.out.println("📋 需求: " + requirement);
            List<CodingStrategy> recommendations = recommender.recommendStrategies(requirement, strategies);
            
            System.out.println("🎯 AI推荐策略 (按优先级排序):");
            for (int i = 0; i < recommendations.size(); i++) {
                CodingStrategy strategy = recommendations.get(i);
                System.out.println("   " + (i + 1) + ". " + strategy.getStrategyName() + 
                                 " (复杂度: " + strategy.getComplexityScore() + "/10)");
            }
            
            // 记录使用情况
            if (!recommendations.isEmpty()) {
                recommender.recordUsage(recommendations.get(0).getStrategyName(), true, 120);
            }
            
            System.out.println();
        }
    }
    
    private static void demonstrateStrategyFactory() {
        System.out.println("=== 策略工厂演示 ===");
        
        System.out.println("📋 可用策略类型: " + StrategyFactory.getAvailableStrategyTypes());
        
        String[] requirements = {
            "快速开发一个原型系统",
            "企业级电商平台开发",
            "开源工具库开发",
            "敏捷迭代开发社交应用"
        };
        
        for (String requirement : requirements) {
            System.out.println("\n📋 需求: " + requirement);
            
            // 自动建议策略类型
            String suggestedType = StrategyFactory.suggestStrategyType(requirement);
            System.out.println("🤖 建议策略类型: " + suggestedType);
            
            // 创建并使用策略
            try {
                CodingStrategy strategy = StrategyFactory.createStrategy(suggestedType);
                System.out.println("🔧 使用 " + strategy.getStrategyName() + ":");
                System.out.println(strategy.code(requirement));
            } catch (IllegalArgumentException e) {
                System.out.println("❌ " + e.getMessage());
            }
        }
        
        System.out.println();
    }
    
    private static void demonstrateRealWorldComparison() {
        System.out.println("=== 实际应用场景对比 ===");
        
        System.out.println("💡 策略模式的实际应用场景:");
        System.out.println("   ✅ 支付系统：支付宝、微信、银联等不同支付策略");
        System.out.println("   ✅ 排序算法：快排、归并、堆排序等不同排序策略");
        System.out.println("   ✅ 压缩算法：ZIP、RAR、7Z等不同压缩策略");
        System.out.println("   ✅ 缓存策略：LRU、LFU、FIFO等不同淘汰策略");
        System.out.println("   ✅ 折扣计算：满减、打折、积分兑换等营销策略");
        
        System.out.println("\n🎯 策略模式 vs 其他模式:");
        System.out.println("   🆚 vs 状态模式: 策略关注算法选择，状态关注状态转换");
        System.out.println("   🆚 vs 模板方法: 策略是组合，模板方法是继承");
        System.out.println("   🆚 vs 简单工厂: 策略在运行时切换，工厂在创建时选择");
        
        System.out.println("\n⚠️ 使用注意事项:");
        System.out.println("   🔸 策略数量不宜过多，避免增加复杂性");
        System.out.println("   🔸 客户端需要了解各种策略的差异");
        System.out.println("   🔸 所有策略都会被创建，可能消耗内存");
        System.out.println("   🔸 策略之间通信困难，避免策略间依赖");
        
        System.out.println("\n📈 2025年发展趋势:");
        System.out.println("   🌟 与AI结合：智能策略推荐和优化");
        System.out.println("   🌟 函数式增强：Lambda表达式简化策略定义");
        System.out.println("   🌟 响应式集成：与Stream API完美结合");
        System.out.println("   🌟 云原生适配：动态策略加载和热更新");
    }
}

/* 预期输出示例：
🎯 瓦学弟的策略模式实战开始！

=== 传统策略模式演示 ===
🔧 传统瓦学弟 切换到: 快速原型策略
👨‍💻 传统瓦学弟 开始开发...
🚀 使用快速原型策略实现: 用户登录功能
   ✅ 快速搭建基础框架
   ✅ 实现核心功能
   ⚠️ 跳过单元测试
   📦 输出: 可运行的原型系统

🔧 传统瓦学弟 切换到: 企业级开发策略
👨‍💻 传统瓦学弟 开始开发...
🏢 使用企业级开发策略实现: 支付系统
   ✅ 详细的需求分析
   ✅ 完整的系统设计
   ✅ 规范的代码实现
   ✅ 全面的单元测试
   ✅ 完善的文档编写
   📦 输出: 企业级生产系统
...
*/

🎯 策略模式2025年面试考点总结：

1. 策略模式 vs 状态模式的区别？

   • 策略模式：关注算法的替换，策略间无依赖关系
   • 状态模式：关注状态的转换，状态间有转换逻辑

2. 策略模式的优缺点？

   • 优点：符合开闭原则、消除条件语句、算法可复用
   • 缺点：客户端必须知道所有策略、策略数量增加复杂性

3. 函数式策略模式的优势？

   • 使用Lambda表达式简化策略定义
   • 减少类的数量，提高代码的简洁性
   • 更适合简单的策略逻辑

---

第四章：设计模式最佳实践 - “瓦学弟的架构师之路” 🏗️

4.1 设计模式组合使用

在实际项目中，单一设计模式往往无法解决复杂问题，需要多个模式协同工作。让我们看看瓦学弟如何像架构师一样组合使用设计模式！

/**
 * 设计模式组合实战 - 瓦学弟的企业级架构系统
 * 综合运用：单例+工厂+观察者+策略+装饰者+代理模式
 */

// 1. 单例模式：系统配置管理器
class SystemConfigManager {
    private static volatile SystemConfigManager instance;
    private final Map<String, Object> configs = new ConcurrentHashMap<>();
    private final List<ConfigChangeObserver> observers = new ArrayList<>();
    
    private SystemConfigManager() {
        loadDefaultConfigs();
    }
    
    public static SystemConfigManager getInstance() {
        if (instance == null) {
            synchronized (SystemConfigManager.class) {
                if (instance == null) {
                    instance = new SystemConfigManager();
                }
            }
        }
        return instance;
    }
    
    private void loadDefaultConfigs() {
        configs.put("app.name", "瓦学弟企业系统");
        configs.put("app.version", "2025.1.0");
        configs.put("database.url", "jdbc:mysql://localhost:3306/valstudent");
        configs.put("cache.enabled", true);
        configs.put("logging.level", "INFO");
    }
    
    public void setConfig(String key, Object value) {
        Object oldValue = configs.put(key, value);
        notifyConfigChange(key, oldValue, value);
    }
    
    public <T> T getConfig(String key, Class<T> type) {
        return type.cast(configs.get(key));
    }
    
    // 观察者模式：配置变更通知
    public void addConfigObserver(ConfigChangeObserver observer) {
        observers.add(observer);
    }
    
    private void notifyConfigChange(String key, Object oldValue, Object newValue) {
        ConfigChangeEvent event = new ConfigChangeEvent(key, oldValue, newValue);
        observers.forEach(observer -> observer.onConfigChanged(event));
    }
}

// 配置变更观察者接口
interface ConfigChangeObserver {
    void onConfigChanged(ConfigChangeEvent event);
}

// 配置变更事件
class ConfigChangeEvent {
    private final String key;
    private final Object oldValue;
    private final Object newValue;
    private final long timestamp;
    
    public ConfigChangeEvent(String key, Object oldValue, Object newValue) {
        this.key = key;
        this.oldValue = oldValue;
        this.newValue = newValue;
        this.timestamp = System.currentTimeMillis();
    }
    
    // Getter methods
    public String getKey() { return key; }
    public Object getOldValue() { return oldValue; }
    public Object getNewValue() { return newValue; }
    public long getTimestamp() { return timestamp; }
}

// 2. 工厂模式：服务工厂
interface BusinessService {
    String processRequest(String request);
    String getServiceType();
}

class UserService implements BusinessService {
    @Override
    public String processRequest(String request) {
        return "👤 用户服务处理: " + request;
    }
    
    @Override
    public String getServiceType() { return "USER"; }
}

class OrderService implements BusinessService {
    @Override
    public String processRequest(String request) {
        return "📦 订单服务处理: " + request;
    }
    
    @Override
    public String getServiceType() { return "ORDER"; }
}

class PaymentService implements BusinessService {
    @Override
    public String processRequest(String request) {
        return "💳 支付服务处理: " + request;
    }
    
    @Override
    public String getServiceType() { return "PAYMENT"; }
}

// 抽象工厂模式
abstract class ServiceFactory {
    private static final Map<String, ServiceFactory> factories = new HashMap<>();
    
    static {
        factories.put("USER", new UserServiceFactory());
        factories.put("ORDER", new OrderServiceFactory());
        factories.put("PAYMENT", new PaymentServiceFactory());
    }
    
    public static ServiceFactory getFactory(String type) {
        ServiceFactory factory = factories.get(type.toUpperCase());
        if (factory == null) {
            throw new IllegalArgumentException("不支持的服务类型: " + type);
        }
        return factory;
    }
    
    public abstract BusinessService createService();
}

class UserServiceFactory extends ServiceFactory {
    @Override
    public BusinessService createService() {
        return new UserService();
    }
}

class OrderServiceFactory extends ServiceFactory {
    @Override
    public BusinessService createService() {
        return new OrderService();
    }
}

class PaymentServiceFactory extends ServiceFactory {
    @Override
    public BusinessService createService() {
        return new PaymentService();
    }
}

// 3. 策略模式：请求处理策略
interface RequestProcessingStrategy {
    String process(String request, BusinessService service);
    String getStrategyName();
}

class SyncProcessingStrategy implements RequestProcessingStrategy {
    @Override
    public String process(String request, BusinessService service) {
        System.out.println("🔄 同步处理请求...");
        return service.processRequest(request);
    }
    
    @Override
    public String getStrategyName() { return "同步处理"; }
}

class AsyncProcessingStrategy implements RequestProcessingStrategy {
    private final ExecutorService executor = Executors.newFixedThreadPool(5);
    
    @Override
    public String process(String request, BusinessService service) {
        System.out.println("⚡ 异步处理请求...");
        CompletableFuture<String> future = CompletableFuture.supplyAsync(
            () -> service.processRequest(request), executor);
        
        try {
            return future.get(5, TimeUnit.SECONDS);
        } catch (Exception e) {
            return "❌ 异步处理超时: " + e.getMessage();
        }
    }
    
    @Override
    public String getStrategyName() { return "异步处理"; }
}

class BatchProcessingStrategy implements RequestProcessingStrategy {
    private final List<String> batchRequests = new ArrayList<>();
    private final int batchSize = 3;
    
    @Override
    public String process(String request, BusinessService service) {
        batchRequests.add(request);
        System.out.println("📦 添加到批处理队列，当前数量: " + batchRequests.size());
        
        if (batchRequests.size() >= batchSize) {
            return processBatch(service);
        }
        
        return "📝 请求已加入批处理队列，等待更多请求...";
    }
    
    继续完成策略模式的批处理逻辑，然后基于搜索到的Spring设计模式信息继续完善：

```java
    private String processBatch(BusinessService service) {
        StringBuilder result = new StringBuilder("📦 批处理执行结果:\n");
        for (String request : batchRequests) {
            result.append("  ✅ ").append(service.processRequest(request)).append("\n");
        }
        batchRequests.clear();
        return result.toString();
    }
    
    @Override
    public String getStrategyName() { return "批处理策略"; }
}

// 4. 装饰者模式：服务增强
interface ServiceDecorator extends BusinessService {
    BusinessService getWrappedService();
}

class LoggingServiceDecorator implements ServiceDecorator {
    private final BusinessService wrappedService;
    private final String decoratorName;
    
    public LoggingServiceDecorator(BusinessService service, String decoratorName) {
        this.wrappedService = service;
        this.decoratorName = decoratorName;
    }
    
    @Override
    public String processRequest(String request) {
        System.out.println("📝 [" + decoratorName + "] 记录请求日志: " + request);
        long startTime = System.currentTimeMillis();
        
        String result = wrappedService.processRequest(request);
        
        long endTime = System.currentTimeMillis();
        System.out.println("📊 [" + decoratorName + "] 处理耗时: " + (endTime - startTime) + "ms");
        System.out.println("📤 [" + decoratorName + "] 记录响应日志: " + result);
        
        return result;
    }
    
    @Override
    public String getServiceType() {
        return wrappedService.getServiceType();
    }
    
    @Override
    public BusinessService getWrappedService() {
        return wrappedService;
    }
}

class CachingServiceDecorator implements ServiceDecorator {
    private final BusinessService wrappedService;
    private final Map<String, String> cache = new ConcurrentHashMap<>();
    private final long cacheExpiry = 60000; // 1分钟过期
    private final Map<String, Long> cacheTimestamps = new ConcurrentHashMap<>();
    
    public CachingServiceDecorator(BusinessService service) {
        this.wrappedService = service;
    }
    
    @Override
    public String processRequest(String request) {
        String cacheKey = generateCacheKey(request);
        
        // 检查缓存
        if (isCacheValid(cacheKey)) {
            System.out.println("💾 [缓存装饰器] 命中缓存: " + request);
            return cache.get(cacheKey) + " (来自缓存)";
        }
        
        System.out.println("🔍 [缓存装饰器] 缓存未命中，执行原服务");
        String result = wrappedService.processRequest(request);
        
        // 存入缓存
        cache.put(cacheKey, result);
        cacheTimestamps.put(cacheKey, System.currentTimeMillis());
        
        return result;
    }
    
    private String generateCacheKey(String request) {
        return wrappedService.getServiceType() + ":" + request.hashCode();
    }
    
    private boolean isCacheValid(String cacheKey) {
        if (!cache.containsKey(cacheKey)) {
            return false;
        }
        
        Long timestamp = cacheTimestamps.get(cacheKey);
        return timestamp != null && (System.currentTimeMillis() - timestamp) < cacheExpiry;
    }
    
    @Override
    public String getServiceType() {
        return wrappedService.getServiceType();
    }
    
    @Override
    public BusinessService getWrappedService() {
        return wrappedService;
    }
    
    public void clearCache() {
        cache.clear();
        cacheTimestamps.clear();
        System.out.println("🗑️ [缓存装饰器] 缓存已清空");
    }
}

class SecurityServiceDecorator implements ServiceDecorator {
    private final BusinessService wrappedService;
    private final Set<String> authorizedUsers = new HashSet<>();
    private String currentUser;
    
    public SecurityServiceDecorator(BusinessService service) {
        this.wrappedService = service;
        // 初始化授权用户
        authorizedUsers.add("admin");
        authorizedUsers.add("user1");
        authorizedUsers.add("manager");
    }
    
    @Override
    public String processRequest(String request) {
        if (!isAuthorized()) {
            return "🚫 [安全装饰器] 访问被拒绝: 用户 " + currentUser + " 无权限";
        }
        
        System.out.println("✅ [安全装饰器] 权限验证通过，用户: " + currentUser);
        String result = wrappedService.processRequest(request);
        
        System.out.println("🔐 [安全装饰器] 记录安全审计日志");
        return result;
    }
    
    private boolean isAuthorized() {
        return currentUser != null && authorizedUsers.contains(currentUser);
    }
    
    public void setCurrentUser(String user) {
        this.currentUser = user;
        System.out.println("👤 [安全装饰器] 当前用户设置为: " + user);
    }
    
    @Override
    public String getServiceType() {
        return wrappedService.getServiceType();
    }
    
    @Override
    public BusinessService getWrappedService() {
        return wrappedService;
    }
}

// 5. 代理模式：远程服务代理
class RemoteServiceProxy implements BusinessService {
    private final String serviceUrl;
    private final String serviceType;
    private BusinessService cachedService;
    private boolean isConnected = false;
    
    public RemoteServiceProxy(String serviceType, String serviceUrl) {
        this.serviceType = serviceType;
        this.serviceUrl = serviceUrl;
    }
    
    @Override
    public String processRequest(String request) {
        if (!ensureConnection()) {
            return "❌ [远程代理] 无法连接到远程服务: " + serviceUrl;
        }
        
        if (cachedService == null) {
            cachedService = createRemoteService();
        }
        
        System.out.println("🌐 [远程代理] 转发请求到: " + serviceUrl);
        String result = cachedService.processRequest(request);
        
        System.out.println("📡 [远程代理] 收到远程响应");
        return result + " (via 远程代理)";
    }
    
    private boolean ensureConnection() {
        if (!isConnected) {
            System.out.println("🔌 [远程代理] 尝试连接到: " + serviceUrl);
            // 模拟网络连接
            try {
                Thread.sleep(100); // 模拟连接延迟
                isConnected = Math.random() > 0.1; // 90%成功率
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return false;
            }
            
            if (isConnected) {
                System.out.println("✅ [远程代理] 连接成功");
            } else {
                System.out.println("❌ [远程代理] 连接失败");
            }
        }
        return isConnected;
    }
    
    private BusinessService createRemoteService() {
        // 基于服务类型创建对应的远程服务实现
        return ServiceFactory.getFactory(serviceType).createService();
    }
    
    @Override
    public String getServiceType() {
        return serviceType + "_REMOTE";
    }
    
    public void disconnect() {
        isConnected = false;
        cachedService = null;
        System.out.println("🔌 [远程代理] 已断开连接");
    }
}

// 6. 企业级请求处理器 - 组合所有模式
class EnterpriseRequestProcessor implements ConfigChangeObserver {
    private RequestProcessingStrategy strategy;
    private final SystemConfigManager configManager;
    private final Map<String, BusinessService> serviceCache = new ConcurrentHashMap<>();
    
    public EnterpriseRequestProcessor() {
        this.configManager = SystemConfigManager.getInstance();
        this.configManager.addConfigObserver(this);
        
        // 根据配置初始化默认策略
        initializeDefaultStrategy();
    }
    
    private void initializeDefaultStrategy() {
        Boolean asyncEnabled = configManager.getConfig("processing.async.enabled", Boolean.class);
        if (Boolean.TRUE.equals(asyncEnabled)) {
            this.strategy = new AsyncProcessingStrategy();
        } else {
            this.strategy = new SyncProcessingStrategy();
        }
        System.out.println("🔧 [企业处理器] 初始化策略: " + strategy.getStrategyName());
    }
    
    public String processBusinessRequest(String serviceType, String request, String userContext) {
        System.out.println("🏢 [企业处理器] 开始处理业务请求");
        System.out.println("   服务类型: " + serviceType);
        System.out.println("   请求内容: " + request);
        System.out.println("   用户上下文: " + userContext);
        
        try {
            // 获取或创建服务实例
            BusinessService service = getOrCreateService(serviceType, userContext);
            
            // 使用当前策略处理请求
            String result = strategy.process(request, service);
            
            System.out.println("✅ [企业处理器] 请求处理完成");
            return result;
            
        } catch (Exception e) {
            String errorMsg = "❌ [企业处理器] 处理异常: " + e.getMessage();
            System.out.println(errorMsg);
            return errorMsg;
        }
    }
    
    private BusinessService getOrCreateService(String serviceType, String userContext) {
        String cacheKey = serviceType + ":" + userContext;
        
        return serviceCache.computeIfAbsent(cacheKey, key -> {
            System.out.println("🏭 [企业处理器] 创建新的服务实例: " + serviceType);
            
            // 1. 工厂模式：创建基础服务
            BusinessService baseService = ServiceFactory.getFactory(serviceType).createService();
            
            // 2. 根据配置决定是否使用远程代理
            Boolean remoteEnabled = configManager.getConfig("service.remote.enabled", Boolean.class);
            if (Boolean.TRUE.equals(remoteEnabled)) {
                String remoteUrl = configManager.getConfig("service.remote.url." + serviceType, String.class);
                if (remoteUrl != null) {
                    baseService = new RemoteServiceProxy(serviceType, remoteUrl);
                }
            }
            
            // 3. 装饰者模式：添加各种增强功能
            BusinessService decoratedService = baseService;
            
            // 安全装饰
            Boolean securityEnabled = configManager.getConfig("service.security.enabled", Boolean.class);
            if (Boolean.TRUE.equals(securityEnabled)) {
                SecurityServiceDecorator securityDecorator = new SecurityServiceDecorator(decoratedService);
                securityDecorator.setCurrentUser(extractUserFromContext(userContext));
                decoratedService = securityDecorator;
            }
            
            // 缓存装饰
            Boolean cacheEnabled = configManager.getConfig("service.cache.enabled", Boolean.class);
            if (Boolean.TRUE.equals(cacheEnabled)) {
                decoratedService = new CachingServiceDecorator(decoratedService);
            }
            
            // 日志装饰
            Boolean loggingEnabled = configManager.getConfig("service.logging.enabled", Boolean.class);
            if (Boolean.TRUE.equals(loggingEnabled)) {
                decoratedService = new LoggingServiceDecorator(decoratedService, "企业日志");
            }
            
            return decoratedService;
        });
    }
    
    private String extractUserFromContext(String userContext) {
        // 简单的用户提取逻辑
        return userContext != null && userContext.startsWith("user:") ? 
               userContext.substring(5) : "anonymous";
    }
    
    public void setProcessingStrategy(RequestProcessingStrategy strategy) {
        this.strategy = strategy;
        System.out.println("🔄 [企业处理器] 策略已切换: " + strategy.getStrategyName());
    }
    
    @Override
    public void onConfigChanged(ConfigChangeEvent event) {
        System.out.println("⚙️ [企业处理器] 检测到配置变更: " + event.getKey());
        
        // 根据配置变更调整行为
        switch (event.getKey()) {
            case "processing.async.enabled":
                adjustProcessingStrategy();
                break;
            case "service.cache.enabled":
                handleCacheConfigChange();
                break;
            default:
                System.out.println("   配置变更已忽略");
        }
    }
    
    private void adjustProcessingStrategy() {
        Boolean asyncEnabled = configManager.getConfig("processing.async.enabled", Boolean.class);
        if (Boolean.TRUE.equals(asyncEnabled)) {
            setProcessingStrategy(new AsyncProcessingStrategy());
        } else {
            setProcessingStrategy(new SyncProcessingStrategy());
        }
    }
    
    private void handleCacheConfigChange() {
        Boolean cacheEnabled = configManager.getConfig("service.cache.enabled", Boolean.class);
        if (Boolean.FALSE.equals(cacheEnabled)) {
            // 清理所有缓存装饰器的缓存
            serviceCache.values().stream()
                    .filter(service -> service instanceof CachingServiceDecorator)
                    .map(service -> (CachingServiceDecorator) service)
                    .forEach(CachingServiceDecorator::clearCache);
        }
    }
    
    public void showSystemStatus() {
        System.out.println("📊 [企业处理器] 系统状态报告:");
        System.out.println("   当前策略: " + strategy.getStrategyName());
        System.out.println("   缓存服务数: " + serviceCache.size());
        System.out.println("   配置项: ");
        
        String[] configKeys = {
            "processing.async.enabled",
            "service.remote.enabled", 
            "service.security.enabled",
            "service.cache.enabled",
            "service.logging.enabled"
        };
        
        for (String key : configKeys) {
            Object value = configManager.getConfig(key, Object.class);
            System.out.println("     " + key + " = " + value);
        }
    }
    
    public void clearServiceCache() {
        serviceCache.clear();
        System.out.println("🗑️ [企业处理器] 服务缓存已清空");
    }
}

/**
 * 使用示例 - 瓦学弟的企业级架构实战
 */
public class DesignPatternCombinationDemo {
    public static void main(String[] args) {
        System.out.println("🏗️ 瓦学弟的设计模式组合实战开始！\n");
        
        // 演示1：基础模式组合
        demonstrateBasicCombination();
        
        // 演示2：配置驱动的动态行为
        demonstrateConfigDrivenBehavior();
        
        // 演示3：复杂业务场景处理
        demonstrateComplexBusinessScenario();
        
        // 演示4：系统监控和管理
        demonstrateSystemMonitoring();
        
        // 演示5：性能优化和最佳实践
        demonstratePerformanceOptimization();
        
        System.out.println("🏆 设计模式组合让瓦学弟的架构更加强大，得了MVP！");
    }
    
    private static void demonstrateBasicCombination() {
        System.out.println("=== 基础模式组合演示 ===");
        
        // 单例配置管理器
        SystemConfigManager config = SystemConfigManager.getInstance();
        config.setConfig("service.logging.enabled", true);
        config.setConfig("service.cache.enabled", true);
        
        // 创建企业级处理器
        EnterpriseRequestProcessor processor = new EnterpriseRequestProcessor();
        
        // 处理不同类型的业务请求
        System.out.println("👤 处理用户服务请求:");
        String result1 = processor.processBusinessRequest("USER", "查询用户信息", "user:admin");
        System.out.println("结果: " + result1);
        
        System.out.println("\n📦 处理订单服务请求:");
        String result2 = processor.processBusinessRequest("ORDER", "创建订单", "user:user1");
        System.out.println("结果: " + result2);
        
        System.out.println();
    }
    
    private static void demonstrateConfigDrivenBehavior() {
        System.out.println("=== 配置驱动的动态行为演示 ===");
        
        SystemConfigManager config = SystemConfigManager.getInstance();
        EnterpriseRequestProcessor processor = new EnterpriseRequestProcessor();
        
        // 初始配置
        processor.showSystemStatus();
        
        System.out.println("\n🔧 修改配置启用异步处理:");
        config.setConfig("processing.async.enabled", true);
        
        System.out.println("\n🔧 修改配置启用远程服务:");
        config.setConfig("service.remote.enabled", true);
        config.setConfig("service.remote.url.PAYMENT", "http://payment-service:8080");
        
        System.out.println("\n💳 使用新配置处理支付请求:");
        String result = processor.processBusinessRequest("PAYMENT", "处理支付", "user:manager");
        System.out.println("结果: " + result);
        
        processor.showSystemStatus();
        System.out.println();
    }
    
    private static void demonstrateComplexBusinessScenario() {
        System.out.println("=== 复杂业务场景处理演示 ===");
        
        SystemConfigManager config = SystemConfigManager.getInstance();
        config.setConfig("service.security.enabled", true);
        config.setConfig("service.cache.enabled", true);
        config.setConfig("service.logging.enabled", true);
        
        EnterpriseRequestProcessor processor = new EnterpriseRequestProcessor();
        
        // 模拟电商下单流程
        System.out.println("🛒 模拟电商下单流程:");
        
        String[] requests = {
            "验证用户身份",
            "检查商品库存", 
            "计算订单金额",
            "调用支付接口",
            "更新库存",
            "发送确认邮件"
        };
        
        String[] serviceTypes = {"USER", "ORDER", "ORDER", "PAYMENT", "ORDER", "USER"};
        
        for (int i = 0; i < requests.length; i++) {
            System.out.println("\n步骤 " + (i + 1) + ": " + requests[i]);
            String result = processor.processBusinessRequest(
                serviceTypes[i], 
                requests[i], 
                "user:customer123"
            );
            System.out.println("✅ " + result);
            
            // 模拟处理间隔
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        
        System.out.println();
    }
    
    private static void demonstrateSystemMonitoring() {
        System.out.println("=== 系统监控和管理演示 ===");
        
        EnterpriseRequestProcessor processor = new EnterpriseRequestProcessor();
        
        // 批量处理请求以观察缓存效果
        System.out.println("📊 批量处理相同请求观察缓存效果:");
        for (int i = 1; i <= 3; i++) {
            System.out.println("\n第 " + i + " 次请求:");
            processor.processBusinessRequest("USER", "获取用户资料", "user:testuser");
        }
        
        System.out.println("\n📈 系统状态检查:");
        processor.showSystemStatus();
        
        System.out.println("\n🔄 测试配置热更新:");
        SystemConfigManager.getInstance().setConfig("service.cache.enabled", false);
        
        System.out.println("\n🗑️ 清理系统缓存:");
        processor.clearServiceCache();
        
        System.out.println();
    }
    
    private static void demonstratePerformanceOptimization() {
        System.out.println("=== 性能优化和最佳实践演示 ===");
        
        System.out.println("💡 设计模式组合的最佳实践:");
        System.out.println("   ✅ 单例模式管理全局配置，避免重复创建");
        System.out.println("   ✅ 工厂模式封装对象创建逻辑，便于扩展");
        System.out.println("   ✅ 策略模式支持算法切换，提高灵活性");
        System.out.println("   ✅ 装饰者模式分层增强功能，职责清晰");
        System.out.println("   ✅ 代理模式处理远程调用，透明化网络访问");
        System.out.println("   ✅ 观察者模式实现配置热更新，无需重启");
        
        System.out.println("\n⚠️ 注意事项:");
        System.out.println("   🔸 避免过度设计，根据实际需求选择模式");
        System.out.println("   🔸 注意性能开销，装饰者链不宜过长");
        System.out.println("   🔸 保持代码可读性，添加清晰的注释和文档");
        System.out.println("   🔸 考虑线程安全，特别是共享状态的管理");
        
        System.out.println("\n🚀 2025年发展趋势:");
        System.out.println("   🌟 与Spring框架深度集成");
        System.out.println("   🌟 响应式编程模式的融合");
        System.out.println("   🌟 云原生架构的适配");
        System.out.println("   🌟 微服务模式的完美支持");
        
        // 性能测试
        performanceTest();
    }
    
    private static void performanceTest() {
        System.out.println("\n⚡ 性能测试:");
        
        SystemConfigManager config = SystemConfigManager.getInstance();
        config.setConfig("service.cache.enabled", true);
        
        EnterpriseRequestProcessor processor = new EnterpriseRequestProcessor();
        
        // 预热
        for (int i = 0; i < 10; i++) {
            processor.processBusinessRequest("USER", "性能测试预热", "user:perf");
        }
        
        // 正式测试
        int testCount = 100;
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < testCount; i++) {
            processor.processBusinessRequest("USER", "性能测试请求" + i, "user:perf");
        }
        
        long endTime = System.currentTimeMillis();
        long totalTime = endTime - startTime;
        
        System.out.println("📊 性能测试结果:");
        System.out.println("   总请求数: " + testCount);
        System.out.println("   总耗时: " + totalTime + "ms");
        System.out.println("   平均耗时: " + (totalTime / testCount) + "ms/请求");
        System.out.println("   QPS: " + (testCount * 1000 / totalTime) + "请求/秒");
    }
}

/* 预期输出示例：
🏗️ 瓦学弟的设计模式组合实战开始！

=== 基础模式组合演示 ===
🔧 [企业处理器] 初始化策略: 同步处理
⚙️ [企业处理器] 检测到配置变更: service.logging.enabled
   配置变更已忽略
⚙️ [企业处理器] 检测到配置变更: service.cache.enabled
   配置变更已忽略

👤 处理用户服务请求:
🏢 [企业处理器] 开始处理业务请求
   服务类型: USER
   请求内容: 查询用户信息
   用户上下文: user:admin
🏭 [企业处理器] 创建新的服务实例: USER
👤 [安全装饰器] 当前用户设置为: admin
🔄 同步处理请求...
📝 [企业日志] 记录请求日志: 查询用户信息
✅ [安全装饰器] 权限验证通过，用户: admin
🔍 [缓存装饰器] 缓存未命中，执行原服务
👤 用户服务处理: 查询用户信息
📊 [企业日志] 处理耗时: 0ms
📤 [企业日志] 记录响应日志: 👤 用户服务处理: 查询用户信息
🔐 [安全装饰器] 记录安全审计日志
✅ [企业处理器] 请求处理完成
结果: 👤 用户服务处理: 查询用户信息
...
*/

🎯 设计模式组合使用2025年面试考点总结：

1. 如何选择合适的设计模式组合？

   • 分析业务场景的复杂度和变化点
   • 考虑性能要求和扩展性需求
   • 遵循SOLID原则，避免过度设计

2. 设计模式在Spring框架中的应用？

   • IoC容器使用工厂模式和依赖注入
   • AOP使用代理模式和装饰者模式
   • Bean作用域使用单例模式
   • 事件机制使用观察者模式

3. 模式组合的最佳实践？

   • 保持代码的可读性和可维护性
   • 注意性能开销，特别是装饰者链
   • 考虑线程安全和并发访问
   • 建立清晰的架构边界

---

总结：瓦学弟的设计模式武功秘籍 🥷

通过这次完整的设计模式之旅，瓦学弟已经掌握了2025年最实用的设计模式技能：

🏆 核心收获

1. 创建型模式 - 掌握对象创建的艺术

   • 单例模式：全局唯一实例管理
   • 工厂模式：对象创建的灵活控制
   • 建造者模式：复杂对象的优雅构建

2. 结构型模式 - 理解对象组合的智慧

   • 装饰者模式：功能增强的层次化设计
   • 代理模式：访问控制和远程调用

3. 行为型模式 - 掌握对象交互的技巧

   • 观察者模式：事件驱动的响应式设计
   • 策略模式：算法选择的灵活切换

4. 模式组合 - 架构师级别的系统设计

   • 多模式协同工作
   • 企业级架构实践
   • 性能优化和最佳实践

🚀 2025年发展趋势

• 函数式编程融合：Lambda表达式简化模式实现
• 响应式编程集成：与Stream API完美结合
• Spring生态集成：深度融入企业级开发
• 云原生适配：支持微服务和容器化部署
• AI辅助设计：智能推荐最适合的设计模式

💎 实战建议

1. 不要为了模式而模式：根据实际需求选择合适的模式
2. 渐进式应用：从简单场景开始，逐步应用复杂模式
3. 注重可读性：保持代码清晰，添加详细注释
4. 持续重构：随着需求变化及时调整模式应用
5. 团队协作：建立模式使用规范，提高团队效率

恭喜瓦学弟！现在你已经具备了高级Java开发工程师的设计模式功底，可以在面试和实际工作中游刃有余地运用这些强大的设计工具了！🎉