责任链模式
- 前言
- [一、CypherCorrectionHandler 提供入口](#一、CypherCorrectionHandler 提供入口)
- [二、AbstractCorrectionHandler 抽象类](#二、AbstractCorrectionHandler 抽象类)
- [三、check 实现类](#三、check 实现类)
- 四、调用
- 总结
前言
就是记录下,方便自己工作用。
含责任链顺序加载,以及抽象调度链路。
一、CypherCorrectionHandler 提供入口
java
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 抽象类
java
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 实现类
第一个检查
java
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;
}
}
第二个检查
java
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;
}
}
四、调用
java
@Resource
private CypherCorrectionHandler cypherCorrectionHandler;
//调用责任链
str= cypherCorrectionHandler.correctCypher(str);
总结
重点在CypherCorrectionHandler和AbstractCorrectionHandler这两个类。剩下的实现类反而是最简单的。