# 整合资料
本指南将引导您完成使用Spring Integration创建一个简单应用程序的过程，该应用程序将从RSS Feed（Spring Blog）中检索数据，处理数据，然后将其写入文件。 本指南使用传统的Spring Integration XML配置。 其他指南显示了如何在带有和不带有JDK 8 Lambda表达式的情况下使用Java Configuration和DSL。
## 你会建立什么
您将使用传统的XML配置通过Spring Integration创建一个流程。
## 你需要什么
* 约15分钟
* 最喜欢的文本编辑器或IDE
* [JDK 1.8](http://www.oracle.com/technetwork/java/javase/downloads/index.html) 或更高版本
* [Gradle 4+](http://www.gradle.org/downloads) 或 [Maven 3.2+](https://maven.apache.org/download.cgi)
* 您还可以将代码直接导入到IDE中：
* [弹簧工具套件（STS）](https://spring.io/guides/gs/sts)
* [IntelliJ IDEA](https://spring.io/guides/gs/intellij-idea/)
## 如何完成本指南
像大多数Spring 一样 [入门指南](https://spring.io/guides) ，您可以从头开始并完成每个步骤，也可以绕过您已经熟悉的基本设置步骤。 无论哪种方式，您最终都可以使用代码。
要 **从头开始** ，请继续进行“ [从Spring Initializr开始”](https://spring.io/guides/gs/integration/#scratch) 。
要 **跳过基础知识** ，请执行以下操作：
* [下载](https://github.com/spring-guides/gs-integration/archive/master.zip) 并解压缩本指南的源存储库，或使用 对其进行克隆 [Git](https://spring.io/understanding/Git) ： `git clone [https://github.com/spring-guides/gs-integration.git](https://github.com/spring-guides/gs-integration.git)`
* 光盘进入 `gs-integration/initial`
* 继续 [定义集成流程](https://spring.io/guides/gs/integration/#initial) 。
**完成后** ，您可以根据中的代码检查结果 `gs-integration/complete`.
## 从Spring Initializr开始
如果您使用Maven，请访问 [Spring Initializr](https://start.spring.io/#!type=maven-project&language=java&platformVersion=2.4.3.RELEASE&packaging=jar&jvmVersion=11&groupId=com.example&artifactId=integration&name=integration&description=Demo%20project%20for%20Spring%20Boot&packageName=com.example.integration&dependencies=integration) 以生成具有所需依赖项的新项目（Spring Integration）。
以下清单显示了 `pom.xml` 选择Maven时创建的文件：
~~~
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.4.3</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>integration</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>integration</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-integration</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.integration</groupId>
<artifactId>spring-integration-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
~~~
如果您使用Gradle，请访问 [Spring Initializr](https://start.spring.io/#!type=gradle-project&language=java&platformVersion=2.4.3.RELEASE&packaging=jar&jvmVersion=11&groupId=com.example&artifactId=integration&name=integration&description=Demo%20project%20for%20Spring%20Boot&packageName=com.example.integration&dependencies=integration) 以生成具有所需依赖项的新项目（Spring Integration）。
以下清单显示了 `build.gradle` 选择Gradle时创建的文件：
~~~
plugins {
id 'org.springframework.boot' version '2.4.3'
id 'io.spring.dependency-management' version '1.0.11.RELEASE'
id 'java'
}
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-integration'
testImplementation('org.springframework.boot:spring-boot-starter-test')
testImplementation 'org.springframework.integration:spring-integration-test'
}
test {
useJUnitPlatform()
}
~~~
### 手动初始化（可选）
如果要手动初始化项目而不是使用前面显示的链接，请按照以下步骤操作：
1. 导航到 [https://start.spring.io](https://start.spring.io) 。 该服务提取应用程序所需的所有依赖关系，并为您完成大部分设置。
2. 选择Gradle或Maven以及您要使用的语言。 本指南假定您选择了Java。
3. 单击 **Dependencies，** 然后选择 **Spring Integration** 。
4. 点击 **生成** 。
5. 下载生成的ZIP文件，该文件是使用您的选择配置的Web应用程序的存档。
如果您的IDE集成了Spring Initializr，则可以从IDE中完成此过程。
## 添加到构建文件
对于此示例，您需要添加两个依赖项：
* `spring-integration-feed`
* `spring-integration-file`
以下清单显示了最终的 `pom.xml` 文件：
~~~
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.4.3</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>integration</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>integration</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-integration</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.integration</groupId>
<artifactId>spring-integration-feed</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.integration</groupId>
<artifactId>spring-integration-file</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.integration</groupId>
<artifactId>spring-integration-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
~~~
The following listing shows the final `build.gradle` file:
~~~
plugins {
id 'org.springframework.boot' version '2.4.3'
id 'io.spring.dependency-management' version '1.0.11.RELEASE'
id 'java'
}
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-integration'
implementation 'org.springframework.integration:spring-integration-feed'
implementation 'org.springframework.integration:spring-integration-file'
testImplementation('org.springframework.boot:spring-boot-starter-test')
testImplementation 'org.springframework.integration:spring-integration-test'
}
test {
useJUnitPlatform()
}
~~~
## 定义整合流程
对于本指南的示例应用程序，您将定义一个Spring Integration流程，该流程：
* 从spring.io的RSS feed中阅读博客文章。
* 将它们转换为易于阅读的 `String` 由帖子标题和帖子的网址组成。
* 追加 `String` 到文件末尾（ `/tmp/si/SpringBlog`).
要定义集成流程，您可以使用Spring Integration的XML名称空间中的一些元素来创建Spring XML配置。 具体来说，对于所需的集成流程，您可以使用这些Spring Integration名称空间中的元素：核心，提要和文件。 （获得最后两个是为什么我们必须修改Spring Initializr提供的构建文件的原因。）
以下XML配置文件（来自 `src/main/resources/integration/integration.xml`）定义集成流程：
~~~
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:int="http://www.springframework.org/schema/integration"
xmlns:file="http://www.springframework.org/schema/integration/file"
xmlns:feed="http://www.springframework.org/schema/integration/feed"
xsi:schemaLocation="http://www.springframework.org/schema/integration/feed https://www.springframework.org/schema/integration/feed/spring-integration-feed.xsd
http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/integration/file https://www.springframework.org/schema/integration/file/spring-integration-file.xsd
http://www.springframework.org/schema/integration https://www.springframework.org/schema/integration/spring-integration.xsd">
<feed:inbound-channel-adapter id="news" url="https://spring.io/blog.atom" auto-startup="${auto.startup:true}">
<int:poller fixed-rate="5000"/>
</feed:inbound-channel-adapter>
<int:transformer
input-channel="news"
expression="payload.title + ' @ ' + payload.link + '#{systemProperties['line.separator']}'"
output-channel="file"/>
<file:outbound-channel-adapter id="file"
mode="APPEND"
charset="UTF-8"
directory="/tmp/si"
filename-generator-expression="'${feed.file.name:SpringBlog}'"/>
</beans>
~~~
这里有三个集成元素：
* `<feed:inbound-channel-adapter>`：检索入站适配器的入站适配器，每个轮询一个。 按照此处的配置，它每五秒钟轮询一次。 帖子被放置在名为的频道中 `news` （对应于适配器的ID）。
* `<int:transformer>`：转换条目（ `com.rometools.rome.feed.synd.SyndEntry`） 在里面 `news` 频道，提取条目的标题（ `payload.title`）并链接（ `payload.link`）并将它们连接成可读的 `String`（并添加换行符）。 这 `String` 然后发送到名为 `file`.
* `<file:outbound-channel-adapter>`：一个出站通道适配器，它从其通道写入内容（名为 `file`）到文件。 具体来说，如此处配置的那样，它会将任何内容附加到 `file` 引导至位于的文件 `/tmp/si/SpringBlog`.
下图显示了此简单流程：
忽略 `auto-startup`现在的属性。 我们稍后在讨论测试时会重新讨论。 现在，请注意，默认情况下， `true`，这意味着在应用程序启动时提取帖子。 还要注意属性占位符在 `filename-generator-expression`。 这意味着默认值为 `SpringBlog` 但可以用属性覆盖。
## 使应用程序可执行
尽管通常在较大的应用程序（甚至是Web应用程序）中配置Spring Integration流，但没有理由不能在更简单的独立应用程序中定义它。 接下来，您将要做的是：创建一个开始集成流程的主类，该主类声明了少数支持集成流程的bean。 您还将把应用程序构建到一个独立的可执行JAR文件中。 我们使用Spring Boot的 `@SpringBootApplication`注释以创建应用程序上下文。 由于本指南将XML名称空间用于集成流程，因此您必须使用 `@ImportResource`批注以将其加载到应用程序上下文中。 以下清单（来自 `src/main/java/com/example/integration/IntegrationApplication.java`）显示了应用程序文件：
~~~
package com.example.integration;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ImportResource;
@SpringBootApplication
@ImportResource("/integration/integration.xml")
public class IntegrationApplication {
public static void main(String[] args) throws Exception {
ConfigurableApplicationContext ctx = new SpringApplication(IntegrationApplication.class).run(args);
System.out.println("Hit Enter to terminate");
System.in.read();
ctx.close();
}
}
~~~
### 建立可执行的JAR
您可以使用Gradle或Maven从命令行运行该应用程序。 您还可以构建一个包含所有必需的依赖项，类和资源的可执行JAR文件，然后运行该文件。 生成可执行jar使得在整个开发生命周期中，跨不同环境等等的情况下，都可以轻松地将服务作为应用程序进行发布，版本控制和部署。
如果您使用Gradle，则可以通过使用以下命令运行该应用程序 `./gradlew bootRun`。 或者，您可以通过使用以下命令构建JAR文件： `./gradlew build` 然后运行JAR文件，如下所示：
~~~
java -jar build/libs/gs-integration-0.1.0.jar
~~~
如果您使用Maven，则可以通过使用以下命令运行该应用程序 `./mvnw spring-boot:run`。 或者，您可以使用以下命令构建JAR文件： `./mvnw clean package` 然后运行JAR文件，如下所示：
~~~
java -jar target/gs-integration-0.1.0.jar
~~~
此处描述的步骤将创建可运行的JAR。 您还可以 构建经典的WAR文件 。
## 运行应用程序
现在，您可以通过运行以下命令从jar运行应用程序：
~~~
java -jar build/libs/{project_id}-0.1.0.jar
... app starts up ...
~~~
应用程序启动后，它将连接到RSS feed并开始获取博客文章。 应用程序通过您定义的集成流程处理这些帖子，最终将帖子信息附加到位于以下位置的文件中： `/tmp/si/SpringBlog`.
应用程序运行了一段时间后，您应该可以在以下位置查看文件： `/tmp/si/SpringBlog`查看少量帖子中的数据。 在基于UNIX的操作系统上，您还可以 `tail` 通过运行以下命令以查看结果（如结果所示）的文件：
~~~
tail -f /tmp/si/SpringBlog
~~~
您应该看到类似以下示例输出的内容（尽管实际新闻会有所不同）：
~~~
Spring Integration Java DSL 1.0 GA Released @ https://spring.io/blog/2014/11/24/spring-integration-java-dsl-1-0-ga-released
This Week in Spring - November 25th, 2014 @ https://spring.io/blog/2014/11/25/this-week-in-spring-november-25th-2014
Spring Integration Java DSL: Line by line tutorial @ https://spring.io/blog/2014/11/25/spring-integration-java-dsl-line-by-line-tutorial
Spring for Apache Hadoop 2.1.0.M2 Released @ https://spring.io/blog/2014/11/14/spring-for-apache-hadoop-2-1-0-m2-released
~~~
## 测验
检查 `complete` 项目，您将在其中看到一个测试用例 `src/test/java/com/example/integration/FlowTests.java`:
~~~
package com.example.integration;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.integration.endpoint.SourcePollingChannelAdapter;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.messaging.MessageChannel;
import com.rometools.rome.feed.synd.SyndEntryImpl;
@SpringBootTest({ "auto.startup=false", // we don't want to start the real feed
"feed.file.name=Test" }) // use a different file
public class FlowTests {
@Autowired
private SourcePollingChannelAdapter newsAdapter;
@Autowired
private MessageChannel news;
@Test
public void test() throws Exception {
assertThat(this.newsAdapter.isRunning()).isFalse();
SyndEntryImpl syndEntry = new SyndEntryImpl();
syndEntry.setTitle("Test Title");
syndEntry.setLink("http://characters/frodo");
File out = new File("/tmp/si/Test");
out.delete();
assertThat(out.exists()).isFalse();
this.news.send(MessageBuilder.withPayload(syndEntry).build());
assertThat(out.exists()).isTrue();
BufferedReader br = new BufferedReader(new FileReader(out));
String line = br.readLine();
assertThat(line).isEqualTo("Test Title @ http://characters/frodo");
br.close();
out.delete();
}
}
~~~
该测试使用Spring Boot的测试支持来设置名为 `auto.startup` 到 `false`。 依靠网络连接进行测试通常不是一个好主意，尤其是在CI环境中。 相反，我们阻止Feed适配器启动，并注入一个 `SyndEntry` 进入 `news`其余流程处理的通道。 该测试还设置了 `feed.file.name`以便测试写入另一个文件。 然后：
* 验证适配器已停止。
* 创建一个测试 `SyndEntry`.
* 删除测试输出文件（如果存在）。
* 发送消息。
* 验证文件是否存在。
* 读取文件并验证数据是否符合预期。
## 概括
恭喜你！ 您已经开发了一个简单的应用程序，该应用程序使用Spring Integration从spring.io中获取博客文章，对其进行处理并将其写入文件。
- springboot概述
- springboot构建restful服务
- spring构建一个RESTful Web服务
- spring定时任务
- 消费RESTful Web服务
- gradle构建项目
- maven构建项目
- springboot使用jdbc
- springboot应用上传文件
- 使用LDNA验证用户
- 使用 spring data redis
- 使用 spring RabbitTemplate消息队列
- 用no4j访问nosql数据库
- springboot验证web表单
- Spring Boot Actuator构j建服务
- 使用jms传递消息
- springboot创建批处理服务
- spring security保护web 安全
- 在Pivotal GemFire中访问数据
- 使用Spring Integration
- 使用springboot jpa进行数据库操作
- 数据库事务操作
- 操作mongodb
- springmvc+tymleaf创建web应用
- 将Spring Boot JAR应用程序转换为WAR
- 创建异步服务
- spring提交表单
- 使用WebSocket构建交互式Web应用程序
- 使用REST访问Neo4j数据
- jquery消费restful
- springboot跨域请求
- 消费SOAP Web服务
- springboot使用缓存
- 使用Vaadin创建CRUD UI
- 使用REST访问JPA数据
- 使用REST访问Pivotal GemFire中的数据
- 构建soap服务
- 使用rest访问mongodb数据
- 构建springboot应用docker镜像
- 从STS部署到Cloud Foundry
- springboot测试web应用
- springboot访问mysql
- springboot编写自定义模块并使用
- 使用Google Cloud Pub / Sub进行消息传递
- 构建反应式RESTful Web服务
- 使用Redis主动访问数据
- Spring Boot 部署到Kubernetes
- 使用反应式协议R2DBC访问数据
- Spring Security架构
- spring构建Docker镜像详解
- Spring Boot和OAuth2
- springboot应用部署到k8s
- spring构建rest服务详解