享元模式

享元模式

如果在一个系统中存在多个相同的对象，那么只需共享一份对象的拷贝，而不必为每一次使用都创建新的对象。这里可以看出，享元模式是对象的结构模式。享元模式以共享的方式高效地支持大量的细粒度对象。

概述

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

内蕴状态(Internal State)：存储在享元对象内部的，不随环境的改变而改变。

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

享元模式分类

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

单纯享元模式

在单纯的享元模式中，所有的享元对象都是可以共享的。用uml图表示如下：

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

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

代码实现

Flyweight.java(抽象享元)

public interface Flyweight {    //参数state是外蕴状态    public void operation(String state);}

ConcreteFlyweight.java（具体享元）

public class ConcreteFlyweight implements Flyweight {    private Character intrinsicState = null;    /**     * 构造函数，内蕴状态作为参数传入     * @param state     */    public ConcreteFlyweight(Character state){        this.intrinsicState = state;    }    @Override    public void operation(String state) {        // TODO Auto-generated method stub        System.out.println("Intrinsic State = " + this.intrinsicState);        System.out.println("Extrinsic State = " + state);    }}

一般我们在写具体享元的时候，我们会写一个构造作为内蕴状态传入参数。所有的内蕴状态在对象创建之后，就不会再改变了。如果一个享元对象有外蕴状态的话，所有的外部状态都必须存储在客户端，在使用享元对象时，再由客户端传入享元对象。

FlyweightFactory.java

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;    }}

这里必须说明一点：客户端不可以直接将具体享元类实例化，而必须通过一个工厂对象，利用一个factory()方法得到享元对象。

客户端测试类（Test）

public class ClientTest {    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)角色 ：本角 色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有 一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象。

源代码实现：

Flyweight.java

public interface Flyweight {    //一个示意性方法，参数state是外蕴状态    public void operation(String state);}

ConcreteFlyweight.java

public class ConcreteFlyweight implements Flyweight {    private Character intrinsicState = null;    /**     * 构造函数，内蕴状态作为参数传入     * @param state     */    public ConcreteFlyweight(Character state){        this.intrinsicState = state;    }    @Override    public void operation(String state) {        System.out.println("Intrinsic State = " + this.intrinsicState);        System.out.println("Extrinsic State = " + state);    }}

ConcreteCompositeFlyweight.java

public class ConcreteCompositeFlyweight implements Flyweight {        private Map<Character,Flyweight> files = new HashMap<Character,Flyweight>();    /**     * 增加一个新的单纯享元对象到聚集中     */    public void add(Character key , Flyweight fly){        files.put(key,fly);    }    /**     * 外蕴状态作为参数传入到方法中     */    @Override    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>();    /**     * 复合享元工厂方法     */    public Flyweight factory(List<Character> compositeState){        ConcreteCompositeFlyweight compositeFly = new ConcreteCompositeFlyweight();                for(Character state : compositeState){            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);        }        return fly;    }}

测试类：

public class Client {    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("---------------------------------");                System.out.println("复合享元模式是否可以共享对象：" + (compositeFly1 == compositeFly2));                Character state = 'a';        Flyweight fly1 = flyFactory.factory(state);        Flyweight fly2 = flyFactory.factory(state);        System.out.println("单纯享元模式是否可以共享对象：" + (fly1 == fly2));    }}

总结

享元模式的优点在于它大幅度地降低内存中对象的数量，但是它的使用使系统使用更加复杂了。如果使用外部状态数据的话，使得程序的运行时间更长。