一起学设计模式 - 享元模式

摘要：享元模式属于结构型模式的一种，又称轻量级模式，通过共享技术有效地实现了大量细粒度对象的复用概述两种结构状态内部状态享元对象内部不随外界环境改变而改变的共享部分。

享元模式（Flyweight Pattern）属于结构型模式的一种，又称轻量级模式，通过共享技术有效地实现了大量细粒度对象的复用...

两种结构状态

内部状态：享元对象内部不随外界环境改变而改变的共享部分。

外部状态：享元对象内部随环境的改变而改变，不能够共享的状态就是外部状态。

结构图

存在的角色

Flyweight（抽象享元类）：通常是一个接口或抽象类，向外界提供享元对象的内部数据（内部状态）或外部数据（外部状态）。

ConcreteFlyweight（具体享元类）：实现了Flyweight（抽象享元类）也称为享元对象，指定内部状态，为内部状态增加存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。

UnsharedConcreteFlyweight（非共享具体享元类）：指不需要共享的Flyweight子类。

FlyweightFactory（享元工厂类）：用于创建并管理享元对象，针对抽象享元类编程，将各种类型的具体享元对象存储在一个享元池中，享元池一般设计为键值对的集合（也可以是其他类型的集合），同时可以结合工厂模式进行设计。

享元模式的核心在于享元工厂类，享元工厂类的作用在于提供一个用于存储享元对象的享元池，用户需要对象时，首先从享元池中获取，如果享元池中不存在，则创建一个新的享元对象返回给用户，并在享元池中保存该新增对象。

案例UML图如下：

1.创建Flyweight接口/抽象类

interface Flyweight {
    void operation(String name);

    String getType();
}

2.创建ConcreteFlyweight（享元对象），实现了Flyweight接口

class ConcreteFlyweight implements Flyweight {
    private String type;

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

    @Override
    public void operation(String name) {
        System.out.printf("[类型(内在状态)] - [%s] - [名字(外在状态)] - [%s]
", type, name);
    }

    @Override
    public String getType() {
        return type;
    }
}

3.创建FlyweightFactory（享元工厂类），用来维护享元池

class FlyweightFactory {
    private static final Map FLYWEIGHT_MAP = new HashMap<>();

    public static Flyweight getFlyweight(String type) {
        if (FLYWEIGHT_MAP.containsKey(type)) {
            return FLYWEIGHT_MAP.get(type);
        } else {
            ConcreteFlyweight flyweight = new ConcreteFlyweight(type);
            FLYWEIGHT_MAP.put(type, flyweight);
            return flyweight;
        }
    }

    public static int total() {
        return FLYWEIGHT_MAP.size();
    }
}

4.创建Client（测试类）

public class Client {

    public static void main(String[] args) {
        Flyweight fw0 = FlyweightFactory.getFlyweight("战士");
        Flyweight fw1 = FlyweightFactory.getFlyweight("战士");
        Flyweight fw2 = FlyweightFactory.getFlyweight("法师");
        Flyweight fw3 = FlyweightFactory.getFlyweight("坦克");
        fw1.operation("瑞文");
        fw1.operation("鳄鱼");
        fw2.operation("光辉");
        fw3.operation("泰坦");
        fw3.operation("盖伦");
        System.out.printf("[结果(对象对比)] - [%s]
", fw0 == fw1);
        System.out.printf("[结果(内在状态)] - [%s]
", fw1.getType());
        System.out.printf("一共召唤 %s 种类型英雄
", FlyweightFactory.total());
    }
}

5.运行结果，从结果中可以发现，只生成了3个不同的类

[类型(内在状态)] - [战士] - [名字(外在状态)] - [瑞文]
[类型(内在状态)] - [战士] - [名字(外在状态)] - [鳄鱼]
[类型(内在状态)] - [法师] - [名字(外在状态)] - [光辉]
[类型(内在状态)] - [坦克] - [名字(外在状态)] - [泰坦]
[类型(内在状态)] - [坦克] - [名字(外在状态)] - [盖伦]
[结果(对象对比)] - [true]
[结果(内在状态)] - [战士]
一共召唤 3 种类型英雄

在JAVA语言中，String类型就是使用了享元模式。String对象是final类型，对象一旦创建就不可改变。在JAVA中字符串常量都是存在常量池中的，JAVA会确保一个字符串常量在常量池中只有一个拷贝。

public class Client {
    public static void main(String[] args) {
        String a = "盖伦";
        String b = "盖伦";
        System.out.println(a==b);// 返回 true
    }
}

上面的例子中结果为：true，这就说明a和b两个引用都指向了常量池中的同一个字符串常量。这样设计的目的就是：为了避免在创建多相同对象时，所产生的不必要的资源消耗。

如果程序里使用大量相同或者相似的对象，造成内存的大量耗费，且大多都是外部状态，这时候就应该考虑使用享元模式了，比如围棋、五子棋等小游戏

优点

能够极大的减少系统中对象的个数。

外部状态相对独立，不会影响到内部状态，能够使享元对象在不同的环境被共享。

缺点

由于享元模式需要区分外部状态和内部状态，使得程序在某种程度上来说更加复杂化了。

为了使对象可以共享，享元模式需要将享元对象的状态外部化，而读取外部状态使得运行时间变长。

全文代码：https://gitee.com/battcn/design-pattern/tree/master/Chapter9/battcn-flyweight

个人QQ：1837307557

battcn开源群（适合新手）：391619659

微信公众号：battcn（欢迎调戏）