享元模式 Flyweight Pattern
一、什么是享元模式
Flyweight模式也叫享元模式，原意是“轻量级”模式，它用来解决大量相同对象被多次实例化，从而导致内存被大量占用的情况。享元模式尽可能多地节省对象的生成次数，让多个对象共用一个缓存中的对象。是构造型模式之一，它通过与其他类似对象共享数据来减小内存占用。
常见应用：
1、JDK中的享元模式：
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多相同对象时所产生的不必要的大量的资源消耗。
2、数据库连接池：
享元模式由于其共享特性，可以使用在任何池化的操作中，如线程池、数据库连接池等。数据库连接池是享元模式的一个典型应用。在该应用中，需要一个连接池工厂类ConnectPool，它是多个连接Connection的聚集，其结构如图12-26所示。
 |
享元模式中关键要理解“内蕴状态”（Internal State）和“外蕴状态”（External State）这两个概念：
内蕴状态：存储在享元对象内部，并且是不会随环境的改变而有所不同。因此，一个享元可以具有内蕴状态并可以共享。。
外蕴状态：一个外蕴状态是随环境的改变而改变的、不可以共享的。享元对象的外蕴状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再传入到享元对象内部。外蕴状态不可以影响享元对象的内蕴状态，它们是相互独立的。
享元模式可以分成单纯享元模式和复合享元模式两种形式。
单纯享元模式
在单纯的享元模式中，所有的享元对象都是可以共享的。
二、享元模式的结构
三、享元模式的角色和职责
抽象享元角色：所有具体享元类的父类，规定一些需要实现的公共接口。
具体享元角色：抽象享元角色的具体实现类，并实现了抽象享元角色规定的方法。
享元工厂角色： 负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。
四、用法
调用方在生成Flyweight实例时，不直接通过new的方式而是通过FlyweightFactory#getFlyweight()取得Flyweight的一个实例。
而FlyweightFactory 对象对Flyweight实例进行管理：
调用时当Flyweight的相应实例还未生成时，则：
1，生成Flyweight实例
2，将生成的Flyweight实例保存到对象池中（pooling）
3，返回该Flyweight实例
调用时当Flyweight的相应实例已经生成时，则：
1，从对象池取出该Flyweight实例
2，返回该Flyweight实例
通过以上处理，一方面，FlyweightFactory可以在对象池里只保存最少限度的Flyweight实例；另一方面，调用方可以不用理会FlyweightFactory的内部实现细节而可以取得Flyweight实例。
五、应用场景（享元模式特点）：
系统中会动态产生大量的、无需区分的同一类的对象。
这些对象的状态中具有相对稳定内蕴状态，和经常变化的外蕴状态，拿掉外蕴状态后，同一类享元对 象是不可分辨的。
享元工厂拥有管理和创建享元对象的功能，确保享元对象有限的实例化。
MyCharacter.java
public class MyCharacter { private char mychar; public MyCharacter(char mychar) { this.mychar = mychar; } public void display() { System.out.println(mychar); } }
MyCharacterFactory.java
import java.util.HashMap; import java.util.Map; public class MyCharacterFactory { private Map<Character,MyCharacter> pool; public MyCharacterFactory() { pool = new HashMap<Character,MyCharacter>(); } public MyCharacter getMyCharacter(Character character) { MyCharacter myChar = pool.get(character); if(myChar == null) { myChar = new MyCharacter(character); pool.put(character, myChar); } return myChar; } }
MainClass.java
public class MainClass { public static void main(String[] args) { // MyCharacter myChar1 = new MyCharacter('a'); // MyCharacter myChar2 = new MyCharacter('b'); // MyCharacter myChar3 = new MyCharacter('a'); // MyCharacter myChar4 = new MyCharacter('d'); // // myChar1.display(); // myChar2.display(); // myChar3.display(); // myChar4.display(); // // if(myChar1 == myChar3) { // System.out.println("true"); // } else { // System.out.println("false"); // } //1.创建MyCharacter工厂 MyCharacterFactory factory = new MyCharacterFactory(); //2.从工厂中取出相应的MyCharacter MyCharacter myChar1 = factory.getMyCharacter('a'); MyCharacter myChar2 = factory.getMyCharacter('b'); MyCharacter myChar3 = factory.getMyCharacter('a'); MyCharacter myChar4 = factory.getMyCharacter('d'); myChar1.display(); myChar2.display(); myChar3.display(); myChar4.display(); if(myChar1 == myChar3) { System.out.println("true"); } else { System.out.println("false"); } } }
另一个关于人，老师的，运用了享元模式的例子代码
Person.java
package com.ibeifeng.news; public class Person { private String name; private int age; private String sex; public Person(String name, int age, String sex) { super(); this.name = name; this.age = age; this.sex = sex; } public Person() { } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } }
Teacher.java
package com.ibeifeng.news; public class Teacher extends Person { private String number; public String getNumber() { return number; } public void setNumber(String number) { this.number = number; } public Teacher(String name, int age, String sex,String number) { super(name, age, sex); this.number = number; } public Teacher() { super(); } }
TeacherFactory.java
package com.ibeifeng.news; import java.util.HashMap; import java.util.Map; public class TeacherFactory { private Map<String,Teacher> pool; public TeacherFactory() { pool = new HashMap<String,Teacher>(); } public Teacher getTeacher(String number) { Teacher teacher = pool.get(number); if(teacher == null) { teacher = new Teacher(); teacher.setNumber(number); pool.put(number, teacher); } return teacher; } }
MainClass.java
package com.ibeifeng.news; public class MainClass { public static void main(String[] args) { TeacherFactory factory = new TeacherFactory(); Teacher teacher1 = factory.getTeacher("0102034"); Teacher teacher2 = factory.getTeacher("0102035"); Teacher teacher3 = factory.getTeacher("0102034"); Teacher teacher4 = factory.getTeacher("0102037"); System.out.println(teacher1.getNumber()); System.out.println(teacher2.getNumber()); System.out.println(teacher3.getNumber()); System.out.println(teacher4.getNumber()); if(teacher1 == teacher3) { System.out.println("true"); } else { System.out.println("false"); } } }
复合享元模式
在单纯享元模式中，所有的享元对象都是单纯享元对象，也就是说都是可以直接共享的。还有一种较为复杂的情况，将一些单纯享元使用合成模式加以复合，形成复合享元对象。这样的复合享元对象本身不能共享，但是它们可以分解成单纯享元对象，而后者则可以共享。
复合享元角色所涉及到的角色如下：
● 抽象享元(Flyweight)角色 ：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。
● 具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定出的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。
● 复合享元(ConcreteCompositeFlyweight)角色 ：复合享元角色所代表的对象是不可以共享的，但是一个复合享元对象可以分解成为多个本身是单纯享元对象的组合。复合享元角色又称作不可共享的享元对象。
● 享元工厂(FlyweightFactory)角色 ：本角 色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有 一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个 合适的享元对象。
源代码
抽象享元角色类
public interface Flyweight { //一个示意性方法，参数state是外蕴状态 public void operation(String state); }
具体享元角色类
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); } }
复合享元对象是由单纯享元对象通过复合而成的，因此它提供了add()这样的聚集管理方法。由于一个复合享元对象具有不同的聚集元素，这些聚集元素在复合享元对象被创建之后加入，这本身就意味着复合享元对象的状态是会改变的，因此复合享元对象是不能共享的。
复合享元角色实现了抽象享元角色所规定的接口，也就是operation()方法，这个方法有一个参数，代表复合享元对象的外蕴状态。一个复合享元对象的所有单纯享元对象元素的外蕴状态都是与复合享元对象的外蕴状态相等的；而一个复合享元对象所含有的单纯享元对象的内蕴状态一般是不相等的，不然就没有使用价值了。
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)); } }
运行结果如下：
从运行结果可以看出，一个复合享元对象的所有单纯享元对象元素的外蕴状态都是与复合享元对象的外蕴状态相等的。即外运状态都等于Composite Call。
从运行结果可以看出，一个复合享元对象所含有的单纯享元对象的内蕴状态一般是不相等的。即内蕴状态分别为b、c、a。
从运行结果可以看出，复合享元对象是不能共享的。即使用相同的对象compositeState通过工厂分别两次创建出的对象不是同一个对象。
从运行结果可以看出，单纯享元对象是可以共享的。即使用相同的对象state通过工厂分别两次创建出的对象是同一个对象。
享元模式的优缺点
享元模式的优点在于它大幅度地降低内存中对象的数量。但是，它做到这一点所付出的代价也是很高的：
● 享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。
● 享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。