Spring Integration

https://docs.spring.io/spring-integration/reference/
Admin
Spring Integration provides enterprise integration patterns and tools for message-driven...
Tokens:492,816
Snippets:4,861
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Configure MQTT Outbound Adapter with Java DSL

Source: https://docs.spring.io/spring-integration/reference/mqtt.html

This example shows how to configure an MQTT outbound adapter using the Spring Integration Java DSL, which simplifies the setup into an IntegrationFlow.

```java
@SpringBootApplication
public class MqttJavaApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(MqttJavaApplication.class)
            .web(false)
            .run(args);
    }

       @Bean
       public IntegrationFlow mqttOutboundFlow() {
           return f -> f.handle(new MqttPahoMessageHandler("tcp://host1:1883", "someMqttClient"));
    }

}
```

--------------------------------

### Inbound Channel Adapter Configuration Examples

Source: https://docs.spring.io/spring-integration/reference/file/reading.html

Examples of configuring inbound channel adapters with various filtering strategies including default filters, custom beans, filename patterns, and regex patterns.

```xml
<int-file:inbound-channel-adapter id="filesIn1"
    directory="file:${input.directory}" prevent-duplicates="true" ignore-hidden="true"/>

<int-file:inbound-channel-adapter id="filesIn2"
    directory="file:${input.directory}"
    filter="customFilterBean" />

<int-file:inbound-channel-adapter id="filesIn3"
    directory="file:${input.directory}"
    filename-pattern="test*" />

<int-file:inbound-channel-adapter id="filesIn4"
    directory="file:${input.directory}"
    filename-regex="test[0-9]+\.txt" />
```

--------------------------------

### Sample Component Configuration

Source: https://docs.spring.io/spring-integration/reference/message-history.html

Example of components that can be tracked by the message history mechanism.

```java
@MessagingGateway(defaultRequestChannel = "bridgeInChannel")
public interface SampleGateway {
   ...
}

@Bean
@Transformer(inputChannel = "enricherChannel", outputChannel="filterChannel")
HeaderEnricher sampleEnricher() {
    HeaderEnricher enricher =
           new HeaderEnricher(Collections.singletonMap("baz", new StaticHeaderValueMessageProcessor("baz")));
    return enricher;
}
```

```xml
<int:gateway id="sampleGateway"
    service-interface="org.springframework.integration.history.sample.SampleGateway"
    default-request-channel="bridgeInChannel"/>

<int:header-enricher id="sampleEnricher" input-channel="enricherChannel" output-channel="filterChannel">
    <int:header name="baz" value="baz"/>
</int:header-enricher>
```

--------------------------------

### URI Template Path Example

Source: https://docs.spring.io/spring-integration/reference/http/namespace.html

An example of a URI template path used for inbound request mapping.

```text
/first-name/{firstName}/last-name/{lastName}
```

--------------------------------

### Implement IntegrationFlow interface

Source: https://docs.spring.io/spring-integration/reference/dsl/java-flow-adapter.html

Example of implementing the IntegrationFlow interface directly to be picked up by the IntegrationFlowBeanPostProcessor.

```java
@Component
public class MyFlow implements IntegrationFlow {

    @Override
    public void configure(IntegrationFlowDefinition<?> f) {
        f.<String, String>transform(String::toUpperCase);
    }

}
```

--------------------------------

### Configure Inbound Stdin Channel Adapter

Source: https://docs.spring.io/spring-integration/reference/stream.html

Examples of configuring the stdin-channel-adapter with and without a specified charset.

```xml
<int-stream:stdin-channel-adapter id="adapterWithDefaultCharset"/>

<int-stream:stdin-channel-adapter id="adapterWithProvidedCharset" charset="UTF-8"/>
```

--------------------------------

### Control Bus GET request response format

Source: https://docs.spring.io/spring-integration/reference/http/control-bus-controller.html

Example of the JSON response returned by a GET request to /control-bus, listing available beans and their associated control bus commands.

