关于java:设计模式10-顺便看看享元模式

设计模式系列：http://aphysia.cn/categories/…

开局还是那种图，各位客官往下看 …

享元模式是什么？

享元模式（FlyWeight），是结构型模式的一种，次要是为了缩小创建对象的数量，缩小内存占用以及进步性能。说到这里，不晓得你是否会想到池技术，比方String 常量池，数据库连接池，缓冲池等等，是的，这些都利用了享元模式。

比方，有一些对象，创立时候须要资源比拟多，创立老本比拟高，内存开销比拟大，如果咱们始终创立，机器吃不消，那么咱们就想到了池化技术，把创立好的对象放在外面，须要时，去池子外面取就能够了，也就是大家共享了池子外面的对象，这就是共享。

听名字，就很共享单车：

享元模式的特点

一般而言，享元对象须要在不同的场景下应用，那状态如果可随便批改，就容易造成凌乱，出错的概率大大增加。然而如果所有的外部属性都是不可批改的，貌似也不是非常灵便，因而为了在稳固和灵活性之间找到平衡点，个别的享元对象，都会将外部属性划分为两大类：

• 外部状态：不可变，且在多个中央中共享，重复使用的局部，只能通过构造函数设值
• 内部状态：每个对象，在不同场景下，可能存在不一样的状态，能够批改

• 单纯享元模式：在单纯享元模式中，所有的具体享元类都是能够共享的，不存在非共享具体享元类。
• 复合享元模式：将一些单纯享元对象应用组合模式加以组合，还能够造成复合享元对象，这样的复合享元对象自身不能共享，然而它们能够分解成单纯享元对象，而后者则能够共享

这里咱们说的是单纯享元模式，享元模式个别会有几种对象：

• 享元接口或则抽象类（Flyweight）: 在接口或者抽象类中申明定义了公共的办法，能够对外提供局部能力，或者按需提供数据。
• 具体的享元实现类（ConcreteFlyweight）: 实现了形象享元类，在外部有一部分数据是不可变的，实现接口的时候，会对外提供一部分能力或者数据。
• 享元工厂(FlyweightFactory): 享元工厂次要是用来创立和治理享元对象的，将各种类型的享元对象放到一个池子里，个别是键值对的模式存在，当然也能够是其余的类型，如果首次获取一个对象，须要先创立，如果池子里曾经有该对象，那么就能够间接返回了。

实现

举个小栗子，比方咱们进来游玩须要购买飞机票，假如一架航班的唯一性是与航班号，登程工夫，达到工夫相干，用户喜爱通过航班号，来查问航班的相干信息，首先咱们须要创立航班一个接口：

public interface IFlight {void info();
}

具体的航班类Flight:

public class Flight implements IFlight {

    private String flightNo;

    private String start;

    private String end;

    private boolean isDelay;

    public Flight(String flightNo, String start, String end) {
        this.flightNo = flightNo;
        this.start = start;
        this.end = end;
        isDelay = Math.random() > 0.5;}

    @Override
    public void info() {System.out.println(String.format("从 [%s] 到[%s]的航班[%s]: %s",
                start, end, flightNo, isDelay ? "延误腾飞" : "失常腾飞"));
    }
}

航班搜寻工厂类FlightSearchFactory：

public class FlightSearchFactory {public static IFlight searchFlight(String flightNo,String start,String end){return new Flight(flightNo,start,end);
    }
}

模仿客户端申请：

public class ClientTest {public static void main(String[] args) {IFlight flight = FlightSearchFactory.searchFlight("C9876","北京","上海");
        flight.info();}
}

咱们能够看到打印出了以下信息：

从 [北京] 到[上海]的航班[C9876]: 延误腾飞 

然而，下面的有一个问题，每次来拜访，都会创立一个对象，坐同一个航班的人，实践上查问的是雷同的数据才对，这部分其实能够共享的，复用来提高效率，何乐而不为呢？

怎么缓存呢？

咱们个别用 HashMap 来缓存，只须要将惟一辨认的 key 定义好即可：

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

public class FlightSearchFactory {private static Map<String, IFlight> maps = new HashMap<>();

