diff --git a/docs/src/reference/docbook/index.xml b/docs/src/reference/docbook/index.xml
index 2b678aa1c0..9306eb97b0 100644
--- a/docs/src/reference/docbook/index.xml
+++ b/docs/src/reference/docbook/index.xml
@@ -118,25 +118,26 @@
by Spring Integration to support Message-based communication with external systems.
+
+
-
-
+
-
+
+
+
-
+
-
-
-
-
-
+
+
+
Appendices
diff --git a/docs/src/reference/docbook/redis.xml b/docs/src/reference/docbook/redis.xml
new file mode 100644
index 0000000000..b6508e8b72
--- /dev/null
+++ b/docs/src/reference/docbook/redis.xml
@@ -0,0 +1,223 @@
+
+
+
+ Redis Support
+
+
+ Since version 2.1 Spring Integration introduces support for 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 via its PUBLISH, SUBSCRIBE and UNSUBSCRIBE commands.
+
+
+
+ Introduction
+
+ To download, install and run Redis please refer to the Redis documentation.
+
+
+
+
+ Connecting to Redis
+
+ To begin interacting with Redis you first need to connect to it. Spring Integration uses support provided by another Spring project,
+ Spring Data Redis, which provides typical Spring constructs:
+ ConnectionFactory and Template. Those abstractions
+ simplify integration with several Redis-client Java APIs. Currently Spring-Data-Redis supports
+ jedis, jredis and rjc
+
+ RedisConnectionFactory
+
+
+ To connect to Redis you would use one of the implementations of the RedisConnectionFactory interface:
+
+
+
+
+ The example below shows how to create a JedisConnectionFactory.
+
+ In Java:
+
+
+
+ Or in Spring's XML configuration:
+
+
+]]>
+
+
+
+ The implementations of RedisConnectionFactory provide a set of properties such as port and host that can be set if needed.
+ Once an instance of RedisConnectionFactory is created, you can create an instance of RedisTemplate and inject it with the RedisConnectionFactory.
+
+
+ RedisTemplate
+
+
+ As with other template classes in Spring (e.g., JdbcTemplate, JmsTemplate)
+ RedisTemplate is a helper class that simplifies Redis data access code.
+ For more information about RedisTemplate and its variations (e.g., StringRedisTemplate)
+ please refer to the Spring-Data-Redis documentation
+
+
+ The code below shows how to create an instance of RedisTemplate:
+
+ In Java:
+ ();
+rt.setConnectionFactory(redisConnectionFactory);]]>
+
+
+ Or in Spring's XML configuration::
+
+
+]]>
+
+
+
+
+ Messaging with Redis
+
+
+ As mentioned in the introduction Redis provides support for Publish-Subscribe messaging via its PUBLISH, SUBSCRIBE and UNSUBSCRIBE
+ commands. As with JMS and AMQP, Spring Integration provides Message Channels and adapters for sending and receiving messages via Redis.
+
+
+
+ Redis Publish/Subscribe channel
+
+
+ Similar to the JMS there are cases where both the producer and consumer are intended to be part of the same application, running
+ within the same process. This could be accomplished by using a pair of inbound and outbound Channel Adapters,
+ however just like with Spring Integration's JMS support, there is a simpler approach to address this use case.
+ ]]>
+
+
+
+ The publish-subscribe-channel (above) will behave much like a normal <publish-subscribe-channel/> element from the
+ main Spring Integration namespace. It can be referenced by both input-channel and output-channel attributes of
+ any endpoint. The difference is that this channel is backed by a Redis topic name - a String value specified by the topic-name
+ attribute. However unlike JMS this topic doesn't have to be created in advance or even auto-created by Redis. In Redis topics are simple
+ String values that play the role of an address, and all the producer and consumer need to do to communicate is use the same String value
+ as their topic name. A simple subscription to this channel means that asynchronous pub-sub messaging is possible between the producing and
+ consuming endpoints, but unlike the asynchronous Message Channels created by adding a <queue/> sub-element within
+ a simple Spring Integration <channel/> element, the Messages are not just stored in an in-memory queue. Instead those
+ Messages are passed through Redis allowing you to rely on its support for persistence and clustering as well as its interoperability with
+ other non-java platforms.
+
+
+
+
+ Redis Inbound Channel Adapter
+
+ The Redis-based Inbound Channel Adapter adapts incoming Redis messages into Spring Integration Messages in the same way as other
+ inbound adapters. It receives platform-specific messages (Redis in this case) and converts them to Spring Integration Messages using
+ a MessageConverter strategy.
+
+
+
+
+
+
+
+]]>
+
+
+
+ Above is a simple but complete configuration of a Redis Inbound Channel Adapter. Note that the above configuration relies on the
+ familiar Spring paradigm of auto-discovering certain beans. In this case the redisConnectionFactory is implicitly
+ injected into the adapter. You can of course specify it explicitly using the connection-factory attribute instead.
+
+
+
+ Also, note that the above configuration injects the adapter with a custom MessageConverter.
+ The approach is similar to JMS where MessageConverters are used to convert between
+ Redis Messages and the Spring Integration Message payloads. The default is a SimpleMessageConverter.
+
+
+ Inbound adapters can subscribe to multiple topic names hence the comma-delimited set of values in the
+ topics attribute.
+
+
+
+ Redis Outbound Channel Adapter
+
+ The Redis-based Outbound Channel Adapter adapts outgoing Spring Integration messages into Redis messages in the same way as
+ other outbound adapters. It receives Spring Integration messages and converts them to platform-specific messages (Redis in this case)
+ using a MessageConverter strategy.
+
+
+
+
+
+
+
+]]>
+
+
+ As you can see the configuration is similar to the Redis Inbound Channel Adapter. The adapter is implicitly injected with
+ a RedisConnectionFactory which was defined with 'redisConnectionFactory' as its bean name.
+ This example also includes the optional, custom MessageConverter (the 'testConverter' bean).
+
+
+
+
+
+ Redis Message Store
+
+
+ As described in EIP, a Message Store allows you to persist Messages.
+ This can be very useful when dealing with components that have a capability to buffer messages
+ (QueueChannel, Aggregator, Resequencer, etc.) if reliability is a concern.
+ In Spring Integration, the MessageStore strategy also provides the foundation for the
+ ClaimCheck pattern, described in EIP as well.
+
+
+
+ Spring Integration's Redis module provides the RedisMessageStore which is an implementation of both the
+ MessageStore strategy (mainly used by the QueueChannel and ClaimCheck patterns) and
+ the MessageGroupStore strategy (mainly used by Aggregator and Resequencer patterns).
+
+
+
+
+
+
+
+
+
+
+
+]]>
+
+
+
+ Above is a sample RedisMessageStore configuration that shows its usage by a QueueChannel
+ and an Aggregator. As you can see it is a simple bean configuration, and it expects a
+ RedisConnectionFactory as a constructor argument.
+
+
+ By default the RedisMessageStore will use Java serialization to serialize the Message.
+ However if you want to use a different serialization technique (e.g., JSON), you can provide your own serializer via
+ the valueSerializer property of the RedisMessageStore.
+
+
+
+
\ No newline at end of file