创建型设计模式实战：从Singleton到Builder的Java实现精髓

创建型设计模式实战：从Singleton到Builder的Java实现精髓

【免费下载链接】java-design-patterns Java 中实现的设计模式。 项目地址: https://gitcode.com/GitHub_Trending/ja/java-design-patterns

本文深入探讨了Java中五种核心创建型设计模式的实战应用，包括Singleton模式的多种线程安全实现方案对比、Factory Method与Abstract Factory的对象创建优雅解决方案、Builder模式的复杂对象构建艺术，以及Prototype模式的高效对象克隆机制。通过详细的代码示例、性能分析和适用场景对比，为开发者提供了全面的设计模式实现指南。

Singleton模式深度解析：多种线程安全实现方案对比

在Java并发编程中，Singleton模式的线程安全实现是一个经典且重要的话题。不同的实现方式在性能、内存占用和线程安全性方面有着显著差异。本文将深入分析四种主流的线程安全Singleton实现方案，并通过详细的代码示例和性能对比来帮助开发者选择最适合的方案。

同步方法实现（Synchronized Method）

同步方法是最直观的线程安全Singleton实现方式，通过在getInstance()方法上添加synchronized关键字来确保线程安全。

public final class ThreadSafeLazyLoadedIvoryTower {
    private static volatile ThreadSafeLazyLoadedIvoryTower instance;
    
    private ThreadSafeLazyLoadedIvoryTower() {
        if (instance != null) {
            throw new IllegalStateException("Already initialized.");
        }
    }
    
    public static synchronized ThreadSafeLazyLoadedIvoryTower getInstance() {
        if (instance == null) {
            instance = new ThreadSafeLazyLoadedIvoryTower();
        }
        return instance;
    }
}

优点：

• 实现简单直观
• 确保线程安全
• 延迟初始化，节省内存

缺点：

• 每次调用getInstance()都需要获取锁，性能开销大
• 在高并发场景下可能成为性能瓶颈

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

双重检查锁定通过减少同步块的使用来提高性能，是现代Java版本中推荐的实现方式。

public final class ThreadSafeDoubleCheckLocking {
    private static volatile ThreadSafeDoubleCheckLocking instance;
    
    private ThreadSafeDoubleCheckLocking() {
        if (instance != null) {
            throw new IllegalStateException("Already initialized.");
        }
    }
    
    public static ThreadSafeDoubleCheckLocking getInstance() {
        var result = instance;
        if (result == null) {
            synchronized (ThreadSafeDoubleCheckLocking.class) {
                result = instance;
                if (result == null) {
                    result = new ThreadSafeDoubleCheckLocking();
                    instance = result;
                }
            }
        }
        return result;
    }
}

关键特性：

• 使用volatile关键字确保可见性和有序性
• 局部变量result提高25%性能（Joshua Bloch推荐）
• 只在实例未创建时进行同步

枚举实现（Enum Singleton）

枚举实现是《Effective Java》作者Joshua Bloch推荐的Singleton实现方式，由JVM保证线程安全。

public enum EnumIvoryTower {
    INSTANCE;
    
    @Override
    public String toString() {
        return getDeclaringClass().getCanonicalName() + "@" + hashCode();
    }
}

优势分析：

• 绝对线程安全，由JVM保证
• 防止反射攻击和序列化问题
• 代码简洁，无需担心同步问题

使用方式：

EnumIvoryTower instance1 = EnumIvoryTower.INSTANCE;
EnumIvoryTower instance2 = EnumIvoryTower.INSTANCE;
// instance1 == instance2 为true

Bill Pugh实现（Initialization-on-demand Holder Idiom）

Bill Pugh实现利用Java类加载机制实现线程安全的延迟初始化，是目前性能最优的实现方案。

public final class BillPughImplementation {
    private BillPughImplementation() {
        if (InstanceHolder.instance != null) {
            throw new IllegalStateException("Already initialized.");
        }
    }
    
    private static class InstanceHolder {
        private static BillPughImplementation instance = new BillPughImplementation();
    }
    
    public static BillPughImplementation getInstance() {
        return InstanceHolder.instance;
    }
}

实现原理：

• 静态内部类在首次使用时才被加载
• 类加载过程是线程安全的
• 无需显式同步，性能最佳

性能对比分析

下表展示了四种实现方案的性能特征对比：

实现方案	线程安全性	性能	内存使用	代码复杂度	推荐场景
同步方法	高	低	中等	简单	低并发场景
双重检查	高	高	中等	中等	高并发场景
枚举	最高	最高	低	简单	所有场景
Bill Pugh	高	最高	低	中等	延迟初始化需求

