设计模式之责任链模式

最新推荐文章于 2024-04-10 15:20:35 发布
最新推荐文章于 2024-04-10 15:20:35 发布
阅读量794 收藏
点赞数
分类专栏： java 文章标签： Java 类
刚学习了责任链模式，感觉还是蛮不错的，随手记录了下学习的内容。

责任链模式：责任链模式用于弱化请求发生者和请求处理者之间的关系。当多个对象都可以对请求进行处理，但不同的对象能处理的请求类型不同时，可以通过指向另一个对象的引用把这些对象连成一条责任链。当 Client 发出一个请求时，并不知道具体由哪个对象进行处理，它看到的只是一条责任链，将请求直接交给责任链，请求会在责任链中传递，直到找到一个能够进行处理的对象或者遍历结束找不到一个能够处理的对象为止。Java 语言中的异常处理机制就是责任链模式的一个典型应用例子。

下面模拟的是一个员工处理问题层次的责任链模式，不同级别的员工能处理不同级别的请求。

首先设计一个请求类：
Java代码 复制代码  收藏代码
  1. package com.design.test.mode.responsibilityChain;   
  2.   
  3. /**  
  4.  *  请求操作  
  5.  *  请求分级别，不同的级别需要不同层次的去处理一个请求  
  6.  * @author Share  
  7.  *  
  8.  */  
  9. public class Request {   
  10.     public static final int TYPE_1 = 1;   
  11.     public static final int TYPE_2 = 2;   
  12.     public static final int TYPE_3 = 3;   
  13.     public static final int TYPE_4 = 4;   
  14.        
  15.     private int type;   
  16.     private String msg;   
  17.        
  18.     public Request(int type,String msg){   
  19.         this.type=type;   
  20.         this.msg=msg;   
  21.     }   
  22.        
  23.     public int getType() {   
  24.         return type;   
  25.     }   
  26.   
  27.     public String getMsg() {   
  28.         return msg;   
  29.     }   
  30. }  
package com.design.test.mode.responsibilityChain;

/**
 *  请求操作
 *  请求分级别，不同的级别需要不同层次的去处理一个请求
 * @author Share
 *
 */
public class Request {
	public static final int TYPE_1 = 1;
	public static final int TYPE_2 = 2;
	public static final int TYPE_3 = 3;
	public static final int TYPE_4 = 4;
	
	private int type;
	private String msg;
	
	public Request(int type,String msg){
		this.type=type;
		this.msg=msg;
	}
	
	public int getType() {
		return type;
	}

	public String getMsg() {
		return msg;
	}
}


设计员工的抽象类：
Java代码 复制代码  收藏代码
  1. package com.design.test.mode.responsibilityChain;   
  2.   
  3. /**  
  4.  *  定义一个员工抽象类  
  5.  *  一个员工有自己的上层，不同上层有处理问题的级别  
  6.  *  如果最上层都处理不了这问题，则无人能处理这问题。  
  7.  *  具体的员工类必须重写processRequest方法，才能见效  
  8.  * @author Share  
  9.  *  
  10.  */  
  11. public abstract class Employee {   
  12.     protected Employee boss;   
  13.     protected String name;   
  14.     protected int requestLevel;   
  15.        
  16.     public Employee(Employee boss,String name){   
  17.         this.boss = boss;   
  18.         this.name = name;   
  19.     }   
  20.        
  21.     public void processRequest(Request request){   
  22.         if(boss!=null){   
  23.             boss.processRequest(request);   
  24.         }else{   
  25.             System.out.println("Nobody can handle the request."+request.getMsg());   
  26.         }   
  27.     }   
  28.        
  29.        
  30. }  
package com.design.test.mode.responsibilityChain;

/**
 *  定义一个员工抽象类
 *  一个员工有自己的上层，不同上层有处理问题的级别
 *  如果最上层都处理不了这问题，则无人能处理这问题。
 *  具体的员工类必须重写processRequest方法，才能见效
 * @author Share
 *
 */
public abstract class Employee {
	protected Employee boss;
	protected String name;
	protected int requestLevel;
	
	public Employee(Employee boss,String name){
		this.boss = boss;
		this.name = name;
	}
	
	public void processRequest(Request request){
		if(boss!=null){
			boss.processRequest(request);
		}else{
			System.out.println("Nobody can handle the request."+request.getMsg());
		}
	}
	
	
}


