第14章享元模式

14.1 享元模式概述

享元池（Flyweight Pool）：存储共享对象的地方。
享元模式以共享的方式高效地支持大量细粒度对象的重用，享元对象能做到共享的关键是区分了内部状态（Intrinsic State） 和外部状态（Extrinsic State）。

内部状态是存储在享元对象内部并且不会随环境改变而改变的状态，内部状态可以共享。例如字符的内容不会随外部环境的变化而变化，无论在任何环境下字符“a”始终是“a”,都不会变成“b”。
外部状态是随环境改变而改变的、不可以共享的状态。享元对象的外部状态通常由客户端保存，并在享元对象被创建之后需要使用的时候再传入到享元对象内部。一个外部状态与另一个外部状态之间是相互独立的。例如字符的颜色，可以在不同的地方有不同的颜色，例如有的“a”是红色的，有的“a”是绿色的，字符的大小也是如此，有的“ a”是五号字，有的"a”是四号字。而且字符的颜色和大小是两个独立的外部状态，它们可以独立变化，相互之间没有影响，客户端可以在使用时将外部状态注入享元对象中。

享元模式（Flyweight Pattern）：运用共享技术有效地支持大量细粒度对象的复用。

轻量级模式
对象结构型模式

14.2 享元模式结构与实现

14.2.1 享元模式结构

通常结合工厂模式一起使用

Flyweight（抽象享元类）：抽象享元类通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）。
ConcreteFlyweight（具体享元类）：具体享元类实现了抽象享元类，其实例称为享元对象；在具体享元类中为内部状态提供了存储空间。通常可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。
UnsharedConcreteFlyweight（非共享具体享元类）：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建。
FlyweightFactory（享元工厂类）：享元工厂类用于创建并管理享元对象，它针对抽象享元类编程，将各种类型的具体享元对象存储在一个享元池中，享元池一般设计为一个存储“键值对”的集合（也可以是其他类型的集合），可以结合工厂模式进行设计；当用户请求一个具体享元对象时，享元工厂提供一个存储在享元池中已创建的实例或者创建一个新的实例（如果不存在），返回新创建的实例并将其存储在享元池中。

14.2.2 享元模式实现

享元类 Flyweight：

public abstract class Flyweight {
    public abstract void operation(String extrinsicState);
}

具体享元类 ConcreteFlyweight：

public class ConcreteFlyweight extends Flyweight {
    //内部状态intrinsicState作为成员变量,同一个享元对象的内部状态是一致的
    private String intrinsicState;

    public ConcreteFlyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }

    //外部状态extrinsicState在使用时由外部设置,不保存在享元对象中,即使是同一个对象,
    //在每一次调用时可以传入不同的外部状态
    public void operation(String extrinsicState) {
        //实现业务方法
    }
}

非共享具体享元类 UnsharedConcreteFlyweight：

public class UnsharedConcreteFlyweight extends Flyweight {
    public void operation(String extrinsicState) {
    //实现业务方法
    }
}

享元工厂类 FlyweightFactory：

public class FlyweightFactory {
    //定义一个HashMap用于存储享元对象，实现享元池
    private HashMap flyweights = new HashMap();

    public Flyweight getFlyweight(String key) {
        //如果对象存在,则直接从享元池获取
        if (flyweights.containsKey(key)) {
            return (Flyweight) flyweights.get(key);
        }
        //如果对象不存在，先创建一个新的对象添加到享元池中，然后返回
        else {
            Flyweight fw = new ConcreteFlyweight();
            flyweights.put(key, fw);
            return fw;
        }
    }
}

14.3 享元模式应用实例

实例说明

某软件公司要开发一个围棋软件﹐其界面效果如图

该软件公司的开发人员通过对围棋软件进行分析发现，在围棋棋盘中包含大量的黑子和白子，它们的形状、大小一模一样,只是出现的位置不同而已。如果将每一个棋子作为一个独立的对象存储在内存中，将导致该围棋软件在运行时所需的内存空间较大，那么如何降低运行代价、提高系统性能是需要解决的一个问题。
为了解决该问题，现使用享元模式来设计该围棋软件的棋子对象。

实例类图

抽象享元类
- IgoChessman
具体享元类
- BlackIgoChessman
- WhiteIgoChessman
享元工厂类
- IgoChessmanFactory

实例代码

IgoChessman：围棋棋子类，充当抽象享元类。

package designpatterns.flyweight.simple;

public abstract class IgoChessman extends designpatterns.flyweight.extend.IgoChessman {
    public abstract String getColor();

    public void display() {
        System.out.println("棋子颜色:" + this.getColor());
    }
}

BlackIgoChessman：黑色棋子类，充当具体享元类。

package designpatterns.flyweight.simple;

public class BlackIgoChessman extends IgoChessman{
    @Override
    public String getColor() {
        return "黑色";
    }
}

WhiteIgoChessman：白色棋子类，充当具体享元类。

package designpatterns.flyweight.simple;

public class WhiteIgoChessman extends IgoChessman {
    @Override
    public String getColor() {
        return "白色";
    }
}

IgoChessmanFactory：围棋棋子工厂类，充当享元工厂类，使用单例模式对其进行设计。

package designpatterns.flyweight.simple;

import java.util.Hashtable;

public class IgoChessmanFactory {
    private static IgoChessmanFactory instance = new IgoChessmanFactory();
    private static Hashtable ht;

