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

01.3.2.7 外观组合桥接与享元

所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解

覆盖范围

  • Facade 简化子系统与分层边界
  • Facade 与中介者、代理、适配器的区别
  • Composite 树形结构与递归遍历
  • Composite 在 UI 菜单、组织架构、文件系统中的落地
  • Bridge 抽象维度与实现维度双解耦
  • Bridge 与策略、适配器的区别
  • Flyweight 内部状态与外部状态拆分
  • Flyweight 与对象池、缓存的区别
  • Java Integer.valueOf 缓存与 String 常量池作为享元实例
  • Go sync.Pool 为什么不是享元
  • 前端虚拟列表中的享元思想
  • 四者的互斥与组合使用
  • 「为组合而组合」的误用信号

面试题索引

编号 题目 难度 状态 备注
01.3.2.7-001 Facade 怎么简化子系统?分层边界怎么划? 基础 已完成 外观意图
01.3.2.7-002 Facade 与中介者、代理、适配器怎么区分? 进阶 已完成 结构型辨析
01.3.2.7-003 Composite 怎么用统一接口处理树形结构? 基础 已完成 组合模式
01.3.2.7-004 Composite 在 UI 菜单、组织架构、文件系统中怎么落地? 进阶 已完成 真实场景
01.3.2.7-005 Bridge 怎么解耦抽象维度与实现维度? 进阶 已完成 桥接意图
01.3.2.7-006 Bridge 与策略、适配器有什么区别? 进阶 已完成 模式辨析
01.3.2.7-007 Flyweight 的内部状态与外部状态怎么拆? 进阶 已完成 享元意图
01.3.2.7-008 Flyweight 与对象池、缓存有什么区别? 进阶 已完成 复用辨析
01.3.2.7-009 Java Integer.valueOf 缓存与 String 常量池怎么体现享元? 进阶 已完成 JDK 实例
01.3.2.7-010 Go 的 sync.Pool 为什么不是享元? 高级 已完成 并发原语
01.3.2.7-011 前端虚拟列表如何体现享元思想? 进阶 已完成 工程实践
01.3.2.7-012 Facade / Composite / Bridge / Flyweight 四者怎么组合使用? 高级 已完成 模式组合
01.3.2.7-013 「为组合而组合」的误用有哪些信号? 高级 已完成 滥用反思

01.3.2.7-001 Facade 怎么简化子系统?分层边界怎么划?

一句话结论

Facade 为复杂子系统提供一个统一的高层入口,把多个子模块的调用顺序与协作封装在一个类里,让外部调用方只依赖一个粗粒度接口;它位于外部层与子系统之间,不封装业务规则。

概念解释

  • Facade:对外的统一入口,编排多个子系统调用。
  • 子系统:内部多个模块,各自可被独立调用与测试。
  • 分层边界:Facade 在业务层与基础设施层之间,不承载业务规则。
  • 价值:降低调用方理解成本、屏蔽内部重构、提供粗粒度 API。

原理流程

  1. 梳理外部常用的子系统调用组合。
  2. 写 Facade 类,按固定顺序编排子系统调用。
  3. 外部调用方只依赖 Facade,不直接调用子系统。
  4. 子系统内部重构不影响 Facade 契约。

代码或图示

public class OrderFacade {
    private final StockService stock;
    private final PayService pay;
    private final DeliveryService delivery;

    public OrderFacade(StockService s, PayService p, DeliveryService d) {
        this.stock = s; this.pay = p; this.delivery = d;
    }

    public void place(Order order) {
        stock.lock(order);
        pay.charge(order);
        delivery.dispatch(order);
    }
}
// C#:Facade 通过 DI 注入多个子系统
public class OrderFacade
{
    private readonly StockService _stock;
    private readonly PayService _pay;
    private readonly DeliveryService _delivery;

    public OrderFacade(StockService stock, PayService pay, DeliveryService delivery)
    {
        _stock = stock; _pay = pay; _delivery = delivery;
    }

