Spring integration Spring集成：拆分器聚合器流中错误处理的意外行为

我考试不及格。问题是，为什么在拆分的“子消息”之一出现错误的情况下，回答仅为错误，而对另一个成功处理的子消息没有结果（如测试中所预期的）？是否对该代码进行了修改以达到测试中预期的结果

@RunWith(SpringRunner.class)
public class ErrorHandlingTests {

    @Autowired
    StringsService stringsService;

    interface StringsService {
        @Nonnull
        List<String> process(@Nonnull List<String> data);
    }

    @EnableIntegration
    @Configuration
    static class Config {

        @Bean
        IntegrationFlow errorHandler() {
            return IntegrationFlows.from("errorChannel")
                    .<MessagingException>handle((ex, h) -> "Failure for " + ex.getFailedMessage().getPayload())
                    .get();
        }

        @Bean
        IntegrationFlow errorsHandlingFlow2() {
            AtomicInteger incomingCorrelationId = new AtomicInteger();

            return IntegrationFlows.from(StringsService.class, gws -> gws.errorChannel("errorChannel"))
                    .split(new AbstractMessageSplitter() {
                        @Override
                        protected Object splitMessage(Message<?> message) {
                            List<String> strings = (List<String>) message.getPayload();
                            int id = incomingCorrelationId.get();
                            return strings
                                    .stream()
                                    .map(r -> MessageBuilder
                                            .withPayload(r)
                                            .setHeader(IntegrationMessageHeaderAccessor.CORRELATION_ID, id)
                                            .setHeader(IntegrationMessageHeaderAccessor.SEQUENCE_SIZE, strings.size())
                                            .build())
                                    .collect(Collectors.toList());
                        }
                    })
                    .transform(new AbstractPayloadTransformer<String, String>() {
                        @Override
                        protected String transformPayload(String s) {
                            if (s.contains("oops"))
                                throw new IllegalArgumentException("Bad value");

                            return "R: " + s;
                        }
                    })
                    .aggregate(a -> a.outputProcessor(new AbstractAggregatingMessageGroupProcessor() {
                        @Override
                        protected Object aggregatePayloads(MessageGroup group, Map<String, Object> defaultHeaders) {
                            return group.getMessages()
                                    .stream()
                                    .map(m -> (String) m.getPayload())
                                    .collect(Collectors.toList());
                        }
                    }))
                    .get();
        }
    }

    @Test
    public void testErrorHandlingInFlow2() {
        assertEquals(Arrays.asList("R: a", "R: b"), stringsService.process(Arrays.asList("a", "b")));
        assertEquals(Arrays.asList("R: a", "Failure for oops"), stringsService.process(Arrays.asList("a", "oops")));
    }
}

@RunWith（SpringRunner.class）
公共类错误处理测试{
@自动连线
Strings服务Strings服务；
接口StringsService{
@非空
列表进程（@非空列表数据）；
}
@使能集成
@配置
静态类配置{
@豆子
IntegrationFlow errorHandler（）{
返回IntegrationFlows.from（“errorChannel”）
.handle（（ex，h）->“+ex.getFailedMessage（）.getPayload（）的失败）
.get（）；
}
@豆子
集成流错误ShandlingFlow2（）{
AtomicInteger incomingCorrelationId=新的AtomicInteger（）；
返回IntegrationFlows.from（StringsService.class，gws->gws.errorChannel（“errorChannel”））
.split（新的AbstractMessageSplitter（）{
@凌驾
受保护对象拆分消息（消息消息）{
List strings=（List）message.getPayload（）；
int id=incomingCorrelationId.get（）；
返回字符串
.stream（）
.map（r->MessageBuilder
.有效载荷（r）
.setHeader（IntegrationMessageHeaderAccessor.CORRELATION_ID，ID）
.setHeader（IntegrationMessageHeaderAccessor.SEQUENCE_SIZE，strings.SIZE（））
.build（））
.collect（Collectors.toList（））；
}
})
.transform（新的AbstractPayloadTransformer（）{
@凌驾
受保护的字符串有效负载（字符串s）{
如果（s.contains（“oops”））
抛出新的IllegalArgumentException（“坏值”）；
返回“R:+s；
}
})
.aggregate（a->a.outputProcessor（新的AbstractAggregatingMessageGroupProcessor（））{
@凌驾
受保护对象aggregatePayloads（MessageGroup、Map defaultHeaders）{
返回组。getMessages（）
.stream（）
.map（m->（字符串）m.getPayload（））
.collect（Collectors.toList（））；
}
}))
.get（）；
}
}
@试验
public void testerRorrHandlingFlow2（）{
assertEquals（Arrays.asList（“R:a”、“R:b”）、stringsService.process（Arrays.asList（“a”、“b”））；
assertEquals（Arrays.asList（“R:a”，“oops失败”）、stringsService.process（Arrays.asList（“a”，“oops”））；
}
}

