创建型模式

创建型模式是设计模式的核心分支，专注于对象创建机制的优化，通过封装对象实例化过程，提升系统的灵活性与可扩展性。在分布式系统中，由于多节点协作、网络通信延迟、状态一致性等特性，传统单体环境下的创建型模式需进行适应性演化。本文从分布式场景出发，系统解析单例、工厂方法、抽象工厂、建造者、原型五大创建型模式的核心原理、分布式变种及实战应用。

一、单例模式：分布式环境下的唯一性保障

1.1 单体与分布式单例的本质区别

1.2 分布式单例的实现方案

1. 基于 ZooKeeper 的分布式单例

public class DistributedSingleton { 

   private static final String LOCK_PATH = "/distributed/singleton"; 

   private static DistributedSingleton instance; 

   private static CuratorFramework zkClient; 

   private DistributedSingleton() {} 

   public static DistributedSingleton getInstance() throws Exception { 

       if (instance == null) { 

           // 1. 创建ZooKeeper分布式锁 
           InterProcessMutex lock = new InterProcessMutex(zkClient, LOCK_PATH); 

           try { 

               // 2. 尝试获取锁（超时时间10秒） 
               if (lock.acquire(10, TimeUnit.SECONDS)) { 
                   // 3. 双重检查（防止并发创建） 
                   if (instance == null) { 
                       instance = new DistributedSingleton(); 
                       // 4. 在ZK创建临时节点，节点存在表示单例已初始化 
                       zkClient.createEphemeral(LOCK_PATH); 
                   } 
               } 
           } finally { 
               // 5. 释放锁 
               if (lock.isAcquiredInThisProcess()) { 
                   lock.release(); 
               } 
           } 
       } 
       return instance; 
   } 
} 

2. 方案对比与适用场景

二、工厂方法模式：分布式服务的动态实例化

2.1 模式核心与分布式适配

1. 基础结构

工厂方法模式通过定义抽象工厂接口，由子类决定具体产品的创建逻辑。在分布式系统中，该模式常用于服务实例的动态创建，适配不同环境（如生产 / 测试）或不同实现（如 MySQL/PostgreSQL 数据源）。

2. 分布式服务发现中的工厂方法

// 抽象工厂：服务客户端工厂 
public interface ServiceClientFactory { 
   ServiceClient createClient(String serviceName); 
} 

// 具体工厂：REST API客户端工厂 
public class RestClientFactory implements ServiceClientFactory { 

   @Override 
   public ServiceClient createClient(String serviceName) { 

       // 从服务注册中心获取服务地址 
       String serviceUrl = serviceDiscovery.getServiceUrl(serviceName); 
       return new RestClient(serviceUrl); 
   } 
} 

// 具体工厂：RPC客户端工厂 
public class RpcClientFactory implements ServiceClientFactory { 

   @Override 
   public ServiceClient createClient(String serviceName) { 
       // 基于Dubbo创建RPC客户端 
       return new DubboClient(serviceName); 
   } 
} 

// 客户端使用 
public class ServiceConsumer { 
   private ServiceClientFactory factory; 
   public void invokeService(String serviceName) { 
       // 根据配置动态选择工厂（如配置文件指定"rpc"或"rest"） 
       ServiceClient client = factory.createClient(serviceName); 
       client.invoke(); 
   } 
} 

2.2 关键优势与扩展

• 动态适配：通过工厂方法透明切换服务实现（如从 MySQL 切换到 TiDB，无需修改业务代码）。
• 服务治理集成：工厂内部可集成负载均衡（如从 Nacos 获取服务列表后按权重选择实例）。
• 容错扩展：在工厂中实现客户端熔断降级（如创建ResilientClient包装原始客户端）。

三、抽象工厂模式：跨组件的一致性创建

3.1 模式架构与分布式应用

抽象工厂模式通过定义一系列相关或相互依赖的对象的创建接口，确保组件间的兼容性。在分布式系统中，该模式常用于多组件协同创建（如数据库 + 缓存 + 消息队列的组合配置）。

实战案例：多环境存储组件工厂

// 抽象产品：缓存组件 
public interface Cache { 
   void set(String key, String value); 
   String get(String key); 
} 

// 抽象产品：数据库组件 
public interface Database { 

   void execute(String sql); 
} 

// 抽象工厂：存储组件工厂 
public interface StorageFactory { 
   Cache createCache(); 
   Database createDatabase(); 
} 

