SilverLining's Blog

结构型模式-享元模式与组合模式

设计模式系列文章:https://zhum.in/blog/category/notes/design-pattern
Demo code:https://github.com/njZhuMin/BlogSampleCode

享元模式

面向对象可以很好地解决一些灵活性或可扩展性问题,但在很多情况下需要在系统中增加类和 对象的个数。当对象数量太多时,将导致运行代价过高,带来性能下降等问题。享元模式正是为解决这类问题而诞生的。

享元模式 (Flyweight Pattern) 又称为轻量级模式,是对象池的一种实现。例如通过引入线程池,可以避免不停的创建和销毁多个链接对象,减小了性能的损耗。享元模式的宗旨是共享细粒度对象,将多个对同类对象的访问集中管理,不必为每个访问者都创建一个单独的对象,以此来降低内存的消耗。

享元模式把一个对象的状态分成内部状态和外部状态,内部状态即是不变的,外部状态是变化的。通过共享不变的部分,达到减少对象数量并节约内存的目的。

享元模式有三个参与角色:

享元模式的内部状态和外部状态

享元模式的定义为我们提出了两个要求:细粒度和共享对象。

因为要求细粒度对象,所以不可避免地会使对象数量多且性质相近,此时我们就将这些对象的信息分为两个部分:内部状态和外部状态。

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

应用场景

生活中的一些 “共享” 场景:

以共享单车举例,其内部状态有:是否损坏,颜色,款式,编码;外部状态:是否解锁,是否已被借出。

当系统中,多个访问者都需要访问相同的信息时,可以把这些信息(固定的状态属性)封装到一个对象中,然后对该对象进行缓存,这样,就可以将同一个对象提供给多个访问者,避免大量的重复创建同一个对象,消耗大量内存空间。

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

享元模式主要用于以下场景:

  1. 常应用于系统底层的开发,以便解决系统的性能问题。
  2. 系统中需要提供大量相似对象、需要缓冲池的场景。

这里看一个简易的数据库连接池的实现:

public class SimpleConnectionPool {
    private static Vector<Connection> pool;
    private static final int MAX_SIZE = 100;

    private final String url = "jdbc:mysql://localhost:3306/test";
    private final String username = "root";
    private final String password = "root";
    private final String driverClassName = "com.mysql.jdbc.Driver";

