设计模式——享元设计模式（结构型）

摘要

享元设计模式是一种结构型设计模式，旨在通过共享对象减少内存占用和提升性能。其核心思想是将对象状态分为内部状态（可共享）和外部状态（不可共享），并通过享元工厂管理共享对象池。享元模式包含抽象享元类、具体享元类、非共享具体享元类和享元工厂类。它适用于处理大量相似对象的场景，如文档编辑器中的字符对象。文章还提供了享元模式的实现方式、适合与不适合的使用场景、实战示例以及与其他设计模式的比较。

1. 享元设计模式定义

享元设计模式（Flyweight Pattern） 是一种结构型设计模式，用于减少对象的数量，以节省内存和提高性能。享元模式通过共享内存中已经存在的对象，避免重复创建相同内容的对象，适用于大量相似对象的场景。

1.1.1. 核心思想

把对象状态划分为：

• 内部状态（可共享，存储在享元对象中）
• 外部状态（不可共享，由客户端维护）

享元工厂（FlyweightFactory）: 负责管理共享对象的池，复用已有实例。

1.1.2. 举例说明

假设一个文档编辑器中有 10 万个字符，但字符集就 128 个（ASCII），如果每个字符都是独立对象，将浪费大量内存。此时可以：

• 把字符内容作为内部状态（可共享）
• 把字体、大小、颜色作为外部状态（由外部控制）
• 同一个字符内容只创建一次对象，由享元工厂复用

2. 享元设计模式结构

享元模式包含如下角色：

• Flyweight: 抽象享元类
• ConcreteFlyweight: 具体享元类
• UnsharedConcreteFlyweight: 非共享具体享元类
• FlyweightFactory: 享元工厂类

2.1. 享元设计模式类图

2.2. 享元设计模式时序图

3. 享元设计模式实现方式

享元设计模式的实现方式主要围绕 对象共享池 和 内部状态与外部状态的分离。它通过一个享元工厂（FlyweightFactory）来管理共享对象，避免重复创建，从而节省内存。

3.1. 1️⃣ 定义抽象享元接口（Flyweight）

public interface Flyweight {
    void operation(String externalState); // 外部状态由调用方传入
}

3.2. 2️⃣ 创建具体享元类（ConcreteFlyweight）

public class ConcreteFlyweight implements Flyweight {
    
    private final String intrinsicState; // 内部状态，能共享

    public ConcreteFlyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }

    @Override
    public void operation(String externalState) {
        System.out.println("共享[" + intrinsicState + "]，非共享[" + externalState + "]");
    }
}

3.3. 3️⃣ 创建享元工厂类（FlyweightFactory）

public class FlyweightFactory {
    
    private final Map<String, Flyweight> pool = new HashMap<>();

    public Flyweight getFlyweight(String key) {
        if (!pool.containsKey(key)) {
            pool.put(key, new ConcreteFlyweight(key));
        }
        return pool.get(key);
    }

    public int getPoolSize() {
        return pool.size();
    }
}

3.4. 4️⃣ 客户端调用（Client）

public class Client {
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();

        Flyweight a1 = factory.getFlyweight("A");
        Flyweight a2 = factory.getFlyweight("A"); // 重复，不创建新对象

        a1.operation("外部状态1");
        a2.operation("外部状态2");

        System.out.println("共享对象数量：" + factory.getPoolSize()); // 输出：1
    }
}

3.5. ✅ 享元设计模式总结

4. 享元设计模式适合场景

4.1. ✅ 适合使用享元设计模式的场景

4.2. ❌ 不适合使用享元模式的场景

4.3. 🧠 享元模式的场景总结

5. 享元设计模式实战示例

下面是一个 享元设计模式在金融风控系统中的 Spring 实战示例，场景为：风控规则元数据共享池，用于缓存和复用规则的静态定义，减少重复加载和内存占用。在风控系统中，不同的策略规则经常引用相同的“规则定义”（如规则编号、描述、字段映射等）。这些定义是 不可变 的、重复使用 的，适合使用享元模式来缓存复用。

5.1. ✅ 享元接口：RuleDefinition

public interface RuleDefinition {
    void evaluate(String param);  // 示例行为
}

5.2. ✅ 具体享元类：ConcreteRuleDefinition

public class ConcreteRuleDefinition implements RuleDefinition {

    private final String ruleCode;
    private final String description;

    public ConcreteRuleDefinition(String ruleCode, String description) {
        this.ruleCode = ruleCode;
        this.description = description;
    }

    @Override
    public void evaluate(String param) {
        System.out.println("执行规则 [" + ruleCode + "] - " + description + "，参数：" + param);
    }

    public String getRuleCode() {
        return ruleCode;
    }

    public String getDescription() {
        return description;
    }
}

5.3. ✅ 享元工厂：RuleDefinitionFactory（由 Spring 管理）

@Component
public class RuleDefinitionFactory {

    private final Map<String, RuleDefinition> pool = new ConcurrentHashMap<>();

    /**
     * 获取共享的规则定义
     */
    public RuleDefinition getRule(String ruleCode) {
        return pool.computeIfAbsent(ruleCode, this::loadRuleDefinition);
    }

    /**
     * 模拟从数据库或配置中加载规则元数据
     */
    private RuleDefinition loadRuleDefinition(String ruleCode) {
        // 实际情况应从数据库或配置中心加载
        System.out.println("加载规则定义：" + ruleCode);
        return new ConcreteRuleDefinition(ruleCode, "规则描述_" + ruleCode);
    }

    public int getPoolSize() {
        return pool.size();
    }
}

5.4. ✅ 客户端服务：RiskEngineService（注入使用）

@Service
public class RiskEngineService {

    @Autowired
    private RuleDefinitionFactory ruleDefinitionFactory;

    public void processRisk(String ruleCode, String inputParam) {
        RuleDefinition rule = ruleDefinitionFactory.getRule(ruleCode);
        rule.evaluate(inputParam);
    }
}

5.5. ✅ 启动类或控制器测试（模拟调用）

@RestController
public class RiskController {

    @Autowired
    private RiskEngineService riskEngineService;

    @GetMapping("/risk/test")
    public String test() {
        riskEngineService.processRisk("R001", "用户A数据");
        riskEngineService.processRisk("R001", "用户B数据");
        riskEngineService.processRisk("R002", "用户C数据");
        return "风控规则执行完毕";
    }
}

5.6. ✅ 运行结果示例

加载规则定义：R001
执行规则 [R001] - 规则描述_R001，参数：用户A数据
执行规则 [R001] - 规则描述_R001，参数：用户B数据
加载规则定义：R002
执行规则 [R002] - 规则描述_R002，参数：用户C数据

可见：R001 只加载一次，后续复用；实现了享元模式在 Spring 项目下的实战落地。

6. 享元设计模式思考

6.1. 享元设计模式与原型设计模式？

享元设计模式（Flyweight）和原型设计模式（Prototype）都是创建相关的设计模式，但它们解决的问题、使用方式和结构完全不同。下面是它们的详细对比：

6.1.1. 🆚 Flyweight vs. Prototype

6.1.2. ✅ 简单总结

• 享元模式 = 节省内存、共享对象：适用于大量对象重复的场景。
• 原型模式 = 快速复制、提升性能：适用于快速创建复杂对象的场景。

6.1.3. 📌 举个类比：

博文参考

• 5. 享元模式 — Graphic Design Patterns
• 享元设计模式