设计模式——享元模式

享元模式

模式定义

享元模式(Flyweight Pattern)：运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象，而这些对象都很相似，状态变化很小，可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象，因此它又称为轻量级模式，它是一种对象结构型模式。

模式结构

享元模式包含如下角色：

• Flyweight: 抽象享元类
• ConcreteFlyweight: 具体享元类

• FlyweightFactory: 享元工厂类

  　　享元模式采用一个共享来避免大量拥有相同内容对象的开销。这种开销最常见、最直观的就是内存的损耗。享元对象能做到共享的关键是区分内蕴状态(Internal State)和外蕴状态(External State)。

  　　一个内蕴状态是存储在享元对象内部的，并且是不会随环境的改变而有所不同。因此，一个享元可以具有内蕴状态并可以共享。

  　　一个外蕴状态是随环境的改变而改变的、不可以共享的。享元对象的外蕴状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再传入到享元对象内部。外蕴状态不可以影响享元对象的内蕴状态，它们是相互独立的。
  　　

享元模式可以分成单纯享元模式和复合享元模式两种形式。

单纯享元模式：

在单纯的享元模式中，所有的享元对象都是可以共享的。

-

单纯享元模式所涉及到的角色如下：

　　●　　抽象享元(Flyweight)角色 ：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。

　　●　　具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定出的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。

　　●　　享元工厂(FlyweightFactory)角色 ：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。
　　

单纯享元模式举例

模拟在一个app中有许多控件要展示图片，这些图片有些是相同的，有些是不同的，相同图片宽高路径等特征基本一样。

要图片的展示控件:即外蕴状态

    static class TView {
        private String mName;
        public TView(String name) {
            mName = name;
        }

        public String getName() {
            return mName;
        }
    }

图片对象：图片宽高、路径等都是图片本身特征，可以共享，是内蕴状态，此例只写了路径

    interface IPicture{
        void show(TView view);
    }

    static class MPicture implements IPicture{
        private String mPath;//内蕴状态

        public MPicture(String path) {
            mPath = path;
        }

        @Override
        public void show(TView view) {
            System.out.println("图片路径=" + mPath + " view=" + view.mName);
        }
    }

图片工厂

    static class PictureFactory{
        private static Map<String, IPicture> sPictureMap = new HashMap<>();//享元池

        public static IPicture createPicture(String path){
            if(sPictureMap.containsKey(path)){
                return sPictureMap.get(path);
            }
            IPicture picture = new MPicture(path);
            sPictureMap.put(path, picture);//以内蕴状态为key
            return picture;
        }

        public static int getSize(){
            return sPictureMap.size();
        }
    }

测试：

   public static void main(String args[]){
        for(int i = 0; i < 4; i++){
            IPicture picture = PictureFactory.createPicture("path" + i);
        }
        IPicture picture = PictureFactory.createPicture("path2");
        picture.show(new TView("Button"));

        picture = PictureFactory.createPicture("path0");
        picture.show(new TView("ImageView"));

        picture = PictureFactory.createPicture("path5");
        picture.show(new TView("TextView"));

        picture = PictureFactory.createPicture("path3");
        picture.show(new TView("ImageButton"));

        picture = PictureFactory.createPicture("path1");
        picture.show(new TView("LinearLayout"));

        picture = PictureFactory.createPicture("path2");
        picture.show(new TView("RelativeLayout"));

        picture = PictureFactory.createPicture("path3");
        picture.show(new TView("FrameLayout"));

        picture = PictureFactory.createPicture("path0");
        picture.show(new TView("AbsoultyLayout"));

        System.out.println("实际创建的picture数量=" + PictureFactory.getSize());
    }

输出

图片路径=path2 view=Button
图片路径=path0 view=ImageView
图片路径=path5 view=TextView
图片路径=path3 view=ImageButton
图片路径=path1 view=LinearLayout
图片路径=path2 view=RelativeLayout
图片路径=path3 view=FrameLayout
图片路径=path0 view=AbsoultyLayout
实际创建的picture数量=5

虽然客户端申请了八个对象，但实际上系统只创建了5个对象

复合享元模式

在单纯享元模式中，所有的享元对象都是单纯享元对象，也就是说都是可以直接共享的。还有一种较为复杂的情况，将一些单纯享元使用合成模式加以复合，形成复合享元对象。这样的复合享元对象本身不能共享，但是它们可以分解成单纯享元对象，而后者则可以共享。

复合享元角色所涉及到的角色如下：

　　●　　抽象享元(Flyweight)角色 ：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。

