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.
To download, install and run Redis please refer to the Redis documentation.
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:
public interface RedisConnectionFactory extends PersistenceExceptionTranslator {
/**
* Provides a suitable connection for interacting with Redis.
*
* @return connection for interacting with Redis.
*/
RedisConnection getConnection();
}
The example below shows how to create a JedisConnectionFactory.
In Java:
JedisConnectionFactory jcf = new JedisConnectionFactory();
jcf.afterPropertiesSet();
Or in Spring's XML configuration:
<bean id="redisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name="port" value="7379" />
</bean>
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:
RedisTemplate rt = new RedisTemplate<String, Object>();
rt.setConnectionFactory(redisConnectionFactory);
Or in Spring's XML configuration::
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="redisConnectionFactory"/>
</bean>
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.
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.
<int-redis:publish-subscribe-channel id="redisChannel" topic-name="si.test.topic"/>
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.
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.
<int-redis:inbound-channel-adapter id="redisAdapter"
topics="foo, bar"
channel="receiveChannel"
error-channel="testErrorChannel"
message-converter="testConverter" />
<bean id="redisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name="port" value="7379" />
</bean>
<bean id="testConverter" class="foo.bar.SampleMessageConverter" />
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.
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.
<int-redis:outbound-channel-adapter id="outboundAdapter"
channel="sendChannel"
topic="foo"
message-converter="testConverter"/>
<bean id="redisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name="port" value="7379"/>
</bean>
<bean id="testConverter" class="foo.bar.SampleMessageConverter" />
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).
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, which is described in EIP as well.
Spring Integration's Redis module provides the RedisMessageStore which is an implementation of both the
the MessageStore strategy (mainly used by the QueueChannel and ClaimCheck
patterns) and the MessageGroupStore strategy (mainly used by the Aggregator and
Resequencer patterns).
<bean id="redisMessageStore" class="org.springframework.integration.redis.store.RedisMessageStore">
<constructor-arg ref="redisConnectionFactory"/>
</bean>
<int:channel id="somePersistentQueueChannel">
<int:queue message-store="redisMessageStore"/>
<int:channel>
<int:aggregator input-channel="inputChannel" output-channel="outputChannel"
message-store="redisMessageStore"/>
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.