chainOfResponsibility责任链模式

责任链（Chain of Responsibility）模式 ：

　　责任链模式是对象的行为模式。使多个对象都有机会处理请求，从而避免请求的发送者和接受者直接的耦合关系。将这些处理对象连成一条链，沿着这条链传递该请求，直到有一个对象处理它为止。责任链模式强调的是每一个对象及其对下家的引用来组成一条链，利用这种方式将发送者和接收者解耦，类图如下：

通过上图可以看出责任链模式有两个角色：

抽象处理者（Handler）角色 ：定义一个请求的接口。如果需要可以定义个一个方法用来设定和返回下家对象的引用。

具体处理者（ConcreteHandler）角色 ：如果可以处理就处理请求，如果不能处理，就把请求传给下家，让下家处理。也就是说它处理自己能处理的请求且可以访问它的下家。

 

代码演示：

 

1.新建一个抽象处理角色，当然，它是一个abstract类，因为里面的处理方法要给每个具体角色类去扩展使用

/**
 * 抽象处理角色
 * @author mlxs
 *
 */
public abstract class Hander {

    /**
     * 处理角色 实例
     */
    protected Hander hander;

    /**
     * 抽象处理方法：执行处理
     */
    public abstract void doHander(String reqStr);

    public Hander getHander() {
        return hander;
    }

    public void setHander(Hander hander) {
        this.hander = hander;
    }

}

2.添加3个具体实现子类：HanderFirst，HanderSecond，HanderLast，并实现doHander方法

/**
 * 具体处理角色
 * @author mlxs
 *
 */
public class HanderFirst extends Hander {

    @Override
    public void doHander(String reqStr) {
        //得到当前处理角色
        Hander nowHander = getHander();
        //判断：如果是自己的责任，则处理，处理完后结束(return)；否则，传给下一角色处理
        if(reqStr.equals("HanderFirst")){
            System.out.println("---Hander1 doHander()---");
            return;
        }else{
            //不是自己的责任，责任推给下家
            System.out.println("Hander1 pass --> next");
            nowHander.doHander(reqStr);
        }
    }
}

/**
 * 具体处理角色
 * @author mlxs
 *
 */
public class HanderSecond extends Hander {

    @Override
    public void doHander(String reqStr) {
        //得到当前处理角色
        Hander nowHander = getHander();
        //判断：如果是自己的责任，则处理，处理完后结束(return)；否则，传给下一角色处理
        if(reqStr.equals("HanderSecond")){
            System.out.println("---Hander2 doHander()---");
            return;
        }else{
            //不是自己的责任，责任推给下家
            System.out.println("Hander2 pass --> next");
            nowHander.doHander(reqStr);
        }
    }
}

/**
 * 具体处理角色
 * @author mlxs
 *
 */
public class HanderLast extends Hander {

    @Override
    public void doHander(String reqStr) {
        //如果前面的都没处理，最后一家处理
        System.out.println("...\n---HanderLast doHander()---");
    }

}

3.编写客户端请求类：Main

public class Main {

    public static void main(String[] args) {

        //创建3个具体处理者
        Hander hander1 = new HanderFirst();
        Hander hander2 = new HanderSecond();
        Hander hander3 = new HanderLast();

        //3个处理者链接，形成责任链
        hander1.setHander(hander2);
        hander2.setHander(hander3);

        //从hander1开始处理请求
//        hander1.doHander("HanderFirst");
//        hander1.doHander("HanderSecond");
        hander1.doHander("hahahahh");
    }
}

4.运行，查看结果

Hander1 pass --> next
Hander2 pass --> next
...
---HanderLast doHander()---

过滤器和拦截器，就是通过这种模式思想写的,,,