设计模式之享元模式（六）

发表于 | 分类于 | | 浏览 次
字数统计: 1.3k | 阅读时长 ≈ 4 分钟

享元模式在客户对象间提供共享对象，并且为共享对象创建职责，以便普通对象不需要考虑共享对象创建的问题。通常情况，任何时候都只能有一个客户对象引用该共享对象。当某个客户对象改变该共享对象的状态时，该共享对象不需要通知其他客户对象，然而有时候可能需要让多个客户对象同时共享访问某个对象。

存在这么一种需要在多个客户对象间共享对象的场景：当你需要管理成千上万个小对象时，例如在线电子书中的字符对象。在这种场景下，出于性能的考虑，需要在不同的客户对象间安全地传输这些细粒度的对象。例如：某本书需要A对象，当有很多A对象时，就需要采用某种方法对其建模。

享元模式的意图是通过共享来有效地支持大量细粒度的对象。

享元模式的结构

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

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

其结构图如图所示：
享元模式的结构图

享元模式的实现

非享元角色：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class UnsharedConcreteFlyweight{
    private String info;
    UnsharedConcreteFlyweight(String info)
    {
        this.info=info;
    }
    public String getInfo()
    {
        return info;
    }
    public void setInfo(String info)
    {
        this.info=info;
    }
}

抽象享元角色：

1
2
3
public interface Flyweight{
    public void operation(UnsharedConcreteFlyweight state);
}

具体享元角色：

1
2
3
4
5
6
7
8
9
10
11
public class ConcreteFlyweight implements Flyweight{
    private String key;
    public ConcreteFlyweight(String key){
        this.key = key;
        System.out.println("具体享元"+key+"被创建！");
    }
    public void operation(UnsharedConcreteFlyweight outState){
        System.out.print("具体享元"+key+"被调用，");
        System.out.println("非享元信息是:"+outState.getInfo());
    }
}

享元工厂角色：

1
2
3
4
5
6
7
8
9
10
11
12
13
public 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;
    }
}

运行：

1
2
3
4
5
6
7
8
9
10
11
12
13
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。"));
}

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

常见案例及应用场景

常见案例：Java 中的 String，如果有则返回，如果没有则创建一个字符串保存在字符串缓存池里面。

应用场景：

  • 系统有大量相似对象。
  • 需要缓冲池的场景。

总结

享元模式可以使你共享地访问那些大量出现的细粒度对象。可以将那些需要共享访问，并且不变的部分提取出来。为了确保你的享元对象能够被共享，需要提供并强制客户对象使用享元工厂来查找享元对象。访问修饰符对其他开发者进行了一定的限制，但是内部类的使用使限制更进一步，完全限制了该类仅能由其外部容器访问。在确保客户对象正确地使用享元工厂后，你就可以提供大量细粒度对象的安全共享访问了。

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

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