跟屌丝大哥学习设计模式--享元模式

四、举例

这里就以去餐馆吃饭为例详细的说明下享元模式的使用方式。去菜馆点菜吃饭的过程大家一定都是轻车熟路了，这里就不赘述。在例子中我使用了一个list来存放外蕴状态和内蕴状态的对应关系，而且提供了查询每个客人点菜情况的方法。内蕴状态在这里代表了菜肴的种类，而外蕴状态就是每盘菜肴的点菜人。
A 让我们先来看看单纯享元模式的实现吧。

先看下抽象享元角色的定义：GoF对享元模式的描述是：运用共享技术有效地支持大量细粒度的对象。
Flyweight模式是构造型模式之一，它通过与其他类似对象共享数据来减小内存占用。也就是说在一个系统中如果有多个相同的对象，那么只共享一份就可以了，不必每个都去实例化一个对象。在Flyweight模式中，由于要产生各种各样的对象，所以在Flyweight(享元)模式中常出现 Factory模式。Flyweight的内部状态是用来共享的,Flyweight factory负责维护一个对象存储池（Flyweight Pool）来存放内部状态的对象。为了调用方便，FlyweightFactory类一般使用Singleton模式实现。Flyweight模式是一个提高程序效率和性能的模式,会大大加快程序的运行速度。

Flyweight模式的有效性很大程度上取决于如何使用它以及在何处使用它。当以下情况成立时使用Flyweight模式：
1 一个应用程序使用了大量的对象。
2 完全由于使用大量的对象，造成很大的存储开销。
3 对象的大多数状态都可以变为外部状态。
4 如果删除对象以外的状态那么可以用相对较少的共享对象取代很多组对象。
5 应用程序不依赖于对象标识。
其结构图如下所示：

比如说，一个咖啡店有几种口味的咖啡（拿铁、摩卡、卡布奇诺等等），如果这家店接到分订单要几十杯咖啡。那么显然咖啡的口味就可以设置成共享的，而不必为每一杯单独生成。代码实现如下：

import java.util.*;

public abstract class Order {
// 执行卖出动作
public abstract void sell();
}

public class FlavorOrder extends Order {
public String flavor;

// 获取咖啡口味
public FlavorOrder(String flavor) {
this.flavor = flavor;
}

@Override
public void sell() {
// TODO Auto-generated method stub
System.out.println("卖出一份" + flavor + "的咖啡。");
}
}

public class FlavorFactory {
private Map<String, Order> flavorPool = new HashMap<String, Order>();

// 静态工厂,负责生成订单对象
private static FlavorFactory flavorFactory = new FlavorFactory();

private FlavorFactory() {
}

public static FlavorFactory getInstance() {
return flavorFactory;
}

public Order getOrder(String flavor) {
Order order = null;

if (flavorPool.containsKey(flavor)) {// 如果此映射包含指定键的映射关系，则返回 true
order = flavorPool.get(flavor);

   } else {
    order = new FlavorOrder(flavor);
    flavorPool.put(flavor, order);
   }
   return order;
}

public int getTotalFlavorsMade() {
return flavorPool.size();
}
}

public class Client {
// 客户下的订单
private static List<Order> orders = new ArrayList<Order>();

// 订单对象生成工厂
private static FlavorFactory flavorFactory;

// 增加订单
private static void takeOrders(String flavor) {
orders.add(flavorFactory.getOrder(flavor));
}

public static void main(String[] args) {
// 订单生成工厂
flavorFactory = FlavorFactory.getInstance();

   // 增加订单
   takeOrders("摩卡");
   takeOrders("卡布奇诺");
   takeOrders("香草星冰乐");
   takeOrders("香草星冰乐");
   takeOrders("拿铁");
   takeOrders("卡布奇诺");
   takeOrders("拿铁");
   takeOrders("卡布奇诺");
   takeOrders("摩卡");
   takeOrders("香草星冰乐");
   takeOrders("卡布奇诺");
   takeOrders("摩卡");
   takeOrders("香草星冰乐");
   takeOrders("拿铁");
   takeOrders("拿铁");

   // 卖咖啡
   for (Order order : orders) {
    order.sell();
   }

// 打印生成的订单java对象数量
System.out.println("\n客户一共买了 " + orders.size() + " 杯咖啡! ");

   // 打印生成的订单java对象数量
   System.out.println("共生成了 " + flavorFactory.getTotalFlavorsMade()
     + " 个 FlavorOrder java对象! ");
}
}