    public void Place(Order order)
    {
        _stock.Lock(order);
        _pay.Charge(order);
        _delivery.Dispatch(order);
    }
}
外部调用方 ──> OrderFacade
                ├─ StockService
                ├─ PayService
                └─ DeliveryService
子系统内部仍可被独立调用与测试

常见误区

  • 把 Facade 写成「上帝类」:所有业务都堆进去,Facade 变成业务规则的承担者。
  • Facade 取代所有子系统接口:子系统应仍可被独立测试与调用。
  • Facade 里做跨模块事务:事务边界应由领域服务或编排层管理,Facade 只做流程编排。

追问

  • Facade 和 DDD 中的领域服务怎么区分?答:Facade 编排已有子系统、不产生新业务规则;领域服务承载业务规则与状态流转。
  • Facade 接口设计要点?答:粗粒度、参数稳定、异常归一化;内部子系统变更不破坏 Facade 契约。

01.3.2.7-002 Facade 与中介者、代理、适配器怎么区分?

一句话结论

Facade 对外简化多个子系统;中介者对内解耦多个同事对象之间的网状通信;代理不改接口只控制访问;适配器改接口对齐期望;四者都「包了一层」,但位置与意图完全不同。

概念解释

  • Facade:外部 → 子系统,单向简化。
  • 中介者:同事 ↔ 中介者 ↔ 同事,集中交互。
  • 代理:调用方 → 代理 → 真实对象,控制访问。
  • 适配器:调用方期望接口 → 适配者实际接口。

原理流程

  1. 看调用方是谁:外部调用子系统选 Facade。
  2. 看对象间通信:同事对象互相引用收敛到中介者。
  3. 看接口是否一致:不一致选适配器;一致再看是控制访问还是简化入口。

代码或图示

Facade:     Client ──> Facade ──> SubsystemA, SubsystemB, SubsystemC
中介者:      ColleagueA ↔ Mediator ↔ ColleagueB(同事不直接互调)
代理:       Client ──> Proxy ──> RealSubject(接口相同)
适配器:      Client ──> Target <── Adapter ──> Adaptee(接口不同)

常见误区

  • 把 Facade 当中介者:Facade 是「对外门面」,中介者是「对内解耦」;一个订单流程中,对外下单入口用 Facade,内部库存/支付/物流协作可结合领域服务,而不是让所有同事直接互调。
  • 代理做简化:代理不提供新接口,只控制是否放行;提供新接口归 Facade。

追问

  • 聊天室成员互相发消息用哪种?答:中介者,成员只认识聊天室对象,由聊天室转发。
  • 微服务 BFF 是 Facade 吗?答:BFF 兼具 Facade(聚合下游多个服务)与适配器(模型转换)特征,本质是面向前端的外观层。

01.3.2.7-003 Composite 怎么用统一接口处理树形结构?

一句话结论

Composite 把容器与叶子节点抽象为同一接口,让调用方一致对待单个对象与组合对象,递归处理树形结构时不需要 if (instanceof) 判断节点类型。

概念解释

  • 抽象构件:声明叶子与容器的共同接口。
  • 叶子:无子节点,实现自身行为。
  • 容器:持有子构件列表,递归聚合行为。
  • 透明式:接口统一含子节点管理方法;安全式:叶子不暴露 add/remove。

原理流程

  1. 定义构件接口(如 show、count)。
  2. 叶子实现终止行为。
  3. 容器维护子列表,行为方法递归遍历子节点。
  4. 调用方对任意节点调用同一接口,不关心具体类型。

代码或图示

public interface Node {
    long size();
}

public class FileNode implements Node {
    private final long size;
    public FileNode(long s) { this.size = s; }
    public long size() { return size; }
}

public class FolderNode implements Node {
    private final List<Node> children = new ArrayList<>();
    public void add(Node n) { children.add(n); }
    public long size() {
        long total = 0;
        for (Node c : children) total += c.size();
        return total;
    }
}
# Python:Composite 用鸭子类型,不需要显式接口
class FileNode:
    def __init__(self, name: str, size: int):
        self.name = name
        self._size = size
    def size(self) -> int:
        return self._size

