责任链模式-升级版

前言

就是记录下，方便自己工作用。
含责任链顺序加载，以及抽象调度链路。

一、CypherCorrectionHandler 提供入口

import com.wonders.cube.sdk.graph.constant.NumberConstant;
import com.wonders.cube.sdk.graph.handler.correctcypher.impl.AbstractCorrectionHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 数据纠错链管理类
 *
 * @author lobster.long
 */
@Slf4j
@Component
public class CypherCorrectionHandler {

    // 责任链中的处理器优先级排序集合
    private List<Integer> orders = new ArrayList<>();
    // 责任链的处理类集合
    private final Map<Integer, AbstractCorrectionHandler> handlerList = new LinkedHashMap<>();
	
	/**
	*自动加载顺序
	*/
    @Autowired
    public CypherCorrectionHandler(ApplicationContext applicationContext) {
        Map<String, AbstractCorrectionHandler> beansOfType = applicationContext.getBeansOfType(AbstractCorrectionHandler.class);
        beansOfType.values().forEach(x -> {
            Class<? extends AbstractCorrectionHandler> aClass = x.getClass();
            int order = aClass.getAnnotation(Order.class).value();
            try {
                handlerList.put(order, aClass.newInstance());
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        orders = handlerList.keySet().stream().sorted().collect(Collectors.toList());
        // 指定处理器的下一个处理器实例
        handlerList.forEach((k, v) -> {
            int size = orders.size() - 1;
            int index = orders.indexOf(k);
            if (size > index) {
                v.setNextHandler(handlerList.get(orders.get(index + 1)));
            }
        });
    }
	
	/**
	* 入口方法
	*/
    public String correctCypher(String cypher, String communityCode) {
        return handlerList.get(NumberConstant.ONE).correctCypher(cypher, communityCode);
    }

}

二、AbstractCorrectionHandler 抽象类

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;

/**
 * 数据纠错处理器
 */
@Slf4j
public abstract class AbstractCorrectionHandler {

    private AbstractCorrectionHandler handler;

    public void setNextHandler(AbstractCorrectionHandler handler) {
        this.handler = handler;
    }

    /**
     * 抽象方法，不同的检查
     * @param str 需要进行check的参数，可以是字符串、也可以是对象
     */
    public abstract String dealCheck(String str);

    public String check(String str) {
        String result = str;
        try {
            result = dealCheck(result, communityCode);
            if (ObjectUtils.isNotEmpty(this.handler)) {
                result = this.handler.check(result);
            }
        } catch (Exception e) {
            log.error("责任链异常，直接退出", e);
        }
        return result;
    }

}

三、check 实现类

第一个检查

import com.wonders.cube.sdk.graph.constant.NumberConstant;
import com.wonders.cube.sdk.graph.constant.RegexConstant;
import com.wonders.cube.sdk.graph.constant.StringConstant;
import com.wonders.cube.sdk.graph.enums.GraphRelationEnum;
import com.wonders.cube.sdk.graph.utils.RegexUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 修正边
 *
 * @author lobster.long
 */
@Order(1)
@Slf4j
@Service
public class CorrectDirectHandler extends AbstractCorrectionHandler {
    /**
     * 第一个检查
     *
     */
    @Override
    public String dealCorrectCypher(String str) {
        log.debug("----------第一个检查 start----------");
        log.debug("----------第一个检查 end----------");
        return str;
    }
  }

第二个检查

import com.wonders.cube.sdk.graph.constant.RegexConstant;
import com.wonders.cube.sdk.graph.utils.RegexUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Service;

/**
 * @author lobster.long
 */
@Slf4j
@Order(2)
@Service
public class CorrectLabelHandler extends AbstractCorrectionHandler {

    @Override
    public String dealCorrectCypher(String str) {
        log.debug("----------第二个检查 start----------");
       
        log.debug("----------第二个检查 start----------");
        return str;
    }

}

四、调用

   @Resource
   private CypherCorrectionHandler cypherCorrectionHandler;
   
  //调用责任链
   str= cypherCorrectionHandler.correctCypher(str);

总结

重点在CypherCorrectionHandler和AbstractCorrectionHandler这两个类。剩下的实现类反而是最简单的。