设计模式:学习责任链模式

责任链模式

定义

为了避免"请求者"和"处理请求着"耦合在一起.可将所有请求者组合在一起形成一个链条,当一个请求发出之后,可以顺着这个链条,找到真正的处理者

结构

抽象处理者:定义一个处理请求的接口,包含抽象的处理方法
具体处理者:继承抽象处理者,实现具体的处理方法,并继续传递请求
客户端:用来创建链条,也可以用工厂模式来创建链条

实现

package org.bana.white.common.service;

import lombok.Data;
import lombok.Getter;
import lombok.Setter;

/**
 * @author ly
 * @version 1.0.0
 */
@Setter
@Getter
public abstract class DutyHandler {
    private DutyHandler next;

    /**
     * 请假接口
     * @param message
     * @param day
     * @return
     */
    public abstract boolean dutyHandler(String message,int day);

    /**
     * 添加下一个策略
     * @param handler
     * @return
     */
    public DutyHandler nextHandler(DutyHandler handler){
        this.next=handler;
        return this;
    }

}

package org.bana.white.common.service.impl;

import org.bana.white.common.service.DutyHandler;

/**
 * @author ly
 * @version 1.0.0
 */
public class ProcessorOne extends DutyHandler {

    private ProcessorOne() {
    }

    private static final class Instance{
        private static final ProcessorOne INSTANCE=new ProcessorOne();
    }

    public static ProcessorOne getInstance(){
        return Instance.INSTANCE;
    }


    @Override
    public boolean dutyHandler(String message, int day) {
        System.out.println("处理请求：" + message);
        System.out.println("请假天数：" + day);
        if (day <= 1) {
            System.out.println("开发经理审批通过");
            return true;
        } else {
            System.out.println("请假天数大于一天，开发经理无法处理，交给项目经理处理");
            DutyHandler handler=getNext();
            System.out.println("=====================================");
            return handler.dutyHandler(message, day);
        }
    }
}

package org.bana.white.common.service.impl;

import org.bana.white.common.service.DutyHandler;

/**
 * @author ly
 * @version 1.0.0
 */
public class ProcessorTwo extends DutyHandler {

    private ProcessorTwo() {
    }

    private static final class Instance{
        private static final ProcessorTwo INSTANCE=new ProcessorTwo();
    }

    public static ProcessorTwo getInstance(){
        return Instance.INSTANCE;
    }

    @Override
    public boolean dutyHandler(String message, int day) {
        System.out.println("处理请求：" + message);
        System.out.println("请假天数：" + day);
        if (day <= 10) {
            System.out.println("项目经理审批通过");
            return true;
        } else {
            System.out.println("请假天数大于十天，项目经理无法处理，交给总记录处理");
            DutyHandler next = getNext();
            System.out.println("=====================================");
            return next.dutyHandler(message, day);
        }
    }
}

package org.bana.white.common.service;

import org.bana.white.common.service.impl.ProcessorOne;
import org.bana.white.common.service.impl.ProcessorTwo;
import org.springframework.stereotype.Component;

/**
 * @author ly
 * @version 1.0.0
 */
@Component
public class DutyHandlerFactory {
    public DutyHandler create(){
        return ProcessorOne.getInstance().nextHandler(ProcessorTwo.getInstance());
    }
}

public void demo(String name) {
        DutyHandler handler = handlerFactory.create();
        handler.dutyHandler("张三提交请假审批", 10);
    }

这里使用了单例模式创建链条,以减少开销

函数式责任链

因为使用责任链模式,如果实现者过多会造成类爆炸,会有很多个实现类,但是有可能每个实现类只是很简单的一个逻辑,所以可以使用方法来代替类

package org.bana.white.common.service;

import lombok.Getter;
import lombok.Setter;

/**
 * 函数链信息
 *
 * @author ly
 * @version 1.0.0
 */
@Getter
@Setter
public class FunctionChainInfo<T> {

    /**
     * 下一个节点是否执行标志
     */
    private boolean nextFlag;

    /**
     * 节点处理数据(可以是原值,也可以是每个节点处理完返回的数据,供给下游的处理器使用)
     */
    private T data;

}

package org.bana.white.common.service;

import java.util.function.Function;

/**
 * @author ly
 * @version 1.0.0
 */
public class FunctionHandler {

    public static void main(String[] args) {
        boolean b = create(10);
    }

    public static boolean create(int day) {
        FunctionChainInfo<Boolean> chainInfo = new FunctionChainInfo<>();
        chainInfo.setData(false);
        Function<Integer, Boolean> integerBooleanFunction = processorOne(chainInfo)
                .andThen(aBoolean -> chainInfo.isNextFlag() ? aBoolean : processorTwo(chainInfo).apply(day));
        return integerBooleanFunction.apply(day);
    }

    public static Function<Integer, Boolean> processorOne(FunctionChainInfo<Boolean> chainInfo) {
        return integer -> {
            if (integer <= 1) {
                // 设置下一个节点无需停止处理
                chainInfo.setNextFlag(true);
                System.out.println("开发经理审批通过");
                return true;
            } else {
                // 如果不满足,返回入参给下一个处理器使用
                return chainInfo.getData();
            }
        };
    }

    public static Function<Integer, Boolean> processorTwo(FunctionChainInfo<Boolean> chainInfo) {
        return integer -> {
            if (integer <= 15) {
                // 设置下一个节点无需停止处理
                chainInfo.setNextFlag(true);
                System.out.println("项目经理审批通过");
                return true;
            } else {
                // 如果不满足,返回入参给下一个处理器使用
                return chainInfo.getData();
            }
        };
    }
}