class FolderNode:
    def __init__(self, name: str):
        self.name = name
        self.children: list = []
    def add(self, node) -> None:
        self.children.append(node)
    def size(self) -> int:
        return sum(c.size() for c in self.children)

# 调用方不关心是 File 还是 Folder
root = FolderNode("root")
root.add(FileNode("a.txt", 100))
sub = FolderNode("sub")
sub.add(FileNode("b.txt", 200))
root.add(sub)
print(root.size())  # 300
Folder
 ├─ File (1KB)
 └─ Folder
      ├─ File (2KB)
      └─ File (3KB)
递归:Folder.size() = 1 + (2 + 3) = 6

常见误区

  • 叶子也继承容器的 add/remove:透明式方便但类型不安全,安全式让叶子不暴露修改方法。
  • 递归不防环:节点互相引用会栈溢出,需 visited 集合或深度上限。
  • 树深度很大仍用方法递归:深树改用栈/队列迭代,避免栈溢出。

追问

  • 透明式与安全式怎么选?答:节点类型明确、调用方知道谁是容器时选安全式;需要调用方无差别处理任意节点时选透明式。
  • Composite 和装饰器结构相似吗?答:结构都是持有子对象,但装饰器是单链包装、增强能力;Composite 是树状聚合、统一对待。

01.3.2.7-004 Composite 在 UI 菜单、组织架构、文件系统中怎么落地?

一句话结论

UI 菜单树、组织架构树、文件目录树都是典型树形结构,Composite 让「菜单项与菜单组」「员工与部门」「文件与文件夹」实现同一接口,递归渲染与统计。

概念解释

  • UI 菜单:叶子是菜单项,容器是菜单组。
  • 组织架构:叶子是员工,容器是部门。
  • 文件系统:叶子是文件,容器是文件夹。
  • 共同特征:统一的 render / size / count 行为,递归聚合。

原理流程

  1. 定义统一构件接口(如 render、count、size)。
  2. 叶子实现终止行为。
  3. 容器持有子列表,递归调用子节点的同一接口。
  4. 调用方从根节点开始,一次调用完成整树处理。

代码或图示

// UI 菜单
interface MenuNode {
  render(indent: string): void;
}

class MenuItem implements MenuNode {
  constructor(private label: string) {}
  render(indent: string): void { console.log(indent + "- " + this.label); }
}

class MenuGroup implements MenuNode {
  private children: MenuNode[] = [];
  constructor(private label: string) {}
  add(n: MenuNode) { this.children.push(n); }
  render(indent: string): void {
    console.log(indent + "# " + this.label);
    for (const c of this.children) c.render(indent + "  ");
  }
}
// 组织架构:员工与部门
type OrgNode interface {
    Headcount() int
}

type Employee struct{ name string }
func (e *Employee) Headcount() int { return 1 }

type Department struct {
    name     string
    children []OrgNode
}
func (d *Department) Headcount() int {
    total := 0
    for _, c := range d.children { total += c.Headcount() }
    return total
}

常见误区

  • 把「是否可展开」作为叶子与容器的判断依据:应通过接口类型区分,而不是运行时 instanceof。
  • 递归渲染时不维护缩进/层级:展示类行为需要把上下文(缩进、深度)作为参数传入。
  • 数据库里用邻接表存树,加载到内存后才做 Composite:大数据量应改用路径枚举或闭包表,避免递归加载整树。

追问

  • 前端组件库(如 Vue / React)的组件树是 Composite 吗?答:是思想落地——组件递归渲染子组件,父组件不关心子组件是叶子还是容器。
  • 树深度 10000 层怎么办?答:改用迭代式遍历(栈/队列),或按懒加载分段加载,避免递归栈溢出。

01.3.2.7-005 Bridge 怎么解耦抽象维度与实现维度?

一句话结论

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

