模板方法模式：剖析模板方法在JDKTomcatMybatis等开源框架中的应用

Posted 2021-07-22 徐同学呀

本篇约2千字，阅读时长约3分钟。河南加油！中国加油！

• 一、模板方法定义

• 二、通用写法

• 三、模板方法在源码架构中的体现

• 1、JDK中模板方法的体现

• 2、Tomcat中生命周期设计用到了模板方法

• 3、Mybatis中模板方法的体现

• 四、要点回顾

This browser does not support music or audio playback. Please play it in Weixin or another browser.

中国加油！

一、模板方法定义

模板方法模式，原理非常简单，在GOF的祖师爷设计模式一书中定义如下：

Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure.

大概的意思就是：在一个方法中定义一个算法骨架，并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。

这里的“算法”，可以理解为广义上的“业务逻辑”，算法骨架就是“模板”，包含算法骨架的方法就是“模板方法”，这也是模板方法模式名字的由来。（摘自《设计模式之美》王争）

从定义可以体会到模板方法模式主要有两个特点：

• 代码复用：所有的子类可以复用父类模板方法的代码。
• 功能扩展：父类留给子类重写的步骤方法就是一个个扩展点，可以在不修改框架源码的情况下，子类基于扩展点定制化框架的功能。

二、通用写法

说实在的，模板方法就是把公共部分，放到抽象父类里让所有子类共享，再留一些扩展方法让子类自行实现，其类图如下：

template method

public interface Template {
    void templateMethod();
}

public abstract class AbstractTemplate implements Template {
    @Override
    public void templateMethod() {
        System.out.println("templateMethod...start");
        step1();
        step2();
        step3();
        System.out.println("templateMethod...end");
    }

    protected abstract void step1();
    protected abstract void step2();
    protected abstract void step3();
}

public class TemplateA extends AbstractTemplate {
    @Override
    protected void step1() {
        System.out.println("TemplateA...step1");
    }

    @Override
    protected void step2() {
        System.out.println("TemplateA...step2");
    }

    @Override
    protected void step3() {
        System.out.println("TemplateA...step3");
    }
}

public class TemplateB extends AbstractTemplate {
    @Override
    protected void step1() {
        System.out.println("TemplateB...step1");
    }

    @Override
    protected void step2() {
        System.out.println("TemplateB...step2");
    }

    @Override
    protected void step3() {
        System.out.println("TemplateB...step3");
    }
}

public class Test {
    public static void main(String[] args) {
        Template templateA = new TemplateA();
        templateA.templateMethod();
        System.out.println("------------------------------");
        Template templateB = new TemplateB();
        templateB.templateMethod();
    }
}
// 控制台输出
templateMethod...start
TemplateA...step1
TemplateA...step2
TemplateA...step3
templateMethod...end
------------------------------
templateMethod...start
TemplateB...step1
TemplateB...step2
TemplateB...step3
templateMethod...end

注意：

抽象父类AbstractTemplate中，step1()、step2()、step3()都是抽象方法，子类必须实现，这也算是模板方法模式的一个缺点吧，但是可以通过提供空方法实现避免子类必须重写这些方法，也可以在空方法体内抛异常，达到不强制实现，但是使用时必须实现的效果。

三、模板方法在源码架构中的体现

1、JDK中模板方法的体现

JDK中用到模板方法的地方实在太多了：

（1）JUC中AQS本身是提供了一套同步控制器的模板，可以通过这一套模板，实现ReentrantLock、ReentrantReadWriteLock、CountDownLatch、Semaphore等。

独占锁的获取释放、共享锁的获取释放，AbstractQueuedSynchronizer都使用了模板方法。拿独占模式获取锁举例，acquire是独占模式获取锁的模板方法，将同步队列的操作放在父类，在进入同步队列前的tryAcquire留给子类实现：

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
    
    public final void acquire(int arg) {
        //若没有抢到锁，则进入等待队列
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            //自己中断自己
            selfInterrupt();
    }
    protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }
}

（2）io模块中有很多用到模板方法的地方，拿InputStream举例，提供了一个read(byte b[], int off, int len)模板方法，同时又留了一个抽象的read()让子类实现：

public abstract class InputStream implements Closeable {
    public abstract int read() throws IOException;
    public int read(byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }
        // 子类需要实现read
        int c = read();
        if (c == -1) {
            return -1;
        }
        b[off] = (byte)c;

        int i = 1;
        try {
            for (; i < len ; i++) {
                c = read();
                if (c == -1) {
                    break;
                }
                b[off + i] = (byte)c;
            }
        } catch (IOException ee) {
        }
        return i;
    }
}

（3）集合中也大量用到模板方法，AbstractList、AbstractCollection等都是很多集合类的父类，所以会把一些公共部分放在抽象父类中，一些可扩展的方法让子类实现。拿AbstractList举例，AbstractList本身也是AbstractCollection的子类：

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    public boolean add(E e) {
        add(size(), e);
        return true;
    }
    public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }
    ... ...
}

2、Tomcat中生命周期设计用到了模板方法

Tomcat中比较明显用到模板方法的是生命周期的设计，所有需要统一生命周期管理的类都可以继承LifecycleBase，LifecycleBase实现了接口Lifecycle。LifecycleBase 实现了init、start、stop、destroy  等生命周期的方法，也是模板方法，做一些生命周期状态的流转和生命周期监听事件的触发，也留了一些抽象方法 initInternal、startInternal、stopInternal、destoryInternal给子类具体实现。Tomcat的一键启动、停止等都得益于其生命周期的设计。

3、Mybatis中模板方法的体现

Mybatis是一个ORM框架，也大量用到模板方法，拿org.apache.ibatis.executor.BaseExecutor举例：

public abstract class BaseExecutor implements Executor {
    
    @Override
  public int update(MappedStatement ms, Object parameter) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    clearLocalCache();
    return doUpdate(ms, parameter);
  }
  protected abstract int doUpdate(MappedStatement ms, Object parameter) throws SQLException;

  protected abstract List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException;

  protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
      throws SQLException;

  protected abstract <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql)
      throws SQLException;
}

四、要点回顾

模板方法模式，非常之简单，也很容易理解，记住两点：代码复用和功能扩展。至于扩展点不想强制让子类实现，可以提供默认空实现，或者抛个异常，只有使用时才提醒子类去实现。

参考：

• 《设计模式之美》王争
• Mybatis3源码
• JDK源码
• Tomcat10源码

注：尽一份绵薄之力！

如若文章有错误理解，欢迎批评指正，同时非常期待你的留言和点赞。

如果觉得有用，不妨点个在看，让更多人受益。