责任链模式

一句话定义

将请求发送给请求处理链,请求在链上传递，链上的每个节点都可以进行处理，实现发送者和接收者解耦。

使用场景

1. 多个对象处理同一个请求，根据请求状态进行处理
2. 动态指定一组对象处理，不清楚具体的处理对象
3. 需要对请求进行层层过滤、筛选

实现要点

1. 多个节点实现(继承)同一个接口(父类)
2. 节点聚合接口(父类)自己，通过set方法设置下一个传递

情景假设

上学期间自习课偷传小纸条。

实现步骤

1. 创建节点的抽象类

/**
 * Created by ffengz.
 *
 * 责任链  节点抽象类
 */
public abstract class Handler {
    // 下一个节点
    protected Handler mNextHandler;

    /**
     * 处理方法
     * @param message 信息
     */
    public abstract void handlerMessage(String message);

    /**
     * 设置下一个节点
     */
    public void setNextHandler(Handler handler){
        this.mNextHandler = handler;
    }
}

2. 创建具体的节点，继承自抽象类。具体的处理信息

/**
 * Created by ffengz.
 *
 * 伙伴节点B
 */
public class ParterB extends Handler {
    @Override
    public void handlerMessage(String message) {
        if ("B".equals(message)){
            Log.i("info", "handlerMessage: ==++  B同学接收了信息");
        }else {
            Log.i("info", "handlerMessage: ==++  没有该同学，错误对象");
        }
    }
}

/**
 * Created by ffengz.
 *
 * 伙伴节点A
 */
public class ParterA extends Handler {
    @Override
    public void handlerMessage(String message) {
        // 如果是 A 的信息，A同学处理
        if ("A".equals(message)){
            Log.i("info", "handlerMessage: ==++  A同学接收到了信息");
        } else { // 不是A的信息，传递给下一个
            mNextHandler.handlerMessage(message);
        }
    }
}

3. 责任链使用,不管责任链的具体处理，A-B或A-C-B或A-C-D-B

        // 责任链模式
        ParterA parterA = new ParterA();
        ParterB parterB = new ParterB();
        parterA.setNextHandler(parterB);
        // 丢给责任链   最终输出B接收了信息
        parterA.handlerMessage("B");

进阶使用

**在抽象类统一处理节点的转发，将发送者和处理者进行封装使用。**

1. 创建消息封装抽象类。对消息进行封装

/**
 * Created by ffengz.
 *
 * 消息抽象类
 */
public abstract class Message {
    private String message;

    // 创建消息
    public Message(String message){
        this.message = message;
    }

    /**
     * 获取消息内容
     */
    public String getMessage() {
        return message;
    }

    /**
     * 获取消息的发送对象
     */
    public abstract String getRequestParter();
}

2. 创建消息处理抽象类。对处理者进行封装，链责任转移集中处理

/**
 * Created by ffengz.
 *
 * 消息处理抽象类
 */
public abstract class Handler {
    // 下一个处理节点
    protected Handler mNextHandler;

    // 获取处理者名字
    public abstract String getHandlerName();

    // 具体的处理方式
    public abstract void handleMessage(String message);

    // 下个节点设置
    public void setNext(Handler handler){
        this.mNextHandler = handler;
    }

    /**
     * 对消息进行集中处理，子类不能修改处理方式
     */
    public final void handleMessage(Message message){
        // 发送给当前节点
        if (getHandlerName().equals(message.getRequestParter())){
            handleMessage(message.getMessage());
        } else {
            // 传递给下一个节点
            if (mNextHandler != null){
                mNextHandler.handleMessage(message);
            }else{
                Log.i("info", "handleMessage: ==++  没有该同学，错误信息");
            }
        }
    }
}

3. 创建具体的消息类。

/**
 * Created by ffengz.
 *
 * 消息A 继承消息抽象类
 */
public class MessageA extends Message {

    public MessageA(String message) {
        super(message);
    }

    @Override
    public String getRequestParter() {
        return "A";
    }
}

/**
 * Created by ffengz.
 *
 * 消息B
 */
public class MessageB extends Message {

    public MessageB(String message) {
        super(message);
    }

    @Override
    public String getRequestParter() {
        return "B";
    }
}

4. 创建具体的处理者类。

/**
 * Created by ffengz.
 *
 * 处理者A 继承消息处理接口
 */
public class HandlerA extends Handler {
    @Override
    public String getHandlerName() {
        return "A";
    }

    @Override
    public void handleMessage(String message) {
        Log.i("info", "handMessage: ==++  A接收了消息   " + message);
    }
}

public class HandlerB extends Handler {
    @Override
    public String getHandlerName() {
        return "B";
    }

    @Override
    public void handleMessage(String message) {
        Log.i("info", "handMessage: ==++  B接收了信息   " + message);
    }
}

5. 使用方式

        // 创建消息
        MessageA messageA = new MessageA("A同学你好啊！");
        MessageB messageB = new MessageB("B同学 我稀饭你！");
        // 创建处理者
        HandlerA handlerA = new HandlerA();
        HandlerB handlerB = new HandlerB();
        // 链 创建
        handlerA.setNext(handlerB);
        // 发送消息到链  进行处理
        handlerA.handleMessage(messageA);
        handlerA.handleMessage(messageB);

6. 结果展示