概念解释

  • 抽象维度:高层逻辑(如形状、消息类型)。
  • 实现维度:底层渠道(如颜色、发送方式)。
  • 桥接:抽象层持有实现层接口引用,组合而非继承。
  • 收益:两个维度独立扩展,避免子类数量爆炸。

原理流程

  1. 识别两个会独立变化的维度。
  2. 各维度定义接口。
  3. 抽象层组合实现接口,沿两个方向扩展子类。
  4. 运行期把实现注入抽象,组合出具体对象。

代码或图示

// 实现维度:颜色
interface Color { String fill(); }
class Red implements Color { public String fill() { return "red"; } }
class Blue implements Color { public String fill() { return "blue"; } }

// 抽象维度:形状,持有 Color 引用
abstract class Shape {
    protected Color color;
    public Shape(Color c) { this.color = c; }
    abstract void draw();
}
class Circle extends Shape {
    public Circle(Color c) { super(c); }
    public void draw() { System.out.println("circle " + color.fill()); }
}
继承方案:CircleRed / CircleBlue / SquareRed / SquareBlue = 4 个子类
桥接方案:Shape(2 个子类)× Color(2 个实现)= 2 + 2,扩展时只加一个类

常见误区

  • 把 Bridge 当普通组合:组合是手段,Bridge 强调两个独立变化维度的结构解耦。
  • 维度交叉很少也上 Bridge:组合数有限时继承更直白。
  • 在抽象层里硬编码实现:实现应通过构造器注入,运行期可替换。

追问

  • 消息通知怎么用 Bridge?答:消息类型(通知/营销)为抽象维度,发送渠道(短信/邮件/推送)为实现维度,各自扩展。
  • Bridge 和「依赖倒置」什么关系?答:Bridge 是 DIP 的具体应用——抽象层依赖实现层接口,不依赖具体实现。

01.3.2.7-006 Bridge 与策略、适配器有什么区别?

一句话结论

Bridge 是两个维度的结构性分离,长期共存;策略是算法可替换,运行期选择;适配器是接口对齐,过渡形态;三者都用组合,但意图与生命周期不同。

概念解释

  • Bridge:抽象与实现两个维度都在演进,结构上长期分离。
  • 策略:同一接口下多个算法实现,运行期按场景选择。
  • 适配器:接口不匹配时转换,通常是过渡形态。

原理流程

  1. 看是否两个维度都在长期扩展:是则 Bridge。
  2. 看是否同一接口下多个可替换算法:是则策略。
  3. 看是否接口不匹配需要转换:是则适配器。

代码或图示

Bridge:  AbstractionA/B × ImplementorA/B(两个维度都在扩展)
策略:    Context ──> Strategy(同一接口,运行期选一个)
适配器:  Client ──> Target <── Adapter ──> Adaptee(接口转换)

常见误区

  • 把策略当 Bridge:策略是「同一维度下的算法替换」,Bridge 是「两个维度结构分离」。
  • 把适配器当 Bridge:适配器是临时转换,Bridge 是长期架构。
  • 用 Bridge 解决接口不匹配:接口不匹配应选适配器,Bridge 不解决接口对齐问题。

追问

  • 日志系统:日志级别 + 输出目的地,是 Bridge 吗?答:是,两个维度独立扩展;但如果只有一个目的地在换,更像策略。
  • Bridge 的实现侧可以是策略吗?答:可以,实现侧本身就是一个策略接口;Bridge 是更宏观的结构,策略是其中一侧的实现手法。

01.3.2.7-007 Flyweight 的内部状态与外部状态怎么拆?

一句话结论

Flyweight 把对象拆成「不可变内部状态」(可共享,存在享元对象内)与「可变外部状态」(随上下文变化,使用时传入),通过共享大量细粒度对象减少内存占用。

概念解释

  • 内部状态:不可变、可共享,如字体名、字号、颜色。
  • 外部状态:随上下文变化,如文本内容、位置,使用时传入方法参数。
  • 享元工厂:按 key 缓存内部状态相同的对象。
  • 前提:对象数量巨大、内部状态可枚举且可共享。

