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

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

<!-- more -->

概述

两种结构状态

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

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

结构图

存在的角色

• 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]\n", type, name);
    }

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

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

class FlyweightFactory {
    private static final Map<String, Flyweight> 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]\n", fw0 == fw1);
        System.out.printf("[结果(内在状态)] - [%s]\n", fw1.getType());
        System.out.printf("一共召唤 %s 种类型英雄\n", FlyweightFactory.total());
    }
}

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

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

JDK中使用

在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（欢迎调戏）