```json
[
  {
    "beanName": "errorChannel",
    "commands": [
      {
        "command": "errorChannel.setShouldTrack",
        "description": "setShouldTrack",
        "parameterTypes": [
          "boolean"
        ]
      },
      {
        "command": "errorChannel.setLoggingEnabled",
        "description": "Use to disable debug logging during normal message flow",
        "parameterTypes": [
          "boolean"
        ]
      },
      {
        "command": "errorChannel.isLoggingEnabled",
        "description": "isLoggingEnabled",
        "parameterTypes": []
      }
    ]
  },
  {
    "beanName": "testManagementComponent",
    "commands": [
      {
        "command": "testManagementComponent.operation2",
        "description": "operation2",
        "parameterTypes": []
      },
      {
        "command": "testManagementComponent.operation",
        "description": "operation",
        "parameterTypes": []
      },
      {
        "command": "testManagementComponent.operation",
        "description": "operation",
        "parameterTypes": [
          "int",
          "java.lang.String"
        ]
      },
      {
        "command": "testManagementComponent.operation",
        "description": "operation",
        "parameterTypes": [
          "int"
        ]
      }
    ]
  }
]
```

--------------------------------

### Configure SmbSessionFactory with SMB protocol versions

Source: https://docs.spring.io/spring-integration/reference/smb.html

Demonstrates setting up an SMB session factory with explicit minimum and maximum SMB protocol versions using DialectVersion.

```java
@Bean
public SmbSessionFactory smbSessionFactory() {
    SmbSessionFactory smbSession = new SmbSessionFactory();
    smbSession.setHost("myHost");
    smbSession.setPort(445);
    smbSession.setDomain("myDomain");
    smbSession.setUsername("myUser");
    smbSession.setPassword("myPassword");
    smbSession.setShareAndDir("myShareAndDir");
    smbSession.setSmbMinVersion(DialectVersion.SMB210);
    smbSession.setSmbMaxVersion(DialectVersion.SMB311);
    return smbSession;
}
```

--------------------------------

### Configure XMPP MessageHandler with Java Configuration

Source: https://docs.spring.io/spring-integration/reference/overview.html

Example of configuring a ChatMessageSendingMessageHandler as a bean for use with @ServiceActivator, including header mapper setup.

```java
@Bean
@ServiceActivator(inputChannel = "input")
public MessageHandler sendChatMessageHandler(XMPPConnection xmppConnection) {
    ChatMessageSendingMessageHandler handler = new ChatMessageSendingMessageHandler(xmppConnection);

    DefaultXmppHeaderMapper xmppHeaderMapper = new DefaultXmppHeaderMapper();
    xmppHeaderMapper.setRequestHeaderNames("*");
    handler.setHeaderMapper(xmppHeaderMapper);

    return handler;
}
```

--------------------------------

### Configure Inbound Adapter with Java Configuration

Source: https://docs.spring.io/spring-integration/reference/mqtt.html

Example of setting up an MqttPahoMessageDrivenChannelAdapter using standard Spring Boot Java configuration.

```java
@SpringBootApplication
public class MqttJavaApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(MqttJavaApplication.class)
                .web(false)
                .run(args);
    }

    @Bean
    public MessageChannel mqttInputChannel() {
        return new DirectChannel();
    }

    @Bean
    public MessageProducer inbound() {
        MqttPahoMessageDrivenChannelAdapter adapter =
                new MqttPahoMessageDrivenChannelAdapter("tcp://localhost:1883", "testClient",
                                                 "topic1", "topic2");
        adapter.setCompletionTimeout(5000);
        adapter.setConverter(new DefaultPahoMessageConverter());
        adapter.setQos(1);
        adapter.setOutputChannel(mqttInputChannel());
        return adapter;
    }

    @Bean
    @ServiceActivator(inputChannel = "mqttInputChannel")
    public MessageHandler handler() {
        return new MessageHandler() {

            @Override
            public void handleMessage(Message<?> message) throws MessagingException {
                System.out.println(message.getPayload());
            }

        };
    }

}
```

--------------------------------

### Filter definition with discardFlow sub-flow

Source: https://docs.spring.io/spring-integration/reference/dsl/java-subflows.html