线程安全机制深度解析

实际应用场景建议

选择同步方法的情况：

• 应用并发量较低
• 对性能要求不高
• 需要简单可靠的实现

选择双重检查锁定的情况：

• 高并发环境
• 对性能有较高要求
• 需要延迟初始化

选择枚举实现的情况：

• 追求最佳的线程安全性
• 需要防止反射和序列化攻击
• 代码简洁性优先

选择Bill Pugh实现的情况：

• 需要最优的性能表现
• 延迟初始化是必须的
• 愿意接受稍复杂的代码结构

代码示例：完整的性能测试

public class SingletonPerformanceTest {
    private static final int THREADS = 100;
    private static final int ITERATIONS = 100000;
    
    public static void main(String[] args) throws InterruptedException {
        testSynchronizedMethod();
        testDoubleCheckedLocking();
        testEnumSingleton();
        testBillPugh();
    }
    
    private static void testSynchronizedMethod() throws InterruptedException {
        long startTime = System.currentTimeMillis();
        ExecutorService executor = Executors.newFixedThreadPool(THREADS);
        
        for (int i = 0; i < THREADS; i++) {
            executor.submit(() -> {
                for (int j = 0; j < ITERATIONS; j++) {
                    ThreadSafeLazyLoadedIvoryTower.getInstance();
                }
            });
        }
        
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);
        long endTime = System.currentTimeMillis();
        System.out.println("Synchronized Method: " + (endTime - startTime) + "ms");
    }
    
    // 其他测试方法类似...
}

通过深入分析这四种线程安全Singleton实现方案，开发者可以根据具体的应用场景和性能需求选择最合适的实现方式。枚举实现虽然简单高效，但Bill Pugh实现在需要延迟初始化的场景中表现更佳，而双重检查锁定则在性能和复杂度之间提供了良好的平衡。

Factory Method与Abstract Factory：对象创建的优雅解决方案

在软件设计中，对象创建是一个看似简单却蕴含深意的环节。Factory Method和Abstract Factory作为创建型设计模式的杰出代表，为我们提供了优雅的对象创建解决方案。它们不仅仅是简单的"new"操作符的替代品，更是面向对象设计原则的完美体现。

模式核心思想对比

让我们首先通过一个对比表格来理解这两种模式的核心差异：

特性	Factory Method	Abstract Factory
创建对象	单个产品对象	产品族（多个相关对象）
抽象层次	方法级别抽象	工厂级别抽象
扩展性	通过子类扩展	通过新工厂实现扩展
使用场景	类无法预知创建对象类型	需要创建相关对象族
耦合度	较低，客户端与具体产品解耦	较高，但产品族内高度一致

Factory Method：虚拟构造器的艺术

Factory Method模式通过定义一个创建对象的接口，但让子类决定实例化哪个类。这种设计将对象的创建过程延迟到子类，实现了创建逻辑的封装和扩展。

代码实现解析

以武器制造系统为例，我们首先定义抽象创建者接口：

public interface Blacksmith {
    Weapon manufactureWeapon(WeaponType weaponType);
}

具体的创建者实现根据不同类型创建相应的产品：

public class ElfBlacksmith implements Blacksmith {
    private static final Map<WeaponType, Weapon> ELFARSENAL = new EnumMap<>(WeaponType.class);
    
    static {
        ELFARSENAL.put(WeaponType.SPEAR, new ElfWeapon(WeaponType.SPEAR));
        ELFARSENAL.put(WeaponType.AXE, new ElfWeapon(WeaponType.AXE));
    }
    
    @Override
    public Weapon manufactureWeapon(WeaponType weaponType) {
        return ELFARSENAL.get(weaponType);
    }
}

序列图展示

Abstract Factory：产品族的统一创建

Abstract Factory模式提供了一个接口用于创建相关或依赖对象的家族，而无需指定它们具体的类。这种模式特别适合于需要确保一系列相关产品一起使用的场景。

王国创建系统实现

在王国创建示例中，我们首先定义产品接口：

public interface Castle {
    String getDescription();
}

public interface King {
    String getDescription();
}

public interface Army {
    String getDescription();
}

然后定义抽象工厂接口：

public interface KingdomFactory {
    Castle createCastle();
    King createKing();
    Army createArmy();
}

具体的工厂实现创建特定风格的产品族：

public class ElfKingdomFactory implements KingdomFactory {
    @Override
    public Castle createCastle() {
        return new ElfCastle();
    }
    
