责任链模式【Chain of Responsibility Pattern】

责任链模式(Chain of Responsibility Pattern)—— 嵌套拦截器 一、what is 责任链模式? 我前面的文章介绍过动态代理模式,该模式设计者只需要向开发者暴露拦截器即可。当有多个拦截器时,就衍生出了责任链。 什么是责任链?比如请假流程:请假单看成对象,你要请假需要经过开发经理、部门经理、人事部门负责人等多个环节,每个环节的人都可以拦截你的请假申请单进行修改或审批,这里把每个环节都看成拦截器的话,总共有三个拦截器。 一个对象在一条链上被多个拦截器处... 阅读详情

        中国古代对妇女制定了“三从四德”的道德规范,“三从”是指“未嫁从父、既嫁从夫、夫死从子”,也就是说一个女性,在没有结婚的时候要听从于父亲,结了婚后听从于丈夫,丈夫死了还要听儿子的,举个例子来说,一个女的要出去逛街,同样这样的一个请求,在她没有出嫁前她必须征得父亲的同意,出嫁之后必须获得丈夫的许可,那丈夫死了怎么办?一般都是男的比女的死的早,还要问问儿子是否允许自己出去逛街,估计你下边马上要问要是没有儿子怎么办?请示小叔子、侄子等等,在父系社会中,妇女只占从属地位,现在想想中国的妇女还是比较悲惨的,逛个街还要请示来请示去,而且作为父亲、丈夫、儿子只有两种选择:要不承担起责任来告诉她允许或不允许逛街,要不就让她请示下一个人,这是整个社会体系的约束,应用到我们项目中就是业务规则,那我们来看怎么把“三从”通过我们的程序来实现,需求很简单:通过程序描述一下古代妇女的“三从”制度,好我们先看类图:


非常简单的类图,这个实现也非常简单,我们先看 IWomen 接口:

