亲爱的 Spring 社区！

最近我们发布了Spring Integration Java DSL：逐行教程，该教程大量使用了 Java 8 Lambda 表达式。我们收到了一些反馈，认为这是一个很好的 DSL 入门教程，但对于那些无法迁移到 Java 8 或不熟悉Lambda表达式但希望利用其优势的用户来说，也需要类似的教程。

因此，为了帮助那些希望从 XML 配置迁移到 Java 和注解配置的 Spring Integration 用户，我们提供了此逐行教程，以演示即使没有Lambda表达式，我们也能从 Spring Integration Java DSL 的使用中获益良多。尽管大多数人会同意 Lambda 语法提供了更简洁的定义。

我们在此分析了相同的Cafe Demo示例，但使用了 Java 8 之前的配置变体。许多选项相同，因此我们在此处复制/粘贴其描述以获得完整的画面。由于此 Spring Integration Java DSL 配置与 Java 8 Lambda 样式完全不同，因此对于所有用户来说，了解如何使用 Spring Integration Java DSL 提供的各种选项来获得相同的结果将非常有用。

我们应用程序的源代码放置在一个类中，该类是一个Boot应用程序；重要的行都用一个数字进行注释，该数字对应于后续的注释。

@SpringBootApplication                                                   // 1
@IntegrationComponentScan                                                // 2
public class Application {

  public static void main(String[] args) throws Exception {
  	ConfigurableApplicationContext ctx =
			SpringApplication.run(Application.class, args);              // 3

  	Cafe cafe = ctx.getBean(Cafe.class);                                 // 4
  	for (int i = 1; i <= 100; i++) {                                     // 5
  	  Order order = new Order(i);
  	  order.addItem(DrinkType.LATTE, 2, false);
  	  order.addItem(DrinkType.MOCHA, 3, true);
  	  cafe.placeOrder(order);
  	}

  	System.out.println("Hit 'Enter' to terminate");                      // 6
  	System.in.read();
  	ctx.close();
  }

  @MessagingGateway                                                      // 7
  public interface Cafe {

  	@Gateway(requestChannel = "orders.input")                            // 8
  	void placeOrder(Order order);                                        // 9

  }

  private final AtomicInteger hotDrinkCounter = new AtomicInteger();

  private final AtomicInteger coldDrinkCounter = new AtomicInteger();    // 10

  @Autowired
  private CafeAggregator cafeAggregator;                                 // 11

  @Bean(name = PollerMetadata.DEFAULT_POLLER)
  public PollerMetadata poller() {                                       // 12
  	return Pollers.fixedDelay(1000).get();
  }

  @Bean
  @SuppressWarnings("unchecked")
  public IntegrationFlow orders() {                                      // 13
  	return IntegrationFlows.from("orders.input")                         // 14
	  .split("payload.items", (Consumer) null)                           // 15
	  .channel(MessageChannels.executor(Executors.newCachedThreadPool()))// 16
	  .route("payload.iced",                                             // 17
	    new Consumer<RouterSpec<ExpressionEvaluatingRouter>>() {         // 18

	      @Override
	      public void accept(RouterSpec<ExpressionEvaluatingRouter> spec) {
	      	spec.channelMapping("true", "iced")
                .channelMapping("false", "hot");                         // 19
  	      }

  	    })
  	  .get();                                                            // 20
  }

  @Bean
  public IntegrationFlow icedFlow() {                                    // 21
  	return IntegrationFlows.from(MessageChannels.queue("iced", 10))      // 22
	  .handle(new GenericHandler<OrderItem>() {                          // 23

	  	@Override
	  	public Object handle(OrderItem payload, Map<String, Object> headers) {
	  	  Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS);
	  	  System.out.println(Thread.currentThread().getName()
	  	    + " prepared cold drink #" + coldDrinkCounter.incrementAndGet()
	  	    + " for order #" + payload.getOrderNumber() + ": " + payload);
	  	  return payload;                                                // 24
  	  	}

  	  })
  	  .channel("output")                                                 // 25
  	  .get();
  }

  @Bean
  public IntegrationFlow hotFlow() {                                     // 26
  	return IntegrationFlows.from(MessageChannels.queue("hot", 10))
	  .handle(new GenericHandler<OrderItem>() {

	  	@Override
	  	public Object handle(OrderItem payload, Map<String, Object> headers) {
	  	  Uninterruptibles.sleepUninterruptibly(5, TimeUnit.SECONDS);    // 27
	  	  System.out.println(Thread.currentThread().getName()
	  	    + " prepared hot drink #" + hotDrinkCounter.incrementAndGet()
	  	    + " for order #" + payload.getOrderNumber() + ": " + payload);
	  	  return payload;
  	  	}

  	  })
  	  .channel("output")
  	  .get();
  }

  @Bean
  public IntegrationFlow resultFlow() {                                  // 28
    return IntegrationFlows.from("output")                               // 29
      .transform(new GenericTransformer<OrderItem, Drink>() {            // 30

        @Override
        public Drink transform(OrderItem orderItem) {
          return new Drink(orderItem.getOrderNumber(),
            orderItem.getDrinkType(),
            orderItem.isIced(),
            orderItem.getShots());                                       // 31
        }

      })
      .aggregate(new Consumer<AggregatorSpec>() {                        // 32

        @Override
        public void accept(AggregatorSpec aggregatorSpec) {
          aggregatorSpec.processor(cafeAggregator, null);                // 33
        }

      }, null)
      .handle(CharacterStreamWritingMessageHandler.stdout())             // 34
    .get();
  }


  @Component
  public static class CafeAggregator {                                   // 35

  	@Aggregator                                                          // 36
  	public Delivery output(List<Drink> drinks) {
  	  return new Delivery(drinks);
  	}

  	@CorrelationStrategy                                                 // 37
  	public Integer correlation(Drink drink) {
  	  return drink.getOrderNumber();
  	}

  }

}

逐行检查代码…

好的，我们已经完成了基于 Spring Integration Java DSL（在 Java Lambda 支持不可用时）的 Cafe Demo 示例的描述。将其与XML 示例进行比较，并查看Lambda 支持教程以获取有关 Spring Integration 的更多信息。

如您所见，在没有 Lambda 表达式的情况下使用 DSL 会稍微冗长一些，因为您需要为函数式接口的内联匿名实现提供样板代码。但是，我们认为支持无法迁移到 Java 8 的用户使用 DSL 非常重要。许多 DSL 的优势（流畅的 API、编译时验证等）都适用于所有用户。

Lambda 表达式的使用延续了 Spring Framework 减少或消除样板代码的传统，因此我们鼓励用户尝试 Java 8 和 Lambda 表达式，并鼓励他们的组织考虑允许在 Spring Integration 应用程序中使用 Java 8。

此外，请参阅参考手册以获取更多信息。

与往常一样，我们期待您的评论和反馈（StackOverflow（spring-integration标签）、Spring JIRA、GitHub），我们非常欢迎贡献！

感谢您抽出时间阅读本文！