模板模式就是定义一个操作中的算法骨架，然后将一些步骤延迟到子类中。模板方法使得子类在不改变算法的结构即可重定义该算法的某些步骤。
喝茶水
我们都知道泡茶基本步骤（算法骨架）有：
烧水、泡茶、喝茶水。
整个过程中很关键的步骤是泡茶，泡茶需要跑什么茶呢？泡多久？（留给子类自己去实现）。
API
写过API接口的码友们都知道，写API一般有四个步骤：
参数解析、参数校验、处理业务、组织返回参数。
把请求参数解析成该业务的请求参数json解析成实体类；参数校验，您可以使用通用的方式就是判断参数是否为空，也可以自己定义特殊的校验方式；处理业务一般每个接口都是不一样的，基本上都是自己去实现；至于返回参数，可能您得根据该API接口业务来返回。
支付订单
做过支付相关的系统的人都清楚，支付订单大致分这三个步骤：
组织请求银行或者第三方支付公司的请求参数、发起支付、处理返回结果。
以上三个场景中的步骤就是算法骨架，至于每个步骤可能每个人喝茶偏好不一样，API接口业务不一样、银行或者第三方支付的支付处理不一样，可能需要自己做特殊的处理。
实现一个API接口
算法类
package com.tian.springbootdemo.controller;
import com.tian.springbootdemo.rep.Result;
/**
* @auther: 老田
* @Description: 模板类
*/
public abstract class AbstractTemplate {
/**
* 算法骨架
*/
public Result execute() {
//第一步：解析参数
parseRequestParameters();
//第二步：校验参数
checkRequestParameters();
//第三步：业务处理
Object data= doBusiness();
//第四步：组织返回参数
return assembleResponseParameters(data);
}
/**
* 解析参数
*/
public abstract void parseRequestParameters();
/**
* 校验参数
*/
public abstract void checkRequestParameters();
/**
* 业务处理
*/
public abstract Object doBusiness();
/**
* 组织返回参数
*/
public abstract Result assembleResponseParameters(Object object);
}
实现类一
import com.tian.springbootdemo.rep.Result;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
/**
* @auther: 老田
* @Description: api接口
*/
@RequestMapping("/api")
@Controller
public class MyApiController extends AbstractTemplate {
@RequestMapping(value = "/users", method = RequestMethod.POST)
@ResponseBody
@Override
public Result execute() {
return super.execute();
}
@Override
public void parseRequestParameters() {
System.out.println("*****解析参数*****");
}
@Override
public void checkRequestParameters() {
System.out.println("*****校验参数*****");
}
@Override
public Object doBusiness() {
System.out.println("*****处理业务*****");
// TODO: 2018/11/17 调用service处理业务
User user = new User();
user.setName("小田哥");
user.setId(1);
user.setAge(20);
user.setSex("man");
return user;
}
@Override
public Result assembleResponseParameters(Object object) {
System.out.println("*****返回参数*****");
Result result = new Result("200", "处理成功");
result.setData(object);
return result;
}
}
实现类二
import com.tian.springbootdemo.dao.domain.User;
import com.tian.springbootdemo.rep.Result;
import org.springframework.web.bind.annotation.*;
/**
* @auther: 老田
* @Description: api接口
*/
@RequestMapping("/api")
@RestController
public class LoginController extends AbstractTemplate {
@PostMapping(value = "/login")
@Override
public Result execute() {
return super.execute();
}
@Override
public void parseRequestParameters() {
System.out.println("解析登录参数");
}
@Override
public void checkRequestParameters() {
System.out.println("校验登录用户名是否为空，密码是否为空");
}
@Override
public Object doBusiness() {
System.out.println("通过用户名查询是否存在此用户");
System.out.println("校验用户密码是否正确");
System.out.println("登录成功");
User user = new User();
user.setName("小田哥");
user.setId(1);
user.setAge(20);
user.setSex("man");
return user;
}
@Override
public Result assembleResponseParameters(Object object) {
System.out.println("*****返回参数*****");
Result result = new Result("200", "登录成功");
result.setData(object);
return result;
}
}
相关类
/**
* @auther: 老田
* @Description: 返回信息
*/
public class Result {
//返回码
private String responseCode;
//描述
private String message;
//数据
private Object data;
public Result() {
}
public Result(String responseCode, String message) {
this.responseCode = responseCode;
this.message = message;
}
public Result(String responseCode, String message, Object data) {
this.responseCode = responseCode;
this.message = message;
this.data = data;
}
public String getResponseCode() {
return responseCode;
}
public void setResponseCode(String responseCode) {
this.responseCode = responseCode;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
}
import java.io.Serializable;
/**
* @auther: 老田
* @Description: 数据
*/
public class User implements Serializable {
//id
private Integer id;
//用户姓名
private String name;
//性别
private String sex;
//年龄
private int age;
public User() {
}
public User(Integer id, String name, String sex, int age) {
this.id = id;
this.name = name;
this.sex = sex;
this.age = age;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
测试
这里使用的是idea的Tools下面的REST Client进行接口测试：
enter image description here
enter image description here
再看看控制台Console打印出来的信息：
enter image description here
enter image description here
这样我们就把模板设计模式应用到我们的具体代码里了，同样的我们也可以实现其他API的实现类。
另外，参数校验也可以在 AbstractTemplate 中实现一个 default 的方式，比如说：校验参数是否为空，但是子类也可以重写这个方法，自己做一个特殊的校验；比如说：如果参数中有手机号码，那么我们不仅要校验手机号是否为空，还可以校验这个手机号码是不是11位，是否合法的校验等等。
优点
缺点
Spring中
AbstractApplicationContext 中的refreash方法就是模板方法，源码为：
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//调用容器准备刷新的方法，获取容器的当时时间，
//同时给容器设置同步标识
prepareRefresh();
//告诉子类启动refreshBeanFactory()方法，
//Bean定义资源文件的载入从
//子类的refreshBeanFactory()方法启动
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//为BeanFactory配置容器特性，例如类加载器、事件处理器等
prepareBeanFactory(beanFactory);
try {
//为容器的某些子类指定特殊的BeanPost事件处理器
//-----子类实现
postProcessBeanFactory(beanFactory);
//调用所有注册的BeanFactoryPostProcessor的Bean
invokeBeanFactoryPostProcessors(beanFactory);
//为BeanFactory注册BeanPost事件处理器.
//BeanPostProcessor是Bean后置处理器，
//用于监听容器触发的事件
registerBeanPostProcessors(beanFactory);
//初始化信息源，和国际化相关.
initMessageSource();
//初始化容器事件传播器.
initApplicationEventMulticaster();
//调用子类的某些特殊Bean初始化方法
//-----子类实现
onRefresh();
//为事件传播器注册事件监听器.
registerListeners();
//初始化所有剩余的单例Bean
finishBeanFactoryInitialization(beanFactory);
//初始化容器的生命周期事件处理器，
//并发布容器的生命周期事件
finishRefresh();
//.....
该方法就是上下文启动模板方法。这就是模板模式在Spring中应用场景之一。
Mybatis中
BaseExecutor中的update方法就是一个模板方法
/**
* SqlSession.update/insert/delete会调用此方法
* 模板方法
*/
@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);
}
在BaseExecutor里只是定义了方法，但是实现是在子类里
//更新
protected abstract int doUpdate(MappedStatement ms, Object parameter)
throws SQLException;
//查询
protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds
rowBounds, ResultHandler resultHandler, BoundSql boundSql)
throws SQLException;
//...do开头的方法都是交给具体子类自己去实现
BaseExecutor的实现类如下：
enter image description here
实现类SimpleExecutor中的doUpdate方法的实现
@Override
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
Statement stmt = null;
try {
Configuration configuration = ms.getConfiguration();
//新建一个StatementHandler
//这里看到ResultHandler传入的是null
StatementHandler handler = configuration.newStatementHandler(
this, ms, parameter, RowBounds.DEFAULT, null, null);
//准备语句
stmt = prepareStatement(handler, ms.getStatementLog());
//StatementHandler.update
return handler.update(stmt);
} finally {
closeStatement(stmt);
}
}
实现类ReuseExecutor中的doUpdate方法的实现
@Override
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
Configuration configuration = ms.getConfiguration();
//和SimpleExecutor一样，
//新建一个StatementHandler
//这里看到ResultHandler传入的是null
StatementHandler handler = configuration.newStatementHandler(
this, ms, parameter, RowBounds.DEFAULT, null, null);
//准备语句
Statement stmt = prepareStatement(handler, ms.getStatementLog());
return handler.update(stmt);
}
这就是Mybatis中的模板方法模式的经典应用。
总结
模板方法模式就是定义了一个算法骨架，然后每个实现类自己去实现自己的业务逻辑。在Spring、Mybatis、Dubbo等框架中有很好实现案例。相对来说模板方法模式是算比较简单的哈，在面试中也能和面试官扯一会儿了。
「为了未来好一点 ,现在苦一点算什么」
微信关注我们
转载内容版权归作者及来源网站所有！
低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。
为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。
Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。
Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。
Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。
扫码在手机上查看文章
扫描二维码，手机阅读更方便
有任何问题或合作意向欢迎联系我们
Email: 99873273@qq.com
QQ: 99873273