传统责任链模式和变种责任链模式

一、传统责任链模式

传统责任链模式是事件在链条中的某一节进行处理，而变种责任链模式是事件会在链条的每一节都进行处理，每一节担当的责任各不相同。

1.一个接口或抽象类

定义一个接口，一个方法，判断数值是否正确。这里简单的自定义判断数值是否正确，规则随便怎么写。

package com.ykq;

/**
 * 数值处理接口类
 */
public interface NumInf {
    /**
     * 检查数值是否正确
     *
     * @param num int
     * @return boolean
     */
    public boolean checkNumCurrent(int num);
}

2.多个实现类

多个实现类都实现上面的接口，重写方法。这样责任链的每个类都有一个相同的方法。

1.小于5的数值定义该数值正确或错误

package com.impl;

import com.ykq.NumInf;

/**
 * <= 5的数值处理
 */
public class FiveImpl implements NumInf {
    private NumInf nextNumImpl;

    public NumInf getNextNumImpl() {
        return nextNumImpl;
    }

    public void setNextNumImpl(NumInf nextNumImpl) {
        this.nextNumImpl = nextNumImpl;
    }

    public boolean checkNumCurrent(int num) {
        System.out.println("进入 <= 5 值的数值判断！");
        if(num <= 5){
            // 当数值小于5时，由该类处理判断是否正确
            // 此处校验规则由该类自己决定，不受其他类干涉
            if(num % 2 == 0){
                return true;
            } else {
                return false;
            }
        } else {
            return nextNumImpl.checkNumCurrent(num);
        }
    }
}

2.小于10的数值定义该数值正确或错误

package com.impl;

import com.ykq.NumInf;

/**
 * <= 10的处理
 */
public class TenImpl implements NumInf {
    private NumInf nextNumImpl;

    public NumInf getNextNumImpl() {
        return nextNumImpl;
    }

    public void setNextNumImpl(NumInf nextNumImpl) {
        this.nextNumImpl = nextNumImpl;
    }

    public boolean checkNumCurrent(int num) {
        System.out.println("进入 <= 10 值的数值判断！");
        if(num <= 10){
            // 当数值小于10时，由该类处理判断是否正确
            // 此处校验规则由该类自己决定，不受其他类干涉
            if(num % 2 == 0){
                return false;
            } else {
                return true;
            }
        } else {
            return nextNumImpl.checkNumCurrent(num);
        }
    }
}

3.小于100的数值定义该数值正确或错误

package com.impl;

import com.ykq.NumInf;

/**
 * <= 100的数值处理
 */
public class HundredImpl implements NumInf {
    private NumInf nextNumImpl;

    public NumInf getNextNumImpl() {
        return nextNumImpl;
    }

    public void setNextNumImpl(NumInf nextNumImpl) {
        this.nextNumImpl = nextNumImpl;
    }

    public boolean checkNumCurrent(int num) {
        System.out.println("进入 <= 100 值的数值判断！");
        if(num <= 100){
            // 当数值小于100时，由该类处理判断是否正确
            // 此处校验规则由该类自己决定，不受其他类干涉
            switch(num){
                case 20:
                case 30:
                case 40:
                case 50:
                case 60:
                case 70:
                case 80:
                case 90:
                    return true;
                default:
                    return false;
            }
        } else {
            return nextNumImpl.checkNumCurrent(num);
        }
    }
}

4.小于1000的数值定义该数值正确或错误

package com.impl;

import com.ykq.NumInf;

/**
 * <= 1000的数值处理
 */
public class ThousandImpl implements NumInf {
    private NumInf nextNumImpl;

    public NumInf getNextNumImpl() {
        return nextNumImpl;
    }

    public void setNextNumImpl(NumInf nextNumImpl) {
        this.nextNumImpl = nextNumImpl;
    }

    public boolean checkNumCurrent(int num) {
        System.out.println("进入 <= 1000 值的数值判断！");
        if(num <= 1000){
            // 当数值小于1000时，由该类处理判断是否正确
            // 此处校验规则由该类自己决定，不受其他类干涉
            switch(num){
                case 200:
                case 300:
                case 400:
                case 500:
                case 600:
                case 700:
                case 800:
                case 900:
                    return false;
                default:
                    return true;
            }
        } else {
            return nextNumImpl.checkNumCurrent(num);
        }
    }
}

5.更大的数值定义该数值正确或错误

package com.impl;

import com.ykq.NumInf;

/**
 * 更大的数值处理
 */
public class BiggerImpl implements NumInf {
    private NumInf nextNumImpl;

    public NumInf getNextNumImpl() {
        return nextNumImpl;
    }

    public void setNextNumImpl(NumInf nextNumImpl) {
        this.nextNumImpl = nextNumImpl;
    }

    public boolean checkNumCurrent(int num) {
        System.out.println("进入 > 1000 值的数值判断！");
        return false;
    }
}

那么实际上，对于上述责任链，我还可以继续扩充责任链的节点。小于0的方向可以扩充，大于1000的方向也可以扩充。

3.main实现

main的实现可以设置链条的每一节，这样使得责任链具有灵活性。
下面的实现，则是把上面已有的节点类，都加入了进来。
那么实际上我少一个或两个节点，对于数值的判断正误，很可能的接口就是返回的结果不一样。

package com;

import com.impl.*;
import com.ykq.NumInf;

public class MainClass {
    public static void main(String[] args){
        FiveImpl fiveImpl = new FiveImpl();
        TenImpl tenImpl = new TenImpl();
        HundredImpl hundredImpl = new HundredImpl();
        ThousandImpl thousandImpl = new ThousandImpl();
        BiggerImpl biggerImpl = new BiggerImpl();
        fiveImpl.setNextNumImpl(tenImpl);
        tenImpl.setNextNumImpl(hundredImpl);
        hundredImpl.setNextNumImpl(thousandImpl);
        thousandImpl.setNextNumImpl(biggerImpl);
        // 判断数boolean值
        System.out.println(fiveImpl.checkNumCurrent(999));
    }
}

二、变种责任链模式

我们常见的变种责任链就是过滤器。Filter提供一个接口，我们实现接口，然后通过链条的方式走到下一个过滤器。