　　●　　具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定出的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。

　　●　 复合享元(ConcreteCompositeFlyweight)角色 ：复合享元角色所代表的对象是不可以共享的，但是一个复合享元对象可以分解成为多个本身是单纯享元对象的组合。复合享元角色又称作不可共享的享元对象。

　　●　 享元工厂(FlyweightFactory)角色 ：本角 色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有 一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个 合适的享元对象。
　　
　　复合享元对象是由单纯享元对象通过复合而成的，因此它提供了add()这样的聚集管理方法。由于一个复合享元对象具有不同的聚集元素，这些聚集元素在复合享元对象被创建之后加入，这本身就意味着复合享元对象的状态是会改变的，因此复合享元对象是不能共享的。

一个复合享元对象的所有单纯享元对象元素的外蕴状态都是与复合享元对象的外蕴状态相等的；而一个复合享元对象所含有的单纯享元对象的内蕴状态一般是不相等的，不然就没有使用价值了

复合享元模式举例

接着单纯享元模式的例子，现在的需求是希望在一个ImageView上安顺序显示一组图片,利用享元模式分解需求：ImageView即是共同的外部状态，一组图片即是拥有不同内部状态的享元对象，此时采用复合享元模式完美契合

和之前例子一样，view和picture都不变

    static class TView {
        private String mName;
        public TView(String name) {
            mName = name;
        }

        public String getName() {
            return mName;
        }
    }

    interface IPicture{
        void show(TView view);

    }

    static class MPicture implements IPicture{
        private String mPath;

        public MPicture(String path) {
            mPath = path;
        }

        @Override
        public void show(TView view) {
            System.out.println("图片路径=" + mPath + " view=" + view.mName);
        }
    }

创建复合享元类：创建一个集合来存储单纯享元对象（一组图片）

    static class CompositePicture implements IPicture{
        private Map<String, IPicture> mPictureMap = new HashMap<>();

        public void addPicture(String path, IPicture picture){
            mPictureMap.put(path, picture);
        }

        @Override
        public void show(TView view) {
            for(Object o : mPictureMap.keySet()){
                mPictureMap.get(o).show(view);
            }
        }
    }

修改工厂方法：增加一个创建复合享元对象的方法，每一次客户端获取的复合享元对象都是新的一个对象，但是里面集合包含的单纯享元对象确是享元池中的对象（如果有，就直接用，如果没有就创建）

    static class PictureFactory{
        private static Map<String, IPicture> sPictureMap = new HashMap<>();//其实就是享元池
        public static IPicture createPicture(String path){
            if(sPictureMap.containsKey(path)){
                return sPictureMap.get(path);
            }
            IPicture picture = new MPicture(path);
            sPictureMap.put(path, picture);
            return picture;
        }

        public static CompositePicture createCompositePicture(List<String> pathes){
            CompositePicture compositePicture = new CompositePicture();
            for(String path : pathes){
                compositePicture.addPicture(path, createPicture(path));//享元池中获取单纯享元对象
            }
            return compositePicture;
        }

        public static int getSize(){
            return sPictureMap.size();
        }
    }

测试代码：

    public static void main(String args[]){
        for(int i = 0; i < 4; i++){
            IPicture picture = PictureFactory.createPicture("path" + i);
        }
        IPicture picture = PictureFactory.createPicture("path2");
        picture.show(new TView("Button"));

        picture = PictureFactory.createPicture("path0");
        picture.show(new TView("ImageView"));

        picture = PictureFactory.createPicture("path5");
        picture.show(new TView("TextView"));

        picture = PictureFactory.createPicture("path3");
        picture.show(new TView("ImageButton"));

        picture = PictureFactory.createPicture("path1");
        picture.show(new TView("LinearLayout"));

        picture = PictureFactory.createPicture("path2");
        picture.show(new TView("RelativeLayout"));

        picture = PictureFactory.createPicture("path3");
        picture.show(new TView("FrameLayout"));

        picture = PictureFactory.createPicture("path0");
        picture.show(new TView("AbsoultyLayout"));

        System.out.println("实际创建的picture数量=" + PictureFactory.getSize());
        System.out.println();
        System.out.println("======在ImageView中展示一组图片=========");
        List<String> pathes = new ArrayList<>();
        pathes.add("path1");
        pathes.add("path2");
        pathes.add("path3");
        pathes.add("path4");

        picture = PictureFactory.createCompositePicture(pathes);
        picture.show(new TView("ImageView"));
        System.out.println("实际创建的picture数量=" + PictureFactory.getSize());
    }