An example of a filter definition using a discardFlow sub-flow that starts with a channel() element, triggering an implicit bridge creation.

```java
.filter(p -> p instanceof String, e -> e
	.discardFlow(df -> df
                         .channel(MessageChannels.queue())
                         ...)
```

--------------------------------

### Configure simple publishing-interceptor

Source: https://docs.spring.io/spring-integration/reference/message-publishing.html

This example shows a minimal <publishing-interceptor> configuration where defaults are used for mapping return values.

```xml
<publishing-interceptor id="anotherInterceptor"/>
```

--------------------------------

### Configure Inbound Adapter with Java DSL

Source: https://docs.spring.io/spring-integration/reference/mqtt.html

Example of setting up an MqttPahoMessageDrivenChannelAdapter using the Spring Integration Java DSL.

```java
@SpringBootApplication
public class MqttJavaApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(MqttJavaApplication.class)
            .web(false)
            .run(args);
    }

    @Bean
    public IntegrationFlow mqttInbound() {
        return IntegrationFlow.from(
                         new MqttPahoMessageDrivenChannelAdapter("tcp://localhost:1883",
                                        "testClient", "topic1", "topic2"))
                .handle(m -> System.out.println(m.getPayload()))
                .get();
    }

}
```

--------------------------------

### Defining a Custom Smack Providers XML File

Source: https://docs.spring.io/spring-integration/reference/xmpp.html

Example structure for a .providers configuration file defining iqProvider and extensionProvider elements.

```xml
<?xml version="1.0"?>
<smackProviders>
<iqProvider>
    <elementName>query</elementName>
    <namespace>jabber:iq:time</namespace>
    <className>org.jivesoftware.smack.packet.Time</className>
</iqProvider>

<iqProvider>
    <elementName>query</elementName>
    <namespace>https://jabber.org/protocol/disco#items</namespace>
    <className>org.jivesoftware.smackx.provider.DiscoverItemsProvider</className>
</iqProvider>

<extensionProvider>
    <elementName>subscription</elementName>
    <namespace>https://jabber.org/protocol/pubsub</namespace>
    <className>org.jivesoftware.smackx.pubsub.provider.SubscriptionProvider</className>
</extensionProvider>
</smackProviders>
```

--------------------------------

### FileTailingIdleEvent Example

Source: https://docs.spring.io/spring-integration/reference/file/reading.html

Example of the event emitted when no data is detected in the file during the idleEventInterval.

```text
[message=Idle timeout, file=/tmp/somefile] [idle time=5438]
```

--------------------------------

### IMAPMessage.getContent() output example

Source: https://docs.spring.io/spring-integration/reference/mail.html

Example of the output rendered by IMAPMessage.getContent() for a simple text email.

```text
To: thing1@things.com
From: thing2@morethings.com
Subject: Test Email

something
```

--------------------------------

### Configure Inbound Gateway with Java DSL Alternative

Source: https://docs.spring.io/spring-integration/reference/kafka.html

Alternative example of configuring an inbound gateway using the Java DSL with factory methods.

```java
@Bean
public IntegrationFlow serverGateway() {
    return IntegrationFlow
            .from(Kafka.inboundGateway(consumerFactory(), containerProperties(),
                    producerFactory())
                .replyTimeout(30_000))
            .<String, String>transform(String::toUpperCase)
            .get();
}
```

--------------------------------

### BeanCreationException Example

Source: https://docs.spring.io/spring-integration/reference/dsl/java-subflows.html

An example of the exception thrown when a one-way MessageHandler is incorrectly configured for an output channel.

```text
Caused by: org.springframework.beans.factory.BeanCreationException:
    The 'currentComponent' (org.springframework.integration.router.MethodInvokingRouter@7965a51c)
    is a one-way 'MessageHandler' and it isn't appropriate to configure 'outputChannel'.
    This is the end of the integration flow.
```

--------------------------------

### Example File Tailing Events

Source: https://docs.spring.io/spring-integration/reference/file/reading.html

Shows the format of ApplicationEvent instances published when file system events occur during tailing.

