Android设计模式之（23）----享元模式

享元模式

享元模式属于结构型模式.主要用于解决系统中存在的内存性能消耗等问题.

当项目中存在多个同一个对象的时候,对象的回收创建成本不断增加,导致内存性能等问题,使用享元模式将减少内存消耗,在相同的对象上可以有不同的状态处理内部与外部状态.

• 内部状态
  内部状态属于可以共享的,不会随着环境改变而改变,在构造参数进行构造或者set
• 外部状态
  外部状态属于不可共享的,随着环境改变而改变.

对于内部状态与外部状态,在享元模式中会有一个享元工厂,以键值对的方式将键（内部状态）与值（外部状态对象自身）存储起来.

如果在工厂中已经有了对象则直接取出,否则就创建新的实例并存入工厂中,以此来降低对象的创建与销毁所带来的开销.

享元模式分类

• 单纯享元,所有的享元对象是共享的

• 复合享元,将单纯的享元结合而成复合的享元,对于新生成的复合享元来说是不可共享的,对于复合享元的组成部分（单纯享元）来说是可共享的

应用场景

• 项目中存在大量相同的对象
• 外部状态相同类似情况

代码示例

一个公司前端攻城狮/Android攻城狮等等的职位,对于这些职位来说是不变的状态,而对于做这项工作的人可能是A也能是B是随时变化的.

前端职位=内部状态（不可变）
做前端的人=外部状态（随时改变）

• 单纯享元

(一)抽象享元角色（外部状态)

public interface Flyweight {
    //name是职位的人叫什么 是一个抽象外部状态
    public void show(String name);
}

(二)具体的享元角色

public class ConcreteFlyweight  implements  Flyweight {

    private  String inSideState=null;//内部状态不可变

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

    @Override
    public void show(String name) {
//        System.out.println("内部状态:"+this.inSideState);
//        System.out.println("外部状态:"+name);
        System.out.println(this.inSideState+"职位");
        System.out.println("做"+inSideState+"的职位的人的名字:"+name);
    }
}

享元角色的内部状态是不可变的,构造期间传入或者setter

(三)享元工厂

public class FlyweightFactory {

    /**
     * 存储键值对
     * String键:内部状态 不可变
     * Flyweight值:外部状态 可变
     */
    private Map<String, Flyweight> files = new HashMap<String, Flyweight>();

    public FlyweightFactory() {
    }

    public static final FlyweightFactory getInstance() {
        return SingletonHolder.INSTANCE;
    }


    private static class SingletonHolder {
        private static final FlyweightFactory INSTANCE = new FlyweightFactory();
    }

    public Flyweight getFactory(String key) {
        //先从系统中获取
        Flyweight fly = files.get(key);
        if (null ==fly ) {
            // 如果对象不存在则创建一个新对象并且添加
            fly = new ConcreteFlyweight(key);
            files.put(key, fly);
        }
        return fly;
    }

    //获取对象个数
    public int getFlyWeightSize() {
        return files.size();
    }
}

享元对象不能直接进行实例,在一个项目中只会存在一个享元工厂,因此用单例来获取,而享元对象则通过工厂获取,有则取用,无则创建

(四) 调用方式

  //单纯享元
        FlyweightFactory flyweightFactory=FlyweightFactory.getInstance();
        Flyweight flyweight=flyweightFactory.getFactory(new String("Android程序猿"));
        flyweight.show("A");
        System.out.println("");


        Flyweight flyweight1=flyweightFactory.getFactory(new String("前端程序猿"));
        flyweight1.show("B");
        System.out.println("");

        Flyweight flyweight2=flyweightFactory.getFactory(new String("高级Java工程师"));
        flyweight2.show("C");
        System.out.println("");

        Flyweight flyweight3=flyweightFactory.getFactory(new String("Android程序猿"));
        flyweight3.show("A");
        System.out.println("");

        //比较彼此的内存空间,Android程序猿存在两个,指向同一个内存地址
        System.out.println("单纯享元模式是否可以共享对象:" +(flyweight==flyweight1));//false
        System.out.println("");
        System.out.println("单纯享元模式是否可以共享对象:" +(flyweight==flyweight2));//false
        System.out.println("");
        System.out.println("单纯享元模式是否可以共享对象:" +(flyweight==flyweight3));//true
        System.out.println("");
        System.out.println("单纯享元模式是否可以共享对象:" +(flyweight1==flyweight2));//false
        System.out.println("");
        System.out.println("单纯享元模式是否可以共享对象:" +(flyweight1==flyweight3));//false
        System.out.println("");
        System.out.println("单纯享元模式是否可以共享对象:" +(flyweight2==flyweight3));//false
        System.out.println("");
        System.out.println("原本有4个对象,实际有:"+flyweightFactory.getFlyWeightSize()+"个");