package com.cbf4life.common;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 古代悲哀女性的总称
*/
public interface IWomen {
//获得个人状况
public int getType();

//获得个人请示,你要干什么?出去逛街?约会?还是看电影
public String getRequest();
} 
女性就两个参数,一个是当前的个人状况,是结婚了呢还是没结婚,丈夫有没有去世,另外一个是要请示的内容,要出去逛街呀还是吃饭,我们看实现类:
package com.cbf4life.common;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 古代女性的总称
*/
public class Women implements IWomen{
/*
 * 通过一个int类型的参数来描述妇女的个人状况
 * 1---未出嫁
 * 2---出嫁
 * 3---夫死
 */
private int type=0;

//妇女的请示
private String request = "";

//构造函数传递过来请求
public Women(int _type,String _request){
 this.type = _type;
 this.request = _request;
 }

//获得自己的状况
public int getType(){
 return this.type;
 }

//获得妇女的请求
public String getRequest(){
 return this.request;
 }
} 
我们使用数字来代表女性的不同状态,1 是未结婚,2 是已经结婚的,而且丈夫建在,3 是丈夫去世了的。我们再来看有处理权的人员接口:
package com.cbf4life.common;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 父系社会,那就是男性有至高权利,handler控制权
*/
public interface IHandler {

//一个女性(女儿,妻子或者是母亲)要求逛街,你要处理这个请求
public void HandleMessage(IWomen women);

} 
父亲、丈夫、儿子都是这个 IHandler 接口的实现者:
package com.cbf4life.common;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 父亲
*/
public class Father implements IHandler {
//未出嫁女儿来请示父亲
public void HandleMessage(IWomen women) {
 System.out.println("女儿的请示是:"+women.getRequest());
 System.out.println("父亲的答复是:同意");
 }
} 
package com.cbf4life.common;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 丈夫类
*/
public class Husband implements IHandler {
//妻子向丈夫请示
public void HandleMessage(IWomen women) {
 System.out.println("妻子的请示是:"+women.getRequest());
 System.out.println("丈夫的答复是:同意");
 }
} 
package com.cbf4life.common;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 儿子类
*/
public class Son implements IHandler {
//目前向儿子请示
public void HandleMessage(IWomen women) {
 System.out.println("母亲的请示是:"+women.getRequest());
 System.out.println("儿子的答复是:同意");
 }
} 
这三个类非常非常的简单,就一个方法,处理女儿、妻子、母亲提出的请求,再来看 Client 是怎么组装的:
package com.cbf4life.common;
import java.util.ArrayList;
import java.util.Random;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 我们后人来看这样的社会道德
*/
@SuppressWarnings("all")
public class Client {

public static void main(String[] args) {
 //随机挑选几个女性
 Random rand = new Random();
 ArrayList<IWomen> arrayList = new ArrayList();
 for(int i=0;i<5;i++){
 arrayList.add(new Women(rand.nextInt(4),"我要出去逛街"));
 } 
 //定义三个请示对象
 IHandler father = new Father();
 IHandler husband = new Husband();
 IHandler son = new Son();

 for(IWomen women:arrayList){
 if(women.getType() ==1){ //未结婚少女,请示父亲
 System.out.println("\n--------女儿向父亲请示-------");
 father.HandleMessage(women);
 }else if(women.getType() ==2){ //已婚少妇,请示丈夫
 System.out.println("\n--------妻子向丈夫请示-------");
 husband.HandleMessage(women);
 }else if(women.getType() == 3){ //母亲请示儿子
 System.out.println("\n--------母亲向儿子请示-------");
 son.HandleMessage(women);
 }else{
 //暂时啥也不做
 }
 }
 }

} 
首先是通过随机方法产生了 5 个古代妇女的对象,然后看她们是如何就逛街这件事去请示的,运行结果如下:(由于是随机的,您看到得结果可能和这里有所不同)
--------女儿向父亲请示-------
女儿的请示是:我要出去逛街
父亲的答复是:同意
--------妻子向丈夫请示-------
妻子的请示是:我要出去逛街
丈夫的答复是:同意
--------妻子向丈夫请示-------
妻子的请示是:我要出去逛街
丈夫的答复是:同意
--------女儿向父亲请示-------
女儿的请示是:我要出去逛街
父亲的答复是:同意
        “三从四德”的旧社会规范已经完整的表现出来了,你看谁向谁请示都定义出来了,但是你是不是发现这个程序写的有点不舒服?有点别扭?有点想重构它的感觉?那就对了!这段代码有以下几个问题:
       失去面向对象的意义。对女儿提出的请示,应该在父亲类中做出决定,父亲这个类应该是知道女儿的请求应该自己处理,而不是在 Client 类中进行组装出来,也就是说原本应该是父亲这个类做的事情抛给了其他类进行处理;
        迪米特法则相违背。我们在 Client 类中写了 if…eles 的判断条件,你看这个条件体内都是一个接口IHandler 的三个实现类,谁能处理那个请求,怎么处理,直接在实现类中定义好不就结了吗?你的类我知道的越少越好,别让我猜测你类中的逻辑,想想看,把这段 if…else 移动到三个实现类中该怎么做?
       耦合过重。这个什么意思呢,我们要根据 Women 的 type 来决定使用 IHandler 的那个实现类来处理请求,我问你,如果 IHanlder 的实现类继续扩展怎么办?修改 Client 类?与开闭原则违背喽!

       异常情况没有考虑。妻子只能向丈夫请示吗?如果妻子向自己的父亲请示了,父亲应该做何处理?我们的程序上可没有体现出来。

       既然有这么多的问题,那我们要想办法来解决这些问题,我们可以抽象成这样一个结构,女性的请求先发送到父亲类,父亲类一看是自己要处理的,就回应处理,如果女儿已经出嫁了,那就要把这个请求转发到女婿来处理,那女婿一旦去天国报道了,那就由儿子来处理这个请求,类似于这样请求:


