Java设计模式深度解析：创建型模式实战指南

设计模式是软件工程中解决常见问题的可复用方案，本文将重点解析Java中的创建型模式，包括其实现原理、典型应用场景以及最佳实践。

一、单例模式：全局唯一实例的优雅实现

1.1 线程安全实现方案

单例模式确保一个类只有一个实例，并提供全局访问点。以下是几种线程安全的实现方式：

1.1.1 双重检查锁定（Double-Checked Locking）

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;
    }
}

关键点：

• volatile防止指令重排序
• 双重检查减少同步开销
• 适用于JDK5及以上版本

1.1.2 静态内部类实现

public class Singleton {
    private Singleton() {}
    
    private static class Holder {
        static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

优势：

• 懒加载（首次调用getInstance时加载）
• 无同步开销
• JVM保证类初始化的线程安全

1.2 单例模式的破坏与防御

1.2.1 反射攻击防护

public class Singleton {
    private static volatile Singleton instance;
    private static boolean initialized = false;
    
    private Singleton() {
        synchronized (Singleton.class) {
            if (initialized) {
                throw new RuntimeException("单例已被创建");
            }
            initialized = true;
        }
    }
    // ...其余代码
}

1.2.2 反序列化防护

public class Singleton implements Serializable {
    // ...其他代码
    
    protected Object readResolve() {
        return getInstance();
    }
}

实践建议：

• 优先使用枚举实现单例（天然防反射和序列化攻击）
• 考虑使用依赖注入框架管理单例生命周期
• 避免在分布式环境中误用单例模式

二、工厂方法模式：灵活的对象创建

2.1 标准实现

public interface Product {
    void operate();
}

public class ConcreteProduct implements Product {
    @Override
    public void operate() {
        System.out.println("具体产品操作");
    }
}

public abstract class Creator {
    public abstract Product createProduct();
    
    public void doSomething() {
        Product product = createProduct();
        product.operate();
    }
}

public class ConcreteCreator extends Creator {
    @Override
    public Product createProduct() {
        return new ConcreteProduct();
    }
}

2.2 Spring中的工厂方法

@Configuration
public class AppConfig {
    @Bean
    public Product product() {
        return new ConcreteProduct();
    }
}

// 使用
@Autowired
private Product product;

应用场景：

• 需要解耦对象创建与使用
• 需要支持多种产品变体
• 需要扩展产品类型而不修改客户端代码

三、抽象工厂模式：产品族的创建

代码实现：

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

interface Checkbox {
    void check();
}

// 具体产品
class WindowsButton implements Button {
    public void render() { System.out.println("Windows风格按钮"); }
}

class MacButton implements Button {
    public void render() { System.out.println("Mac风格按钮"); }
}

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

// 具体工厂
class WindowsFactory implements GUIFactory {
    public Button createButton() { return new WindowsButton(); }
    public Checkbox createCheckbox() { return new WindowsCheckbox(); }
}

class MacFactory implements GUIFactory {
    public Button createButton() { return new MacButton(); }
    public Checkbox createCheckbox() { return new MacCheckbox(); }
}

最佳实践：

• 当需要确保产品兼容性时使用
• 适合UI组件库、跨平台开发等场景
• 结合依赖注入框架使用效果更佳

四、建造者模式：复杂对象的逐步构建

4.1 经典实现

public class Computer {
    private final String CPU;
    private final String RAM;
    private final int storage;
    
    private Computer(Builder builder) {
        this.CPU = builder.CPU;
        this.RAM = builder.RAM;
        this.storage = builder.storage;
    }
    
    public static class Builder {
        private String CPU;
        private String RAM;
        private int storage;
        
        public Builder setCPU(String CPU) {
            this.CPU = CPU;
            return this;
        }
        
        public Builder setRAM(String RAM) {
            this.RAM = RAM;
            return this;
        }
        
        public Builder setStorage(int storage) {
            this.storage = storage;
            return this;
        }
        
        public Computer build() {
            return new Computer(this);
        }
    }
}

// 使用
Computer computer = new Computer.Builder()
    .setCPU("Intel i7")
    .setRAM("16GB")
    .setStorage(512)
    .build();

4.2 Lombok简化版

@Builder
public class Computer {
    private final String CPU;
    private final String RAM;
    private final int storage;
}

与工厂模式对比：

• 工厂模式：关注整体产品创建
• 建造者模式：关注产品的分步构建和配置

五、原型模式：对象的克隆

5.1 浅拷贝实现

public class Sheep implements Cloneable {
    private String name;
    private Date birthday;
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 浅拷贝
    }
}

5.2 深拷贝实现

public class Sheep implements Cloneable {
    private String name;
    private Date birthday;
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Sheep sheep = (Sheep)super.clone();
        sheep.birthday = (Date)this.birthday.clone(); // 深拷贝引用对象
        return sheep;
    }
}

应用场景：

• 对象创建成本高时（如数据库查询结果）
• 需要保存对象状态用于回滚
• 配合享元模式使用

实践总结

1. 模式选择标准：

   • 对象创建复杂度：简单→工厂，复杂→建造者
   • 产品族需求：单一产品→工厂方法，产品族→抽象工厂
   • 性能要求：高→原型，低→常规创建

2. 性能考量：

   • 单例模式减少对象创建开销
   • 原型模式避免重复初始化
   • 工厂模式增加一定抽象成本

3. 框架整合：

   • Spring中优先使用依赖注入而非硬编码单例
   • 结合AOP增强工厂方法
   • 使用@Builder简化建造者模式实现

通过合理运用创建型模式，可以显著提高代码的可维护性、扩展性和灵活性，是每个Java开发者必须掌握的核心技能。