Spring Integration Documentation

Spring Integration testing support is divided into two primary modules:

• spring-integration-test-support: Contains core items, shared utilities, rules, and matchers for standalone unit testing. It has no dependencies on Spring Integration itself.
• spring-integration-test: Provides high-level APIs for integration testing, including mocking components and configuring application contexts to verify whole flows or individual parts.

The framework is built upon JUnit, Hamcrest, and Mockito, and integrates with the Spring Test Framework.

The TCP DSL provides specialized support for building integration flows involving TCP connections. Key components include:

• Adapters and Gateways: Specs for both inbound and outbound communication.
• Tcp class: Provides factory methods to create connection factory beans (e.g., Tcp.netServer, Tcp.nioClient, Tcp.inboundAdapter, Tcp.outboundGateway).
• TcpCodecs class: Provides factory methods to create serializers and deserializers (e.g., TcpCodecs.lengthHeader1()).

The FTP outbound gateway allows interaction with remote FTP or FTPS servers using a specific set of commands. It acts as a gateway to perform file operations such as listing, retrieving, sending, moving, or removing files.

Supported Commands:

• ls (list files)
• nlst (list file names)
• get (retrieve file)
• mget (retrieve file(s))
• rm (remove file(s))
• mv (move/rename file)
• put (send file)
• mput (send multiple files)

Spring Integration provides a wide array of protocol-specific channel adapters and gateways to connect your application to external systems. Supported integration endpoints include:

• Messaging Protocols: AMQP, MQTT, RSocket, STOMP, WebSockets, XMPP, ZeroMQ, and Syslog.
• Databases & Persistence: JDBC, JPA, Cassandra, MongoDB, Redis, and R2DBC.
• File & Network Systems: File, FTP/FTPS, SFTP, SMB, TCP/UDP, and Spring Resources.
• Web & APIs: HTTP, WebFlux, GraphQL, Web Services (SOAP), and XML (XPath).
• Messaging & Streaming: Apache Kafka, JMS, Apache Camel, and Debezium CDC.
• Other Integrations: Spring ApplicationEvent, JMX, Mail, Hazelcast, and Zookeeper.

Samples are organized into four categories based on the developer's expertise and the sample's goal:

• Basic (samples/basic): Best for getting started. Focuses on technical use cases, bare minimum configuration, and core concepts like Service Activators, Messaging Gateways, and Enterprise Integration Patterns (EIP).
• Intermediate (samples/intermediate): For developers familiar with the framework who need guidance on advanced technical problems, such as error handling or complex aggregator configurations.
• Advanced (samples/advanced): For experts looking to extend the framework using the public API, such as implementing custom channels, consumers, or adapters.
• Applications (samples/applications): Focuses on business use cases (e.g., loan brokers, travel agents) to demonstrate how to solve real-world problems using message-driven architecture.

The SFTP outbound gateway allows you to interact with a remote SFTP server using a specific set of commands. It acts as a gateway to perform file operations such as listing, retrieving, removing, moving, and sending files.

Supported commands include:

• ls (list files)
• nlst (list file names)
• get (retrieve a file)
• mget (retrieve multiple files)
• rm (remove file(s))
• mv (move and rename file)
• put (send a file)
• mput (send multiple files)

A Service Activator is an endpoint type used to connect any Spring-managed object to an input channel, allowing that object to act as a service. It is a generic endpoint that invokes a method on a target object using an input message (payload and headers).

Key characteristics:

• Input/Output: It consumes messages from an input channel. If the service produces output, it can be connected to an output-channel. If no output channel is defined, it uses the replyChannel header from the inbound message.
• Versatility: It serves as the foundation for many specialized components like outbound gateways and outbound channel adapters.
• Return Behavior: If the method returns a non-null value, the framework attempts to send a reply. If the method returns void or null, the service activator exits without sending a signal.

A channel adapter is a message endpoint that connects a single sender or receiver to a message channel. Spring Integration provides various adapters for different transports (JMS, file, HTTP, etc.), but the core concept includes method-invoking adapters that allow you to use any Spring-managed object as a source or destination for messages.

• Inbound Channel Adapter: Invokes a method on a source object and sends the non-null return value to a MessageChannel as a Message.
• Outbound Channel Adapter: Connects a MessageChannel to a POJO consumer method, invoking it with the message payload.

The Scatter-Gather pattern is a compound endpoint used to send a single message to multiple recipients (the 'scatter' phase) and then aggregate their individual replies into a single result (the 'gather' phase). It is ideal for scenarios like a "best quote" request, where you query multiple suppliers and decide on the best option based on the combined results.

In Spring Integration, the ScatterGatherHandler implements this pattern by combining a scatterer (either a PublishSubscribeChannel or a RecipientListRouter) with an aggregator (AggregatingMessageHandler).

Spring Integration implements Enterprise Integration Patterns (EIP) to facilitate messaging-based communication between different systems. The core architecture is built around several key abstractions:

• Core Messaging: The fundamental building blocks including Messages, Message Channels, and Messaging Endpoints.
• Message Routing: Components that direct messages to specific channels, such as Routers, Splitters, Aggregators, and Filters.
• Message Transformation: Components that modify message content or structure, including Transformers, Content Enrichers, Claim Checks, and Codecs.
• Messaging Endpoints: The points where messages enter or leave the integration flow, such as Service Activators, Gateways, and Adapters.

You can define these integration flows using several Domain Specific Languages (DSLs):

• Java DSL
• Groovy DSL
• Kotlin DSL