JAVA的23种设计模式---责任链模式

概要：

该文章参考了《设计模式之禅》一书及一些前辈的博客文章

1.该文章阐述了责任链模式的基础原理及示例代码；
2.该文章适合初学设计模式的技术人员研习；
3.该文章有许多不足之处，请各位大咖指正，喷子绕道；

正文：

责任链模式：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之前的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

1.责任链模式示例代码实现：

package com.csdn;
/*
 * 员工抽象类
 */
public interface Employee {
    //获取申报级别
    public int getType();
    //获取申报事项
    public String getRequest();
}

package com.csdn;
/**
 * 员工汤姆
 * @author Administrator
 *
 */
public class Tom implements Employee {
    //汤姆的申报级别
    private int type = 0;
    //汤姆的申报事项
    private String request;
    //构造函数传递求情
    public Tom(int _request){
        //申报事项为请假？天
        this.request = "Tom提交请假申请，请假天数是"+_request+"天";
        //如果是请假1~3天，申报级别为3（对应主管）
        if(_request > 0 && _request < 4){
            type = 3;
        //如果是请假4~7天，申报级别为2（对应经理）
        }else if(_request > 3 && _request < 8){
            type = 2;
        //如果是请假7天以上，申报级别为1（对应董事长）
        }else if(_request > 7){
            type = 1;
        }
    }
    //获得自己的申报级别
    @Override
    public int getType() {
        return this.type;
    }
    //获取自己的申报事项
    @Override
    public String getRequest() {
        return this.request;
    }
}

package com.csdn;
/**
 * Handler类，处理逻辑关系
 * @author Administrator
 *
 */
public abstract class Handler {
    //3个汇报等级
    public final static int CHARGE_LEVEL_REQUEST = 3;
    public final static int MANAGER_LEVEL_REQUEST = 2;
    public final static int CHAIRMAN_LEVEL_REQUEST = 1;
    //当前处理者等级
    private int level = 0;
    //当前处理者的下级处理者
    private Handler nextHandler;
    public Handler(int _level){
        this.level = _level;
    }
    //责任链模式主要实现方法
    public final void HandleMessage(Employee employee){
        //判断用户的申报等级是否跟当前处理者等级一致
        //如果一致，处理者处理请求并提交给用户返回值
        if(employee.getType() == this.level){
            this.response(employee);
        //如果不一致,请求交给下一级处理者处理
        }else{
            //如果下一级处理者不为空
            if(this.nextHandler != null){
                //因为该模拟场景是请假申请，一般需要逐级审批同意，一般的责任链模式无此处理
                this.response(employee);
                //转到下一级处理者处理请求，递归
                this.nextHandler.HandleMessage(employee);
            }else{
                System.out.println("没有上级可以请示了，作不同意处理");
            }
        }
    }
    //传入下级处理者是谁
    public void setNext(Handler _handler){
        this.nextHandler = _handler;
    }
    //每级处理者处理后做出的响应
    protected abstract void response(Employee employee);
}

package com.csdn;
/**
 * 主管类
 * @author Administrator
 *
 */
public class Charge extends Handler{
    //主管等级为3，下一级是经理
    public Charge() {
        super(Handler.CHARGE_LEVEL_REQUEST);
        super.setNext(new Manager());
    }
    //主管的具体回复
    @Override
    protected void response(Employee employee) {
        System.out.println("-----Tom向主管请示-----");
        System.out.println(employee.getRequest());
        System.out.println("主管表示同意");
    }
}

package com.csdn;
/**
 * 经理类
 * @author Administrator
 *
 */
public class Manager extends Handler{
    //经理等级为2，下一级是董事长
    public Manager() {
        super(Handler.MANAGER_LEVEL_REQUEST);
        super.setNext(new Chairman());
    }
    //经理的具体回复
    @Override
    protected void response(Employee employee) {
        System.out.println("-----Tom向经理请示-----");
        System.out.println(employee.getRequest());
        System.out.println("经理表示同意");
    }
}

