设计模式（一）责任链模式

背景1：

员工请事假时，

0-1天，直属领导审批

1-3天，部门经理审批

3-30天，总经理审批

30天以上，原则上不批

在审批流程中，不同的条件对应的不同的审批人。有一组对象处理一个请求

举个栗子：fitler过滤链

 

package com.shunteng.gof;

/**
 * @Description 责任链设计模式
 * @Author GCL
 * @Date 2020/7/3 上午11:24
 */
public class ChainOfResposityTest {

    public static void main(String[] args) {
        LeaveRequest leaveRequest = new LeaveRequest("咚咚锵",20);
        AbstractLeaveHandler directLeaderLeaveHandler = new DirectLeaderLeaveHandler("小明");
        AbstractLeaveHandler deptManagerLeaveHandler = new DeptManagerLeaveHandler("小花");
        AbstractLeaveHandler gManagerLeaveHandler = new GManagerLeaveHandler("小钟");
        directLeaderLeaveHandler.setNextHandler(deptManagerLeaveHandler);
        deptManagerLeaveHandler.setNextHandler(gManagerLeaveHandler);
        directLeaderLeaveHandler.handlerRequest(leaveRequest);
    }
}

/**
 * @Description: 员工请假申请类
 */
class LeaveRequest {
    private String name;
    private Integer leaveDay;

    public LeaveRequest(String name, Integer leaveDay) {
        this.name = name;
        this.leaveDay = leaveDay;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getLeaveDay() {
        return leaveDay;
    }

    public void setLeaveDay(Integer leaveDay) {
        this.leaveDay = leaveDay;
    }
}

/**
 * @Description: 请假处理抽象类
 */
abstract class AbstractLeaveHandler {

    protected int min = 1;

    protected int middle = 3;

    protected int max = 30;

    protected String handlerName;

    protected AbstractLeaveHandler nextHandler;

    /**
     * @Description: 设置下一节点处理
     */
    protected void setNextHandler(AbstractLeaveHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    protected void handlerRequest(LeaveRequest leaveRequest) {

    }

}

/**
 * @Description: 直接主管处理请假类
 */
class DirectLeaderLeaveHandler extends AbstractLeaveHandler {
    public DirectLeaderLeaveHandler(String name){
        this.handlerName=name;
    }

    @Override
    protected void handlerRequest(LeaveRequest leaveRequest) {
        super.handlerRequest(leaveRequest);
        if (leaveRequest.getLeaveDay() > 0 && leaveRequest.getLeaveDay() <= this.min) {
            System.out.println("直接主管:" + handlerName + ",已经处理;流程结束。");
            return;
        }
        if(null!=this.nextHandler){
            this.nextHandler.handlerRequest(leaveRequest);
        }else{
            System.out.println("审核被拒绝");
        }
    }
}

/**
 * @Description: 部门经理处理请假类
 */
class DeptManagerLeaveHandler extends AbstractLeaveHandler{
    public DeptManagerLeaveHandler(String name){
        this.handlerName=name;
    }

    @Override
    protected void handlerRequest(LeaveRequest leaveRequest) {
        super.handlerRequest(leaveRequest);
        if (leaveRequest.getLeaveDay() > this.min && leaveRequest.getLeaveDay() <= this.middle) {
            System.out.println("部门经理:" + handlerName + ",已经处理;流程结束。");
            return;
        }
        if(null!=this.nextHandler){
            this.nextHandler.handlerRequest(leaveRequest);
        }else{
            System.out.println("审核被拒绝");
        }
    }
}

/**
 * @Description: 总经理处理请假类
 */
class GManagerLeaveHandler extends AbstractLeaveHandler{
    public GManagerLeaveHandler(String name){
        this.handlerName=name;
    }

    @Override
    protected void handlerRequest(LeaveRequest leaveRequest) {
        super.handlerRequest(leaveRequest);
        if (leaveRequest.getLeaveDay() > this.middle && leaveRequest.getLeaveDay() <= this.max) {
            System.out.println("部门经理:" + handlerName + ",已经处理;流程结束。");
            return;
        }
        if(null!=this.nextHandler){
            this.nextHandler.handlerRequest(leaveRequest);
        }else{
            System.out.println("审核被拒绝");
        }
    }
}

背景2：

记录不同级别日志，

INFO级别日志 level=0

DEBUGGER级别日志levle=1

ERROR级别日志levle=2

FATAL级别日志levle=3

 

设计：

假设被操作对象为Log

抽象类及多个子类

抽象类包含方法：持有AbstractHandler对象，及setNextHandler(AbstractHandler handler)  operate(Log logger)及其他方法

 

package com.shunteng.gof;

/**
 * @Description 日志记录责任链
 * @Author GCL
 * @Date 2020/7/3 下午1:56
 */
public class LogChainOfResposityTest {
    public static void main(String[] args) {
        Logger log = new Logger(1, "NullPointException");
        AbstractLoggerHandler infoLogger = new InfoLogger(0);
        AbstractLoggerHandler debuggerLogger = new DebuggerLogger(1);
        AbstractLoggerHandler errorLogger = new ErrorLogger(2);
        AbstractLoggerHandler fatalLogger = new FatalLogger(3);
        infoLogger.setNextLogger(debuggerLogger);
        debuggerLogger.setNextLogger(errorLogger);
        errorLogger.setNextLogger(fatalLogger);
        infoLogger.write(log);
    }
}

/**
 * @Description: 日志类
 */
class Logger {
    private Integer level;
    private String msg;

