罗罗编程学习记录
本页内容 展开查看

01.3.1.2 结构型模式

所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.1 设计模式与架构基础

01.3.1.2-001 结构型模式总体解决什么问题?

一句话结论

结构型模式解决类与对象如何组合成更大结构的问题,在不修改既有组件的前提下,通过包装、代理、组合、转换等方式适配接口、增强能力或组织层级关系,让各部分可独立复用。

概念解释

  • 关注点:对象之间的装配关系,而非创建算法或业务流程。
  • 手段:继承/组合、接口转换、统一抽象层级。
  • 收益:接口兼容、能力增强、层级透明、资源复用。

原理流程

  1. 识别现有组件接口与使用方期望之间的差距。
  2. 选择包装/代理/适配/组合等结构补齐差距。
  3. 上层只依赖统一抽象,不感知内部装配。

代码或图示

使用方 ──> 统一抽象
            ├─ 代理包装(控制访问)
            ├─ 装饰包装(增强能力)
            ├─ 适配转换(接口对齐)
            └─ 组合树(容器/叶子统一)

常见误区

  • 结构型模式只靠继承实现:优先组合,继承层级越深越难维护。
  • 包装层级越多越好:每层包装都有理解与性能成本,层级应可解释。

追问

  • 结构型和创建型怎么配合?答:创建型负责产出对象,结构型负责把产出的对象组装成可用结构。
  • 常见结构型模式有哪些?答:代理、装饰、适配器、组合、桥接、外观、享元。

01.3.1.2-002 代理模式解决什么问题?有哪几种实现?

一句话结论

代理为目标对象提供一个替身,在不改变目标接口的前提下控制访问(远程、懒加载、权限、事务、日志、缓存);实现分静态代理(手写代理类)与动态代理(运行期生成代理类)。

概念解释

  • 角色:抽象主题、真实主题、代理主题,三者实现同一接口。
  • 前置/后置逻辑:代理在调用前后插入横切逻辑。
  • 控制访问:代理决定是否、何时调用真实对象。

原理流程

  1. 定义共同接口。
  2. 真实对象实现业务,代理持有真实对象引用。
  3. 代理方法内做检查/增强后委托调用。

代码或图示

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 方法;目标类有无参构造要求(具体约束以所用版本为准,待确认)。

原理流程

  1. 判断目标是否实现接口。
  2. 有接口可用 JDK 代理;无接口用 CGLIB 子类代理。
  3. 调用处理器/拦截器织入增强逻辑。

代码或图示

// 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 代理模式和装饰器模式怎么区分?

一句话结论

两者结构都是持有被包装对象并实现同一接口,区别在意图:代理强调“控制访问”,由代理决定能否/何时调用;装饰器强调“增强能力”,通常多层包装叠加功能,且调用方主动组装。

概念解释

  • 代理:控制权在代理,目标创建/可见性/访问受控。
  • 装饰:在目标外围叠加职责,增强后仍可继续包装。
  • 结构相似是历史上常被混淆的原因,区分看设计意图与包装方向。

原理流程

  1. 看谁创建并持有目标:代理常自己管理目标生命周期。
  2. 看包装目的:控制访问归代理,加功能归装饰。
  3. 多层叠加增强是装饰器典型形态。

代码或图示

代理:Proxy → Target(代理控制是否放行)
装饰:LoggingDecorator → CacheDecorator → Target(逐层加功能)

常见误区

  • 代码结构一样就归为一种模式:模式分类看意图,结构相似不代表角色相同。
  • 装饰器不能控制访问:装饰器也可做前置检查,但其核心定位是增强而非替身控制。

追问

  • Spring AOP 更接近哪种?答:属于动态代理,主要承载横切增强(事务、日志),兼具装饰器式叠加与代理式拦截特征。
  • 装饰器和责任链区别?答:装饰器一定把请求传给内层并叠加结果;责任链可中断、不继续传递。

01.3.1.2-005 装饰器模式怎么实现多层增强?

一句话结论

装饰器与被装饰对象实现同一接口,装饰器持有一个同接口对象;构造时传入内层对象,方法内先/后叠加增强再委托,多个装饰器按需要层层嵌套。

概念解释

  • 抽象组件:定义统一接口。
  • 具体组件:原始对象。
  • 装饰器:持有组件引用,叠加职责。

