Java设计模式万字长文深度解析：瓦学弟的架构修炼之路（2025版） - 实践

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开发工程师的设计模式功底，可以在面试和实际工作中游刃有余地运用这些强大的设计工具了！