```text
[message=tail: cannot open '/tmp/somefile' for reading:
               No such file or directory, file=/tmp/somefile]

[message=tail: '/tmp/somefile' has become accessible, file=/tmp/somefile]

[message=tail: '/tmp/somefile' has become inaccessible:
               No such file or directory, file=/tmp/somefile]

[message=tail: '/tmp/somefile' has appeared;
               following end of new file, file=/tmp/somefile]
```

--------------------------------

### Configure SFTP Outbound Adapter with Java

Source: https://docs.spring.io/spring-integration/reference/sftp/outbound.html

A complete Spring Boot application example demonstrating the configuration of an SFTP outbound adapter, including the session factory, message handler, and messaging gateway.

```java
@SpringBootApplication
@IntegrationComponentScan
public class SftpJavaApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context =
                    new SpringApplicationBuilder(SftpJavaApplication.class)
                        .web(false)
                        .run(args);
        MyGateway gateway = context.getBean(MyGateway.class);
        gateway.sendToSftp(new File("/foo/bar.txt"));
    }

    @Bean
    public SessionFactory<SftpClient.DirEntry> sftpSessionFactory() {
        DefaultSftpSessionFactory factory = new DefaultSftpSessionFactory(true);
        factory.setHost("localhost");
        factory.setPort(port);
        factory.setUser("foo");
        factory.setPassword("foo");
        factory.setAllowUnknownKeys(true);
        return new CachingSessionFactory<SftpClient.DirEntry>(factory);
    }

    @Bean
    @ServiceActivator(inputChannel = "toSftpChannel")
    public MessageHandler handler() {
        SftpMessageHandler handler = new SftpMessageHandler(sftpSessionFactory());
        handler.setRemoteDirectoryExpressionString("headers['remote-target-dir']");
        handler.setFileNameGenerator(new FileNameGenerator() {

            @Override
            public String generateFileName(Message<?> message) {
                 return "handlerContent.test";
            }

        });
        return handler;
    }

    @MessagingGateway
    public interface MyGateway {

         @Gateway(requestChannel = "toSftpChannel")
         void sendToSftp(File file);

    }
}
```

--------------------------------

### Spring Boot Mail Application Setup

Source: https://docs.spring.io/spring-integration/reference/mail.html

Basic Spring Boot application setup for mail integration.

```java
@SpringBootApplication
public class MailApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(MailApplication.class)
            .web(false)
            .run(args);
    }
```

--------------------------------

### Configuring MQTT v5 Outbound Channel Adapter with Java DSL

Source: https://docs.spring.io/spring-integration/reference/mqtt.html

This example demonstrates how to configure an Mqttv5PahoMessageHandler using the Java DSL, including setting up a custom header mapper and enabling asynchronous events.

```java
@Bean
public IntegrationFlow mqttOutFlow() {
    Mqttv5PahoMessageHandler messageHandler = new Mqttv5PahoMessageHandler(MQTT_URL, "mqttv5SIout");
    MqttHeaderMapper mqttHeaderMapper = new MqttHeaderMapper();
    mqttHeaderMapper.setOutboundHeaderNames("some_user_header", MessageHeaders.CONTENT_TYPE);
    messageHandler.setHeaderMapper(mqttHeaderMapper);
    messageHandler.setAsync(true);
    messageHandler.setAsyncEvents(true);
    messageHandler.setConverter(mqttStringToBytesConverter());

    return f -> f.handle(messageHandler);
}
```

--------------------------------

### JSON Wire Format Example

Source: https://docs.spring.io/spring-integration/reference/ip/correlation.html

Example of the resulting JSON structure on the wire for a message with a payload of 'something' and the specified headers.

```json
{"headers":{"correlationId":"things","sequenceSize":5,"sequenceNumber":1},"payload":"something"}
```

--------------------------------

### RedisCommandExecutionException Example

Source: https://docs.spring.io/spring-integration/reference/redis.html

An example of the error message encountered when Redis scripts attempt to access keys that do not hash to the same slot in a cluster environment.

