设计模式之责任链模式详解

   最近发现项目中有一个接口中使用if{}else{}达到7个之多，导致这个接口代码量达到500多行，所以想着怎么让这代码优雅一些，于是就想到了使用设计模式-责任链模式，保密原因，只贴出demo代码，说明直接看代码

//公共抽象类，本来预计只是想处理一个单项链表的，后来手痒，形成一个简单的双向链表了
//实际开发，根据需求完成即可
public abstract class Handler {

    protected Handler nexthandler;

    protected Handler prehandler;

    public Handler getNexthandler() {
        return nexthandler;
    }

    public void setNexthandler(Handler nexthandler) {
        this.nexthandler = nexthandler;
    }

    public Handler getPrehandler() {
        return prehandler;
    }

    public void setPrehandler(Handler prehandler) {
        this.prehandler = prehandler;
    }

    public void setNexthanlder(Handler nexthandler){
        this.nexthandler=nexthandler;
    }


    public abstract void handlerRequest(RequestBean bean);


}

//按照最初的想法，我想手动设置每个链子的下面节点，但是考虑到，如果可以拿到所有的抽象类的子类
//那么我们给他们系统自动排序，这样就算我们后续增加了chain，只需要增加chain，而不需要改动其他地方
//这个类为静态工厂类，用于获取chain，并吧他们形成一个链子
public class HandlerStaticFactory {
    private static List<Class<? extends Handler>> list = Lists.newArrayList();

    static {
        //获取该路径下所有类，我们吧所有的类放到一个包下面，然后通过反射得到报下所有类
        Reflections reflections = new Reflections("com.demo.***.***.***");
        //获取继承了Handler的所有类
        Set<Class<? extends Handler>> classSet = reflections.getSubTypesOf(Handler.class);
        list.addAll(classSet);
    }

    /**
     * 获取某一个类下面的所有子类，然后把它们组装成一个双向链表
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public Handler getChain() throws IllegalAccessException, InstantiationException {
        Handler handler = null;
        for (Class<? extends Handler> cls:list) {
            Handler handler1 = null;
            if (null == handler) {
                handler = cls.newInstance();
                handler.setPrehandler(null);
                continue;
            } else {
                handler1 = cls.newInstance();
                handler1.setPrehandler(handler);
                handler1.setNexthandler(null);
                handler.setNexthandler(handler1);
                handler = handler1;
            }
        }
        return handler;
    }

   /* public static Handler createChain1() {
        return new RequestChain1();
    }

    public static Handler createChain2() {
        return new RequestChain2();
    }

    public static Handler createChain3() {
        return new RequestChain3();
    }*/
}

demo嘛，就贴一个链子，大家看看就好

//当这个是我们要处理逻辑的类是，直接处理，如果不是，拿下一个类继续处理，如果下一个没有，也可以定义默认处理逻辑
public class RequestChain1 extends Handler {
    @Override
    public void handlerRequest(RequestBean bean) {
        if ("1".equals(bean.getIntefaceType())){
          System.out.println("111111111111111");
          return;
        }
        if (null != prehandler){
            System.out.println(RequestChain1.class.toString());
            prehandler.handlerRequest(bean);
        } else {
            System.out.println("默认处理");
        }
    }

}

测试类：

public class ChainTest {

    @Test
    public void test1() throws InstantiationException, IllegalAccessException {
        RequestBean bean = new RequestBean();
        bean.setIntefaceType("3");
        HandlerStaticFactory factory = new HandlerStaticFactory();
        factory.getChain().handlerRequest(bean);
    }
}

 

上面则是一个简单的责任链模式送给大家，因为想偷懒，用到了反射，用到了链表

最后告诉大家，后面觉得责任链模式，并不是最优的解决我们项目的方法，所以并没有使用，二是借鉴了它，当然我觉得上面的demo并不是解析责任链模式的最优demo，因为它虽然低耦合了，也拆分了，代码也优雅多了，但是如果链子过长，那就会创造N多的对象，当然这不是我们想要的，因为这会浪费内存（个人臆想）；

写在最后：

     作为一个不到2年的大龄码农，学习的目的就是像那个28岁就退休，实现财务*的人一样。

     个人感觉写代码需要有成就感，每次感觉到自己学到东西之后，就会特有成就感，就会特有学习的欲望，接下来的一段时间就会一直有学习的动力，相互下来，有动力就会有学习到技术，学习到技术就会有成就感，有成就感就又学习的动力...........哈哈

本文地址：https://blog.csdn.net/weixin_42508041/article/details/107089978