父亲、丈夫、儿子每个节点有两个选择:要么承担责任,做出回复;要么把请求转发到后序环节。结构分析的已经很清楚了,那我们看怎么来实现这个功能,先看类图:


从类图上看,三个实现类 Father、Husband、Son 只要实现构造函数和父类的中抽象方法就可以了,具体怎么处理这些请求,都已经转移到了 Hanlder 抽象类中,我们来看 Hanlder 怎么实现:

package com.cbf4life.advance;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 父系社会,那就是男性有至高权利,handler控制权
*/
public abstract class Handler {
//能处理的级别
private int level =0;

//责任传递,下一个人责任人是谁
private Handler nextHanlder;

//每个类都要说明一下自己能处理哪些请求
public Handler(int _level){
 this.level = _level;
 }

//一个女性(女儿,妻子或者是母亲)要求逛街,你要处理这个请求
public final void HandleMessage(IWomen women){
 if(women.getType() == this.level){
 this.response(women);
 }else{
 if(this.nextHanlder != null){ //有后续环节,才把请求往后递送
 this.nextHanlder.HandleMessage(women);
 }else{ //已经没有后续处理人了,不用处理了
 System.out.println("-----------没地方请示了,不做处理!---------\n"); 
 }

 }
 }

/*
 * 如果你属于你处理的返回,你应该让她找下一个环节的人,比如
 * 女儿出嫁了,还向父亲请示是否可以逛街,那父亲就应该告诉女儿,应该找丈夫请示
 */
public void setNext(Handler _handler){
 this.nextHanlder = _handler;
 }

//有请示那当然要回应
public abstract void response(IWomen women);
} 
       有没有看到,其实在这里也用到模版方法模式,在模版方法中判断请求的级别和当前能够处理的级别,如果相同则调用基本方法,做出反馈;如果不相等,则传递到下一个环节,由下一环节做出回应。基本方法 response 要各个实现类都要实现,我们来看三个实现类:
package com.cbf4life.advance;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 父亲
*/
public class Father extends Handler {
//父亲只处理女儿的请求
public Father(){
 super(1);
 }

//父亲的答复
@Override
public void response(IWomen women) {
 System.out.println("--------女儿向父亲请示-------");
 System.out.println(women.getRequest());
 System.out.println("父亲的答复是:同意\n");
 } 
} 
package com.cbf4life.advance;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 丈夫类
*/
public class Husband extends Handler {
//丈夫只处理妻子的请求
public Husband(){
 super(2);
 }

//丈夫请示的答复
@Override
public void response(IWomen women) {
 System.out.println("--------妻子向丈夫请示-------");
 System.out.println(women.getRequest());
 System.out.println("丈夫的答复是:同意\n");
 }
} 
package com.cbf4life.advance;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 儿子类
*/
public class Son extends Handler {
//儿子只处理母亲的请求
public Son(){
 super(3);
 }

//儿子的答复
public void response(IWomen women) {
 System.out.println("--------母亲向儿子请示-------");
 System.out.println(women.getRequest());
 System.out.println("儿子的答复是:同意\n");
 } 

}
       这三个类都很简单,构造方法那是你必须实现的,父类已经定义了,子类不实现编译不通过,通过构造方法我们设置了各个类能处理的请求类型,Father 只能处理请求类型为 1(也就是女儿)的请求;Husband只能处理请求类型类 2(也就是妻子)的请求;儿子只能处理请求类型为 3(也就是目前)的请求。

Women 类的接口没有任何变化,实现类少有变化,看代码:

