7，享元模式

一，概念

Flyweight模式也叫享元模式，是构造型模式之一，享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。在JAVA语言中，String类型就是使用了享元模式。

二，例子

三个要素

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

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

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

享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。在JAVA语言中，String类型就是使用了享元模式。享元对象能做到共享的关键是区分内蕴状态(Internal State)和外蕴状态(External State)。

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

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

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

1，单纯享元模式

抽象享元角色(Flyweight)：Person

/**
 * 
 * @类名称：Person
 * @类描述：抽象享元角色(Flyweight)
 * @创建人：zender
 */
public interface Person {
    //一个示意性方法，参数name，sex是外蕴状态
    public void operation(String name, String sex);
}

具体享元角色(ConcreteFlyweight)：Teacher

/**
 * 
 * @类名称：Teacher
 * @类描述：具体享元角色(ConcreteFlyweight)
 * @创建人：zender
 */
public class Teacher implements Person {
    //内温状态
    private String number;
    
    public Teacher() {
        super();
    }
    public String getNumber() {
        return number;
    }
    public void setNumber(String number) {
        this.number = number;
    }
 
    @Override
    //name,sex为外温状态
    public void operation(String name, String sex) {
        System.out.println("身份证：" + number + "，名字：" + name + "，性别：" + sex);
    }
}

享元工厂角色(FlyweightFactory) ：TeacherFactory

/**
 * 
 * @类名称：TeacherFactory
 * @类描述：享元工厂角色(FlyweightFactory) 
 * @创建人：zender
 */
public class TeacherFactory {
    private Map<String,Teacher> pool;
    
    public TeacherFactory() {
        pool = new HashMap<String,Teacher>();
    }
    //获取缓存中的对象
    public Person getTeacher(String number) {
        //判断缓存是否有该对象
        Teacher teacher = pool.get(number);
        if(teacher == null) {
            teacher = new Teacher();
            teacher.setNumber(number);
            pool.put(number, teacher);
        }
        return teacher;
    }
    //返回集合大小
    public void getSize(){
        System.out.println("集合大小："+pool.size());
    }
}

测试：

/**
 * 
 * @类名称：Test
 * @类描述：测试
 * @创建人：zender
 */
public class Test {
    public static void main(String[] args) {
        TeacherFactory factory = new TeacherFactory();
        Person person1 = factory.getTeacher("0102034");
        Person person2 = factory.getTeacher("0102035");
        Person person3 = factory.getTeacher("0102034");
        Person person4 = factory.getTeacher("0102037");
        person1.operation("张三","男");
        person2.operation("张三2","男");
        person3.operation("张三3","男");
        person4.operation("张三4","男");
        System.out.println(person1 == person3);
        factory.getSize();
    }
}

结果：

虽然客户端申请了四个享元对象，但是实际创建的享元对象只有三个，这就是共享的含义。

2，复合享元模式

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

抽象享元角色(Flyweight)：Person

/**
 * 
 * @类名称：Person
 * @类描述：抽象享元角色(Flyweight)
 * @创建人：zender
 */
public interface Person {
    //一个示意性方法，参数name，sex是外蕴状态
    public void operation(String name, String sex);
}

具体享元角色(ConcreteFlyweight)：Teacher

/**
 * 
 * @类名称：Teacher
 * @类描述：具体享元角色(ConcreteFlyweight)
 * @创建人：zender
 */
public class Teacher implements Person {
    //内温状态
    private String number;
    
    public Teacher() {
        super();
    }
    public String getNumber() {
        return number;
    }
    public void setNumber(String number) {
        this.number = number;
    }
 
    @Override
    //name,sex为外温状态
    public void operation(String name, String sex) {
        System.out.println("身份证：" + number + "，名字：" + name + "，性别：" + sex);
    }
}

复合享元角色：Teachers

/**
 * 
 * @类名称：Teachers
 * @类描述：复合享元角色
 * @创建人：zender
 */
public class Teachers implements Person{
    private Map<String, Person> map = new HashMap<String, Person>();
    
    //增加一个新的单纯享元对象到map中
    public void add(String num, Person p){
        map.put(num, p);
    }
 
    @Override
    //name,sex为外温状态
    public void operation(String name, String sex) {
        Person p = null;
        for (String s : map.keySet()) {
            p = map.get(s);
            p.operation(name, sex);
        }
    }
}

享元工厂角色(FlyweightFactory) ：TeacherFactory

/**
 * 
 * @类名称：TeacherFactory
 * @类描述：享元工厂角色(FlyweightFactory) 
 * @创建人：zender
 */
public class TeacherFactory {
    private Map<String,Teacher> pool;
    
    public TeacherFactory() {
        pool = new HashMap<String,Teacher>();
    }
    
    //复合享元工厂方法
    public Person getTeacher(List<String> list){
        //复合享元对象
        Teachers ts = new Teachers();
        for (String string : list) {
            ts.add(string, this.getTeacher(string));
        }
        return ts;
    }
    
    //单纯享元工厂方法
    //获取缓存中的对象
    public Person getTeacher(String number) {
        //判断缓存是否有该对象
        Teacher teacher = pool.get(number);
        if(teacher == null) {
            teacher = new Teacher();
            teacher.setNumber(number);
            pool.put(number, teacher);
        }
        return teacher;
    }
    //返回集合大小
    public void getSize(){
        System.out.println("集合大小："+pool.size());
    }
}

测试：

/**
 * 
 * @类名称：Test
 * @类描述：测试
 * @创建人：zender
 */
public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("0102034");
        list.add("0102035");
        list.add("0102037");
        TeacherFactory tf = new TeacherFactory();
        Person p1 = tf.getTeacher(list);
        Person p2 = tf.getTeacher(list);
        p1.operation("张三", "男");
        System.out.println("---------------------------------");
        p2.operation("张三2", "男");
        System.out.println("---------------------------------");
        System.out.println("复合享元模式是否可以共享对象：" + (p1 == p2));
        
        p1 = tf.getTeacher("0102034");
        p2 = tf.getTeacher("0102034");
        System.out.println("---------------------------------");
        System.out.println("单纯享元模式是否可以共享对象：" + (p1 == p2));
    }
}

结果：

从运行结果可以看出：

（1）一个复合享元对象的所有单纯享元对象元素的外蕴状态都是与复合享元对象的外蕴状态相等的。

（2）一个复合享元对象所含有的单纯享元对象的内蕴状态一般是不相等的。

（3）复合享元对象是不能共享的。

（4）单纯享元对象是可以共享的。