卖出一份摩卡的咖啡。
卖出一份卡布奇诺的咖啡。
卖出一份香草星冰乐的咖啡。
卖出一份香草星冰乐的咖啡。
卖出一份拿铁的咖啡。
卖出一份卡布奇诺的咖啡。
卖出一份拿铁的咖啡。
卖出一份卡布奇诺的咖啡。
卖出一份摩卡的咖啡。
卖出一份香草星冰乐的咖啡。
卖出一份卡布奇诺的咖啡。
卖出一份摩卡的咖啡。
卖出一份香草星冰乐的咖啡。
卖出一份拿铁的咖啡。
卖出一份拿铁的咖啡。

客户一共买了 15 杯咖啡!
共生成了 4 个 FlavorOrder java对象!

正如输入结果对比所示，把口味共享极大减少了对象数目，减小了内存消耗。

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

一、引子

让我们先来复习下java中String类型的特性：String类型的对象一旦被创造就不可改变；当两个String对象所包含的内容相同的时候，JVM只创建一个String对象对应这两个不同的对象引用。让我们来证实下着两个特性吧（如果你已经了解，请跳过直接阅读第二部分）。

先来验证下第二个特性：

public class TestPattern {

public static void main(String[] args){

String n = "I Love Java";

String m = "I Love Java";

System.out.println(n==m);

}

这段代码会告诉你n==m是true，这就说明了在JVM中n和m两个引用了同一个String对象（如果你还分不清== 和 equals的区别的话，请先确认）。

那么接着验证下第一个特性：

在系统输出之前加入一行代码“m = m + "hehe";”，这时候n==m结果为false，为什么刚才两个还是引用相同的对象，现在就不是了呢？原因就是在执行后添加语句时，m指向了一个新创建的String对象，而不是修改引用的对象。

呵呵，说着说着就差点跑了题，并不是每个String的特性都跟我们今天的主题有关的。
String类型的设计避免了在创建N多的String对象时产生的不必要的资源损耗，可以说是享元模式应用的范例，那么让我们带着对享元的一点模糊的认识开始，来看看怎么在自己的程序中正确的使用享元模式！

注：使用String类型请遵循《Effective Java》中的建议。

二、定义与分类

享元模式英文称为“Flyweight Pattern”，我非常感谢将Flyweight Pattern翻译成享元模式的那位强人，因为这个词将这个模式使用的方式明白得表示了出来；如果翻译成为羽量级模式或者蝇量级模式等等，虽然可以含蓄的表现出使用此模式达到的目的，但是还是没有抓住此模式的关键。

享元模式的定义为：采用一个共享来避免大量拥有相同内容对象的开销。这种开销中最常见、直观的就是内存的损耗。享元模式以共享的方式高效的支持大量的细粒度对象。

在名字和定义中都体现出了共享这一个核心概念，那么怎么来实现共享呢？要知道每个事物都是不同的，但是又有一定的共性，如果只有完全相同的事物才能共享，那么享元模式可以说就是不可行的；因此我们应该尽量将事物的共性共享，而又保留它的个性。为了做到这点，享元模式中区分了内蕴状态和外蕴状态。内蕴状态就是共性，外蕴状态就是个性了。

注：共享的对象必须是不可变的，不然一变则全变（如果有这种需求除外

内蕴状态存储在享元内部，不会随环境的改变而有所不同，是可以共享的；外蕴状态是不可以共享的，它随环境的改变而改变的，因此外蕴状态是由客户端来保持（因为环境的变化是由客户端引起的）。在每个具体的环境下，客户端将外蕴状态传递给享元，从而创建不同的对象出来。至于怎样来维护客户端保持的外蕴状态和享元内部保持的内蕴状态的对应关系，你先不用担心这个问题，我们后面会涉及到的。

我们引用《Java与模式》中的分类，将享元模式分为：单纯享元模式和复合享元模式。在下一个小节里面我们将详细的讲解这两种享元模式。

三、结构

先从简单的入手，看看单纯享元模式的结构。

1) 抽象享元角色：为具体享元角色规定了必须实现的方法，而外蕴状态就是以参数的形式通过此方法传入。在Java中可以由抽象类、接口来担当。

