定义

Flyweight在拳击比赛中指最轻量级，即“蝇量级”或“雨量级”。这里选择使用“享元模式”的意译，是因为这样更能反映出模式的用意。享元模式是对象的结构模式。享元模式以共享的方式高效的支持大量的细粒度对象。

Java中的String类型

在Java语言中，String类型就是使用了享元模式。String对象是final类型，对象一旦创建就不可改变。在Java中字符串常量都是存储在常量池中的，Java会确保一个字符串常量在常量池中只有一个拷贝。String a = "abc"，其中"abc"就是一个字符串常量。

public class Test {
    public static void main(String[] args) {
        String a = "abc";
        String b = "abc";
        System.out.println(a==b);
    }
}

上面的例子中，结果为true，这说明a和b两个引用都指向了常量池中的同一个字符串常量abc。这样的设计避免了在创建N多个相同对象时所产生的不必要的大量的资源消耗。

享元模式的结构

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

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

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

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

单纯享元模式

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

单纯享元模式结构

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

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

示例代码

抽象享元角色类

public interface Flyweight {
    //一个示意性方法，参数state时外运状态，由外部传入
    public void operation(String state);
}

具体享元角色类ConcreteFlyweight有一个内蕴状态，在本例中，使用Character类型的intrinsicState属性代表，它的值应当是在享元模式被创建时赋予。所有的内蕴状态，在对象创建完成之后，就不会再改变了。

如果一个享元模式有内蕴状态的话，所有的外部状态必须存储在客户端，在使用享元对象时，再由客户端传入享元对象。这里只有一个外蕴状态，operation(String state)的state参数就是由外部传入的外蕴状态。

public class ConcreteFlyweight implements Flyweight {
    private Character intrinsicState = null;
    
    public ConcreteFlyweight(Character intrinsicState) {
        this.intrinsicState = intrinsicState;
    }
    
    /**
     * 外蕴状态作为参数传入方法中，改变方法的行为
     * 但是并不改变方法的内蕴状态
     */
    @Override
    public void operation(String state) {
        System.out.println("Intrinsic State = " + this.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 flyweight = files.get(state);
        if (flyweight == null) {
            //如果对象不存在，则重新创建一个新的Flyweight对象
            flyweight = new ConcreteFlyweight(state);
            //将新生成的对象放入缓存列表中
            files.put(state, flyweight);
        }
        //返回对象
        return flyweight;
    }
}

客户端类

public class Client {
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();
        
        Flyweight flyweightA = factory.factory(new Character('A'));
        flyweightA.operation("First Call , A State");
        System.out.println(flyweightA);
        
        Flyweight flyweightB = factory.factory(new Character('B'));
        flyweightB.operation("Second Call , B State");
        System.out.println(flyweightB);
        
        Flyweight flyweightC = factory.factory(new Character('A'));
        flyweightC.operation("Third Call , A State");
        System.out.println(flyweightC);
    }
}

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

Intrinsic State = A
Extrinsic State = First Call , A State
com.sschen.flyweight.ConcreteFlyweight@2a139a55
Intrinsic State = B
Extrinsic State = Second Call , B State
com.sschen.flyweight.ConcreteFlyweight@15db9742
Intrinsic State = A
Extrinsic State = Third Call , A State
com.sschen.flyweight.ConcreteFlyweight@2a139a55

复合享元模式

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

复合享元模式结构

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

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

示例代码

抽象享元角色类

public interface Flyweight {
    //一个示意性方法，参数state时外运状态，由外部传入
    public void operation(String state);
}

具体享元角色类

public class ConcreteFlyweight implements Flyweight {
    private Character intrinsicState = null;
    
    public ConcreteFlyweight(Character intrinsicState) {
        this.intrinsicState = intrinsicState;
    }
    
    /**
     * 外蕴状态作为参数传入方法中，改变方法的行为
     * 但是并不改变方法的内蕴状态
     */
    @Override
    public void operation(String state) {
        System.out.println("Intrinsic State = " + this.intrinsicState);
        System.out.println("Extrinsic State = " + state);
    }
}

复合享元对象是由单纯享元对象通过复合而成的，因此它提供了add()这样的聚集管理方法。由于 一个复合享元对象具有不同的聚集元素，这些聚集元素在复合享元对象被创建之后加入，这本身就意味着复合享元对象的状态是会改变的，因此复合享元对象是不能共享的。

复合享元角色实现了抽象享元角色所规定的借口，也就是operation()方法，这个方法有一个参数，代表复合享元对象的外蕴状态。一个复合享元对象的所有单纯享元对象元素的外蕴状态都是与复合享元对象的外蕴状态相等的；而一个复合享元对象所包含的所有的单纯享元对象的内蕴状态一般是不相等的，不然就没有了使用的价值。

