Apache Camel迭代List

3 回答

• 1

  以下是拆分聚合并转换列表消息的完整示例 .

  • camel splitter提供了一个内置聚合器，它聚合原始交换中的所有拆分消息 . 因此，拆分器只聚合"direct:start"中发送的每个列表（交换）的消息 . 您必须提供自定义聚合策略，因为默认的策略将使用原始交换，在我的示例中为InOrder . 聚合策略是拆分定义的第二个参数 .

  • 类型转换器使我们有机会在DSL中使用convertBodyTo . 您还可以使用bean，处理器或自定义聚合策略中的所有转换来实现这一点 .

  package org.mydemocamel.app;
  import org.apache.camel.*;
  import org.apache.camel.builder.RouteBuilder;
  import org.apache.camel.component.mock.MockEndpoint;
  import org.apache.camel.processor.aggregate.AggregationStrategy;
  import org.apache.camel.processor.aggregate.GroupedExchangeAggregationStrategy;
  import org.apache.camel.processor.aggregate.UseLatestAggregationStrategy;
  import org.apache.camel.processor.aggregate.UseOriginalAggregationStrategy;
  import org.apache.camel.support.TypeConverterSupport;
  import org.apache.camel.test.junit4.CamelTestSupport;
  import org.apache.camel.util.toolbox.FlexibleAggregationStrategy;
  import org.junit.Test;
  
  import java.util.ArrayList;
  import java.util.List;
  
  
  public class CamelSplitAggregateConvertTest extends CamelTestSupport {
  
      @Produce
      private ProducerTemplate template;
  
      @EndpointInject(uri = "mock:out")
      private MockEndpoint mock;
  
      @Test
      public void testSplitAggregateConvertOrder(){
          InOrder inOrder1 = new InOrder();
          inOrder1.setId("1");
  
          InOrder inOrder2 = new InOrder();
          inOrder2.setId("2");
  
          List<InOrder> inOrderList = new ArrayList<InOrder>();
          inOrderList.add(inOrder1);
          inOrderList.add(inOrder2);
  
          template.sendBody("direct:start", inOrderList);
  
          mock.expectedMessageCount(1);
          Exchange outList = mock.getReceivedExchanges().get(0);
          List<OutOrder> outOrderList = outList.getIn().getBody(List.class);
  
          assertEquals(1, outOrderList.get(0).getId());
          assertEquals(2, outOrderList.get(1).getId());
  
  
      }
  
      @Override
      protected RouteBuilder createRouteBuilder() throws Exception {
          return new RouteBuilder() {
              @Override
              public void configure() throws Exception {
  
                  context.getTypeConverterRegistry().addTypeConverter(OutOrder.class, InOrder.class, new MyOrderTypeConverter());
  
                  from("direct:start")
                  .split(body(), new AggregationStrategy() {
                      @Override
                      public Exchange aggregate(Exchange oldExchange, Exchange newExchange) {
                          if (oldExchange == null) {
                              List<OutOrder> orders = new ArrayList<OutOrder>();
                              OutOrder newOrder = newExchange.getIn().getBody(OutOrder.class);
                              orders.add(newOrder);
                              newExchange.getIn().setBody(orders);
                              return newExchange;
                          }
                          List<OutOrder> orders = oldExchange.getIn().getBody(List.class);
                          OutOrder newOutOrder = newExchange.getIn().getBody(OutOrder.class);
                          orders.add(newOutOrder);
                          oldExchange.getIn().setBody(orders);
                          return oldExchange;
                      }
                  })
                  .convertBodyTo(OutOrder.class)
                  .end()  //splitter ends here and the exchange body  is now List<OutOrder> 
                  .to("mock:out");
  
              }
          };
      }
  
      private static class MyOrderTypeConverter extends TypeConverterSupport {
  
          @SuppressWarnings("unchecked")
          public <T> T convertTo(Class<T> type, Exchange exchange, Object value) {
              // converter from inorder to outorder bean
              OutOrder order = new OutOrder();
              order.setId(Integer.parseInt(((InOrder) value).getId()));
              return (T) order;
          }
      }
  
      private static class OutOrder {
          private int id;
  
          public void setId(int id) {
              this.id = id;
          }
  
          public int getId() {
              return id;
          }
      }
  
      private static class InOrder {
          private String id;
  
          public void setId(String id) {
              this.id = id;
          }
  
          public String getId() {
              return id;
          }
      }
  }
  

  回复于 2024-04-25T21:06:51+08:00
• 3

  你是对的是拆分器和聚合器，http://camel.apache.org/splitter.html来自http://camel.apache.org/splitter.html显示你需要的东西 .

  在拆分器之后你需要"converted"对象列表吗？如果是，http://camel.apache.org/aggregator2.html中的"Using a List in AggregationStrategy"点看起来正确满足您的需求 .

  亲切的问候，土工

  回复于 2024-04-25T21:06:51+08:00
• 0

  为了将来参考，您可以使用Java DSL的 loop 构造迭代列表的另一种方法 . 这是一个例子：

  from("direct:myDirect")
  .loop(header("LIST_LENGTH")) // You will set this header in the processor before with the list lenght.
  .process(new Processor(){
  
        @Override
        public void proocess(Exchange arg0){
            MyObj currentElement = (MyObj) arg0.getIn().getBody(List.class).get(LOOP_INDEX);
            // Do your processing here.
        }
  })
  .end()
  .end();
  

  LOOP_INDEX 属性将包含当前迭代，从0开始到LIST_LENGHT标头值，因此您可以使用它从列表中获取当前元素 .

  注意双 end() 方法调用：一个用于结束循环，另一个用于结束路由 .

  文档：http://camel.apache.org/loop.html

  回复于 2024-04-25T21:06:51+08:00