原理流程

  1. 定义组件接口。
  2. 写基础实现与抽象装饰器(持有组件)。
  3. 各增强装饰器继承装饰器,嵌套组装。

代码或图示

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 适配器模式解决什么问题?

一句话结论

适配器把已有类的接口转换为使用方期望的接口,在不改遗留代码的前提下接入新系统;分类适配器(继承)与对象适配器(组合),优先用组合。

概念解释

  • 目标接口:使用方期望的接口。
  • 适配者:已有但接口不匹配的类。
  • 适配器:实现目标接口,内部调用适配者。

原理流程

  1. 明确使用方期望接口。
  2. 识别遗留/第三方类的现有接口。
  3. 写适配器做方法映射与参数转换。

代码或图示

// 期望接口
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 适配器、代理、装饰器三者怎么一句话区分?

一句话结论

适配器改接口以对齐期望;代理不改接口只控制访问;装饰器不改接口只叠加能力;三者都持有被包装对象,区别在“改什么、为什么包装”。

概念解释

  • 适配器:接口不同 → 转换。
  • 代理:接口相同 → 控制。
  • 装饰:接口相同 → 增强。

原理流程

  1. 先看接口是否一致。
  2. 不一致归适配器。
  3. 一致再看意图:控制访问归代理,叠加功能归装饰。

代码或图示

接口不一致 ──> 适配器(转换签名/参数)
接口一致 ──> 代理(放行/懒加载/权限)
接口一致 ──> 装饰(日志/缓存/压缩叠加)

常见误区

  • 凭代码结构归类:必须结合调用方期望与包装意图判断。
  • 把参数转换写进代理/装饰器:签名转换属于适配器职责。

追问

  • 接入旧短信 SDK 用哪种?答:接口签名不一致用适配器;在其外围加日志/重试可再叠装饰器。
  • 统一多套第三方支付接口怎么设计?答:先定义领域支付接口,各 SDK 写适配器实现,上层只依赖领域接口。

01.3.1.2-008 组合模式解决什么问题?

一句话结论

组合模式把容器与叶子节点抽象为同一接口,让树形结构中的单个对象和组合对象被一致对待,调用方无需区分文件与文件夹、菜单项与菜单组。

概念解释

  • 抽象构件:声明叶子与容器共同接口。
  • 叶子:无子节点。
  • 容器:持有子构件列表,递归聚合行为。

原理流程

  1. 定义统一构件接口。
  2. 叶子实现自身行为。
  3. 容器实现子节点管理与递归遍历。

代码或图示

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 桥接模式分离的是哪两个维度?

一句话结论

桥接把“抽象”和“实现”两个独立变化维度分离,用组合代替继承,让两个维度可各自扩展;典型场景是形状与颜色、消息类型与发送渠道这种多维度交叉。

概念解释

  • 抽象维度:高层逻辑/类型分类。
  • 实现维度:底层渠道/具体能力。
  • 桥接:抽象持有实现接口引用,组合而非继承。

原理流程

  1. 识别两个会独立变化的维度。
  2. 各维度定义接口。
  3. 抽象层组合实现接口,沿两个方向扩展子类。

代码或图示

形状(抽象) ──桥接──> 颜色(实现)
  Circle / Square     Red / Blue
若用继承:CircleRed/CircleBlue/SquareRed/SquareBlue 组合爆炸

常见误区

  • 桥接就是简单组合:组合是手段,桥接强调两个独立变化维度解耦。
  • 维度交叉少也上桥接:维度固定、组合数有限时继承更直白。

追问

  • 消息发送怎么用桥接?答:消息类型(通知/营销)为抽象维度,发送渠道(短信/邮件/推送)为实现维度,各自扩展。
  • 桥接和策略区别?答:策略是算法可替换;桥接是两个维度结构上分离,策略可作为桥接的实现侧。

01.3.1.2-010 外观模式提供什么价值?

一句话结论

外观为复杂子系统提供一个统一高层入口,屏蔽内部多模块协作细节,降低使用方理解成本;子系统内部仍可独立调用,外观只是简化门面,不封装业务规则。

概念解释

  • 外观:聚合多个子系统调用流程。
  • 子系统:内部模块,各自可被独立使用。
  • 价值:降低耦合、提供粗粒度接口。

