设计模式：模板方法模式详解与实战应用

在这个例子中，prepare() 是模板方法，定义了固定的执行顺序。brew() 和 addCondiments() 是抽象方法，由子类根据具体需求实现。这样既保证了流程的一致性，又实现了行为的扩展性。

Java 核心类库中的应用

ClassLoader 类加载器

在 Java 核心类库中，ClassLoader 类就使用了模板方法模式来保证类加载过程中的唯一性和一致性。

public class ClassLoader {
    // 这是一个重载方法
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }

    // 父类算法的定义（模板方法）
    protected synchronized Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException {
        Class c = findLoadedClass(name);
        if (c == null) {
            try {
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    c = findBootstrapClass0(name);
                }
            } catch (ClassNotFoundException e) {
                c = findClass(name);
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }

    // 这里留了一个方法给子类选择性覆盖
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }
}

从上面的代码可以看出，findClass 这个方法并不是必须实现的，所以 ClassLoader 选择留给程序员们自己选择是否要覆盖。ClassLoader 中定义的算法顺序是：

1. 首先看是否有已经加载好的类。
2. 如果父类加载器不为空，则首先从父类类加载器加载。
3. 如果父类加载器为空，则尝试从启动加载器加载。
4. 如果两者都失败，才尝试从 findClass 方法加载。

这是 ClassLoader 的双亲委派模型，即先从父类加载器加载，直到继承体系的顶层，否则才会采用当前的类加载器加载。这样做的目的是为了 JVM 中类的一致性。

无疑 ClassLoader 中就定义了模板方法，而 ClassLoader 的子类 BaseDexClassLoader 中就覆盖了 ClassLoader 的 findClass 方法：

@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
    Class clazz = pathList.findClass(name);
    if (clazz == null) {
        throw new ClassNotFoundException(name);
    }
    return clazz;
}

Android 源码中的实践

View 绘制流程

在 Android 源码中，View 中的 draw() 方法就是一个典型的'模板方法'。它定义了一系列'Draw'过程，主要包括这几个步骤：

1. Draw the background
2. If necessary, save the canvas' layers to prepare for fading
3. Draw view's content
4. Draw children
5. If necessary, draw the fading edges and restore layers
6. Draw decorations (scrollbars for instance)

// Step 1, draw the background, if needed
int saveCount;
if (!dirtyOpaque) {
    drawBackground(canvas);
}

// skip step 2 & 5 if possible (common case)
final int viewFlags = mViewFlags;
boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
if (!verticalEdges && !horizontalEdges) {
    // Step 3, draw the content
    if (!dirtyOpaque) onDraw(canvas);

    // Step 4, draw the children
    dispatchDraw(canvas);

    // Overlay is part of the content and draws beneath Foreground
    if (mOverlay != null && !mOverlay.isEmpty()) {
        mOverlay.getOverlayView().dispatchDraw(canvas);
    }

    // Step 6, draw decorations (foreground, scrollbars)
    onDrawForeground(canvas);

    // we're done...
    return;
}

其中第三步（Step 3）Draw view's content 函数：

/**
 * Implement this to do your drawing.
 *
 * @param canvas the canvas on which the background will be drawn
 */
protected void onDraw(Canvas canvas) {
}

第四步（Step 4）draw children：

/**
 * Called by draw to draw the child views. This may be overridden
 * by derived classes to gain control just before its children are drawn
 * (but after its own view has been drawn).
 * @param canvas the canvas on which to draw the view
 */
protected void dispatchDraw(Canvas canvas) {
}

从 View 的 draw() '模板方法'可以看出，当继承 View 子类中，如果要重写或者扩展这个方法时，整个方法流程和基本内容不能够修改，子类只能通过扩展 onDraw(Canvas canvas) 和 dispatchDraw(Canvas canvas) 两个函数，使子类自己的 View 显示效果和别的具体子类的不同。

我们可以看到，在 TextView 类中就重写了 onDraw 方法，处理文本渲染、背景绘制等逻辑。

AsyncTask 异步任务

Android 中的 AsyncTask 也是典型的模板方法模式。

private class DownloadImageTask extends AsyncTask<String, Void, Bitmap> {
    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }

    protected Bitmap doInBackground(String... urls) {
        return loadImageFromNetwork(urls[0]);
    }

    @Override
    protected void onProgressUpdate(Void... values) {
        super.onProgressUpdate(values);
    }

    protected void onPostExecute(Bitmap result) {
        mImageView.setImageBitmap(result);
    }

    @Override
    protected void onCancelled() {
        super.onCancelled();
    }
}

继承 AsyncTask 的时候只需要根据需要重写上面几个方法就可以，它们就是 AsyncTask 类的可变部分，我们在子类中只需要实现可变部分就可以了，不变部分 AsyncTask 已经实现了，所以我们只需要根据这个模板进行使用就行。

优缺点分析

优点

1. 封装不变部分，扩展可变部分：把属于不变部分的行为封装到父类中，把属于可变部分的行为交给子类实现，符合开闭原则。
2. 提取公共代码：各个子类中公共的行为应该被提取出来并且集中到一个公共的父类中去，这样避免了代码的重复。
3. 控制子类扩展：模板方法只在特定点调用操作，这样就只允许在这些点进行扩展，防止子类随意修改算法流程。

缺点

1. 增加系统复杂度：每一个不同的实现都需要一个子类来实现，导致类的个数成对增加，增加了系统的复杂度。
2. 继承耦合：由于引入了继承关系，父类的变化会影响子类，如果父类中模板方法的逻辑发生变化，所有子类都需要重新审视。
3. 限制灵活性：对于某些需要动态调整算法流程的场景，模板方法模式显得不够灵活，此时策略模式可能更合适。

模板方法模式 vs 策略模式

虽然模板方法模式和策略模式都能解决算法变化的问题，但它们的侧重点不同：

• 模板方法模式：侧重于算法的流程固定，步骤的执行顺序不可变，只有具体步骤的实现可变。它利用的是继承。
• 策略模式：侧重于算法的整体替换，不同的算法之间可以互相独立切换，互不影响。它利用的是组合。

在实际开发中，如果算法的流程是固定的，只是中间某些步骤有差异，优先使用模板方法模式；如果算法本身差异较大，且需要在运行时动态切换，优先使用策略模式。

适用场景总结

1. 一次性实现一个算法的不变部分，并将可变的行为留给子类去实现。
2. 各个子类中公共的行为应该被提取出来并且集中到一个公共的父类中去，这样避免了代码的重复。
3. 扩展子类的扩展。模板方法只在特定点调用操作，这样就只允许在这些点进行扩展。
4. 当多个子类存在大量相同代码时，考虑使用模板方法模式提取公共逻辑。

结语

模板方法模式是设计模式中非常基础且实用的一种模式。它通过定义算法骨架，有效地减少了代码冗余，提高了代码的可维护性。在 Android 开发、JVM 底层机制以及各种业务框架设计中，我们都能看到它的身影。掌握模板方法模式，有助于我们设计出更加清晰、稳定且易于扩展的软件架构。