设计模式-责任链模式

背景说明

最近要搞一个简单的监测web心跳的逻辑，但我希望能做成通用点的，设计想法是这样的：

做一个配置，里面填weburl,还有各种校验模块,
校验模块会有多种，如httpstatus的校验，返回数据的code校验，也可能会有去查数据库的校验，甚至去调另一个接口确认其状态的校验！

流程开始时即，有一个定时器,去拿配置，发现配置里有weburl及其校验模块，然后 对校验模块的列表 进行循环处理。

同时校验时，前一个校验不OK了，后面一般也不需要继续了，所以这种模式有点像责任链，于是做了个这样的例子

设计

实际 上就是一个 抽象 类，两个实现类，后续如果要加更多的handler，参考加即可!

代码参考

抽象 的handler:

为了方便后面处理， 里面有一个方法 genHandlers(String[] validateClassArr)
根据 validateClassArr 来生成 责任链（可以用 反射的方式，不过这里实现少，就直接写出来了

public abstract class AbstractHealthMonitorReqAndJudgeHandler {

    protected AbstractHealthMonitorReqAndJudgeHandler nextHandler ;

    protected void setNextHandler(AbstractHealthMonitorReqAndJudgeHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract void doHandle(String procFlag, Object busiObj);


    /**
     * 生成责任链
     * @param validateClassArr
     * @return
     */
    public static AbstractHealthMonitorReqAndJudgeHandler genHandlers(String[] validateClassArr) {
        AbstractHealthMonitorReqAndJudgeHandler theRight = null;
        //构成责任链
        for (int i=validateClassArr.length-1;i>=0;i--) {
            // 由后往前走
            AbstractHealthMonitorReqAndJudgeHandler currentHandler = convertByVClass(validateClassArr[i]);

            //把上一个设置成当前的 下一级
            currentHandler.setNextHandler(theRight);

            // 当前被存起来
            theRight = currentHandler;
        }

        //最后留 下来的为 第一个
        return  theRight;
    }

    private static AbstractHealthMonitorReqAndJudgeHandler convertByVClass(String vClassName) {
        // netJudge,customerization
        AbstractHealthMonitorReqAndJudgeHandler tmp = null;
        if ("netJudge".equals(vClassName)) {
            tmp = new NetJudgeHandler();
        }else if ("customerization".equals(vClassName)) {
            tmp = new CustomizationHandler();
        }else{

        }
        return tmp;
    }

}

public class NetJudgeHandler extends AbstractHealthMonitorReqAndJudgeHandler {

    private static Logger log = LoggerFactory.getLogger(NetJudgeHandler.class);

    @Override
    public void doHandle(String procFlag, Object busiObj) {

        ResponseEntity<String> stringResponseEntity = (ResponseEntity<String>) busiObj;
        if(stringResponseEntity.getStatusCode().equals(HttpStatus.OK)){
            //保存
            log.info("这里进行保存,stringResponseEntity.getStatusCode()为"+stringResponseEntity.getStatusCode());
            //传递
            if (this.nextHandler != null) {
                this.nextHandler.doHandle(procFlag,busiObj);
            }
        }else{
            return;
        }
    }
}

/*
自定义的filter,如判断业务上的状态
*/
public class CustomizationHandler extends AbstractHealthMonitorReqAndJudgeHandler {

    private static Logger log = LoggerFactory.getLogger(CustomizationHandler.class);

    @Override
    public void doHandle(String procFlag, Object busiObj) {

        ResponseEntity<String> stringResponseEntity = (ResponseEntity<String>) busiObj;

        String resultStr = stringResponseEntity.getBody();
        try {
            DPageResponse<WattActivityVO> resultObj = DJsonByJacksonUtils.json2Bean(resultStr, DPageResponse.class);
            Integer total = resultObj.getTotal();
            List itemlist = resultObj.getItemList();
            //保存 TODO
            log.info("这里进行保存,total为"+total);
            if (this.nextHandler != null) {
                this.nextHandler.doHandle(procFlag,busiObj);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用:
这里 的 paramKey_web_handler_class_arr 是一个字符串, 在这里,即: netJudge,customerization
顺序是有要求的

        String[] validateClassArr = paramKey_web_handler_class_arr.split(",");

        //构成责任链
        AbstractHealthMonitorReqAndJudgeHandler firstHandler
                = AbstractHealthMonitorReqAndJudgeHandler.genHandlers(validateClassArr);

        ....//请求逻辑


        firstHandler.doHandle(procFlag,stringResponseEntity);

后记

理想中，是希望能达到 handler更加通用，但感觉处理的时候更多是自定义的逻辑!
加上 责任链 会让条理更加清楚，但通用模块化可能还并不明朗，先用着吧.