设计模式（六）责任链模式

顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

 

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

 

举个例子，有这样关系销售员-销售组长-经理-CEO。你如果要买房的话，你选择要5%的折扣，销售员可以同意，如果你要20%的折扣，销售员就不能同意了，只能向上级传送。传给组长，如果组长也没有这个权利就继续向上传递。

 

责任链其实就是一个黑盒子，我们只负责发送请求，不管他内部是谁响应了你的请求，只要我的请求被响应就可以了。

 

这是链条的抽象类，指定这个的后继是谁，并且他的功能

package com.imooc.pattern.cor.handler;

/*
 * 价格处理人，负责处理客户折扣申请
 */
public abstract class PriceHandler {
	
	/*
	 * 直接后继，用于传递请求
	 */
	protected PriceHandler successor;

	public void setSuccessor(PriceHandler successor) {
		this.successor = successor;
	}
	
	/*
	 * 处理折扣申请
	 */
	public abstract  void processDiscount(float discount);

}

下面是链条

package com.imooc.pattern.cor.handler;

/*
 * 销售， 可以批准5%以内的折扣
 */
public class Sales extends PriceHandler {

	@Override
	public void processDiscount(float discount) {
		if(discount <= 0.05){
			System.out.format("%s批准了折扣：%.2f%n", this.getClass().getName(), discount);
		}else{
			successor.processDiscount(discount);
		}

	}

}







package com.imooc.pattern.cor.handler;

/*
 * 销售小组长， 可以批准15%以内的折扣
 */
public class Lead extends PriceHandler {

	@Override
	public void processDiscount(float discount) {
		if(discount<=0.15){
			System.out.format("%s批准了折扣:%.2f%n",this.getClass().getName(),discount);
		}else{
			successor.processDiscount(discount);
		}

	}

}





package com.imooc.pattern.cor.handler;

/*
 * 销售经理， 可以批准30%以内的折扣
 */
public class Manager extends PriceHandler {

	@Override
	public void processDiscount(float discount) {
		if(discount<=0.3){
			System.out.format("%s批准了折扣:%.2f%n",this.getClass().getName(),discount);
		}else{
			successor.processDiscount(discount);
		}

	}

}









package com.imooc.pattern.cor.handler;


/*
 * 销售副总裁， 可以批准50%以内的折扣
 */
public class VicePresident extends PriceHandler {

	@Override
	public void processDiscount(float discount) {
		if(discount<=0.5){
			System.out.format("%s批准了折扣:%.2f%n",this.getClass().getName(),discount);
		}else{
			successor.processDiscount(discount);
		}

	}

}








package com.imooc.pattern.cor.handler;

/*
 * CEO， 可以批准55%以内的折扣
 * 折扣超出55%， 就拒绝申请
 */
public class CEO extends PriceHandler {

	@Override
	public void processDiscount(float discount) {
		if(discount<=0.55){
			System.out.format("%s批准了折扣:%.2f%n",this.getClass().getName(),discount);
		}else{
			System.out.format("%s拒绝了折扣:%.2f%n", this.getClass().getName(),discount);
		}

	}

}

这就创建了链，每个结点都有自己的功能

 

 

这是用工厂模式来创建链，创建的过程当中，为每个结点设置他的后继

package com.imooc.pattern.cor.handler;

public class PriceHandlerFactory {

	/*
	 * 创建PriceHandler的工厂方法
	 */
	public static PriceHandler createPriceHandler() {
		
		PriceHandler sales = new Sales();
		PriceHandler lead = new Lead();
		PriceHandler man = new Manager();
		PriceHandler dir = new Director();
		PriceHandler vp = new VicePresident();
		PriceHandler ceo = new CEO();
		
		sales.setSuccessor(lead);
		lead.setSuccessor(man);
		man.setSuccessor(dir);
		dir.setSuccessor(vp);
		vp.setSuccessor(ceo);
		
		return sales;
	}

}

 

 

顾客请求

package com.imooc.pattern.cor;

import java.util.Random;
import com.imooc.pattern.cor.handler.PriceHandler;
import com.imooc.pattern.cor.handler.PriceHandlerFactory;

/*
 * 客户，请求折扣
 */
public class Customer {
	
        //责任链
	private PriceHandler priceHandler;
	
	public void setPriceHandler(PriceHandler priceHandler) {
		this.priceHandler = priceHandler;
	}

	public void requestDiscount(float discount){
		priceHandler.processDiscount(discount);
	}
	
	
	public static void main(String[] args){
		Customer customer = new Customer();
		customer.setPriceHandler(PriceHandlerFactory.createPriceHandler());//设置责任链
		
		Random rand = new Random();
		
		for(int i=1;i<=100;i++){
			System.out.print(i+":");
			customer.requestDiscount(rand.nextFloat());
		}
		
		
	}
	

}

 

总结

1.责任链模式的效率会比较低，因为我们的责任链有很多对象，每个请求都会去遍历链。速度慢，且对象多，会占用内存。

2.在这责任链模式之中发出请求的客户端并不知道链上的哪一个接受者会处理请求，从而实现了客户端和接受者之间的解耦。

因为你不用直接调用接受者，如果你添加删除接受者，是不会影响到客户端的。