nosum-support/easy-chain-boot-starter/src/main/java/cn/nosum/support/processor/ResponsibilityChainProcessor.java

package cn.nosum.support.processor;

import cn.nosum.support.chain.BaseResponsibilityChainHandler;
import cn.nosum.support.chain.Processor;
import cn.nosum.support.chain.ResponsibilityChainException;
import cn.nosum.support.chain.ResponsibilityChainHandlerFactory;
import cn.nosum.support.core.utils.CheckUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import java.util.function.Predicate;

/**
 * 负责生产责任链中的节点。
 *
 * @author Young
 */
@Slf4j
public class ResponsibilityChainProcessor<T extends Processor> {

    /**
     * 处理链
     */
    private final Map<String, List<BaseResponsibilityChainHandler<T>>> MULTI_CHAINS = new ConcurrentHashMap<>(64);

    /**
     * 添加处理节点到链路中，会根据返回的值决定是否继续执行链
     *
     * @param hitPredicate  提供给外部注册的判断是否命中当前责任链节点的逻辑块
     * @param handleAction  提供给外部注册的责任链上下文处理的逻辑块, 返回值为true时，将会继续执行下一个节点
     */
    protected void addChain(String name, Predicate<T> hitPredicate,
                         Predicate<T> handleAction, int order, String groupName) {

        verification(hitPredicate, handleAction);
        BaseResponsibilityChainHandler<T> chain;
        chain = new BaseResponsibilityChainHandler<T>(name, hitPredicate, handleAction, null);
        setNodeAndSort(order, groupName, chain);
    }

    /**
     * 添加处理节点到链路中，用户无法干预链表的执行，会一直执行结束
     *
     * @param hitPredicate 提供给外部注册的判断是否命中当前责任链节点的逻辑块
     * @param handleAction 提供给外部注册的责任链上下文处理的逻辑块,
     */
    protected void addChainFromConsumer(String name, Predicate<T> hitPredicate,
                                     Consumer<T> handleAction, int order, String groupName) {

        verification(hitPredicate, handleAction);
        BaseResponsibilityChainHandler<T> chain;
        chain = ResponsibilityChainHandlerFactory.generate(name, hitPredicate, (context) -> {
            handleAction.accept(context);
            return true;
        }, null);

        setNodeAndSort(order, groupName, chain);
    }

    /**
     * 往组中放入节点并且排序
     *
     * @param order     排序
     * @param groupName 组名
     * @param chain     链中的节点
     */
    private void setNodeAndSort(int order, String groupName, BaseResponsibilityChainHandler<T> chain) {

        List<BaseResponsibilityChainHandler<T>> chains = MULTI_CHAINS.get(groupName);
        if (CollectionUtils.isEmpty(chains)) {
            chains = new ArrayList<>();
            MULTI_CHAINS.put(groupName, chains);
        }

        chain.setSort(order);
        if (!chains.isEmpty()) {
            // 存在相同的顺序的接口直接返回
            chains.forEach(a -> {
                if (a.getSort() == order) {
                    throw new ResponsibilityChainException(String.format("节点:[%s]与节点:[%s] order:[%s]相同", a.getName(), chain.getName(), order));
                }
            });

            chains.get(chains.size() - 1).setNext(chain);
        }

        chains.add(chain);

        // 排序
        sort(chains);
    }

    /**
     * 转换器
     *
     * @param source 源节点
     * @param target 目标节点
     */
    private static <T extends Processor> void covert(BaseResponsibilityChainHandler<T> source, BaseResponsibilityChainHandler<T> target) {
        target.setSort(source.getSort());
        target.setHandleAction(source.getHandleAction());
        target.setHitPredicate(source.getHitPredicate());
        target.setId(source.getId());
        target.setName(source.getName());
    }

    /**
     * 链表排序
     *
     * @param chains 执行链
     */
    private void sort(List<BaseResponsibilityChainHandler<T>> chains) {
        BaseResponsibilityChainHandler<T> temp, p;
        for (int i = 0; i < chains.size(); i++) {
            p = chains.get(0);
            for (int j = 0; j < chains.size() - i; j++) {
                CheckUtil.checkNotNull(p,"chains is null,check your configuration!!");
                if (p.getNext() != null && p.getSort() > p.getNext().getSort()) {
                    temp = new BaseResponsibilityChainHandler<>(p.getName(), p.getHitPredicate(), p.getHandleAction(), p.getNext());
                    temp.setSort(p.getSort());
                    covert(p.getNext(), p);
                    covert(temp, p.getNext());
                }
                p = p.getNext();
            }
        }
    }

    /**
     * 责任链上下文处理
     *
     * @param context {@link T} 当前处理的上下文信息
     */
    public void handle(T context, String groupName) {
        List<BaseResponsibilityChainHandler<T>> chains = MULTI_CHAINS.get(groupName);
        if (chains.isEmpty()) {
            return;
        }

        context.clearLog();
        chains.get(0).handle(context);
    }

    /**
     * 校验参数
     */
    private <THandleAction> void verification(Predicate<T> hitPredicate,
                                              THandleAction handleAction) {
        if (hitPredicate == null) {
            throw new IllegalArgumentException("hitPredicate");
        }

        if (handleAction == null) {
            throw new IllegalArgumentException("handleAction");
        }
    }

}