Java设计模式之享元模式

亨元模式(Flyweight Pattern): 如想让某个类的一个实例能用来提供许多”虚拟实例”, 就使用蝇量模式。

享元模式的详解

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

内蕴状态：是指存储在享元对象内部的，并且是不会随着环境的改变而改变的。所以享元对象可以具有内蕴状态，并可以被共享。

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

享元模式有可以分为：单纯享元模式和符合享元模式

单纯享元模式

类图：



角色说明：

抽象享元角色（Flyweight）：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。

具体享元角色（ConcreteFlyweight）：实现抽象享元角色所规定的出的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。

享元工厂角色（FlyweightFactory）：本角色负责创建和管理享元角色。享元工程必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工程角色会检查系统中是否已经有一个符合要求的享元对象。如果已经有了，享元工厂就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂就应当创建一个合适的享元对象。

代码演示，抽象享元类：

public interface Flyweight {
// 示例操作方法，参数state是外蕴状态
public void operation(String state);
}

具体享元类：

public class ConcreteFlyweight implements Flyweight {
private String intrinsicState = null;

// 内蕴状态在构造时作为参数传入,传入之后是不可改变的
public ConcreteFlyweight(String state) {
this.intrinsicState = state;
}

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

}

享元工厂类：

public class FlyweightFactory {
//对象的内蕴状态是不变的，可以作为该对象的标识
private Map<String, Flyweight> resource = new HashMap<String, Flyweight>();

public Flyweight factory(String state) {
// 先从缓存中查找对象，查看是否有适合的对象进行分享
Flyweight fly = resource.get(state);
if (fly == null) {
// 如果没有就应当创建一个合适的Flyweight对象
fly = new ConcreteFlyweight(state);
// 把这个新创建的Flyweight对象添加到缓存中
resource.put(state, fly);
System.out.println(state + "状态对应对象不存在，已经新建一个新的对象");
} else {
System.out.println(state + "状态对应对象已经存在，已从缓存中取出");
}
return fly;
}
}

客户端测试类：

public class Test {

public static void main(String[] args) {

FlyweightFactory factory = new FlyweightFactory();
Flyweight fly = factory.factory("NBA");
fly.operation("Request one");
System.out.println("=============");

fly = factory.factory("CBA");
fly.operation("Request two");
System.out.println("=============");

fly = factory.factory("NBA");
fly.operation("Request three");
}

}

运行结果：

复合享元模式

在单纯享元模式中，所有的享元对象都是单纯享元对象，都可以直接进行共享。还有另一种较为复杂的情况，将一些单纯享元对象复合起来，形成复合享元对象。这种复合享元对象本身是不能共享的，但是可以分解成单纯享元对象，然后进行单纯享元对象的分享。

类图：



角色说明：

复合享元角色（CompositeFlyweight）：复合享元角色所代表第的对象是不可以共享的，但是一个复合享元对象可以分解成为多个单纯享元对象的组合。复合享元角色是不可共享的享元对象。

剩余的角色和单纯享元对象角色说明一样。

代码演示，抽象享元类：

public interface Flyweight {
// 示例操作方法，参数state是外蕴状态
public void operation(String state);
}

具体享元类：

public class ConcreteFlyweight implements Flyweight {
private String intrinsicState = null;

// 内蕴状态在构造时作为参数传入,传入之后是不可改变的
public ConcreteFlyweight(String state) {
this.intrinsicState = state;
}

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

}

复合享元类：

public class CompositeFlyweight implements Flyweight {

private Map<String, Flyweight> compositeResource = new HashMap<String, Flyweight>();

// 复合一个新的单纯享元对象
public void add(String key, Flyweight fly) {
compositeResource.put(key, fly);
}

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

}

}

复合享元对象是由单纯享元对象通过复合而成的，所以有add()这个复合方法。由于复合对象是由不同的子元素，而这些子元素是在复合享元对象创建之后才加入的。这就意味着复合享元对象的内蕴状态是随时会改变的，所以它不能共享。

享元工厂类：

public class FlyweightFactory {
//对象的内蕴状态是不变的，可以作为该对象的标识
private Map<String, Flyweight> resource = new HashMap<String, Flyweight>();

//复合享元的工厂方法
public Flyweight factory(List<String> compositeState) {
CompositeFlyweight compositeFlyweight = new CompositeFlyweight();

for (String state : compositeState) {
compositeFlyweight.add(state, this.factory(state));
}

return compositeFlyweight;
}

public Flyweight factory(String state) {
// 先从缓存中查找对象，查看是否有适合的对象进行分享
Flyweight fly = resource.get(state);
if (fly == null) {
// 如果没有就应当创建一个合适的Flyweight对象
fly = new ConcreteFlyweight(state);
// 把这个新创建的Flyweight对象添加到缓存中
resource.put(state, fly);
System.out.println(state + "状态对应对象不存在，已经新建一个新的对象");
} else {
System.out.println(state + "状态对应对象已经存在，已从缓存中取出");
}
return fly;
}
}

客户端测试类：

public class Test {
public static void main(String[] args) {
List<String > compositeState = new ArrayList<String>();
compositeState.add("NBA");
compositeState.add("CBA");
compositeState.add("NBA");

FlyweightFactory flyFactory = new FlyweightFactory();
Flyweight compositeFly1 = flyFactory.factory(compositeState);
System.out.println("================");
Flyweight compositeFly2 = flyFactory.factory(compositeState);
compositeFly1.operation("Request");

System.out.println("================");
System.out.println("复合享元角色是否可以共享：" + (compositeFly1 == compositeFly2));
System.out.println("================");
String state = "CBA";
Flyweight fly1 = flyFactory.factory(state);
Flyweight fly2 = flyFactory.factory(state);
System.out.println("单纯享元角色是否可以共享：" + (fly1 == fly2));
}
}

运行结果：



享元模式的优点：

享元模式可以很好的降低内存中对象的数量，从而有效的减少内存的消耗。

缺点：

同时享元模式也会使得系统更加复杂，为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。

享元模式将享元对象的状态外部化，而读取外部状态使得云心时间稍微变长。

享元模式的适用场景：

一个系统中存在着大量细粒度的对象；

大量细粒度的对象耗费了大量的内存；

大量细粒度的对象状态中的大部分都可以外部化；

大量细粒度的对象可以按照内蕴状态分成很多组，当把外蕴对象从对象中剔除时，每一个组都可以仅用一个对象代替；

系统不依赖于这些对象的身份，换而言之，这些对象允许不用分辨。

题外话：其实Java中的String类型就使用了享元模式。下面看个简单的例子



这说明了str和str1两个对象引用的是常量池中的同一个字符串常量”Layne”。