【设计模式】享元模式 实现 ( 实现流程 | 抽象享元类 | 具体享元类 | 享元工厂 | 用户调用 | 代码模板 )

I . 享元模式 实现流程

---

1 . 定义抽象享元类 : 定义抽象类 , 内部状态 , 外部状态 , 抽象方法 ;

① 抽象类 : 该类是一个 抽象类 , 在 享元工厂类 和 用户调用 中 , 涉及的对象类型就声明为该 抽象类型 , 一般不直接使用具体的实现类 ;

② 定义内部状态 : 内部状态数据是多个 细粒度对象 ( 用户实际使用的一万个对象 ) 共享的信息 , 共享就是在对象池中的维护一个享元对象 ( 共享对象 ) , 当多个 细粒度对象 从 享元工厂类 中获取该享元对象时 , 获取的都是该享元对象 ( 共享对象 ) , 这些细粒度对象 ( 用户使用的对象 ) 使用的内部状态 ( 数据 ) 肯定都是一样的 ; 定义时不用太关心该状态 , 区分内部状态与外部状态即可 ;

③ 定义外部状态 : 该状态很重要 , 该信息作为从对象池中获取对象的依据 ; 即外部状态相等的两个对象 , 说明对象是相同的 ;

④ 定义抽象行为 : 享元类实际的操作 , 此处是抽象方法 , 也是最终用户调用该享元类调用的方法 ;

2 . 定义具体享元类 : 继承抽象享元类 , 实现抽象享元类的抽象方法 ;

① 继承 : 该类继承 抽象的享元类 , 可以定义多个具体享元类 ;

② 使用 : 声明享元类对象时 , 声明抽象享元类类型 , 实际为该对象赋值时 , 需要赋值具体的享元类 ;

③ 对象池对象 : 享元工厂类中的对象池 , 可以存储不同的具体享元类对象 , 但必须都是抽象享元类的子类对象 ;

3 . 定义享元工厂类 :

① 定义对象池 : 对象池一般是 Map 键值对类型 , 使用 抽象享元类对象的 外部状态 数据作为键 , 值就是 享元类对象 ;

② 对象获取机制 : 当用户根据 外部状态 获取享元类对象时 , 先在对象池中查找是否存在该享元对象 , 如果存在直接返回该对象 , 如果不存在 , 那么创建该对象 , 将新创建的对象放入对象池中 , 并返回该享元对象 ;

4 . 用户调用 : 用户使用 享元工厂类 创建 抽象享元类 类型对象 , 并为其赋值一个 具体的享元类 对象 , 调用 抽象的方法 ;

II . 享元模式 抽象享元类

---

1 . 定义 抽象享元类 AbstractFlyweight :

① 定义内部状态 : private String intrinsicState是内部状态 , 也就是多个 细粒度对象 ( 用户持有的多个对象 ) 共享的信息 , 这部分内容我们不关心 , 为其设置 Getter 和 Setter 方法即可 ;

② 定义外部状态 : protected final String externalState , 外部状态推荐使用 final 修饰 , 这是为了避免其在构造函数外的地方修改该值 , 外部状态值只能在对象创建的时候赋值一次 , 其它任何时候都不允许修改该值 ;

③ 定义抽象行为 : abstract void action() , 这是享元类的具体逻辑 , 在具体享元角色中实现该类 ;

2 . 抽象享元类 代码示例 :

package kim.hsl.design.flyweight;

/**
 * 抽象的享元角色
 */
public abstract class AbstractFlyweight {
    /**
     * 内部状态
     */
    private String intrinsicState;

    /**
     * 外部状态
     * 注意使用 final 修饰只能 ① 马上初始化 ② 在构造函数中初始化
     * 没有其它的初始化途径
     */
    protected final String externalState;

    public AbstractFlyweight(String externalState) {
        this.externalState = externalState;
    }

    /**
     * 抽象的行为
     */
    abstract void action();

    /*
        下面是访问内部状态的 Getter 和 Setter 方法
     */
    public String getIntrinsicState() {
        return intrinsicState;
    }
    public void setIntrinsicState(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }

    /**
     * 获取外部状态的数据
     * 该数据用于 作为 对比两个对象是否一致 的依据
     * @return
     */
    public String getExternalState() {
        return externalState;
    }
}

III . 享元模式 具体享元类