// 具体工厂：生产环境（Redis + MySQL） 
public class ProductionStorageFactory implements StorageFactory { 

   @Override 
   public Cache createCache() { 
       return new RedisCache("prod-redis:6379"); 
   } 
   
   @Override 
   public Database createDatabase() { 
       return new MySQLDatabase("prod-mysql:3306"); 
   } 
} 

// 具体工厂：测试环境（本地缓存 + H2） 
public class TestStorageFactory implements StorageFactory { 

   @Override 
   public Cache createCache() { 
       return new LocalCache(); 
   } 

   @Override 
   public Database createDatabase() { 
       return new H2Database("test-h2:mem"); 
   } 
} 

3.2 分布式场景价值

• 环境一致性：确保同一环境下的组件版本兼容（如生产环境的 Redis 与 MySQL 版本匹配）。
• 部署灵活性：通过切换工厂实现一键部署到不同环境（无需修改组件初始化逻辑）。

四、建造者模式：复杂分布式对象的构建

4.1 模式核心与分布式适配

建造者模式将复杂对象的构建与表示分离，通过分步构建与导演类协调，生成不同配置的对象。在分布式系统中，该模式常用于构建复杂配置对象（如分布式任务、集群节点配置）。

实战案例：分布式任务构建器

// 复杂对象：分布式任务 
public class DistributedTask { 

   private String taskId; 

   private List<String> targetNodes; // 目标节点列表 

   private int retryCount; // 重试次数 

   private boolean isParallel; // 是否并行执行 

   private Map<String, String> params; // 任务参数 

   // 私有构造器，仅允许建造者创建 
   private DistributedTask(Builder builder) { 
       this.taskId = builder.taskId; 
       this.targetNodes = builder.targetNodes; 
       this.retryCount = builder.retryCount; 
       this.isParallel = builder.isParallel; 
       this.params = builder.params; 
   } 

   // 建造者 
   public static class Builder { 
       private String taskId; 
       private List<String> targetNodes = new ArrayList<>(); 
       private int retryCount = 3; // 默认重试3次 
       private boolean isParallel = false; 
       private Map<String, String> params = new HashMap<>(); 
       public Builder taskId(String taskId) { 
           this.taskId = taskId; 
           return this; 
       } 

       public Builder addTargetNode(String node) { 
           this.targetNodes.add(node); 
           return this; 
       } 

       public Builder retryCount(int retryCount) { 
           this.retryCount = retryCount; 
           return this; 
       } 

       public Builder parallel(boolean isParallel) { 
           this.isParallel = isParallel; 
           return this; 
       } 

       public Builder param(String key, String value) { 
           this.params.put(key, value); 
           return this; 
       } 

       // 构建方法：校验参数并生成任务对象 
       public DistributedTask build() { 
           if (taskId == null || targetNodes.isEmpty()) { 
               throw new IllegalArgumentException("任务ID和目标节点不能为空"); 
           } 
           return new DistributedTask(this); 
       } 
   } 
} 

// 使用示例 
public class TaskScheduler { 
   public void submitTask() { 
       // 构建分布式任务：ID为"backup-1"，在node1/node2并行执行，重试5次 
       DistributedTask task = new DistributedTask.Builder() 
           .taskId("backup-1") 
           .addTargetNode("node1") 
           .addTargetNode("node2") 
           .parallel(true) 
           .retryCount(5) 
           .param("path", "/data/backup") 
           .build(); 
       taskExecutor.execute(task); 
   } 
} 

4.2 分布式场景优势

• 参数校验：在build()方法中集中校验分布式对象的合法性（如目标节点是否在集群中存在）。
• 配置可读性：链式调用清晰表达对象的构建逻辑（如parallel(true)明确表示并行执行）。
• 版本兼容：新增参数时只需扩展建造者方法，不影响旧版本代码（如添加timeout(int)方法）。

五、原型模式：分布式系统中的对象复制

5.1 模式核心与分布式挑战

原型模式通过复制现有对象生成新实例，避免重复初始化开销。在分布式系统中，该模式常用于对象的跨节点复制（如缓存同步、会话复制），但需解决序列化、深拷贝及一致性问题。

1. 分布式原型的实现（基于序列化）

// 可复制对象：用户会话 
public class UserSession implements Cloneable, Serializable { 
   private String sessionId; 
   private String userId; 
   private Map<String, Object> attributes; // 会话属性 

