设计模式-行为型模式-责任链模式
定义
将请求沿着链传递，然后直到对象处理即可。
UML图
代码
基本的责任链
public class Test{
public void test(int i, Request request){
if(i == 1){
Hander1.response(request);
}
if(i == 2){
Hander2.response(request);
if(i == 3){
Hander3.requese(request);
代码逻辑如上，只处理1，2,3情况，其余的情况都不处理。
责任链
// 对象
public class Level{
private int level = 0;
public Level(int level){
this.level = level;
public boolean above(Level level){
if(this.level >= level.level)
return true;
else
return false;
// 将对象进行封装
public class Request{
Level level;
public Request(Level level){
public Level getLevel(){
return level;
// 返回消息
public class Response{}
public abstract class Handler{
private Handler nextHandler;
public final Response handleRequest(Request request){
Response response = null;
// 根据处理器的优先级处理，如果优先级高，处理
if(this.getHandlerLevel().above(request.getLevel())){
// 如果寻找到处理器，进行处理
response = this.response(request);
}else{
// 否则，进入下一个处理器
if(this.nextHandler != null){
this.nextHandler.handleRequest(request);
System.out.println("没有合适的处理器");
return response;
// 设置下一个处理器
public void setNextHandler(Handler handler){
this.nextHandler = handler;
// 当前处理器
protected abstract Level getHandlerLvel();
// 进入处理器处理
public abstract Response response(Request request);
// 第一个处理器
public class ConcreteHandler1 extends Handler{
protected Level getHandlerLevel(){
return new Level(1);
public Response response(Request request){
System.out.println("处理1处理");
return null; // 下一个处理器为空
// 第二个处理器
public class ConcreteHandler2 extends Handler{
return new Level(3);
// 第三个处理器
public class ConcreteHandler3 extends Handler{
return new Level(5);
// 最后定义场景
public class Client{
public static void main(String[] args){
// 新建处理器
Handler handler1 = new ConcreteHandler1();
Handler handler2 = new ConcreteHandler2();
Handler handler3 = new ConcreteHandler3();
// 处理器处理逻辑为先处理1，再处理2，再处理3
handler1.setNextHandler(handler2);
handler2.setNextHandler(handler3);
// 进行处理
Response response = handler1.handlerRequest(new Request(new Level(4)));
总结
责任链模式核心在处理流，让对象在类之间流动，直到合适进行对象处理，并把下一个设置为空。
写法，当然就是新建几个处理器类，然后要处理的对象，处理类之间用next指向下一个，然后把处理的对象传入进去，如果找到合适的处理器，进行处理，并将下一个设置为空，完成责任链。
其中，几个处理器类可以抽象出一个抽象类，并把对象进行封装成一个类，以上为上方代码的设计思路。
应用
开发一个电商网站，支付过500元定金的用户，收到100元优惠卷，200元收到50元，没有支付过的，进入普通模式购买。
如果不用职责链，需要写入一大堆if语句。
将if语句拆分，使用职责链，将处理器类抽象出来，然后将购买的用户传入处理器，然后如果处理完成，下一个设置为空，返回结果。