```text
Caused by: io.lettuce.core.RedisCommandExecutionException: ERR Script attempted to access keys that do not hash to the same slot script: b2dedc0ab01c17f9f20e3e6ddb62dcb6afbed0bd, on @user_script:3.
```

--------------------------------

### Configure SmbSessionFactory with custom CIFSContext

Source: https://docs.spring.io/spring-integration/reference/smb.html

Shows how to initialize the SMB session factory using a custom implementation of org.codelibs.jcifs.smb.CIFSContext.

```java
@Bean
public SmbSessionFactory smbSessionFactory() {
    SmbSessionFactory smbSession = new SmbSessionFactory(new MyCIFSContext());
    smbSession.setHost("myHost");
    smbSession.setPort(445);
    smbSession.setDomain("myDomain");
    smbSession.setUsername("myUser");
    smbSession.setPassword("myPassword");
    smbSession.setShareAndDir("myShareAndDir");
    return smbSession;
}
```

--------------------------------

### Configure ClientManager and IntegrationFlows

Source: https://docs.spring.io/spring-integration/reference/mqtt.html

Demonstrates defining a Mqttv5ClientManager bean and using it across multiple inbound and outbound IntegrationFlows.

```java
@Bean
public ClientManager<IMqttAsyncClient, MqttConnectionOptions> clientManager() {
    MqttConnectionOptions connectionOptions = new MqttConnectionOptions();
    connectionOptions.setServerURIs(new String[]{ "tcp://localhost:1883" });
    connectionOptions.setConnectionTimeout(30000);
    connectionOptions.setMaxReconnectDelay(1000);
    connectionOptions.setAutomaticReconnect(true);
    Mqttv5ClientManager clientManager = new Mqttv5ClientManager(connectionOptions, "client-manager-client-id-v5");
    clientManager.setPersistence(new MqttDefaultFilePersistence());
    return clientManager;
}

@Bean
public IntegrationFlow mqttInFlowTopic1(
        ClientManager<IMqttAsyncClient, MqttConnectionOptions> clientManager) {

    Mqttv5PahoMessageDrivenChannelAdapter messageProducer =
        new Mqttv5PahoMessageDrivenChannelAdapter(clientManager, "topic1");
    return IntegrationFlow.from(messageProducer)
            .channel(c -> c.queue("fromMqttChannel"))
            .get();
}

@Bean
public IntegrationFlow mqttInFlowTopic2(
        ClientManager<IMqttAsyncClient, MqttConnectionOptions> clientManager) {

    Mqttv5PahoMessageDrivenChannelAdapter messageProducer =
        new Mqttv5PahoMessageDrivenChannelAdapter(clientManager, "topic2");
    return IntegrationFlow.from(messageProducer)
            .channel(c -> c.queue("fromMqttChannel"))
            .get();
}

@Bean
public IntegrationFlow mqttOutFlow(
        ClientManager<IMqttAsyncClient, MqttConnectionOptions> clientManager) {

    return f -> f.handle(new Mqttv5PahoMessageHandler(clientManager));
}
```

--------------------------------

### Usage examples of the #xpath SpEL function

Source: https://docs.spring.io/spring-integration/reference/xml/xpath-spel-function.html

Examples showing the #xpath function used within transformer, filter, splitter, and router components.

```xml
<transformer expression="#xpath(payload, '/name')"/>

<filter expression="#xpath(payload, headers.xpath, 'boolean')"/>

<splitter expression="#xpath(payload, '//book', 'document_list')"/>

<router expression="#xpath(payload, '/person/@age', 'number')">
    <mapping channel="output1" value="16"/>
    <mapping channel="output2" value="45"/>
</router>
```

--------------------------------

### Ambiguous Method Argument Mapping Examples

Source: https://docs.spring.io/spring-integration/reference/gateway.html

Examples of method signatures where default mapping conventions may fail to distinguish between payload and header arguments.

```java
public String send1(Object thing1, Map thing2);

public String send2(Map thing1, Map thing2);
```

--------------------------------

### Configure ContextHolderRequestHandlerAdvice with DelegatingSessionFactory

