博客原文地址:折腾Java设计模式之模板方法模式

模板方法模式

Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.

翻译过来就是,把算法的框架定义好,可以将某些步抽象出来放到子类去实现。模板方法允许子类在不改变算法框架的情况下重新实现算法的某些步骤。

模板方法模式UML图

UML图

抽象类AbstractClass定义了算法框架templateMethod()方法,其中有2个方法primitve1()primitve2()被抽象出来,子类SubClass1继承了抽象类AbstractClass,从而实现了primitve1()primitve2()

模板方法模式角色

抽象类(AbstractClass): 定义了算法核心框架,同时把局部的算法行为封装成步骤,让子类去实现。

子类(SubClass): 继承了抽象类,实现抽象类中的抽象方法,具体实现了算法部分逻辑。

模板方法模式源码示例

源码地址:Template-method

抽象方法

先定义抽象类,抽象类AbstractProcessor中核心算法handle方法中大体分3部,第一先校验参数具体怎么校验放在子类中实现,第二获取结果也放在子类实现,第三获取结果后的操作也放在子类实现。

@Slf4j
public abstract class AbstractProcessor<P extends Request, R extends Response> { /**
* 逻辑处理
*
* @param request
* @return
*/
public R handle(P request) {
// 1.校验参数
log.info("开始处理, 请求参数={}", request);
validRequest(request); // 2.获取结果
R response = getResponse(request);
log.info("获取结果, 响应结果={}", response); // 3.结果之后的处理
afterHandle(response);
return response;
} /**
* 结果之后的处理 可以更新其他业务或者处理缓存
*
* @param response
*/
protected abstract void afterHandle(R response); /**
* 校验请求参数
*
* @param request
*/
protected void validRequest(P request) {
if (Objects.isNull(request.getToken())) {
throw new RuntimeException("token不能为空");
}
if (Objects.isNull(request.getVersion())) {
throw new RuntimeException("version不能为空");
} validRequestParam(request);
} /**
* 校验请求真正的参数
* @param request
*/
protected abstract void validRequestParam(P request); /**
* 获取到结果
* @param request
* @return
*/
protected abstract R getResponse(P request);
}

基本请求

@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class Request { private String version; private String token;
}

基本响应

@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class Response { private String msg; private int code; private boolean success; }

子类实现

第一个子类实现

@Slf4j
public class OneProcessor extends AbstractProcessor<OneRequest, OneResponse> { public OneProcessor() {
ProcessorFactory.putProcess("two", this);
} @Override
protected void afterHandle(OneResponse response) {
log.info("处理One结果: {}", response.getOne());
} @Override
protected void validRequestParam(OneRequest request) {
log.info("校验one参数...省略......");
} @Override
protected OneResponse getResponse(OneRequest request) {
String name = request.getName();
return OneResponse.builder()
.one(name + "one")
.success(true)
.code(0)
.msg("成功")
.build();
}
}

第一个子类的请求

@Data
@ToString(callSuper = true)
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class OneRequest extends Request { private String name; @Builder.Default
private int a = 0; }

第一个子类的响应

@Data
@ToString(callSuper = true)
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class OneResponse extends Response { private String one; }

第二个子类实现

@Slf4j
public class TwoProcessor extends AbstractProcessor<TwoRequest, TwoResponse> { public TwoProcessor() {
ProcessorFactory.putProcess("two", this);
} @Override
protected void afterHandle(TwoResponse response) {
log.info("处理结果TWO, {}", response);
} @Override
protected void validRequestParam(TwoRequest request) {
log.info("校验TWO参数...省略......");
} @Override
protected TwoResponse getResponse(TwoRequest request) {
Long id = request.getId();
return TwoResponse.builder()
.two("id为"+id)
.success(true)
.code(0)
.msg("成功")
.build();
}
}

第二个子类的请求

@Data
@ToString(callSuper = true)
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class TwoRequest extends Request { private Long id;
}

第二个子类的响应

@Data
@ToString(callSuper = true)
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class TwoResponse extends Response { private String two;
}

扩展为工厂

有的时候我们定义的子类在Spring容器的时候由Spring定义好后,我们其实可以借用工厂模式方法,在子类初始化的时候就把子类放置在ProcessorFactory中,后续只需要根据key从中拿取即可,实际项目中用这种方式还是比较多的。

public class ProcessorFactory {

    private static Map<String, AbstractProcessor> factories = new HashMap();

    public static void putProcess(String key, AbstractProcessor process) {
factories.put(key, process);
} public static AbstractProcessor selectProcess(String key) {
return factories.get(key);
} }

执行程序

@Slf4j
public class TemplateMethodApplication { public static void main(String[] args) {
OneRequest oneRequest = OneRequest.builder()
.version("2312312")
.token("23423")
.name("张三")
.build();
new OneProcessor().handle(oneRequest); log.info("--------------------------"); TwoRequest twoRequest = TwoRequest.builder()
.version("2312312")
.token("23423")
.id(23456L)
.build();
new TwoProcessor().handle(twoRequest); }
}

结果

总体上来讲,抽象类中定义了算法的框架,然后把部分算法步骤抽象出来供子类实现,有的时候有些方法只有个别子类会去实现,我们可以在抽象类中实现为空实现,在有需要的子类中我们可以覆盖抽象类的实现,这样避免了所有的子类都去实现,其实不关心的话都是空实现了。本示例用到了lombok@SuperBuilder特性,可能在下载完完整的代码后会出现编译错误,这是因为Lombok的插件暂时还不支持@SuperBuilder

模板方法模式总结

