---

前言

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

一、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<>();/***自动加载顺序*/@Autowiredpublic 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 {/*** 第一个检查**/@Overridepublic 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 {@Overridepublic String dealCorrectCypher(String str) {log.debug("----------第二个检查 start----------");log.debug("----------第二个检查 start----------");return str;}}

四、调用

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

总结

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