package com.cbf4life.advance;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 古代女性的总称
*/
public class Women implements IWomen{
/*
 * 通过一个int类型的参数来描述妇女的个人状况
 * 1---未出嫁
 * 2---出嫁
 * 3---夫死
 */
private int type=0;

//妇女的请示
private String request = "";

//构造函数传递过来请求
public Women(int _type,String _request){
 this.type = _type;

 //为了显示好看点,我在这里做了点处理
 switch(this.type){
 case 1:
 this.request = "女儿的请求是:" + _request;
 break;
 case 2:
 this.request = "妻子的请求是:" + _request;
 break;
 case 3:
 this.request = "母亲的请求是:" + _request; 
 }
 }

//获得自己的状况
public int getType(){
 return this.type;
 }

//获得妇女的请求
public String getRequest(){
 return this.request;
 }
} 
就是为了展示结果清晰一点,Women 类做了一点改变,看黄色部分。我们再来看 Client 类是怎么描述古代这一个礼节的:
package com.cbf4life.advance;
import java.util.ArrayList;
import java.util.Random;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 我们后人来看这样的社会道德
*/
@SuppressWarnings("all")
public class Client {

public static void main(String[] args) {
 //随机挑选几个女性
 Random rand = new Random();
 ArrayList<IWomen> arrayList = new ArrayList();
 for(int i=0;i<5;i++){
 arrayList.add(new Women(rand.nextInt(4),"我要出去逛街"));
 }
 //定义三个请示对象
 Handler father = new Father();
 Handler husband = new Husband();
 Handler son = new Son(); 


 //设置请示顺序
 father.setNext(husband);
 husband.setNext(son);

 for(IWomen women:arrayList){
 father.HandleMessage(women);
 }
 }

} 
通过在 Client 中设置请求的传递顺序,解决了请求到底谁来回应的问题,运行结果如下:
--------妻子向丈夫请示-------
妻子的请求是:我要出去逛街
丈夫的答复是:同意
--------女儿向父亲请示-------
女儿的请求是:我要出去逛街
父亲的答复是:同意
--------母亲向儿子请示-------
母亲的请求是:我要出去逛街
儿子的答复是:同意
--------妻子向丈夫请示-------
妻子的请求是:我要出去逛街
丈夫的答复是:同意
--------母亲向儿子请示-------
母亲的请求是:我要出去逛街
儿子的答复是:同意
       结果也正确,业务调用类 Client 也不用去做判断到底是需要谁去处理,而且 Handler 抽象类的子类以后可以继续增加下去,只是我们这个传递链增加而已,调用类可以不用了解变化过程,甚至是谁在处理这个请求都不用知道。
        以上讲解的就是责任链模式,你看 Father、Husband、Son 这三个类的处理女性的请求时是不是在传递呀,每个环节只有两个选项:要么承担责任做出回应,要么向下传递请求,最终会有环节做出回应,通用 类图如下:



