CoR 模式（另一种）

CoR(Chain of Responsibility)   职责链设计模式

我在 两种 CoR（一） 中讨论了传统的CoR实现：

但我感觉 让 每个处理器都持有后继处理器的引用，会增加处理器之间的耦合度.

 

下面是我的一些想法 和 具体实现：

（1）处理器 不持有 后继处理器的引用，引入一个新的角色 处理器容器（HandlerContainer ） ，由容器管理每个处理器，并且这个处理器容器 也是一个处理器（实现了Handler 接口），他的处理能力是容器里所有处理器的处理能力的和。

（2）一个处理器如果不能处理传递过来的请求，则抛出一个（CanNotHandleRequestException ）异常，

 如果管理这个处理器的容器接受到这个异常，则将请求传递给容器中的下一个处理器。如果容器中的所有处理器都不能处理这个请求，则由容器抛出一个（CanNotHandleRequestException ）异常。

 

实现：与传统CoR相比，处理器接口（Handler ）不变，请求接口（Request ）和实现类不变。

1，增加CanNotHandleRequestException 异常类，当处理器不能处理传递过来的请求时就抛出这个异常。

 

Java代码

1. public   class  CanNotHandleRequestException  extends  Exception{  
2.     private   static   final   long  serialVersionUID = 1L;  
3. }  

public class CanNotHandleRequestException extends Exception{
	private static final long serialVersionUID = 1L;
}

 

2，增加处理器容器类（HandlerContainer ），处理器容器类也实现了处理器接口，他的处理能力是容器里所有处理器的处理能力的和。

 

Java代码

1. public   class  HandlerContainer  implements  Handler{  
2.     private  List<Handler> handlers;  
3.     public  HandlerContainer(){  
4.         handlers = new  ArrayList<Handler>();  
5.     }   
6.     public   boolean  add(Handler handler){  
7.         return   this .handlers.add(handler);  
8.     }  
9.     public   boolean  remove(Handler handler){  
10.         return   this .handlers.remove(handler);  
11.     }  
12.     public   void  handleRequest(Request request)  throws  CanNotHandleRequestException{  
13.         int  length =  this .handlers.size();  
14.         for ( int  i =  0  ; i < length ; i++){  
15.             Handler handler = handlers.get(i);  
16.             try  {  
17.                 handler.handleRequest(request);  
18.                 break ;  
19.             } catch  (CanNotHandleRequestException e) {  
20.                 /*  
21.                  * 如果处理器容器里的所有处理器都不能处理该请求,  
22.                  * 则由容器抛出 CanNotHandleRequestException 异常。  
23.                  */   
24.                 if (i == length- 1 )  throw  e;  
25.             }  
26.         }  
27.     }  
28. }  

public class HandlerContainer implements Handler{
	private List<Handler> handlers;
	public HandlerContainer(){
		handlers = new ArrayList<Handler>();
	} 
	public boolean add(Handler handler){
		return this.handlers.add(handler);
	}
	public boolean remove(Handler handler){
		return this.handlers.remove(handler);
	}
	public void handleRequest(Request request) throws CanNotHandleRequestException{
		int length = this.handlers.size();
		for(int i = 0 ; i < length ; i++){
			Handler handler = handlers.get(i);
			try {
				handler.handleRequest(request);
				break;
			} catch (CanNotHandleRequestException e) {
				/*
				 * 如果处理器容器里的所有处理器都不能处理该请求,
				 * 则由容器抛出 CanNotHandleRequestException 异常。
				 */
				if(i == length-1) throw e;
			}
		}
	}
}

 

3，实现处理器接口的实现类  HelpHandler   ，PrintHandler   ，SaveHandler

     HelpHandler  处理 帮助请求（HelpRequest   ）

 

 

Java代码

1. public   class  HelpHandler  implements  Handler{  
2.     public   void  handleRequest(Request request)  throws  CanNotHandleRequestException {  
3.         if (request  instanceof  HelpRequest){  
4.             System.out.println("HelpHandler  handle " +request.getClass().getSimpleName());  
5.         }else   
6.             throw   new  CanNotHandleRequestException();  
7.     }  
8. }  

public class HelpHandler implements Handler{
	public void handleRequest(Request request) throws CanNotHandleRequestException {
		if(request instanceof HelpRequest){
			System.out.println("HelpHandler  handle "+request.getClass().getSimpleName());
		}else
			throw new CanNotHandleRequestException();
	}
}

 

  PrintHandler  处理 打印请求（PrintRequest   ）

 

Java代码

1. public   class  PrintHandler  implements  Handler{  
2.     public   void  handleRequest(Request request)  throws  CanNotHandleRequestException{  
3.         if (request  instanceof  PrintRequest){  
4.             System.out.println("PrintHandler handle " +request.getClass().getSimpleName());  
5.         }else {  
6.             throw   new  CanNotHandleRequestException();  
7.         }  
8.     }  
9. }  

public class PrintHandler implements Handler{
	public void handleRequest(Request request) throws CanNotHandleRequestException{
		if(request instanceof PrintRequest){
			System.out.println("PrintHandler handle "+request.getClass().getSimpleName());
		}else{
			throw new CanNotHandleRequestException();
		}
	}
}

 

SaveHandler   处理 保存请求（SaveRequest   ）

 

Java代码

1. public   class  SaveHandler  implements  Handler{  
2.     public   void  handleRequest(Request request)  throws  CanNotHandleRequestException{  
3.         if (request  instanceof  SaveRequest){  
4.             System.out.println("SaveHandler handle " +request.getClass().getSimpleName());  
5.         }else {  
6.             throw   new  CanNotHandleRequestException();  
7.         }  
8.     }  
9. }  

public class SaveHandler implements Handler{
	public void handleRequest(Request request) throws CanNotHandleRequestException{
		if(request instanceof SaveRequest){
			System.out.println("SaveHandler handle "+request.getClass().getSimpleName());
		}else{
			throw new CanNotHandleRequestException();
		}
	}
}

 

4，客户端 Client 类

 

Java代码

1. public   class  Client {  
2.     public   static   void  main(String[] args)  throws  CanNotHandleRequestException{  
3.         HandlerContainer Container1 = new  HandlerContainer();  
4.         Container1.add(new  HelpHandler());  
5.         HandlerContainer Container2 = new  HandlerContainer();  
6.         Container2.add(new  PrintHandler());  
7.         Container2.add(new  SaveHandler());  
8.         Container1.add(Container2);  
9.           
10.         Container1.handleRequest(new  HelpRequest());  
11.         Container1.handleRequest(new  PrintRequest());  
12.         Container1.handleRequest(new  SaveRequest());  
13.     }  
14. }  

public class Client {
	public static void main(String[] args) throws CanNotHandleRequestException{
		HandlerContainer Container1 = new HandlerContainer();
		Container1.add(new HelpHandler());
		HandlerContainer Container2 = new HandlerContainer();
		Container2.add(new PrintHandler());
		Container2.add(new SaveHandler());
		Container1.add(Container2);
		
		Container1.handleRequest(new HelpRequest());
		Container1.handleRequest(new PrintRequest());
		Container1.handleRequest(new SaveRequest());
	}
}

 

运行Client 类，输出如下

 

HelpHandler handle HelpRequest
PrintHandler handle PrintRequest
SaveHandler handle SaveRequest