原理流程

  1. 梳理使用方常用的子系统调用组合。
  2. 写外观类编排流程顺序。
  3. 上层通过外观完成业务操作。

代码或图示

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 享元模式怎么复用细粒度对象?

一句话结论

享元通过共享不可变的内部状态对象,把可变外部状态从对象中剥离出来由调用方持有,减少大量细粒度对象的内存占用;典型如字符串常量池、连接复用、表格样式共享。

概念解释

  • 内部状态:不可变、可共享,存在享元对象内。
  • 外部状态:随上下文变化,使用时传入。
  • 享元工厂:缓存并复用内部状态相同的对象。

原理流程

  1. 拆分对象可共享与可变部分。
  2. 工厂按 key 缓存共享对象。
  3. 使用时传入外部状态执行。

代码或图示

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 外围织入切面(事务、日志、权限、缓存),调用代理对象的方法时先执行拦截链,再委托目标方法;代理对象与目标实现同一接口或为其子类。

概念解释

  • 切面:横切逻辑定义。
  • 通知:前置/后置/环绕/异常/最终执行点。
  • 拦截链:多个增强按顺序环绕目标方法。

原理流程

  1. 容器扫描带切面注解的 Bean。
  2. 按接口情况生成 JDK 或 CGLIB 代理。
  3. 方法调用走拦截链,最后反射调用目标。

代码或图示

调用方 → 代理对象
          ├─ 事务开启
          ├─ 日志记录
          ├─ 目标方法
          └─ 提交/回滚、日志结束

常见误区

  • 同类内部方法调用能触发切面:内部 this.method() 绕过代理对象,切面不生效,需经代理调用或自注入。
  • 代理 Bean 可直接强转实现类:JDK 代理只实现接口,强转实现类会失败。

追问

  • 事务注解为什么同类调用失效?答:调用没经过代理对象,事务拦截器不执行。
  • AOP 只能代理 public 方法吗?答:受代理机制限制,非 public 方法通常无法被正确拦截,具体以 Spring 版本规则为准。

01.3.1.2-013 装饰器在 Java IO 流中怎么体现?

一句话结论

Java 字节流/字符流按装饰器分层:基础流对接数据源,缓冲流、转换流、对象流等装饰器在外围叠加能力,可按需嵌套组合,上层统一使用流接口。

概念解释

  • 基础组件:FileInputStream 等对接文件/网络。
  • 装饰组件:BufferedInputStream、InputStreamReader、ObjectInputStream。
  • 嵌套:包装顺序决定能力叠加顺序。

原理流程

  1. 创建底层数据源流。
  2. 按需要包缓冲、编码、对象序列化层。
  3. 统一通过上层流接口读写。

代码或图示

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 与领域对象互转。
  • 错误归一:外部异常映射为领域异常。

原理流程

  1. 先定核心领域接口与模型。
  2. 为每个外部系统写适配器。
  3. 适配器负责调用、映射、重试与异常翻译。

代码或图示

核心业务 ──> 领域接口(订单仓库/支付网关)
                 ↑ 实现
          适配器 A(旧库)  适配器 B(第三方 API)

常见误区

  • 适配器直接暴露外部 DTO 到核心层:外部字段变更会穿透核心模型。
  • 把外部特殊规则写进核心:差异规则应留在适配器内。

追问

  • 防腐层和适配器什么关系?答:防腐层是一组适配器/转换器的统称,目的是防止外部模型污染领域模型。
  • 适配器需要重试/熔断吗?答:可在适配器侧接入容错组件,但策略与配置应可独立调整。

01.3.1.2-015 组合模式实现树结构有哪些注意点?

一句话结论

统一叶子与容器的构件接口,容器递归聚合子节点行为;注意区分安全式(叶子不提供子节点操作)与透明式(接口统一含增删),遍历要防循环引用与过深递归,展示类行为区分容器与叶子。

概念解释

  • 递归聚合:容器行为由子节点结果汇总。
  • 遍历防护:visited 集合或深度上限。
  • 行为差异:叶子终止递归,容器继续下钻。

原理流程

  1. 定义构件抽象与公共行为。
  2. 叶子实现终止行为,容器维护子列表并递归。
  3. 遍历工具按树深度与防环规则访问。

代码或图示

Folder
 ├─ File
 └─ Folder
      └─ File