输出：其实在展示一组图片的时候，就增加了一个path4的对象，其他都是用已经存在享元池中的对象

图片路径=path2 view=Button
图片路径=path0 view=ImageView
图片路径=path5 view=TextView
图片路径=path3 view=ImageButton
图片路径=path1 view=LinearLayout
图片路径=path2 view=RelativeLayout
图片路径=path3 view=FrameLayout
图片路径=path0 view=AbsoultyLayout
实际创建的picture数量=5

======在ImageView中展示一组图片=========
图片路径=path1 view=ImageView
图片路径=path2 view=ImageView
图片路径=path3 view=ImageView
图片路径=path4 view=ImageView
实际创建的picture数量=6

模式分析

享元模式是一个考虑系统性能的设计模式，通过使用享元模式可以节约内存空间，提高系统的性能。

享元模式的核心在于享元工厂类，享元工厂类的作用在于提供一个用于存储享元对象的享元池，用户需要对象时，首先从享元池中获取，如果享元池中不存在，则创建一个新的享元对象返回给用户，并在享元池中保存该新增对象。

享元模式以共享的方式高效地支持大量的细粒度对象，享元对象能做到共享的关键是区分内部状态(Internal State)和外部状态(External State)。

内部状态是存储在享元对象内部并且不会随环境改变而改变的状态，因此内部状态可以共享。
外部状态是随环境改变而改变的、不可以共享的状态。享元对象的外部状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再传入到享元对象内部。一个外部状态与另一个外部状态之间是相互独立的。

优点

享元模式的优点

享元模式的优点在于它可以极大减少内存中对象的数量，使得相同对象或相似对象在内存中只保存一份。
享元模式的外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享。

缺点

享元模式的缺点

享元模式使得系统更加复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化。
为了使对象可以共享，享元模式需要将享元对象的状态外部化，而读取外部状态使得运行时间变长。

适用环境

在以下情况下可以使用享元模式：

一个系统有大量相同或者相似的对象，由于这类对象的大量使用，造成内存的大量耗费。
对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。
使用享元模式需要维护一个存储享元对象的享元池，而这需要耗费资源，因此，应当在多次重复使用享元对象时才值得使用享元模式。

模式应用

享元模式在编辑器软件中大量使用，如在一个文档中多次出现相同的图片，则只需要创建一个图片对象，通过在应用程序中设置该图片出现的位置，可以实现该图片在不同地方多次重复显示。

模式扩展

单纯享元模式和复合享元模式

• 单纯享元模式：在单纯享元模式中，所有的享元对象都是可以共享的，即所有抽象享元类的子类都可共享，不存在非共享具体享元类。

• 复合享元模式：将一些单纯享元使用组合模式加以组合，可以形成复合享元对象，这样的复合享元对象本身不能共享，但是它们可以分解成单纯享元对象，而后者则可以共享。
  享元模式与其他模式的联用

在享元模式的享元工厂类中通常提供一个静态的工厂方法用于返回享元对象，使用简单工厂模式来生成享元对象。
在一个系统中，通常只有唯一一个享元工厂，因此享元工厂类可以使用单例模式进行设计。
享元模式可以结合组合模式形成复合享元模式，统一对享元对象设置外部状态。

总结

• 享元模式运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象，而这些对象都很相似，状态变化很小，可以实现对象的多次复用，它是一种对象结构型模式。
• 享元模式包含四个角色：抽象享元类声明一个接口，通过它可以接受并作用于外部状态；具体享元类实现了抽象享元接口，其实例称为享元对象；非共享具体享元是不能被共享的抽象享元类的子类；享元工厂类用于创建并管理享元对象，它针对抽象享元类编程，将各种类型的具体享元对象存储在一个享元池中。
• 享元模式以共享的方式高效地支持大量的细粒度对象，享元对象能做到共享的关键是区分内部状态和外部状态。其中内部状态是存储在享元对象内部并且不会随环境改变而改变的状态，因此内部状态可以共享；外部状态是随环境改变而改变的、不可以共享的状态。
• 享元模式主要优点在于它可以极大减少内存中对象的数量，使得相同对象或相似对象在内存中只保存一份；其缺点是使得系统更加复杂，并且需要将享元对象的状态外部化，而读取外部状态使得运行时间变长。
• 享元模式适用情况包括：一个系统有大量相同或者相似的对象，由于这类对象的大量使用，造成内存的大量耗费；对象的大部分状态都可以外部化，可以将这些外部状态传入对象中；多次重复使用享元对象。