背景

项目中遇到这样一种场景，传入参数A，需要根据参数A做不同的业务逻辑处理，只要匹配到一个就结束。于是便想到责任链设计模式，标准的审批流，拿来改造改造，不也刚好符合需求吗？于是就开始了探索。

设计思路

有三个不同的处理逻辑，如果其一不符合要求，便流转到其二，否则到其三，以此类推。

• 那首先可以先将三个不同处理逻辑独立成各自的类
• 自己处理不了自动流转到下一个，那便需要一个next指针，判断自己不符合，则流转到下一个
• 判断 + 流转 可以独立到抽象类中
• 实际处理，可以定义为抽象方法，子类来实现
• 面向接口编程，那势必需要对应的借口，则抽象类实现借口

这些都做完，那其实也就能实现功能了，看了一些责任链最佳实践，需要在业务代码处，现场拼接每个处理类的next指针，这不是重复动作吗？肯定不能忍啊，毕竟刚看了《程序员修炼之道-通向务实的最高境界》中的「重复」章节

于是想到对象的创建和使用分开，妥妥的工厂模式啊

• 定义工厂类
• 在工厂中定义方法将用到的多个业务链，结合自己的业务拼起来
• 在工厂中定义获取业务链的方法

此时，这里对于使用方就相当友好啦，只需要使用工厂获取业务链，再调用业务链的处理方法即可，到此，大功告成。

UML类图

代码示例

定义接口

/**  
  * <p>抽象链</p>  
  *  
  * @author <Arvin> (<yuandingdingd@gmail.com>)  
  * @date 2023/11/30 16:06  
  * @since 1.0.0  
  */  
public interface BusinessChain {  
  
  void process(Object param);  
    
  void setNext(BusinessChain next);  
}

定义抽象类

/**
 * <p>抽象实现链</p>
 *
 * @author <Arvin> (<yuandingdingd@gmail.com>)
 * @date 2023/11/30 16:07
 * @since 1.0.0
 */
@Data
public abstract class AbstractBusinessChain implements BusinessChain {

    protected BusinessChain next;

    private Boolean hasNext() {
        return Objects.nonNull(next);
    }

    @Override
    public void process(Object param) {
        var r = executeProcess(param);
        if (Boolean.FALSE.equals(r) && Boolean.TRUE.equals(hasNext())) {
            next.process(param);
        }
    }

    protected abstract Boolean executeProcess(Object param);

    @Override
    public void setNext(BusinessChain next) {
        this.next = next;
    }
}

定义具体实现类

/**
 * <p>第一个</p>
 *
 * @author <Arvin> (<yuandingdingd@gmail.com>)
 * @date 2023/11/30 16:10
 * @since 1.0.0
 */
@Component
public class FirstBusinessChain extends AbstractBusinessChain {

    @Override
    public Boolean executeProcess(Object param) {
        return Objects.nonNull(param);
    }
}

/**
 * <p>第二个</p>
 *
 * @author <Arvin> (<yuandingdingd@gmail.com>)
 * @date 2023/11/30 16:10
 * @since 1.0.0
 */
@Component
public class SecondBusinessChain extends AbstractBusinessChain {

    @Override
    public Boolean executeProcess(Object param) {
        return Objects.nonNull(param);
    }
}

/**
 * <p>第三个</p>
 *
 * @author <Arvin> (<yuandingdingd@gmail.com>)
 * @date 2023/11/30 16:10
 * @since 1.0.0
 */
@Component
public class ThirdBusinessChain extends AbstractBusinessChain {

    @Override
    public Boolean executeProcess(Object param) {
        return Objects.nonNull(param);
    }
}

定义创建工厂

/**
 * <p>业务链链工厂</p>
 *
 * @author <Arvin> (<yuandingdingd@gmail.com>)
 * @date 2023/11/30 16:52
 * @since 1.0.0
 */
@Component
@AllArgsConstructor
public class BusinessChainFactory {

    private final BusinessChain firstBusinessChain;
    private final BusinessChain sencondBusinessChain;
    private final BusinessChain thirdBusinessChain;

    @PostConstruct
    public void init() {
      firstBusinessChain.setNext(sencondBusinessChain);
      sencondBusinessChain.setNext(thirdBusinessChain);
      thirdBusinessChain.setNext(null);
    }

    public BusinessChain businessChain() {
        return firstBusinessChain;
    }
}

使用

// 创建并获取业务链
var businessChain = businessChainFactory.businessChain();

// 执行处理
businessChain.prcoess(param);