[设计模式] 设计模式课程（十一）-- 享元模式（Flyweight）

概述

• 缓存、Cache、Flyweight
• 属于结构型模式
• 不在每个对象中保存所有数据，而是共享多个对象所共有的相同状态，实现在有限的内存中载入更多的对象
• 在软件系统采用纯粹对象方案的问题在于大量细粒度的对象会很快充斥在系统中，从而带来很高的运行（内存）代价
• 如何在避免大量细粒度对象问题的同时，让外部客户程序仍然能够透明地使用面向对象的形式操作
• 运用共享技术有效地支持大量细粒度对象
• 举例：绝大部分字符可共用字体对象，不用每个字符创建一个字体对象
• 建立表，按字符查找，有字体返回，没字体创建
• 面向对象解决了抽象性问题，但作为一个在机器中的运行实体，需要考虑对象的代价问题
• 注意内部状态和外部状态的划分，否则可能会引起线程安全问题
• 所有类必须有一个工厂对象加以控制
• Flyweight采用对象共享的做法来降低系统中的对象个数，从而降低细粒度对象给系统带来的内存压力，在具体实现方面，要注意对象状态的处理
• 拿到对象先用一下sizeof()，看看它有多大
• 首先评估，如一个对象40k，10w个4M，再决定是否用

场景

• 游戏中，玩家在地图上移动并相互射击，每个子弹都是一个独立对象，战况激烈时，过多的子弹对象导致内存崩溃。每个子弹的颜色、大小等一样且保持不变（内在状态），位置、速度等不一样且不断变化（外在状态）
• 将两种属性分开处理，通过享元对象保存内在状态，而将外在状态传递给依赖于享元对象的一个特殊方法，内在状态只能读取，不能修改，外在状态可以从外部修改
• Game类中的数组容器存储外在对象和享元对象的引用
• 虽然子弹对象的总数是不变的，但占用的空间要小得多
• Java中的String，如果有则返回，没有则创建一个字符串保存在字符串缓存池中
• 数据库的数据池

结构

• 享元类（Flyweight）：存储能在多个对象中共享的状态，享元中存储内在状态，传递给享元方法的状态为外在状态
• 情境类（Context）：包含原始对象中各不相同的外在状态，与享元对象组合在一起表示原始对象的全部状态
• 客户端（Client）：计算或存储享元的外在状态
• 享元工厂（FlyweightFactory）：管理已有享元的缓存池，客户端无需直接创建享元，而是通过调用工厂并向其传递目标享元的一些内在状态，工厂根据参数查找已有的享元，如有则将其返回，没有则创建新享元

示例1

Flyweight.cpp

class Font {
private:

    //unique object key
    string key;
    
    //object state
    //....
    
public:
    Font(const string& key){
        //...
    }
};

class FontFactory{
private:
    map<string,Font* > fontPool;
    
public:
    Font* GetFont(const string& key){

        map<string,Font*>::iterator item=fontPool.find(key);
        
        if(item!=footPool.end()){
            return fontPool[key];
        }
        else{
            Font* font = new Font(key);
            fontPool[key]= font;
            return font;
        }

    }
    
    void clear(){
        //...
    }
};

示例2 

// 享元类包含一个树的部分状态。这些成员变量保存的数值对于特定树而言是唯一
// 的。例如，你在这里找不到树的坐标。但这里有很多树木之间所共有的纹理和颜
// 色。由于这些数据的体积通常非常大，所以如果让每棵树都其进行保存的话将耗
// 费大量内存。因此，我们可将纹理、颜色和其他重复数据导出到一个单独的对象
// 中，然后让众多的单个树对象去引用它。
class TreeType is
    field name
    field color
    field texture
    constructor TreeType(name, color, texture) { ... }
    method draw(canvas, x, y) is
        // 1. 创建特定类型、颜色和纹理的位图。
        // 2. 在画布坐标 (X,Y) 处绘制位图。

// 享元工厂决定是否复用已有享元或者创建一个新的对象。
class TreeFactory is
    static field treeTypes: collection of tree types
    static method getTreeType(name, color, texture) is
        type = treeTypes.find(name, color, texture)
        if (type == null)
            type = new TreeType(name, color, texture)
            treeTypes.add(type)
        return type

// 情景对象包含树状态的外在部分。程序中可以创建数十亿个此类对象，因为它们
// 体积很小：仅有两个整型坐标和一个引用成员变量。
class Tree is
    field x,y
    field type: TreeType
    constructor Tree(x, y, type) { ... }
    method draw(canvas) is
        type.draw(canvas, this.x, this.y)

// 森林（Forest）类是享元的客户端。
class Forest is
    field trees: collection of Trees

    method plantTree(x, y, name, color, texture) is
        type = TreeFactory.getTreeType(name, color, texture)
        tree = new Tree(x, y, type)
        trees.add(tree)

    method draw(canvas) is
        foreach (tree in trees) do
            tree.draw(canvas)

示例3

import java.util.HashMap;

public interface Shape {
    void draw();
}

public class Circle implements Shape{
    private String color;
    private int x;
    private int y;
    private int radius;
    
    public Circle(String color) {
        this.color = color;
    }
    
    public void setX(int x) {
        this.x = x;
    }
    
    public void setY(int y) {
        this.y = y;
    }
    
    public void setRadius(int radius) {
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("Circle : Draw() [Color : " + color + " , x : " 
                + x + ", y : " + y + ", radius : " + radius + "]");
        
    }
}

public class ShapeFactory {
    private static final HashMap<String, Shape> circleMap = new HashMap();
    public static Shape getCircle(String color) {
        Circle circle = (Circle)circleMap.get(color);
        if(circle == null) {
            circle = new Circle(color);
            circleMap.put(color, circle);
            System.out.println("Creating circle of color : " + color );
        }
        return circle;
    }
}

public class FlyweightPatternDemo {

    private static final String colors[] = {"Red","Green","Blue","White","Black"};
    public static void main(String[] args) {
        for(int i = 0 ; i < 20 ; ++ i ) {
            Circle circle = (Circle)ShapeFactory.getCircle(getRandomColor());
            circle.setX(getRandomX());
            circle.setY(getRandomY());
            circle.setRadius(100);
            circle.draw();
        }
    }
    private static String getRandomColor() {
        return colors[(int)(Math.random()*colors.length)];
    }
    private static int getRandomX() {
        return (int)(Math.random()*100);
    }
    private static int getRandomY() {
        return (int)(Math.random()*100);
    }
}

参考

https://refactoringguru.cn/design-patterns/flyweight