public class ConcreteCompositeFlyweight implements Flyweight {
    private Map<Character, Flyweight> files = new HashMap<Character, Flyweight>();
    
    /**
     * 添加一个新的单纯享元对象到聚集中
     * @param key
     * @param flyweight
     */
    public void add(Character key, Flyweight flyweight) {
        files.put(key, flyweight);
    }
    
    /**
     * 外蕴状态作为参数传递到方法中
     */
    @Override
    public void operation(String state) {
        Flyweight flyweight = null;
        for (Object o: files.keySet()) {
            flyweight = files.get(o);
            flyweight.operation(state);
            System.out.println(flyweight);
        }
    }
}

享元工厂角色提供两种不同的方法，一种用于提供单纯享元对象，一种用于提供复合享元对象。

public class FlyweightFactory {
    private Map<Character, Flyweight> files = new HashMap<Character, Flyweight>();
    
    /**
     * 复合享元工厂方法
     * @param compositeState
     * @return
     */
    public Flyweight factory(List<Character> compositeState) {
        ConcreteCompositeFlyweight concreteCompositeFlyweight = new ConcreteCompositeFlyweight();
        
        for (Character state : compositeState) {
            concreteCompositeFlyweight.add(state, this.factory(state));
        }
        
        return concreteCompositeFlyweight;
    }
    
    /**
     * 单纯享元工厂方法
     * @param state
     * @return
     */
    public Flyweight factory(Character state) {
        //先从已有的缓存列表中查询对象是否已存在
        Flyweight flyweight = files.get(state);
        if (flyweight == null) {
            //如果对象不存在，则重新创建一个新的Flyweight对象
            flyweight = new ConcreteFlyweight(state);
            //将新生成的对象放入缓存列表中
            files.put(state, flyweight);
        }
        //返回对象
        return flyweight;
    }
}

客户端角色

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('B');
        compositeState.add('A');
        
        FlyweightFactory flyweightFactory = new FlyweightFactory();
        Flyweight compositeFly1 = flyweightFactory.factory(compositeState);
        Flyweight compositeFly2 = flyweightFactory.factory(compositeState);
        
        compositeFly1.operation("Composite1 Call");
        compositeFly2.operation("Composite2 Call");
        
        System.out.println("---------------------------------------------");
        System.out.println("复合享元模式是否可以共享对象：" + (compositeFly1 == compositeFly2));
        System.out.println(compositeFly1);
        System.out.println(compositeFly2);
        
        Character charState = 'A';
        Flyweight flyweight1 = flyweightFactory.factory(charState);
        Flyweight flyweight2 = flyweightFactory.factory(charState);
        System.out.println("单纯享元模式是否可以共享对象：" + (flyweight1 == flyweight2));
    }
}

运行结果如下：

Intrinsic State = A
Extrinsic State = Composite1 Call
com.sschen.compositeflyweight.ConcreteFlyweight@2a139a55
Intrinsic State = B
Extrinsic State = Composite1 Call
com.sschen.compositeflyweight.ConcreteFlyweight@15db9742
Intrinsic State = C
Extrinsic State = Composite1 Call
com.sschen.compositeflyweight.ConcreteFlyweight@6d06d69c
Intrinsic State = A
Extrinsic State = Composite2 Call
com.sschen.compositeflyweight.ConcreteFlyweight@2a139a55
Intrinsic State = B
Extrinsic State = Composite2 Call
com.sschen.compositeflyweight.ConcreteFlyweight@15db9742
Intrinsic State = C
Extrinsic State = Composite2 Call
com.sschen.compositeflyweight.ConcreteFlyweight@6d06d69c
---------------------------------------------
复合享元模式是否可以共享对象：false
com.sschen.compositeflyweight.ConcreteCompositeFlyweight@7852e922
com.sschen.compositeflyweight.ConcreteCompositeFlyweight@4e25154f
单纯享元模式是否可以共享对象：true

从运行结果可以看出：

• 一个复合享元对象的所有单纯享元对象元素的外蕴状态都是与复合享元对象的外蕴状态相等，也就是上面例子中的Composite1 Call。
• 一个复合享元对象所含有的单纯享元对象的内蕴状态一般是不想等的，也就是A、B、C。
• 复合享元对象是不能共享的。也就是说，使用相同的对象compositeState通过享元工厂角色分别两次创建出的对象不是同一个对象。
• 单纯享元对象是可以共享的。也就是相同的对象state通过享元工厂角色分别多次创建出的对象是同一个对象。

享元模式的优缺点

享元模式的优点在于它大幅度的降低内存中对象的数量。但是，它做到这一点所付出的代价也是很高的：

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

参考

《JAVA与模式》之享元模式