介绍
模板方法模式是一种行为型模式，就是将固定的步骤抽象出来，并将每个步骤不同的细节延伸到不同的子类去做。因为每个子类都不同，所以具有可变信息，然后把不变的行为给他封装到父类中去，这样就去除子类中重复的代码了。
模板方法模式UML图.png
例子
在实际工作中我们数据同步，需要使用token来保证同步数据的用户身份正确，而我们的步骤是首先通过用户名和密码来获取token，然后每次发送Get请求或者Post请求就把token带上发送来执行请求，而我们发现机构同步，账号同步每个模块都是先获取token，再发送请求，而我们可以为此设计一套模板，将固定的步骤提取出来作为一个抽象模板，将不同的同步模块的细节延伸到子类去设计。
样例代码
抽象流程模板类：
public abstract class MyTemplet {
/**
* 使用用户名和密码获取token
* @param username
* @param password
* @return
*/
public abstract String getToken(String username, String password);
/**
* 使用token发送get请求获取数据
* @param id
* @param token
* @return
*/
public abstract String doGet(String id, String token);
/**
* 使用token发送post请求新增数据
* @param model
* @param token
* @return
*/
public abstract String doPost(Object model, String token);
}
模块A具体实现类：
public class MySystemA extends MyTemplet{
@Override
public String getToken(String username, String password) {
System.out.println("MySystemA 获取 token");
return null;
}
@Override
public String doGet(String id, String token) {
System.out.println("MySystemA 发送 Get请求");
return null;
}
@Override
public String doPost(Object model, String token) {
System.out.println("MySystemA 发送 Post请求");
return null;
}
}
模块B具体实现类：
public class MySystemB extends MyTemplet {
@Override
public String getToken(String username, String password) {
System.out.println("MySystemB 获取 token");
return null;
}
@Override
public String doGet(String id, String token) {
System.out.println("MySystemB 发送 Get请求");
return null;
}
@Override
public String doPost(Object model, String token) {
System.out.println("MySystemB 发送 Post请求");
return null;
}
}
说明：抽象模板类只是规定了系统开发所需的步骤，但是没有定义具体细节，将具体的细节都延伸到了子类来实现，减少了重复代码。因为重复对应更多的是易错和难改。
思考1，如何在项目中应用模板方法模式
- 项目中的业务逻辑有一套固定的流程，可以抽取出来。
- 项目中的业务逻辑也存在一些不同的部分，可以抽取出来，将不同的部分延伸到子类去实现。
思考2，示例，审批项目中使用模板方法模式的思路
/**
* 业务模板
*/
public abstract class PubApprovalTemplate {
@Autowired
private PubApprovalMapper pubApprovalMapper;
public final void firstInsertApproval(PubApprovalVO pubApprovalVO) {
System.out.println("使用pubApprovalMapper将pubApprovalVO审批流水插入到审批流程表中");
}
public final void doApproval(PubApprovalVO pubApprovalVO) {
System.out.println("使用pubApprovalMapper将pubApprovalVO审批流水更新到审批流程表中");
if (审批成功) {
// 更新业务表中的状态字段从未审批更新为已审批，并且更新业务数据为审核通过
updateBus(pubApprovalVO);
}
// 审批失败，更新业务表中的状态字段从未审批更新为已审批，并且更新业务数据为审核不通过
updateBus(pubApprovalVO);
}
public abstract void updateBus(PubApprovalVO pubApprovalVO);
}
@Service
public class OrderServiceImpl extends PubApprovalTemplate{
@Autowired
private OrderMapper orderMapper;
// 新增订单，生成流水插入到审批流水表
public void insertOrder(OrderVO orderVO) {
System.out.println("用orderMapper插入orderVO到订单业务表，状态为未审批");
orderVO 转化为 PubApprovalVO
super.firstInsertApproval(pubApprovalVO);
}
// 审批人员审批，更新订单表和业务流水表
public void insertOrderByApproval(PubApprovalVO pubApprovalVO) {
System.out.println("订单信息插入到数据库中,状态字段为未审批");
// 进行审批
super.doApproval(pubApprovalVO);
}
@Override
public void updateBus(PubApprovalVO pubApprovalVO) {
System.out.println("将字段更新到订单业务表");
}
}
思考3，模板方法模式中注意点，final关键字
为了防止子类在继承父类时，重写父类的模板，所以将父类的模板方法设置为final。
思考4，抽象类模板中定义的抽象方法延伸到子类实现个性化，但是有的时候子类没有需要实现的内容，但是却要写个实现父类的空方法。可以让子类重写父类的方法，这样父类调用本类中的方法，相当于调用子类重写的方法。
/**
* 业务模板
*/
@Slf4j
public abstract class PubApprovalTemplate {
public final void doApproval(PubApprovalVO pubApprovalVO) {
updateBus(pubApprovalVO);
}
public void updateBus(PubApprovalVO pubApprovalVO) {
log.info("父类中的updateBus");
}
}
@Slf4j
@Service
public class OrderServiceImpl extends PubApprovalTemplate{
public void insertOrderByApproval(PubApprovalVO pubApprovalVO) {
System.out.println("订单信息插入到数据库中,状态字段为未审批");
// 进行审批
super.doApproval(pubApprovalVO);
}
public void updateBus(PubApprovalVO pubApprovalVO) {
log.info("子类中的updateBus");
}
}
模板方法模式在IO流中的应用
public static void main(String[] args) throws Exception {
Reader fileReader = new FileReader("D:\\BugReport.txt");
char[] arr = new char[1024];
int len = 0;
while ((len = fileReader.read(arr)) != -1) {
System.out.println(new String(arr, 0, len));
}
fileReader.close();
}
public static void main(String[] args) throws Exception {
Reader fileReader = new FileReader("D:\\BugReport.txt");
Reader bufferedReader = new BufferedReader(fileReader);
char[] arr = new char[1024];
int len = 0;
while ((len = bufferedReader.read(arr)) != -1) {
System.out.println(new String(arr, 0, len));
}
fileReader.close();
bufferedReader.close();
}
- 抽象模板类Reader
public abstract class Reader implements Readable, Closeable {
abstract public int read(char cbuf[], int off, int len) throws IOException;
}
- 具体实现类InputStreamReader
FileReader实际上还是使用InputStreamReader提供的read方法来实现的。
public class InputStreamReader extends Reader {
private final StreamDecoder sd;
public int read(char cbuf[], int offset, int length) throws IOException {
return sd.read(cbuf, offset, length);
}
}
public class FileReader extends InputStreamReader {
}
- 具体实现类BufferedReader
public class BufferedReader extends Reader {
public int read(char cbuf[], int off, int len) throws IOException {
synchronized (lock) {
ensureOpen();
if ((off < 0) || (off > cbuf.length) || (len < 0) ||
((off + len) > cbuf.length) || ((off + len) < 0)) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return 0;
}
int n = read1(cbuf, off, len);
if (n <= 0) return n;
while ((n < len) && in.ready()) {
int n1 = read1(cbuf, off + n, len - n);
if (n1 <= 0) break;
n += n1;
}
return n;
}
}
}
说明：
可以看出抽象模板类Reader定义了read方法，但是read方法的具体实现还是延伸到子类InputStreamReader、BufferedReader。而FileReader实际上还是使用的InputStreamReader来实现的。模板方法模式的关键在于将多个类中的公共部分抽取出来，防止产生重复代码。
总结：
- 模板方法模式应用场景：当系统中存在不变的行为在子类中重复出现时，就将不变的行为和可变的行为分离，将不变的行为抽取出来放到一个单一的地方，让子类们去实现这个单一的地方。避免了大量的重复代码，也同时为子类的设计做了一个统一的规范。
- 具体的做法就是将重复不变的部分放在抽象父类中，然后让子类们去继承父类，然后重写父类的抽象方法。
- 模板方法模式的使用提高了代码的复用性。