2) 具体享元角色：实现抽象角色规定的方法。如果存在内蕴状态，就负责为内蕴状态提供存储空间。

3) 享元工厂角色：负责创建和管理享元角色。要想达到共享的目的，这个角色的实现是关键！

4) 客户端角色：维护对所有享元对象的引用，而且还需要存储对应的外蕴状态。

来用类图来形象地表示出它们的关系吧（对类图的了解可以参看我关于类图的blog）。

怎么咋看咋像简单工厂模式呢！没错，可以说结构型的单纯享元模式和创建型的简单工厂模式实现上非常相似，但是它的重点或者用意却和工厂模式截然不同。工厂模式的使用主要是为了使系统不依赖于实现得细节（见《深入浅出工厂模式》）；而在享元模式的主要目的如前面所述：采用共享技术来避免大量拥有相同内容对象的开销。正所谓“旧瓶装新酒”阿！

再来看看复合享元模式的结构。

1) 抽象享元角色：为具体享元角色规定了必须实现的方法，而外蕴状态就是以参数的形式通过此方法传入。在Java中可以由抽象类、接口来担当。

2) 具体享元角色：实现抽象角色规定的方法。如果存在内蕴状态，就负责为内蕴状态提供存储空间。

3) 复合享元角色：它所代表的对象是不可以共享的，并且可以分解成为多个单纯享元对象的组合。

4) 享元工厂角色：负责创建和管理享元角色。要想达到共享的目的，这个角色的实现是关键！

5) 客户端角色：维护对所有享元对象的引用，而且还需要存储对应的外蕴状态。

统比一下单纯享元对象和复合享元对象，里面只多出了一个复合享元角色，但是它的结构就发生了很大的变化。我们还是使用类图来表示下：

你也许又纳闷了，这个也似曾相逢！单看左半部，和简单工厂模式类似；再看右半部，怎么这么像合成模式呢（请参看关于合成模式的文章或者期待我的《深入浅出合成模式》）！合成模式用在此处就是为了将具体享元角色和复合享元角色同等对待和处理，通过将享元模式与合成模式组合在一起，可以确保复合享元中所包含的每个单纯享元都具有相同的外蕴状态，而这些单纯享元的内蕴状态往往是不同的。

四、举例

interface Menu

{

//规定了实现类必须实现设置内外关系的方法

public void setPersonMenu(String person , List list);

//规定了实现类必须实现查找外蕴状态对应的内蕴状态的方法

public List findPersonMenu(String person, List list);

}

这便是具体享元角色了：

class PersonMenu implements Menu

{

private String dish ;

//在构造方法中给内蕴状态附值

public PersonMenu(String dish){

this.dish = dish ;

}

public synchronized void setPersonMenu(String person , List list)

{

list.add(person);

list.add(dish);

}

public List findPersonMenu(String person, List list)

{

List dishList = new ArrayList();

Iterator it = list.iterator();

while(it.hasNext())

{

if(person.equals((String)it.next()))

dishList.add(it.next());

}

return dishList ;

}

享元工厂角色，这可是关键所在，大家注意看！

class FlyweightFactory

{

private Map menuList = new HashMap();

private static FlyweightFactory factory = new FlyweightFactory();

//这里还使用了单例模式，来使工厂对象只产生一个工厂实例

private FlyweightFactory(){}

public static FlyweightFactory getInstance()

{

return factory ;

}

//这就是享元模式同工厂模式的不同所在！！

public synchronized Menu factory(String dish)

{

//判断如果内蕴状态已经存在就不再重新生成，而是使用原来的，否则就重新生成

if(menuList.containsKey(dish))

{

return (Menu)menuList.get(dish);

}else{

Menu menu = new PersonMenu(dish);

menuList.put(dish,menu);

return menu;

}

//来验证下是不是真的少产生了对象

public int getNumber()

{

return menuList.size();

}

我们使用客户程序来试验下吧。

class Client

{

private static FlyweightFactory factory ;

public static void main(String[] args)

{

List list1 = new ArrayList();

factory = FlyweightFactory.getInstance();

Menu list = factory.factory("尖椒土豆丝");