    public SimpleConnectionPool() {
        pool = new Vector<Connection>(MAX_SIZE);
        try {
            Class.forName(driverClassName);
            for (int i = 0; i < MAX_SIZE; i++) {
                Connection conn = DriverManager.getConnection(url, username, password);
                pool.add(conn);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public synchronized Connection getConnection() {
        if (pool.size() > 0) {
            Connection conn = pool.get(0);
            pool.remove(conn);
            return conn;
        }
        return null;
    }

    public synchronized void release(Connection conn) {
        pool.add(conn);
    }
}

对于外部使用者来说,其可见的连接对象的状态操作是创建和释放,可用和不可用。但是从连接池内部的角度来看,这些连接对象的内部状态(如用户名、密码、连接 URL 等信息)是不变的,只是对应从缓存中取出和放回并标记其可用状态(外部状态)。这就是享元模式封装对象从而实现复用的核心思想。

而对于大量连接对象创建这个耗时的行为,我们也可以在系统启动时就完成,在查询时节省宝贵的初始化时间。

JDK 中的享元模式

Java 中将 String 类定义为 final 类型,是不可改变的。 JVM 中字符串一般保存在字符串常量池中,java 会确保一个字符串在常量池中只有一个拷贝。这个字符串常量池在 JDK 6.0 以前是位于永久代中的常量池,而在 JDK 7.0 中,JVM 将其从永久代移除,放置于堆内存中。

看测试代码:

public class StringTest {
    public static void main(String[] args) {
        String s1 = "hello";    // 创建 "hello" 常量,s1 -> &"hello"(#0)
        String s2 = "hello";    // "hello" 常量已存在,s2 -> &"hello"(#0)
        System.out.println(s1 == s2);   // true

        String s3 = "he" + "llo";       // 编译期推断出常量已存在,s3 -> &"hello"(#0)
        System.out.println(s1 == s3);   // true

        // 编译时创建常量 "he",运行时在堆上创建 "llo" 对象
        // 相加结果得到新的 "hello" 对象保存在堆上,和常量池中的 "hello" 不是同一个
        String s4 = "he" + new String("llo");   // s4 -> &"hello"(#1)
        System.out.println(s1 == s4);   // false

        String s5 = new String("hello");    // 运行时在堆上创建 "hello" 对象
        System.out.println(s1 == s5);       // false,s5 -> &"hello"(#2)
        System.out.println(s4 == s5);       // false

        String s6 = s5.intern();    // 取 s5 的常量地址,即常量池中的 &"hello"(#0)
        System.out.println(s1 == s6);   // true

        String s7 = "h";        // 创建常量 "h"
        String s8 = "ello";     // 创建常量 "ello"
        // 编译期只认识常量,由于是变量运算,等到运行时才执行结果
        String s9 = s7 + s8;    // 运行时创建 "hello" 对象,s9 -> &"hello"(#3)
        System.out.println(s1 == s9);   // false
    }
}

再举个大家都非常熟悉的例子,Integer 对象也用到了享元模式,其中暗藏玄机:

public class IntegerTest {
    public static void main(String[] args) {
        Integer a1 = Integer.valueOf(127);
        Integer a2 = 100;
        System.out.println(a1 == a2);   // true

        Integer a3 = Integer.valueOf(128);
        Integer a4 = 500;
        System.out.println(a3 == a4);   // false
    }
}

为什么同样的 valueOf 方法行为却不一样呢,这是因为 Integer 底层使用了享元模式缓存了他认为我们最常用的对象,范围是-128 至 127,上限可以通过 java.lang.Integer.IntegerCache.high 参数设置:

public final class Integer extends Number implements Comparable<Integer> {
    public static Integer valueOf(int i) {
        if (i >= -128 && i <= Integer.IntegerCache.high) {
            return Integer.IntegerCache.cache[i + 128];
        }
        return new Integer(i);
    }
}

同样的 Long 类型也应用了类似的缓存机制,只不过范围是固定的:

public static Long valueOf(long l) {
    int offset = true;
    if (l >= -128L && l <= 127L) {
        return Long.LongCache.cache[(int)l + 128];
    }
    return new Long(l);
}

Apache Commons Pool 中的享元模式

对象池化的基本思路是:将用过的对象保存起来,等下一次需要这种对象的时候,再取出来重复使用,从而在一定程度上减少频繁创建对象所造成的开销。用于充当保存对象的 “容器” 对象,被称为 “对象池”(Object Pool,或简称 Pool) 。

Apache Commons Pool 实现了对象池的功能,定义了对象的生成、销毁、激活、钝化等操作及其状态转换,并提供几个默认的对象池实现。

其中有几个重要的对象:

private final Map<IdentityWrapper<T>, PooledObject<T>> allObjects;

小结

享元模式的优点:减少对象的创建,降低内存中对象的数量,降低系统的内存占用,提高效率。
享元模式的缺点:关注对象的内部、外部状态,关注线程安全问题。

享元模式与代理模式:

享元模式与单例模式:
享元模式一般配合工厂模式来使用,而这个享元工厂类一般实现为到单例。否则缓存对象存在多个地方,很难控制。

组合模式

组合模式 (Composite Pattern) 也称为整体-部分 (Part-Whole) 模式,它的宗旨是通过将单个对象(叶子节点)和组合对象(树枝节点)用相同的接口进行表示,使得客户对单个对象和组合对象的使用具有一致性。

组合模式一般用来描述整体与部分的关系,它将对象组织到树形结构中以表示 “部分-整体” 的层次结构,最顶层的节点称为根节点,根节点下面可以包含树枝节点和叶子节点,树枝节点下面又可以包含树枝节点和叶子节点。

组合模式包含三个角色:

  1. 抽象根节点 (Component):定义系统各层次对象的共有方法和属性,可以预先定义一些默认行为和属性;
  2. 树枝节点 (Composite):定义树枝节点的行为,存储子节点,组合树枝节点和叶子节点形成一个树形结构;
  3. 叶子节点 (Leaf):叶子节点对象,其下再无分支,是系统层次遍历的最小单位。

组合模式在代码具体实现上,有两种不同的方式,分别是透明组合模式安全组合模式

应用场景

当子系统与其内各个对象层次呈现树形结构时,可以使用组合模式让子系统内各个对象层次的行为操作具备一致性。

组合模式主要应用场景:

  1. 希望客户端可以忽略组合对象与单个对象的差异
  2. 对象层次具备整体和部分,呈树形结构。

在我们生活中的组合模式也非常常见,比如树形菜单,操作系统目录结构,公司组织架构等。

透明组合模式

透明组合模式是把所有公共方法都定义在 Component 中,这样做的好处是客户端无需分辨叶子节点 (Leaf) 和树枝节点 (Composite),它们具备完全一致的接口。

看一个透明实现的 Directory 类的案例,把所有可能用到的方法都定义到这个最顶层的抽象类中,但是不写任何逻辑处理的代码。

public abstract class Directory {
    protected String name;
    public Directory(String name) {
        this.name = name;
    }

    public void add(Directory dir) {
        throw new UnsupportedOperationException("add not supported");
    }

    public void remove(Directory dir) {
        throw new UnsupportedOperationException("remove not supported");
    }

    public void ls() {
        throw new UnsupportedOperationException("ls not supported");
    }

    public void tree() {
        throw new UnsupportedOperationException("tree not supported");
    }
}

这里有些同学会感到疑惑,为什么不用抽象方法?因为定义了抽象方法,其子类就必须实现,这样便体现不出各子类的细微差异。因此,子类继承此抽象类后,只需要重写有差异的方法来覆盖父类的对应方法即可。

public class File extends Directory {
    public File(String name) {
        super(name);
    }
    @Override
    public void tree() {
        System.out.println(this.name);
    }
}

public class Folder extends Directory {
    private List<Directory> dirs;
    private Integer dirLevel;

    public Folder(String name, Integer dirLevel) {
        super(name);
        this.dirLevel = dirLevel;
        this.dirs = new ArrayList<Directory>();
    }

    @Override
    public void add(Directory dir) {
        this.dirs.add(dir);
    }
    @Override
    public void remove(Directory dir) {
        this.dirs.remove(dir);
    }
    @Override
    public void ls() {
        for (Directory dir : this.dirs) {
            System.out.println(dir.name + (dir instanceof Folder ? "/" : ""));
        }
    }
    @Override
    public void tree() {
        System.out.println(this.name + "/");
        for (Directory dir : this.dirs) {
            if (this.dirLevel != null) {
                for (int i = 0; i < this.dirLevel; i ++) {
                    System.out.print("  ");
                }
                for (int i = 0; i < this.dirLevel; i ++) {
                    if (i == 0) {
                        System.out.print("+");
                    }
                    System.out.print("-");
                }
            }
            dir.tree();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("[Transparent Composite]");

        Folder home = new Folder("Home", 1);
        File a = new File("a.txt");
        File b = new File("b.doc");
        home.add(a);
        home.add(b);

        Folder apps = new Folder("Apps", 2);
        File chrome = new File("Chrome.exe");
        File firefox = new File("Firefox.exe");
        apps.add(chrome);
        apps.add(firefox);

        File word = new File("Word.exe");
        File excel = new File("Excel.exe");
        File ppt = new File("Ppt.exe");
        Folder office = new Folder("Office", 3);
        office.add(word);
        office.add(excel);
        office.add(ppt);

        apps.add(office);
        home.add(apps);

        System.out.println("[List home folder]");
        home.ls();

        System.out.println("[Tree home folder]");
        home.tree();

        // Transparent implement
        // Not safe: caller can call unsupported method defined in Interface
        chrome.ls();
        // Exception in thread "main" java.lang.UnsupportedOperationException: ls not supported
    }
}

透明组合模式的缺点是,叶子节点 (Leaf) 会继承得到一些它所不需要的方法,这与接口隔离的设计原则相违背。

安全组合模式

安全组合模式是只规定系统各个层次的最基础的一致行为,而把组合(树节点)本身的方法放到实现子类中。

还是举文件系统的例子,文件系统有两大层次:文件夹,文件。其中,文件夹能容纳其他层次,为树枝节点;文件为最小单位,为叶子节点。

由于目录系统层次较少,且树枝节点(文件夹)结构相对稳定,而文件可以有很多类型,所以选择使用安全组合模式来实现目录系统,可以避免为叶子类型(文件)引入冗余方法。

public abstract class Directory {
    protected String name;
    public Directory(String name) {
        this.name = name;
    }

    public abstract void tree();
}

public class File extends Directory {
    public File(String name) {
        super(name);
    }
    @Override
    public void tree() {
        System.out.println(this.name);
    }
}

public class Folder extends Directory {
    private List<Directory> dirs;
    private Integer dirLevel;

    public Folder(String name, Integer dirLevel) {
        super(name);
        this.dirLevel = dirLevel;
        this.dirs = new ArrayList<Directory>();
    }
    public void add(Directory dir) {
        this.dirs.add(dir);
    }
    public void remove(Directory dir) {
        this.dirs.remove(dir);
    }
    public void ls() {
        for (Directory dir : this.dirs) {
            System.out.println(dir.name + (dir instanceof Folder ? "/" : ""));
        }
    }

    @Override
    public void tree() {
        System.out.println(this.name + "/");
        for (Directory dir : this.dirs) {
            if (this.dirLevel != null) {
                for (int i = 0; i < this.dirLevel; i ++) {
                    System.out.print("  ");
                }
                for (int i = 0; i < this.dirLevel; i ++) {
                    if (i == 0) {
                        System.out.print("+");
                    }
                    System.out.print("-");
                }
            }
            dir.tree();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("[Safe Composite]");

        Folder home = new Folder("Home", 1);
        File a = new File("a.txt");
        File b = new File("b.doc");
        home.add(a);
        home.add(b);

        Folder apps = new Folder("Apps", 2);
        File chrome = new File("Chrome.exe");
        File firefox = new File("Firefox.exe");
        apps.add(chrome);
        apps.add(firefox);

        File word = new File("Word.exe");
        File excel = new File("Excel.exe");
        File ppt = new File("Ppt.exe");
        Folder office = new Folder("Office", 3);
        office.add(word);
        office.add(excel);
        office.add(ppt);

        apps.add(office);
        home.add(apps);

        System.out.println("[List home folder]");
        home.ls();

        System.out.println("[Tree home folder]");
        home.tree();

        // Safe implement
        // Safe: caller cannot call unsupported method as is defined in subclass
        // chrome.ls();
    }
}

我们可以看到,由于子节点自身的实现并不在接口中公开保留,File 对象就无法调用到 Folder 对象才有的 ls 方法,从而在调用端保证了安全性。

安全组合模式的好处:

缺点:

组合模式在源码中的应用

HashMap

组合模式在源码中应用也是非常广泛的。首先我们来看一个非常熟悉的 HashMap.putAll()方法:

public class HashMap<K, V> extends AbstractMap<K, V> implements Map<K, V>, Cloneable, Serializable {
    public void putAll(Map<? extends K, ? extends V> m) {
        this.putMapEntries(m, true);
    }

    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        if (s > 0) {
            // ...
            Iterator var8 = m.entrySet().iterator();
            while(var8.hasNext()) {
                Entry<? extends K, ? extends V> e = (Entry)var8.next();
                K key = e.getKey();
                V value = e.getValue();
                this.putVal(hash(key), key, value, false, evict);
            }
        }
    }
}

我们看到 putAll() 方法传入的是 Map 对象,Map 就是一个抽象构件(同时这个构件中只支持键值对的存储格式),而 HashMap 是一个中间构件。 HashMap 中的 Node 节点就是叶子节点。

HashMap 中的存储方式是一个静态内部类的数组 Node<K,V>[] tab

static class Node<K, V> implements Entry<K, V> {
    final int hash;
    final K key;
    V value;
    HashMap.Node<K, V> next;

    Node(int hash, K key, V value, HashMap.Node<K, V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }
}

ArrayList

同理,我们常用的 ArrayList 对象中的 addAll()方法,其参数也是 ArrayList 的父类 Collection:

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable {
    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        ++this.modCount;
        int numNew = a.length;
        if (numNew == 0) {
            return false;
        } else {
            Object[] elementData;
            int s;
            if (numNew > (elementData = this.elementData).length - (s = this.size)) {
                elementData = this.grow(s + numNew);
            }

            System.arraycopy(a, 0, elementData, s, numNew);
            this.size = s + numNew;
            return true;
        }
    }
}

MyBatis

再举一个 MyBatis 中非常经典的案例,MyBatis 解析各种 Mapping 文件中的 SQL,设计了一个非常关键的类叫做 SqlNode 。 XML 中的每一个 Node 都会解析为一个 SqlNode 对象,最后把所有的 SqlNode 拼装到一起,从而生成完整的 SQL 语句。

它的顶层设计非常简单:

public interface SqlNode {
    boolean apply(DynamicContext context);
}

apply()方法会根据传入的参数 context,解析该 SqlNode 所记录的 SQL 片段,并调用 DynamicContext.appendSql()方法拼接 SQL 片段。当 SQL 节点下的所有 SqlNode 完成解析后,可以通过 DynamicContext.getSql()获取一条完成的 SQL 语句。

组合模式小结

既然组合模式分为两种实现,那么不同的实现方式会更适合某些特定场景,即具体情况具体分析。

  1. 透明组合模式:适用于系统中绝大多数层次具备相同的公共行为时;代价是为剩下少数层次节点引入不需要的方法。
  2. 安全组合模式:适用于系统中各个层次差异性行为较多或者树节点层次相对稳定(健壮)时。

下面我们再来总结一下组合模式的优缺点。

优点:

  1. 清楚地定义分层次的复杂对象,表示对象的全部或部分层次
  2. 让客户端忽略系统层次的差异,方便对整个层次结构进行控制
  3. 简化客户端代码,符合开闭原则

缺点:

  1. 限制类型时会较为复杂
  2. 使设计变得更加抽象