Source: https://docs.spring.io/spring-integration/reference/handler-advice/context-holder.html

This example demonstrates configuring the advice to manage thread keys for a DelegatingSessionFactory and applying it to an FtpOutboundGateway via an advice chain.

```java
@Bean
DelegatingSessionFactory<?> dsf(SessionFactory<?> one, SessionFactory<?> two) {
    return new DelegatingSessionFactory<>(Map.of("one", one, "two", two), null);
}

@Bean
ContextHolderRequestHandlerAdvice contextHolderRequestHandlerAdvice(DelegatingSessionFactory<String> dsf) {
    return new ContextHolderRequestHandlerAdvice(message -> message.getHeaders().get("FACTORY_KEY"),
                                      dsf::setThreadKey, dsf::clearThreadKey);
}

@ServiceActivator(inputChannel = "in", adviceChain = "contextHolderRequestHandlerAdvice")
FtpOutboundGateway ftpOutboundGateway(DelegatingSessionFactory<?> sessionFactory) {
	return new FtpOutboundGateway(sessionFactory, "ls", "payload");
}
```

--------------------------------

### Define an IntegrationFlow using a lambda

Source: https://docs.spring.io/spring-integration/reference/dsl/java-flows.html

Demonstrates how to define a direct IntegrationFlow using a lambda expression. This flow is started with a named direct channel and cannot start from a MessageSource or MessageProducer.

```java
@Bean
public IntegrationFlow lambdaFlow() {
    return f -> f.filter("World"::equals)
                   .transform("Hello "::concat)
                   .handle(System.out::println);
}
```

--------------------------------

### Piping Data via Command Line

Source: https://docs.spring.io/spring-integration/reference/stream.html

Examples of redirecting file data to standard input for the application.

```bash
cat myfile.txt | java -jar my.jar
```

```bash
java -jar my.jar < foo.txt
```

--------------------------------

### Configuring MailSendingMessageHandler

Source: https://docs.spring.io/spring-integration/reference/mail.html

Example of initializing a MailSendingMessageHandler using a JavaMailSender bean.

```java
 JavaMailSender mailSender = context.getBean("mailSender", JavaMailSender.class);

 MailSendingMessageHandler mailSendingHandler = new MailSendingMessageHandler(mailSender);
```

--------------------------------

### Configure inbound-streaming-channel-adapter

Source: https://docs.spring.io/spring-integration/reference/ftp/streaming.html

Example configuration for the FTP streaming inbound channel adapter using XML.

```xml
<int-ftp:inbound-streaming-channel-adapter id="ftpInbound"
            channel="ftpChannel"
            session-factory="sessionFactory"
            filename-pattern="*.txt"
            filename-regex=".*\.txt"
            filter="filter"
            filter-expression="@myFilterBean.check(#root)"
            remote-file-separator="/"
            comparator="comparator"
            max-fetch-size="1"
            remote-directory-expression="'foo/bar'">
        <int:poller fixed-rate="1000" />
</int-ftp:inbound-streaming-channel-adapter>
```

--------------------------------

### Configure SimpleReactiveMongoDatabaseFactory

Source: https://docs.spring.io/spring-integration/reference/mongodb.html

Examples for connecting to MongoDB using the reactive SimpleReactiveMongoDatabaseFactory.

```java
ReactiveMongoDatabaseFactory mongoDbFactory =
        new SimpleReactiveMongoDatabaseFactory(com.mongodb.reactivestreams.client.MongoClients.create(), "test");
```

```xml
<bean id="mongoDbFactory" class="o.s.data.mongodb.core.SimpleReactiveMongoDatabaseFactory">
    <constructor-arg>
        <bean class="com.mongodb.reactivestreams.client.MongoClients" factory-method="create"/>
    </constructor-arg>
    <constructor-arg value="test"/>
</bean>
```

--------------------------------

### Configure ZeroMqChannel with Java DSL

Source: https://docs.spring.io/spring-integration/reference/zeromq.html

Example of using the ZeroMq factory to configure a ZeroMqChannel with a connection URL and consume delay.