(五) 显示结果

做高级Java工程师的职位的人的名字:C

Android程序猿职位
做Android程序猿的职位的人的名字:A

单纯享元模式是否可以共享对象:false

单纯享元模式是否可以共享对象:false

单纯享元模式是否可以共享对象:true

单纯享元模式是否可以共享对象:false

单纯享元模式是否可以共享对象:false

单纯享元模式是否可以共享对象:false

原本有4个对象,实际有:3个

在创建过程中,建立了4个对象,实际在进入享元工厂后,因为已经存在了同一个对象,所以实际上只有3个对象的存在.

• 复合享元

复合享元是将单纯享元合成起来行程一个新的享元,而这个享元变的不在可以共享,但是他们的组成部分可以共享.

在单纯享元基础上合成构造一个复合享元

public class ConcreteCompositeFlyweight implements Flyweight {

    private Map<String, Flyweight> hashMap = new HashMap<String, Flyweight>();

    @Override
    public void show(String name) {
        Flyweight fly = null;
        for (String inSideState : hashMap.keySet()) {
            fly = hashMap.get(inSideState);
            fly.show(name);
        }
    }

    //添加一个新的享元到集合中
    public void addFly(String inSideState, Flyweight flyweight) {

        hashMap.put(inSideState, flyweight);
    }
}

在享元工厂中添加获取复合享元角色的方法

  //复合享元
    public Flyweight getFactory(List<String> compositeState) {
        ConcreteCompositeFlyweight compositeFly = new ConcreteCompositeFlyweight();

        for (String inSideState : compositeState) {
            //添加一个享元对象
            compositeFly.addFly(inSideState,getFactory(inSideState));
        }

        return compositeFly;
    }

使用复合享元调用

 //复合享元

        List<String> list=new ArrayList<>();
        list.add("Android程序猿");
        list.add("前端程序猿");
        list.add("高级Java工程师");
        list.add("Android程序猿");

        Flyweight flyweight4=flyweightFactory.getFactory(list);
        flyweight4.show("A");//外部状态

        System.out.println("");

        Flyweight flyweight5=flyweightFactory.getFactory(list);
        flyweight5.show("B");

        System.out.println("");


        System.out.println("复合享元模式是否可以共享对象：" + (flyweight4 == flyweight5));

        System.out.println("---------------------------------");

显示结果

Android程序猿职位
做Android程序猿的职位的人的名字:A
前端程序猿职位
做前端程序猿的职位的人的名字:A
高级Java工程师职位
做高级Java工程师的职位的人的名字:A

Android程序猿职位
做Android程序猿的职位的人的名字:B
前端程序猿职位
做前端程序猿的职位的人的名字:B
高级Java工程师职位
做高级Java工程师的职位的人的名字:B

复合享元模式是否可以共享对象：false

之前以及知道了内部状态是各个职位,外部状态是名字

上述结果可以看出

• 在一个复合的享元对象中,他的所有外状态都是和他内部包含的具体的单纯享元的外部状态相同

• 复合的享元对象是不共享,不对等的

• 而复合享元对象里包含的单纯享元对象是可以共享的

• 复合享元对象的内部具体单纯享元对象的内部状态是不相等的

总结

• 优点
  
  • 享元模式可以降低内存中的对象数量,提高性能
• 缺点
  
  • 设计复杂,对象的共享性,使得需要将一些状态外部hua,程序逻辑将变得复杂
  • 享元对象的状态外部化,在读取外部状态时耗时增加

github源码地址