   // 深拷贝实现（支持跨节点传输） 
   @Override 
   public UserSession clone() { 

       try { 
           // 序列化实现深拷贝（适用于跨JVM复制） 
           ByteArrayOutputStream bos = new ByteArrayOutputStream(); 
           ObjectOutputStream oos = new ObjectOutputStream(bos); 
           oos.writeObject(this); 
           ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); 
           ObjectInputStream ois = new ObjectInputStream(bis); 
           return (UserSession) ois.readObject(); 
       } catch (Exception e) { 
           throw new RuntimeException("Session复制失败", e); 
       } 
   } 

   // 集群复制方法：将会话复制到其他节点 
   public void replicateTo(List<String> targetNodes) { 

       for (String node : targetNodes) { 
           UserSession copy = this.clone(); 
           // 通过RPC将复制对象发送到目标节点 
           clusterClient.send(node, "session/replicate", copy); 
       } 
   } 
} 

2. 分布式场景的优化策略

• 增量复制：仅复制修改的属性（如通过dirty标记），减少网络传输量。
• 版本控制：为复制对象添加版本号，避免旧版本覆盖新版本（如version=3的对象无法覆盖version=5的对象）。

六、面试高频问题深度解析

6.1 基础概念类问题

Q：分布式环境下的单例模式与单体环境有何不同？如何实现分布式单例？

A：

• 核心差异：单体单例仅需保证进程内唯一（依赖类加载机制），分布式单例需保证集群内唯一（跨 JVM 进程），需解决节点一致性与网络分区问题。

• 实现方案：

1. ZooKeeper 临时节点：通过抢占 ZK 临时节点保证唯一实例，节点失效时自动释放（适合强一致性场景）。
2. Redis 分布式锁：利用SET NX命令实现锁机制，配合过期时间避免死锁（适合高并发场景）。

Q：建造者模式与工厂模式的核心区别？在分布式配置构建中如何选择？

A：

• 分布式配置选择：优先使用建造者模式，因其支持细粒度配置（如分布式任务的节点列表、重试次数、并行策略等多维度参数），且构建过程清晰可追溯。

6.2 实战设计类问题

Q：如何用工厂模式设计一个支持多注册中心（Nacos/Eureka/Consul）的服务发现组件？

A：

1. 抽象工厂接口：定义RegistryFactory，包含createServiceDiscovery()和createServiceRegistry()方法。

2. 具体工厂：

• NacosRegistryFactory：创建 Nacos 的服务发现与注册实例。
• EurekaRegistryFactory：创建 Eureka 的对应实例。

1. 客户端适配：通过配置文件（如registry.type=nacos）动态选择工厂，业务代码无需感知具体实现。

// 抽象工厂 

public interface RegistryFactory { 

   ServiceDiscovery createDiscovery(); 
   ServiceRegistry createRegistry(); 

} 

// 客户端使用 
public class ServiceClient { 
   private ServiceDiscovery discovery; 
   public ServiceClient() { 

       // 从配置获取注册中心类型 
       String type = Config.get("registry.type"); 
       RegistryFactory factory = RegistryFactoryLoader.load(type); 
       this.discovery = factory.createDiscovery(); 
   } 
} 

Q：在分布式缓存同步中，原型模式如何保证缓存对象的一致性？

A：

1. 版本控制：缓存对象添加version字段，复制时携带版本信息，避免旧版本覆盖新版本。

2. 增量复制：仅复制修改的字段（如通过diff算法计算差异），减少网络传输。

3. 同步机制：采用 “修改者推送” 模式，对象修改后主动复制到其他节点，而非被动拉取，降低一致性延迟。

总结：创建型模式在分布式系统中的选型策略

模式选型决策框架

分布式环境下的设计原则

1. 一致性优先：创建型模式需优先保证分布式场景下的实例一致性（如单例的集群唯一性、原型复制的版本一致性）。

2. 容错性设计：工厂方法需支持服务实例的故障转移（如创建服务客户端时自动重试），建造者需校验分布式参数合法性（如目标节点是否在线）。

3. 性能平衡：避免过度设计导致性能损耗（如分布式单例的锁竞争需控制粒度，原型复制优先增量同步）。

通过掌握创建型模式在分布式环境下的演化与实践，不仅能应对面试中的设计类问题，更能在实际架构中优化对象创建逻辑，提升系统的灵活性与可靠性 —— 这正是高级程序员与普通开发者在设计思维上的核心差异。