---

更新版本，正在使用，并附有应用建议

@RunWith(SpringRunner.class)
public class ErrorHandlingTests2 {

    interface StringsService {
        @Nonnull
        List<String> process(@Nonnull List<String> data);
    }

    @Autowired
    StringsService stringsService;

    @EnableIntegration
    @Configuration
    static class Config {

        @Bean
        IntegrationFlow errorHandler() {
            return IntegrationFlows.from("errorChannel")
                    .<MessagingException>handle((ex, h) -> "Failure for " + ex.getFailedMessage().getPayload())
                    .get();
        }

        @Bean
        IntegrationFlow errorsHandlingFlow2() {
            return IntegrationFlows.from(StringsService.class, gws -> gws.errorChannel("errorChannel"))
                    .split(new AbstractMessageSplitter() {
                        @Override
                        protected Object splitMessage(Message<?> message) {
                            List<String> strings = (List<String>) message.getPayload();
                            return strings
                                    .stream()
                                    .map(r -> MessageBuilder
                                            .withPayload(r)
                                            .build())
                                    .collect(Collectors.toList());
                        }
                    })
                    .transform(new AbstractPayloadTransformer<String, String>() {
                        @Override
                        protected String transformPayload(String s) {
                            if (s.contains("oops"))
                                throw new IllegalArgumentException("Bad value");

                            return "R: " + s;
                        }
                    }, c -> c.advice(advice()))
                    .aggregate(a -> a.outputProcessor(new AbstractAggregatingMessageGroupProcessor() {
                        @Override
                        protected Object aggregatePayloads(MessageGroup group, Map<String, Object> defaultHeaders) {
                            return group.getMessages()
                                    .stream()
                                    .map(m -> (String) m.getPayload())
                                    .collect(Collectors.toList());
                        }
                    }))
                    .get();
        }

        @Bean
        ExpressionEvaluatingRequestHandlerAdvice advice() {
            ExpressionEvaluatingRequestHandlerAdvice advice = new ExpressionEvaluatingRequestHandlerAdvice();
            advice.setReturnFailureExpressionResult(true);
            advice.setOnFailureExpression(
                    new FunctionExpression<Message<?>>(s ->
                            MessageBuilder
                                    .withPayload("Failure for " + s.getPayload())
                                    .copyHeaders(s.getHeaders()).build())
            );
            return advice;
        }
    }

    @Test
    public void testErrorHandlingInFlow2() {
        assertEquals(Arrays.asList("R: a", "R: b"), stringsService.process(Arrays.asList("a", "b")));
        assertEquals(Arrays.asList("R: a", "Failure for oops", "R: b"), stringsService.process(Arrays.asList("a", "oops", "b")));
    }

}

@RunWith（SpringRunner.class）
公共类ErrorHandlingTests2{
接口StringsService{
@非空
列表进程（@非空列表数据）；
}
@自动连线
Strings服务Strings服务；
@使能集成
@配置
静态类配置{
@豆子
IntegrationFlow errorHandler（）{
返回IntegrationFlows.from（“errorChannel”）
.handle（（ex，h）->“+ex.getFailedMessage（）.getPayload（）的失败）
.get（）；
}
@豆子
集成流错误ShandlingFlow2（）{
返回IntegrationFlows.from（StringsService.class，gws->gws.errorChannel（“errorChannel”））
.split（新的AbstractMessageSplitter（）{
@凌驾
受保护对象拆分消息（消息消息）{
List strings=（List）message.getPayload（）；
返回字符串
.stream（）
.map（r->MessageBuilder
.有效载荷（r）
.build（））
.collect（Collectors.toList（））；
}
})
.transform（新的AbstractPayloadTransformer（）{
@凌驾
受保护的字符串有效负载（字符串s）{
如果（s.contains（“oops”））
抛出新的IllegalArgumentException（“坏值”）；
返回“R:+s；
}
}，c->c.advice（advice（））
.aggregate（a->a.outputProcessor（新的AbstractAggregatingMessageGroupProcessor（））{
@凌驾
受保护对象aggregatePayloads（MessageGroup、Map defaultHeaders）{
返回组。getMessages（）
.stream（）
.map（m->（字符串）m.getPayload（））
.collect（Collectors.toList（））；
}
}))
.get（）；
}
@豆子
ExpressionEvaluationRequestHandlerAdvice通知（）{
ExpressionEvaluationRequestHandlerAdvice通知=新的ExpressionEvaluationRequestHandlerAdvice（）；
advice.setReturnFailureExpressionResult（true）；
advice.setOnFailureExpression(
新函数