模板方法经常和其他模式混合使用,比如工厂、策略等等。其实在Spring中大量使用了模板方法模式,其实也不光在Spring中,像平时jdbcTemplate或者RedisTemplate,像这种带有Template的。

优点 1、封装不变部分,扩展可变部分。 2、提取公共代码,便于维护。 3、行为由父类控制,子类实现。

缺点 每一个不同的实现都需要一个子类来实现,导致类的个数增加,使得系统更加庞大。

使用场景 1、有多个子类共有的方法,且逻辑相同。 2、重要的、复杂的方法,可以考虑作为模板方法。

注意事项 为防止恶意操作,一般模板方法都加上 final 关键词。

参考

模板模式|菜鸟教程

Template method pattern

欢迎关注我的微信公众号

折腾Java设计模式之模板方法模式的更多相关文章

  1. 折腾Java设计模式之建造者模式

    博文原址:折腾Java设计模式之建造者模式 建造者模式 Separate the construction of a complex object from its representation, a ...

  2. 折腾Java设计模式之备忘录模式

    原文地址:折腾Java设计模式之备忘录模式 备忘录模式 Without violating encapsulation, capture and externalize an object's int ...

  3. 折腾Java设计模式之状态模式

    原文地址 折腾Java设计模式之状态模式 状态模式 在状态模式(State Pattern)中,类的行为是基于它的状态改变的.这种类型的设计模式属于行为型模式.在状态模式中,我们创建表示各种状态的对象 ...

  4. 折腾Java设计模式之访问者模式

    博客原文地址:折腾Java设计模式之访问者模式 访问者模式 Represent an operation to be performed on the elements of an object st ...

  5. 折腾Java设计模式之命令模式

    博客原文地址 折腾Java设计模式之命令模式 命令模式 wiki上的描述 Encapsulate a request as an object, thereby allowing for the pa ...

  6. Java设计模式应用——模板方法模式

    所谓模板方法模式,就是在一组方法结构一致,只有部分逻辑不一样时,使用抽象类制作一个逻辑模板,具体是实现类仅仅实现特殊逻辑就行了.类似科举制度八股文,文章结构相同,仅仅具体语句有差异,我们只需要按照八股 ...

  7. Java设计模式之模板方法模式(Template)

    前言: 我们在开发中有很多固定的流程,这些流程有很多步凑是固定的,比如JDBC中获取连接,关闭连接这些流程是固定不变的,变动的只有设置参数,解析结果集这些是根据不同的实体对象“来做调整”,针对这种拥有 ...

  8. java设计模式之模板方法模式

    模板方法模式 定义一个操作中的算法的骨架,而将一些步骤延迟到子类中. 模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤.通俗的说的就是有很多相同的步骤的,在某一些地方可能有一些差 ...

  9. 折腾Java设计模式之迭代器模式

    迭代器模式 Provide a way to access the elements of an aggregate object sequentially without exposing its ...

随机推荐

  1. mpvue 小程序开发爬坑汇总

    <!-- 小程序的爬坑记录 --> 1 微信小程序之动态获取元素宽高 var obj=wx.createSelectorQuery(); 2 微信小程序图片自适应 <image cl ...

  2. 【EXCEL-折线图】百折不挠 | 用EXCEL画出与众不同的折线图(曲线图)

    很多熟悉EXLCE的朋友都知道EXCEL在生成统计图表方面的强大功能,我们在写各类总结.报告.方案等文档时常涉及到各类统计数字,将统计数字用图表的形式展示出来,既直观又美观.下面我分享一种不一样的折线 ...

  3. django+mysql的使用

    Django中每一个模型model都对应于数据库中的一张表,每个模型中的字段都对应于数据库表的列.方便的是,django可以自动生成这些create table, alter table, drop ...

  4. Redux的中间件原理分析

    redux的中间件对于使用过redux的各位都不会感到陌生,通过应用上我们需要的所有要应用在redux流程上的中间件,我们可以加强dispatch的功能.最近也有一些初学者同时和实习生在询问中间件有关 ...

  5. ASP.NET Core微服务实战系列

    希望给你3-5分钟的碎片化学习,可能是坐地铁.等公交,积少成多,水滴石穿,码字辛苦,如果你吃了蛋觉得味道不错,希望点个赞,谢谢关注. 前言 这里记录的是个人奋斗和成长的地方,该篇只是一个系列目录和构想 ...

  6. 基于.NET的APP开发和Windows开发,异步回调差别

    在Smobiler的开发中,控件或组件及客户端功能都是通过事件或委托来进行处理的. Smobiler是基于异步非阻塞的方式来运行的 下面我们分别对Windows的和Smobiler的MessageBo ...

  7. C# Array数组是引用类型

    在C#中值类型都是由System.ValueType的直接派生类,System.ValueType本身又是直接从System.Object派生的.派生的意思是‘利用继承机制,新的类可以从已有的类中生出 ...

  8. 驰骋工作流引擎 -CCBPM如何自动升级

    关键词:工作流引擎自动升级   工作流自动升级升级步骤设置1,CCBPM把更新分成三类, 应用程序代码更新.数据表结构更新.数据更新.2,CCBPM在您登录流程设计器时自动判断当前的版本与数据库版本是 ...

  9. Android 启动优化

    对与Android的项目来说,app的启动速度是非常重要的.因为用户打开你的app给别人的第一体验就是打开软件的速度.但是app的启动速度是比较难以缩短的,因为一般来说开发者在app的启动入口都会创建 ...

  10. v4v7升级到androidx过程

    因为原项目应用的都是v4v7包,谷歌改成androidx后就升级了一番,首先在properties文件 然后在菜单里点击升级,studio会帮你把报名什么的都改掉 打开项目,发现都自动改掉了,完美,然 ...