Java設(shè)計模式之java模板方法模式詳解

更新時間：2021年09月15日 15:20:39 作者：大忽悠愛忽悠

這篇文章主要介紹了Java設(shè)計模式模板方法模式(Template)用法解析,文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下

模板方法模式

在程序開發(fā)中，經(jīng)常會遇到這種情況：某個方法要實現(xiàn)的算法需要多個步驟，但其中有一些步驟是固定不變的，而另一些步驟則是不固定的。為了提高代碼的可擴展性和可維護性，模板方法模式在這種場景下就派上了用場。

譬如制作一節(jié)網(wǎng)課的步驟可以簡化為4個步驟：

1.制作PPT

2.錄制視頻

3.編寫筆記

4.提供課程資料

其中1、2、3的動作在所有課程中的固定不變的，步驟3可有可無，步驟4在每個課程都不同（有些課程需要提供源代碼，有些需要提供圖片文件等）

我們可以在父類中確定整個流程的循序，并實現(xiàn)固定不變的步驟，而把不固定的步驟留給子類實現(xiàn)。甚至可以通過一個鉤子方法，讓子類來決定流程中某個方法的執(zhí)行與否

介紹

模板方法模式：定義一個操作中算法的框架，而將一些步驟延遲到子類中。模板方法模式使得子類可以不改變一個算法的結(jié)構(gòu)即可重定義該算法的某些特定步驟。模板方法模式是一種基于繼承的代碼復(fù)用技術(shù)，它是一種類行為型模式。

角色

AbstractClass（抽象類）：在抽象類中定義了一系列基本操作(PrimitiveOperations)，這些基本操作可以是具體的，也可以是抽象的，每一個基本操作對應(yīng)算法的一個步驟，在其子類中可以重定義或?qū)崿F(xiàn)這些步驟。同時，在抽象類中實現(xiàn)了一個模板方法(Template Method)，用于定義一個算法的框架，模板方法不僅可以調(diào)用在抽象類中實現(xiàn)的基本方法，也可以調(diào)用在抽象類的子類中實現(xiàn)的基本方法，還可以調(diào)用其他對象中的方法。

ConcreteClass（具體子類）：它是抽象類的子類，用于實現(xiàn)在父類中聲明的抽象基本操作以完成子類特定算法的步驟，也可以覆蓋在父類中已經(jīng)實現(xiàn)的具體基本操作。

一個模板方法是定義在抽象類中的、把基本操作方法組合在一起形成一個總算法或一個總行為的方法。這個模板方法定義在抽象類中，并由子類不加以修改地完全繼承下來。模板方法是一個具體方法，它給出了一個頂層邏輯框架，而邏輯的組成步驟在抽象類中可以是具體方法，也可以是抽象方法。

基本方法是實現(xiàn)算法各個步驟的方法，是模板方法的組成部分?；痉椒ㄓ挚梢苑譃槿N：抽象方法(Abstract Method)、具體方法(Concrete Method)和鉤子方法(Hook Method)。

抽象方法：一個抽象方法由抽象類聲明、由其具體子類實現(xiàn)。
具體方法：一個具體方法由一個抽象類或具體類聲明并實現(xiàn)，其子類可以進行覆蓋也可以直接繼承。
鉤子方法：可以與一些具體步驟 “掛鉤” ，以實現(xiàn)在不同條件下執(zhí)行模板方法中的不同步驟

代碼演示

所以我們通過模板方法模式，在抽象類中把整個流程固定下來，其中1、2、3的實現(xiàn)在抽象類中完成，3的執(zhí)行與否則由子類通過鉤子方法來控制，4則由子類來實現(xiàn)

抽象類定義如下：

//抽象課程類
public abstract class Course
{
    protected final void makeCourse() {
        this.makePPT();
        this.makeVideo();
        if (needWriteArticle()) {
            this.writeArticle();
        }
        this.packageCourse();
    }
    //final表示子類繼承后，無法修改父類該方法
    final void makePPT() {
        System.out.println("1. 制作PPT");
    }
    final void makeVideo() {
        System.out.println("2. 制作視頻");
    }
    final void writeArticle() {
        System.out.println("3. 編寫課程筆記");
    }
    //鉤子方法
    protected boolean needWriteArticle() {
        return false;
    }
   //抽象方法，留給子類去實現(xiàn)
    abstract void packageCourse();
}

其中的 makeCourse 方法是模板方法，它定義了制作網(wǎng)課的基本流程，makePPT、makeVideo、writeArticle 這三個步驟在所有課程中都是固定的，所以用 final 關(guān)鍵字修飾；packageCourse 方法在所有課程中都可能不一樣，所以聲明為抽象方法，由子類自行實現(xiàn)；鉤子方法 needWriteArticle 返回一個 boolean 類型的值，控制是否編寫課程筆記