在通用类图中 Handler 是一个接口或者是抽象类,每个实现类都有两个方法 HandlerRequest 是处理请求,setNext 是设置当前环节怎么把不属于自己处理的请求扔给谁,对于这个类图我觉得需要改变,融合进来模版方法模式,类图如下:


       想想单一职责法则和迪米特法则吧,通过融合模版方法模式,各个实现类只要关注的自己业务逻辑就成了,至于说什么事要自己处理,那就让父类去决定好了,也就是说父类实现了请求传递的功能,子类实现请求的处理,符合单一职责法则,各个类只作一个动作或逻辑,也就是只有一个原因引起类的改变,我建议大家在使用的时候用这种方法,好处是非常明显的了,子类的实现非常简单,责任链的建立也非常的灵活。

       这里顺便插一句话,在论坛上有网友不赞成我这种写法,说是没有抓住 XX 模式的核心的,我想请问你一下,XX 模式的核心是什么?就拿今天讲的责任链模式来说,GOF 是这样说的:

           Avoid coupling the sender of a request to its receiver by giving more than one object a chanceto handle the request. Chain the receiving objects and pass the request along the chain untilan object handles it.

         这是 GOF 的原话,我想请问大侠,告诉我这句话是什么意思,如果你来给读者讲解,你想怎么讲?翻译成中文?拿着彦 X 的那本书给读者讲?照本宣科?你觉的还有人来看吗?模式是在经验中积累的,是知识的结晶,而不是死板硬套的模子!不要因为一些写模式的书比较流行就膜拜了,自己动脑筋想想这模式真是就只能是这样吗? 是不是有更优秀的方式来替代呢?别照抄别人的!

       责任链模式屏蔽了请求的处理过程,你发起一个请求到底是谁处理的,这个你不用关心,只要你把请求抛给责任链的第一个处理者,最终会返回一个处理结果(当然也可以不做任何处理),作为请求者可以不用知道到底是需要谁来处理的,这是责任链模式的核心;同时责任链模式也可以做为一种补救模式来使用,举个简单例子,如项目开发的时候,需求确认是这样的:一个请求(比如银行客户存款的币种),一个处理者(只处理人民币),但是随着业务的发展(改革开放了嘛,还要处理美元、日元等等),处理者的数量和类型都有所增加,那这时候就可以在第一个处理者后面建立一个链,也就是责任链来处理请求,你是人民币,好,还是第一个业务逻辑来处理,你是美元,好,传递到第二个业务逻辑来处理,日元,欧元…,这些都不用在对原有的业务逻辑产生很大改变,通过扩展实现类就可以很好的解决这些需求变更的问题。

       责任链有一个缺点是大家在开发的时候要注意:调试不是很方便,特别是链条比较长,环节比较多的时候,由于采用了类似递归的方式,调试的时候逻辑可能比较复杂。

       、责任链在实际的项目中使用也是比较多的,我曾经做过这样一个项目,界面上有一个用户注册功能,注册用户分两种,一种是 VIP 用户,也就是在该单位办理过业务的,一种是普通用户,一个用户的注册要填写一堆信息,VIP 用户只比普通用户多了一个输入项:VIP 序列号,注册后还需要激活, VIP 和普通用户的激活流程也是不同的,VIP 是自动发送邮件到用户的邮箱中就算激活了,普通用户要发送短信才能激活,为什么呢?获得手机号码以后好发广告短信呀!这个功能项目组就采用了责任链模式,甭管从前台传递过来的是 VIP 用户信息还是普通用户信息,统一传递到一个处理入口,通过责任链来完成任务的处理,类图如下:


          其中 RegisterAction 是继承了 Strust2 中的 ActionSupport,实现 HTTP 传递过来的对象组装,组装出一个 HashMap 对象 UserInfoMap,传递给 handler 的两个实现类,具体是那个实现类来处理的,就由 HashMap上的用户标识来做决定了,这个和上面我们举的例子很类似,代码大家自己实现。

         还有一个问题需要和大家说明一下,观察者模式也可以实现请求的传递,比如一个事件发生了,通知了观察者,同时观察者又作为一个被观察者,通知了另外一个观察者,这也形成了一个事件广播链,这和我们今天讲的责任链是有区别的:

        受众数量不同。观察者广播链式可以 1:N 的方式广播,而责任链则要求是的 1:1 的传递,必然有一个且只有一个类完成请求的处理;

      请求内容不同。观察者广播链中的信息可以在传播中改变,但是责任链中的请求是不可改变的;

       处理逻辑不通。观察者广播链主要用于触发联动动作,而责任链则是对一个类型的请求按照既定的规则进行处理。


责任链模式(Chain of Responsibility Pattern) 责任链模式是一种行为型设计模式,它将请求的发送者和接收者解耦,使多个对象都有机会处理这个请求。将这些对象连成一条链,并沿着这条链传递请求,直到有一个对象处理它为止。责任链模式是一种灵活且强大的设计模式,尤其适用于处理流程化的请求处理场景。它通过将请求的发送者和接收者解耦,提高了系统的灵活性和可扩展性。抽象出请求处理者的统一接口或抽象类每个处理者只关注自己能处理的请求类型构建一条处理链,让请求在链上传递客户端只需要访问链的头部节点合理设计链的长度,避免链过长导致性能问题。 阅读详情

相关推荐

CS算法实战:用MATLAB从零实现SAR点目标成像(附完整代码)