管理员员工类：
Java代码 复制代码  收藏代码
  1. package com.design.test.mode.responsibilityChain;   
  2.   
  3. ublic class Manager extends Employee {   
  4.   
  5. public Manager(Employee boss, String name) {   
  6.     super(boss, name);   
  7.     requestLevel = Request.TYPE_1;   
  8. }   
  9.   
  10. @Override  
  11. public void processRequest(Request request) {   
  12.     if(request.getType() > requestLevel){   
  13.         System.out.println(this.name+" say: I can't handle the request. My boss will handle it.");   
  14.         super.processRequest(request);   
  15.     }else{   
  16.         System.out.println(this.name+" say: I can handle the request."+request.getMsg());   
  17.     }   
  18. }   
  19.   
 package com.design.test.mode.responsibilityChain;

public class Manager extends Employee {

	public Manager(Employee boss, String name) {
		super(boss, name);
		requestLevel = Request.TYPE_1;
	}

	@Override
	public void processRequest(Request request) {
		if(request.getType() > requestLevel){
			System.out.println(this.name+" say: I can't handle the request. My boss will handle it.");
			super.processRequest(request);
		}else{
			System.out.println(this.name+" say: I can handle the request."+request.getMsg());
		}
	}
	
}



主管类：
Java代码 复制代码  收藏代码
  1. package com.design.test.mode.responsibilityChain;   
  2.   
  3. public class Director extends Employee {   
  4.   
  5.     public Director(Employee boss, String name) {   
  6.         super(boss, name);   
  7.         requestLevel = Request.TYPE_2;   
  8.     }   
  9.   
  10.     @Override  
  11.     public void processRequest(Request request) {   
  12.         if(request.getType() > requestLevel){   
  13.             System.out.println(this.name+" say: I can't handle the request. My boss will handle it.");   
  14.             super.processRequest(request);   
  15.         }else{   
  16.             System.out.println(this.name+" say: I can handle the request."+request.getMsg());   
  17.         }   
  18.     }   
  19.        
  20. }  
package com.design.test.mode.responsibilityChain;

public class Director extends Employee {

	public Director(Employee boss, String name) {
		super(boss, name);
		requestLevel = Request.TYPE_2;
	}

	@Override
	public void processRequest(Request request) {
		if(request.getType() > requestLevel){
			System.out.println(this.name+" say: I can't handle the request. My boss will handle it.");
			super.processRequest(request);
		}else{
			System.out.println(this.name+" say: I can handle the request."+request.getMsg());
		}
	}
	
}


CEO类：
Java代码 复制代码  收藏代码
  1. package com.design.test.mode.responsibilityChain;   
  2.   
  3. public class CEO extends Employee {   
  4.   
  5.     public CEO(Employee boss, String name) {   
  6.         super(boss, name);   
  7.         requestLevel = Request.TYPE_3;   
  8.     }   
  9.   
  10.     @Override  
  11.     public void processRequest(Request request) {   
  12.         if(request.getType() > requestLevel){   
  13.             System.out.println(this.name+" say: I can't handle the request. My boss will handle it.");   
  14.             super.processRequest(request);   
  15.         }else{   
  16.             System.out.println(this.name+" say: I can handle the request."+request.getMsg());   
  17.         }   
  18.     }   
  19.        
  20. }  
package com.design.test.mode.responsibilityChain;

public class CEO extends Employee {

	public CEO(Employee boss, String name) {
		super(boss, name);
		requestLevel = Request.TYPE_3;
	}

	@Override
	public void processRequest(Request request) {
		if(request.getType() > requestLevel){
			System.out.println(this.name+" say: I can't handle the request. My boss will handle it.");
			super.processRequest(request);
		}else{
			System.out.println(this.name+" say: I can handle the request."+request.getMsg());
		}
	}
	
}


测试类：
Java代码 复制代码  收藏代码
  1. package com.design.test.mode.responsibilityChain;   
  2.   
  3. public class Main {   
  4.   
  5.     public static void main(String[] args) {   
  6.         CEO ceo = new CEO(null, "Jack Ceo");   
  7.         Director dir = new Director(ceo, "Sello Director");   
  8.         Manager manager = new Manager(dir, "Fewen Mananger");   
  9.            
  10.         Request req1 = new Request(4, "我要加薪");   
  11.         Request req2 = new Request(2, "我要请假");   
  12.         Request req3 = new Request(1, "我要加班");   
  13.            
  14.         System.out.println("处理请求1");   
  15.         manager.processRequest(req1);   
  16.         System.out.println("处理请求2");   
  17.         manager.processRequest(req2);   
  18.         System.out.println("处理请求3");   
  19.         manager.processRequest(req3);   
  20.     }   
  21. }  
package com.design.test.mode.responsibilityChain;

public class Main {

	public static void main(String[] args) {
		CEO ceo = new CEO(null, "Jack Ceo");
		Director dir = new Director(ceo, "Sello Director");
		Manager manager = new Manager(dir, "Fewen Mananger");
		
		Request req1 = new Request(4, "我要加薪");
		Request req2 = new Request(2, "我要请假");
		Request req3 = new Request(1, "我要加班");
		
		System.out.println("处理请求1");
		manager.processRequest(req1);
		System.out.println("处理请求2");
		manager.processRequest(req2);
		System.out.println("处理请求3");
		manager.processRequest(req3);
	}
}



打印结果：

处理请求1
Fewen Mananger say: I can't handle the request. My boss will handle it.
Sello Director say: I can't handle the request. My boss will handle it.
Jack Ceo say: I can't handle the request. My boss will handle it.
Nobody can handle the request.我要加薪
处理请求2
Fewen Mananger say: I can't handle the request. My boss will handle it.
Sello Director say: I can handle the request.我要请假
处理请求3
Fewen Mananger say: I can handle the request.我要加班

 

责任链可以使得系统在不影响客户端的前提下动态的安排责任链和分配责任。责任链模式中包含的角色有抽象处理者，具体处理者以及请求的发送者。责任链可以是一条直线，一个环链甚至一个树结构。它使得每一个具体的消息处理者都有可能处理消息。

Java代码 复制代码  收藏代码
  1. /**  
  2.  * 抽象的请求处理者  
  3.  * @author wly  
  4.  *  
  5.  */  
  6. public abstract class Filter {    
  7.        
  8.     abstract String doFilter(String s);   
  9. }  
/**
 * 抽象的请求处理者
 * @author wly
 *
 */
public abstract class Filter { 
	
	abstract String doFilter(String s);
}

 

Java代码 复制代码  收藏代码
  1. /**  
  2.  * 具体处理者A  
  3.  * @author wly  
  4.  *  
  5.  */  
  6. public class FilterA extends Filter {   
  7.   
  8.     @Override  
  9.     String doFilter(String s) {   
  10.         s = s.replace('<', '(');   
  11.         s = s.replace('>', ')');   
  12.         return s;   
  13.     }   
  14. }  
/**
 * 具体处理者A
 * @author wly
 *
 */
public class FilterA extends Filter {

	@Override
	String doFilter(String s) {
		s = s.replace('<', '(');
		s = s.replace('>', ')');
		return s;
	}
}

 

Java代码 复制代码  收藏代码
  1. /**  
  2.  * 具体处理者B  
  3.  * @author wly  
  4.  *  
  5.  */  
  6. public class FilterB extends Filter {   
  7.   
  8.     @Override  
  9.     String doFilter(String s) {   
  10.         s = s.replace('#', '$');   
  11.         return s;   
  12.     }   
  13. }  
/**
 * 具体处理者B
 * @author wly
 *
 */
public class FilterB extends Filter {

	@Override
	String doFilter(String s) {
		s = s.replace('#', '$');
		return s;
	}
}

 

Java代码 复制代码  收藏代码
  1. /**  
  2.  * 具体处理者C  
  3.  * @author wly  
  4.  *  
  5.  */  
  6. public class FilterC extends Filter {   
  7.   
  8.     @Override  
  9.     String doFilter(String s) {   
  10.         s = s.replace('W','C');   
  11.         return s;   
  12.     }   
  13. }  
/**
 * 具体处理者C
 * @author wly
 *
 */
public class FilterC extends Filter {

	@Override
	String doFilter(String s) {
		s = s.replace('W','C');
		return s;
	}
}

 

Java代码 复制代码  收藏代码
  1. /**  
  2.  * 责任链中的“链"  
  3.  * @author wly  
  4.  *  
  5.  */  
  6. public class FilterChain extends ArrayList<Filter>{      
  7.        
  8.     public void addFilter(Filter filter) {   
  9.         this.add(filter);   
  10.     }   
  11.        
  12.     public String doFilter(String s) {   
  13.         for(Filter filter:this) {   
  14.             s = filter.doFilter(s);   
  15.         }   
  16.         return s;   
  17.     }   
  18. }  
/**
 * 责任链中的“链"
 * @author wly
 *
 */
public class FilterChain extends ArrayList<Filter>{	
	
	public void addFilter(Filter filter) {
		this.add(filter);
	}
	
	public String doFilter(String s) {
		for(Filter filter:this) {
			s = filter.doFilter(s);
		}
		return s;
	}
}

 

Java代码 复制代码  收藏代码
  1. /**  
  2.  * 客户端类  
  3.  * @author wly  
  4.  *  
  5.  */  
  6. public class Test {   
  7.     public static void main(String[] args){   
  8.            
  9.         FilterChain filterChain = new FilterChain();   
  10.         filterChain.addFilter(new FilterA());   
  11.         filterChain.addFilter(new FilterB());   
  12.         filterChain.addFilter(new FilterC());   
  13.            
  14.         System.out.println(filterChain.doFilter("<今天>,W，#"));   
  15.     }   
  16. }  
/**
 * 客户端类
 * @author wly
 *
 */
public class Test {
	public static void main(String[] args){
		
		FilterChain filterChain = new FilterChain();
		filterChain.addFilter(new FilterA());
		filterChain.addFilter(new FilterB());
		filterChain.addFilter(new FilterC());
		
		System.out.println(filterChain.doFilter("<今天>,W，#"));
	}
}

   输出：(今天),C，$

   其实，上面的代码并不是真正的责任链，因为具体的处理者应该可以选择将请求继续往下传递还是自己直接处理掉。不过，我们可以拿Android中的Touch事件的传递来做例子。当一个view捕获到一个onTouch事件后，就可以通过onTouch的返回智决定是否继续把事件往它的父级view传递。

 

haoxingfengcrazy
关注
专栏目录
JAVA设计模式之责任链模式详解
09-03
责任链模式（Chain of Responsibility）是一种行为设计模式，它的核心思想是将一系列处理请求的对象串联成一条链，每个对象称为处理者（Handler），并包含处理请求的逻辑以及将请求传递给下家的能力。请求沿着链传递...
Python设计模式之职责链模式原理与用法实例分析
01-20
本文实例讲述了Python设计模式之职责链模式原理与用法。分享给大家供大家参考，具体如下： 职责链模式(Chain Of Responsibility):使多个对象都有机会处理请求，从而避免发送者和接收者的耦合关系。将对象连成链并...
行为型模式——责任链模式
ai-exception的博客
03-18 291
概述 顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。 在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推(感觉有点像链表？)。 介绍 意图 ...
同事写了一个责任链模式，bug无数...
石杉的架构笔记
06-18 252
文章来源：https://c1n.cn/dilnW‍‍‍目录背景什么是责任链使用场景结语背景最近，我让团队内一位成员写了一个导入功能。他使用了责任链模式，代码堆的非常多，bug 也多，没有达到我预期的效果。实际上，针对导入功能，我认为模版方法更合适！为此，隔壁团队也拿出我们的案例，进行了集体 code review。学好设计模式，且不要为了练习，强行使用！让原本 100 ...
【大话设计模式】模式十九：责任链模式在JAVA异常处理机制中的体现
m0_46013789的博客
02-07 1823
【引入】 当一个问题发生的时候，当前对象看一下自己是否能够处理，不能的话将问题抛给自己的上级去处理，但是要注意这里的上级不一定指的是继承关系的父类，这点和异常的处理是不一样的。所以可以这样说，当问题不能解决的时候，将问题交给另一个对象去处理，就这样一直传递下去直至当前对象找不到下线了，处理结束。
自定义异常 责任链模式
u014300969的专栏
04-12 763
异常链 http://www.cnblogs.com/chenssy/p/3453039.html
职责链模式
zsfhrd的博客
05-26 146
职责链模式 定义 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。 解决 避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。在处理消息的时候以过滤很多道。 职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。 优点 当客户提交一个请求时
C++设计模式之职责链模式
09-04
职责链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许将请求沿着处理者对象的链式结构进行传递，直到某个对象能够处理该请求。在C++中，职责链模式通常用于解耦发送者和接收者，使得系统更加...
php设计模式之职责链模式定义与用法经典示例
01-02
* @desc php设计模式之职责链模式（责任链模式） 定义：顾名思义，责任链模式为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。 在...
Java经典设计模式之责任链模式原理与用法详解
08-29
Java经典设计模式之责任链模式原理与用法详解 责任链模式是Java经典设计模式之一，它允许将请求...责任链模式是一个非常重要的Java经典设计模式，它可以使得系统更加灵活和可扩展，提高了系统的可维护性和可扩展性。
Java 责任链模式详解
兴趣是最好的老师，勤能补拙
05-11 2403
责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它用于将请求的发送者和接收者解耦，使得多个对象都有机会处理这个请求。在责任链模式中，有一个请求处理链条，每个处理请求的对象都是一个节点，当请求进入这个链条时，链条上的节点逐一判断是否能够处理该请求，如果可以，则处理；否则，将请求传递给下一个节点，直到请求被处理为止。
【Java设计模式】责任链模式
『程序员·小李』的博客
08-06 202
类似于异常处理机制，前一个异常处理器如果能够处理异常的话将直接处理，否则提交给下一个处理器。或者类似于ASP.NET的处理管道机制，每个处理层面都维护着下个层面的引用，当前能够处理会直接处理，否则移交下一层。有点Fail fast的赶脚。...
浅析Java责任链模式实现
qq_42077317的博客
09-16 443
3.异常处理：在Java中，可以使用责任链模式来处理异常。首先，程序先尝试使用自定义的异常处理器来处理异常，如果该处理器无法处理异常，则将其转发给下一个处理器进行处理。定义：责任链模式是一种行为设计模式， 允许你将请求沿着处理者链进行发送。收到请求后， 每个处理者均可对请求进行处理， 或将其传递给链上的下个处理者。2.过滤器：在Servlet中，过滤器就是使用责任链模式实现的。每个过滤器都可以决定是否处理请求，或者将其转发给下一个过滤器进行处理。1.多条件流程判断：权限相关控制。3.最后我们可以测试一下。
责任链模式
苦行僧
07-23 104
1、责任链模式 1.1、先抛出问题 现在我们有一个业务要求如下： - 判断此请求是否合法，不合法则拦截 - 判断此请求是否为接受请求，不是则丢弃 - 判断此请求用户是否登录，未登录则先登录 - 判断此请求用户是否授权此请求，未授权则异常返回 - 扒拉扒拉扒拉还有一大堆................... 此时我们过滤拦截代码会很繁杂，而且对于判断顺序也是繁杂，如果出现不同请求不同判断逻辑，那又得加if，然后当后面出现新需求，那又得扒拉扒拉的堆积代码。这种情况是不好的，我们只要抽出时间细想这些代码，就应该
java 链式异常_Java™ 教程（如何抛出异常）
weixin_39953102的博客
02-25 202
如何抛出异常在捕获异常之前，某些代码必须抛出一个，任何代码都可能抛出异常：你的代码，来自其他人编写的包中的代码，例如Java平台附带的包或Java运行时环境，无论抛出什么异常，它总是使用throw语句抛出。你可能已经注意到，Java平台提供了许多异常类，所有类都是Throwable类的后代，并且所有类都允许程序区分在程序执行期间可能发生的各种类型的异常。你还可以创建自己的异常类来表示你编写的类中可...
【设计模式】职责链模式：如果第三方短信平台挂了怎么办？
最新发布
shenliba的博客
04-10 269
面试题文档来啦，内容很多，485页！由于笔记的内容太多，没办法全部展示出来，下面只截取部分内容展示。面试题文档来啦，内容很多，485页！由于笔记的内容太多，没办法全部展示出来，下面只截取部分内容展示。
设计模式（四）—— 责任链模式
xingyu19911016的博客
04-28 1086
1 简介 责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链，请求在这条链上传递，直到链上的某个对象处理此请求，或者每个对象都可以处理请求，并传给“下家”，直到最终链上每个对象都处理完。 responsibility [rɪˌspɑːnsəˈbɪləti] 责任，负责 pattern [ˈpætərn] 模式，方式； 这种模式可以避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求。 在Java中，异常机制就是一种责任链模式。一个try语句可以
Java模式之责任链模式
热门推荐
漫长学习路
05-14 1万+
从请假开始谈起 话说上次五一请假回去玩了一个多星期，期间回了一次老家，去了一趟武汉，接着又跑到了景德镇，和庐山；玩的好不自在；但是想起来上次请假的经历另我记忆犹新啊，算起来也是一波三折吧； 记得那时是4月20号，因为家里出了点事情，急需回家，然后也快到五一了，就想出去玩几天，因为之前加班积攒了不少的调休，所以想把调休给用了。记得当时我是先跟我们的部门经理说，我们部门经理跟我关系比较好，我就
理解与应用：设计模式之职责链模式解析
"设计模式之职责链模式" 职责链模式是一种行为设计模式，它允许将请求沿着处理者对象的链式结构进行传递，直到某个对象处理这个请求。这种模式的关键在于，请求的发送者并不直接知道哪个对象会处理请求，而是将请求...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值