设计模式（11）——对象性能模式（2）——享元模式

目录

1.基本介绍

2.动机

3.类图

4.案例：展示网站

5.Integer中应用享元模式的源码分析

6.总结

---

1.基本介绍

也叫蝇量模式

享元模式：享：共享 ，元：对象

• 定义：运用共享技术有效地支持大量细粒度的对象
• 常用于系统底层开发，解决系统性能问题，像数据库连接池，里面都是创建好的连接对象，在这些连接对象中有我们需要的则直接拿来用，避免重新创建，如果没有我们需要的，则创建一个
• 享元模式能够解决重复对象的内存浪费问题，当系统中有大量相似现象，需要缓冲池时，不需总是创建新对象，可以从缓冲池中拿，这样可以降低系统内存，同时提高效率
• 享元模式经典的应用场景就是池技术了，如Java中的String常量池、线程池、连接池、内存池等等都是共享的思想

2.动机

• 在软件系统采用纯粹面向对象方案的问题在于大量细粒度的对象会很快充斥在系统中，从而带来很高的运行时代价——主要指内存需求方面的代价

• 如何在避免大量细粒度对象问题的同时，让外部客户程序仍然能够透明地使用面向对象的方式来进行操作？

3.类图

• 1.FlyWeight是抽象的享元角色 ，它是产品的抽象类，同时定义出对象的外部状态和内部状态的接口或实现
• 2.ConcreteFlyWeight是具体的享元角色，是具体的产品类，实现抽象角色定义相关业务
• 3.UnSharedConcreteFlyWeight是不可共享的角色，一般不会出现在享元工厂
• 4.FlyWeightFactory是享元工厂类，用于构建一个池容器(集合)，同时提供从池中获取对象的方法

外部状态和内部状态：

比如围棋、五子棋、跳棋，它们都有大量的棋子对象，围棋和五子棋只有黑白两色，跳棋就色多一点，所以棋子颜色就是棋子的内部状态，而各个棋子之间的差别就是位置的不同，当我们落子后，落子颜色是定的，但位置是变化的，所以棋子坐标是棋子的外部状态

• 内部状态指对象共享出来的信息，存储在享元对象的内部且不会随环境的改变而改变
• 外部状态指对象得以依赖得一个标记，是随着环境改变而改变的、不可共享的状态

 

4.案例：展示网站

需求：

给客户A做一个产品展示网站，客户A的朋友感觉效果不错，也希望做这样的产品展示网站，但是要求有些不同

• 有客户要求以新闻的形式发布
• 有客户要求以博客的形式发布
• 有客户希望以微信公众号的形式发布

传统方式解决方案：

思路：

直接为每个网站复制粘贴一份，然后根据不同的用户需求，进行定制修改，然后为每个网站租用一个虚拟空间存放它们各自的网站

分析问题：

• 需要的网站结构相似度很高，而且都不是高访问量网站，如果分成多个虚拟空间来处理，相当于一个相同网站的实例对象很多，造成服务器的资源浪费
• 多份网站，维护成本高
• 解决思路：整合到一个网站中，共享其相关的代码和数据，对于硬盘、内存、CPU、数据库空间等服务器资源都可以达成共享，减少服务器资源，对于代码来说，由于是一份实例，维护和扩展都更加容易

享元模式实现：

package cn.cqu.flyWeight;

public class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package cn.cqu.flyWeight;

public abstract class WebSite {
    //User为外部状态
    public abstract void use(User user);
}

package cn.cqu.flyWeight;

public class ConcreteWebSite extends WebSite{
    //网站发布形式
    //共享的部分，内部状态
    private String type="";

    public ConcreteWebSite(String type){
        this.type = type;
    }

    @Override
    public void use(User user) {
        System.out.println("网站发布的形式："+this.type+","+user.getName()+"正在使用中");
    }
}

package cn.cqu.flyWeight;

import java.util.HashMap;

/**
 * 根据需求返回具体网站
 */
public class WebSiteFactory {
    //集合，充当池的作用
    private HashMap<String,WebSite> pool = new HashMap<>();

    //根据网站的发布形式，返回一个网站，如果没有就创建一个网站，放入到池中
    public WebSite getWebSite(String type){
        if(!pool.containsKey(type))
        {
            //创建一个网站并放入池中
            pool.put(type,new ConcreteWebSite(type));
        }
        return pool.get(type);
    }

    //获取网站分类的总数(池中有多少个网站类型)
    public int getWebSiteCount(){
        return pool.size();
    }

}

package cn.cqu.flyWeight;

public class Client {
    public static void main(String[] args) {
        //创建一个工厂
        WebSiteFactory factory = new WebSiteFactory();

        //客户1要一个以新闻形式发布的网站
        WebSite webSite1 = factory.getWebSite("新闻");
        webSite1.use(new User("Tom"));

        //客户2要一个以博客形式发布的网站
        WebSite webSite2 = factory.getWebSite("博客");
        webSite2.use(new User("Jack"));

        //客户3要一个以博客形式发布的网站
        WebSite webSite3 = factory.getWebSite("博客");
        webSite3.use(new User("Mike"));

        //客户4要一个以博客形式发布的网站
        WebSite webSite4 = factory.getWebSite("博客");
        webSite4.use(new User("Lucy"));

        //客户5要一个以博客形式发布的网站
        WebSite webSite5 = factory.getWebSite("新闻");
        webSite5.use(new User("Lily"));


        System.out.println("网站的分类共有"+factory.getWebSiteCount()+"种");
    }
}

5.Integer中应用享元模式的源码分析

public class Client {
    public static void main(String[] args) {
        Integer x = Integer.valueOf(127);
        Integer y = new Integer(127);
        Integer z = Integer.valueOf(127);
        Integer w = new Integer(127);

        System.out.println(x.equals(y)); //true
        System.out.println(x == y);//false
        System.out.println(x == z);//true
        System.out.println(w == x);//false
        System.out.println(w == y);//false
    }
}

Integer.valueOf的源码：

• 如果Integer.valueOf(x)中[-128,127]之间，就使用享元模式，直接从缓存池中返回，执行速度要比new要快
• 如果不在[-128,127]之间，就使用new关键字创建新的对象

6.总结

• 面向对象很好地解决了抽象性的问题，但是作为一个运行在机器中的程序实体，我们需要考虑对象的代价问题，Flyweight主要解决面向对象的代价问题，一般不触及面向对象的抽象性问题
• 系统中有大量对象，这些对象消耗大量内存，并且对象的状态大部分可以外部化时，我们就可以考虑选用享元模式
• 用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象，用HashMap/HashTable存储
• 享元模式大大减少了对象的创建，降低了程序内存的占用，提高效率
• 享元模式提高了系统的复杂性，需要分离内部状态和外部状态，而外部状态具有固化特性，不应该随着内部状态的改变而改变
• 使用享元模式时，注意划分内部状态和外部状态，并且需要有一个工厂类加以控制
• 对象的数量太大从而导致对象内存开销加大——什么样的数量才算大？这需要我们仔细的根据具体应用情况进行评估，而不能凭空臆断
• 使用享元模式创建出来的对象一般是只读的，不能允许被使用者更改（如常量池中的String）,否则共享不成立