01.3.1.2 结构型模式
所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.1 设计模式与架构基础
01.3.1.2-001 结构型模式总体解决什么问题?
一句话结论
结构型模式解决类与对象如何组合成更大结构的问题,在不修改既有组件的前提下,通过包装、代理、组合、转换等方式适配接口、增强能力或组织层级关系,让各部分可独立复用。
概念解释
- 关注点:对象之间的装配关系,而非创建算法或业务流程。
- 手段:继承/组合、接口转换、统一抽象层级。
- 收益:接口兼容、能力增强、层级透明、资源复用。
原理流程
- 识别现有组件接口与使用方期望之间的差距。
- 选择包装/代理/适配/组合等结构补齐差距。
- 上层只依赖统一抽象,不感知内部装配。
代码或图示
使用方 ──> 统一抽象
├─ 代理包装(控制访问)
├─ 装饰包装(增强能力)
├─ 适配转换(接口对齐)
└─ 组合树(容器/叶子统一)
常见误区
- 结构型模式只靠继承实现:优先组合,继承层级越深越难维护。
- 包装层级越多越好:每层包装都有理解与性能成本,层级应可解释。
追问
- 结构型和创建型怎么配合?答:创建型负责产出对象,结构型负责把产出的对象组装成可用结构。
- 常见结构型模式有哪些?答:代理、装饰、适配器、组合、桥接、外观、享元。
01.3.1.2-002 代理模式解决什么问题?有哪几种实现?
一句话结论
代理为目标对象提供一个替身,在不改变目标接口的前提下控制访问(远程、懒加载、权限、事务、日志、缓存);实现分静态代理(手写代理类)与动态代理(运行期生成代理类)。
概念解释
- 角色:抽象主题、真实主题、代理主题,三者实现同一接口。
- 前置/后置逻辑:代理在调用前后插入横切逻辑。
- 控制访问:代理决定是否、何时调用真实对象。
原理流程
- 定义共同接口。
- 真实对象实现业务,代理持有真实对象引用。
- 代理方法内做检查/增强后委托调用。
代码或图示
public interface UserService { User get(Long id); }
public class UserServiceImpl implements UserService {
public User get(Long id) { return new User(id); }
}
public class UserServiceProxy implements UserService {
private final UserServiceImpl target;
public UserServiceProxy(UserServiceImpl t) { this.target = t; }
public User get(Long id) {
before(); // 权限/日志/事务
User u = target.get(id);
after();
return u;
}
}
常见误区
- 代理改变了目标接口:代理必须保持同一接口,换接口属于适配器。
- 代理里写业务规则:代理承载横切控制逻辑,业务仍在真实主题。
追问
- 静态代理缺点?答:每个接口方法都要手写转发,接口多时代理类膨胀。
- 代理模式典型应用?答:远程调用存根、事务/权限切面、懒加载占位、缓存代理。
01.3.1.2-003 JDK 动态代理和 CGLIB 有什么区别?
一句话结论
JDK 动态代理基于接口生成代理类,目标必须实现接口;CGLIB 通过继承目标类生成子类代理,不需要接口,但不能代理 final 类/方法。Spring AOP 默认按目标是否实现接口选择。
概念解释
- JDK Proxy:反射 + 接口实现,运行期生成 $Proxy 类。
- CGLIB:字节码生成子类,重写非 final 方法。
- 限制:CGLIB 不能代理 final 方法;目标类有无参构造要求(具体约束以所用版本为准,待确认)。
原理流程
- 判断目标是否实现接口。
- 有接口可用 JDK 代理;无接口用 CGLIB 子类代理。
- 调用处理器/拦截器织入增强逻辑。
代码或图示
// JDK 动态代理
Object proxy = Proxy.newProxyInstance(
loader, target.getClass().getInterfaces(),
(p, m, args) -> { before(); Object r = m.invoke(target, args); after(); return r; });
常见误区
- CGLIB 代理一定比 JDK 快:两者生成方式不同,性能差异受场景与版本影响,不能脱离实测下结论。
- 代理对象 equals/hashCode 行为和原对象完全一致:代理默认委托方法调用,个别方法行为需按拦截器实现确认。
追问
- 为什么 final 方法不能被 CGLIB 代理?答:子类无法重写 final 方法,拦截器织不进去。
- Spring 什么时候强制用 CGLIB?答:目标无接口或配置
proxy-target-class=true时,具体配置以所用 Spring 版本为准。
01.3.1.2-004 代理模式和装饰器模式怎么区分?
一句话结论
两者结构都是持有被包装对象并实现同一接口,区别在意图:代理强调“控制访问”,由代理决定能否/何时调用;装饰器强调“增强能力”,通常多层包装叠加功能,且调用方主动组装。
概念解释
- 代理:控制权在代理,目标创建/可见性/访问受控。
- 装饰:在目标外围叠加职责,增强后仍可继续包装。
- 结构相似是历史上常被混淆的原因,区分看设计意图与包装方向。
原理流程
- 看谁创建并持有目标:代理常自己管理目标生命周期。
- 看包装目的:控制访问归代理,加功能归装饰。
- 多层叠加增强是装饰器典型形态。
代码或图示
代理:Proxy → Target(代理控制是否放行)
装饰:LoggingDecorator → CacheDecorator → Target(逐层加功能)
常见误区
- 代码结构一样就归为一种模式:模式分类看意图,结构相似不代表角色相同。
- 装饰器不能控制访问:装饰器也可做前置检查,但其核心定位是增强而非替身控制。
追问
- Spring AOP 更接近哪种?答:属于动态代理,主要承载横切增强(事务、日志),兼具装饰器式叠加与代理式拦截特征。
- 装饰器和责任链区别?答:装饰器一定把请求传给内层并叠加结果;责任链可中断、不继续传递。
01.3.1.2-005 装饰器模式怎么实现多层增强?
一句话结论
装饰器与被装饰对象实现同一接口,装饰器持有一个同接口对象;构造时传入内层对象,方法内先/后叠加增强再委托,多个装饰器按需要层层嵌套。
概念解释
- 抽象组件:定义统一接口。
- 具体组件:原始对象。
- 装饰器:持有组件引用,叠加职责。
原理流程
- 定义组件接口。
- 写基础实现与抽象装饰器(持有组件)。
- 各增强装饰器继承装饰器,嵌套组装。
代码或图示
public interface Notifier { void send(String msg); }
public class SmsNotifier implements Notifier {
public void send(String msg) { /* 短信 */ }
}
public abstract class NotifierDecorator implements Notifier {
protected final Notifier inner;
protected NotifierDecorator(Notifier inner) { this.inner = inner; }
}
public class LogDecorator extends NotifierDecorator {
public LogDecorator(Notifier inner) { super(inner); }
public void send(String msg) { log(msg); inner.send(msg); }
}
常见误区
- 装饰器继承基础实现类而非实现接口:应面向统一接口,否则无法透明嵌套。
- 装饰器之间顺序随意:有依赖关系的增强(如先缓存后日志)顺序会影响结果。
追问
- 装饰器相比继承加功能好在哪?答:运行期组合、避免子类爆炸,职责可按需叠加。
- Java IO 流怎么体现装饰器?答:
BufferedInputStream包装FileInputStream,DataInputStream再包装缓冲流,层层增强读写能力。
01.3.1.2-006 适配器模式解决什么问题?
一句话结论
适配器把已有类的接口转换为使用方期望的接口,在不改遗留代码的前提下接入新系统;分类适配器(继承)与对象适配器(组合),优先用组合。
概念解释
- 目标接口:使用方期望的接口。
- 适配者:已有但接口不匹配的类。
- 适配器:实现目标接口,内部调用适配者。
原理流程
- 明确使用方期望接口。
- 识别遗留/第三方类的现有接口。
- 写适配器做方法映射与参数转换。
代码或图示
// 期望接口
public interface Payment { void pay(BigDecimal amount); }
// 已有第三方 SDK,方法签名不同
public class ThirdPartyGateway { public void charge(String yuan) { } }
// 对象适配器
public class GatewayAdapter implements Payment {
private final ThirdPartyGateway gw = new ThirdPartyGateway();
public void pay(BigDecimal amount) { gw.charge(amount.toPlainString()); }
}
常见误区
- 适配器里补业务逻辑:适配器只做接口转换与参数映射,业务规则应留在领域层。
- 长期依赖适配器掩盖设计差距:遗留过渡可以,新系统应逐步对齐统一接口。
追问
- 类适配器和对象适配器区别?答:类适配器靠继承适配者,对象适配器靠组合;组合更灵活、避免继承膨胀。
- 适配器和外观区别?答:适配器转换单个接口对齐;外观提供简化的高层入口封装整个子系统。
01.3.1.2-007 适配器、代理、装饰器三者怎么一句话区分?
一句话结论
适配器改接口以对齐期望;代理不改接口只控制访问;装饰器不改接口只叠加能力;三者都持有被包装对象,区别在“改什么、为什么包装”。
概念解释
- 适配器:接口不同 → 转换。
- 代理:接口相同 → 控制。
- 装饰:接口相同 → 增强。
原理流程
- 先看接口是否一致。
- 不一致归适配器。
- 一致再看意图:控制访问归代理,叠加功能归装饰。
代码或图示
接口不一致 ──> 适配器(转换签名/参数)
接口一致 ──> 代理(放行/懒加载/权限)
接口一致 ──> 装饰(日志/缓存/压缩叠加)
常见误区
- 凭代码结构归类:必须结合调用方期望与包装意图判断。
- 把参数转换写进代理/装饰器:签名转换属于适配器职责。
追问
- 接入旧短信 SDK 用哪种?答:接口签名不一致用适配器;在其外围加日志/重试可再叠装饰器。
- 统一多套第三方支付接口怎么设计?答:先定义领域支付接口,各 SDK 写适配器实现,上层只依赖领域接口。
01.3.1.2-008 组合模式解决什么问题?
一句话结论
组合模式把容器与叶子节点抽象为同一接口,让树形结构中的单个对象和组合对象被一致对待,调用方无需区分文件与文件夹、菜单项与菜单组。
概念解释
- 抽象构件:声明叶子与容器共同接口。
- 叶子:无子节点。
- 容器:持有子构件列表,递归聚合行为。
原理流程
- 定义统一构件接口。
- 叶子实现自身行为。
- 容器实现子节点管理与递归遍历。
代码或图示
public interface Node { void show(String indent); }
public class FileNode implements Node {
private final String name;
public FileNode(String name) { this.name = name; }
public void show(String indent) { System.out.println(indent + name); }
}
public class FolderNode implements Node {
private final List<Node> children = new ArrayList<>();
public void add(Node n) { children.add(n); }
public void show(String indent) {
System.out.println(indent + "dir");
children.forEach(c -> c.show(indent + " "));
}
}
常见误区
- 叶子也继承容器的 add/remove 方法:安全方式是把子节点管理放容器类,叶子不暴露修改方法。
- 递归遍历不控深度:循环引用或过深树需加深度防护。
追问
- 组合模式适用哪些结构?答:文件目录、菜单树、组织架构、组件嵌套、评论楼中楼。
- 透明方式与安全方式区别?答:透明方式统一接口含子节点方法;安全方式叶子不提供子节点操作,接口略不统一。
01.3.1.2-009 桥接模式分离的是哪两个维度?
一句话结论
桥接把“抽象”和“实现”两个独立变化维度分离,用组合代替继承,让两个维度可各自扩展;典型场景是形状与颜色、消息类型与发送渠道这种多维度交叉。
概念解释
- 抽象维度:高层逻辑/类型分类。
- 实现维度:底层渠道/具体能力。
- 桥接:抽象持有实现接口引用,组合而非继承。
原理流程
- 识别两个会独立变化的维度。
- 各维度定义接口。
- 抽象层组合实现接口,沿两个方向扩展子类。
代码或图示
形状(抽象) ──桥接──> 颜色(实现)
Circle / Square Red / Blue
若用继承:CircleRed/CircleBlue/SquareRed/SquareBlue 组合爆炸
常见误区
- 桥接就是简单组合:组合是手段,桥接强调两个独立变化维度解耦。
- 维度交叉少也上桥接:维度固定、组合数有限时继承更直白。
追问
- 消息发送怎么用桥接?答:消息类型(通知/营销)为抽象维度,发送渠道(短信/邮件/推送)为实现维度,各自扩展。
- 桥接和策略区别?答:策略是算法可替换;桥接是两个维度结构上分离,策略可作为桥接的实现侧。
01.3.1.2-010 外观模式提供什么价值?
一句话结论
外观为复杂子系统提供一个统一高层入口,屏蔽内部多模块协作细节,降低使用方理解成本;子系统内部仍可独立调用,外观只是简化门面,不封装业务规则。
概念解释
- 外观:聚合多个子系统调用流程。
- 子系统:内部模块,各自可被独立使用。
- 价值:降低耦合、提供粗粒度接口。
原理流程
- 梳理使用方常用的子系统调用组合。
- 写外观类编排流程顺序。
- 上层通过外观完成业务操作。
代码或图示
public class OrderFacade {
private final StockService stock;
private final PayService pay;
private final DeliveryService delivery;
public void place(Order o) {
stock.lock(o);
pay.charge(o);
delivery.dispatch(o);
}
}
常见误区
- 外观变成万能上帝类:外观只编排已有服务,不在里面堆业务逻辑。
- 外观取代所有子系统接口:内部细节仍需可独立访问与测试。
追问
- 外观和中介者区别?答:外观简化外部调用入口;中介者封装多个同事对象之间的相互通信,解耦网状引用。
- 门面 API 设计要点?答:粗粒度、参数稳定、异常归一化,内部变更不影响外观契约。
01.3.1.2-011 享元模式怎么复用细粒度对象?
一句话结论
享元通过共享不可变的内部状态对象,把可变外部状态从对象中剥离出来由调用方持有,减少大量细粒度对象的内存占用;典型如字符串常量池、连接复用、表格样式共享。
概念解释
- 内部状态:不可变、可共享,存在享元对象内。
- 外部状态:随上下文变化,使用时传入。
- 享元工厂:缓存并复用内部状态相同的对象。
原理流程
- 拆分对象可共享与可变部分。
- 工厂按 key 缓存共享对象。
- 使用时传入外部状态执行。
代码或图示
public class Font { // 内部状态:字号、字体名,不可变
private final String name; private final int size;
}
public class FontFactory {
private static final Map<String, Font> CACHE = new ConcurrentHashMap<>();
public static Font get(String name, int size) {
return CACHE.computeIfAbsent(name + size, k -> new Font(name, size));
}
}
常见误区
- 把可变状态也放进享元对象:共享对象被多线程/多请求修改会串数据。
- 为微小对象强行享元:缓存本身占内存,对象生命周期短、数量不大时直接创建更划算。
追问
- 享元和对象池区别?答:享元共享不可变内部状态,强调对象复用减少数量;对象池借出归还可变实例,强调资源复用与并发上限。
- Java 字符串常量池是享元吗?答:属于享元思想,相同字面量字符串共享同一内部对象。
01.3.1.2-012 代理模式在 Spring AOP 中怎么落地?
一句话结论
Spring AOP 用动态代理在目标 Bean 外围织入切面(事务、日志、权限、缓存),调用代理对象的方法时先执行拦截链,再委托目标方法;代理对象与目标实现同一接口或为其子类。
概念解释
- 切面:横切逻辑定义。
- 通知:前置/后置/环绕/异常/最终执行点。
- 拦截链:多个增强按顺序环绕目标方法。
原理流程
- 容器扫描带切面注解的 Bean。
- 按接口情况生成 JDK 或 CGLIB 代理。
- 方法调用走拦截链,最后反射调用目标。
代码或图示
调用方 → 代理对象
├─ 事务开启
├─ 日志记录
├─ 目标方法
└─ 提交/回滚、日志结束
常见误区
- 同类内部方法调用能触发切面:内部
this.method()绕过代理对象,切面不生效,需经代理调用或自注入。 - 代理 Bean 可直接强转实现类:JDK 代理只实现接口,强转实现类会失败。
追问
- 事务注解为什么同类调用失效?答:调用没经过代理对象,事务拦截器不执行。
- AOP 只能代理 public 方法吗?答:受代理机制限制,非 public 方法通常无法被正确拦截,具体以 Spring 版本规则为准。
01.3.1.2-013 装饰器在 Java IO 流中怎么体现?
一句话结论
Java 字节流/字符流按装饰器分层:基础流对接数据源,缓冲流、转换流、对象流等装饰器在外围叠加能力,可按需嵌套组合,上层统一使用流接口。
概念解释
- 基础组件:
FileInputStream等对接文件/网络。 - 装饰组件:
BufferedInputStream、InputStreamReader、ObjectInputStream。 - 嵌套:包装顺序决定能力叠加顺序。
原理流程
- 创建底层数据源流。
- 按需要包缓冲、编码、对象序列化层。
- 统一通过上层流接口读写。
代码或图示
try (var in = new ObjectInputStream(
new BufferedInputStream(new FileInputStream("a.dat")))) {
Object o = in.readObject();
}
常见误区
- 包装后只关外层流:外层装饰流关闭会级联关闭底层流,正确关闭最外层即可,但需 try-with-resources 管理。
- 缓冲流位置随意:缓冲应尽量贴近底层流,减少逐系统调用次数。
追问
- 装饰流为什么实现相同抽象类?答:保证可透明嵌套,任意一层都能再被包装。
- 字符流和字节流桥接靠什么?答:
InputStreamReader/OutputStreamWriter做编码转换桥接。
01.3.1.2-014 适配器在遗留系统接入中的实践要点是什么?
一句话结论
新系统定义领域接口,遗留/第三方系统通过适配器实现该接口,完成协议、字段、时序、错误码转换;适配器隔离外部变化,避免遗留概念渗透到核心业务。
概念解释
- 防腐层:适配器集合构成防腐层,隔离外部模型。
- 模型转换:外部 DTO 与领域对象互转。
- 错误归一:外部异常映射为领域异常。
原理流程
- 先定核心领域接口与模型。
- 为每个外部系统写适配器。
- 适配器负责调用、映射、重试与异常翻译。
代码或图示
核心业务 ──> 领域接口(订单仓库/支付网关)
↑ 实现
适配器 A(旧库) 适配器 B(第三方 API)
常见误区
- 适配器直接暴露外部 DTO 到核心层:外部字段变更会穿透核心模型。
- 把外部特殊规则写进核心:差异规则应留在适配器内。
追问
- 防腐层和适配器什么关系?答:防腐层是一组适配器/转换器的统称,目的是防止外部模型污染领域模型。
- 适配器需要重试/熔断吗?答:可在适配器侧接入容错组件,但策略与配置应可独立调整。
01.3.1.2-015 组合模式实现树结构有哪些注意点?
一句话结论
统一叶子与容器的构件接口,容器递归聚合子节点行为;注意区分安全式(叶子不提供子节点操作)与透明式(接口统一含增删),遍历要防循环引用与过深递归,展示类行为区分容器与叶子。
概念解释
- 递归聚合:容器行为由子节点结果汇总。
- 遍历防护:visited 集合或深度上限。
- 行为差异:叶子终止递归,容器继续下钻。
原理流程
- 定义构件抽象与公共行为。
- 叶子实现终止行为,容器维护子列表并递归。
- 遍历工具按树深度与防环规则访问。
代码或图示
Folder
├─ File
└─ Folder
└─ File
递归:遇到 File 输出自身;遇到 Folder 遍历 children
常见误区
- 子节点列表在叶子里也暴露 add:类型不安全,误用会在叶子上挂子节点。
- 递归无防环:节点互相引用时遍历栈溢出。
追问
- 树深度很大怎么遍历?答:改用栈/队列迭代遍历,避免方法递归栈溢出。
- 节点权限/排序怎么挂?答:作为节点字段或遍历策略,不破坏构件接口的透明性。
01.3.1.2-016 外观和中介者怎么区分职责?
一句话结论
外观面向外部使用方,简化对子系统的调用入口;中介者面向多个同事对象之间的网状通信,把相互调用收敛到中介者内部。一个是“对外门面”,一个是“对内解耦”。
概念解释
- 外观:外部 → 子系统,单向简化。
- 中介者:同事 ↔ 中介者 ↔ 同事,集中交互。
- 场景:门面 API 用外观;聊天室、订单流程中多对象协作集中用中介者。
原理流程
- 判断要简化的是外部调用还是内部对象间通信。
- 外部入口编排走外观。
- 同事对象间相互引用收敛到中介者。
代码或图示
外观:Client → Facade → 多个 Subsystem
中介者:ColleagueA ↔ Mediator ↔ ColleagueB(同事不直接互调)
常见误区
- 中介者变成上帝类:交互规则集中,但不应把同事自身业务搬进中介者。
- 外观承担跨模块编排后形成新耦合:外观接口要稳定,内部子系统可调整。
追问
- 大厅/聊天室成员互相发消息用哪种?答:中介者,成员只认识聊天室对象,由聊天室转发。
- 下单串联库存支付物流用哪种?答:对外提供订单门面用外观;内部各服务协作可结合领域服务编排。
01.3.1.2-017 享元和对象池、缓存有什么区别?
一句话结论
享元共享不可变细粒度对象,降低对象数量;对象池复用可变实例并控制并发上限;缓存保存计算结果以避免重复计算。三者都有复用目的,但复用的内容、可变性与生命周期不同。
概念解释
- 享元:内部状态不可变,外部状态传入。
- 对象池:实例可借出归还,状态需重置。
- 缓存:按 key 存结果,可失效淘汰。
原理流程
- 识别复用对象是不可变状态、可变资源还是计算结果。
- 分别选享元、对象池、缓存。
- 注意共享对象的线程安全与淘汰策略。
代码或图示
享元:相同不可变对象共享(字体/样式)
对象池:可变实例借出归还(连接/线程)
缓存:结果 key → value,可过期淘汰(热点数据)
常见误区
- 把可变资源当享元共享:多请求改同一实例导致串数据。
- 缓存对象当连接池复用:缓存不管理资源占用与归还。
追问
- 字符串常量池属于哪类?答:享元式共享,字符串不可变所以安全。
- 线程池和享元冲突吗?答:线程是可变执行资源,用对象池思路复用,不是享元。
01.3.1.2-018 结构型模式组合使用时有哪些取舍原则?
一句话结论
结构型模式优先用组合而非继承,每层包装解决一个明确差距;包装层级应可解释、可测试,避免为套模式叠加无意义间接层,新增结构前先看是否有真实的接口差距、增强需求或层级组织问题。
概念解释
- 单一职责:一个包装层只承担一类结构职责。
- 可测试:底层组件可脱离包装单独测试。
- 可演进:结构随真实问题逐步引入。
原理流程
- 列出现有组件与使用方期望的差距清单。
- 每个差距匹配一个结构型角色。
- 评审包装层级数量与间接成本,移除无职责包装。
代码或图示
调用方
→ 外观(统一入口)
→ 装饰(日志/缓存)
→ 代理(事务/权限)
→ 真实组件
每层职责单一,顺序可解释
常见误区
- 包装层层嵌套但每层只透传:无职责包装应删除。
- 结构型抽象破坏类型信息:必要时暴露底层接口用于测试与排障。
追问
- 怎么判断包装层过多?答:调用一个方法要追五六层透传才到业务,说明结构冗余。
- 组合优先于继承体现在哪?答:运行期组装、避免子类爆炸、符合开闭与单一职责;继承只用于固定的类型层次。