执行管道操作的设计模式建议

Question

问题陈述：我必须处理类似于管道的请求。
例如：
当一个请求到来时，它必须经历一系列的操作，比如 (step1,step2,step3...)。
因此，为了实现这一点，我使用了模板设计模式。

请检查并建议我是否正确地解决了这个问题，或者有更好的解决方案。
我怀疑我的方法会引入代码异味，因为我经常更改对象的值。

另外，建议我是否以及如何使用 Java 8 来完成此操作？ 谢谢。

代码：

package com.example.demo.design;

import java.util.List;

public abstract class Template {
    @Autowired
    private Step1 step1;
    @Autowired
    private Step2 step2;
    @Autowired
    private Save save;
    List<String> stepOutput = null;
    List<String> stepOutputTwo = null;
    List<String> stepOutputThree = null;

    public void step1(String action1) {
        stepOutput = step1.method(action1);
    }

    public void step2(String action2) {
        stepOutputTwo = step2.method(stepOutput, action2);
    }

    abstract public void step3();

    public void save() {
        save.persist(stepOutputThree);
    }

    final public void run(String action1, String action2) {
        step1(action1);
        step2(action2);
        stepOutputTwo = step3();
    }
}

Answer 1

我有同样的问题！ 您可以执行以下操作： uncheckCall方法用于处理异常。

final public void run(String action1, String action2) {
     //other stuffs 

     Stream.of(step1.method(action1))
           .map(stepOutput->uncheckCall(() ->step2.method(stepOutput,action2)))
           .forEach(stepOutputThree -> uncheckCall(()->save.persist(stepOutputThree)));

    //.....

}

对于uncheckCall方法：

 public static <T> T uncheckCall(Callable<T> callable) {
    try {
        return callable.call();
    } catch (RuntimeException e) {
       // throw BusinessException.wrap(e);
    } catch (Exception e) {
        //throw BusinessException.wrap(e);
    }
}

Answer 2

在 Java 8 流模型中，它可能如下所示：

