责任链模式

Chain of Responsibility(CoR) 是用一系列类(classes)试图处理一个请求request,这些类之间是一个松散的耦合,唯一共同点是在他们之间传递request. 也就是说，来了一个请求，A类先处理，如果没有处理，就传递到B类处理，如果没有处理，就传递到C类处理，就这样象一个链条(chain)一样传递下去。
1) 抽象处理者角色（Handler）：它定义了一个处理请求的接口。当然对于链子的不同实现，也可以在这个角色中实现后继链。
2) 具体处理者角色（Concrete Handler）：实现抽象角色中定义的接口，并处理它所负责的请求。如果不能处理则访问它的后继者。
至于类图不放也罢。毕竟就是一个继承或者实现。
纯与不纯
责任链模式的纯与不纯的区别，就像黑猫、白猫的区别一样。不要刻意的去使自己的代码来符合一个模式的公式。只要能够使代码降低耦合、提高重用，满足系统需求并能很好的适应变化就好了。正所谓：管它黑猫白猫，抓住老鼠就是好猫！
纯的责任链模式，规定一个具体处理者角色只能对请求作出两种动作：自己处理；传给下家。不能出现处理了一部分，把剩下的传给了下家的情况。而且请求在责任链中必须被处理，而不能出现无果而终的结局。
反之，则就是不纯的责任链模式。
不纯的责任链模式还算是责任链模式吗？比如一个请求被捕获后，每个具体处理者都尝试去处理它，不管结果如何都将请求再次转发。我认为这种方式的实现，算不算是责任链模式的一种倒不重要，重要的是我们也能从中体味到责任链模式的思想：通过将多个处理者之间建立联系，来达到请求与具体的某个处理者的解耦。

我在代码中写了一个Army的Handler类，其中实现它的有陆军军士长，陆军上尉，陆军上校和将军，军士长可以对士兵的请假做审核处理，上尉可以对士兵的破坏请求做处理，上校可以对士兵的谍报请求做处理，而将军可以对士兵的开战请求做处理。
handler：

    package pattern.chain;

public abstract class Army {
	protected Army army;

	public Army(Army army) {
		this.army = army;
	}
	Status s;
	public enum Status {
		JIA("请假"), PO("破坏"), DIE("谍报"), KAI("开战");
		String value = "";

		private Status(String value) {
			this.value = value;
		}

		String getValue() {
			return this.value;
		}
	}

	public void setNext(Army army) {
		this.army = army;

	}

	protected abstract void handler(Status s);

	public void next() {
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		if (army != null) {
			army.handler(s);
		}

	}
}

  

    
package pattern.chain;

public class General extends Army {

	public General(Army army) {
		super(army);
		// TODO Auto-generated constructor stub
	}

	@Override
	protected void handler(Status s) {
		this.s = s;
		if (Status.KAI.equals(s)) {
			System.out.println("将军同意");

		} else {
			next();
		}
	}

}


  

    
package pattern.chain;

public class Colonel extends Army {

	public Colonel(Army army) {
		super(army);
		// TODO Auto-generated constructor stub
	}

	@Override
	protected void handler(Status ss) {
	this.s=ss;
		
		if (Status.DIE.equals(s)) {
			System.out.println("少校同意");
		} else {
			next();		}
	}

}

  

    

package pattern.chain;

public class Captain extends Army {

	public Captain(Army army) {
		super(army);
		// TODO Auto-generated constructor stub
	}

	@Override
	protected void handler(Status ss) {
		this.s = ss;

		if (Status.PO.equals(s)) {
			System.out.println("上尉同意");
		} else {
			next();
		}
	}

}


  

    
package pattern.chain;

public class Commander extends Army {

	public Commander(Army army) {
		super(army);
		// TODO Auto-generated constructor stub
	}

	@Override
	protected void handler(Status ss) {
		this.s = ss;

		if (Status.JIA.equals(s)) {
			System.out.println("士官长同意");
		} else {
			next();
		}
	}

}


  

Test:

    
package pattern.chain;

import pattern.chain.Army.Status;

public class Test {
	public static void main(String[] args) {
		Army gen = new General(null);
		Army col = new Colonel(gen);
		Army cap = new Captain(col);
		Army com = new Commander(cap);
		com.setNext(cap);
		cap.setNext(col);
		col.setNext(gen);
		com.handler(Status.KAI);
	}
}


  

责任链模式