    public Logger(Integer level, String msg) {
        this.level = level;
        this.msg = msg;
    }

    public Integer getLevel() {
        return level;
    }

    public void setLevel(Integer level) {
        this.level = level;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

/**
 * @Description: 抽象日志处理类
 */
abstract class AbstractLoggerHandler {
    protected final Integer INFO = 0;
    protected final Integer DEBUGGER = 1;
    protected final Integer ERROR = 2;
    protected final Integer FATAL = 3;
    protected Integer level;
    protected AbstractLoggerHandler nextLoggerHandler;

    public AbstractLoggerHandler(Integer level) {
        this.level = level;
    }

    /**
     * @Description: 发送至下一节点
     */
    protected void setNextLogger(AbstractLoggerHandler nextLoggerHandler) {
        this.nextLoggerHandler = nextLoggerHandler;
    }

    /**
     * @Description: 写入日志
     */
    protected void write(Logger logger) {

    }

    /**
     * @Description: 日志详情
     */
    protected void logMessage(String log) {

    }
}

/**
 * @Description: 提醒级别日志处理类
 */
class InfoLogger extends AbstractLoggerHandler {

    public InfoLogger(Integer level) {
        super(level);
    }

    @Override
    protected void write(Logger logger) {
        if (this.INFO.equals(logger.getLevel())) {
            System.out.println("[INFO]日志已写入text");
            logMessage(logger.getMsg());
            return;
        }
        if (null != this.nextLoggerHandler) {
            this.nextLoggerHandler.write(logger);
        } else {
            System.out.println("INFO日志记录完毕");
        }
    }

    @Override
    protected void logMessage(String log) {
        System.out.println("[INFO]日志信息为：" + log);
    }
}

/**
 * @Description: 错误级别日志处理类
 */
class ErrorLogger extends AbstractLoggerHandler {

    public ErrorLogger(Integer level) {
        super(level);
    }

    @Override
    protected void write(Logger logger) {
        if (this.ERROR.equals(logger.getLevel())) {
            System.out.println("[ERROR]日志已写入text");
            logMessage(logger.getMsg());
            return;
        }
        if (null != this.nextLoggerHandler) {
            this.nextLoggerHandler.write(logger);
        } else {
            System.out.println("ERROR日志记录完毕");
        }
    }

    @Override
    protected void logMessage(String log) {
        System.out.println("[ERROR]日志信息为：" + log);
    }
}

/**
 * @Description: 调试级别日志处理类
 */
class DebuggerLogger extends AbstractLoggerHandler {


    public DebuggerLogger(Integer level) {
        super(level);
    }

    @Override
    protected void write(Logger logger) {
        if (this.DEBUGGER.equals(logger.getLevel())) {
            System.out.println("[DEBUFFER]日志已写入text");
            logMessage(logger.getMsg());
            return;
        }
        if (null != this.nextLoggerHandler) {
            this.nextLoggerHandler.write(logger);
        } else {
            System.out.println("DEBUGGER日志记录完毕");
        }
    }

    @Override
    protected void logMessage(String log) {
        System.out.println("[DEBUFFER]日志信息为：" + log);
    }
}

/**
 * @Description: 严重级别日志处理类
 */
class FatalLogger extends AbstractLoggerHandler {

    public FatalLogger(Integer level) {
        super(level);
    }

    @Override
    protected void setNextLogger(AbstractLoggerHandler abstractLoggerHandler) {

    }

    @Override
    protected void write(Logger logger) {
        if (this.FATAL.equals(logger.getLevel())) {
            System.out.println("[FATAL]日志已写入text");
            logMessage(logger.getMsg());
            return;
        }
        if (null != this.nextLoggerHandler) {
            this.nextLoggerHandler.write(logger);
        } else {
            System.out.println("FATAL日志记录完毕");
        }
    }

    @Override
    protected void logMessage(String log) {
        System.out.println("[FATAL]日志信息为：" + log);
    }
}