设计模式 _第十六招式_享元模式

ゝ一世哀愁。 2023-08-17 16:25 72阅读 0赞

## 一、定义 ##

享元模式（Flyweight Pattern）是池技术的重要实现方式其定义如下：使用共享对象可以有效地支持大量的细粒度的对象。

享元模式的定义为我们提出列两个要求：细粒度对象和共享对象。我们知道分配太多的对象到应用程序中将有损程序的性能，同时还容易造成内存溢出，那怎么规避呢 ？就是享元模式提供的共享技术。

要求细粒度对象，则会导致对象的数量多且属性都非常相似，为了抽取相同的属性， 可以将对象内容分为两个部分：内部状态（instrinsic）与外部状态（extrinsic）。

*  内部状态  
    内部状态是对象可共享出来的信息。存储在享元对象内部并且不会随着环境改变而改变，他们可以作为一个对象的动态附件信息， 不直接保存在对象内部，如一个学生类中的 所属学校信息等。
 *  外部状态  
    外部状态是对象依赖的一些属性，是随环境改变而改变的、不可以共享的状态，如一个用户类的 创建时间、姓名等。

## 二、代码演示 ##

### 2.1 通用类图 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTE4MTQ5_size_16_color_FFFFFF_t_70]

### 2.2 角色说明 ###

*  Flyweight–抽象享元角色  
    简单说是一个产品的抽象类，同时定义了对象的外部状态和内部状态的接口或实现。  
    \-ConcreteFlyweight–具体享元角色  
    具体的一个产品类，该类中内部状态处理应该与环境无关，不应该出现一个操作改变了内部状态，同时修改了外部状态。
 *  unsharedConcreteFlyweight–不可共享的享元角色  
    不存在外部状态或线程安全不能够用共享技术的对象，该对象一般不会出现在享元工厂中。
 *  FlyweightFactory–享元工厂  
    职责非常简单，就是构建一个池容器，同时提供从池中获取对象的方法。

### 2.3 抽象享元角色 ###

抽象享元角色一般为抽象类，在实际项目中，一般是一个实现类，它是描述一类事物的方法。抽象角色中，一般需要把外部状态和内部状态定义出来，避免子类的随意扩展。

package com.design.flyweiht.pattern;
    
    /**
     * @description 抽象享元对象
     * @date: 2019/9/28 17:24
     * @version: v 0.1
     */
    public abstract class Flyweight {
        //内部状态
        private String intrinsic;
        //外部状态
        protected final String extrinsic;
    
        public Flyweight(String _extrinsic) {
            this.extrinsic = _extrinsic;
        }
    
        //定义业务操作
        public abstract void operate();
    
        public String getIntrinsic() {
            return intrinsic;
        }
    
        public void setIntrinsic(String intrinsic) {
            this.intrinsic = intrinsic;
        }
    
        public String getExtrinsic() {
            return extrinsic;
        }
    }

### 2.4 具体享元角色 ###

实现自己的业务逻辑，然后接收外部状态，以便内部业务逻辑对外部状态的依赖。

package com.design.flyweiht.pattern;
    
    /**
     * @description 具体享元对象
     * @date: 2019/9/28 17:31
     * @version: v 0.1
     */
    public class ConcreteFlyweight1 extends Flyweight {
        public ConcreteFlyweight1(String _extrinsic) {
            super(_extrinsic);
        }
    
        @Override
        public void operate() {
            System.out.println("ConcreteFlyweight1 operate");
        }
    }

### 2.5 享元工厂 ###

package com.design.flyweiht.pattern;
    
    import java.util.HashMap;
    
    /**
     * @description 享元工厂
     * @date: 2019/9/28 17:47
     * @version: v 0.1
     */
    public class FlyweightFactory {
        //定义一个容器
        private static HashMap<String, Flyweight> pool = new HashMap<String, Flyweight>();
    
        public static Flyweight getFlyweight(String extriansic) {
            //返回需要的对象
            Flyweight flyweight = null;
            if (pool.containsKey(extriansic)) {
                flyweight = pool.get(extriansic);
                System.out.println("FlyweightFactory  :" + extriansic + ":  come from pool");
            } else {
                //根据外部状态创建享元对象
                flyweight = new ConcreteFlyweight1(extriansic);
                //放到池中
                pool.put(extriansic, flyweight);
                System.out.println("FlyweightFactory  :" + extriansic + ":  not come from pool");
            }
            return flyweight;
        }
    }

### 2.6 验证场景类 ###

package com.design.flyweiht.pattern;
    
    /**
     * @description TODO
     * @date: 2019/9/28 17:57
     * @version: v 0.1
     */
    public class Client {
        public  static  void  main(String args[]){
            String extriansic= "tester";
            Flyweight  flyweight1 = FlyweightFactory.getFlyweight(extriansic);
            flyweight1.operate();
            Flyweight  flyweight2 = FlyweightFactory.getFlyweight(extriansic);
            flyweight2.operate();
        }
    }

### 2.7 运行结果 ###

FlyweightFactory  :tester:  not come from pool
    ConcreteFlyweight1 operate
    FlyweightFactory  :tester:  come from pool
    ConcreteFlyweight1 operate

## 三、优点 ##

享元模式是一个非常简单的模式，可以大大减少应用程序创建的对象，降低程序内存占用，增加程序的性能；

## 四、缺点 ##

由于需要区分内部状态和外部状态，而且外部状态是固化的，可能导致系统复杂性增加。

## 五、应用场景 ##

*  系统中存在大量的相似对象。
 *  细粒度的对象中外部状态相似，且内部状态与环境无关。
 *  需要缓冲池的场景。

## 六、注意事项 ##

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTE4MTQ5_size_16_color_FFFFFF_t_70]: /images/20230810/1c3149c0f552474cb0098daafb465708.png