原文:详解Java设计模式之职责链模式_java_脚本之家
责任链模式是一种行为设计模式,使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系,文中通过代码示例给大家介绍的非常详细,需要的朋友可以参考下
−
目录
- 职责链模式
- 1、职责链模式介绍
- 2、具体例子说明
- 2.1 不使用职责链模式 - 加薪 / 请假
- 2.2 职责链模式 - 加薪 / 请假
- 3、职责链模式总结
职责链模式
1、职责链模式介绍
责任链模式(Chain of Responsibility Pattern)是一种行为设计模式,使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。
在责任链模式中,请求通过一条链传递,每个对象都有机会处理请求。当一个对象无法处理请求时,它会将请求传递给链中的下一个对象,直到找到能够处理请求的对象为止。这种方式可以动态地组织和管理对象,使得请求发送者和接收者之间解耦,提高系统的灵活性和可扩展性。
1.1 职责链模式基本实现
职责链模式结构图:
责任链模式包含以下几个角色:
- 抽象处理者(Handler):定义了一个处理请求的接口,通常包含一个指向下一个处理者的引用,用于构建责任链。
- 具体处理者(ConcreteHandler):实现抽象处理者接口,具体处理请求的逻辑。如果可以处理请求,则处理请求;否则,将请求传递给下一个处理者。
Handler类,定义一个处理请示的接口:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | /** * @author Shier * CreateTime 2023/5/20 16:04 * 处理请求的接口 */ public abstract class Handler { protected Handler successor; /** * 设置继承者 * @param successor */ public void setSuccessor(Handler successor) { this .successor = successor; } public abstract void handleRequest( int request); } |
ConcreteHandler类,具体处理者类,处理它所负责的请求,可访问它的 后继者,如果可处理该请求,就处理之,否则就将该请求转发给它的后继 者。
ConcreteHandler1,当请求数为0~10则有权处理,否则转到下一位:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | /** * @author Shier * CreateTime 2023/5/20 16:06 */ public class ConcreteHandler1 extends Handler { @Override public void handleRequest( int request) { if (request >= 0 && request < 10 ) { // 当前处理者权限 0 ~ 9 System.out.println( this .getClass().getSimpleName() + "处理了请求" + request); } else if (successor != null ) { // 转移给下一个处理者 successor.handleRequest(request); } } } |
ConcreteHandler2,当请求数为10~20则有权处理,否则转到下一位。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | /** * @author Shier * CreateTime 2023/5/20 16:06 */ public class ConcreteHandler2 extends Handler { @Override public void handleRequest( int request) { if (request >= 10 && request < 20 ) { // 当前处理者权限 10 ~ 19 System.out.println( this .getClass().getSimpleName() + "处理了请求" + request); } else if (successor != null ) { // 转移给下一个处理者 successor.handleRequest(request); } } } |
ConcreteHandler3,当请求数为20~99则有权处理,否则转到下一位
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | /** * @author Shier * CreateTime 2023/5/20 16:06 */ public class ConcreteHandler3 extends Handler { @Override public void handleRequest( int request) { if (request >= 20 && request < 100 ) { // 当前处理者权限 20 ~ 99 System.out.println( this .getClass().getSimpleName() + "处理了请求" + request); } else if (successor != null ) { // 转移给下一个处理者 successor.handleRequest(request); } } } |
客户端代码,向链上的具体处理者对象提交请求。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | /** * @author Shier * CreateTime 2023/5/20 16:09 */ public class ChainClient { public static void main(String[] args) { ConcreteHandler1 handler1 = new ConcreteHandler1(); ConcreteHandler2 handler2 = new ConcreteHandler2(); ConcreteHandler3 handler3 = new ConcreteHandler3(); // 设置职责链上下关系 handler1.setSuccessor(handler2); handler2.setSuccessor(handler3); // 请求 int [] request = { 15 , 67 , 8 , 9 , 46 , 1 , 5 , 23 , 41 }; // 循环给最小矗立着提交请求,不同的数额,得不同的权限处理者处理 for ( int i : request) { handler1.handleRequest(i); } } } |
2、具体例子说明
在公司请假或者升职加薪,需要通过经理、总监、总经理的批准,不同身份有不同的权限。当然可以直接直接找总经理给你升职加薪😎
2.1 不使用职责链模式 - 加薪 / 请假
升值加薪:经理是没有权限的,要上报给总监,总监的回复也是没有权限管,只能再上报到总经理才有处理的权限
请假:经理只能处理请假两天的申请,再多就不可以。必须要上报给上司才有权限去处理这个请求。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | // 申请类 public class Request { // 申请类别 private String requestType; public String getRequestType(){ return this .requestType; } public void setRequestType(String value){ this .requestType = value; } //申请内容 private String requestContent; public String getRequestContent(){ return this .requestContent; } public void setRequestContent(String value){ this .requestContent = value; } // 数量 private int number; public int getNumber(){ return this .number; } public void setNumber( int value){ this .number = value; } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | //管理者 public class Manager{ protected String name; public Manager(String name){ this .name = name; } public void getResult(String managerLevel,Request request){ if (managerLevel == "经理" ){ if (request.getRequestType()== "请假" && request.getNumber()<= 2 ) System.out.println( this .name+ ":" +request.getRequestContent()+ " 数量:" +request.getNumber()+ "天,被批准" ); else System.out.println( this .name+ ":" +request.getRequestContent()+ " 数量:" +request.getNumber()+ "天,我无权处理" ); } else if (managerLevel == "总监" ){ if (request.getRequestType()== "请假" && request.getNumber()<= 5 ) System.out.println( this .name+ ":" +request.getRequestContent()+ " 数量:" +request.getNumber()+ "天,被批准" ); else System.out.println( this .name+ ":" +request.getRequestContent()+ " 数量:" +request.getNumber()+ "天,我无权处理" ); } else if (managerLevel == "总经理" ){ if (request.getRequestType()== "请假" ) System.out.println( this .name+ ":" +request.getRequestContent()+ " 数量:" +request.getNumber()+ "天,被批准" ); else if (request.getRequestType()== "加薪" && request.getNumber()<= 5000 ) System.out.println( this .name+ ":" +request.getRequestContent()+ " 数量:" +request.getNumber()+ "元,被批准" ); else if (request.getRequestType()== "加薪" && request.getNumber()> 5000 ) System.out.println( this .name+ ":" +request.getRequestContent()+ " 数量:" +request.getNumber()+ "元,再说吧" ); } } } |
客户端:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | public class Test { public static void main(String[] args) { Manager manager = new Manager( "金利" ); Manager director = new Manager( "宗剑" ); Manager generalManager = new Manager( "钟精励" ); Request request = new Request(); request.setRequestType( "加薪" ); request.setRequestContent( "Shier请求加薪" ); request.setNumber( 10000 ); // 不同身份的人有不同的权限,进行处理结果 manager.getResult( "经理" , request); director.getResult( "总监" , request); generalManager.getResult( "总经理" , request); Request request2 = new Request(); request2.setRequestType( "请假" ); request2.setRequestContent( "Shier请假" ); request2.setNumber( 3 ); // 权限级别 manager.getResult( "经理" , request2); director.getResult( "总监" , request2); generalManager.getResult( "总经理" , request2); } } |
通过上面的程序,会发现一个问题管理者类,里面的方法比较长,太多的分支判断。类的责任太多,就违背了单一职责原则,同时增加新的项目时,要去修改这个方法,就违背了开发 - 封闭原则。下面就要用到职责链模式要简化这样开发业务场景 。
2.2 职责链模式 - 加薪 / 请假
将上面的程序进行重构,得到的代码结构图如下:
Request请求类:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | /** * @author Shier * 申请类 */ public class Request { // 申请类别 private String requestType; public String getRequestType() { return this .requestType; } public void setRequestType(String value) { this .requestType = value; } //申请内容 private String requestContent; public String getRequestContent() { return this .requestContent; } public void setRequestContent(String value) { this .requestContent = value; } // 数量 private int number; public int getNumber() { return this .number; } public void setNumber( int value) { this .number = value; } } |
抽象管理者:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | /** * @author Shier * CreateTime 2023/5/20 16:33 * 抽象管理这类 */ public abstract class Manager { protected String name; public Manager(String name) { this .name = name; } /** * 设置管理者上级 */ protected Manager superior; public void setSuperior(Manager superior) { this .superior = superior; } /** * 请求申请 * * @param request */ public abstract void requestApplications(Request request); } |
经理类就可以去继承这个'管理者'类,只需重写 '申请请求' 的方法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | /** * @author Shier * CreateTime 2023/5/20 16:34 * 普通经理类 */ public class CommonManager extends Manager { public CommonManager(String name) { super (name); } @Override public void requestApplications(Request request) { if (request.getRequestType() == "请假" && request.getNumber() <= 2 ) { System.out.println( this .name + ":" + request.getRequestContent() + " 数量:" + request.getNumber() + "天,被批准" ); } else if ( this .superior != null ) { this .superior.requestApplications(request); } } } |
总监同样继承抽象管理类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | /** * @author Shier * CreateTime 2023/5/20 16:36 * 总监 */ public class Director extends Manager { public Director(String name) { super (name); } @Override public void requestApplications(Request request) { if (request.getRequestType() == "请假" && request.getNumber() <= 5 ) { System.out.println( this .name + ":" + request.getRequestContent() + " 数量:" + request.getNumber() + "天,被批准" ); } else if ( this .superior != null ) { this .superior.requestApplications(request); } } } |
总经理同样继承管理者类,总经理的权限就是全部都需要处理。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | /** * @author Shier * CreateTime 2023/5/20 16:36 * 总经理 */ public class GeneralManager extends Manager { public GeneralManager(String name) { super (name); } @Override public void requestApplications(Request request) { if (request.getRequestType() == "请假" ) { System.out.println( this .name + ":" + request.getRequestContent() + " 数量:" + request.getNumber() + "天,被批准" ); } else if (request.getRequestType() == "加薪" && request.getNumber() <= 5000 ) { System.out.println( this .name + ":" + request.getRequestContent() + " 数量:" + request.getNumber() + "元,被批准" ); } else if (request.getRequestType() == "加薪" && request.getNumber() > 5000 ) { System.out.println( this .name + ":" + request.getRequestContent() + " 数量:" + request.getNumber() + "元,再说吧" ); } } } |
测试类:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | /** * @author Shier */ public class ChainClient { public static void main(String[] args) { CommonManager manager = new CommonManager( "大明经理" ); Director director = new Director( "大大明总监" ); GeneralManager generalManager = new GeneralManager( "大大大明总经理" ); // 设置管理者之间上下级关系 经理 => 总监 => 总经理 manager.setSuperior(director); director.setSuperior(generalManager); // 加薪 5000 Request request = new Request(); request.setRequestType( "加薪" ); request.setRequestContent( "Shier请求加薪" ); request.setNumber( 5000 ); // 从自己最近的上司开始请求也就是经理 manager.requestApplications(request); // 加薪10000 Request request1 = new Request(); request1.setRequestType( "加薪" ); request1.setRequestContent( "Shier请求加薪" ); request1.setNumber( 10000 ); manager.requestApplications(request1); // 请假一天 Request request2 = new Request(); request2.setRequestType( "请假" ); request2.setRequestContent( "Shier请假" ); request2.setNumber( 1 ); manager.requestApplications(request2); // 请假四天 Request request3 = new Request(); request3.setRequestType( "请假" ); request3.setRequestContent( "Shier请假" ); request3.setNumber( 4 ); manager.requestApplications(request3); } } |
最后得到的结果:
由于我们把原来的一个 '管理者' 类改成了一个抽象类和三个具体类, 此时类之间的灵活性就大大增加了,如果我们需要扩展新的管理者类别,只需要增加子类就可以。比如这个例子增加一个 '集团总裁' 类,完全是没有问题的,只需要修改 '总经理类' 即可,并不影响其他类代码。
这样使用职责链模式可以更加清晰这些代码之间的关系,不像最上面的一个类里面多个判断语句,看起来都很难维护。好了,再总结一下职责链模式
3、职责链模式总结
职责链模式的好处
- 当客户提交一个请求时,请求是沿链传递直至有一个 ConcreteHandler 对象负责处理它。
- 降低耦合:接收者和发送者都没有对方的明确信息,且链中的对 象自己也并不知道链的结构。结果是职责链可简化对象的相互连接,它们仅 需保持一个指向其后继者的引用,而不需保持它所有的候选接受者的引用。降低了代码之间耦合度。
- 灵活性:随时地增加或修改处理一个请求的结构。增强了给对象指派职责的灵活性。
优点:
- 将请求发送者和接收者解耦,可以避免请求发送者与接收者之间的直接耦合,增强了代码的可维护性。
- 可以动态地新增或修改请求处理顺序,提高了程序的灵活性和可扩展性。
- 可以进行请求的拦截、分流等操作,方便进行统计和日志记录等处理。
- 可以根据需要对请求的处理进行单独的测试,便于代码测试和调试。
- 解耦发送者和接收者:职责链模式可以将发送者和接收者解耦,发送者不需要知道请求的具体处理者是谁,而处理者也不需要知道请求的发送者是谁,从而提高系统的灵活性。
- 动态组合和扩展性:职责链模式允许动态地向链中添加或删除处理者,以适应不同的业务需求,增强了系统的可扩展性。
- 可配置性:通过调整链中处理者的顺序,可以灵活地配置处理流程,满足不同的处理优先级或条件。
缺点:
- 请求的保证:没有明确的处理者处理请求的保证。请求可能到达链的末尾而没有被处理,这需要在设计时进行合理的考虑。
- 性能考虑:由于链中的请求需要依次传递给每个处理者,因此在处理大量请求时可能会影响性能。
- 可能导致系统变得复杂:当链过长或者处理者过多时,职责链模式可能会导致系统变得复杂,难以理解和维护。
使用场景:
- 处理复杂的请求处理流程,例如购物车结算、审批流程等复杂业务中。
- 需要动态指定请求的处理顺序或者动态添加新的请求处理者时。
- 处理日志记录、缓存等拦截器的场景。例如在Spring中,就应用了责任链模式来实现Interceptor拦截器。
- 多个对象可以处理同一请求,但具体的处理者在运行时可变或不确定的情况下,可以使用职责链模式。
- 需要动态组合处理流程或动态调整处理顺序的情况下,职责链模式可以提供灵活性和可配置性。
- 需要在不明确请求的发送者和接收者之间建立松耦合关系的情况下,职责链模式可以解耦对象之间的关系。
以上就是详解Java设计模式之职责链模式的详细内容,更多关于Java 职责链模式的资料请关注脚本之家其它相关文章!
您可能感兴趣的文章:
- 深入了解Java设计模式之职责链模式
- Java设计模式之职责链模式详解
- 深入理解Java设计模式之职责链模式
- Java职责链模式的深入了解
- Java设计模式中单一职责原则详解
- Java创建型设计模式之建造者模式详解