本文详细介绍了如何使用MATLAB从零实现SAR点目标CS成像算法,涵盖Chirp Scaling(CS)算法的核心理论、距离徙动校正(RCMC)和方位压缩等关键步骤。通过完整的代码示例和实战技巧,帮助读者掌握SAR成像处理算法,提升遥感图像处理能力。

weixin_29211309的博客 181

设计模式学习笔记(二):门面模式【Facade】(一) 问题的提出

学习自博客园的author cbf4Life cbf4life@126.com

学习点滴的专栏 481

评分卡建模学习(一)————数据预处理part.3

目录六、数据处理的思路及代码(一)对缺失值的处理:在我这个数据预处理的part.1板块(二)对异常值的处理:在我这个数据预处理的part.2板块(三)数据归一化、标准化:在我这个数据预处理的part.2板块(四)非结构化数据转变+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++———————————————————————————————————————————++++++++++++++++++++++++++

Morven_dai的博客 898

设计模式10-责任链模式

中国古代对妇女制定了“三从四德”的道德规范,“三从”是指未嫁从父,既嫁从夫,夫死从子。也就是说一位女性在结婚之前要听从父亲,结婚后要听从于丈夫,如果丈夫死了还要听从于儿子。比如要逛街,作为父亲,丈夫或儿子,只有两种选择:要不要承担起责任来,允许她或不允许她逛街;要不就让她请示下一个人。这就延伸出了责任链模式。类图如下:

wj903829182的专栏 781

树莓派c语言串口通讯程序

在网上搜了很多关于树莓派串口通讯的例子,但是都是用python写的,虽然python很有名,而且最近也在学习这门语言, 但是还是想用c语言实现一下,因为需要用到整套系统里,其他内容都是用c语言写的。但是网上没有找打现成的。 还好,之前做过天嵌2440开发板的串口程序(参照天嵌工程师提供的代码),发现串口程序其实是通用的, 驱动层屏蔽了硬件细节,个人猜测,几乎所有移植好的系统的串口,都可以用一

realank的专栏 1万+

百度API实现人流量数量检测(动态)

百度的这个API还挺好用的,对与不追求高精度的人来说非常适用,结合他官方给的文档,极易上手。 需要做的就是通过API Key和Secret Key获取的access_token。 然后稍微修改下代码就行,但是他给的代码并没有直接从摄像头获取视频,而是读取一个文件夹,那么就需要自己先对摄像头的输出视频进行处理。 识别结果如下,"person_num"是当前画面的人数,in是累计进入的人数,out是累计走出去的人数。 他这个有个缺点就是返回值里边并没有实时返回in和out的值,而是都是0,但是这个图片上有,图片

qq_42479987的博客 3389

设计模式原则16----责任链模式

个人博客:打开链接 责任链模式的定义 使多个对象都有机会处理请求,从而避免了请求的发送者和接收者的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有对象处理它为止。 例子:古代妇女的枷锁—-三从四德 古代女子要 “三从四德”,这里的三从是什么呢?是指“未嫁从父,既嫁从夫,夫死从子”。也就是说,一位女性在结婚前听父亲的,结婚后听丈夫的,丈夫G了听儿子的,没有儿子听小叔子的...

JingLisen的博客 511

基于Hadoop的NBA篮球球员大数据分析与可视化系统大数据分析系统python的项目(源码+lw+部署文档+讲解等)

本系统以 Hadoop 为基础,致力于对 NBA 篮球球员的海量数据进行深入分析与可视化呈现。它能够收集来自多个数据源的丰富数据,包括球员比赛统计数据、身体素质数据、技术特点数据等。利用 Hadoop 的分布式存储和计算能力,对这些大规模数据进行高效处理。通过数据分析算法,挖掘球员的潜在价值和特点,如球员的得分能力趋势、篮板球效率变化、不同位置球员的技术差异等。同时,借助先进的可视化技术,将分析结果以直观的图表、图形等形式展示出来。教练和球队管理层可以通过可视化界面清晰地了解球员的综合表现和发展态势,从而制

