推荐 原创 视频 Java开发 iOS开发 前端开发 JavaScript开发 Android开发 PHP开发 数据库 开发工具 Python开发 Kotlin开发 Ruby开发 .NET开发 服务器运维 开放平台 架构师 大数据 云计算 人工智能 开发语言 其它开发
Lambda在线 > 徐同学呀 > 模板方法模式:剖析模板方法在JDK、Tomcat、Mybatis等开源框架中的应用

模板方法模式:剖析模板方法在JDK、Tomcat、Mybatis等开源框架中的应用

徐同学呀 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.

模板方法模式:剖析模板方法在JDK、Tomcat、Mybatis等开源框架中的应用

中国加油!

一、模板方法定义

模板方法模式,原理非常简单,在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本身是提供了一套同步控制器的模板,可以通过这一套模板,实现ReentrantLockReentrantReadWriteLockCountDownLatchSemaphore等。

独占锁的获取释放、共享锁的获取释放,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)集合中也大量用到模板方法,AbstractListAbstractCollection等都是很多集合类的父类,所以会把一些公共部分放在抽象父类中,一些可扩展的方法让子类实现。拿AbstractList举例,AbstractList本身也是AbstractCollection的子类:

public abstract class AbstractList<Eextends AbstractCollection<Eimplements 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中比较明显用到模板方法的是生命周期的设计,所有需要统一生命周期管理的类都可以继承LifecycleBaseLifecycleBase实现了接口LifecycleLifecycleBase 实现了initstartstopdestroy  等生命周期的方法,也是模板方法,做一些生命周期状态的流转和生命周期监听事件的触发,也留了一些抽象方法 initInternalstartInternalstopInternaldestoryInternal给子类具体实现。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源码
注:尽一份绵薄之力!
如若文章有错误理解,欢迎批评指正,同时非常期待你的留言和点赞。
如果觉得有用,不妨点个在看,让更多人受益。

版权声明:本站内容全部来自于腾讯微信公众号,属第三方自助推荐收录。《模板方法模式:剖析模板方法在JDK、Tomcat、Mybatis等开源框架中的应用》的版权归原作者「徐同学呀」所有,文章言论观点不代表Lambda在线的观点, Lambda在线不承担任何法律责任。如需删除可联系QQ:516101458

文章来源: 阅读原文

相关阅读

关注徐同学呀微信公众号

徐同学呀微信公众号:yydsblog

徐同学呀

手机扫描上方二维码即可关注徐同学呀微信公众号

徐同学呀最新文章

精品公众号随机推荐