设计模式享元模式

本文通过优化买票的重复流程来说明享元模式，为了加深对该模式的理解，会以String和基本数据类型的包装类对该模式的设计进一步说明。

读者可以拉取完整代码到本地进行学习，实现代码均测试通过后上传到码云。

一、引出问题

鉴于小王之前的优质表现，老王决定带小王出去旅游一下，但在火车站买票时却陷于了长长的队伍。

老王注意到，每次售票员卖票时都重新走一遍卖票的所有流程，很明显，如果始发地和目的地如果一样的成人票和儿童票是可以复用流程的，如果复用的话就可以大大提高卖票效率。

二、概念和使用

上面所说的复用流程实际上就是享元模式的设计思想，它是构造型设计模式之一，它通过共享数据使得相同对象在内存中仅创建一个实例，以降低系统创建对象实例的性能消耗。

享元模式包含三个角色：

（1）抽象享元Flyweight类：享元对象抽象基类或接口。

（2）具体享元ConcreteFlyweight类：实现抽象享元类。

（3）享元工ctory类：厂FlyweightFa享元模式的核心模块，负责管理享元对象池、创建享元对象，保证享元对象可以被系统适当地共享。

当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个符合要求的享元对象，如果已有，享元工厂角色就提供这个已有的享元对象；如果没有就创建一个。

老王基于享元模式开发了一套卖票系统，如果起点和终点一样，成人票和儿童票就可以复用一套流程。

抽象享元类：

/**
 * 抽象享元类
 */
public interface Ticket {
    //显示票价，参数为列车类型
    public void showPrice(String type);

}

具体享元实现类：

/**
 * 享元实现类
 * @author tcy
 * @Date 11-08-2022
 */
public class ConcreteTicket implements Ticket{

    String from;
    String to;
    public ConcreteTicket(String from,String to){
        this.from = from;
        this.to = to;
    }

    @Override
    public void showPrice(String type) {
        if(type.equals("adult")){
            System.out.println("从"+from+"到"+to+"的成人票价为200元");
        }else{
            System.out.println("从"+from+"到"+to+"的儿童票价为100元");
        }

    }
}

享元工厂类：

/**
 * 享元工厂
 * @author tcy
 * @Date 11-08-2022
 */
public class TicketFactory {

    static Map<String,Ticket> map= new ConcurrentHashMap< String,Ticket >();

    public static Ticket getTicket(String from,String to){
        String key = from+to;
        if(map.containsKey(key)){
            System.out.println("使用缓存"+key);
            return map.get(key);
        }else{
            System.out.println("创建对象"+key);
            Ticket ticket = new ConcreteTicket(from,to);
            map.put(key, ticket);
            return ticket;
        }
    }

}

客户端调用：

/**
 * @author tcy
 * @Date 11-08-2022
 */
public class Client {
    public static void main(String[] args) {
        //使用时
        TicketFactory.getTicket("南京","杭州").showPrice("adult");
        TicketFactory.getTicket("南京","杭州").showPrice("children");
    }
}

上面例子是享元模式实现的典型案例。核心其实就是享元工厂类，享元工厂类设置一个缓存池，根据条件判断是否属于一个对象，如果是一个对象就不再重新创建，直接使用缓存池中的。

三、运用

1、jdk中的String就是典型的采用的享元模式的思想。

Java中将String类定义为final（不可改变的），JVM中字符串一般保存在字符串常量池中，java会确保一个字符串在常量池中只有一个拷贝，这个字符串常量池在JDK6.0以前是位于常量池中，位于永久代，而在JDK7.0中，JVM将其从永久代拿出来放置于堆中。

创建一个字符串有两种方式，一种是直接String=”hello”，另外一种是String s =new String(“hello”)，第一种是直接在字符串常量池声明一个变量，第二种方式除了是一个堆中的普通对象以外，还会在字符串常量池保存一份。

我们经常使用的一些基本数据类型的包装类实际上也使用了享元模式。我们以Integer 举例，其他包装类类似。

当我们声明一个变量时，使用Integer i1 = 88，编译器是不会报错的，在这Java上面的一个概念就叫自动装箱，编译器会自动使用valueOf()方法创建一个Integer对象并把值赋给该对象。

查看valueOf()方法，如下：

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

Integer 使用享元模式的核心就在于IntegerCache，它是Integer 的一个内部类。

这里的 IntegerCache 相当于享元设计模式中的享元对象工厂类，既然是享元对象工厂类就一定会有判定一个对象是否一样的条件。


private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];
    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;
    }
    private IntegerCache() {}
}