二十、Flyweight模式 —— 共享对象、避免浪费

Author：Gorit
Date：2021年11月26日
Refer：《图解设计模式》

20.1 Flyweight 模式

“Flyweight” 是“轻量级”的意思，指的是拳击比赛中选手体重最轻等级。所以，该设计模式的作用是为了让对象变“轻”。

在计算机中，“对象”是抽象的东西，它所用的“重量”是指在计算机中的所使用的内存大小。

Java 中，我们通过 new 关键字来生成对象，但是如果一次性生成太多对象，计算机可能就会内存不足，而负担不起。

关于 Flyweight 模式，就是“通过尽量共享实例来避免 new 实例”

因此，尽可能使用已存在的内存实例

20.2 示例程序

模拟数据：（太长就懒得手敲了）

我们会写程序，来读取这些文件

BigChar

package Flyweight;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
 * @Author Gorit
 * @Date 2021/11/26
 **/
public class BigChar {
    // 字符名字
    private char charname;
    // 大型字符串对应字符串（由 # . \n）组成
    private String fontData;
    public BigChar(char charname) {
        this.charname = charname;
        try {
            BufferedReader reader = new BufferedReader(
                    new FileReader("big" + charname + ".txt")
            );
            String line;
            StringBuffer buf = new StringBuffer();
            while ((line = reader.readLine()) != null) {
                buf.append(line);
                buf.append("\n");
            }
            reader.close();
            this.fontData = buf.toString();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    // 显示大型字符
    public void print () {
        System.out.println(fontData);
    }
}

BigCharFactory

package Flyweight;
import java.util.HashMap;
/**
 * @Author Gorit
 * @Date 2021/11/26
 **/
public class BigCharFactory {
    // 管理已经生成的 BigChar 实例
    private HashMap pool = new HashMap(16);
    // Singleton 模式
    private static BigCharFactory singleton = new BigCharFactory();
    public BigCharFactory() {
    }
    // 获取唯一实例
    public static BigCharFactory getInstance() {
        return singleton;
    }
    // 生成（共享）BigChar 实例 （使用 synchronized 保证在多线程中原子性）
    public synchronized BigChar getBigChar(char charname) {
        BigChar br = (BigChar) pool.get("" + charname);
        if (br == null) {
            br = new BigChar(charname);     // 生成 BigChar 实例
            pool.put("" + charname, br);
        }
        return br;
    }
}

BigString

package Flyweight;
import java.util.HashMap;
/**
 * @Author Gorit
 * @Date 2021/11/26
 **/
public class BigCharFactory {
    // 管理已经生成的 BigChar 实例
    private HashMap pool = new HashMap(16);
    // Singleton 模式
    private static BigCharFactory singleton = new BigCharFactory();
    public BigCharFactory() {
    }
    // 获取唯一实例
    public static BigCharFactory getInstance() {
        return singleton;
    }
    // 生成（共享）BigChar 实例 （使用 synchronized 保证在多线程中原子性）
    public synchronized BigChar getBigChar(char charname) {
        BigChar br = (BigChar) pool.get("" + charname);
        if (br == null) {
            br = new BigChar(charname);     // 生成 BigChar 实例
            pool.put("" + charname, br);
        }
        return br;
    }
}

Main

package Flyweight;
import java.util.Scanner;
/**
 * @Author Gorit
 * @Date 2021/11/27
 **/
public class Main {
    public static void main(String[] args) {
//        if (args.length == 0) {
//            System.out.println("Usage: java Main digits");
//            System.out.println("Example: java Main 123123");
//            System.exit(0);
//        }
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要打印的字符数字：（比如 123131）");
        String nums = sc.next();
        BigString bs = new BigString(nums);
        bs.print();
    }
}

怎么实现共享呢？

比如我们输入 123123，打印过一次 1 之后，1 就会被存进 HashMap，当再次需要时，如果存在，就直接使用，因此就不会创建实例了

20.3 Flyweight 中登场的角色

一、Flyweight（轻量级）

减少类的代码数量，Flyweight 表示的就是实例会被共享的类

二、FlyweightFactory（轻量级工厂）

前面学过 Factory 模式，FlyweightFactory 就是生产 Flyweight 实例的工厂，同时实现共享实例

四、Client（请求者）

Client 角色 使用 FlyweightFactory 生成的 Flyweight 实例，由 BigString 扮演此角色

20.4 相关设计模式

一、Proxy 模式

如果生成实例处理的时间比较长，那么使用 Flyweight 模式可以提高程序处理的速度

而 Proxy 模式则是通过设置代理提高程序的处理速度

二、Composite 模式

有时可以使用 Flyweight 模式共享 Composite 模式中的 Leaf 角色

三、Singleton 模式

FlyweightFactory 角色有时会使用 Singleton 模式