package com.csdn;
/**
 * 董事长类
 * @author Administrator
 *
 */
public class Chairman extends Handler{
    //董事长等级为1，无下一级
    public Chairman() {
        super(Handler.CHAIRMAN_LEVEL_REQUEST);
    }
    //董事长的具体回复
    @Override
    protected void response(Employee employee) {
        System.out.println("-----Tom向董事长请示-----");
        System.out.println(employee.getRequest());
        System.out.println("董事长表示同意");
    }
}

package com.csdn;
/**
 * 场景模拟
 * @author Administrator
 *
 */
public class Client {
    public static void main(String[] args) {
        //汤姆想请假12天（12天需要主管、经理、董事长都批准）
        Tom tom = new Tom(12);
        //汤姆的主管出现了
        Handler charge = new Charge();
        //主管收到汤姆的请求并开始处理
        charge.HandleMessage(tom);
    }
}

输出：

-----Tom向主管请示-----
Tom提交请假申请，请假天数是12天
主管表示同意
-----Tom向经理请示-----
Tom提交请假申请，请假天数是12天
经理表示同意
-----Tom向董事长请示-----
Tom提交请假申请，请假天数是12天
董事长表示同意

注：
a：该示例模拟了员工的请假审批流，请假天数越多，在这个审批链中需要做出响应的人越多。在很多情况下，责任链模式只是要求从开始沿着这个“链”找出一个请求对应的处理人，不需要经过的每一级都做出处理。
b：责任链模式屏蔽了请求的处理过程，发起一个请求到底是谁处理的，这个你不用关心，只要你把请求抛给责任链的第一个处理者，最终会返回一个处理结果，作为请求者可以不用知道到底是谁处理的，这是责任链模式的核心。

2.通用责任链模式模板代码实现：

package com.csdn;
//抽象处理者
public abstract class Handler {
    private Handler nextHandler;
    //每个处理者都必须对请求作出处理
    public final Response handleMessage(Request request){
        Response response = null;
        //判断是否是自己的处理级别
        if(this.getHandlerLevel().equals(request.getRequsetLevel())){
            response = this.echo(request);
        }else{
            //判断是否有下一个处理着
            if(this.nextHandler != null){
                response = this.nextHandler.handleMessage(request);
            }else{
                //没有适当的处理者，业务自行处理
            }
        }
        return response;
    }
    //设置下一个处理者是谁
    public void setNext(Handler _handler){
        this.nextHandler = _handler;
    }
    //每个处理者都有一个处理级别
    protected abstract Level getHandlerLevel();
    //每个处理者都必须实现处理任务
    protected abstract Response echo(Request request);
}

//模式中有关框架代码
class Level{
    //定义一个请求和处理等级
}
class Request{
    //请求的等级
    public Level getRequsetLevel(){
        return null;
    }
}
class Response{
    //处理者返回的数据
}

package com.csdn;
//具体处理者
public class ConcreteHandler1 extends Handler{
    //定义自身处理逻辑
    @Override
    protected Level getHandlerLevel() {
        return null;
    }
    //设置自己处理级别
    @Override
    protected Response echo(Request request) {
        return null;
    }
}

package com.csdn;
//具体处理者
public class ConcreteHandler2 extends Handler{
    //定义自身处理逻辑
    @Override
    protected Level getHandlerLevel() {
        return null;
    }
    //设置自己处理级别
    @Override
    protected Response echo(Request request) {
        return null;
    }
}

package com.csdn;
//具体处理者
public class ConcreteHandler3 extends Handler{
    //定义自身处理逻辑
    @Override
    protected Level getHandlerLevel() {
        return null;
    }
    //设置自己处理级别
    @Override
    protected Response echo(Request request) {
        return null;
    }
}

package com.csdn;
//场景模拟
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.setNext(handler2);
        handler2.setNext(handler3);
        //提交请求返回结果
        Response response = handler1.handleMessage(new Request());
    }
}

注：
a：在示例和通用模板中Handler是抽象类，融合了模板方法模式，每个实现类只要实现两个方法