Java设计模式——享元模式（Flyweight）

Flyweight在拳击比赛中指最轻量级，即“蝇量级”或“雨量级”，这里选择使用“享元模式”的意译，是因为这样更能反映模式的用意。享元模式是对象的结构模式。享元模式以共享的方式高效地支持大量的细粒度对象。
在JAVA语言中，String类型就是使用了享元模式。String对象是final类型，对象一旦创建就不可改变。在JAVA中字符串常量都是存在常量池中的，JAVA会确保一个字符串常量在常量池中只有一个拷贝。String a=”abc”，其中”abc”就是一个字符串常量。
享元模式的结构：
享元模式采用一个共享来避免大量拥有相同内容对象的开销。这种开销最常见、最直观的就是内存的损耗。享元对象能做到共享的关键是区分内蕴状态(Internal State)和外蕴状态(External State)。
内蕴状态是存储在享元对象内部的，并且是不会随着环境改变而有所不同。因此，一个享元可以具有内蕴状态并可以共享
外蕴状态是随着环境改变而改变的、不可以共享的。享元对象的外蕴状态必须由客户端 保存，并在享元对象被创建之后，在需要使用的时候再传入想原对象内部。外蕴状态不可以影响享元对象的内蕴状态，他们是互相独立的。
享元模式分为单纯享元模式和复合享元模式
单纯享元模式结构：

●抽象享元(Flyweight)角色 ：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。
●具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定出的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。
●享元工厂(FlyweightFactory)角色 ：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。

public class ConcreteFlyweight implements Flyweight {

    private Character intrinsicState;

    public ConcreteFlyweight(Character state){
        this.intrinsicState = state;
    }

    /**
     * 外蕴状态作为参数传入方法中，改变方法的行为，但是并不改变对象的内蕴状态
     */
    public void operation(String state) {
        System.out.println("Intrinsic state = "+intrinsicState);
        System.out.println("Extrinsic state = "+state);
    }

}

享元工厂角色类，必须指出的是，客户端不可以直接将具体享元类实例化，而必须通过一个工厂对象，利用一个factory()方法得到享元对象。一般而言，享元工厂对象在整个系统中只有一个，因此也可以使用单例模式。
当客户端需要单纯享元对象的时候，需要调用享元工厂的factory()方法，并传入所需的单纯享元对象的内蕴状态，由工厂方法产生所需要的享元对象。

public class FlyweightFactory {

    private Map<Character,Flyweight> files = new HashMap<Character,Flyweight>();

    public Flyweight factory(Character state){
        Flyweight fly = files.get(state);
        if(fly == null){
            // 如果对象不存在创建一个新的Flyweight对象
            fly = new ConcreteFlyweight(state);
            // 把这个新的Flyweight对象放到缓存中
            files.put(state, fly);
        }
        return fly;
    }
}
/**
     * @author 付玉伟
     * @time 2015-3-5 下午10:52:51
     * @param args
     */
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();
        Flyweight fly = factory.factory(new Character(‘a‘));
        fly.operation("first call");

        fly = factory.factory(new Character(‘b‘));
        fly.operation("second call");

        fly = factory.factory(new Character(‘a‘));
        fly.operation("Third Call");
    }

虽然客户端申请了三个享元对象，但是实际创建的享元对象只有两个，这就是共享的含义。运行结果如下：

复合享元模式：

复合享元角色所涉及到的角色如下：
　　●　抽象享元(Flyweight)角色 ：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。
　　●　具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定出的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。
　　●　复合享元(ConcreteCompositeFlyweight)角色 ：复合享元角色所代表的对象是不可以共享的，但是一个复合享元对象可以分解成为多个本身是单纯享元对象的组合。复合享元角色又称作不可共享的享元对象。
　　●　享元工厂(FlyweightFactory)角色 ：本角 色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有 一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个 合适的享元对象。
　　

public class ConcreteCompositeFlyweight implements Flyweight {

    private Map<Character,Flyweight> files = new HashMap<Character,Flyweight>();

    /**
     * 增加一个新的单纯享元对象到聚集中
     * @author 付玉伟
     * @time 2015-3-5 下午11:20:08
     * @param key
     * @param fly
     */
    public void add(Character key,Flyweight fly){
        files.put(key, fly);
    }

    /**
     * 外蕴状态作为参数传入方法中
     */
    public void operation(String state) {
        Flyweight fly = null;
        for(Object o:files.keySet()){
            fly = files.get(o);
            fly.operation(state);
        }
    }

}
public class FlyweightFactory {

    private Map<Character,Flyweight> files = new HashMap<Character,Flyweight>();

    /**
     * 复合享元工厂方法
     * @author 付玉伟
     * @time 2015-3-5 下午11:24:51
     * @param compositeSate
     * @return
     */
    public Flyweight factory(List<Character> compositeSate){
        ConcreteCompositeFlyweight compositeFly = new ConcreteCompositeFlyweight();
        for(Character state:compositeSate){
            compositeFly.add(state, this.factory(state));
        }
        return compositeFly;
    }

    public Flyweight factory(Character state){
        Flyweight fly = files.get(state);
        if(fly == null){
            // 如果对象不存在创建一个新的Flyweight对象
            fly = new ConcreteFlyweight(state);
            // 把这个新的Flyweight对象放到缓存中
            files.put(state, fly);
            System.out.println("享元对象被创建");
        }
        return fly;
    }
}

　复合享元对象是由单纯享元对象通过复合而成的，因此它提供了add()这样的聚集管理方法。由于一个复合享元对象具有不同的聚集元素，这些聚集元素在复合享元对象被创建之后加入，这本身就意味着复合享元对象的状态是会改变的，因此复合享元对象是不能共享的。
　　复合享元角色实现了抽象享元角色所规定的接口，也就是operation()方法，这个方法有一个参数，代表复合享元对象的外蕴状态。一个复合享元对象的所有单纯享元对象元素的外蕴状态都是与复合享元对象的外蕴状态相等的；而一个复合享元对象所含有的单纯享元对象的内蕴状态一般是不相等的，不然就没有使用价值了。
　　

/**
     * @author 付玉伟
     * @time 2015-3-5 下午10:52:51
     * @param args
     */
    public static void main(String[] args) {

        List<Character> compositeState = new ArrayList<Character>();
        compositeState.add(‘a‘);
        compositeState.add(‘b‘);
        compositeState.add(‘c‘);
        compositeState.add(‘a‘);
        compositeState.add(‘b‘);

        FlyweightFactory flyFactory = new FlyweightFactory();
        Flyweight compositeFly1 = flyFactory.factory(compositeState);
        Flyweight compositeFly2 = flyFactory.factory(compositeState);
        compositeFly1.operation("composite call");

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

        Character state = ‘a‘;
        Flyweight fly1 = flyFactory.factory(state);
        Flyweight fly2 = flyFactory.factory(state);

        System.out.println("单纯享元模式是否可以共享对象："+(fly1 == fly2));
    }

享元模式的优缺点
　　享元模式的优点在于它大幅度地降低内存中对象的数量。但是，它做到这一点所付出的代价也是很高的：
　　●享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。
　　●享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。