---

1 . 定义具体享元类 ConcreteFlyweight :

① 继承 : 该类继承 AbstractFlyweight 抽象类 ;

② 重写构造函数 : 抽象类实现类需要重写有参构造函数 ;

③ 实现抽象方法 : 具体的享元类中需要实现 抽象享元类中的 抽象行为 ;

2 . 具体享元类 代码示例 :

package kim.hsl.design.flyweight;

/**
 * 具体的享元角色
 * 注意要实现 抽象方法 , 覆盖其非默认的构造函数
 */
public class ConcreteFlyweight extends AbstractFlyweight {
    public ConcreteFlyweight(String externalState) {
        super(externalState);
    }
    @Override
    void action() {
        System.out.println("享元对象行为 , 外部状态 : " + externalState);
    }
}

IV . 享元模式 享元工厂

---

1 . 定义 享元工厂类 :

① 对象池 : 享元工厂类 中维护一个静态的 HashMap<String, AbstractFlyweight> 数据结构 , 这就是对象池在内存中的数据结构 , 键 String 数据就是 享元类的 外部状态 , 用于作为 享元对象 的 身份标识 , 每个享元对象的该 外部状态值 都不一样 ;

② 从对象池中获取对象 : 从 HashMap<String, AbstractFlyweight> OBJECT_POOL 对象池中获取 AbstractFlyweight 抽象享元类 对象时 , 先检查对象池中是否有该数据 , 如果使用 map.get() 获取的 享元对象不为空 , 说明对象池中有该数据 , 直接返回即可 ; 如果 map.get() 获取的 享元对象为空 , 说明对象池中没有该对象 , 需要创建该对象 , 放入对象池 , 然后返回 ; 注意要使用 外部状态传入构造函数创建对象 ;

2 . 享元工厂类 代码示例 :

package kim.hsl.design.flyweight;

import java.util.HashMap;

/**
 * 享元工厂
 * 维护对象池
 */
public class FlyweightFactory {
    /**
     * 对象池
     * 使用对象时, 从对象池中查找
     * 如果找到直接取出
     * 如果没有找到, 创建一个新对象, 放入对象池中, 然后返回该对象
     * 键 : 外部状态 值 : 享元对象
     */
    private static final HashMap<String, AbstractFlyweight> OBJECT_POOL = new HashMap<String, AbstractFlyweight>();
    public static AbstractFlyweight getObject(String externalState){
        //从对象池中获取对象
        ConcreteFlyweight object = (ConcreteFlyweight) OBJECT_POOL.get(externalState);
        //如果对象池中没有该对象
        if(object == null){
            object = new ConcreteFlyweight(externalState);
            OBJECT_POOL.put(externalState, object);
            System.out.println("创建新对象 外部状态 值 : " + externalState + " , 并放入对象池");
        }else{
            System.out.println("获取对象池中已有的对象 , 外部状态 值 : " + externalState);
        }
        return object;
    }
}

V . 享元模式 用户调用

---

1 . 用户调用 :

① 用户声明对象类型 : 用户声明 AbstractFlyweight 抽象享元类的对象 , 从享元工厂类的对象池中获取对象 ;

② 新建对象 : 如果对象池中没有对象 , 会调用构造函数 , 创建该对象 , 并放入对象池中 , 再返回该对象 ;

② 复用对象 : 如果对象池中有该享元对象 , 那么直接从线程池中获取该对象 , 并返回 ;

2 . 用户调用 代码示例 :

package kim.hsl.design.flyweight;

public class Main {
    /**
     * 注意 : 享元对象使用时, 创建的是抽象的享元类
     * @param args
     */
    public static void main(String[] args) {
        //外部状态值为 "tom" , 对象池中没有该对象, 创建后放入对象池, 然后从对象池中取出使用
        AbstractFlyweight tom = FlyweightFactory.getObject("tom");
        tom.action();

        //外部状态值为 "tom" 的对象之前已经创建过, 直接从对象池中取出使用
        AbstractFlyweight tom2 = FlyweightFactory.getObject("tom");
        tom2.action();

        //外部状态值为 "Jerry" , 对象池中没有该对象, 创建后放入对象池, 然后从对象池中取出使用
        AbstractFlyweight jerry = FlyweightFactory.getObject("Jerry");
        jerry.action();
    }
}