QQ3359892174的博客 1315

责任链模式

中国古代对妇女制定了“三从四德”的道德规范,“三从”是指“未嫁从父、既嫁从夫、夫 死从子”。也就是说,一位女性在结婚之前要听从于父亲,结婚之后要听从于丈夫,如果丈 夫死了还要听从于儿子。举例来说,如果一位女性要出去逛街,在她出嫁前必须征得父亲的 同意,出嫁之后必须获得丈夫的许可,那丈夫死了怎么办?那就得问问儿子是否允许自己出 去逛街。估计你接下来马上要问:“要是没有儿子怎么办?”那就请示小叔子、侄...

zy1104560031的专栏 310

[PCIe5.0] 3.4.1 Flow Control Initialization State Machine Rules

流控初始化是PCIe链路中每个虚拟通道(VC)启用的必经流程,分为FC_INIT1和FC_INIT2两个阶段,确保发送端与接收端的缓冲区信用值协商一致。

系统固件工程师 139

YOLO26-Quantized:面向国产AI芯片的全栈量化方案,适配昇腾310P与寒武纪MLU270

在算力国产化替代的行业趋势下,昇腾310P、寒武纪MLU270已成为工业边缘视觉、智能检测场景的主流国产AI芯片选型。针对原生YOLO26模型在国产芯片上推理效率低、算子兼容性差、量化精度塌陷三大核心痛点,本文提出YOLO26-Quantized全栈量化方案,覆盖训练感知量化(QAT)、离线静态量化(PTQ)、模型编译优化、芯片专属部署全流程。

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 764

设计模式之责任链模式

责任链模式的定义如下: 是多个对象都有机会处理请求,从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有对象处理它位置。 责任链模式的通用类图如下: 下面以《设计模式之禅》中的例子说明一下,中国古代对父母制定了“三从四德”的规范,所谓“三从”指“未嫁从父,既嫁从夫,夫死从子”,下面就用责任链模式来说明一下“三从”,加入

想成为工程师的码农 580

【AI Agent】Hermes Agent解析

Hermes Agent:一个具备持久化学习能力的开源AI Agent框架 核心特点: 突破传统Agent的"无状态困境",通过记忆系统(SQLite+FTS5全文检索)实现跨会话经验积累 支持200+模型自由切换,11种模型家族和15+平台接入 五层架构设计(入口层、编排层、推理层、工具执行层、存储层)实现平台无关性 47+内置工具和动态技能沉淀机制,支持从任务执行中自动提炼可复用Skill 独特的四层记忆体系(会话/每日/长期/向量索引)和辩证式用户建模 与传统Agent对比: 具备自我进化能力,通过A

sysu_lluozh 976

设计模式中的责任链模式(Chain of Responsibility Pattern)

在软件开发中,经常会遇到需要按照顺序处理请求的情况,例如日志处理、权限控制、审批流程等。如果使用硬编码的 `if-else` 结构,代码将变得复杂且难以扩展。 **责任链模式(Chain of Responsibility Pattern)** 提供了一种**将请求的处理者组织成链式结构**的方法,使请求可以**沿着责任链传递,直到被某个处理者处理**,从而提高代码的灵活性和可扩展性。本文将详细介绍责任链模式的概念、应用场景,并通过 Python 代码示例展示其实现方式。

2494

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Chain of Responsibility Pattern

Chain of Responsibility Pattern

小胖的专栏 357

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

责任链模式 Chain of Responsibility Pattern

一、模式介绍 1.1、定义 将请求的发送和接收解耦,让多个接收对象都有机会处理这个请求。将这些接收对象串成一条链,沿着这条链传递这个请求,直到链上的某个对象能够处理它为止。责任链模式也叫职责模式。 在责任链模式中,客户只需要将请求发送到责任链上即可,不需要关心请求的处理细节和请求的传递过程,请求会自动进行传递。所以责任链将请求的发送者和请求的矗立着解耦了。 1.2、优点 降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构,发送者和接收者也无须拥有对方的明确信息 增强了