    public static IFlight searchFlight(String flightNo, String start, String end) {String key = getKey(flightNo, start, end);
        IFlight flight = maps.get(key);
        if (flight == null) {System.out.print("缓存中没有，须要从新构建：");
            flight = new Flight(flightNo, start, end);
            maps.put(key, flight);
        }else{System.out.print("从缓存中读取数据：");
        }
        return flight;
    }

    private static String getKey(String flightNo, String start, String end) {return String.format("%s_%s_%s", flightNo, start, end);
    }
}

测试代码：

public class ClientTest {public static void main(String[] args) {IFlight flight = FlightSearchFactory.searchFlight("C9876","北京","上海");
        flight.info();

        IFlight flight1 = FlightSearchFactory.searchFlight("C9876","北京","上海");
        flight1.info();

        IFlight flight2 = FlightSearchFactory.searchFlight("H1213","北京","广州");
        flight2.info();}
}

测试后果：

缓存中没有，须要从新构建：从 [北京] 到[上海]的航班[C9876]: 失常腾飞 
从缓存中读取数据：从 [北京] 到[上海]的航班[C9876]: 失常腾飞 
缓存中没有，须要从新构建：从 [北京] 到[广州]的航班[H1213]: 失常腾飞 

能够看到如果缓存外面有，那么就不会从新构建对象，能够达到共享对象的目标，咱们平时在我的项目外面应用的各种连接池，比方 Redis 连接池，Mysql连接池等等，这些资源实质上都比拟贵重，咱们能够共享。

JDK中 Integer 其实也用了缓存的技术，因为大家罕用的都是较小的数值，所以默认 Integer 如果应用 valuesOf(int i) 办法获取，就会优先读取缓存内容：

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

咱们能够看到如果在 low 和high 范畴内的数据，就会从缓存外面获取，否则会间接新建一个对象，那么 low 和high的范畴多大呢？

        static final int low = -128;
        static final int high;

high是动态变化的, 然而 high 是有断言的，必须大于等于 127:assert IntegerCache.high >= 127;, 而范畴能够从java.lang.Integer.IntegerCache.high 这个配置项读取进去：

        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;
        }

测试一下：

public class IntegerTest {public static void main(String[] args) {
        // 不相等
        Integer integer = Integer.valueOf(128);
        Integer integer1 = Integer.valueOf(128);
        System.out.println(integer == integer1);

        // 相等
        Integer integer2 = Integer.valueOf(127);
        Integer integer3 = Integer.valueOf(127);
        System.out.println(integer2 == integer3);

        // 相等
        Integer integer4 = Integer.valueOf(0);
        Integer integer5 = Integer.valueOf(0);
        System.out.println(integer4 == integer5);

        // 相等
        Integer integer6 = Integer.valueOf(-128);
        Integer integer7 = Integer.valueOf(-128);
        System.out.println(integer6 == integer7);

        // 不相等
        Integer integer8 = Integer.valueOf(-129);
        Integer integer9 = Integer.valueOf(-129);
        System.out.println(integer8 == integer9);
    }
}

从下面的后果能够看出实际上 Integer 从-128到 127 被缓存了，也验证了咱们的后果，留神必须应用 Integer.valueOf() 这个方法，要是应用结构器new Integer()，创立进去必然是新的对象。

总结

• 长处：如果有很多类似或者反复的对象，应用享元模式，能够节俭空间
• 毛病：如果重用很多，不同中央还做了特殊化解决，代码复杂度减少

设计模式其实是在软件工程的一直摸索中，总结进去的罕用的一种设计思路，并不是非用不可，不是银弹，然而总有值得咱们学习的中央，理解它这般设计的益处，一直的改良咱们写代码，即便每次一点点改良。已经听过一句话：看见他人写得不优雅的代码就有想重构它的激动，能够多读读本人写的代码，而后写得更好（大抵是这个意思）。共勉！

【作者简介】：
秦怀，公众号【秦怀杂货店】作者，集体网站：http://aphysia.cn，技术之路不在一时，山高水长，纵使迟缓，驰而不息。

剑指 Offer 全副题解 PDF

开源编程笔记