    private IgoChessmanFactory() {
        ht = new Hashtable();
        IgoChessman balck, white;
        balck = new BlackIgoChessman();
        ht.put("b", balck);
        white = new WhiteIgoChessman();
        ht.put("w", white);
    }

    //返回享元工厂类的唯一实例
    public static IgoChessmanFactory getInstance() {
        return instance;
    }

    //通过key获取存储在Hashtable中的享元对象
    public static IgoChessman getIgoChessman(String color) {
        return (IgoChessman) ht.get(color);
    }
}

Client：客户端测试类。

package designpatterns.flyweight.simple;

public class Client {
    public static void main(String[] args) {
        IgoChessman black1, black2, black3, white1, white2;
        IgoChessmanFactory factory;

        //获取享元工厂对象
        factory = IgoChessmanFactory.getInstance();

        //通过享元工厂获取三颗黑子
        black1 = factory.getIgoChessman("b");
        black2 = factory.getIgoChessman("b");
        black3 = factory.getIgoChessman("b");
        System.out.println("判断三颗黑子是否相同:" + (black1 == black2));

        //通过享元工厂获取两颗白子
        white1 = factory.getIgoChessman("w");
        white2 = factory.getIgoChessman("w");
        System.out.println("判断三颗白子是否相同:" + (white1 == white2));

        //显示棋子
        black1.display();
        black2.display();
        black3.display();
        white1.display();
        white2.display();
    }
}

结果分析

14.4 有外部状态的享元模式

对14.3节的应用实例中的围棋棋子进行进一步分析,不难发现虽然黑色棋子和白色棋子可以共享，但是它们将显示在棋盘的不同位置，如何让相同的黑子或者白子能够多次重复显示且位于一个棋盘的不同地方？解决方法之一就是将棋子的位置定义为棋子的一个外部状态，在需要时再进行设置。
增加了一个新的类Coordinates（坐标类），用于存储每一个棋子的位置。

package designpatterns.flyweight.extend;

public class Coordinates {
    private int x;
    private int y;

    public Coordinates(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

package designpatterns.flyweight.extend;

public abstract class IgoChessman {
    public abstract String getColor();

    public void display(Coordinates coordinates) {
        System.out.println("棋子颜色:" + this.getColor() + ",棋子位置:" + coordinates.getX() + "," + coordinates.getY());
    }
}

package designpatterns.flyweight.extend;


import designpatterns.flyweight.simple.IgoChessmanFactory;

public class Client {
    public static void main(String[] args) {
        IgoChessman black1, black2, black3, white1, white2;
        IgoChessmanFactory factory;

        //获取享元工厂对象
        factory = IgoChessmanFactory.getInstance();

        //通过享元工厂获取三颗黑子
        black1 = factory.getIgoChessman("b");
        black2 = factory.getIgoChessman("b");
        black3 = factory.getIgoChessman("b");
        System.out.println("判断三颗黑子是否相同:" + (black1 == black2));

        //通过享元工厂获取两颗白子
        white1 = factory.getIgoChessman("w");
        white2 = factory.getIgoChessman("w");
        System.out.println("判断三颗白子是否相同:" + (white1 == white2));

        //显示棋子
        black1.display(new Coordinates(1, 2));
        black2.display(new Coordinates(3, 4));
        black3.display(new Coordinates(1, 3));
        white1.display(new Coordinates(2, 5));
        white2.display(new Coordinates(2, 4));
    }
}

14.5 单纯享元模式与复合享元模式

单纯享元模式

复合享元模式

希望为多个内部状态不同的享元对象设置相同的外部状态，考虑使用复合享元模式。

14.6 享元模式与 String 类

package designpatterns.flyweight;

public class Demo {
    public static void main(String[] args) {
        String str1 = "abcd";
        String str2 = "abcd";
        String str3 = "ab" + "cd";
        String str4 = "ab";
        str4 += "cd";
        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        System.out.println(str1 == str4);
        str2 += "e";
        System.out.println(str1 == str2);
    }
}

str1，str2，str3 在内存中引用了相同的对象;
由于 str4 的初始值不同，在创建 str4 时重新分配了内存；
对 str2 进行修改时将创建一个新的对象，修改工作在新对象上完成，而原来引用的对象并没有发生任何改变，strl 仍然引用原有对象，而str2引用新对象，strl 与 str2 引用了两个完全不同的对象。

14.7 享元模式优/缺点与适用环境

14.7.1 享元模式优点

享元模式可以减少内存中对象的数量，使得相同或者相似对象在内存中只保存一份，从而可以节约系统资源，提高系统性能。
享元模式的外部状态相对独立，而且不会影响其内部状态，从而使享元对象可以在不同的环境中被共享。

14.7.2 享元模式缺点

享元模式使系统变得复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化。
为了使对象可以共享，享元模式需要将享元对象的部分状态外部化，而读取外部状态将使运行时间变长。

14.7.3 享元模式适用环境

一个系统有大量相同或者相似的对象，造成内存的大量耗费。
对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。
在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此应当在需要多次重复使用享元对象时才使用享元模式。

posted @ 2022-04-18 23:26 手持六脉神剑的外星人阅读(43) 评论(0) 编辑收藏举报

刷新页面返回顶部

手持六脉神剑的外星人

第14章 享元模式