结构型模式 - 享元模式

系列文章目录

设计模式 - 设计原则

创建型模式 - 单例模式（一）
创建型模式 - 工厂模式（二）
创建型模式 - 原型模式（三）
创建型模式 - 建造者模式（四）

结构型模式 - 适配器模式（一）
结构型模式 - 桥接模式（二）
结构型模式 - 装饰器模式（三）
结构型模式 - 组合模式（四）
结构型模式 - 外观模式（五）
结构型模式 - 享元模式（六）
结构型模式 - 代理模式（七）

行为型模式 - 模板方法模式（一）
行为型模式 - 命令模式（二）
行为型模式 - 访问者模式（三）
行为型模式 - 迭代器模式（四）
行为型模式 - 观察者模式（五）
行为型模式 - 中介者模式（六）
行为型模式 - 备忘录模式（七）
行为型模式 - 解释器模式（八）
行为型模式 - 状态模式（九）
行为型模式 - 策略模式（十）
行为型模式 - 责任链模式（十一）

---

---

前言

代码地址

---

一、享元模式

1.1 享元模式介绍

• 享元（Flyweight）模式：

• 运用共享技术有效地支持`大量细粒度对象的复用。系统只使用少量对象，而这些对象都很相似，状态变化小，可以实现对象的多次复用；
• 在享元模式中可以共享的相同内容称为内部状态（IntrisicState）, 而那些需要外部环境来设置的不能共享的内容称为外部状态（ExtrinsicState） ，由于区分了内部状态和外部状态，因此可以设置不同的而外部状态使得相同的对象具有不同的特征，而相同的内部状态是可以共享的；
• 在享元模式中通常会出现工厂模式，需要创建一个享元工厂来负责维护一个享元池用于存储相同内部状态的享元对象；
• 享元模式经典的应用场景就是池技术了，String常量池、数据库连接池、缓冲池等等，享元模式是池技术的重要实现方式；

1.2 享元模式结构

• 抽象享元（Flyweight）角色：

• 是所有具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数形式通过方法传入；

• 具体享元（ConcreteFlyweight）角色：

• 实现抽象享元角色中所规定的接口；

• 非享元（UnsharableFlayweight）角色：

• 是不可共享的外部状态，它以参数的形式注入具体享元的相关方法中；

• 享元工厂（FlyweightFactory）角色：

• 负责创建和管理享元角色。当客户创建对象请求一个享元对象时，享元工厂检查系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果 不存在的话，就创建一个新的享元对象；

1.3 享元内部状态、外部状态

• 内部状态：指存储在享元对象内部且不会随环境改变而改变；
• 外部状态：随外部环境变化而变化，不能共享的状态；

二、实现

例子：

• 张三：唉，一天天的加班太累了，生活没啥意思。
• 李四：我曹，兄弟你别想不开，我请你去大宝剑一条龙缓解缓解吧；
• 于是，张三和李四去了家足道店（享元工厂），有很多服务员（抽象享元类）。他们都有姓名，编号等信息，于是张三就点了个美女服务员9527（具体享元类）给他做足疗服务（服务状态为非享元）；

2.1 享元模式实现

package com.dozezz.designpattern.flyweight;

public class ConcreteFlyweight extends AbstractFlyweight {
    //共享的部分，内部状态
    String id;

    //共享的部分，内部状态
    String name;

    public ConcreteFlyweight(String id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public void service() {

        System.out.println(String.format("工号：%s；姓名：%s , 正在为您服务...", id, name));
        //改变外部状态

        this.canService = Boolean.FALSE;

    }

    @Override
    public void endService() {

        System.out.println(String.format("工号：%s；姓名：%s , 服务结束...请给五星好评", id, name));
        //改变外部状态

        this.canService = Boolean.TRUE;

    }
}

package com.dozezz.designpattern.flyweight;

public abstract class AbstractFlyweight {

    Boolean canService = Boolean.TRUE;
    /**
     * 服务中，享元的不可共享属性留给外部进行改变的接口
     */
    public abstract void service( );

    /**
     * 服务完成。享元的不可共享属性留给外部进行改变的接口；
     */
    public abstract void endService( );

    public Boolean isCanService(){
        return canService;
    }

}

package com.dozezz.designpattern.flyweight;

import java.util.HashMap;
import java.util.UUID;

public class FlyweightFactory {

    private static FlyweightFactory flyweightFactory = new FlyweightFactory();

    private FlyweightFactory() {

    }

    public static FlyweightFactory getInstance() {
        return flyweightFactory;
    }

    private static HashMap<String, AbstractFlyweight> pool = new HashMap<>();

    //享元，池子中有对象
    static {
        ConcreteFlyweight waitress =
                new ConcreteFlyweight("1111", "田七");


        ConcreteFlyweight waitress2 =
                new ConcreteFlyweight("9527", "肖九");


        pool.put(waitress.id, waitress);
        pool.put(waitress2.id, waitress2);
    }


    public AbstractFlyweight getFlyweight(String id) {
        AbstractFlyweight flyweight = pool.get(id);
        if (!pool.containsKey(id) || !flyweight.isCanService()) {
            for (AbstractFlyweight abstractFlyweight : pool.values()) {
                if (abstractFlyweight.isCanService()) {
                    return abstractFlyweight;
                }
                return null;
            }
        }

        return pool.get(id);
    }

    public void addFlyweight(AbstractFlyweight abstractFlyweight) {
        pool.put(UUID.randomUUID().toString(), abstractFlyweight);
    }

}

package com.dozezz.designpattern.flyweight;

public class ClientTest {
    public static void main(String[] args) {
        AbstractFlyweight abstractFlyweight = FlyweightFactory.getInstance().getFlyweight("9527");

        abstractFlyweight.service();

        System.out.println(abstractFlyweight);

        AbstractFlyweight abstractFlyweight1 = FlyweightFactory.getInstance().getFlyweight("9527");

        abstractFlyweight1.service();

        System.out.println(abstractFlyweight1);


        AbstractFlyweight abstractFlyweight2 = FlyweightFactory.getInstance().getFlyweight("9527");

        abstractFlyweight2.service();

        System.out.println(abstractFlyweight2);

    }
}

三、享元模式总结

3.1 享元模式使用场景

• 应用程序中使用了大量的对象；
• 大量的对象明显增加了程序的存储运行开销；
• 对象可以提取出内部状态，并且可以分离外部状态；

3. 2 享元模式优缺点

• 应用程序不依赖对象的身份，也就是单纯的使用对用的方法，而不在意对象是否创建而来，否则如果客户端鉴别对象的身份，当他们是同一个对象时将会出现问题；
• 相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力；
• 为了使对象可以共享，需要将一些不能共享的状态外部化，增加程序的复杂性；
• 读取享元模式的外部状态会使得运行时间稍微边长；

3.3 享元模式与原型模式区别

• 享元模式为结构型模式，原型模式为创建型模式；
• 享元模式返回的的享元工厂存储的享元类的对象，返回本体，原型模式返回的是克隆体；

四、参考文献

• http://c.biancheng.net/view/1371.html
• https://www.cnblogs.com/noteless/p/10074969.html
• https://www.bilibili.com/video/BV1G4411c7N4?p=88&spm_id_from=pageDriver