设计模式系列 — 享元模式持续更新中...... 23种设计模式快速记忆的请看上面第一篇，本篇和大家一起来学习享元模式。

点赞再看，养成习惯，公众号搜一搜【一角钱技术】关注更多原创技术文章。本文 GitHub org_hejianhui/JavaStudy 已收录，有我的系列文章。

前言

23种设计模式快速记忆的请看上面第一篇，本篇和大家一起来学习享元模式。在了解什么是享元模式之前，你一定见过下面这样的面试题：

public class FlyweightTest {
    public static void main(String[] args) {
        Integer a = Integer.valueOf(127);
        Integer b = new Integer(127);
        System.out.println(a == b);
        int c = 127;
        System.out.println(a == c);
        System.out.println(b == c);
    }
}

如果你能一下看出答案是什么，相信你对享元模式或多或少有一定概念。答案我们在文末输出。

模式定义

运用共享技术有效地支持大量细粒度的对象。

享元模式要求细粒度对象，那么就会使得对象数量多且性质相近，因此我们将对象信息分为两个部分：内部状态（intrinsic） 和 外部状态（extrinsic）：

内部状态：对象共享出来的信息，存储在享元对象内部并且不会随环境改变而改变；
外部状态：是对象得以依赖的一个标记，是随环境的改变而改变的，不可以共享的状态；

解决的问题

享元模式能够解决重复对象的内存浪费问题，当系统中有大量相似对象，需要缓冲池时。不需要总是创建对象，可以从缓冲池中拿。这样可以降低系统内存，同时提高效率。

实例说明

步骤1：抽象享元角色，定义一个对象的外部状态和内部状态的接口或实现的抽象类。

abstract class Flyweight {

    //内部状态
    private String intrinsic;
    //外部状态
    protected  final String Extrinsic;

    //要求享元角色必须接受外部状态
    public Flyweight(String _Extrinsic){
        System.out.println(" Extrinsic: "+ _Extrinsic +" created. ");
        this.Extrinsic=_Extrinsic;
    }

    //定义业务操作
    public abstract void operate();

    //内部状态的getter/setter
    public String getIntrinsic() {
        return intrinsic;
    }

    public void setIntrinsic(String intrinsic) {
        this.intrinsic = intrinsic;
    }
}

步骤2：具体享元角色，定义具体的一个产品类，需要注意的是内部状态处理应该与环境无关，不应该出现一个操作改变了外部状态，同时也改变了内部状态。

class ConcreteFlyweight extends Flyweight {
    
    //接受外部状态
    public ConcreteFlyweight(String _Extrinsic){
        super(_Extrinsic);
    }
    
    //根据外部状态进行逻辑处理
    @Override
    public void operate() {
        //业务逻辑
    }
}

步骤3：享元工厂，构造一个池容器，提供从池中获得对象的方法。

public class FlyweightFactory {
    //定义一个池容器
    private static HashMap<String,Flyweight> pool=new HashMap<>();
    //享元工厂
    public static Flyweight getFlyweight(String Extrinsic){
        //需要返回的对象
        Flyweight flyweight=null;
        //如果在池中有该对象,直接从池中拿
        if (pool.containsKey(Extrinsic)){
            flyweight=pool.get(Extrinsic);
        }else { //如果池中没有该对象，则创建一个并放入池中
            flyweight=new ConcreteFlyweight(Extrinsic);
            pool.put(Extrinsic,flyweight);
        }
        return flyweight;
    }
}

步骤4：验证输出

/**
 * 享元模式
 */
public class FlyweightPattern {
    public static void main(String[] args) {

        Flyweight flyweight1 = FlyweightFactory.getFlyweight("1");
        Flyweight flyweight2 = FlyweightFactory.getFlyweight("1");
        Flyweight flyweight3 = FlyweightFactory.getFlyweight("2");

    }
}

外部状态为1的只创建了一次。

优点

减少了应用程序创建的对象数量，降低内存的占用，增强了程序的性能。

缺点

增加了系统的复杂性，需要分离出外部状态和内部状态，并且外部状态具有固化属性，不应该随内部状态改变而改变。

应用场景

常用于系统底层开发，以便解决系统的性能问题。像数据库连接池，里面都是创建好的连接对象，在这些连接对象中有我们需要的则直接拿来用，避免重新创建。如果没有我们需要的，则创建一个。

在一个系统中有大量相似对象，需要缓冲池的场景。不需要一直创建一个新的对象，可以直接从缓冲池里拿。这样可以降低系统内存，同时提高效率。

系统中存在大量的相似对象；
细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关；
需要缓冲池的场景

源码中的应用

Integer、Lang、Byte、String等都用到了享元模式

Integer、Lang、Byte中的valueOf()方法用到了享元模式，String常量池就是享元模式。

#JDK
String,Integer,Long...
com.sun.org.apache.bcel.internal.generic.InstructionConstants
......

总结

回头看一下开头的例子

public class FlyweightTest {
    public static void main(String[] args) {
        Integer a = Integer.valueOf(127);
        Integer b = new Integer(127);
        System.out.println(a == b);
        int c = 127;
        System.out.println(a == c);
        System.out.println(b == c);
    }
}

输出结果为：

false
true
true

具体看一下valueOf()方法的源码实现：

//valueOf()方法的具体实现
public static Integer valueOf(int i) {
	//IntegerCache.low=-128，IntegerCache.high=127
	if (i >= IntegerCache.low && i <= IntegerCache.high)
    	return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
}

//Integer类中的静态方法，
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) {
    	try {
        	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);
        } catch( NumberFormatException nfe) {
          	// If the property cannot be parsed into an int, ignore it.
          }
     }
     high = h;

     cache = new Integer[(high - low) + 1];
     int j = low;
     for(int k = 0; k < cache.length; k++)
     	cache[k] = new Integer(j++);

     // range [-128, 127] must be interned (JLS7 5.1.7)
     assert IntegerCache.high >= 127;
}

在上面的源代码我们可以看到，如果Integer.valueOf(int i)中传递的i在[-128,127]之间，就会直接从IntegerCache.cache[i + (-IntegerCache.low)]中取一个出来，如果不在这个范围，才会去创建一个新的Integer。

看完源码就会发现在valueOf这个方法中它会先判断传进去的值是否在IntegerCache中，如果不在就创建新的对象，在就直接返回缓存池里的对象。这个valueOf方法就用到享元模式。它将-128到127的Integer对象先在缓存池里创建好，等我们需要的时候直接返回即可。所以在-128到127中的数值我们用valueOf创建会比new更快。

这里就可以很清晰的看出来a和b的内存不相等。结果当然是false。

int类型和Integer比较的时候会自动的拆箱也就是只比较里面的值大小是否相等，所以上面的答案就是false，true，true。

回到我们的设计模式上来，在实际的场景中我们更多的是完成缓冲池的创建，来达到缓冲池对象里面复用的功能。就像下面这种情况，尽管我定义了两个不同的对象，但实际上我指向的是同一块内存地址，这样就减少了系统内存，并且使系统的响应速度更快。

PS：以上代码提交在 Github ：github.com/Niuh-Study/…

文章持续更新，可以公众号搜一搜「一角钱技术」第一时间阅读，本文 GitHub org_hejianhui/JavaStudy 已经收录，欢迎 Star。