【Java设计模式】—— 享元模式概述和示例

概述

在面向对象程序设计过程中，有时会面临要创建大量相同或相似对象实例的问题。创建那么多的对象将会耗费很多的系统资源，它是系统性能提高的一个瓶颈。

例如，围棋和五子棋中的黑白棋子，图像中的坐标点或颜色，局域网中的路由器、交换机和集线器，教室里的桌子和凳子等。这些对象有很多相似的地方，如果能把它们相同的部分提取出来共享，则能节省大量的系统资源，这就是享元模式的产生背景。

享元模式的定义与特点

享元（Flyweight）模式的定义：顾名思义，利用JVM中的不同变量存储相同地址指向与操作同一片内存空间的特性，实现的对象共享技术，来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。

享元模式的主要优点是：相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。

其主要缺点是：

1. 为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
2. 读取享元模式的外部状态会使得运行时间稍微变长。

享元模式的结构与实现

享元模式的定义提出了两个要求，细粒度和共享对象。因为要求细粒度，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。

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

比如，连接池中的连接对象，保存在连接对象中的用户名、密码、连接URL等信息，在创建对象的时候就设置好了，不会随环境的改变而改变，这些为内部状态。而当每个连接要被回收利用时，我们需要将它标记为可用状态，这些为外部状态。

享元模式的本质是缓存共享对象，降低内存消耗。

1. 模式的结构

享元模式的主要角色有如下：

1. 抽象享元角色（Flyweight）：是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
2. 具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
3. 非享元（Unsharable Flyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
4. 享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

图 1 是享元模式的结构图，其中：

• UnsharedConcreteFlyweight 是非享元角色，里面包含了非共享的外部状态信息 info；
• Flyweight 是抽象享元角色，里面包含了享元方法 operation(UnsharedConcreteFlyweight state)，非享元的外部状态以参数的形式通过该方法传入；
• ConcreteFlyweight 是具体享元角色，包含了关键字 key，它实现了抽象享元接口；
• FlyweightFactory 是享元工厂角色，它是关键字 key 来管理具体享元；
• 客户角色通过享元工厂获取具体享元，并访问具体享元的相关方法。

2. 模式的理论实现

享元模式的实现代码如下：

public class FlyweightPattern {
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();
        Flyweight f01 = factory.getFlyweight("a");
        Flyweight f02 = factory.getFlyweight("a");
        Flyweight f03 = factory.getFlyweight("a");
        Flyweight f11 = factory.getFlyweight("b");
        Flyweight f12 = factory.getFlyweight("b");
        f01.operation(new UnsharedConcreteFlyweight("第1次调用a。"));
        f02.operation(new UnsharedConcreteFlyweight("第2次调用a。"));
        f03.operation(new UnsharedConcreteFlyweight("第3次调用a。"));
        f11.operation(new UnsharedConcreteFlyweight("第1次调用b。"));
        f12.operation(new UnsharedConcreteFlyweight("第2次调用b。"));
    }
}

//非享元角色
class UnsharedConcreteFlyweight {
    private String info;

    UnsharedConcreteFlyweight(String info) {
        this.info = info;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }
}

//抽象享元角色
interface Flyweight {
    public void operation(UnsharedConcreteFlyweight state);
}

//具体享元角色
class ConcreteFlyweight implements Flyweight {
    private String key;

    ConcreteFlyweight(String key) {
        this.key = key;
        System.out.println("具体享元" + key + "被创建！");
    }

    public void operation(UnsharedConcreteFlyweight outState) {
        System.out.print("具体享元" + key + "被调用，");
        System.out.println("非享元信息是:" + outState.getInfo());
    }
}

//享元工厂角色
class FlyweightFactory {
    private HashMap<String, Flyweight> flyweights = new HashMap<String, Flyweight>();

    public Flyweight getFlyweight(String key) {
        Flyweight flyweight = (Flyweight) flyweights.get(key);
        if (flyweight != null) {
            System.out.println("具体享元" + key + "已经存在，被成功获取！");
        } else {
            flyweight = new ConcreteFlyweight(key);
            flyweights.put(key, flyweight);
        }
        return flyweight;
    }
}

程序运行结果如下：

具体享元a被创建！
具体享元a已经存在，被成功获取！
具体享元a已经存在，被成功获取！
具体享元b被创建！
具体享元b已经存在，被成功获取！
具体享元a被调用，非享元信息是:第1次调用a。
具体享元a被调用，非享元信息是:第2次调用a。
具体享元a被调用，非享元信息是:第3次调用a。
具体享元b被调用，非享元信息是:第1次调用b。
具体享元b被调用，非享元信息是:第2次调用b。

享元模式的应用实例

商品秒杀，很多家商铺同时参加，且其中一商品的信息是不变的，但不同的商铺的库存是不同的且会随着变化的。
此时商品信息就是内部状态，是不变的；库存是外部状态，是会变化的。

代码实现

抽象共享角色–商品

public interface Commodity {

    /**
     * 售出
     * @param inventory
     */
    void sell(Inventory inventory);

}

非共享角色–库存

