责任链模式 ~ 设计模式之三

责任重于泰山，咱再来看看责任链模式。
这里的责任我理解为两种责任：
1）一种是自我责任，自己的任务，自己认真做好，保证任务的质量
2）另一种是整体责任，当不属于自己的任务，或是自己不能担当的，应尽快交给能完成他的人，保证整体效率的提高

1. 定义

有点像流水线的模式，前一个流程处理完了，交给下一个流程处理，是一个自动流程链处理的过程，要进入整个流程很简单，
只需要知道第一个流程节点的位置就可以，且各个流程节点也不需要关心其他节点的处理过程。
注：可能存在某一次流水线过程，比如一共10个环节，而实际呢，只有5个环节参与了流程，这个就是要看具体加工的产品需要
哪个环节来处理。

2. 优点

1. 降低了处理对象与自身的关联关系
2. 扩展性增加，需要增加处理流程时，随时动态增加到流程的具体位置即可
3. 可以动态调整节点，包括更换位置、或是删除
4. 前后流程维护较方便，只需要保留后一个节点的引用即可
5. 职责分工明确，各个节点只需要负责自己的处理即可

3. 缺点

1. 请求处理的随机性，可能被流程中的过程环节处理到，也可能一个环节也没有处理
2. 如果流程环节较长，可能对系统性能有一定的影响

4. 结构

• 抽象处理类：主要包括处理的抽象方法，及下一个流程节点的维护
• 具体处理类：具体的流程处理方法 ，大概包括：本节点是否需要执行，以及负责把流程流转到下一个节点
• 客户端：负责向流程的第一个处理节点发起请求，不需要关心后续的流程和处理过程

5. 实现

一般来说，汽车生产分为4个环节，冲压、焊接、涂装、总装。
当然真实的流水线，是挨个顺序来的，当然呢，也有可能某一个零件是中间的一个步骤，下面的逻辑可以支持中间过程的零件生产。

//处理抽象类
abstract class CarProducerHandler {
    //下一个流程的引用
    private CarProducerHandler next;

    public CarProducerHandler getNext() {
        return next;
    }

    public void setNext(CarProducerHandler next) {
        this.next = next;
    }
    
    //处理请求的方法
    public abstract void produceHandler(String request);
}

//冲压环节
class StampingHandler extends CarProducerHandler {

    @Override
    public void produceHandler(String request) {
        if(request.equals("stamping")) {
            System.out.println("我来处理冲压任务");
                        //这样我们可以流转到下一个环节进行生产
            getNext().produceHandler("welding");
        }else {
            if(getNext()!=null) {
                getNext().produceHandler(request);
            }else {
                System.out.println("当前无人处理请求");
            }
        }
    }
}

//焊接环节
class WeldingHandler extends CarProducerHandler {

    @Override
    public void produceHandler(String request) {
        if(request.equals("welding")) {
            System.out.println("我来处理焊接任务");
            getNext().produceHandler("painting");
        }else {
            if(getNext()!=null) {
                getNext().produceHandler(request);
            }else {
                System.out.println("当前无人处理请求");
            }
        }
    }
}

//油漆环节
class PaintingHandler extends CarProducerHandler {

    @Override
    public void produceHandler(String request) {
        if(request.equals("painting")) {
            System.out.println("我来处理涂装任务");
            getNext().produceHandler("assembly");
        }else {
            if(getNext()!=null) {
                getNext().produceHandler(request);
            }else {
                System.out.println("当前无人处理请求");
            }
        }
    }
}

//总装环节
class AssemblyHandler extends CarProducerHandler {

    @Override
    public void produceHandler(String request) {
        if(request.equals("assembly")) {
            System.out.println("我来处理总装任务，全结束");
        }else {
            if(getNext()!=null) {
                getNext().produceHandler(request);
            }else {
                System.out.println("当前无人处理请求");
            }
        }
    }
}

public class ChainPatternTest {
    public static void main(String[] args) {
                //四大环节
        StampingHandler stampingHandler = new StampingHandler();
        WeldingHandler weldingHandler = new WeldingHandler();
        PaintingHandler paintingHandler = new PaintingHandler();
        AssemblyHandler assemblyHandler = new AssemblyHandler();
        
                //建立四大环节的前后关系
        stampingHandler.setNext(weldingHandler);
        weldingHandler.setNext(paintingHandler);
        paintingHandler.setNext(assemblyHandler);
        
                //这个例子是从一开始的冲压环节开始
        stampingHandler.produceHandler("stamping");
        System.out.println("-------------------------");
                //这个例子我们从涂装开始
        stampingHandler.produceHandler("painting");
    }
}
//下面的输出的结果
//例子1：从冲压开始
//我来处理冲压任务
//我来处理焊接任务
//我来处理涂装任务
//我来处理总装任务，全结束
//-------------------------
//例子2：从涂装开始
//我来处理涂装任务
//我来处理总装任务，全结束

当然了，也可以简单一点，任务只有一个节点负责处理，你想想，该怎么来改呢，欢迎回复！