原理流程

  1. 拆分对象的可共享部分与可变部分。
  2. 把可共享部分做成享元对象,放进工厂缓存。
  3. 可变部分作为方法参数传入。
  4. 调用方从工厂获取享元,传入外部状态执行。

代码或图示

// 内部状态:字体名 + 字号(不可变)
public final class Font {
    private final String name;
    private final int size;
    public Font(String n, int s) { name = n; size = s; }
}

// 工厂:缓存相同 Font
public final 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));
    }
}

// 外部状态:文本内容、位置,使用时传入
public void draw(String text, int x, int y, Font f) { }
// Rust:Flyweight 用 HashMap 缓存不可变对象
use std::collections::HashMap;
use std::sync::Mutex;

#[derive(Clone, Hash, Eq, PartialEq)]
struct FontKey { name: String, size: u32 }

#[derive(Clone)]
struct Font { name: String, size: u32 }

struct FontFactory {
    cache: Mutex<HashMap<FontKey, Font>>,
}

impl FontFactory {
    fn get(&self, name: &str, size: u32) -> Font {
        let key = FontKey { name: name.to_string(), size };
        let mut cache = self.cache.lock().unwrap();
        cache.entry(key).or_insert_with(|| Font {
            name: name.to_string(), size,
        }).clone()
    }
}

常见误区

  • 把可变状态放进享元对象:共享对象被多线程/多请求修改会串数据。
  • 为微小对象强行享元:缓存本身占内存,对象数量不大时直接创建更划算。
  • 外部状态不通过参数传,而是塞进享元对象:破坏可共享性。

追问

  • 享元对象可以有状态吗?答:只能有不可变状态;任何可变字段都会破坏共享。
  • 享元工厂要考虑淘汰吗?答:内部状态种类有限时不需要淘汰;如果 key 空间大(如用户 ID),应改用缓存而非享元。

01.3.2.7-008 Flyweight 与对象池、缓存有什么区别?

一句话结论

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

概念解释

  • Flyweight:内部状态不可变,外部状态传入,对象本身无状态。
  • 对象池:实例可变,借出归还,使用前需重置状态。
  • 缓存:按 key 存结果,可过期淘汰,内容是计算结果。

原理流程

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

代码或图示

享元:   相同不可变对象共享(字体/样式/常量)
对象池: 可变实例借出归还(连接/线程/缓冲区)
缓存:   结果 key → value,可过期淘汰(热点数据/查询结果)
// PHP:享元工厂(请求级缓存,FPM 下不跨请求)
final class FontFactory {
    /** @var array<string, Font> */
    private static array $cache = [];

    public static function get(string $name, int $size): Font {
        $key = "$name@$size";
        return self::$cache[$key] ??= new Font($name, $size);
    }
}

常见误区

  • 把可变资源当享元共享:多请求改同一实例导致串数据。
  • 把缓存当连接池:缓存不管理资源占用与归还。
  • 用对象池复用无状态轻量对象:无状态对象直接创建即可,池化反而增加管理成本。

追问

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

01.3.2.7-009 Java Integer.valueOf 缓存与 String 常量池怎么体现享元?

一句话结论

Integer.valueOf(int) 对 -128 到 127 之间的值返回缓存实例;字符串字面量在常量池中共享——两者都是 JDK 内部的享元实现,共享的是不可变对象。

概念解释

  • Integer.valueOf:内部维护 IntegerCache,对小范围数值返回同一实例。
  • String 常量池:编译期字符串字面量在运行期共享同一 String 对象。
  • 共同特征:内部状态(数值、字符序列)不可变,可安全共享。
  • 注意:new Integer(1) 不会走缓存,new String("a") 也不会入常量池。

原理流程

  1. 调用 Integer.valueOf(100) 时,先查缓存。
  2. 命中则返回既有实例,未命中才新建。
  3. 字符串字面量在类加载时进入常量池,相同字面量共享。
  4. 因为 Integer 与 String 都不可变,共享安全。