子類 JavaCourse，實現(xiàn)了抽象方法 packageCourse，重寫了鉤子方法 needWriteArticle

public class JavaCourse extends Course {
    @Override
    void packageCourse() {
        System.out.println("4. 提供Java課程源代碼");
    }
    @Override
    protected boolean needWriteArticle() {
        return true;
    }
}

子類 FECourse，實現(xiàn)了抽象方法 packageCourse，重寫了鉤子方法 needWriteArticle，其中把鉤子方法的結(jié)果交給客戶端確定

public class JavaCourse extends Course {
    @Override
    void packageCourse() {
        System.out.println("4. 提供Java課程源代碼");
    }
    @Override
    protected boolean needWriteArticle() {
        return true;
    }
}

客戶端測試

public class TEST
{
    public static void main(String[] args) {
                System.out.println("Java課程start---");
                Course javaCourse = new JavaCourse();
                javaCourse.makeCourse();
                System.out.println("Java課程end---\n");
                System.out.println("前端課程start---");
                Course feCourse = new FECourse(false);
                feCourse.makeCourse();
                System.out.println("前端課程end---");
    }
}

輸出結(jié)果

Java課程start---
1. 制作PPT
2. 制作視頻
3. 編寫筆記
4. 提供Java課程源代碼
Java課程end---

前端課程start---
1. 制作PPT
2. 制作視頻
4.1 提供課程的前端代碼
4.2 提供課程的圖片等多媒體素材
前端課程end---

模板方法模式總結(jié)

優(yōu)點

在父類中形式化地定義一個算法，而由它的子類來實現(xiàn)細節(jié)的處理，在子類實現(xiàn)詳細的處理算法時并不會改變算法中步驟的執(zhí)行次序。
模板方法模式是一種代碼復(fù)用技術(shù)，它在類庫設(shè)計中尤為重要，它提取了類庫中的公共行為，將公共行為放在父類中，而通過其子類來實現(xiàn)不同的行為，它鼓勵我們恰當(dāng)使用繼承來實現(xiàn)代碼復(fù)用
可實現(xiàn)一種反向控制結(jié)構(gòu)，通過子類覆蓋父類的鉤子方法來決定某一特定步驟是否需要執(zhí)行。
在模板方法模式中可以通過子類來覆蓋父類的基本方法，不同的子類可以提供基本方法的不同實現(xiàn)，更換和增加新的子類很方便，符合單一職責(zé)原則和開閉原則

缺點

需要為每一個基本方法的不同實現(xiàn)提供一個子類，如果父類中可變的基本方法太多，將會導(dǎo)致類的個數(shù)增加，系統(tǒng)更加龐大，設(shè)計也更加抽象，此時，可結(jié)合橋接模式來進行設(shè)計。

適用場景

對一些復(fù)雜的算法進行分割，將其算法中固定不變的部分設(shè)計為模板方法和父類具體方法，而一些可以改變的細節(jié)由其子類來實現(xiàn)。即：一次性實現(xiàn)一個算法的不變部分，并將可變的行為留給子類來實現(xiàn)。
各子類中公共的行為應(yīng)被提取出來并集中到一個公共父類中以避免代碼重復(fù)。
需要通過子類來決定父類算法中某個步驟是否執(zhí)行，實現(xiàn)子類對父類的反向控制。
一般模板方法都會加上final關(guān)鍵字，防止子類重寫該方法

源碼分析模板方法模式的典型應(yīng)用

Servlet 中的模板方法模式

Servlet（Server Applet）是Java Servlet的簡稱，用Java編寫的服務(wù)器端程序，主要功能在于交互式地瀏覽和修改數(shù)據(jù)，生成動態(tài)Web內(nèi)容。在每一個 Servlet 都必須要實現(xiàn) Servlet 接口，GenericServlet 是個通用的、不特定于任何協(xié)議的Servlet，它實現(xiàn)了 Servlet 接口，而 HttpServlet 繼承于 GenericServlet，實現(xiàn)了 Servlet 接口，為 Servlet 接口提供了處理HTTP協(xié)議的通用實現(xiàn)，所以我們定義的 Servlet 只需要繼承 HttpServlet 即可。

HttpServlet 的簡要代碼如下所示

public abstract class HttpServlet extends GenericServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // ...
    }
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // ...
    }
    protected void doHead(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // ...
    }
    protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // ...
    }
    protected void doDelete(HttpServletRequest req,  HttpServletResponse resp) throws ServletException, IOException {
        // ...
    }
    protected void doOptions(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // ...
    }
    protected void doTrace(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // ...
    }
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getMethod();
        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                if (ifModifiedSince < lastModified) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }
        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);
        } else if (method.equals(METHOD_POST)) {
            doPost(req, resp);
        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);
        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);
        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);
        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);
        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //
            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);
            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }
    // ...省略...
}

