前言

从3月份开始，打算找工作，一个偶然的机会，拉勾上一个蚂蚁金服的师兄找到我，说要内推，在此感谢姚师兄，然后就开始了蚂蚁金服的面试之旅。把简历发过去之后，就收到了邮件通知，10个工作日联系我，请耐心等待。

没过2天就接到一个杭州的座机，说要约我进行电话面试，效率还是挺高，然后当天晚上就进行了一面。下班后，吃了饭，专门找了一条人比较少的小路，到了7点，电话准时打过来了。

那这篇博客是不是就这样结束了呢？当然不是，重点才刚刚开始。

上面的职责链模式让人看起来很别扭，那是因为还没有优化过，我们发现再三个子类中都需要调用下一个处理器对不对，这样是不是比较麻烦，如果有人再添加处理器的时候忘记调用下一个处理器呢？bug是不是就来了，然后你就需要加班了，所以这种事情必须要扼杀在摇篮里，我们直接不在子类中调用下一个处理器，我们把调用下一个处理器放到抽象父类中，让他统一处理，就能完美解决了。

请看代码

package com.liuxing.handler;

/**

@ProjectName: handler-of-responsibility-pattern
@Package: com.liuxing.handler
@ClassName: Handler
@Author: 流星007
@Description: 处理器抽象父类
csdn：https://blog.csdn.net/qq_33220089
今日头条：https://www.toutiao.com/c/user/5372182357/#mid=1637641735275523
@Version: 1.0

public abstract class Handler {

/**

下一个处理器

protected Handler nextHandler = null;

/**

设置下一个处理器
@param nextHandler

public void setNextHandler(Handler nextHandler) {

this.nextHandler = nextHandler;

}

public final void handler(){

boolean flag = doHandler();

if(!flag && nextHandler!= null){

nextHandler.handler();

}

/**

处理器处理请求

protected abstract boolean doHandler();

}

package com.liuxing.handler;

/**

@ProjectName: handler-of-responsibility-pattern
@Package: com.liuxing.handler
@ClassName: Handler1
@Author: 流星007
@Description: 处理器1
csdn：https://blog.csdn.net/qq_33220089
今日头条：https://www.toutiao.com/c/user/5372182357/#mid=1637641735275523
@Version: 1.0

public class Handler1 extends Handler {

@Override

public boolean doHandler() {

System.out.println(“这是第一个handler，无法解决此问题，请求下一个处理器处理”);

return false;

}

package com.liuxing.handler;

/**

@ProjectName: handler-of-responsibility-pattern
@Package: com.liuxing.handler
@ClassName: Handler2
@Author: 流星007
@Description: 处理器2
csdn：https://blog.csdn.net/qq_33220089
今日头条：https://www.toutiao.com/c/user/5372182357/#mid=1637641735275523
@Version: 1.0

public class Handler2 extends Handler {

@Override

public boolean doHandler() {

System.out.println(“这是第二个handler，无法解决此问题，请求下一个处理器处理”);

return false;

}

package com.liuxing.handler;

/**

@ProjectName: handler-of-responsibility-pattern
@Package: com.liuxing.handler
@ClassName: Handler3
@Author: 流星007
@Description: 处理器3
csdn：https://blog.csdn.net/qq_33220089
今日头条：https://www.toutiao.com/c/user/5372182357/#mid=1637641735275523
@Version: 1.0

public class Handler3 extends Handler {

@Override

public boolean doHandler() {

boolean flag = true;

System.out.println(“这是第三个handler，问题解决，无需在往下执行”);

if(flag){

return true;

}

System.out.println(“执行结束，没有处理器能够解决这个请求”);

return false;

}

其他代码不变，我们发现，调用下一个处理器的代码被移动了抽象父类处理器Handler中，自立只需要安安心心的处理自己的逻辑即可，是不是降低的bug的产生率？

这里有个小知识点，大家直到我在抽象父类：Handler中为什么将handler();设置为final吗？知道的可以卸载评论区哦。

[](()使用数组实现职责链模式

==========================================================================

这种实现方式比上面那种基于链表的实现方式更为简单，也更容易理解，废话不多说，直接上代码

package com.liuxing.handler;

/**

@ProjectName: demo
@Package: com.liuxing.handler
@ClassName: IHandler
@Author: 流星007
@Description: 处理器接口
csdn：https://blog.csdn.net/qq_33220089
今日头条：https://www.toutiao.com/c/user/5372182357/#mid=1637641735275523
@Date: 2020/7/13 17:17
@Version: 1.0

public interface IHandler {

boolean handler();

}

package com.liuxing.handler;

/**

@ProjectName: handler-of-responsibility-pattern
@Package: com.liuxing.handler
@ClassName: Handler1
@Author: 流星007
@Description: 处理器1
csdn：https://blog.csdn.net/qq_33220089
今日头条：https://www.toutiao.com/c/user/5372182357/#mid=1637641735275523
@Version: 1.0

public class Handler1 implements IHandler {

@Override

public boolean handler() {

System.out.println(“这是第一个handler，无法解决此问题，请求下一个处理器处理”);

return false;

}

package com.liuxing.handler;

/**

@ProjectName: handler-of-responsibility-pattern
@Package: com.liuxing.handler
@ClassName: Handler2
@Author: 流星007
@Description: 处理器2
csdn：https://blog.csdn.net/qq_33220089
今日头条：https://www.toutiao.com/c/user/5372182357/#mid=1637641735275523
@Version: 1.0

public class Handler2 implements IHandler {

@Override

public boolean handler() {

System.out.println(“这是第二个handler，无法解决此问题，请求下一个处理器处理”);

return false;

}

package com.liuxing.handler;

/**

@ProjectName: handler-of-responsibility-pattern
@Package: com.liuxing.handler
@ClassName: Handler3
@Author: 流星007
@Description: 处理器3
csdn：https://blog.csdn.net/qq_33220089
今日头条：https://www.toutiao.com/c/user/5372182357/#mid=1637641735275523
@Version: 1.0

public class Handler3 implements IHandler{

@Override

public boolean handler() {

boolean flag = true;

System.out.println(“这是第三个handler，问题解决，无需在往下执行”);

if(flag){

return true;

}

System.out.println(“执行结束，没有处理器能够解决这个请求”);

return false;

}

package com.liuxing.chain;

import com.liuxing.handler.Handler;

import com.liuxing.handler.IHandler;

import org.springframework.util.CollectionUtils;

import java.util.ArrayList;

import java.util.List;

/**

@ProjectName: handler-of-responsibility-pattern
@Package: com.liuxing.chain
@ClassName: ChainHandler
@Author: 流星007
@Description: 处理器链
csdn：https://blog.csdn.net/qq_33220089
今日头条：https://www.toutiao.com/c/user/5372182357/#mid=1637641735275523
@Version: 1.0

public class ChainHandler {

/**

所有的处理器

private List list = new ArrayList();

/**

添加处理器
@param handler

public void addHandler(IHandler handler){

list.add(handler);

}

/**

开始执行handler

public void handler(){

if(CollectionUtils.isEmpty(list)){

return ;

}

for(IHandler handler: list){

if(handler.handler()){

return;

}

package com.liuxing.test;

import com.liuxing.chain.ChainHandler;

import com.liuxing.handler.Handler1;

import com.liuxing.handler.Handler2;

import com.liuxing.handler.Handler3;

public class HandlerTest {

public static void main(String[] args) {

ChainHandler chainHandler = new ChainHandler();

chainHandler.addHandler(new Handler1());

chainHandler.addHandler(new Handler2());

chainHandler.addHandler(new Handler3());

chainHandler.handler();

}

《一线大厂Java面试真题解析+Java核心总结学习笔记+最新全套讲解视频+实战项目源码》开源

Java优秀开源项目：

ali1024.coding.net/public/P7/Java/git

总结

上述知识点，囊括了目前互联网企业的主流应用技术以及能让你成为“香饽饽”的高级架构知识，每个笔记里面几乎都带有实战内容。

很多人担心学了容易忘，这里教你一个方法，那就是重复学习。

打个比方，假如你正在学习 spring 注解，突然发现了一个注解@Aspect，不知道干什么用的，你可能会去查看源码或者通过博客学习，花了半小时终于弄懂了，下次又看到@Aspect 了，你有点郁闷了，上次好像在哪哪哪学习，你快速打开网页花了五分钟又学会了。

从半小时和五分钟的对比中可以发现多学一次就离真正掌握知识又近了一步。

人的本性就是容易遗忘，只有不断加深印象、重复学习才能真正掌握，所以很多书我都是推荐大家多看几遍。哪有那么多天才，他只是比你多看了几遍书。

ndler(new Handler2());

chainHandler.addHandler(new Handler3());

chainHandler.handler();

}

《一线大厂Java面试真题解析+Java核心总结学习笔记+最新全套讲解视频+实战项目源码》开源

Java优秀开源项目：

ali1024.coding.net/public/P7/Java/git

总结

上述知识点，囊括了目前互联网企业的主流应用技术以及能让你成为“香饽饽”的高级架构知识，每个笔记里面几乎都带有实战内容。

很多人担心学了容易忘，这里教你一个方法，那就是重复学习。

从半小时和五分钟的对比中可以发现多学一次就离真正掌握知识又近了一步。

[外链图片转存中…(img-fORJ2hQF-1649669341343)]

【设计模式】职责链模式，MySQL+Tomcat+JVM，看完还怕面试官相关推荐

“金三银四”春招指南之“性能调优”：MySQL+Tomcat+JVM，看完还怕面试官的轰炸？
春招指南之"性能调优":MySQL+Tomcat+JVM,还怕面试官的轰炸? 01 MySQL性能调优 1.1 MySQL性能调优问题有哪些?怎么学? 关于这个,给大家看一份学习大 ...
MySQL+Tomcat+JVM，看完还怕面试官
前言我朋友也是个写了四年Java代码的程序员,跟女友已经恋爱多年,最近突然结婚了. 他结婚以前,换了一家公司,咱俩就好久没见过面了.刚好今天出门办事碰上了,找了一家店坐一起喝酒聊天. 我聊天时打趣他 ...
面试问烂的 MySQL 查询优化，看完屌打面试官！
Java大数据修炼之道优秀的Java技术公众号作者:唐立勇 https://segmentfault.com/a/1190000013672421 相关阅读面试问烂的 MySQL 四种隔离级别, ...
mysql 查看表v空间自增涨_面试问烂的 MySQL 查询优化，看完屌打面试官！
Java技术栈 www.javastack.cn 优秀的Java技术公众号作者:唐立勇 https://segmentfault.com/a/1190000013672421 什么影响了数据库查询速 ...
Python设计模式-职责链模式
Python设计模式-职责链模式代码基于3.5.2,代码如下; #coding:utf-8 #职责链模式class Handler():def __init__(self):self.success ...
第二十章 Caché 设计模式职责链模式
文章目录第二十章 Caché 设计模式职责链模式定义优点缺点结构图描述完整示例请求类抽象责任类实现责任类调用思考第二十章 Caché 设计模式职责链模式定义使多个对象 ...
别看是面试问烂的题目，一面试你照样还是不会系列MySQL四种隔离级别，看完吊打面试官！
别看是面试问烂的题目,一面试你照样还是不会系列MySQL四种隔离级别,看完吊打面试官! 什么是事务事务是应用程序中一系列严密的操作,所有操作必须成功完成,否则在每个操作中所作的所有更改都会被撤消.也 ...
C++设计模式-职责链模式
目录基本概念代码与实例在哪种地方使用基本概念职责链模式(Chain of Responsibility):时多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系.将这个对象连 ...
设计模式|职责链模式--流程状态审批（枚举实现）
流程审批在实际的项目中,我们经常会涉及到某个对象实体的状态转换,比如合同审批,请假审批,订单流程状态流转,由于本文不涉及工作流(Activiti,Zeebe)的介绍,只是介绍职责链模式的设计模式,因 ...
设计模式---职责链模式（Chain of Responsibility Pattern）
目录 1.学校 OA系统采购审批需求 2.传统方式解决审批流程 3.传统方式问题分析 4.职责链模式基本介绍 5.职责链模式原理类图 6.职责链模式解决OA采购审批 7.职责链模式在SpringM ...

【设计模式】职责链模式，MySQL+Tomcat+JVM，看完还怕面试官

前言

总结

总结

【设计模式】职责链模式，MySQL+Tomcat+JVM，看完还怕面试官相关推荐

最新文章

热门文章