final public void run(String action1, String action2) {
    Stream.of(action1)                        // Stream<String>
          .map(s -> step1.method(s))          // Stream<List<String>>
          .map(l -> step2.method(l,action2)   // Stream<List<String>>
          .map(l -> step3.method(l))          // Stream<List<String>>
          .forEach(l -> save.persist(l));
}

Answer 3

好吧，当有“管道”、“操作顺序”等时，第一个想到的设计模式是责任链，如下所示

并为您提供以下好处：

1. 允许您在必要时（例如在运行时）添加新的处理程序，而无需修改其他处理程序和处理逻辑（SOLID 的开放/关闭原则）
2. 允许处理程序在必要时停止处理请求
3. 允许您将处理程序的处理逻辑彼此分离（SOLID 的单一职责原则）
4. 允许您定义处理程序的顺序以处理处理程序本身之外的请求

实际使用的一个例子是Servlet 过滤器，您可以在其中调用doFilter(HttpRequest, HttpResponse, FilterChain)来调用下一个处理程序

protected void doFilter(HttpServletRequest req, HttpServletResponse resp, FilterChain chain) {
    if (haveToInvokeNextHandler) {
        chain.doFilter(req, resp);
    }
}

如果使用经典的责任链模式，您的处理管道可能如下所示：

应用程序接口

public class StepContext {
    private Map<String, Object> attributes = new HashMap<>();

    public <T> T getAttribute(String name) {
        (T) attributes.get(name);
    }

    public void setAttribute(String name, Object value) {
        attributes.put(name, value);
    }
}

public interface Step {
    void handle(StepContext ctx);
}

public abstract class AbstractStep implements Step {
    private Step next;

    public AbstractStep() {

    }

    public AbstractStep(Step next) {
        this.next = next;
    }

    protected void next(StepContext ctx) {
        if (next != null) {
            next.handle(ctx);
        }
    }
}

执行

public class Step1 extends AbstractStep {

    public Step1(Step next) {
        super(next);
    }

    public void handle(StepContext ctx) {
        String action1 = ctx.getAttribute("action1");
        List<String> output1 = doSomething(action1);
        ctx.setAttribute("output1", output1);

        next(ctx); // invoke next step
    }
}

public class Step2 extends AbstractStep {

    public Step2(Step next) {
        super(next);
    }

    public void handle(StepContext ctx) {
        String action2 = ctx.getAttribute("action2");
        List<String> output1 = ctx.getAttribute("output1");
        List<String> output2 = doSomething(output1, action2);
        ctx.setAttribute("output2", output2);

        next(ctx); // invoke next step
    }
}

public class Step3 extends AbstractStep {

    public Step3(Step next) {
        super(next);
    }

    public void handle(StepContext ctx) {
        String action2 = ctx.getAttribute("action2");
        List<String> output2 = ctx.getAttribute("output2");
        persist(output2);

        next(ctx); // invoke next step
    }
}

客户端代码

Step step3 = new Step3(null);
Step step2 = new Step2(step3);
Step step1 = new Step1(step2);

StepContext ctx = new StepContext();
ctx.setAttribute("action1", action1);
ctx.setAttribute("action2", action2);

step1.handle(ctx);

此外，所有这些内容都可以通过删除相应的next引用来简化为相互解耦的处理程序链，以防您的处理管道必须始终调用所有可用步骤，而无需控制调用前一个步骤的必要性：

应用程序接口

public class StepContext {
    private Map<String, Object> attributes = new HashMap<>();

    public <T> T getAttribute(String name) {
        (T) attributes.get(name);
    }

    public void setAttribute(String name, Object value) {
        attributes.put(name, value);
    }
}

public interface Step {
    void handle(StepContext ctx);
}

执行

public class Step1 implements Step {
    public void handle(StepContext ctx) {
        String action1 = ctx.getAttribute("action1");
        List<String> output1 = doSomething(action1);
        ctx.setAttribute("output1", output1);
    }
}

public class Step2 implements Step {
    public void handle(StepContext ctx) {
        String action2 = ctx.getAttribute("action2");
        List<String> output1 = ctx.getAttribute("output1");
        List<String> output2 = doSomething(output1, action2);
        ctx.setAttribute("output2", output2);
    }
}

public class Step3 implements Step {
    public void handle(StepContext ctx) {
        String action2 = ctx.getAttribute("action2");
        List<String> output2 = ctx.getAttribute("output2");
        persist(output2);
    }
}

客户端代码

请注意，在 Spring 框架的情况下（刚刚注意到@Autowired注释）客户端代码可能会更加简化，因为@Autowired注释可用于将相应类型的所有 bean 注入相应的集合。

这里是什么文件说明：

自动装配数组、集合和映射

在数组、集合或映射依赖类型的情况下，容器自动装配与声明的值类型匹配的所有 bean。 为此，必须将映射键声明为 String 类型，该类型将解析为相应的 bean 名称。 这样一个容器提供的集合将被排序，考虑目标组件的 Ordered 和 @Order 值，否则按照它们在容器中的注册顺序。 或者，单个匹配的目标 bean 也可能是一般类型的 Collection 或 Map 本身，因此被注入。

public class StepsInvoker {
    // spring will put all the steps into this collection in order they were declared
    // within the spring context (or by means of `@Order` annotation)
    @Autowired
    private List<Step> steps;

    public void invoke(String action1, String action2) {
        StepContext ctx = new StepContext();
        ctx.setAttribute("action1", action1);
        ctx.setAttribute("action2", action2);

        steps.forEach(step -> step.handle(ctx))
    }
}

Answer 4

我建议您看看反应式编程。 书中的一切都是流（有限，无限，空，错误，无所谓）。 RxJava2类的库和Project Reactor类的框架使您能够以非常惯用的方式创建复杂的应用程序。 以您的例子为例。 这是Reactor的代码：

Mono.just(request)
.flatMap(minion::actionOne)
.flatMap(minion::actionTwo)
.flatMap(minion::persist)
.subscribe();

该代码将包含在包含您的业务逻辑的类中（我称为该处理程序）。 奴才包含实际的工作代码。 我立即看到以下好处：

1. 更多惯用的代码。 产品可以立即打开代码并了解业务逻辑。

2. 极其简单的多线程。 例如，如果我希望以上代码在与调用线程不同的线程上执行，我会这样做

    Mono.just(request) .flatMap(minion::actionOne) .flatMap(minion::actionTwo) .flatMap(minion::persist) .subscribeOn(Schedulers.elastic()) .subscribe(); 

3. 处理异常很容易：

    Mono.just(request) .flatMap(minion::actionOne) .flatMap(minion::actionTwo) .flatMap(minion::persist) .doOnError(err -> logError(err)) .onErrorResume(Mono.defer(() -> getFallbackStream())) .subscribeOn(Schedules.elastic()) .subscribe(); 

   上面的代码提供了一个备用流，以防发生任何错误。 假设您有一个要调用的用户配置文件服务。 如果出现故障怎么办？ 您可以提供一个回退流，该回退流从传递的令牌中提取最少的用户信息（尽管容量有限，但您的应用程序仍可以正常工作）。

4. 想重试吗？ 您拥有像retryWhen这样的运算符，它会根据您决定的策略（例如指数补偿）重新启动上述流。

您可以立即看到上述方法的好处。 我看到的唯一缺点是学习曲线，这非常陡峭。 但是一旦您熟悉了这种编程风格，就再也没有回头路了。