使用责任链模式 构建自己的过滤器

1.责任链模式
通过将耦合在一起的业务逻辑分离开，达到解耦效果。
2.代码：

责任链抽象类

public abstract class Handler {
    /**
     * 存储处理器的队列
     */
    public static BlockingQueue<Handler> localQueue = new ArrayBlockingQueue<>(10);

    /**
     * 指向下一个处理器的指针
     */
    public Handler nexthandler;


    /**
     * 添加处理器
     *
     * @param handler
     */
    public static void addHandler(Handler handler) {
        localQueue.offer(handler);
    }

    /**
     * 加载处理器 形成责任链
     */
    public static void loadHandler() {
        Handler head = localQueue.poll();
        int size = localQueue.size();
        for (int i = 1; i <= size; i++) {
            Handler poll = localQueue.poll();
            head.nexthandler = poll;
            head = poll;
        }
    }

    /**
     * 递归执行各个过滤器
     *
     * @param msg
     * @return
     */
    public String doHanle(String msg) {
        //压栈执行 保证按处理器顺序执行 结果带到下一个栈帧
        String result = handleTask(msg);
        if (null != nexthandler) {
            result = nexthandler.doHanle(result);
        }
        return result;
    }

    /**
     * 规定各个处理器的执行接口
     *
     * @param msg
     * @return
     */
    protected abstract String handleTask(String msg);
}

拦截器1

public class Intercepter extends Handler {
    @Override
    protected String handleTask(String msg) {
        String s = msg.toLowerCase();
        System.out.println("过滤器1,转为小写，执行结果"+s);
        return s;
    }
}

拦截器2

public class Intercepter2 extends Handler {
    @Override
    protected String handleTask(String msg) {
        String s = msg.substring(0, 1).toUpperCase() + msg.substring(1);
        System.out.println("过滤器2,大写首字母，执行结果:"+s);
        return s;
    }
}

封装初始化过程

public class InitializeHanler {
    /**
     * 责任链头部
     */
    private static  Handler firstHandler;

    /**
     * 将拦截器实例添加
     *
     * @param hanlers
     * @param <T>
     */
    public  static  <T extends Handler> void buildHandlerChain(T... hanlers) {
        for (T t : hanlers) {
            if(null==firstHandler){
                firstHandler=t;
            }
            Handler.addHandler(t);
        }
        Handler.loadHandler();
    }

    /**
     * 从头部开始执行责任链
     *
     * @param msg
     */
    public static void doHandle(String msg){
        firstHandler.doHanle(msg);
    }

}

配置

@Configuration
public class Config {
    @Bean
    public void Init(){
        InitializeHanler.buildHandlerChain(addIntercepter1(),addIntercepter2());
        System.out.println("拦截器初始化构建完成");
    }

    @Bean
    public Intercepter addIntercepter1(){
        return new Intercepter();
    }

    @Bean
    public Intercepter2 addIntercepter2(){
        return new Intercepter2();
    }
}

测试：

@RunWith(SpringRunner.class)
@SpringBootTest
public class DemoApplicationTests {

	@Test
	public void contextLoads() {
		InitializeHanler.doHandle("AJSDBASB");
	}

}

测试结果：