    @Override
    public King createKing() {
        return new ElfKing();
    }
    
    @Override
    public Army createArmy() {
        return new ElfArmy();
    }
}

类关系图

实际应用场景分析

Factory Method适用场景

1. 框架设计：当框架需要为应用程序提供扩展点时，Factory Method允许子类提供具体的实现
2. 类库开发：类库不知道需要使用哪些具体类，由客户端代码决定
3. 测试驱动开发：通过工厂方法可以轻松注入mock对象进行测试

Abstract Factory适用场景

1. 跨平台UI开发：为不同操作系统创建相应的UI组件族
2. 数据库访问：为不同数据库系统提供统一的数据访问接口
3. 游戏开发：为不同游戏风格创建相应的角色、道具、场景等

模式组合与协作

在实际应用中，这两种模式经常协同工作。Abstract Factory通常使用Factory Methods来实现其产品创建方法，这种组合提供了极大的灵活性。

public class ModernFurnitureFactory implements FurnitureFactory {
    @Override
    public Chair createChair() {
        return new ModernChair();  // Factory Method的应用
    }
    
    @Override
    public Table createTable() {
        return new ModernTable();  // Factory Method的应用
    }
}

性能与复杂度考量

虽然这两种模式提供了优秀的解耦和扩展性，但也需要权衡其带来的复杂度：

1. 代码复杂度：增加了接口和类的数量，提高了代码的抽象层次
2. 运行时性能：额外的间接层可能带来轻微的性能开销
3. 学习曲线：开发人员需要理解模式的设计意图和使用方式

最佳实践建议

1. 适时使用：不要过度设计，只有在真正需要灵活性时才使用这些模式
2. 命名规范：使用清晰的命名，如createXXX()、makeXXX()等工厂方法命名约定
3. 错误处理：在工厂方法中考虑异常情况，提供有意义的错误信息
4. 文档完善：为工厂接口和实现提供详细的文档说明

总结思考

Factory Method和Abstract Factory模式代表了面向对象设计中的高级创建技术。它们不仅仅是创建对象的工具，更是软件架构中重要的设计决策。通过合理运用这些模式，我们可以构建出更加灵活、可维护、可扩展的软件系统。

在选择使用哪种模式时，关键要考虑的是：如果只需要创建单个产品对象，Factory Method是更轻量级的选择；如果需要创建一系列相关的产品对象，Abstract Factory提供了更好的整体一致性保障。无论选择哪种模式，都要确保其带来的好处能够抵消增加的复杂度。

Builder模式：复杂对象构建的逐步构造艺术

在软件开发中，我们经常需要创建具有多个属性的复杂对象。传统的构造方法往往会导致代码可读性差、维护困难的问题。Builder模式通过提供一种优雅的、逐步构造对象的方式，完美解决了这一难题。

Builder模式的核心思想

Builder模式的核心在于将复杂对象的构造过程与其表示分离，使得相同的构造过程可以创建不同的表示。这种模式特别适用于那些具有大量可选参数的对象构造场景。

让我们通过一个角色扮演游戏中的英雄创建系统来深入理解Builder模式的实现：

public record Hero(
    Profession profession,
    String name,
    HairType hairType,
    HairColor hairColor,
    Armor armor,
    Weapon weapon) {
    
    // Builder内部类实现
    public static class Builder {
        private final Profession profession;
        private final String name;
        private HairType hairType;
        private HairColor hairColor;
        private Armor armor;
        private Weapon weapon;
        
        public Builder(Profession profession, String name) {
            // 参数验证
            if (profession == null || name == null) {
                throw new IllegalArgumentException("profession and name can not be null");
            }
            this.profession = profession;
            this.name = name;
        }
        
        // 流畅接口方法
        public Builder withHairType(HairType hairType) {
            this.hairType = hairType;
            return this;
        }
        
        public Builder withHairColor(HairColor hairColor) {
            this.hairColor = hairColor;
            return this;
        }
        
        public Builder withArmor(Armor armor) {
            this.armor = armor;
            return this;
        }
        
        public Builder withWeapon(Weapon weapon) {
            this.weapon = weapon;
            return this;
        }
        
        public Hero build() {
            return new Hero(this);
        }
    }
}

枚举类型的定义

为了支持Builder模式，我们需要定义相关的枚举类型：

public enum Profession {
    WARRIOR, THIEF, MAGE, PRIEST;
    
    @Override
    public String toString() {
        return name().toLowerCase();
    }
}

public enum HairType {
    BALD, SHORT, CURLY, LONG_STRAIGHT, LONG_CURLY;
    