public class Inventory {

    /**
     * 商品库存
     */
    private int num ;

    public Inventory(int num) {
        this.num = num;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
}

具体共享角色–手机商品

public class Phone implements Commodity {

    private String description;

    public Phone(String description) {
        this.description = description;
        System.out.println("商品 ： " + this.description + " 被创建了。");
    }

    @Override
    public void sell(Inventory inventory) {
        int num = inventory.getNum();
        System.out.println(this.description + "将被售出 ，当前库存 ： " + num);
        System.out.println("商品 ： " + this.description + " 被售出。");
        inventory.setNum(--num);
        System.out.println("商品售出后库存 ： " + num);
    }
}

具体共享角色–拖鞋

public class Slipper implements Commodity {

    private String description;

    public Slipper(String description) {
        this.description = description;
    }

    @Override
    public void sell(Inventory inventory) {
        int num = inventory.getNum();
        System.out.println(this.description + "将被售出 ，当前库存 ： " + num);
        System.out.println("商品 ： " + this.description + " 被售出。");
        inventory.setNum(--num);
        System.out.println("商品售出后库存 ： " + num);
    }
}

享元工厂

public class CommodityFactory {
    private Map<String, Commodity> commodityMap = new HashMap<String, Commodity>();

    public Commodity getCommodityInstance(String key) {
        if (!commodityMap.containsKey(key)) {
            if ("拖鞋".equals(key)) {
                commodityMap.put(key,new Slipper("超级拖鞋（航天品质）"));
            } else if ("手机".equals(key)) {
                commodityMap.put(key,new Phone("超级手机（聚变发电）"));
            } else {
                throw new RuntimeException("不存在的手机型号");
            }
        }
        return commodityMap.get(key);
    }
}

入口函数

public class AppMain {

    public static void main(String[] args) {
        CommodityFactory commodityFactory = new CommodityFactory();
        System.out.println("-------商品1-------");
        /**
         * 现有四家店铺，销售描述相同的手机，但每家点的库存不一样
         */
        // 店铺1
        Commodity phone1 = commodityFactory.getCommodityInstance("手机");
        phone1.sell(new Inventory(1000));
        // 店铺2
        Commodity phone2 = commodityFactory.getCommodityInstance("手机");
        phone2.sell(new Inventory(900));
        // 店铺3
        Commodity phone3 = commodityFactory.getCommodityInstance("手机");
        phone3.sell(new Inventory(800));
        // 店铺4
        Commodity phone4 = commodityFactory.getCommodityInstance("手机");
        phone4.sell(new Inventory(300));

        System.out.println("========校验是否是相同对象========");
        System.out.println("phone1 == phone2 ? " + (phone1 == phone2));
        System.out.println("phone2 == phone3 ? " + (phone2 == phone3));
        System.out.println("phone3 == phone4 ? " + (phone3 == phone4));

        System.out.println("-------商品2------测试略---");
        Commodity slipper = commodityFactory.getCommodityInstance("拖鞋");
        slipper.sell(new Inventory(10));
    }
}

享元模式的应用场景

当系统中多处需要同一组信息时，可以把这些信息封装到一个对象中，然后对该对象进行缓存，这样，一个对象就可以提供给多出需要使用的地方，避免大量同一对象的多次创建，降低大量内存空间的消耗。

享元模式其实是工厂方法模式的一个改进机制，享元模式同样要求创建一个或一组对象，并且就是通过工厂方法模式生成对象的，只不过享元模式为工厂方法模式增加了缓存这一功能。

前面分析了享元模式的结构与特点，下面分析它适用的应用场景。享元模式是通过减少内存中对象的数量来节省内存空间的，所以以下几种情形适合采用享元模式。

1. 系统中存在大量相同或相似的对象，这些对象耗费大量的内存资源。

2. 大部分的对象可以按照内部状态进行分组，且可将不同部分外部化，这样每一个组只需保存一个内部状态。

3. 由于享元模式需要额外维护一个保存享元的数据结构，所以应当在有足够多的享元实例时才值得使用享元模式。

   享元模式的在实际工作中的应用

   在前面介绍的享元模式中，其结构图通常包含可以共享的部分和不可以共享的部分。在实际使用过程中，有时候会稍加改变，即存在两种特殊的享元模式：单纯享元模式和复合享元模式，下面分别对它们进行简单介绍。

(1) 单纯享元模式，这种享元模式中的所有的具体享元类都是可以共享的，不存在非共享的具体享元类，其结构图如图 4 所示。

(2) 复合享元模式，这种享元模式中的有些享元对象是由一些单纯享元对象组合而成的，它们就是复合享元对象。虽然复合享元对象本身不能共享，但它们可以分解成单纯享元对象再被共享。

如果希望为多个内部状态不同的享元对象设置相同的外部状态（在上面商品销售案例中，可以理解为给拖鞋**[可以为拖鞋新加一个方法show，用于和手机区别]**和手机分别设置相同的库存），可以考虑使用复合享元模式。

其结构图如图 5 所示。

参考文献

设计模式-C语言中文网