责任链模式
什么是责任链模式
责任链模式：为请求创建了一个接收者对象的链。
即将多个操作组装成一条链路进行处理。请求在链路上传递，链路上的每一个节点就是一个处理器，每个处理器都可以对请求进行处理，或者传递给链路上的下一个处理器处理
在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。
应用场景
1、操作需要经过一系列的校验，通过校验后才执行某些操作。
如网关请求，每一个处理校验都可以作为一个单独的处理器，抽离为一个单独的类，便于复用。
这些处理器形成一条链式调用，请求在处理器链上传递，如果校验条件不通过，则处理器不再向下传递请求，直接返回错误信息；若所有的处理器都通过校验，则执行后续的处理逻辑
2、工作流。企业中通常会制定很多工作流程，一级一级的去处理任务
责任链模式的实现
1、AbstractHandler表示处理器抽象类，负责抽象处理器行为。实际的处理器全部继承该抽象类
public abstract class AbstractHandler {
/**
* 当前处理器持有下一个处理器的引用
*/
protected AbstractHandler nextHandler;
/**
* 处理器动态配置
* 当前处理器的执行条件
*/
protected HandlerConfig handlerConfig;
/**
* 处理器执行
*
* @param param 根据具体的业务传参，也可以将参数放在请求上下文中，也可以是具体的参数类
* @return
*/
public abstract HandleResult handle(Map<String, Object> param);
/**
* 链路传递
* 当前处理器执行完毕时，便调用nextHandler执行下一处理器的handle()校验方法
*
* @param param
* @return
*/
protected HandleResult next(Map<String, Object> param) {
//下一个链路没有处理器了，直接返回
if (Objects.isNull(nextHandler)) {
return HandleResult.success();
}
//执行下一个处理器
return nextHandler.handle(param);
}
... getter and setter
}2、HandlerConfig 表示处理器配置
以通过“配置中心”动态修改该配置，实现处理器的“动态编排”和“顺序控制”。配置类中可以配置处理器的名称、下一个处理器、以及处理器是否降级等属性
如果处理器配置了降级，则跳过该处理器，调用super.next()执行下一个处理器逻辑
public class HandlerConfig {
/**
* 处理器Bean名称
*/
private String handler;
/**
* 下一个处理器配置
*/
private HandlerConfig next;
/**
* 是否降级，配置了降级则跳过该处理器
*/
private Boolean down = Boolean.FALSE;
... getter and setter
}3、HandleResult 处理结果
查看代码
public class HandleResult {
private Integer code = 0;
private String message = "success";
@JsonInclude(JsonInclude.Include.NON_EMPTY)
private Object data;
public HandleResult() {
}
public HandleResult(ResponseEnum response) {
this.code = response.getCode();
this.message = response.getMessage();
}
public HandleResult(Object data) {
this.data = data;
}
public HandleResult fail(ResponseEnum response) {
this.code = response.getCode();
this.message = response.getMessage();
return this;
}
@JsonIgnore
public boolean isSuccess() {
return ResponseEnum.SUCCESS.getCode().equals(code);
}
}ResponseEnum：处理返回枚举
查看代码
public enum ResponseEnum {
/**
* 成功
*/
SUCCESS(0, "success"),
/**
* 参数错误
*/
PARAM_ERROR(2, "param error"),
/**
* 签名错误
*/
SIGN_ERROR(3, "sign error"),
/**
* 未知错误
*/
UNKNOWN_ERROR(9999, "unknown error");
private final Integer code;
private final String message;
ResponseEnum(Integer code, String message) {
this.code = code;
this.message = message;
}
public Integer getCode() {
return code;
}
public String getMessage() {
return message;
}4、HandlerRunner 执行处理器链
/**
* 执行处理器链
* @param handler
* @param param
* @return
*/
public static HandleResult executeChain(AbstractHandler handler, Map<String,Object> param) {
//执行处理器
HandleResult handlerResult = handler.handle(param);
if (!handlerResult.isSuccess()) {
System.out.println("HandlerClient 责任链执行失败返回：" + handlerResult.toString());
return handlerResult;
}
return HandleResult.success();
}加载配置，触发处理器链路执行
@Component
public class HandlerRunner implements ApplicationContextAware {
/**
* 全部的处理器
*/
private static final Map<String, AbstractHandler> HANDLER_MAP = new ConcurrentHashMap<>();
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
// 加载并注册处理器
Map<String, AbstractHandler> handlerMap = applicationContext.getBeansOfType(AbstractHandler.class);
for (Map.Entry<String, AbstractHandler> entry : handlerMap.entrySet()) {
// 注册处理器
HANDLER_MAP.put(entry.getKey(), entry.getValue());
}
}
/**
* 根据配置组装处理器链路，并触发链路执行
*
* @param param
* @return
*/
public HandleResult run(Map<String, Object> param) {
//获取处理器配置：通常配置使用统一配置中心存储，支持动态变更
HandlerConfig handlerConfig = this.getHandlerConfigFile();
//获取处理器
AbstractHandler handler = this.assembleHandler(handlerConfig);
//责任链：执行处理器链路
HandleResult executeChainResult = executeChain(handler, param);
if (!executeChainResult.isSuccess()) {
System.out.println("创建商品 失败...");
return executeChainResult;
}
//处理器链路全部成功
return HandleResult.success();
}
/**
* 根据配置组装处理器链
*
* @param handlerConfig
* @return
*/
private AbstractHandler assembleHandler(HandlerConfig handlerConfig) {
//配置检查：没有配置处理器链路，则不执行校验逻辑
if (Objects.isNull(handlerConfig)) {
return null;
}
//配置错误
String handler = handlerConfig.getHandler();
if (StringUtils.isBlank(handler)) {
return null;
}
//配置了不存在的处理器
AbstractHandler abstractHandler = HANDLER_MAP.get(handlerConfig.getHandler());
if (Objects.isNull(abstractHandler)) {
return null;
}
//处理器设置配置Config
abstractHandler.setHandlerConfig(handlerConfig);
//递归设置链路处理器
abstractHandler.setNextHandler(this.assembleHandler(handlerConfig.getNext()));
return abstractHandler;
}
/**
* 获取处理器链路配置
*
* @return
*/
private HandlerConfig getHandlerConfigFile() {
//配置中心存储的配置
String configJson = "{\"handler\":\"nullValueCheckHandler\",\"down\":true,\"next\":{\"handler\":\"priceCheckHandler\",\"next\":{\"handler\":\"stockCheckHandler\",\"next\":null}}}";
//转成Config对象
HandlerConfig handlerConfig = JacksonUtil.toObject(configJson, HandlerConfig.class);
return handlerConfig;
}
/**
* 执行处理器链
*
* @param handler
* @param param
* @return
*/
public static HandleResult executeChain(AbstractHandler handler, Map<String, Object> param) {
//执行处理器
HandleResult handlerResult = handler.handle(param);
if (!handlerResult.isSuccess()) {
System.out.println("HandlerClient 责任链执行失败返回：" + handlerResult.toString());
return handlerResult;
}
return HandleResult.success();
}
}
END.