    @Override
    public String toString() {
        return name().toLowerCase().replace('_', ' ');
    }
}

public enum HairColor {
    BLACK, BLOND, BROWN, RED, WHITE;
    
    @Override
    public String toString() {
        return name().toLowerCase();
    }
}

public enum Armor {
    CLOTHES, LEATHER, CHAIN_MAIL, PLATE_MAIL;
    
    @Override
    public String toString() {
        return name().toLowerCase().replace('_', ' ');
    }
}

public enum Weapon {
    DAGGER, SWORD, AXE, WARHAMMER, BOW;
    
    @Override
    public String toString() {
        return name().toLowerCase();
    }
}

Builder模式的使用示例

Builder模式的最大优势在于其流畅的API设计和清晰的构造过程：

// 创建法师角色
var mage = new Hero.Builder(Profession.MAGE, "Riobard")
        .withHairColor(HairColor.BLACK)
        .withWeapon(Weapon.DAGGER)
        .build();

// 创建战士角色  
var warrior = new Hero.Builder(Profession.WARRIOR, "Amberjill")
        .withHairColor(HairColor.BLOND)
        .withHairType(HairType.LONG_CURLY)
        .withArmor(Armor.CHAIN_MAIL)
        .withWeapon(Weapon.SWORD)
        .build();

// 创建盗贼角色
var thief = new Hero.Builder(Profession.THIEF, "Desmond")
        .withHairType(HairType.BALD)
        .withWeapon(Weapon.BOW)
        .build();

Builder模式的序列图

为了更好地理解Builder模式的工作流程，让我们通过序列图来展示对象构建的过程：

Builder模式的优势分析

1. 解决构造器膨胀问题

传统的构造器方式在面对多个可选参数时会产生所谓的"伸缩构造器"反模式：

// 反模式示例：伸缩构造器
public Hero(Profession profession, String name) { /*...*/ }
public Hero(Profession profession, String name, HairType hairType) { /*...*/ }
public Hero(Profession profession, String name, HairType hairType, HairColor hairColor) { /*...*/ }
// ... 更多构造器

Builder模式通过流畅接口避免了这种构造器爆炸的问题。

2. 提高代码可读性

Builder模式的方法链调用方式使得代码更加清晰易懂：

// 清晰的构造过程
new Hero.Builder(Profession.MAGE, "Gandalf")
    .withHairColor(HairColor.WHITE)
    .withHairType(HairType.LONG_STRAIGHT)
    .withWeapon(Weapon.STAFF)
    .build();

3. 参数验证和约束

Builder模式可以在构造过程中进行参数验证：

public Builder(Profession profession, String name) {
    if (profession == null || name == null) {
        throw new IllegalArgumentException("profession and name can not be null");
    }
    this.profession = profession;
    this.name = name;
}

4. 不可变对象支持

通过Builder模式可以轻松创建不可变对象，提高线程安全性：

public record Hero(
    Profession profession,
    String name,
    HairType hairType,
    HairColor hairColor,
    Armor armor,
    Weapon weapon) {
    // 所有字段都是final的，对象不可变
}

Builder模式的类关系图

让我们通过类图来展示Builder模式的整体结构：

实际应用场景

Builder模式在现实开发中有广泛的应用：

1. 配置对象构建：如数据库连接配置、HTTP客户端配置等
2. 复杂DTO对象：包含多个嵌套属性的数据传输对象
3. 查询构建器：如SQL查询构建器、搜索条件构建器
4. UI组件构建：图形界面组件的逐步构建

最佳实践和注意事项

1. 必需参数验证：在Builder构造器中验证必需参数
2. 方法链返回this：确保每个with方法都返回Builder实例
3. 构建方法命名：通常使用build()作为最终构建方法
4. 不可变对象：结合record类或final字段创建不可变对象
5. 参数默认值：可以为可选参数提供合理的默认值

性能考虑

虽然Builder模式会增加一些额外的对象创建开销，但在大多数应用场景中，这种开销是可以接受的。Builder模式带来的代码清晰度和可维护性的提升远远超过了微小的性能代价。

通过Builder模式，我们实现了复杂对象的优雅构造，代码的可读性和可维护性得到了显著提升。这种模式特别适合那些具有多个可选参数的复杂对象构造场景，是现代Java开发中不可或缺的设计模式之一。

Prototype模式：通过克隆实现对象高效创建

在软件开发中，对象创建是一个频繁且可能代价高昂的操作。当需要创建大量相似对象时，传统的构造方法调用可能会导致性能瓶颈。Prototype（原型）设计模式通过克隆现有对象来创建新实例，为这一问题提供了优雅的解决方案。

