享元模式（FlyWeight Pattern）及其在java自动拆箱、自动装箱中的运用

本文主要从三个方面着手，第一：简要介绍享元模式。第二：享元模式在基本类型封装类中的运用以Integer为例进行阐述。第三：根据第一、第二的介绍，进而推出java是如何实现自动拆箱与装箱的。

第一：简要介绍享元模式。

享元模式的角色：抽象享元类（FlyWeight）、具体享元类（ConcreteFlyWeight）、享元工厂类（FlyWeightFactory）、客户类（Client，相当于一个测试类）

至于FlyWeight pattern如果直接翻译应译为： 蝇量级模式。从蝇量级我们可以知道共享的对象是非常小的。在Integer中共享的数字范围为[-128,127]。老外是不是从共享的对象太小的角度，所以称它为FlyWeight Pattern呢？。

我国人是从FlyWeight Pattern的用途（FlyWeight Pattern 的用途就是共享对象。元，也就是最小的意思。享元就是共享最小对象。）上进行翻译的。

下面给出各个角色的代码：

FlyWeight的代码如下：

package com.qls.flyWeight2;

public interface FlyWeight {
	//以外蕴状态【external state】为参数的商业方法。这里假设外蕴状态是String类型的。
	void operation(String externalState);
}

　ConcreteFlyWeight的代码如下：

package com.qls.flyWeight2;

public class ConcreteFlyWeight implements FlyWeight {
    //内蕴状态的私有字段[internal state]
    private Character internalState;
    //构造一个以内蕴状态为参数的构造方法
    public ConcreteFlyWeight(Character internalState) {
        this.internalState = internalState;
    }
    @Override
    public void operation(String externalState) {
        // TODO Auto-generated method stub
        System.out.println("internalState="+internalState+" externalState="+externalState);
    }

}

FlyWeightFactory的代码如下：

package com.qls.flyWeight2;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class FlyWeightFactory {
    Map<Character,FlyWeight> files=new HashMap<Character,FlyWeight>();
    //构造方法
    public FlyWeightFactory() {
        // TODO Auto-generated constructor stub
    }
    //写一个以内蕴状态的工厂方法，以生产FlyWeight对象。
    public FlyWeight factory(Character internalState){
        if(files.containsKey(internalState)){
            return files.get(internalState);
        }else{
            FlyWeight flyWeight = new ConcreteFlyWeight(internalState);
            //把对象保存到Map集合中。
            files.put(internalState, flyWeight);
            return flyWeight;
        }
    }
    public void checkFlyWeight(){
        //打印出FlyWeight对象，以及享元对象。
                for(Entry<Character, FlyWeight> en:files.entrySet()){
                    System.out.println(en.getKey()+"="+en.getValue());
                }
    }
}

Client的代码如下：

package com.qls.flyWeight2;

public class Client {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //创建一个享元工厂对象
        FlyWeightFactory flyWeightFactory = new FlyWeightFactory();
        //向享元工厂对象请求一个内蕴状态为'a'的享元对象
        FlyWeight factory = flyWeightFactory.factory(new Character('a'));
        //以参量方式传入一个外蕴状态。
        factory.operation("ouyangfeng");
        //向享元工厂对象请求一个内蕴状态为'b'的享元对象
        FlyWeight factory2 = flyWeightFactory.factory(new Character('b'));
        //以参量方式传入一个外蕴状态。
        factory.operation("sixi");
        //向享元工厂对象请求一个内蕴状态为'a'的享元对象
        FlyWeight factory3 = flyWeightFactory.factory(new Character('a'));
        //以参量方式传入一个外蕴状态。
        factory.operation("wallow");
        System.out.println(factory==factory3);//返回结果为true。由此可以确定'a'确实做到了享元（共享元数据）
        /**
         * 打印出享元对象。以及内蕴状态。目的是证明对相同的内蕴状态只创建一个对象。
         * 下面语句的输出结果是：
         * b=com.qls.flyWeight2.ConcreteFlyWeight@21780f30
            a=com.qls.flyWeight2.ConcreteFlyWeight@512d297a
            这个输出结果证明了：factory==factory3.
         */
        flyWeightFactory.checkFlyWeight();
    }

}

