【设计模式】3W 学习法深入剖析创建型模式：原理、实战与开源框架应用（含 Java 代码）

3W 学习法总结创建型模式（附 Java 代码实战及开源框架应用）

创建型模式主要关注 对象的创建，旨在提高代码的可复用性、可扩展性和灵活性。本文采用 3W 学习法（What、Why、How），深入分析 五大创建型模式：单例、工厂方法、抽象工厂、建造者和原型模式，并结合 Java 代码实战 及 开源框架中的应用，帮助你高效掌握创建型模式。

1. 单例模式（Singleton）

✅ What：单例模式是什么？

单例模式 确保一个类只有一个实例，并提供一个全局访问点。它常用于 共享资源管理、线程池、日志管理 等场景。

🤔 Why：为什么要使用单例模式？

• 节省资源：避免创建多个实例，减少内存占用。
• 全局访问：提供唯一实例，适用于缓存、配置管理等。
• 控制实例化：防止重复创建对象，提升系统性能。

🚀 How：如何实现单例模式？（Java 代码实战）

双重检查锁实现线程安全单例

public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {} // 私有构造函数

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

📌 在开源框架中的应用：

• Spring 的 Bean 作用域：默认情况下，Spring Bean 是单例模式 (@Scope("singleton"))。
• Runtime.getRuntime()：Java 的 Runtime 类是单例模式的典型应用。

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

✅ What：工厂方法模式是什么？

工厂方法模式 通过 定义一个抽象工厂接口，让子类决定实例化哪个类，从而实现 面向接口编程。

🤔 Why：为什么要使用工厂方法？

• 解耦：调用者无需关心具体实现，依赖抽象工厂。
• 符合开闭原则：新增产品无需修改原工厂，只需创建新的子类工厂。

🚀 How：如何实现工厂方法？（Java 代码实战）

// 抽象产品
interface Product {
    void use();
}

// 具体产品A
class ProductA implements Product {
    public void use() { System.out.println("使用产品A"); }
}

// 抽象工厂
interface Factory {
    Product createProduct();
}

// 具体工厂A
class FactoryA implements Factory {
    public Product createProduct() { return new ProductA(); }
}

// 客户端调用
public class FactoryMethodDemo {
    public static void main(String[] args) {
        Factory factory = new FactoryA();
        Product product = factory.createProduct();
        product.use(); // 输出: 使用产品A
    }
}

📌 在开源框架中的应用：

• Spring BeanFactory：Spring 通过 BeanFactory 采用工厂方法模式管理 Bean 的创建。
• JDBC 驱动加载：DriverManager.getConnection() 通过工厂方法获取不同数据库驱动。

3. 抽象工厂模式（Abstract Factory）

✅ What：抽象工厂模式是什么？

抽象工厂模式 提供一个 接口，用于创建 一系列相关或相互依赖的对象，而无需指定其具体类。

🤔 Why：为什么要使用抽象工厂？

• 产品族管理：能创建 一整套相关产品，适用于 GUI 组件、数据库连接等场景。
• 保证产品兼容性：不同产品族之间不会互相影响。

🚀 How：如何实现抽象工厂模式？（Java 代码实战）

// 抽象产品A
interface Button { void click(); }

// 具体产品A1
class MacButton implements Button {
    public void click() { System.out.println("Mac 按钮点击"); }
}

// 抽象工厂
interface GUIFactory {
    Button createButton();
}

// 具体工厂：Mac 工厂
class MacFactory implements GUIFactory {
    public Button createButton() { return new MacButton(); }
}

// 客户端调用
public class AbstractFactoryDemo {
    public static void main(String[] args) {
        GUIFactory factory = new MacFactory();
        Button button = factory.createButton();
        button.click(); // 输出: Mac 按钮点击
    }
}

📌 在开源框架中的应用：

• Spring ApplicationContext：Spring 使用 ApplicationContext 作为抽象工厂，创建和管理 Bean。
• 数据库连接池：如 javax.sql.DataSource 负责创建数据库连接对象。

4. 建造者模式（Builder）

✅ What：建造者模式是什么？

建造者模式 通过 一步步构建复杂对象，并支持 链式调用，适用于 对象参数较多的场景。

🤔 Why：为什么要使用建造者模式？

• 解决构造函数参数过多的问题，避免冗长的构造函数。
• 链式调用 使代码更简洁，提高可读性。

🚀 How：如何实现建造者模式？（Java 代码实战）

class Computer {
    private String CPU;
    private int RAM;

    public static class Builder {
        private String CPU;
        private int RAM;

        public Builder setCPU(String CPU) { this.CPU = CPU; return this; }
        public Builder setRAM(int RAM) { this.RAM = RAM; return this; }
        public Computer build() { return new Computer(this); }
    }

    private Computer(Builder builder) {
        this.CPU = builder.CPU;
        this.RAM = builder.RAM;
    }
}

// 客户端调用
public class BuilderDemo {
    public static void main(String[] args) {
        Computer computer = new Computer.Builder()
            .setCPU("Intel i9")
            .setRAM(32)
            .build();
        System.out.println("电脑构造完成");
    }
}

📌 在开源框架中的应用：

• Lombok @Builder 注解：简化 Java 对象构造。
• StringBuilder：StringBuilder.append() 采用建造者模式。

5. 原型模式（Prototype）

✅ What：原型模式是什么？

原型模式 通过 克隆现有对象 来创建新对象，而不是直接实例化。

🤔 Why：为什么要使用原型模式？

• 提高性能：避免重复创建对象，适用于对象初始化成本高的场景。
• 避免复杂构造：直接复制已有对象，减少对象创建的复杂度。

🚀 How：如何实现原型模式？（Java 代码实战）

class Prototype implements Cloneable {
    String name;

    public Prototype(String name) { this.name = name; }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

// 客户端调用
public class PrototypeDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Prototype p1 = new Prototype("原型对象");
        Prototype p2 = (Prototype) p1.clone();
        System.out.println("克隆成功: " + p2.name);
    }
}

📌 在开源框架中的应用：

• Spring Bean 作用域 @Scope("prototype")：每次获取 Bean 时都会克隆新实例。
• java.lang.Object#clone()：标准 Java 克隆机制。

总结

这五种创建型模式各有特点，结合实际项目，能让代码更加灵活、可维护！ 🚀