结构型设计模式

基本介绍

享元模式（Flyweight Pattern）也叫蝇量模式，运用共享技术有效地支持大量细粒度对象的复用。常用于系统底层开发，解决系统性能问题。例如数据库连接池，里面都是创建好的连接对象，如果有我们需要的，直接拿来用，避免重新创建，可以解决重复对象对内存造成浪费的问题。

内部状态和外部状态

享元模式提出了细粒度和共享对象，这里就涉及了内部状态和外部状态的概念，即可以把对象的信息分为两个部分：内部状态和外部状态

内部状态（Intrinsic State）：可以共享的相同内容

外部状态（Extrinsic State）：需要外部环境来设置的不能共享的内容

举个栗子，围棋理论上有 361 个位置可以放棋子，每盘棋可能会产生两三百个棋子对象，由于内存有限，一台服务器很难支持更多玩家进行围棋对战，如果用享元模式来处理棋子，将棋子的颜色（黑与白）作为内部状态，棋子的位置（不确定）作为外部状态，就可以将棋子对象减少到两个实例（黑棋、白棋），这样就可以很好的解决内存开销问题。

模式结构

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

举例说明

一个开发团队接了这样的项目，客户希望做一个产品展示网站，但网站需要有多种发布形式，每个用户可以以新闻形式发布、以博客形式发布、以微信公众号形式发布...

「抽象享元类」

public abstract class AbstractWebsite {
    public abstract void publish(User user);
}

「非共享具体享元类」

public class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

「具体享元类」

public class ConcreteWebsite extends AbstractWebsite {
    /**
     * 发布类型
     */
    private String type = "";

    public ConcreteWebsite(String type) {
        this.type = type;
    }

    /**
     * 发布
     */
    @Override
    public void publish(User user) {
        System.out.println("用户「"+user.getName()+"」发布的网站形式为「" + type+"」");
    }
}

「享元工厂类」

public class WebsiteFactory {

    /**
     * 以 HashMap 作为对象池
     */
    private Map<String, ConcreteWebsite> pool = new HashMap<>();

    /**
     * 从对象池中返回指定类型的对象，没有则创建
     */
    public AbstractWebsite getWebsite(String type) {
        if (!pool.containsKey(type)) {
            pool.put(type, new ConcreteWebsite(type));
        }
        return pool.get(type);
    }

    /**
     * 计算对象池中对象的个数
     */
    public int count() {
        return pool.size();
    }
}

「测试类」

public class Client {
    @Test
    public void test(){
        WebsiteFactory factory = new WebsiteFactory();

        AbstractWebsite website1 = factory.getWebsite("新闻");
        website1.publish(new User("张三"));
        website1.publish(new User("李四"));

        AbstractWebsite website2 = factory.getWebsite("博客");
        website2.publish(new User("王五"));
        website2.publish(new User("赵六"));

        AbstractWebsite website3 = factory.getWebsite("公众号");
        website3.publish(new User("陈七"));
        website3.publish(new User("胡八"));

        System.out.println("对象的个数：" + factory.count());
    }
}

「运行结果」

用户「张三」发布的网站形式为「新闻」
用户「李四」发布的网站形式为「新闻」
用户「王五」发布的网站形式为「博客」
用户「赵六」发布的网站形式为「博客」
用户「陈七」发布的网站形式为「公众号」
用户「胡八」发布的网站形式为「公众号」
对象的个数：3

享元模式在Integer中的应用

首先我们看一段代码，运行结果是什么？

public class IntegerSource {
    public static void main(String[] args) {
        Integer v1 = 127;
        Integer v2 = 127;
        System.out.println("v1等于v2？ " + (v1 == v2));
        Integer v3 = 128;
        Integer v4 = 128;
        System.out.println("v3等于v4？ " + (v3 == v4));
    }
}

答案

v1等于v2？ true
v3等于v4？ false

分析：查看 Integer 源码，找到 valueOf 方法，可以看到，如果 i 在某个范围内，就不会产生新的对象，直接从缓存数组中获取，点进 IntegerCache 里就会发现 low = -128 high = 127，因此，我们可以理解为这个数组就是「内部状态」

public static Integer valueOf(int i) {
    //low = -128 , high = 127
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        //IntegerCache.cache是一个常量数组：static final Integer cache[];
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

模式分析

优点：

• 可以极大减少内存中对象的数量，使得相同对象或相似对象在内存中只保存一份。

• 享元模式的外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享。

缺点：

• 享元模式使得系统更加复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化。
• 为了使对象可以共享，享元模式需要将享元对象的状态外部化，而读取外部状态使得运行时间变长。

适用场景：

• 一个系统有大量相同或者相似的对象，由于这类对象的大量使用，造成内存的大量耗费。

• 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。

• 使用享元模式需要维护一个存储享元对象的享元池，而这需要耗费资源，因此，应当在多次重复使用享元对象时才值得使用享元模式。