```java
.channel(ZeroMq.zeroMqChannel(this.context)
            .connectUrl("tcp://localhost:6001:6002")
            .consumeDelay(Duration.ofMillis(100)))
}
```

--------------------------------

### Configure SimpleMongoClientDatabaseFactory

Source: https://docs.spring.io/spring-integration/reference/mongodb.html

Examples for connecting to MongoDB using the blocking SimpleMongoClientDatabaseFactory.

```java
MongoDatabaseFactory mongoDbFactory =
        new SimpleMongoClientDatabaseFactory(com.mongodb.client.MongoClients.create(), "test");
```

```xml
<bean id="mongoDbFactory" class="o.s.data.mongodb.core.SimpleMongoClientDatabaseFactory">
    <constructor-arg>
        <bean class="com.mongodb.client.MongoClients" factory-method="create"/>
    </constructor-arg>
    <constructor-arg value="test"/>
</bean>
```

--------------------------------

### EventDrivenConsumer instantiation

Source: https://docs.spring.io/spring-integration/reference/endpoint.html

Example of creating an EventDrivenConsumer by providing a SubscribableChannel and a MessageHandler.

```java
SubscribableChannel channel = context.getBean("subscribableChannel", SubscribableChannel.class);

EventDrivenConsumer consumer = new EventDrivenConsumer(channel, exampleHandler);
```

--------------------------------

### Configure Inbound Gateway with Java

Source: https://docs.spring.io/spring-integration/reference/kafka.html

Example of configuring an inbound gateway using standard Java bean definitions.

```java
@Bean
public KafkaInboundGateway<Integer, String, String> inboundGateway(
        AbstractMessageListenerContainer<Integer, String>container,
        KafkaTemplate<Integer, String> replyTemplate) {

    KafkaInboundGateway<Integer, String, String> gateway =
        new KafkaInboundGateway<>(container, replyTemplate);
    gateway.setRequestChannel(requests);
    gateway.setReplyChannel(replies);
    gateway.setReplyTimeout(30_000);
    return gateway;
}
```

--------------------------------

### Configure GraphQlMessageHandler and IntegrationFlow

Source: https://docs.spring.io/spring-integration/reference/graphql.html

This example demonstrates how to define the GraphQlMessageHandler, the IntegrationFlow, and the necessary ExecutionGraphQlService and GraphQlSource beans.

```java
@Bean
GraphQlMessageHandlerSpec graphQlMessageHandlerSpec(ExecutionGraphQlService graphQlService) {
    return GraphQl.gateway(graphQlService)
            .operation("""
                    query HeroNameAndFriends($episode: Episode) {
                      hero(episode: $episode) {
                        name
                        friends {
                          name
                        }
                      }
                    }""")
            .variablesExpression("{episode:'JEDI'}");
}

@Bean
IntegrationFlow graphqlQueryMessageHandlerFlow(GraphQlMessageHandler handler) {
    return IntegrationFlow.from(MessageChannels.flux("inputChannel"))
            .handle(handler)
            .channel(c -> c.flux("resultChannel"))
            .get();
}

@Bean
ExecutionGraphQlService graphQlService(GraphQlSource graphQlSource) {
    return new DefaultExecutionGraphQlService(graphQlSource);
}

@Bean
GraphQlSource graphQlSource(AnnotatedControllerConfigurer annotatedDataFetcherConfigurer) {
    return GraphQlSource.builder()
            .schemaResources(new ClassPathResource("graphql/test-schema.graphqls"))
            .configureRuntimeWiring(annotatedDataFetcherConfigurer)
            .build();
}

@Bean
AnnotatedControllerConfigurer annotatedDataFetcherConfigurer() {
    return new AnnotatedControllerConfigurer();
}
```

--------------------------------

### Define Protocol Buffers IDL

Source: https://docs.spring.io/spring-integration/reference/transformer.html

Example IDL definition for generating a MyMessageClass.

```protobuf
syntax = "proto2";
package tutorial;

option java_multiple_files = true;
option java_package = "org.example";
option java_outer_classname = "MyProtos";

message MyMessageClass {
  optional string foo = 1;
  optional string bar = 2;
}
```

