代码重构—责任链模式在项目中的使用

代码重构—责任链模式在项目中的使用

责任链模式

定义

• 为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

优点

• 降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构，发送者和接收者也无须拥有对方的明确信息。
• 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
• 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。
• 责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。
• 责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

缺点

• 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
• 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。
• 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。

模式的结构

职责链模式主要包含以下角色。

1. 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
2. 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
3. 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

代码改造

原代码逻辑

这里模拟一个物资变更的功能，需要校验当前物资是否还在流程中（采购或验收），如果还在流程中，则不允许变更其信息。这里将是否在采购流程和验收流程中的校验逻辑耦合在一起了，并且以后可能会减少或增加其他流程或其他规则的校验，这就需要我们在这段代码里面减少或增加逻辑代码，非常不易于维护和拓展。

public static boolean verify(String itemnum) {
        boolean flag = false;
        // 校验一：采购申请已完成？
        if(采购申请已完成？){
            return true;
        }
        // 订单接收完成？
        if(订单接收已完成？){
            return true;
        }
        return false;
    }

public class UdItem {
    public R saveOrUpdate(){
        boolean verify = ItemUtil.verify(itemnum);
		if(verify){
        	throw new ServiceException("CUSTOM_ERR", "GRPMM", "物资编码目前还在流程中，禁止变更");
        }
        ...
    }
}

代码重构

• 定义一个泛型接口，规范责任链处理类必要的方法
  • setNextHandler：下一个处理类
  • handle：处理方法

public interface Handler<T> {
    void setNextHandler(Handler<T> nextHandler);
    void handle(T data);
}

• 定义一个处理类抽象父类，并实现Handler接口
  • 实现handle方法：执行下一个处理类的handler方法，在抽象父类中实现，子类不需要聚合下一个处理类，降低了耦合度
  • builder方法：使用内部类实现建造者模式，方便构建责任链

@Slf4j
public abstract class AbstractHandler<T> implements Handler<T> {
    private Handler<T> nextHandler;

    @Override
    public void setNextHandler(Handler<T> nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handle(T data) {
        if (nextHandler != null) {
            nextHandler.handle(data);
        }else {
            log.info("调用结束");
        }
    }

    public static <T> Builder<T> builder() {
        return new Builder<>();
    }

    public static class Builder<T> {
        private Handler<T> head;
        private Handler<T> tail;

        public Builder<T> addHandler(Handler<T> handler) {
            if (head == null) {
                head = handler;
                tail = handler;
            } else {
                tail.setNextHandler(handler);
                tail = handler;
            }
            return this;
        }

        public Handler<T> build() {
            return head;
        }
    }
}

• 定义一个处理类规则注解，用于标注在处理类上，区分模块和设置顺序
  • moduleName：所属模块（考虑使用配置的方式），默认ALL
  • order：处理类的执行顺序

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface HandlerAnnotation {
    String moduleName() default "ALL";
    int order() default 0;
}

• 处理类
  • handle：执行处理逻辑，最后调用super.handle()方法，父类会根据当前处理类，获取下一个处理类，执行其handle方法

@Component
@Slf4j
@HandlerAnnotation(moduleName = "ITEM", order = 1)
public class PrVerifyHandler extends AbstractHandler {

    @Override
    public void handle(Object data){
        log.info("物资编码{}变更，PrVerifyHandler校验", data.toString());
        // 采购申请已完成？
        if(采购申请已完成？){
             throw new ServiceException("CUSTOM_ERR", "GRPMM", "物资编码目前还在流程中，禁止变更");
        }
  
        super.handle(data);
    }
}

@Component
@Slf4j
@HandlerAnnotation(moduleName = "ITEM", order = 2)
public class PoVerifyHandler extends AbstractHandler {

    @Override
    public void handle(Object data){
        log.info("物资编码{}变更，PoVerifyHandler校验", data.toString());
         if(订单接收已完成？){
             throw new ServiceException("CUSTOM_ERR", "GRPMM", "物资编码目前还在流程中，禁止变更");
        }
        super.handle(data);
    }
}

• 定义一个处理类管理器，统一责任链的构造和执行方式
  • executeHandlers
    • module：用于区分构建不同模块的责任链
    • data：处理对象
  • buildHandlerChain：构建责任链

@Component
public class HandlerManager {

    @Autowired
    private ListableBeanFactory beanFactory;

    public void executeHandlers(String module, Object data) {
        Map<String, Handler> handlerMap = beanFactory.getBeansOfType(Handler.class);

        List<Handler> handlers = handlerMap.values().stream()
                .filter(handler -> handler.getClass().isAnnotationPresent(HandlerAnnotation.class))
                .map(handler -> new AbstractMap.SimpleEntry<>(handler, handler.getClass().getAnnotation(HandlerAnnotation.class)))
                .filter(entry -> entry.getValue().moduleName().equals(module))
                .sorted(Comparator.comparingInt(entry -> entry.getValue().order()))
                .map(Map.Entry::getKey)
                .collect(Collectors.toList());

        Handler<Object> handlerChain = buildHandlerChain(handlers);
        handlerChain.handle(data);
    }

    private Handler<Object> buildHandlerChain(List<Handler> handlers) {
        AbstractHandler.Builder<Object> builder = AbstractHandler.<Object>builder();
        for (Handler handler : handlers) {
            builder.addHandler(handler);
        }
        return builder.build();
    }
}

public class UdItem {
    @Resource
    private HandlerManager handlerManager;
    public R saveOrUpdate(){
		handlerManager.executeHandlers("ITEM", itemnum);
        ...
    }
}