递归:遇到 File 输出自身;遇到 Folder 遍历 children

常见误区

  • 子节点列表在叶子里也暴露 add:类型不安全,误用会在叶子上挂子节点。
  • 递归无防环:节点互相引用时遍历栈溢出。

追问

  • 树深度很大怎么遍历?答:改用栈/队列迭代遍历,避免方法递归栈溢出。
  • 节点权限/排序怎么挂?答:作为节点字段或遍历策略,不破坏构件接口的透明性。

01.3.1.2-016 外观和中介者怎么区分职责?

一句话结论

外观面向外部使用方,简化对子系统的调用入口;中介者面向多个同事对象之间的网状通信,把相互调用收敛到中介者内部。一个是“对外门面”,一个是“对内解耦”。

概念解释

  • 外观:外部 → 子系统,单向简化。
  • 中介者:同事 ↔ 中介者 ↔ 同事,集中交互。
  • 场景:门面 API 用外观;聊天室、订单流程中多对象协作集中用中介者。

原理流程

  1. 判断要简化的是外部调用还是内部对象间通信。
  2. 外部入口编排走外观。
  3. 同事对象间相互引用收敛到中介者。

代码或图示

外观:Client → Facade → 多个 Subsystem
中介者:ColleagueA ↔ Mediator ↔ ColleagueB(同事不直接互调)

常见误区

  • 中介者变成上帝类:交互规则集中,但不应把同事自身业务搬进中介者。
  • 外观承担跨模块编排后形成新耦合:外观接口要稳定,内部子系统可调整。

追问

  • 大厅/聊天室成员互相发消息用哪种?答:中介者,成员只认识聊天室对象,由聊天室转发。
  • 下单串联库存支付物流用哪种?答:对外提供订单门面用外观;内部各服务协作可结合领域服务编排。

01.3.1.2-017 享元和对象池、缓存有什么区别?

一句话结论

享元共享不可变细粒度对象,降低对象数量;对象池复用可变实例并控制并发上限;缓存保存计算结果以避免重复计算。三者都有复用目的,但复用的内容、可变性与生命周期不同。

概念解释

  • 享元:内部状态不可变,外部状态传入。
  • 对象池:实例可借出归还,状态需重置。
  • 缓存:按 key 存结果,可失效淘汰。

原理流程

  1. 识别复用对象是不可变状态、可变资源还是计算结果。
  2. 分别选享元、对象池、缓存。
  3. 注意共享对象的线程安全与淘汰策略。

代码或图示

享元:相同不可变对象共享(字体/样式)
对象池:可变实例借出归还(连接/线程)
缓存:结果 key → value,可过期淘汰(热点数据)

常见误区

  • 把可变资源当享元共享:多请求改同一实例导致串数据。
  • 缓存对象当连接池复用:缓存不管理资源占用与归还。

追问

  • 字符串常量池属于哪类?答:享元式共享,字符串不可变所以安全。
  • 线程池和享元冲突吗?答:线程是可变执行资源,用对象池思路复用,不是享元。

01.3.1.2-018 结构型模式组合使用时有哪些取舍原则?

一句话结论

结构型模式优先用组合而非继承,每层包装解决一个明确差距;包装层级应可解释、可测试,避免为套模式叠加无意义间接层,新增结构前先看是否有真实的接口差距、增强需求或层级组织问题。

概念解释

  • 单一职责:一个包装层只承担一类结构职责。
  • 可测试:底层组件可脱离包装单独测试。
  • 可演进:结构随真实问题逐步引入。

原理流程

  1. 列出现有组件与使用方期望的差距清单。
  2. 每个差距匹配一个结构型角色。
  3. 评审包装层级数量与间接成本,移除无职责包装。

代码或图示

调用方
  → 外观(统一入口)
    → 装饰(日志/缓存)
      → 代理(事务/权限)
        → 真实组件
每层职责单一,顺序可解释

常见误区

  • 包装层层嵌套但每层只透传:无职责包装应删除。
  • 结构型抽象破坏类型信息:必要时暴露底层接口用于测试与排障。

追问

  • 怎么判断包装层过多?答:调用一个方法要追五六层透传才到业务,说明结构冗余。
  • 组合优先于继承体现在哪?答:运行期组装、避免子类爆炸、符合开闭与单一职责;继承只用于固定的类型层次。