在 HttpServlet 的 service 方法中，首先獲得到請求的方法名，然后根據(jù)方法名調(diào)用對應(yīng)的 doXXX 方法，比如說請求方法為GET，那么就去調(diào)用 doGet 方法；請求方法為POST，那么就去調(diào)用 doPost 方法

HttpServlet 相當(dāng)于定義了一套處理 HTTP 請求的模板；service 方法為模板方法，定義了處理HTTP請求的基本流程；doXXX 等方法為基本方法，根據(jù)請求方法做相應(yīng)的處理，子類可重寫這些方法；HttpServletRequest 中的Method則起到鉤子方法的作用.

在開發(fā)javaWeb應(yīng)用時，自定義的Servlet類一般都擴展 HttpServlet 類，譬如我們實現(xiàn)一個輸出 Hello World! 的 Servlet 如下

// 擴展 HttpServlet 類
public class HelloWorld extends HttpServlet {
  public void init() throws ServletException {
    // ...
  }
  public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();
      out.println("<h1>Hello World!</h1>");
  }
  public void destroy() {
      // ...
  }
}

該自定義的 Servlet 重寫了 doGet 方法，當(dāng)客戶端發(fā)起 GET 請求時將得到

Hello World!

Spring中的IOC容器啟動—refresh()方法

Spring IOC容器初始化時運用到的模板方法模式

1、首先定義一個接口ConfigurableApplicationContext，聲明模板方法refresh

public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {
　　/**聲明了一個模板方法*/
　　void refresh() throws BeansException, IllegalStateException;
}

2、抽象類AbstractApplicationContext實現(xiàn)了接口，主要實現(xiàn)了模板方法refresh（這個方法很重要，是各種IOC容器初始化的入口）的邏輯

public abstract class AbstractApplicationContext extends DefaultResourceLoader
        implements ConfigurableApplicationContext, DisposableBean {
　　 /**模板方法的具體實現(xiàn)*/
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();
　　　　　　  //注意這個方法是，里面調(diào)用了兩個抽象方法refreshBeanFactory、getBeanFactory
            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);
            try {
　　　　　　　　　 //注意這個方法是鉤子方法
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);
                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);
                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);
                // Initialize message source for this context.
                initMessageSource();
                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();
　　　　　　　　　 //注意這個方法是鉤子方法
                // Initialize other special beans in specific context subclasses.
                onRefresh();
                // Check for listener beans and register them.
                registerListeners();
                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);
                // Last step: publish corresponding event.
                finishRefresh();
            }
            catch (BeansException ex) {
                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();
                // Reset 'active' flag.
                cancelRefresh(ex);
                // Propagate exception to caller.
                throw ex;
            }
        }
    }

這里最主要有一個抽象方法obtainFreshBeanFactory、兩個鉤子方法postProcessBeanFactory和onRefresh，看看他們在類中的定義

兩個鉤子方法：

 protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    }
    protected void onRefresh() throws BeansException {
        // For subclasses: do nothing by default.
    }

再看看獲取Spring容器的抽象方法：

/**其實他內(nèi)部只調(diào)用了兩個抽象方法**/    
　　protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        refreshBeanFactory();
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (logger.isDebugEnabled()) {
            logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
        }
        return beanFactory;
    }
　　protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;
　　public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;

具體要取那種BeanFactory容器的決定權(quán)交給了子類！

3、具體實現(xiàn)的子類，實現(xiàn)了抽象方法getBeanFactory的子類有： AbstractRefreshableApplicationContext

public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
    @Override
    public final ConfigurableListableBeanFactory getBeanFactory() {
        synchronized (this.beanFactoryMonitor) {
            if (this.beanFactory == null) {
                throw new IllegalStateException("BeanFactory not initialized or already closed - " +
                        "call 'refresh' before accessing beans via the ApplicationContext");
            }
            //這里的this.beanFactory在另一個抽象方法refreshBeanFactory的設(shè)置的
            return this.beanFactory;
        }
    }
}    
public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
    @Override
    public final ConfigurableListableBeanFactory getBeanFactory() {
　　　　//同樣這里的this.beanFactory在另一個抽象方法中設(shè)置        
　　　　return this.beanFactory;
    }
}

其實這里的差別還不是很大，我們可以看看另一個抽象方法refreshBeanFactory的實現(xiàn)，兩個抽象方法的配合使用。

在這里插入圖片描述