代码或图示

Integer a = Integer.valueOf(100);
Integer b = Integer.valueOf(100);
System.out.println(a == b); // true(命中缓存)

Integer c = Integer.valueOf(1000);
Integer d = Integer.valueOf(1000);
System.out.println(c == d); // false(超出缓存范围)

String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2); // true(常量池共享)

常见误区

  • 用 == 比较 Integer:超出缓存范围时 == 返回 false,应用 equals。
  • 认为 new Integer(1) 走缓存:new 永远新建对象,不走缓存。
  • 认为 String 常量池是「字符串池化」:它是享元思想,共享不可变对象,不是连接池。

追问

  • IntegerCache 上限可调吗?答:可通过 -XX:AutoBoxCacheMax 调整 high 端(具体以所用 JDK 版本为准,待确认),low 端固定为 -128。
  • 字符串 intern() 是什么?答:手动把字符串放入常量池,返回共享引用;滥用会导致常量池膨胀。

01.3.2.7-010 Go 的 sync.Pool 为什么不是享元?

一句话结论

sync.Pool 复用的是「可变对象实例」(如缓冲区),使用后需重置,且会被 GC 随时清理;享元共享的是「不可变内部状态」,生命周期长且不会被回收。两者复用内容完全不同。

概念解释

  • sync.Pool:临时对象池,复用分配成本高但状态可重置的对象(如 []byte、http.Request)。
  • 享元:共享不可变对象,外部状态传入,不重置。
  • GC 行为:sync.Pool 在 GC 时会清空,享元不会被清理。
  • 用途:sync.Pool 降低 GC 压力,享元减少对象数量。

原理流程

  1. 从 Pool.Get() 取对象。
  2. 使用后 Put() 归还,归还前重置状态。
  3. GC 触发时 Pool 中的对象可能被回收。
  4. 享元对象按 key 长期缓存,不归还、不重置。

代码或图示

var bufPool = sync.Pool{
    New: func() any {
        b := make([]byte, 0, 4096)
        return &b
    },
}

func handle() {
    buf := bufPool.Get().(*[]byte)
    defer func() {
        *buf = (*buf)[:0] // 重置长度,保留容量
        bufPool.Put(buf)
    }()
    // 使用 buf ...
}
sync.Pool:可变对象借出归还,GC 可回收,降低分配开销
享元:     不可变对象按 key 共享,长期存在,减少对象数量

常见误区

  • 把 sync.Pool 当「长期缓存」:GC 会清空 Pool,不能用来存需要长期存在的对象。
  • 从 Pool 取出对象不重置:上一次使用的残留数据会被下一次读到,串数据。
  • 用 Pool 复用有业务状态的对象:Pool 只适合无业务语义的可变资源(缓冲区)。

追问

  • sync.Pool 适合存连接吗?答:不适合,连接有状态且需长期管理,应用连接池(如 database/sql)。
  • Go 的 http.Request 为什么用 Pool?答:Request 对象分配频繁且可重置,Pool 降低 GC 压力,这是典型的对象池思路而非享元。

01.3.2.7-011 前端虚拟列表如何体现享元思想?

一句话结论

虚拟列表只渲染可视区域内的 DOM 节点,滚动时复用同一批 DOM 元素、更新内容(外部状态),而不是为每条数据新建 DOM;这正是「共享内部结构、传入外部状态」的享元思想。

概念解释

  • 内部状态:DOM 元素结构(如一个 <div class="row">)。
  • 外部状态:行数据、位置、样式。
  • 复用:滚动时创建/回收 DOM 节点,不随数据量增长。
  • 收益:万级数据列表仍只渲染几十个 DOM,避免 DOM 节点爆炸。

原理流程

  1. 固定可视区域高度,计算可视数据范围。
  2. 只渲染可视范围内的行 DOM。
  3. 滚动时回收离开可视区的 DOM,复用给新进入的行。
  4. 更新复用 DOM 的内容与位置(外部状态)。