--------------------------------

### Configure WatchService for File Events

Source: https://docs.spring.io/spring-integration/reference/file/reading.html

Example showing how to configure inbound channel adapters to handle file creation and modification events using the WatchService.

```xml
<int-file:inbound-channel-adapter id="newFiles"
     directory="${input.directory}"
     use-watch-service="true"/>

<int-file:inbound-channel-adapter id="modifiedFiles"
     directory="${input.directory}"
     use-watch-service="true"
     filter="acceptAllFilter"
     watch-events="MODIFY"/> <!-- The default is CREATE. -->
```

--------------------------------

### ObjectMapperFactory Implementation

Source: https://docs.spring.io/spring-integration/reference/transformer.html

Example of using a factory method to create a custom JacksonJsonObjectMapper.

```java
public class ObjectMapperFactory {

    public static JacksonJsonObjectMapper getMapper() {
        ObjectMapper mapper = JsonMapper.builder()
				.configure(JsonReadFeature.ALLOW_JAVA_COMMENTS, true)
				.build();
        return new JacksonJsonObjectMapper(mapper);
    }
}
```

--------------------------------

### StreamTransformer Java DSL

Source: https://docs.spring.io/spring-integration/reference/transformer.html

Example of using the Java DSL to configure a StreamTransformer.

```java
@Bean
public IntegrationFlow someFlow() {
    return IntegrationFlow
             .from("input")
             .transform(Transformers.fromStream("UTF-8"))
             .channel("output")
             .get();
}
```

--------------------------------

### Message History Output Example

Source: https://docs.spring.io/spring-integration/reference/message-history.html

The structure of the message history header value.

```text
[{name=sampleGateway, type=gateway, timestamp=1283281668091},
 {name=sampleEnricher, type=header-enricher, timestamp=1283281668094}]
```

--------------------------------

### Define a basic chain with input and output channels

Source: https://docs.spring.io/spring-integration/reference/chain.html

This example demonstrates a chain containing a filter, a header enricher, and a service activator, connected via input and output channels.

```xml
<int:chain input-channel="input" output-channel="output">
    <int:filter ref="someSelector" throw-exception-on-rejection="true"/>
    <int:header-enricher>
        <int:header name="thing1" value="thing2"/>
    </int:header-enricher>
    <int:service-activator ref="someService" method="someMethod"/>
</int:chain>
```

--------------------------------

### Configure MQTT Outbound Adapter with Java Configuration

Source: https://docs.spring.io/spring-integration/reference/mqtt.html

This example demonstrates a Spring Boot application using @Bean definitions to configure an MqttPahoClientFactory and an MqttPahoMessageHandler, along with a messaging gateway to send data.

```java
@SpringBootApplication
@IntegrationComponentScan
public class MqttJavaApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context =
                new SpringApplicationBuilder(MqttJavaApplication.class)
                        .web(false)
                        .run(args);
        MyGateway gateway = context.getBean(MyGateway.class);
        gateway.sendToMqtt("foo");
    }

    @Bean
    public MqttPahoClientFactory mqttClientFactory() {
        DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();
        MqttConnectOptions options = new MqttConnectOptions();
        options.setServerURIs(new String[] { "tcp://host1:1883", "tcp://host2:1883" });
        options.setUserName("username");
        options.setPassword("password".toCharArray());
        factory.setConnectionOptions(options);
        return factory;
    }

    @Bean
    @ServiceActivator(inputChannel = "mqttOutboundChannel")
    public MessageHandler mqttOutbound() {
        MqttPahoMessageHandler messageHandler =
                       new MqttPahoMessageHandler("testClient", mqttClientFactory());
        messageHandler.setAsync(true);
        messageHandler.setDefaultTopic("testTopic");
        return messageHandler;
    }

    @Bean
    public MessageChannel mqttOutboundChannel() {
        return new DirectChannel();
    }

    @MessagingGateway(defaultRequestChannel = "mqttOutboundChannel")
    public interface MyGateway {

        void sendToMqtt(String data);

    }

}
```
Tokens:
Raw