Java 增量代码的设计模式

根据业务逻辑，一个方法的输出用作另一个方法的输入。该逻辑具有线性流。 为了模拟这种行为，现在有一个拥有一切的控制器类

这是非常混乱，太多的loc和难以修改。此外，异常处理非常复杂。单个方法会进行一些处理，但全局异常会出现，并且会涉及大量的

try

catch

语句

是否存在解决此问题的设计模式

控制器类代码示例

try{
   Logic1Inputs logic1_inputs = new Logic1Inputs( ...<some other params>... );
   Logic1 l = new Logic1(logic1_inputs);
   try{ 
     Logic1Output l1Output = l.execute();
   } catch( Logic1Exception l1Exception) {
     // exception handling
   }

   Logic2Inputs logic2_inputs = new Logic2Inputs(l1Output);
   Logic2 l2 = new Logic2(logic2_inputs);
   try{ 
     Logic2Output l2Output = l2.execute();
   } catch( Logic2Exception l2Exception) {
     // exception handling
   }

   Logic3Inputs logic3_inputs = new Logic3Inputs(l1Output, l2Output);
   Logic3 l3 = new Logic3(logic2_inputs);
   try{ 
     Logic3Output l3Output = l3.execute();
   } catch( Logic3Exception l3Exception) {
     // exception handling
   }
} catch(GlobalException globalEx){
  // exception handling
}

试试看{
Logic1Inputs logic1_inputs=新的Logic1Inputs（……）；
Logic1 l=新的Logic1（Logic1_输入）；
试试{
Logic1Output l1Output=l.execute（）；
}捕获（Logic1Exception l1Exception）{
//异常处理
}
Logic2Inputs logic2_inputs=新的Logic2Inputs（l1Output）；
Logic2 l2=新的Logic2（Logic2_输入）；
试试{
Logic2Output l2Output=l2.execute（）；
}捕获（Logic2Exception l2Exception）{
//异常处理
}
logic3输入logic3_输入=新的logic3输入（L1输出，L2输出）；
Logic3 l3=新的Logic3（logic2_输入）；
试试{
Logic3Output l3Output=l3.execute（）；
}捕获（Logic3Exception l3Exception）{
//异常处理
}
}捕获（GlobalException globalEx）{
//异常处理
}

我认为这就是所谓的管道：这种模式用于算法，其中数据流经一系列任务或阶段

您可以搜索执行此操作的库（）或尝试自己的java实现

基本上，所有对象都在一个列表中，并将一个si的输出传递到下一个si。这是一个幼稚的实现，但您可以添加泛型和所需的一切

public class BasicPipelinePattern {
    List<Filter> filters;

    public Object process(Object input) {
        for (Filter c : filters) {
            try {
                input = c.apply(input);
            } catch (Exception e) {
                // exception handling
            }
        }
        return input;
    }

}

public interface Filter {
    public Object apply(Object o);
}

公共类基本线性模式{
列表过滤器；
公共对象进程（对象输入）{
用于（过滤器c：过滤器）{
试一试{
输入=c.应用（输入）；
}捕获（例外e）{
//异常处理
}
}
返回输入；
}
}
公共接口过滤器{
公共对象应用（对象o）；
}

当遇到这样的问题时，我想看看其他编程语言如何解决它。然后我可以借用这个概念并将其应用到我正在使用的语言中

在javascript中，人们一直在谈论承诺以及它们如何不仅简化异步处理，而且简化错误处理。这是一个很好的问题介绍

然后使用“thenables”调用该方法。以下是伪代码：

initialStep.execute().then(function(result1){
    return step2(result1);
}).then(function(result2){
    return step3(result3);
}).error(function(error){
    handle(error);
}).done(function(result3){
    handleResult(result3)
});

这种模式的优点是，您可以专注于处理并在一个地方有效地处理错误，而无需担心在每个步骤中检查是否成功

那么这在java中是如何工作的呢？我可能会看一看其中一个promises/futures库。我希望您可以将类似的内容放在一起（为简洁起见，假设使用java 8）：

当然，这确实掩盖了代码中隐藏的需求。您提到在步骤3中，您需要步骤1和步骤2的输出。如果您正在编写scala，那么可以使用语法糖来处理这个问题（暂时不考虑错误处理）：

---

最后一个选项是更具表意性的java，但保留了表格处理的许多优点，因此这可能是我的选择。

@user1121883我认为您的评论（除了纯链接，还有一些额外的工作）将是一个很好的答案！就目前而言，我不认为代码太糟糕。事实上，我可以想象这个规范看起来与代码非常相似，如果这个规范很复杂，那就真的没什么可做的了。也就是说，您当然可以将其分解为更小的方法，并在适当的情况下添加注释。如果您将

流程

重命名为

应用

，则责任链的某些变体也可以工作

基本行模式

，以实现

组件

。这意味着使用它的代码不知道它是单个

组件

、整个管道，甚至是一个复杂的组件树。

initialPromise.then( result1 -> {
    Logic2 logic2 = new Logic2(new Logic2Inputs(result1));
    return logic2.execute();
}).then(result2 -> {
    Logic3 logic3 = new Logic3(new Logic3Inputs(result2));
    return logic2.execute();
}).catch(exception -> {
    handleException(exception)
}).finally( result -> {
    handleResult(result);
});

for(result1 <- initialStep.execute(); 
    Logic2 logic2 = new Logic2(Logic2Input(result1));
    result2 <- logic2.execute();
    Logic3 logic3 = new Logic3(Logic3Input(result1, result2));
    result3 <- logic3.execute()) yield result3;

Pipeline p = new Pipeline();
p.then(new Logic1())
 .then(new Logic2())
 .then(new Logic3())
 .addErrorHandlder(e->handleError(e))
 .complete();