第二：享元模式在基本类型封装类中的运用以Integer为例进行阐述。

首先概述一下：在Integer类中享元对象是保存在一个IntegerCache.cache[]这个数组里面的这个数组存放的内容是：[-128,127]之间的数字，这个范围中的Integer，对象只创建一次。

所以你要测验：Integer a=-128; Integer b=-128 ; System.out.println(a==b);输出结果为true. 而Integer c=-129; Integer b=-129 ; System.out.println(a==b);输出结果为false.

要想说清楚这个问题只需看一看private static class IntegerCache 、 public static Integer valueOf(int i)、 public int intValue() 这三个类的源码即可。

private static class IntegerCache的源码如下：（注：在这个源码中我添加了，对这个源码的一些解释）

 private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];
//静态代码块保证了，Integer cache[]在IntegerCache加载时就会被赋值。赋值的结果见第22行
        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);//这个循环语句等价于Integer[] cache={new Integer(-128),new Integer(-127),new Integer(-126).........new Integer(126),new Integer(127)}共127+128+1=256个数字。
        }//当我们在Integer a=f;直接从这个cache[]数组中进行搜索如果f在[-128,127]之间（例如Integer a=1）不需要new Integer(1)了，而是在这个cache[]数组中等于1的值直接赋值。反之如果 f不在[-128,127]之间则会new Integer(f);这个源代码见下面的valueOf
//即可豁然开朗。同时这也体现了享元模式的运用。在享元模式示例中用HashMap存放对象，对同一个对象只创建一次。这里用的是数组存放对象，对同一个对象也只创建一次。
        private IntegerCache() {}
    }

valueOf的源代码如下：

 public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

public static Integer valueOf(int i)这个方法用于把int转换为Integer，它是编译器用于自动装箱的核心方法。由编译器根据代码的实际情况，决定是否调用这个方法。一句话在把int变为Integer时，编译器会自动调用这个方法。
intValue()的源代码如下：

 public int intValue() {
        return value;
    }

public int intValue()这个方法用于把Integer转换为int的。

，它是编译器用于自动拆箱的核心方法。由编译器根据代码的实际情况，决定是否调用这个方法。一句话在把Integer变为int时，编译器会自动调用这个方法。

下面这个例子说明在一下三种情况编译器是如何工作的：三种情况是：int 与Integer    Integer与Integer    int 与int

package com.qls.gateway;

public class Test6 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int g=1;
        int a=1;
        int f=189;
        //b与c在[-128,127]这个范围内。
        Integer b=1;
        Integer c=1;
        //d和e不在[-128,-127]这个范围内。
        Integer d=189;
        Integer e=189;
        System.out.println(a==g);//true【这个是int 与int的比较】
        /**
         * 从这两个输出语句System.out.println(f==d);
        System.out.println(a==b);得出一个结论当int 与Integer比较时，编译器会把Integer自动拆箱。
        证明如下：假设当int 与Integer比较时，编译器会把int自动装箱。那么int f=189.自动装箱过后变为
        new Integer(189)相当于用创建了一个对象所以与Integer d=189。不可能是同一个对象，那么f==d也就为
        false了，但是输出结果为true。所以假设不成立。
        所以当int 与Integer比较时，编译器会把Integer自动拆箱。
         */
        System.out.println(f==d);
        System.out.println(a==b);
        /**
         * Integer与Integer比较时：只需看Integer的范围是否在[-128,127]如果在直接从cache[]数组中取，
         * 则必然是同一个对象，反之如果不在，则会创建一个对象。
         */
        System.out.println(d==e);//输出false
        System.out.println(b==c);//输出true.
    }

}