原型模式的核心思想

Prototype模式的核心在于使用原型实例来指定要创建的对象类型，并通过克隆这些原型来创建新的对象。这种模式特别适用于以下场景：

• 当对象创建成本较高时（如需要进行复杂的数据库查询或网络请求）
• 当系统需要独立于其产品的创建、构成和表示时
• 当需要动态加载类或在运行时指定要实例化的类时

Java中的原型实现机制

在Java中，原型模式通常通过实现Cloneable接口来实现。让我们深入分析Java设计模式项目中提供的实现：

public abstract class Prototype<T> implements Cloneable {
    @SuppressWarnings("unchecked")
    @SneakyThrows
    public T copy() {
        return (T) super.clone();
    }
}

这个基础原型类提供了核心的克隆功能，使用了Lombok的@SneakyThrows注解来简化异常处理。

具体原型类的实现

在游戏角色创建的示例中，我们可以看到具体的原型实现：

@EqualsAndHashCode(callSuper = false)
@RequiredArgsConstructor
public class OrcBeast extends Beast {
    private final String weapon;

    public OrcBeast(OrcBeast orcBeast) {
        super(orcBeast);
        this.weapon = orcBeast.weapon;
    }

    @Override
    public String toString() {
        return "Orcish wolf attacks with " + weapon;
    }
}

原型工厂模式的应用

为了更有效地管理原型对象，项目中实现了HeroFactory接口及其实现：

@RequiredArgsConstructor
public class HeroFactoryImpl implements HeroFactory {
    private final Mage mage;
    private final Warlord warlord;
    private final Beast beast;

    public Mage createMage() {
        return mage.copy();
    }

    public Warlord createWarlord() {
        return warlord.copy();
    }

    public Beast createBeast() {
        return beast.copy();
    }
}

这种工厂模式与原型模式的结合，使得对象创建变得更加灵活和高效。

原型模式的序列流程

让我们通过序列图来理解原型模式的工作流程：

深克隆与浅克隆的考量

在实现原型模式时，必须注意克隆的深度问题：

克隆类型	特点	适用场景
浅克隆	只复制基本类型字段，引用类型字段共享	对象结构简单，无嵌套引用
深克隆	复制所有字段，包括引用类型字段的新实例	对象结构复杂，有嵌套引用

Java默认的clone()方法实现的是浅克隆，如果需要深克隆，需要重写clone()方法。

实际应用示例

在游戏开发中，原型模式可以极大地提高性能：

// 创建精灵族工厂
HeroFactory elfFactory = new HeroFactoryImpl(
    new ElfMage("cooking"),
    new ElfWarlord("cleaning"), 
    new ElfBeast("protecting")
);

// 批量创建精灵角色
List<Mage> elfMages = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
    elfMages.add(elfFactory.createMage());
}

性能优势分析

与传统构造方法相比，原型模式在以下方面具有明显优势：

1. 减少初始化开销：避免重复执行耗时的初始化操作
2. 降低内存分配成本：复用现有对象的结构
3. 提高创建速度：克隆操作通常比完整构造更快

最佳实践建议

在实现原型模式时，建议遵循以下最佳实践：

• 为原型类提供清晰的拷贝构造函数
• 考虑实现深克隆以避免意外的对象共享
• 使用工厂模式来管理原型实例
• 确保原型对象的线程安全性

适用场景总结

原型模式特别适用于以下场景：

• 需要创建大量相似对象的系统
• 对象创建成本较高的应用
• 需要动态配置对象类型的框架
• 游戏开发中的角色和道具创建

通过合理运用原型模式，开发者可以显著提升系统的性能和灵活性，特别是在需要频繁创建相似对象的场景中。这种模式不仅减少了对象创建的开销，还提供了更大的设计灵活性。

总结

通过对五种创建型设计模式的深度解析，我们可以看到每种模式都有其独特的适用场景和优势。Singleton模式确保了对象的全局唯一性，Factory Method和Abstract Factory提供了灵活的对象创建解决方案，Builder模式优雅地处理了复杂对象的构建过程，而Prototype模式则通过克隆机制实现了高效的对象创建。在实际开发中，应根据具体需求选择合适的设计模式，权衡代码复杂度、性能和可维护性，从而构建出更加健壮和灵活的软件系统。

【免费下载链接】java-design-patterns Java 中实现的设计模式。 项目地址: https://gitcode.com/GitHub_Trending/ja/java-design-patterns