设计模式之责任链模式

责任链模式：

    责任链模式：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
    这就好比《红楼梦》中击鼓传花的故事，贾母、贾赦、贾政、贾宝玉和贾环是五个参加击鼓传花游戏的传花者，他们组成一个环链。击鼓者将花传给贾母，开始传花游戏。花由贾母传给贾赦，由贾赦传给贾政，由贾政传给贾宝玉，又由贾宝玉传给贾环，由贾环传回给贾母，如此往复。

    让我们来看看结构图：

    按照结构，就用代码简单实现一下；首先我先定义一个处理请示的接口，

package package1;
/**
 * 定义一个处理请示的接口
 * 抽象处理者角色
 * @author admin
 *
 */
public abstract class Handler {
	/*
	 * 持有后继的责任对象
	 */
	protected Handler successor;
	/*
	 * 赋值方法，设置后继的责任对象
	 */
	public void setSuccessor(Handler successor){
		this.successor=successor;
	}
	/*
	 * 取值方法
	 */
	public Handler getSuccessor(){
		return successor;
	}
	/*
	 * 处理请求的方法
	 */
	public abstract void handleRequest( int request);
}

    接着再定义三个具体处理者，

package concretehandler;

import package1.Handler;
/**
 * 具体处理者1,请求数在0-10之间有权处理，否则转移到下一位
 * @author admin
 *
 */
public class ConcreteHandler1 extends Handler {

	@Override
	public void handleRequest(int request) {
		if (request>=0 && request<10) {
			System.out.println("处理者1.....处理");
		}else if (getSuccessor()!=null) {
			//放过请求，交给下一个处理
			System.out.println("放过请求");
			getSuccessor().handleRequest(request);
		}

	}

}

package concretehandler;

import package1.Handler;
/**
 * 具体处理者2,请求数在10-20之间有权处理，否则转移到下一位
 * @author admin
 *
 */
public class ConcreteHandler2 extends Handler {

	@Override
	public void handleRequest(int request) {
		if (request>=10 && request<20) {
			System.out.println("处理者2.....处理");
		}else if (getSuccessor()!=null) {
			//放过请求，交给下一个处理
			System.out.println("放过请求");
			getSuccessor().handleRequest(request);
		}

	}

}

package concretehandler;

import package1.Handler;
/**
 * 具体处理者3,请求数在20-30之间有权处理，否则转移到下一位
 * @author admin
 *
 */
public class ConcreteHandler3 extends Handler {

	@Override
	public void handleRequest(int request) {
		if (request>=20 && request<30) {
			System.out.println("处理者3.....处理");
		}else if (getSuccessor()!=null) {
			//放过请求，交给下一个处理
			System.out.println("放过请求");
			getSuccessor().handleRequest(request);
		}else if(getSuccessor()==null) {
			//最后boss的处理
			System.out.println("最后由我3来处理");
		}

	}

}

    最后是客户端，

package client;

import java.util.List;

import concretehandler.ConcreteHandler1;
import concretehandler.ConcreteHandler2;
import concretehandler.ConcreteHandler3;
import package1.Handler;

/**
 *  客户端
 * @author admin
 *
 */
public class Client {
	public static void main(String[] args) {
		Handler h1=new ConcreteHandler1();
		Handler h2=new ConcreteHandler2();
		Handler h3=new ConcreteHandler3();
		/*
		 * 设置责任链上家与下家
		 */
		h1.setSuccessor(h2);
		h2.setSuccessor(h3);
		
		int[] requests={5,12,22,32};
		for (int i : requests) {
			h1.handleRequest(i);
			System.out.println("---------------");
		}
	}
}

    运行结果贴在下边，

    简单的责任链模式就算完成了，那么这样设计又有什么好处呢？责任链的好处在于，这当中最关键的是当客户提交一个请求时，请求是沿链传递直至有一个ConcreteHandler对象负责处理它。这就使得接受者和发送者都没有对方的明确信息，且链中的对象自己也并不知道链的结构。结果是责任链可简化对象的相互连接，它们仅需保持一个指向其后继者的引用，而不需保持它所有的候选接受者的引用。这也就大大降低了耦合度了。

    此种模式由于是在客户端来定义链的结构，这样的话就可以随时增加或修改处理一个请求的机构。增强了给对象指派职责的灵活性。不过也要当心，一个请求极有可能到了链的末端都得不到处理，或者因为没有正确配置而得不到处理，这就很糟糕了，需要事先考虑全面。