设计模式——责任链模式（一文看懂）

设计模式主要分为创建型、结构型、行为型。
其中创建型包括单例模式、抽象工厂、工厂方法、建造模式、原型模式模式。
结构型模式包括适配器、桥接、组合、装饰者、外观、代理模式。
行为型包括迭代器、观察者、模板方法、责任链、命令、策略模式。
责任链模式是行为型模式的一种：

不同类型的模式的区别见下图：

进入正题：
假设现在存在这样一个问题，小明想要去跟人力资源部长谈事情，但他并不知道哪个才是自己要找的人，他有三个候选对象分布在不同的地方，他就需要对每个人都发出一次请求（询问对方是否是人资部长）这样一来，命令发送者与接收者之间就有强耦合关系。

而责任链这个设计模式就是希望使得多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。

在上面的例子中也就是这样一个情况，小明先找到候选人A，发出请求，如果A不是，A正好有B的电话，就将请求转移给B，如果B也不是，那他就打电话给C，将请求转移给C。

我们通过这个想法就能设计出类图来：

successor就是继任人，handle()就是判断自己能否接下这件事。但这个类图还存在一些问题，如果我们此时又多了一个候选人D，并且改变了他们之间的继任顺序，那么需要改动的代码就大大增加了。

因此我们用一个抽象类，将successor和handle放入父类，候选人只需要继承实现就行了。

举例1.计算器的四则运算

我们让程序去判断输入的运算符是否是+，若不是则判断是否是-，若不是则判断是否是*，若不是则判断是否是/，若都不是抛出异常警告。

画出类图：

CalcUnit:

package Res;

import javax.naming.OperationNotSupportedException;

public abstract class CalcUnit {
    private CalcUnit next;
    public CalcUnit(CalcUnit next)
    {
        super();
        this.next=next;
    }
    public CalcUnit(){}
    public  CalcUnit getNext()
    {
        return next;
    }
    public void setNext(CalcUnit next)
    {
        this.next=next;
    }
    public   double calc(double x,double y,String operator) throws OperationNotSupportedException
    {
        if(this.getNext()!=null)
        {return  this.getNext().calc(x,y,operator);}
        else
        {
            throw  new  OperationNotSupportedException(operator+"not found!");
        }

    }
    }

Add

package Res;

import javax.naming.OperationNotSupportedException;

public class Add extends CalcUnit {
    public Add(CalcUnit c) {
        super(c);
    }

    @Override
    public double calc(double x, double y, String operator) throws OperationNotSupportedException {
        if (operator.equals("+")) {
            return x + y;
        } else {
            return  super.calc(x, y, operator);

        }
    }
}

Sub:

package Res;

import javax.naming.OperationNotSupportedException;

public class Sub extends CalcUnit {
    public Sub(CalcUnit c) {
        super(c);
    }

    public double calc(double x, double y, String operator) throws OperationNotSupportedException {
        if (operator.equals("-")) {
            return x - y;
        } else {
            return  super.calc(x, y, operator);

        }
    }
}

Mul:

package Res;

import javax.naming.OperationNotSupportedException;

public class Mul extends CalcUnit {
    public Mul(CalcUnit c) {
        super(c);
    }

    public double calc(double x, double y, String operator) throws OperationNotSupportedException {
        if (operator.equals("*")) {
            return x * y;
        } else {
            return  super.calc(x, y, operator);

        }
    }
}

Div:

package Res;

import javax.naming.OperationNotSupportedException;

public class Div extends CalcUnit{
    public double calc(double x, double y, String operator) throws OperationNotSupportedException {
        if (operator.equals("/")) {
            return x / y;
        } else {
            return  super.calc(x, y, operator);

        }
    }
}

Test:

package Res;

import javax.naming.OperationNotSupportedException;

public class Test {
    public static void main(String args[])
    {
        CalcUnit c=new Add(new Sub(new Mul(new Div())));
        try{
            System.out.println(c.calc(3,5,"!"));

        }catch (OperationNotSupportedException e)
        {
            e.printStackTrace();
        }

    }
}

输出结果（因为输入的是！，所以返回异常）：

这是一种责任链模式（纯链式），还有非纯链式

也就是类似于流程图，不做判断，每个模块都需要执行。