代码或图示

// 简化的虚拟列表思路
function renderVirtualList(items: Item[], container: HTMLElement) {
  const rowHeight = 40;
  const visibleCount = Math.ceil(container.clientHeight / rowHeight);
  const startIndex = Math.floor(container.scrollTop / rowHeight);

  // 只渲染可视区域的行
  for (let i = startIndex; i < startIndex + visibleCount; i++) {
    const row = getOrCreateRow(i); // 复用 DOM
    row.textContent = items[i].text; // 外部状态:内容
    row.style.transform = `translateY(${i * rowHeight}px)`; // 外部状态:位置
  }
}
享元:DOM 结构共享(内部状态),行数据/位置作为外部状态传入
对象池:复用 DOM 节点,离开可视区后归还

常见误区

  • 把所有数据都渲染成 DOM:万级数据会导致 DOM 节点爆炸,页面卡顿。
  • 复用 DOM 时不重置内容:上一行的残留内容会闪现。
  • 把虚拟列表当「缓存」:它是 DOM 复用,不是数据缓存。

追问

  • 虚拟列表和窗口化(windowing)是一回事吗?答:是,虚拟列表也叫窗口化渲染,核心是只渲染可视窗口。
  • 变长行高怎么处理?答:需要动态测量每行高度,或用预估高度 + 滚动校正,复杂度上升。

01.3.2.7-012 Facade / Composite / Bridge / Flyweight 四者怎么组合使用?

一句话结论

四者解决不同问题,经常在同一系统中组合:Facade 对外提供入口,Composite 组织树形数据,Bridge 解耦多维度,Flyweight 优化大量细粒度对象;但不要为「组合而组合」。

概念解释

  • Facade:对外简化入口,与其他模式正交。
  • Composite:组织树结构,与 Flyweight 可组合(树节点共享样式享元)。
  • Bridge:解耦维度,与 Strategy 常组合。
  • Flyweight:优化内存,与 Composite 可组合(大量节点共享样式)。

原理流程

  1. 先识别系统中的真实问题:子系统复杂?树形?多维?大量细粒度对象?
  2. 按问题选对应模式,不要预设要「用齐四个」。
  3. 组合时每层只承担一个职责,包装层级可解释。

代码或图示

外部调用方 ──> Facade(订单门面)
                ├─ Composite(菜单树/组织树)
                │    └─ Flyweight(共享字体/样式)
                └─ Bridge(通知类型 × 发送渠道)
                     └─ Strategy(具体发送算法)

常见误区

  • 把四个模式都塞进一个模块:每层包装只透传不做实事,导致代码难以理解。
  • 模式之间互相嵌套超过三层:说明职责划分有问题。
  • 为「设计模式齐全」而引入模式:没有真实问题就不要加。

追问

  • 一个文档编辑器怎么组合?答:Composite 组织文档树,Flyweight 共享字符格式,Facade 提供「打开/保存/打印」入口,Bridge 处理导出格式(PDF/HTML)。
  • 怎么判断组合是否过度?答:调用一个方法要追五六层透传才到业务,说明结构冗余。

01.3.2.7-013 「为组合而组合」的误用有哪些信号?

一句话结论

到处是 Adapter / Facade / Composite 但没有真实问题、每层包装只透传、新功能要改一堆模式类、新人读代码要追五层才到业务——这些都是过度设计的信号,应回归简单方案。

概念解释

  • 信号一:没有真实接口差距却写 Adapter。
  • 信号二:没有复杂子系统却写 Facade。
  • 信号三:没有树形结构却引入 Composite。
  • 信号四:两个维度都固定却上 Bridge。
  • 信号五:对象数量不大却做 Flyweight。

原理流程

  1. 先问:这个模式解决的真实问题是什么?
  2. 如果回答是「为了符合设计模式」,删掉。
  3. 优先用简单方案(直接调用、函数、普通类),遇到真实问题再引入模式。
  4. 模式是重构工具,不是设计目标。

