01.3.1.1 创建型模式与工程取舍
所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.1 设计模式与架构基础
01.3.1.1-001 设计模式分哪几类?学习模式解决什么问题?
一句话结论
GoF 模式分为创建型(对象怎么创建)、结构型(类/对象怎么组合)、行为型(职责怎么分配与交互);模式是针对反复出现的设计问题的经验沉淀,目的是提升可复用性、可维护性与可扩展性,不是必须套用的套路。
概念解释
- 创建型:封装对象创建过程,调用方不关心构造细节。
- 结构型:通过组合/代理/包装形成更大结构。
- 行为型:定义对象间职责划分与通信方式。
原理流程
- 识别代码中反复出现的变化点与耦合点。
- 对照模式的问题、结构与适用条件判断是否匹配。
- 小步落地,避免为用模式而用模式。
代码或图示
创建型:单例 / 工厂方法 / 抽象工厂 / 建造者 / 原型
结构型:代理 / 装饰 / 适配器 / 组合 / 桥接 / 外观 / 享元
行为型:策略 / 观察者 / 责任链 / 模板方法 / 命令 / 状态 ...
常见误区
- 把模式当成背题清单:脱离问题谈模式没有意义,先有场景再有模式。
- 项目里每个类都套一个模式:简单业务强行抽象会增加理解成本。
追问
- 模式和重构是什么关系?答:模式常是重构的目标结构,重构手法把坏味道代码逐步演进到更合理的模式。
- 23 种 GoF 模式都要背吗?答:先掌握高频的单例、工厂、策略、观察者、代理、责任链、模板方法,其余按项目需要补。
01.3.1.1-002 单例模式解决什么问题?有哪些常见实现?
一句话结论
单例保证一个类在进程内只有一个实例,并提供全局访问点;常见实现有饿汉式、懒汉式、静态内部类、枚举单例,按线程安全、懒加载、防破坏需求选择。
概念解释
- 角色:私有构造器、静态持有实例、静态获取方法。
- 目的:共享资源(配置、连接池、注册表)只初始化一次。
- 边界:单例是进程级概念,不等于分布式全局唯一。
原理流程
- 构造器私有,禁止外部 new。
- 内部持有唯一实例引用。
- 获取方法返回同一实例。
代码或图示
// 饿汉式:类加载即初始化,天然线程安全
public class Config {
private static final Config INSTANCE = new Config();
private Config() {}
public static Config getInstance() { return INSTANCE; }
}
// 静态内部类:懒加载 + 线程安全(类初始化锁保证)
public class LazyHolder {
private LazyHolder() {}
private static class Holder {
static final LazyHolder INSTANCE = new LazyHolder();
}
public static LazyHolder getInstance() { return Holder.INSTANCE; }
}
常见误区
- 以为单例适合所有全局对象:无状态工具方法更适合静态类;有状态共享资源才考虑单例。
- 饿汉式一定不好:实例创建便宜且确实需要时,饿汉最简单可靠。
追问
- 枚举单例为什么最安全?答:枚举序列化与反射机制天然防止重复实例化,还防反射调用构造器。
- 单例怎么扩展为多实例?答:改为注册表/对象池,按 key 管理多个实例。
01.3.1.1-003 双重检查锁为什么要加 volatile?
一句话结论
双重检查锁(DCL)先判空再加锁、锁内再判空,减少加锁次数;volatile 禁止对象初始化过程中的指令重排,避免其他线程拿到引用时对象尚未构造完成。
概念解释
- 第一次检查:避免每次调用都进入同步块。
- 第二次检查:防止多线程重复创建。
- volatile:保证写实例引用的操作不被重排到初始化完成之前。
原理流程
- 线程进入 getInstance,第一次判空。
- 为空则竞争类锁,锁内第二次判空。
- 创建实例,volatile 写保证初始化可见与顺序。
代码或图示
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 也能正常跑:低并发下可能不出问题,但指令重排可能发布未完全构造的对象,属于隐患。
- DCL 比静态内部类更好:两者都线程安全,内部类写法更简洁,DCL 主要用于必须懒加载且历史代码场景。
追问
new Singleton()分哪几步?答:分配内存、初始化对象、引用赋值;重排可能让引用先指向未初始化内存。- 高并发下 DCL 性能如何?答:无竞争时只走无锁检查;真正瓶颈通常不在单例获取,而在实例内部逻辑。
01.3.1.1-004 哪些方式会破坏单例?分布式下单例还有效吗?
一句话结论
反射调用私有构造器、序列化反序列化、类加载器隔离都可能产生第二个实例;单例只保证单个 JVM 进程内唯一,多实例部署或分布式场景下不构成全局唯一,需靠分布式锁/数据库唯一约束等保证。
概念解释
- 反射:绕过私有构造器新建对象。
- 序列化:反序列化默认生成新实例。
- 类加载器:不同加载器加载同一类得到不同 Class 与实例。
- 分布式:每个进程各有一份单例。
原理流程
- 识别单例被复制的途径。
- 枚举单例/构造器校验/readResolve 防反射与序列化破坏。
- 跨进程唯一性改由外部协调机制保证。
代码或图示
进程 A 单例 ┐
进程 B 单例 ├─ 互不共享,数据库/缓存才是全局状态
进程 C 单例 ┘
常见误区
- 把单例当分布式锁:单例无法跨进程互斥。
- 枚举单例绝对不会被破坏:枚举可防常规反射与序列化,但类加载器隔离仍可能存在多份。
追问
- Spring Bean 默认是单例吗?答:Spring 容器内默认 singleton,指同一容器共享一个 Bean,不等于 JVM 单例,也不等同线程安全。
- 全局唯一编号怎么保证?答:数据库自增/唯一索引、号段模式、分布式 ID 生成器,单例不参与全局协调。
01.3.1.1-005 简单工厂的结构与角色是什么?
一句话结论
简单工厂由一个工厂类按参数决定创建哪种产品实例,把创建逻辑集中起来;调用方面向产品接口编程,不直接 new 具体类。
概念解释
- 角色:工厂(创建者)、抽象产品、具体产品。
- 适用:产品种类稳定、创建逻辑集中管理。
- 局限:新增产品要修改工厂,违反开闭原则。
原理流程
- 调用方传入类型标识。
- 工厂内部分支创建对应产品。
- 返回抽象产品引用。
代码或图示
public interface Sender { void send(String msg); }
public class SmsSender implements Sender { public void send(String m) {} }
public class MailSender implements Sender { public void send(String m) {} }
public class SenderFactory {
public static Sender create(String type) {
return switch (type) {
case "sms" -> new SmsSender();
case "mail" -> new MailSender();
default -> throw new IllegalArgumentException(type);
};
}
}
常见误区
- 简单工厂就是工厂方法:简单工厂是一个类集中分支,工厂方法为每类产品提供独立工厂,结构不同。
- 工厂里写业务逻辑:工厂只负责创建,业务应在产品或调用层。
追问
- 简单工厂新增产品怎么改?答:改工厂分支;产品频繁扩展时考虑工厂方法或注册表。
- 静态工厂方法和简单工厂什么关系?答:静态工厂方法是类上的静态创建方法(如
List.of),简单工厂是独立工厂类,思想相近。
01.3.1.1-006 工厂方法和简单工厂有什么区别?什么时候用?
一句话结论
工厂方法把创建逻辑下沉到每个产品对应的工厂子类,新增产品只需加新工厂,不改既有工厂;简单工厂用一个类分支处理全部产品。产品扩展频繁、需要解耦时用工厂方法。
概念解释
- 角色:抽象工厂、具体工厂、抽象产品、具体产品。
- 扩展:符合开闭,加产品不动旧代码。
- 成本:每类产品一个工厂类,类数量增多。
原理流程
- 定义工厂接口声明创建方法。
- 每种产品实现自己的工厂。
- 调用方通过具体工厂获取产品。
代码或图示
public interface SenderFactory { Sender create(); }
public class SmsSenderFactory implements SenderFactory {
public Sender create() { return new SmsSender(); }
}
public class MailSenderFactory implements SenderFactory {
public Sender create() { return new MailSender(); }
}
常见误区
- 工厂方法必须配抽象产品:是的,工厂返回抽象类型,调用方不依赖具体产品。
- 工厂方法消灭了 if/else:分支从工厂内部移到了工厂选择环节,注册表/依赖注入可进一步集中选择。
追问
- 工厂方法适合框架扩展点吗?答:适合,框架定义工厂接口,插件提供具体工厂实现。
- 类爆炸怎么控制?答:产品少时用简单工厂;产品成族扩展再考虑抽象工厂。
01.3.1.1-007 抽象工厂解决什么问题?和工厂方法怎么取舍?
一句话结论
抽象工厂创建一组相关联的产品族(如跨数据库方言、跨操作系统 UI),保证族内产品配套使用;工厂方法只生产单一产品。存在多个产品维度且需成套替换时用抽象工厂。
概念解释
- 产品族:一组相互配套的对象。
- 一致性:同一族内产品版本/风格配套。
- 扩展产品族容易,新增单个产品类型困难。
原理流程
- 抽象工厂声明一族产品的创建方法。
- 每个具体工厂实现一族配套产品。
- 调用方按族选择工厂。
代码或图示
UIFactory
├─ WinFactory → WinButton, WinInput
└─ MacFactory → MacButton, MacInput
常见误区
- 抽象工厂就是多几个工厂方法:它强调产品族配套,换族时整体替换。
- 抽象工厂容易加新产品类型:加产品类型要改抽象工厂接口及所有实现,成本高。
追问
- 数据库方言场景怎么用?答:抽象工厂产出连接、方言、分页器等配套对象,换数据库换一族实现。
- 抽象工厂和依赖注入容器结合?答:容器按配置注入具体工厂实现,调用方只依赖抽象工厂。
01.3.1.1-008 建造者模式解决什么问题?
一句话结论
建造者把复杂对象的分步构造与表示分离,通过链式调用逐步设置字段,最后一次性构建;适合字段多、构造步骤有顺序、需要不可变对象的场景。
概念解释
- 角色:建造者(分步设置)、产品(最终对象)、可选导演(编排步骤)。
- 解决:长参数构造器、可选字段混乱、构造过程不可复用。
- 产物:通常不可变,构建完成后不暴露修改入口。
原理流程
- 建造者暴露字段设置方法并返回自身。
- 按步骤填充必填与可选字段。
build()校验并生成不可变产品。
代码或图示
public class Order {
private final String id;
private final int amount;
private Order(Builder b) { this.id = b.id; this.amount = b.amount; }
public static Builder builder() { return new Builder(); }
public static class Builder {
private String id; private int amount;
public Builder id(String id) { this.id = id; return this; }
public Builder amount(int a) { this.amount = a; return this; }
public Order build() {
if (id == null) throw new IllegalStateException("id 必填");
return new Order(this);
}
}
}
常见误区
- 字段少也上建造者:两个字段的对象用构造器或 record 更直接。
- 建造者暴露产品内部可变状态:build 出的对象应不可变,builder 与产品字段不共享引用。
追问
- 建造者和工厂方法区别?答:工厂关注“造哪个”,建造者关注“怎么分步造”。
- 链式调用是建造者专属吗?答:链式是实现风格,fluent API 也可用于其他场景。
01.3.1.1-009 原型模式怎么实现深拷贝?适用什么场景?
一句话结论
原型通过克隆已有实例创建新对象,避免重复初始化成本;需区分浅拷贝(共享引用字段)与深拷贝(复制引用指向的对象),适合对象构造成本高、状态大体相似的场景。
概念解释
- 浅拷贝:复制对象本身,引用字段仍指向同一对象。
- 深拷贝:递归复制引用字段。
- 实现:构造器拷贝、拷贝构造方法、序列化克隆。
原理流程
- 原型实现克隆接口/拷贝方法。
- 新对象按原型复制字段。
- 可变引用字段按需要深拷贝。
代码或图示
public class Address { String city; }
public class User implements Cloneable {
private Address address;
@Override
public User clone() throws CloneNotSupportedException {
User u = (User) super.clone(); // 浅拷贝
u.address = new Address(); // 深拷贝引用字段
u.address.city = this.address.city;
return u;
}
}
常见误区
- 实现 Cloneable 就自动深拷贝:Cloneable 只是标记,super.clone 是浅拷贝。
- 数组/集合字段直接赋值:浅拷贝后改集合内容会影响原型。
追问
- 深拷贝有哪些实现方式?答:拷贝构造方法、递归复制、序列化/反序列化;序列化方式注意版本与性能。
- 原型模式在哪些场景常见?答:配置模板复制、游戏角色/资源克隆、原型对象批量派生。
01.3.1.1-010 创建型模式共同解决什么耦合问题?
一句话结论
创建型模式把“对象怎么被创建”和“对象怎么被使用”分开,调用方依赖抽象类型,具体实现替换时不需要改动使用方代码,降低创建逻辑变更带来的连锁影响。
概念解释
- 变化点:具体类选择、构造步骤、实例数量。
- 解耦:使用方面向接口/抽象编程。
- 收益:替换实现、测试替身、扩展产品族更方便。
原理流程
- 识别哪些部分会变化(实现类、构造顺序、实例数)。
- 用对应创建型模式封装变化。
- 使用方只依赖抽象与创建入口。
代码或图示
使用方 ──依赖──> 抽象产品
↑ 创建
工厂/建造者/原型(封装具体实现)
常见误区
- 创建型模式让代码更简单:它增加了间接层,简单场景反而更绕。
- 解耦等于没有依赖:依赖从具体实现转移到抽象接口,仍是依赖关系。
追问
- 面向接口编程和工厂怎么配合?答:工厂产出抽象接口实例,使用方只声明接口类型。
- 怎么判断创建逻辑该抽出来?答:多处重复 new、构造条件分支集中变更、需要替换实现或测试替身时。
01.3.1.1-011 工厂和策略模式怎么组合使用?
一句话结论
工厂负责按类型创建策略实例,策略负责执行具体算法;用注册表 Map 替代 if/else 选择策略,是业务代码中最常见的组合模式。
概念解释
- 策略:可变算法抽象为接口。
- 工厂/注册表:根据类型找到对应策略实现。
- 组合:新增算法加一个实现并注册,不改选择主干。
原理流程
- 定义策略接口与业务方法。
- 各实现注册到 Map(类型 → 策略)。
- 调用方按类型取策略执行。
代码或图示
public interface Discount { BigDecimal apply(BigDecimal amount); }
@Component
public class StrategyRegistry {
private final Map<String, Discount> map;
public StrategyRegistry(List<Discount> all) {
this.map = all.stream().collect(Collectors.toMap(Discount::type, Function.identity()));
}
public Discount get(String type) { return map.get(type); }
}
常见误区
- 策略接口里塞多组不相关方法:违反接口隔离,策略应只承担一类算法。
- 工厂每次 new 新策略:无状态策略应单例复用,有状态对象才按请求创建。
追问
- 策略无状态还是有状态?答:尽量无状态、可单例;需要请求内状态时用工厂每次创建并在内部隔离。
- 策略找不到默认怎么处理?答:定义默认策略或抛业务异常,按场景决定。
01.3.1.1-012 依赖注入容器和工厂模式是什么关系?
一句话结论
DI 容器本质是通用化的工厂/注册表:按类型与配置创建并组装对象,管理生命周期;手写工厂是容器能力的局部特例,容器把创建、注入、作用域集中管理。
概念解释
- 工厂:硬编码选择具体实现。
- 容器:配置/扫描注册,自动装配依赖。
- 生命周期:单例/请求级/原型作用域由容器维护。
原理流程
- 组件声明依赖抽象类型。
- 容器解析注册的实现并创建实例。
- 按作用域注入并管理销毁。
代码或图示
手写工厂:if/注册表 → new 具体实现
DI 容器:扫描/配置注册 → 解析依赖 → 注入 → 生命周期管理
常见误区
- 用了容器就不用理解工厂:容器内部仍是创建与装配逻辑,理解工厂便于排查装配失败。
- 容器 Bean 天然线程安全:单例 Bean 必须自己保证无共享可变状态。
追问
- 怎么排查 Bean 装配失败?答:看缺失的抽象类型、注册实现、作用域与循环依赖;容器报错信息定位缺失组件。
- 容器单例和 GoF 单例区别?答:容器单例由容器按作用域管理,可替换;GoF 单例是类内部硬编码唯一实例。
01.3.1.1-013 对象池是创建型模式吗?它解决什么问题?
一句话结论
对象池不属于 GoF 创建型模式,属于资源复用机制:预先创建并复用对象,避免频繁创建销毁的开销(数据库连接、线程、HTTP 连接、大对象),同时控制并发占用上限。
概念解释
- 复用:借出/归还对象,而非每次 new。
- 上限:池容量约束并发资源。
- 适用:创建/销毁成本高、对象可安全复用。
原理流程
- 初始化池内对象。
- 借出对象使用,用完归还重置状态。
- 池满时等待/阻塞/按策略拒绝。
代码或图示
借出 ──> 使用 ──> 重置状态 ──> 归还
池满:排队等待 / 新建到上限 / 拒绝(按策略)
常见误区
- 池化对象可直接复用残留状态:归还前必须清理上一请求写入的字段,否则串数据。
- 池越大越好:池过大占用内存与连接资源,容量按压测水位设定。
追问
- 线程池和连接池区别?答:都是对象池,前者复用执行线程,后者复用网络连接;生命周期与回收策略不同。
- 对象池和单例区别?答:单例是唯一一个对象;池是一组可借用归还的对象,数量可大于一。
01.3.1.1-014 单例和静态工具类怎么取舍?
一句话结论
无状态、纯函数集合用静态工具类;需要持有状态、实现接口、被代理注入或生命周期管理时用单例;静态类无法实现接口、不易替换测试,单例更贴合面向对象装配。
概念解释
- 静态工具:无实例、无状态、方法静态。
- 单例:有实例、可持有状态、可实现接口、可被容器管理。
- 测试:单例可注入替身,静态方法难以替换。
原理流程
- 判断是否需要状态与多态。
- 纯函数工具走静态类。
- 需接口/注入/状态管理走单例或容器 Bean。
代码或图示
静态工具:StringUtils.isBlank(...) 无状态、不可注入
单例/Bean:ConfigHolder 持配置、可注入、可代理
常见误区
- 工具类里塞可变静态字段:全局可变状态,并发下极易出问题。
- 所有单例都写成饿汉静态变量:需要懒加载或容器管理时换实现方式。
追问
- 静态方法为什么不利于测试?答:无法 mock 替换,依赖真实实现,边界与副作用难隔离。
- 单例持状态要注意什么?答:状态并发访问需同步或无状态化;可变共享字段是线程安全风险点。
01.3.1.1-015 建造者和工厂方法怎么选择?
一句话结论
工厂方法决定“造哪一类对象”,通常一步返回;建造者决定“怎么分步组装一个复杂对象”,字段多、有必填校验和构造顺序时用建造者。两者可组合:建造者产出对象,工厂选择用哪种建造者。
概念解释
- 选择维度:创建复杂度 vs 类型分支。
- 工厂:产品类型选择。
- 建造者:单对象内部分步构造。
原理流程
- 先判断变化点是“换实现”还是“填字段”。
- 换实现走工厂;复杂分步构造走建造者。
- 复杂产品可由工厂调用建造者完成。
代码或图示
工厂:SenderFactory.create(type) → 选实现
建造者:Order.builder().id().amount().build() → 填字段
组合:工厂内选择 Builder 分步构建
常见误区
- 用工厂传一长串参数:长参数构造应改建造者。
- 用建造者在多种实现间切换:类型选择应交给工厂/注册表。
追问
- 一个对象既有多实现又字段多怎么办?答:抽象工厂/注册表选实现,各实现内部用建造者构造。
- 建造者必须配导演类吗?答:导演只在构造步骤固定复用时需要,简单场景链式调用即可。
01.3.1.1-016 什么是重叠构造器(telescoping constructor)问题?
一句话结论
重叠构造器用多个重载构造器层层叠加可选参数,参数一多就难以阅读、容易传错位置;建造者通过具名链式字段解决参数顺序与可选字段混乱问题。
概念解释
- 问题:重载构造器链式调用,参数位置依赖记忆。
- 风险:同类型参数传错位、可选组合爆炸。
- 解决:builder 方法具名设置,build 前校验。
原理流程
- 识别构造参数数量与可选比例。
- 字段多/可选多时引入建造者。
- 调用方按字段名设置,避免位置传参。
代码或图示
// 差:参数位置难记
public Order(String id) { this(id, 0); }
public Order(String id, int amount) { ... }
// 好:具名链式
Order o = Order.builder().id("A1").amount(100).build();
常见误区
- record/不可变类用全参构造即可:字段少时全参构造清晰;字段多再上建造者。
- 建造者参数和构造器参数命名不一致:字段语义应保持一致,避免二义性。
追问
- 现代语言怎么替代建造者?答:Java record 全参构造、命名参数(部分语言)、Builder 注解生成;按语言生态选择。
- 建造者怎么处理必填校验?答:build() 内检查必填项,缺失抛异常,不返回半成品对象。
01.3.1.1-017 克隆方法有哪些深拷贝陷阱?
一句话结论
数组、集合、嵌套对象、可变包装类型在浅拷贝后仍共享引用,修改副本会影响原型;深拷贝需递归复制引用字段,注意循环引用与不可变对象可共享。
概念解释
- 共享引用:浅拷贝只复制引用值。
- 递归复制:深拷贝逐层复制可变对象。
- 循环引用:深拷贝需用已拷贝映射避免死循环。
原理流程
- 识别对象内所有可变引用字段。
- 对可变字段复制新实例。
- 不可变对象(如 String)可直接共享。
代码或图示
// 集合字段需复制新集合
private List<Item> copyItems(List<Item> src) {
List<Item> dst = new ArrayList<>(src.size());
for (Item i : src) dst.add(i.clone());
return dst;
}
常见误区
- 拷贝构造方法只复制一层:嵌套对象仍需深入复制。
- 深拷贝忽略性能:大对象深拷贝成本高,可共享的不可变对象不必复制。
追问
- 循环引用怎么深拷贝?答:维护“已拷贝对象 → 副本”映射,遇到已拷贝直接复用。
- 序列化克隆有什么风险?答:依赖序列化版本、性能差、可能带出 transient 之外的无关状态。
01.3.1.1-018 判断创建型模式是否过度设计的标准是什么?
一句话结论
看是否存在真实变化点与重复创建逻辑:有明确的实现替换、构造复杂、多实例管理需求才引入;当前只有一种实现、字段简单、创建只发生一次时,直接构造更合适,模式应随重构演进而非预判。
概念解释
- 真实需求:替换实现、测试替身、复杂构造、实例复用。
- 代价:间接层、类数量、理解成本。
- 演进:先简单实现,变化出现后再抽取模式。
原理流程
- 列出当前与可预见的变化点。
- 评估不引入模式的维护成本。
- 匹配才落地,预留扩展点而非提前抽象。
代码或图示
值得抽:多处 new、分支集中变更、需要替身/替换
不值得:单实现、字段少、创建一次、逻辑直白
常见误区
- 设计阶段把所有未来可能都抽象出来:预测的变化常不发生,过度抽象固化错误预期。
- 否定一切模式:重复出现的创建耦合不治理,会导致复制粘贴与改动连锁反应。
追问
- 什么时候重构引入工厂?答:出现第二套实现、分支 if/else 扩散、需要替换测试替身时。
- 怎么平衡开闭原则与简单?答:对确定会扩展的方向留抽象,对不确定的方向保持直接代码,评审时对照真实需求。