木易 192

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

责任链模式(Chain of Responsibility Pattern)

顾名思义,责任链模式(Chain of Responsibility Pattern)为请求创建了一个接收者对象的链。这种模式给予请求的类型,对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。 在这种模式中,通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求,那么它会把相同的请求传给下一个接收者,依此类推。 应用实例: 红楼梦中的"击鼓传花"。 JS 中的事件冒...

qq_21344887的博客 449

Spring框架之责任链模式 (Chain of Responsibility Pattern)

责任链模式(Chain of Responsibility Pattern)是一种行为型设计模式,旨在将请求的发送者和处理者解耦。它通过创建一条 处理请求的责任链,使得多个对象都有机会处理请求,从而避免了请求的发送者和处理者之间的紧耦合。责任链模式的核心思想是将请求沿着链传递,直到有一个对象处理它为止。

欢迎来到我的博客!这里是一个专注于计算机技术的分享平台,涵盖编程开发、算法研究、系统架构、软件工程等多个领域。无论你是初学者还是资深开发者,都能在这里找到有价值的内容。 1613

责任链模式 (Chain of Responsibility Pattern)

行为型设计模式

qq_35861084的博客 905

Mybatis框架之责任链模式 (Chain of Responsibility Pattern)

在 MyBatis 框架中,责任链模式 (Chain of Responsibility Pattern) 被广泛应用于多个功能模块中,例如 插件拦截器、SQL 执行流程中的拦截器链、动态 SQL 的解析与处理等。这种设计模式为 MyBatis 提供了高度的扩展性和灵活性,使其能够轻松应对各种自定义功能需求。

欢迎来到我的博客!这里是一个专注于计算机技术的分享平台,涵盖编程开发、算法研究、系统架构、软件工程等多个领域。无论你是初学者还是资深开发者,都能在这里找到有价值的内容。 1322

责任链模式(Chain of Responsibility Pattern)简介

定义 责任链模式(Chain of Responsibility Pattern)是将链中每一个节点看作是一个对象,每个节点处理的请求均不同,且内部自动维护一个下一节点对象。当一个请求从链式的首端发出时,会沿着链的路径依次传递给每一个节点对象,直至有对象处理这个请求为止。属于行为型模式。 应用场景 责任链模式主要是解耦了请求与处理,客户只需将请求发送到链上即可,无需关心请求的具体内容和处理细节,请求会自动进行传递直至有节点对象进行处理。适用于以下应用场景: 1、多个对象可以处理同一请求,但具体由哪个对象处理

weixin_43183107的博客 598

20.责任链模式(Chain of Responsibility Pattern)

责任链模式(Chain of Responsibility Pattern) 是一种行为型设计模式,它使得多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将多个处理对象连成一条链,并沿着这条链传递请求,直到有一个对象处理它为止。每个对象在处理请求时,可以决定将请求传递给链中的下一个对象。// 处理者接口protected:// 下一个处理者public:// 设置下一个处理者// 处理请求。

Tiantangbujimo7的博客 1204

Java: Chain of Responsibility Pattern

文章摘要:本文展示了一个基于责任链模式的珠宝业务处理系统Java实现。系统通过12个处理器(如原料采购、设计绘图、生产加工等)构建完整业务流程链,每个处理器继承BaseBusinessHandler基类并实现核心业务逻辑。采用异步处理机制(CompletableFuture),支持流程中断和日志记录。包含配置管理(AppSettings)、后台服务(日志清理)和测试用例,演示了正常流程与原料缺失的异常流程处理。系统模拟珠宝从采购到销售的全生命周期管理,体现了责任链模式在复杂业务流程中的灵活应用。

Geovin Du Dream Park 454
上一篇: 组合模式【Composite Pattern】
下一篇: 访问者模式【Visitor Pattern】
涛濤
博客等级 码龄12年 136粉丝 92原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值