Java设计模式之责任链模式(Chain of Responsibility )

た入场券 2022-05-21 00:09 86阅读 0赞

责任链模式(Chain of Responsibility)是用一系列类(classes)试图处理一个请求 request,这些类之间是一个松散的耦合,唯一共同点是在他们之间传递 request. 也就是说，来了一个请求，A 类先处理，如果没有处理，就传递到 B 类处理，如果没有处理，就传递到 C 类处理，就这样象一个链条(chain)一样传递下去。在这种模式下，通常每个接受者都包含对另一个接受者的引用。像Struts2的拦截器、servlet的Filter等都是使用责任链模式。

下面就举例说明这一设计模式。当在产品开发过程中，测试者、开发者、产品经理和需求人员会根据bug的数目产生一个责任链(假设是根据bug的数目^\_^)。

首先对产品bug的负责人抽象出一个责任容器和一个责任链：

public abstract class ProductHandle {
    	
    	protected ProductHandle productHandle;
    
    	public ProductHandle getProductHandle() {
    		return productHandle;
    	}
    	public void setProductHandle(ProductHandle productHandle) {
    		this.productHandle = productHandle;
    	}
    	
    	//根据bug数目来请求责任人来处理
    	public abstract void handleBug(int bugs);
    	
    	//设置责任链
    	public static ProductHandle createHandle(){
    		ProductHandle developer = new Developer();
    		ProductHandle producter = new ProductManager();
    		ProductHandle customer = new CustomerDemand();
    		developer.setProductHandle(producter);
    		producter.setProductHandle(customer);
    		return developer;
    	}
    }

有bug了，提交给程序员，程序员要继承这个责任：

public class Developer extends ProductHandle {
    
    	@Override
    	public void handleBug(int bugs) {
    		if(bugs <= 100){
    			System.out.println("浏览器清除一下缓存，还不行的话我就处理这些Bug: " + bugs);
    		}else{
    			productHandle.handleBug(bugs);
    		}
    	}
    
    }

bug太多，业务都走不下去了，把责任推给产品(肯定产品设计有问题的啦)：

public class ProductManager extends ProductHandle {
    
    	@Override
    	public void handleBug(int bugs) {
    		if(bugs <= 1000){
    			System.out.println("开发的没问题吗，业务走不通？好吧，我来解决这些bug: " + bugs);
    		}else{
    			productHandle.handleBug(bugs);
    		}
    	}
    
    }

根据需求产品经理对这些bug也无能为力，还是跟需求谈一下吧：

public class CustomerDemand extends ProductHandle {
    
    	@Override
    	public void handleBug(int bugs) {
    		if(bugs<=10000){
    			System.out.println("这么多bug，产品设计的有问题吧(怼不过产品)！好吧，我改一下需求，解决这些bug: " + bugs);
    		}else{
    			System.out.println("bug太多，产品取消，大家自行解散！bug: " + bugs);
    		}
    	}
    
    }

这样就形成了一个责任链，还要一个测试人员，要是测试出了bug就列给责任人：

public class Tester {
    	private ProductHandle productHandle;
    
    	public void setProductHandle(ProductHandle productHandle) {
    		this.productHandle = productHandle;
    	}
    
    	public void handleBugs(int bugs){
    		productHandle.handleBug(bugs);
    	}
    }

上午饮茶看新闻，下午喝咖啡敲一个多小时的代码，经过了三个月紧锣密鼓的开发，产品终于成型了，尽情的测试吧：

public class BugsTest {
    	public static void main(String[] args) {
    		Tester tester = new Tester();
    		tester.setProductHandle(ProductHandle.createHandle());
    		int[] bugs = {66,777,8888,99999};
    		for (int bug : bugs) {
    			tester.handleBugs(bug);
    		}
    	}
    }

运行结果如下：

第一次测试：浏览器清除一下缓存，还不行的话我就处理这些Bug: 66
    第二次测试：开发的没问题吗，业务走不通？好吧，我来解决这些bug: 777
    第三次测试：这么多bug，产品设计的有问题吧(怼不过产品)！好吧，我改一下需求，解决这些bug: 8888
    第四次测试：bug太多，产品取消，大家自行解散！bug: 99999

责任链模式的优缺点：

优点：

1、降低耦合度，将请求的发送者和接受者解耦；

2、简化了对象，使得对象不需要知道链的结构；

3、增强给对象指派职责的灵活性，允许动态的新增或者删除责任；

4、增加新的请求处理类很方便

缺点：

1、效率低，系统性能将受到影响，并且代码调试起来不方便，可能造成循环调用；

2、扩展性差，因为一定要有一个统一的接口或者抽象类。