代码或图示

反例:
  BusinessService → OrderFacade → OrderAdapter → OrderRepository
  每层只透传,没有真实转换/简化/控制

正例:
  BusinessService → OrderRepository(直接调用)
  只有当子系统真的复杂、接口真的不匹配时,才引入对应模式

常见误区

  • 认为「用了设计模式就是好架构」:模式是手段,不是目的。
  • 在 CRUD 业务里强行套模式:CRUD 用普通三层结构足够。
  • 过度设计后难以维护:新人读代码成本高,修改一个功能要改多个模式类。

追问

  • 怎么判断「刚好够用」?答:没有模式时代码能清晰表达业务;只有出现真实的接口差距、复杂度、树形结构、多维变化时,才引入对应模式。
  • 重构时什么时候引入模式?答:先写最简单的代码,当出现重复、扩展困难、层级混乱时,再用模式重构;不要预先设计。

跨语言差异对照

语言 惯用实现 差异要点
Java Facade 用普通类;Composite 用接口 + 容器列表;Bridge 用抽象类持有实现接口;Flyweight 用 ConcurrentHashMap 缓存 JDK 自带享元实例(Integer 缓存、String 常量池);Composite 最常用,Bridge 较少用
Go Facade 用包级函数;Composite 用 interface + 递归;Bridge 用接口组合;Flyweight 用 sync.Map 缓存 无继承,Bridge 只能靠接口组合;sync.Pool 是对象池不是享元
Python Facade 用类或模块;Composite 用鸭子类型;Flyweight 用字典缓存 动态语言,Composite 不需要显式接口;__slots__ 可优化内存
PHP Facade 在 Laravel 中是静态代理;Composite 用接口;Flyweight 用静态数组缓存 Laravel Facade 容易被误认成外观模式;FPM 生命周期下享元缓存不跨请求
C# Facade 用 DI 注入的服务;Composite 用接口;Flyweight 用 ConcurrentDictionary;HttpClient 用 AddHttpClient 包装 依赖注入容器让 Facade 与适配器更自然;ArrayPool&lt;T&gt; 是对象池不是享元
TypeScript Facade 用类;Composite 用 interface + 递归;Flyweight 用于虚拟列表 DOM 复用 前端 Composite 体现在组件树;虚拟列表是享元思想的典型工程落地
Rust Facade 用结构体;Composite 用 trait + Vec&lt;Box&lt;dyn Trait&gt;&gt;;Flyweight 用 HashMap 缓存 编译期静态分发优先,dyn Trait 用于运行时多态;Rc/Arc 管理共享

跨语言差异

  • Java 是唯一系统讨论「类适配器 vs 对象适配器」的语言,也是 JDK 自带享元实例最多的语言(Integer 缓存、String 常量池、Boolean 缓存)。
  • Go 没有继承,Bridge 只能靠接口组合;sync.Pool 是对象池而非享元,这是 Go 特有的并发原语与享元的区别。
  • Rust 用 trait 与 dyn Trait 实现 Composite 与 Bridge,编译期静态分发优先,运行时多态有成本。
  • TypeScript 的 Composite 体现在前端组件树与虚拟列表,Flyweight 体现在 DOM 节点复用。
  • PHP 的 Laravel Facade 是静态代理,不是 GoF 的外观模式,这是 PHP 特有的框架语义。
  • Python 的动态类型让 Composite 不需要显式接口,鸭子类型即可。
  • 所有语言的共同结论:模式是解决真实问题的工具,不是设计目标;过度设计比不设计更难维护。

待整理清单

  • [ ] 补充 Kotlin sealed class 对 Composite 模式的类型安全优化
  • [ ] 补充 Rust dyn Trait 与泛型在 Composite / Bridge 中的取舍
  • [ ] 补充 React / Vue 虚拟列表的具体实现库(react-window、vue-virtual-scroller)对照
  • [ ] 补充 Flutter RenderObject 树中的 Composite 与 Flyweight 思想