diff --git a/build.gradle b/build.gradle index c71190a468..d46acaa75b 100644 --- a/build.gradle +++ b/build.gradle @@ -783,7 +783,6 @@ asciidoctor { imagesdir: '', stylesdir: "stylesheets/", stylesheet: 'golo.css', - 'spring-integration-version': "$version", 'source-highlighter': 'highlightjs' ] } diff --git a/src/reference/asciidoc/amqp.adoc b/src/reference/asciidoc/amqp.adoc index e589df4e86..907f8e5ee9 100644 --- a/src/reference/asciidoc/amqp.adoc +++ b/src/reference/asciidoc/amqp.adoc @@ -2,6 +2,27 @@ == AMQP Support Spring Integration provides channel adapters for receiving and sending messages by using the Advanced Message Queuing Protocol (AMQP). + +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-amqp + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-amqp:{project-version}" +---- +==== + The following adapters are available: * <> @@ -18,8 +39,7 @@ Spring AMQP provides similar semantics to (http://docs.spring.io/spring/docs/cur Whereas the provided AMQP Channel Adapters are intended for unidirectional messaging (send or receive) only, Spring Integration also provides inbound and outbound AMQP gateways for request-reply operations. TIP: -You should familiarize yourself with the -http://docs.spring.io/spring-amqp/reference/html/[reference documentation of the Spring AMQP project]. +You should familiarize yourself with the http://docs.spring.io/spring-amqp/reference/html/[reference documentation of the Spring AMQP project]. It provides much more in-depth information about Spring's integration with AMQP in general and RabbitMQ in particular. [[amqp-inbound-channel-adapter]] diff --git a/src/reference/asciidoc/endpoint-summary.adoc b/src/reference/asciidoc/endpoint-summary.adoc index 7a4888b2f1..ee2f8aa6cf 100644 --- a/src/reference/asciidoc/endpoint-summary.adoc +++ b/src/reference/asciidoc/endpoint-summary.adoc @@ -3,6 +3,25 @@ As discussed in the earlier sections, Spring Integration provides a number of endpoints used to interface with external systems, file systems, and others. +For transparent dependency management Spring Integration provides a bill-of-materials POM to be imported into the Maven configuration: + +==== +[source, xml, subs="normal"] +---- + + + + org.springframework.integration + spring-integration-bom + {project-version} + pom + import + + + +---- +==== + To recap: * Inbound channel adapters are used for one-way integration to bring data into the messaging application. diff --git a/src/reference/asciidoc/event.adoc b/src/reference/asciidoc/event.adoc index 33d015e93d..1fff1840ff 100644 --- a/src/reference/asciidoc/event.adoc +++ b/src/reference/asciidoc/event.adoc @@ -4,6 +4,26 @@ Spring Integration provides support for inbound and outbound `ApplicationEvents`, as defined by the underlying Spring Framework. For more information about Spring's support for events and listeners, see the http://docs.spring.io/spring/docs/current/spring-framework-reference/html/beans.html#context-functionality-events[Spring Reference Manual]. +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-event + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-event:{project-version}" +---- +==== + [[appevent-inbound]] === Receiving Spring Application Events @@ -75,5 +95,4 @@ In the preceding example, all messages sent to the 'eventChannel' channel are pu If the payload of the message is an `ApplicationEvent`, it is passed as-is. Otherwise, the message itself is wrapped in a `MessagingEvent` instance. -Starting with version 4.2, you can configure the `ApplicationEventPublishingMessageHandler` (``) with the `publish-payload` boolean attribute to publish to the application context `payload` as is, -instead of wrapping it to a `MessagingEvent` instance. +Starting with version 4.2, you can configure the `ApplicationEventPublishingMessageHandler` (``) with the `publish-payload` boolean attribute to publish to the application context `payload` as is, instead of wrapping it to a `MessagingEvent` instance. diff --git a/src/reference/asciidoc/feed.adoc b/src/reference/asciidoc/feed.adoc index f4e363c7d2..afff1de0c7 100644 --- a/src/reference/asciidoc/feed.adoc +++ b/src/reference/asciidoc/feed.adoc @@ -4,6 +4,26 @@ Spring Integration provides support for syndication through feed adapters. The implementation is based on the https://rometools.github.io/rome/[ROME Framework]. +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-feed + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-feed:{project-version}" +---- +==== + Web syndication is a way to publish material such as news stories, press releases, blog posts, and other items typically available on a website but also made available in a feed format such as RSS or ATOM. Spring integration provides support for web syndication through its 'feed' adapter and provides convenient namespace-based configuration for it. diff --git a/src/reference/asciidoc/file.adoc b/src/reference/asciidoc/file.adoc index 1fe8368a5b..d17083742a 100644 --- a/src/reference/asciidoc/file.adoc +++ b/src/reference/asciidoc/file.adoc @@ -2,6 +2,27 @@ == File Support Spring Integration's file support extends the Spring Integration core with a dedicated vocabulary to deal with reading, writing, and transforming files. + +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-file + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-file:{project-version}" +---- +==== + It provides a namespace that enables elements defining channel adapters dedicated to files and support for transformers that can read file contents into strings or byte arrays. This section explains the workings of `FileReadingMessageSource` and `FileWritingMessageHandler` and how to configure them as beans. diff --git a/src/reference/asciidoc/ftp.adoc b/src/reference/asciidoc/ftp.adoc index 741274855b..5c52916d4a 100644 --- a/src/reference/asciidoc/ftp.adoc +++ b/src/reference/asciidoc/ftp.adoc @@ -6,6 +6,26 @@ Spring Integration provides support for file transfer operations with FTP and FT The File Transfer Protocol (FTP) is a simple network protocol that lets you transfer files between two computers on the Internet. FTPS stands for "`FTP over SSL`". +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-ftp + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-ftp:{project-version}" +---- +==== + There are two actors when it comes to FTP communication: client and server. To transfer files with FTP or FTPS, you use a client that initiates a connection to a remote computer that is running an FTP server. After the connection is established, the client can choose to send or receive copies of files. diff --git a/src/reference/asciidoc/gemfire.adoc b/src/reference/asciidoc/gemfire.adoc index e83e33e7e3..b9b136fe98 100644 --- a/src/reference/asciidoc/gemfire.adoc +++ b/src/reference/asciidoc/gemfire.adoc @@ -1,7 +1,27 @@ [[gemfire]] == Pivotal GemFire and Apache Geode Support -Spring Integration provides support for Pivotal GemFire and Apache Geode +Spring Integration provides support for Pivotal GemFire and Apache Geode. + +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-gemfire + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-gemfire:{project-version}" +---- +==== GemFire is a distributed data management platform that provides a key-value data grid along with advanced distributed system features, such as event processing, continuous querying, and remote function execution. This guide assumes some familiarity with the commercial https://pivotal.io/pivotal-gemfire[Pivotal GemFire] or Open Source http://geode.apache.org[Apache Geode]. diff --git a/src/reference/asciidoc/groovy.adoc b/src/reference/asciidoc/groovy.adoc index a9d7a73bcf..425ca77537 100644 --- a/src/reference/asciidoc/groovy.adoc +++ b/src/reference/asciidoc/groovy.adoc @@ -4,6 +4,26 @@ In Spring Integration 2.0, we added Groovy support, letting you use the Groovy scripting language to provide the logic for various integration components -- similar to the way the Spring Expression Language (SpEL) is supported for routing, transformation, and other integration concerns. For more information about Groovy, see the Groovy documentation, which you can find on the http://www.groovy-lang.org/[project website]. +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-groovy + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-groovy:{project-version}" +---- +==== + [[groovy-config]] ==== Groovy Configuration diff --git a/src/reference/asciidoc/http.adoc b/src/reference/asciidoc/http.adoc index fc3a6fdf4a..23a58c9633 100644 --- a/src/reference/asciidoc/http.adoc +++ b/src/reference/asciidoc/http.adoc @@ -5,6 +5,28 @@ Spring Integration's HTTP support allows for the running of HTTP requests and th The HTTP support consists of the following gateway implementations: `HttpInboundEndpoint` and `HttpRequestExecutingMessageHandler`. See also <>. +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-http + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-http:{project-version}" +---- +==== + +The `javax.servlet:javax.servlet-api` dependency must be provided on the target Servlet container. + [[http-inbound]] === Http Inbound Components diff --git a/src/reference/asciidoc/index-docinfo.xml b/src/reference/asciidoc/index-docinfo.xml index 1068977e72..3c43db4968 100644 --- a/src/reference/asciidoc/index-docinfo.xml +++ b/src/reference/asciidoc/index-docinfo.xml @@ -1,5 +1,5 @@ Spring Integration -{spring-integration-version} +{project-version} Mark diff --git a/src/reference/asciidoc/ip.adoc b/src/reference/asciidoc/ip.adoc index 8abe0652b0..bc19b4f3f9 100644 --- a/src/reference/asciidoc/ip.adoc +++ b/src/reference/asciidoc/ip.adoc @@ -7,6 +7,26 @@ Each adapter provides for one-way communication over the underlying protocol. In addition, Spring Integration provides simple inbound and outbound TCP gateways. These are used when two-way communication is needed. +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-ip + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-ip:{project-version}" +---- +==== + [[ip-intro]] === Introduction diff --git a/src/reference/asciidoc/jdbc.adoc b/src/reference/asciidoc/jdbc.adoc index 4e21bbf88b..fc69d58d00 100644 --- a/src/reference/asciidoc/jdbc.adoc +++ b/src/reference/asciidoc/jdbc.adoc @@ -4,6 +4,26 @@ Spring Integration provides channel adapters for receiving and sending messages by using database queries. Through those adapters, Spring Integration supports not only plain JDBC SQL queries but also stored procedure and stored function calls. +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-jdbc + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-jdbc:{project-version}" +---- +==== + By default, the following JDBC components are available: * <> diff --git a/src/reference/asciidoc/jms.adoc b/src/reference/asciidoc/jms.adoc index c4ba698df6..70fb8c2adf 100644 --- a/src/reference/asciidoc/jms.adoc +++ b/src/reference/asciidoc/jms.adoc @@ -2,6 +2,29 @@ == JMS Support Spring Integration provides channel adapters for receiving and sending JMS messages. + +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-jms + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-jms:{project-version}" +---- +==== + +The `javax.jms:javax.jms-api` must be added explicitly via some JMS vendor-specific implementation, e.g. Apache ActiveMQ. + There are actually two JMS-based inbound Channel Adapters. The first uses Spring's `JmsTemplate` to receive based on a polling period. The second is "`message-driven`" and relies on a Spring `MessageListener` container. diff --git a/src/reference/asciidoc/jmx.adoc b/src/reference/asciidoc/jmx.adoc index 9c503a690b..eeb8eb60bf 100644 --- a/src/reference/asciidoc/jmx.adoc +++ b/src/reference/asciidoc/jmx.adoc @@ -2,6 +2,27 @@ === JMX Support Spring Integration provides channel Adapters for receiving and publishing JMX Notifications. + +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-jmx + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-jmx:{project-version}" +---- +==== + An inbound channel adapter allows for polling JMX MBean attribute values, and an outbound channel adapter allows for invoking JMX MBean operations. [[jmx-notification-listening-channel-adapter]] diff --git a/src/reference/asciidoc/jpa.adoc b/src/reference/asciidoc/jpa.adoc index 6edfa2cd65..7875c97073 100644 --- a/src/reference/asciidoc/jpa.adoc +++ b/src/reference/asciidoc/jpa.adoc @@ -2,6 +2,29 @@ == JPA Support Spring Integration's JPA (Java Persistence API) module provides components for performing various database operations using JPA. + +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-jpa + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-jpa:{project-version}" +---- +==== + +The JPA API must be included via some vendor-specific implementation, e.g. Hibernate ORM Framework. + The following components are provided: * <> diff --git a/src/reference/asciidoc/mail.adoc b/src/reference/asciidoc/mail.adoc index 6579592cd6..e42d14c7f8 100644 --- a/src/reference/asciidoc/mail.adoc +++ b/src/reference/asciidoc/mail.adoc @@ -3,6 +3,28 @@ This section describes how to work with mail messages in Spring Integration. +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-mail + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-mail:{project-version}" +---- +==== + +The `javax.mail:javax.mail-api` must be included via vendor-specific implementation. + [[mail-outbound]] === Mail-sending Channel Adapter @@ -346,11 +368,11 @@ If not specified, the previous behavior is retained (peek is `true`). ==== IMAP `idle` and Lost Connections When using an IMAP `idle` channel adapter, connections to the server may be lost (for example, through network failure) and, since the JavaMail documentation explicitly states that the actual IMAP API is experimental, it is important to understand the differences in the API and how to deal with them when configuring IMAP `idle` adapters. -Currently, Spring Integration mail adapters were tested with JavaMail 1.4.1 and JavaMail 1.4.3,. +Currently, Spring Integration mail adapters were tested with JavaMail 1.4.1 and JavaMail 1.4.3. Depending on which one is used, you must pay special attention to some of the JavaMail properties that need to be set with regard to auto-reconnect. -NOTE: The following behavior was observed with Gmail but should provide you with some tips on how to solve re-connect -issue with other providers. However feedback is always welcome. +NOTE: The following behavior was observed with Gmail but should provide you with some tips on how to solve re-connect issue with other providers. +However feedback is always welcome. Again, the following notes are based on Gmail. With JavaMail 1.4.1, if you set the `mail.imaps.timeout` property to a relatively short period of time (approximately 5 min in our testing), `IMAPFolder.idle()` throws `FolderClosedException` after this timeout. @@ -405,8 +427,7 @@ You can obtain the events by using an `` or a If `shouldMarkMessagesAsRead` is true, the IMAP adapters set the `\Seen` flag. -In addition, when an email server does not support the `\Recent` flag, the IMAP adapters mark messages with a user -flag (by default, `spring-integration-mail-adapter`), as long as the server supports user flags. +In addition, when an email server does not support the `\Recent` flag, the IMAP adapters mark messages with a user flag (by default, `spring-integration-mail-adapter`), as long as the server supports user flags. If not, `Flag.FLAGGED` is set to `true`. These flags are applied regardless of the `shouldMarkMessagesRead` setting. @@ -428,7 +449,7 @@ This is similar to looking at your email client while scrolling through all the Spring Integration 2.0.4 introduced the `mail-filter-expression` attribute on `inbound-channel-adapter` and `imap-idle-channel-adapter`. This attribute lets you provide an expression that is a combination of SpEL and a regular expression. -For example if you would like to read only emails that contain 'Spring Integration' in the subject line, you would configure the `mail-filter-expression` attribute like as follows: `mail-filter-expression="subject matches '(?i).*Spring Integration.*"` +For example if you would like to read only emails that contain 'Spring Integration' in the subject line, you would configure the `mail-filter-expression` attribute like as follows: `mail-filter-expression="subject matches '(?i).*Spring Integration.*"`. Since `javax.mail.internet.MimeMessage` is the root context of the SpEL evaluation context, you can filter on any value available through `MimeMessage`, including the actual body of the message. This one is particularly important, since reading the body of the message typically results in such messages being marked as `SEEN` by default. diff --git a/src/reference/asciidoc/mongodb.adoc b/src/reference/asciidoc/mongodb.adoc index 227d7fa0d9..652c836e98 100644 --- a/src/reference/asciidoc/mongodb.adoc +++ b/src/reference/asciidoc/mongodb.adoc @@ -2,7 +2,26 @@ == MongoDb Support Version 2.1 introduced support for http://www.mongodb.org/[MongoDB]: a "`high-performance, open source, document-oriented database`". -This support comes in the form of a MongoDB-based `MessageStore`. + +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-mongodb + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-mongodb:{project-version}" +---- +==== To download, install, and run MongoDB, see the http://www.mongodb.org/downloads[MongoDB documentation]. @@ -316,7 +335,7 @@ To do that, use `collection-name-expression`, where the provided expression is Version 5.0 introduced the MongoDB outbound gateway. It allows you query a database by sending a message to its request channel. -The gateway thens send the response to the reply channel. +The gateway then send the response to the reply channel. You can use the message payload and headers to specify the query and the collection name, as the following example shows: ==== diff --git a/src/reference/asciidoc/mqtt.adoc b/src/reference/asciidoc/mqtt.adoc index 1eb6d3c9af..8db2d2c1d9 100644 --- a/src/reference/asciidoc/mqtt.adoc +++ b/src/reference/asciidoc/mqtt.adoc @@ -2,6 +2,27 @@ == MQTT Support Spring Integration provides inbound and outbound channel adapters to support the Message Queueing Telemetry Transport (MQTT) protocol. + +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-mqtt + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-mqtt:{project-version}" +---- +==== + The current implementation uses the http://www.eclipse.org/paho/[Eclipse Paho MQTT Client] library. Configuration of both adapters is achieved using the `DefaultMqttPahoClientFactory`. diff --git a/src/reference/asciidoc/redis.adoc b/src/reference/asciidoc/redis.adoc index 2d627fb417..abcef2a574 100644 --- a/src/reference/asciidoc/redis.adoc +++ b/src/reference/asciidoc/redis.adoc @@ -4,6 +4,28 @@ Spring Integration 2.1 introduced support for http://redis.io/[Redis]: "`an open source advanced key-value store`". This support comes in the form of a Redis-based `MessageStore` as well as publish-subscribe messaging adapters that are supported by Redis through its http://redis.io/topics/pubsub[`PUBLISH`, `SUBSCRIBE`, and `UNSUBSCRIBE`] commands. +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-redis + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-redis:{project-version}" +---- +==== + +You also need to include Redis client dependency, e.g. Lettuce. + To download, install, and run Redis, see the http://redis.io/download[Redis documentation]. [[redis-connection]] diff --git a/src/reference/asciidoc/rmi.adoc b/src/reference/asciidoc/rmi.adoc index eb18443c06..6a0f3541e4 100644 --- a/src/reference/asciidoc/rmi.adoc +++ b/src/reference/asciidoc/rmi.adoc @@ -7,6 +7,26 @@ The first section deals with sending messages over RMI. The second section shows how to receive messages over RMI. The last section shows how to define RMI channel adapters by using the namespace support. +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-rmi + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-rmi:{project-version}" +---- +==== + [[rmi-outbound]] === Outbound RMI diff --git a/src/reference/asciidoc/scripting.adoc b/src/reference/asciidoc/scripting.adoc index cd3918e9f7..8f28c43718 100644 --- a/src/reference/asciidoc/scripting.adoc +++ b/src/reference/asciidoc/scripting.adoc @@ -3,7 +3,29 @@ Spring Integration 2.1 added support for the http://jcp.org/aboutJava/communityprocess/pr/jsr223/[JSR223 Scripting for Java specification], introduced in Java version 6. It lets you use scripts written in any supported language (including Ruby, JRuby, Javascript, and Groovy) to provide the logic for various integration components, similar to the way the Spring Expression Language (SpEL) is used in Spring Integration. -For more information about JSR223, see the https://docs.oracle.com/javase/8/docs/technotes/guides/scripting/prog_guide/api.html[documentation] +For more information about JSR223, see the https://docs.oracle.com/javase/8/docs/technotes/guides/scripting/prog_guide/api.html[documentation]. + +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-scripting + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-scripting:{project-version}" +---- +==== + +In addition you need to add a script engine implementation, e.g. JRuby, Jython. IMPORTANT: Note that this feature requires Java 6 or higher. diff --git a/src/reference/asciidoc/security.adoc b/src/reference/asciidoc/security.adoc index 742565a307..78c7dd9741 100644 --- a/src/reference/asciidoc/security.adoc +++ b/src/reference/asciidoc/security.adoc @@ -6,9 +6,27 @@ Moreover, it is critical for distributed systems, such as those built on Enterpr Messaging independence and loose coupling let target systems communicate with each other with any type of data in the message's `payload`. We can either trust all those messages or secure our service against "`infecting`" messages. -Spring Integration, together with -http://projects.spring.io/spring-security/[Spring Security], provides a simple and comprehensive way to -secure message channels, as well as other part of the integration solution. +Spring Integration, together with http://projects.spring.io/spring-security/[Spring Security], provides a simple and comprehensive way to secure message channels, as well as other part of the integration solution. + +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-security + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-security:{project-version}" +---- +==== [[securing-channels]] === Securing channels diff --git a/src/reference/asciidoc/sftp.adoc b/src/reference/asciidoc/sftp.adoc index 456787e1ff..043ba59812 100644 --- a/src/reference/asciidoc/sftp.adoc +++ b/src/reference/asciidoc/sftp.adoc @@ -10,6 +10,26 @@ The SFTP protocol requires a secure channel, such as SSH, and visibility to a cl Spring Integration supports sending and receiving files over SFTP by providing three client side endpoints: inbound channel adapter, outbound channel adapter, and outbound gateway. It also provides convenient namespace configuration to define these client components. +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-sftp + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-sftp:{project-version}" +---- +==== + To include the SFTP namespace in your xml configuration, include the following attributes on the root element: ==== diff --git a/src/reference/asciidoc/stomp.adoc b/src/reference/asciidoc/stomp.adoc index 3212a17487..6f9033fc6f 100644 --- a/src/reference/asciidoc/stomp.adoc +++ b/src/reference/asciidoc/stomp.adoc @@ -6,6 +6,28 @@ It is based on the architecture, infrastructure, and API from the Spring Framewo Spring Integration uses many of Spring STOMP components (such as `StompSession` and `StompClientSupport`). For more information, see the http://docs.spring.io/spring/docs/current/spring-framework-reference/html/websocket.html#websocket-stomp-client[Spring Framework STOMP Support] chapter in the Spring Framework reference manual. +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-stomp + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-stomp:{project-version}" +---- +==== + +For server side components you need to add a `org.springframework:spring-websocket` and/or `io.projectreactor.netty:reactor-netty` dependencies. + [[stomp-overview]] === Overview @@ -19,13 +41,9 @@ The Spring Framework provides the following implementations: You can provide any other `StompClientSupport` implementation. See the https://docs.spring.io/spring-integration/api/[Javadoc] of those classes. -The `StompClientSupport` class is designed as a _factory_ to produce a `StompSession` for the provided -`StompSessionHandler` and all the remaining work is done through the _callbacks_ to that `StompSessionHandler` -and `StompSession` abstraction. -With the Spring Integration _adapter_ abstraction, we -need to provide some managed shared object to represent our application as a STOMP client with its unique session. -For this purpose, Spring Integration provides the `StompSessionManager` abstraction to manage the _single_ -`StompSession` between any provided `StompSessionHandler`. +The `StompClientSupport` class is designed as a _factory_ to produce a `StompSession` for the provided `StompSessionHandler` and all the remaining work is done through the _callbacks_ to that `StompSessionHandler` and `StompSession` abstraction. +With the Spring Integration _adapter_ abstraction, we need to provide some managed shared object to represent our application as a STOMP client with its unique session. +For this purpose, Spring Integration provides the `StompSessionManager` abstraction to manage the _single_ `StompSession` between any provided `StompSessionHandler`. This allows the use of _inbound_ or _outbound_ channel adapters (or both) for the particular STOMP Broker. See `StompSessionManager` (and its implementations) JavaDocs for more information. @@ -40,8 +58,7 @@ For more configuration options, see <> and the `StompInboundCha [[stomp-outbound-adapter]] === STOMP Outbound Channel Adapter -The `StompMessageHandler` is the `MessageHandler` for the `` and is used -to send the outgoing `Message` instances to the STOMP `destination` (pre-configured or determined at runtime with a SpEL expression) through the `StompSession` (which is provided by the shared `StompSessionManager`). +The `StompMessageHandler` is the `MessageHandler` for the `` and is used to send the outgoing `Message` instances to the STOMP `destination` (pre-configured or determined at runtime with a SpEL expression) through the `StompSession` (which is provided by the shared `StompSessionManager`). For more configuration options see <> and the `StompMessageHandler` https://docs.spring.io/spring-integration/api/org/springframework/integration/stomp/outbound/StompMessageHandler.html[Javadoc]. @@ -73,19 +90,16 @@ It provides `fromHeaders()` and `toHeaders()` operations for the inbound and out As with many other Spring Integration modules, the `IntegrationStompHeaders` class has been introduced to map standard STOMP headers to `MessageHeaders`, with `stomp_` as the header name prefix. In addition, all `MessageHeaders` instances with that prefix are mapped to the `StompHeaders` when sending to a destination. -For more information, see the https://docs.spring.io/spring-integration/api/[Javadoc] for those classes and the `mapped-headers` attribute description in the -<>. +For more information, see the https://docs.spring.io/spring-integration/api/[Javadoc] for those classes and the `mapped-headers` attribute description in the <>. [[stomp-events]] === STOMP Integration Events Many STOMP operations are asynchronous, including error handling. -For example, STOMP has a `RECEIPT` server frame that it returns when a client frame has requested one by adding -the `RECEIPT` header. +For example, STOMP has a `RECEIPT` server frame that it returns when a client frame has requested one by adding the `RECEIPT` header. To provide access to these asynchronous events, Spring Integration emits `StompIntegrationEvent` instances, which you can obtain by implementing an `ApplicationListener` or by using an `` (see <>). -Specifically, a `StompExceptionEvent` is emitted from the `AbstractStompSessionManager` when a -`stompSessionListenableFuture` receives `onFailure()` due to failure to connect to STOMP broker. +Specifically, a `StompExceptionEvent` is emitted from the `AbstractStompSessionManager` when a `stompSessionListenableFuture` receives `onFailure()` due to failure to connect to STOMP broker. Another example is the `StompMessageHandler`. It processes `ERROR` STOMP frames, which are server responses to improper (unaccepted) messages sent by this `StompMessageHandler`. @@ -191,7 +205,7 @@ To include it in your configuration, provide the following namespace declaration ---- [[stomp-outbound-channel-adapter]] -==== Understanding the Element +==== Understanding the `` Element The following listing shows the available attributes for the STOMP outbound channel adapter: diff --git a/src/reference/asciidoc/stream.adoc b/src/reference/asciidoc/stream.adoc index be98ba9f6b..3d969f31ad 100644 --- a/src/reference/asciidoc/stream.adoc +++ b/src/reference/asciidoc/stream.adoc @@ -5,6 +5,26 @@ In many cases, application data is obtained from a stream. It is not recommended to send a reference to a stream as a message payload to a consumer. Instead, messages are created from data that is read from an input stream, and message payloads are written to an output stream one by one. +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-stream + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-stream:{project-version}" +---- +==== + [[stream-reading]] === Reading from Streams diff --git a/src/reference/asciidoc/syslog.adoc b/src/reference/asciidoc/syslog.adoc index 0a612264da..8501145ec7 100644 --- a/src/reference/asciidoc/syslog.adoc +++ b/src/reference/asciidoc/syslog.adoc @@ -2,6 +2,27 @@ == Syslog Support Spring Integration 2.2 introduced the syslog transformer: `SyslogToMapTransformer`. + +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-syslog + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-syslog:{project-version}" +---- +==== + This transformer, together with a `UDP` or `TCP` inbound adapter, could be used to receive and analyze syslog records from other hosts. The transformer creates a message payload that contains a map of the elements from the syslog message. diff --git a/src/reference/asciidoc/web-sockets.adoc b/src/reference/asciidoc/web-sockets.adoc index 52d5813948..6bcd4abb17 100644 --- a/src/reference/asciidoc/web-sockets.adoc +++ b/src/reference/asciidoc/web-sockets.adoc @@ -6,6 +6,28 @@ It is based on the architecture, infrastructure, and API from the Spring Framewo Therefore, many of Spring WebSocket's components (such as `SubProtocolHandler` or `WebSocketClient`) and configuration options (such as `@EnableWebSocketMessageBroker`) can be reused within Spring Integration. For more information, see the http://docs.spring.io/spring/docs/current/spring-framework-reference/html/#websocket[Spring Framework WebSocket Support] chapter in the Spring Framework reference manual. +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-websocket + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-websocket:{project-version}" +---- +==== + +For server side, the `org.springframework:spring-webmvc` dependency must be included explicitly. + The Spring Framework WebSocket infrastructure is based on the Spring messaging foundation and provides a basic messaging framework based on the same `MessageChannel` implementations and `MessageHandler` implementations that Spring Integration uses (and some POJO-method annotation mappings). Consequently, Spring Integration can be directly involved in a WebSocket flow, even without WebSocket adapters. For this purpose, you can configure a Spring Integration `@MessagingGateway` with appropriate annotations, as the following example shows: diff --git a/src/reference/asciidoc/webflux.adoc b/src/reference/asciidoc/webflux.adoc index b540f366f0..34d20859af 100644 --- a/src/reference/asciidoc/webflux.adoc +++ b/src/reference/asciidoc/webflux.adoc @@ -2,6 +2,29 @@ == WebFlux Support The WebFlux Spring Integration module (`spring-integration-webflux`) allows for the execution of HTTP requests and the processing of inbound HTTP requests in a reactive manner. + +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-webflux + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-webflux:{project-version}" +---- +==== + +The `io.projectreactor.netty:reactor-netty` dependency must be included in case of non-Servlet-based server configuration. + The WebFlux support consists of the following gateway implementations: `WebFluxInboundEndpoint` and `WebFluxRequestExecutingMessageHandler`. The support is fully based on the Spring https://docs.spring.io/spring/docs/current/spring-framework-reference/web-reactive.html#spring-webflux[WebFlux] and https://projectreactor.io/[Project Reactor] foundations. See <> for more information, since many options are shared between reactive and regular HTTP components. diff --git a/src/reference/asciidoc/ws.adoc b/src/reference/asciidoc/ws.adoc index 08c08e0bfe..8ddda70d7a 100644 --- a/src/reference/asciidoc/ws.adoc +++ b/src/reference/asciidoc/ws.adoc @@ -10,6 +10,26 @@ This chapter describes Spring Integration's support for web services, including: * <> * <> +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-ws + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-ws:{project-version}" +---- +==== + [[webservices-outbound]] === Outbound Web Service Gateways @@ -63,20 +83,15 @@ Both gateways implement the Spring Web Services `MessageEndpoint` interface, so For more detail on how to use these components, see the Spring Web Services reference guide's chapter covering http://docs.spring.io/spring-ws/docs/current/reference/html/server.html[creating a web service]. The chapter covering http://docs.spring.io/spring/docs/current/spring-framework-reference/html/oxm.html[Object/XML mapping] is also applicable again. -To add the `SimpleWebServiceInboundGateway` and `MarshallingWebServiceInboundGateway` configurations to the Spring WS -infrastructure, you should add the `EndpointMapping` definition between `MessageDispatcherServlet` and the target -`MessageEndpoint` implementations, as you would for a normal Spring WS application. -For this purpose (from the Spring Integration perspective), Spring WS provides the following convenient `EndpointMapping` -implementations: +To add the `SimpleWebServiceInboundGateway` and `MarshallingWebServiceInboundGateway` configurations to the Spring WS infrastructure, you should add the `EndpointMapping` definition between `MessageDispatcherServlet` and the target `MessageEndpoint` implementations, as you would for a normal Spring WS application. +For this purpose (from the Spring Integration perspective), Spring WS provides the following convenient `EndpointMapping` implementations: * `o.s.ws.server.endpoint.mapping.UriEndpointMapping` * `o.s.ws.server.endpoint.mapping.PayloadRootQNameEndpointMapping` * `o.s.ws.soap.server.endpoint.mapping.SoapActionEndpointMapping` * `o.s.ws.server.endpoint.mapping.XPathPayloadEndpointMapping` -You must specify the beans for these classes in the application context and reference the -`SimpleWebServiceInboundGateway` and/or `MarshallingWebServiceInboundGateway` bean definitions according to the WS -mapping algorithm. +You must specify the beans for these classes in the application context and reference the `SimpleWebServiceInboundGateway` and/or `MarshallingWebServiceInboundGateway` bean definitions according to the WS mapping algorithm. See the http://docs.spring.io/spring-ws/docs/current/reference/html/server.html#server-endpoint-mapping[endpoint mappings] for more information. @@ -204,15 +219,13 @@ NOTE: If you set `DestinationProvider`, `encode-uri` is ignored. === WS Message Headers The Spring Integration web service gateways automatically map the SOAP action header. -By default, it is copied to and from Spring Integration `MessageHeaders` by using the -http://docs.spring.io/spring-integration/api/org/springframework/integration/ws/DefaultSoapHeaderMapper.html[`DefaultSoapHeaderMapper`]. +By default, it is copied to and from Spring Integration `MessageHeaders` by using the http://docs.spring.io/spring-integration/api/org/springframework/integration/ws/DefaultSoapHeaderMapper.html[`DefaultSoapHeaderMapper`]. You can pass in your own implementation of SOAP-specific header mappers, as the gateways have properties to support doing so. Unless explicitly specified by the `requestHeaderNames` or `replyHeaderNames` properties of the `DefaultSoapHeaderMapper`, any user-defined SOAP headers are not copied to or from a SOAP Message. -When you use the XML namespace for configuration, you can set these properties by using the `mapped-request-headers` and -`mapped-reply-headers` attributes, you can provide a custom mapper by setting the `header-mapper` attribute. +When you use the XML namespace for configuration, you can set these properties by using the `mapped-request-headers` and `mapped-reply-headers` attributes, you can provide a custom mapper by setting the `header-mapper` attribute. TIP: When mapping user-defined headers, the values can also contain simple wildcard patterns (such `myheader*` or `*myheader`). For example, if you need to copy all user-defined headers, you can use the wildcard character: `*`. @@ -223,15 +236,12 @@ NOTE: Rather than using the wildcard (`*`), we recommend using the following com Doing so avoids mapping `request` headers to the reply. Starting with version 4.3, you can negate patterns in the header mappings by preceding the pattern with `!`. -Negated patterns get priority, so a list such as -`STANDARD_REQUEST_HEADERS,thing1,thing*,!thing2,!thing3,qux,!thing1` does not map `thing1`, `thing2`, or `thing3`. It does map the standard headers, `thing4`, and `qux`. +Negated patterns get priority, so a list such as `STANDARD_REQUEST_HEADERS,thing1,thing*,!thing2,!thing3,qux,!thing1` does not map `thing1`, `thing2`, or `thing3`. It does map the standard headers, `thing4`, and `qux`. (Note that `thing1` is included in both non-negated and negated forms. Because negated values take precedence, `thing1` is not mapped.) -IMPORTANT: If you have a user-defined header that begins with `!` that you do wish to map, you can escape it with -`\`, as follows: `STANDARD_REQUEST_HEADERS,\!myBangHeader`. `!myBangHeader` is then mapped. +IMPORTANT: If you have a user-defined header that begins with `!` that you do wish to map, you can escape it with `\`, as follows: `STANDARD_REQUEST_HEADERS,\!myBangHeader`. `!myBangHeader` is then mapped. -Inbound SOAP headers (request headers for the inbound gateway and reply headers for the outbound gateway) are mapped as -`SoapHeaderElement` objects. +Inbound SOAP headers (request headers for the inbound gateway and reply headers for the outbound gateway) are mapped as `SoapHeaderElement` objects. You can explore the contents by accessing the `Source`: ==== diff --git a/src/reference/asciidoc/xml.adoc b/src/reference/asciidoc/xml.adoc index bae5b46490..5af5945549 100644 --- a/src/reference/asciidoc/xml.adoc +++ b/src/reference/asciidoc/xml.adoc @@ -14,6 +14,26 @@ Spring Integration's XML support extends the core of Spring Integration with the * <> * <> +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-xml + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-xml:{project-version}" +---- +==== + These components make working with XML messages in Spring Integration simpler. The messaging components work with XML that is represented in a range of formats, including instances of `java.lang.String`, `org.w3c.dom.Document`, and `javax.xml.transform.Source`. However, where a DOM representation is required (for example, in order to evaluate an XPath expression), the `String` payload is converted into the required type and then converted back to `String`. @@ -56,7 +76,7 @@ When XPath expressions are created, the best XPath implementation that is availa NOTE: Internally, Spring Integration uses the XPath functionality provided by the Spring Web Services project (http://www.spring.io/spring-ws). Specifically, we use the Spring Web Services XML module (spring-xml-x.x.x.jar). -For a deeper understanding, see the respective documentation at http://docs.spring.io/spring-ws/docs/current/reference/html/common.html#xpath +For a deeper understanding, see the respective documentation at http://docs.spring.io/spring-ws/docs/current/reference/html/common.html#xpath. Here is an overview of all available configuration parameters of the `xpath-expression` element: The following listing shows the available attributes for the `xpath-expression` element: @@ -322,7 +342,7 @@ That may be useful for certain custom implementations of the `Marshaller` interf [[xml-xslt-payload-transformers]] ===== XsltPayloadTransformer -http://docs.spring.io/spring-integration/api/org/springframework/integration/xml/transformer/XsltPayloadTransformer.html[`XsltPayloadTransformer`] transforms XML payloads by using http://en.wikipedia.org/wiki/XSL_Transformations[Extensible Stylesheet Language Transformations] (XSLT). +The http://docs.spring.io/spring-integration/api/org/springframework/integration/xml/transformer/XsltPayloadTransformer.html[`XsltPayloadTransformer`] transforms XML payloads by using http://en.wikipedia.org/wiki/XSL_Transformations[Extensible Stylesheet Language Transformations] (XSLT). The transformer's constructor requires an instance of either http://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/io/Resource.html[Resource] or http://docs.oracle.com/javase/6/docs/api/javax/xml/transform/Templates.html[Templates] to be passed in. Passing in a `Templates` instance allows for greater configuration of the `TransformerFactory` used to create the template instance. @@ -722,9 +742,7 @@ XPath splitter namespace support lets you create a message endpoint with an inpu ---- -Starting with version 4.2, the `XPathMessageSplitter` exposes the `outputProperties` -(such as `OutputKeys.OMIT_XML_DECLARATION`) property for an `javax.xml.transform.Transformer` instance when a -request `payload` is not of type `org.w3c.dom.Node`. +Starting with version 4.2, the `XPathMessageSplitter` exposes the `outputProperties` (such as `OutputKeys.OMIT_XML_DECLARATION`) property for an `javax.xml.transform.Transformer` instance when a request `payload` is not of type `org.w3c.dom.Node`. The following example defines a property and uses it with the `output-properties` property: ==== @@ -1015,7 +1033,7 @@ The following listing shows some usage examples: ---- ==== -`#xpath` also supports a third optional parameter for converting the result of the XPath evaluation. +The `#xpath()` also supports a third optional parameter for converting the result of the XPath evaluation. It can be one of the String constants (`string`, `boolean`, `number`, `node`, `node_list` and `document_list`) or an `org.springframework.xml.xpath.NodeMapper` instance. By default, the `#xpath` SpEL function returns a `String` representation of the XPath evaluation. diff --git a/src/reference/asciidoc/xmpp.adoc b/src/reference/asciidoc/xmpp.adoc index ba03b119c9..28b55f1ab1 100644 --- a/src/reference/asciidoc/xmpp.adoc +++ b/src/reference/asciidoc/xmpp.adoc @@ -7,14 +7,34 @@ XMPP stands for "`Extensible Messaging and Presence Protocol`". XMPP describes a way for multiple agents to communicate with each other in a distributed system. The canonical use case is to send and receive chat messages, though XMPP can be (and is) used for other kinds of applications. XMPP describes a network of actors. -Within that network, actors may address each other directly and broadcast status changes (such as -"`presence`"). +Within that network, actors may address each other directly and broadcast status changes (such as "`presence`"). XMPP provides the messaging fabric that underlies some of the biggest instant messaging networks in the world, including Google Talk (GTalk, which is also available from within GMail) and Facebook Chat. Many good open-source XMPP servers are available. Two popular implementations are http://www.igniterealtime.org/projects/openfire/[Openfire] and http://www.ejabberd.im[ejabberd]. Spring integration provides support for XMPP by providing XMPP adapters, which support sending and receiving both XMPP chat messages and presence changes from other entries in a client's roster. + +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-xmpp + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-xmpp:{project-version}" +---- +==== + As with other adapters, the XMPP adapters come with support for a convenient namespace-based configuration. To configure the XMPP namespace, include the following elements in the headers of your XML configuration file: @@ -97,9 +117,7 @@ When started, it registers a `PacketListener` that listens for incoming XMPP cha It forwards any received messages to the underlying adapter, which converts them to Spring Integration messages and sends them to the specified `channel`. When stopped, it unregisters the `PacketListener`. -Starting with version 4.3, the `ChatMessageListeningEndpoint` (and its ``) -supports the injection of a `org.jivesoftware.smack.filter.StanzaFilter` to be registered on the provided `XMPPConnection`, -together with an internal `StanzaListener` implementation. +Starting with version 4.3, the `ChatMessageListeningEndpoint` (and its ``) supports the injection of a `org.jivesoftware.smack.filter.StanzaFilter` to be registered on the provided `XMPPConnection`, together with an internal `StanzaListener` implementation. See the https://www.igniterealtime.org/builds/smack/docs/latest/javadoc/org/jivesoftware/smack/XMPPConnection.html#addAsyncStanzaListener%28org.jivesoftware.smack.StanzaListener,%20org.jivesoftware.smack.filter.StanzaFilter%29[Javadoc] for more information. Version 4.3 introduced the `payload-expression` attribute for the `ChatMessageListeningEndpoint`. @@ -150,8 +168,7 @@ The `outbound-channel-adapter` element provides configuration support for the XM ---- ==== -The adapter expects its input to be (at a minimum) a payload of type `java.lang.String` and a header value for -`XmppHeaders.CHAT_TO` that specifies to which user the message should be sent. +The adapter expects its input to be (at a minimum) a payload of type `java.lang.String` and a header value for `XmppHeaders.CHAT_TO` that specifies to which user the message should be sent. To create a message, you can use Java code similar to the following: ==== diff --git a/src/reference/asciidoc/zookeeper.adoc b/src/reference/asciidoc/zookeeper.adoc index 79256f08ef..7b6cf0ebb1 100644 --- a/src/reference/asciidoc/zookeeper.adoc +++ b/src/reference/asciidoc/zookeeper.adoc @@ -7,6 +7,26 @@ Version 4.2 added https://zookeeper.apache.org/[Zookeeper] support to the framew * <> * <> +You need to include this dependency into your project: + +==== +.Maven +[source, xml, subs="normal"] +---- + + org.springframework.integration + spring-integration-zookeeper + {project-version} + +---- + +.Gradle +[source, groovy, subs="normal"] +---- +compile "org.springframework.integration:spring-integration-zookeeper:{project-version}" +---- +==== + [[zk-metadata-store]] === Zookeeper Metadata Store