设计模式-享元模式

享元模式

说到享元模式，第一个想到的应该就是池技术了，String常量池、数据库连接池、缓冲池等等都是享元模式的应用，所以说享元模式是池技术的重要实现方式。

• 基本介绍

1. 享元模式又叫蝇量模式：运用共享技术有效的支持大量细粒度对象
2. 享元模式长用于底层开发，解决系统的性能问题。像数据库连接池，里面都是创建好的连接对象，在这些连接对象中有我们需要的则直接拿来用，避免了重复创建。如果没有我们需要的则创建一个
3. 享元模式能够解决重复对象内存浪费的问题，当系统中有大量相识的对象，需要创建缓存池时。不需总是创建新的对象，可以从缓冲池里面拿。这样可以降低系统内存，提高效率

• 享元模式原理类图
  
  Flyweight：是抽象的享元角色，他是产品的抽象，同时定义出对象的外部状态和内部状态的接口或实现
  ConcreteFlyweight：继承Flyweight超类或实现Flyweight接口，并为其内部状态增加存储空间。
  UnsharedConcreteFlyweight：指那些不需要共享的Flyweight子类。
  FlyweightFactory：一个享元工厂，用来创建并管理Flyweight对象，主要是用来确保合理地共享Flyweight，当用户请求一个Flyweight时，FlyweightFactory对象提供一个已创建的实例或创建一个实例。

• 内部状态和外部状态

1. 上面享元模式的定义为我们提出了两个要求：细粒度和共享对象。我们知道分配太多的对象到应用程序中将有损程序的性能，同时还容易造成内存溢出，要避免这种情况，用到的就是共享技术，这里就需要提到内部状态和外部状态了。
2. 因为要求细粒度对象，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。
3. 内部状态指对象共享出来的信息，存储在享元对象内部并且不会随环境的改变而改变；外部状态指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。
4. 我们举一个最简单的例子，棋牌类游戏大家都有玩过吧，比如说说围棋和跳棋，它们都有大量的棋子对象，围棋和五子棋只有黑白两色，跳棋颜色略多一点，但也是不太变化的，所以棋子颜色就是棋子的内部状态；而各个棋子之间的差别就是位置的不同，我们落子嘛，落子颜色是定的，但位置是变化的，所以方位坐标就是棋子的外部状态。
5. 那么为什么这里要用享元模式呢？可以想象一下，上面提到的棋类游戏的例子，比如围棋，理论上有361个空位可以放棋子，常规情况下每盘棋都有可能有两三百个棋子对象产生，因为内存空间有限，一台服务器很难支持更多的玩家玩围棋游戏，如果用享元模式来处理棋子，那么棋子对象就可以减少到只有两个实例，这样就很好的解决了对象的开销问题。

• 享元模式的代码示例
  提到现在实现生活中的共享的事务，我们很容易想到共享单车，共享单车有很多种，比如哈喽单车，青桔单车等，每一家的单车都有很多辆。

所以我们很容易定义出个单车的产品抽象对象

public abstract class Bicycle {

    // 内部状态
    private String name;

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

    public String getName() {
        return name;
    }

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

    /**
     * user对象就是外部状态
     * @param user
     */
    public abstract void ride(User user);
}

具体的产品类

public class ConcreteBicycle extends Bicycle {

    public ConcreteBicycle( String name) {
        super(name);
    }

    @Override
    public void ride(User user) {
        System.out.println(user.getName() + "在骑" + getName() + "单车");
    }
}

User类省略

享元工厂：

public class BicyCleFactory {

    private HashMap<String,Object> bicyClePool = new HashMap<>();

    public Bicycle getBicycle (String cycleName) {
        if (!bicyClePool.containsKey(cycleName)) {
            Bicycle bicycle = new ConcreteBicycle(cycleName);
            bicyClePool.put(cycleName, bicycle);
        }

        return (Bicycle) bicyClePool.get(cycleName);

    }

    public int getSize () {
        return bicyClePool.size();
    }
}

测试：

public class Client {

    public static void main(String[] args) {
        BicyCleFactory bicyCleFactory = new BicyCleFactory();
        Bicycle bicycle = bicyCleFactory.getBicycle("哈喽");
        Bicycle bicycle2 = bicyCleFactory.getBicycle("哈喽");
        bicycle.ride(new User("小明"));
        bicycle2.ride(new User("小红"));

        int size = bicyCleFactory.getSize();
        System.out.println(size);
    }
}

结果：

小明在骑哈喽单车
小红在骑哈喽单车
1

结果分析：

1. 我们通过bicyCleFactory获取了2次哈喽单车的实例，但是通过size = 1 我们可以判断出他们实际就产生了一个对象，也是就是享元模式共享单车池的概念
2. 内部状态是单车的名字比如哈喽单车这个是不变的，外部状态是User,谁在骑单车这个是变化的。请仔细体会上面内部状态和外部状态的分析。
3. 可以体会下，比如成千上万的人要骑哈喽单车时，如果通过上面的享元工厂取得单车实例，实际上在内存上就产生了一个哈喽单车实例，这样的话可以大大解决系统的开销，提高了系统性能。如果不用享元模式，那么一个千个人骑单车就要创建一千单车实例，通过对优缺点可想而知。