简介
模板方法模式是最为常见的几个模式之一（也比较简单），是基于继承实现代码复用的基本技术。
模板方法模式（TemplateMethod Pattern）的定义是：首先定义了一个由若干执行步骤组成的执行过程（形成模板），而将一些步骤延迟在子类中实现，使得子类能够对其中一个或者多个具体步骤进行重新定义，从而改变最终的执行结果。
模板方法模式的UML类图如下：
模板方法模式类图.png
这里涉及到了两个角色：
抽象模板 AbstractTemplate
- 定义并实现了一个模板方法。这个模板方法一般是一个具体的方法，它定义了一个顶级逻辑的框架，而逻辑的组成步骤由抽象方法和其他具体方法组成，抽象方法在子类中实现。
- 定义了一个或者多个抽象方法，这个/些抽象方法是模板方法的一部分，组成模板方法内一个或者多个步骤。
具体模板 ConcreteTemplate
- 实现抽象父类定义的一个或者多个抽象方法，它们是模板方法的组成步骤。
- 每一个抽象模板都可以有任意多个具体模板的实现，每一个具体模板都可以给出这些抽象方法的不同实现，从而改变模板方法最后的执行结果。
模板方法模式中的方法
模板方法模式中的方法可以分为两大类：模板方法和基本方法
模板方法
模板方法是定义在抽象类中的，把基本操作组合在一起形成一个总的执行过程。
一个抽象类可以有任意多个模板方法，而不限于一个，每一个模板方法都可以调用任意多个具体方法。
基本方法
基本方法又可以进一步划分成：抽象方法（Abstract Method）、具体方法（Concrete Method）和钩子方法（Hook Method）
- 抽象方法：抽象方法由抽象类声明并最终由具体子类实现，从而改变模板方法的最终执行结果
- 具体方法：具体方法由抽象类声明并实现，子类不一定需要实现（除非是需要重写改方法）
- 钩子方法：钩子方法由抽象类声明并实现，而子类会对其进行拓展，通常抽象类给出的实现是一个空实现，作为方法的默认实现。
使用场景
我之前做过的一个业务场景是：对短信的文本内容进行敏感词过滤，需要将文本内容与敏感词词库做匹配，通过加载敏感词文件即可获取全部的违禁词，敏感词文件可以放在服务器内的某一个具体路径，也可以是放在项目内的Resource目录下，在这两个位置下加载方式是有区别的，但是除此之外违禁词的读取、存放都是相同的。
定义了一个接口SensitiveWordLoader、一个抽象类SensitiveWordAbstractFileLoader以及两个具体实现SensitiveWordExternalFileLoader和SensitiveWordJarFileLoader,UML类图如下：
模板方法模式实现违禁词加载.png
由于敏感词词库也可以存放在各类数据库中，从文件中加载只是其中的一种方法，因此提供了一个接口
SensitiveWordLoader供抽象类SensitiveWordAbstractFileLoader实现，SensitiveWordAbstractFileLoader中的load方法即是模板方法，其中定义了敏感词文件流的获取以及从文件流中读取敏感词并存放，其中的extractSensitiveWordFromSingleLine是具体方法，用于定义从敏感词文件中逐行提取敏感词的逻辑，initInputStream是抽象类中定义的输入流初始化方法，在不同加载方式下获取输入流的方式均不相同因此需要交由子类进行实现；模板方法load内的主要执行逻辑由具体方法extractSensitiveWordFromSingleLine和抽象方法initInputStream完成。各类代码如下：
SensitiveWordLoader
package com.cube.dp.tmp;
import org.springframework.lang.NonNull;
import java.util.List;
/**
* @author cube.li
* @date 2021/9/29 17:45
* <p>
* 违禁词加载器
*/
public interface SensitiveWordLoader {
/**
* 加载违禁词
*
* @return 违禁词列表
*/
@NonNull
List<String> load();
}
SensitiveWordAbstractFileLoader
package com.cube.dp.tmp;
import org.apache.commons.lang3.StringUtils;
import org.apache.tomcat.util.http.fileupload.IOUtils;
import org.springframework.lang.NonNull;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* @author cube.li
* @date 2021/9/29 17:46
* <p>
* 抽象违禁词文件加载器
*/
@SuppressWarnings({"unused", "WeakerAccess"})
public abstract class SensitiveWordAbstractFileLoader implements SensitiveWordLoader {
/**
* 违禁词文件路径
*/
protected String filePath;
/**
* 文件字符集
*/
protected Charset charset;
/**
* 关键词分隔符
*/
protected String separator;
protected InputStream inputStream;
/**
* 加载标识
*/
private static final AtomicBoolean LOAD_FLAG = new AtomicBoolean(false);
/**
* 违禁词列表
*/
private static List<String> sensitiveWordList;
public SensitiveWordAbstractFileLoader(String filePath, Charset charset, String separator) {
this.filePath = filePath;
this.charset = charset;
this.separator = separator;
sensitiveWordList = new ArrayList<>();
initInputStream();
}
/**
* 初始化inputStream
*/
public abstract void initInputStream();
@Override
@NonNull
public List<String> load() {
if (LOAD_FLAG.getAndSet(true)) {
return sensitiveWordList;
}
InputStreamReader reader = null;
BufferedReader bufferedReader = null;
try {
reader = new InputStreamReader(inputStream, charset.name());
bufferedReader = new BufferedReader(reader);
String singleLine;
while ((singleLine = bufferedReader.readLine()) != null) {
sensitiveWordList.addAll(extractSensitiveWordFromSingleLine(singleLine.trim()));
}
return sensitiveWordList;
} catch (Exception e) {
e.printStackTrace();
LOAD_FLAG.set(false);
throw new IllegalStateException("load sensitive word file failed,msg =" + e.getMessage());
} finally {
IOUtils.closeQuietly(inputStream);
IOUtils.closeQuietly(reader);
IOUtils.closeQuietly(bufferedReader);
}
}
/**
* 从文件单行内容中获取违禁词
*
* @param singleLine 单行内容
* @return 提取到的违禁词列表
*/
@NonNull
private List<String> extractSensitiveWordFromSingleLine(String singleLine) {
String[] array = singleLine.split(separator);
List<String> list = new ArrayList<>();
for (String str : array) {
if (StringUtils.isNotBlank(str)) {
list.add(str);
}
}
return list;
}
public String getFilePath() {
return filePath;
}
public Charset getCharset() {
return charset;
}
public String getSeparator() {
return separator;
}
public InputStream getInputStream() {
return inputStream;
}
public static List<String> getSensitiveWordList() {
return sensitiveWordList;
}
}
SensitiveWordJarFileLoader
package com.cube.dp.tmp;
import org.springframework.core.io.ClassPathResource;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
/**
* @author cube.li
* @date 2021/9/30 10:10
* <p>
* 加载jar包内的违禁词文件加载器
*/
@SuppressWarnings("unused")
public class SensitiveWordJarFileLoader extends SensitiveWordAbstractFileLoader {
public SensitiveWordJarFileLoader(String relativePath, String separator) {
super(relativePath, StandardCharsets.UTF_8, separator);
}
public SensitiveWordJarFileLoader(String relativePath) {
super(relativePath, StandardCharsets.UTF_8, ",");
}
/**
* 构造器
*
* @param relativePath 相对路径,包含文件名(位于resources目录下)
* @param charset 字符集
* @param separator 分隔符
*/
public SensitiveWordJarFileLoader(String relativePath, Charset charset, String separator) {
super(relativePath, charset, separator);
}
@Override
public void initInputStream() {
try {
ClassPathResource classPathResource = new ClassPathResource(filePath);
inputStream = classPathResource.getInputStream();
} catch (IOException e) {
throw new IllegalStateException("load sensitive word file in jar failed,message = " + e.getMessage());
}
}
}
SensitiveWordExternalFileLoader
package com.cube.dp.tmp;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
/**
* @author cube.li
* @date 2021/9/30 10:01
* <p>
* 违禁词外部文件加载器(加载服务器内部,jar包外部)
*/
@SuppressWarnings("unused")
public class SensitiveWordExternalFileLoader extends SensitiveWordAbstractFileLoader {
public SensitiveWordExternalFileLoader(String externalFileAbsolutePath, String separator) {
this(externalFileAbsolutePath, StandardCharsets.UTF_8, separator);
}
public SensitiveWordExternalFileLoader(String externalFileAbsolutePath) {
this(externalFileAbsolutePath, ",");
}
/**
* 构造器
*
* @param externalFileAbsolutePath 违禁词文件的绝对路径
* @param charset 字符集
* @param separator 违禁词分隔符
*/
public SensitiveWordExternalFileLoader(String externalFileAbsolutePath, Charset charset, String separator) {
super(externalFileAbsolutePath, charset, separator);
}
@Override
public void initInputStream() {
File file = new File(filePath);
try {
inputStream = new FileInputStream(file);
} catch (FileNotFoundException e) {
throw new IllegalStateException("external sensitive word file not found,filePath = " + filePath);
}
}
}
通过上面的例子可以看出，使用模板方法模式实现后的代码复用率极高，子类只需要专注其中的一个或者多个步骤即可，无须将模板方法内的顶层执行逻辑全部重写，代码的阅读性和可拓展性极高。有的同学可能会问到，为什么这个例子里没有钩子方法（Hook Method）呢？我这里的业务场景比较简单，因此不需要借助钩子方法实现逻辑。
总结
其实各种设计模板无非是前人在无数的业务开发中总结出来的一套模板，说到底就是合理的封装、继承和解耦，设计模式中的各种概念是高度抽象的结果，我们只需要重点关注每个设计模式的实现思路
，不必完全对设计模式进行生搬硬套，所谓尽信书则不如无书，结合实际应用场景灵活运用不拘于形才是最佳。
代码详情请点击：示例代码
