Spring/spring-data-redis
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add documentation on Redis transactions

Browse Source 
DATAREDIS-125
This commit is contained in:
Jennifer Hickey
2013-04-18 12:13:11 -07:00
parent 39b83cea88
commit 5dfb8c447f
6 changed files with 85 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
docs/src/reference/docbook/index.xml
View File

@@ -16,6 +16,11 @@
<surname>Leau</surname>
<affiliation>SpringSource</affiliation>
</author>
<author>
<firstname>Jennifer</firstname>
<surname>Hickey</surname>
<affiliation>SpringSource</affiliation>
</author>
</authorgroup>
<legalnotice>

22
docs/src/reference/docbook/introduction/getting-started.xml
View File

@@ -3,7 +3,7 @@
<title>Getting Started</title>
<para>Learning a new framework is not always straight forward. In this section, we (the Spring Data team)
tried to provide, what we think is, an easy to follow guide for starting with Spring Data Key Value module.
tried to provide, what we think is, an easy to follow guide for starting with the Spring Data Redis module.
Of course, feel free to create your own learning 'path' as you see fit and, if possible, please report back
any improvements to the documentation that can help others.</para>
@@ -22,25 +22,25 @@
<ulink url="http://static.springframework.org/spring/docs/3.0.x/reference/resources.html">resource</ulink> abstract or
<ulink url="http://static.springframework.org/spring/docs/3.0.x/reference/aop.html">AOP</ulink> infrastructure. While it is not important
to know the Spring APIs, understanding the concepts behind them is. At a minimum, the idea behind IoC should be familiar.
These being said, the more knowledge one has about the Spring, the faster she will pick Spring Data Key Value.
That being said, the more knowledge one has about the Spring, the faster she will pick up Spring Data Redis.
Besides the very comprehensive (and sometimes disarming) documentation that explains in detail the Spring Framework,
there are a lot of articles, blog entries and books on the matter - take a look at the Spring framework
<ulink url="http://www.springsource.org/documentation">home page</ulink> for more information. In general, this should be the starting point for
developers wanting to try Spring DKV.</para>
developers wanting to try Spring DR.</para>
</section>
<section id="get-started:first-steps:nosql">
<title>Knowing NoSQL and Key Value stores</title>
<para>NoSQL stores have taken the storage world by storm. It is a vast domain with a plethora of solutions, terms and patterns (to make things worth even the
<para>NoSQL stores have taken the storage world by storm. It is a vast domain with a plethora of solutions, terms and patterns (to make things worse even the
term itself has multiple <ulink url="http://www.google.com/search?q=nosoql+acronym">meanings</ulink>).
While some of the principles are common, it is crucial that the user is familiar to some degree with the stores supported by SDKV.
The best way to get acquainted to this solutions is to read their documentation and follow their examples - it usually doesn't take more then 5-10 minutes
While some of the principles are common, it is crucial that the user is familiar to some degree with the stores supported by SDR.
The best way to get acquainted with these solutions is to read their documentation and follow their examples - it usually doesn't take more then 5-10 minutes
to go through them and if you are coming from an RDMBS-only background many times these exercises can be an eye opener.
</para>
</section>
<section id="get-started:first-steps:samples">
<title>Trying Out The Samples</title>
<para>One can find various samples for key value stores in the dedicated example repo, at
<ulink url="https://github.com/SpringSource/spring-data-keyvalue-examples">http://github.com/SpringSource/spring-data-keyvalue-examples</ulink>. For Spring Redis,
<ulink url="https://github.com/SpringSource/spring-data-keyvalue-examples">http://github.com/SpringSource/spring-data-keyvalue-examples</ulink>. For Spring Data Redis,
of interest is the <literal>retwisj</literal> sample, a Twitter-clone built on top of Redis which can be run locally or be deployed into the cloud. See its
<ulink url="http://static.springsource.org/spring-data/data-keyvalue/examples/retwisj/current/">documentation</ulink>, the following blog
<ulink url="http://blog.springsource.com/2011/04/27/getting-started-redis-spring-cloud-foundry/">entry</ulink> or the
@@ -51,11 +51,11 @@
<section id="get-started:help">
<title>Need Help?</title>
<para>If you encounter issues or you are just looking for an advice, feel free to use one of the links below:</para>
<para>If you encounter issues or you are just looking for advice, feel free to use one of the links below:</para>
<section id="get-started:help:community">
<title>Community Support</title>
<para>The Spring Data <ulink url="http://forum.springframework.org/forumdisplay.php?f=80">forum</ulink> is a message board for all Spring Data (not just Key Value) users to
<para>The Spring Data <ulink url="http://forum.springframework.org/forumdisplay.php?f=80">forum</ulink> is a message board for all Spring Data (not just Redis) users to
share information and help each other. Note that registration is needed <emphasis>only</emphasis> for posting.
</para>
</section>
@@ -76,11 +76,11 @@
<para>You can help make Spring Data best serve the needs of the Spring community by interacting with developers through the Spring Community
<ulink url="http://forum.springsource.org">forums</ulink>.</para>
<para>If you encounter a bug or want to suggest an improvement,
please create a ticket on the Spring Data issue <ulink url="https://jira.springframework.org/browse/DATAKV">tracker</ulink>.</para>
please create a ticket on the Spring Data issue <ulink url="https://jira.springsource.org/browse/DATAREDIS">tracker</ulink>.</para>
<para>To stay up to date with the latest news and announcements in the Spring eco system, subscribe to the
Spring Community <ulink url="http://www.springframework.org/">Portal</ulink>.</para>
<para>Lastly, you can follow the SpringSource Data <ulink url="http://blog.springsource.com/category/data-access/">blog</ulink> or the project team on Twitter
(<ulink url="http://twitter.com/costinl">Costin</ulink>)</para>
(<ulink url="http://twitter.com/jencompgeek">Jennifer</ulink>)</para>
</section>
</chapter>

4
docs/src/reference/docbook/introduction/why-sdr.xml
View File

@@ -10,10 +10,10 @@
<para><ulink url="http://en.wikipedia.org/wiki/NoSQL">NoSQL</ulink>
storages provide an alternative to classical RDBMS for horizontal scalability
and speed. In terms of implementation, Key Value stores represent one of the
largest (and oldest) member in the NoSQL space.</para>
largest (and oldest) members in the NoSQL space.</para>
<para>The Spring Data Redis (or SDR) framework makes it easy to
write Spring applications that use the Redis key value store by eliminating the redundant
tasks and boiler place code required for interacting with the store through
tasks and boiler plate code required for interacting with the store through
Spring's excellent infrastructure support.</para>
</chapter>

26
docs/src/reference/docbook/reference/redis-messaging.xml
View File

@@ -3,7 +3,7 @@
<title>Redis Messaging/PubSub</title>
<para>Spring Data provides dedicated messaging integration for Redis,
very similar in functionality and naming to the JMS integration in
Spring Framework; in fact, users familiar with the JMS support in Spring, should
Spring Framework; in fact, users familiar with the JMS support in Spring should
feel right at home.</para>
<para>Redis messaging can be roughly divided into two areas of functionality, namely
@@ -12,7 +12,7 @@
<classname>RedisTemplate</classname> class is used for message production.
For asynchronous reception similar to
Java EE's message-driven bean style, Spring Data provides a dedicated message
listener containers that is used to create Message-Driven POJOs
listener container that is used to create Message-Driven POJOs
(MDPs) and for synchronous reception, the <interfacename>RedisConnection</interfacename> contract.</para>
<para>The package <literal>org.springframework.data.redis.connection</literal> and
@@ -46,7 +46,7 @@ template.convertAndSend("hello!", "world");]]></programlisting>
<para>On the receiving side, one can subscribe to one or multiple channels either by naming them directly or by using
pattern matching. The latter approach is quite useful as it not only allows multiple subscriptions to be created with
one command but to also listen on channels not yet created at subscription time (as long as match the pattern).
one command but to also listen on channels not yet created at subscription time (as long as they match the pattern).
</para>
<para>At the low-level, <interfacename>RedisConnection</interfacename> offers <methodname>subscribe</methodname> and
@@ -55,16 +55,16 @@ template.convertAndSend("hello!", "world");]]></programlisting>
whether it is listening or not, <interfacename>RedisConnection</interfacename>
provides <methodname>getSubscription</methodname> and <methodname>isSubscribed</methodname> method.</para>
<important>Subscribing commands are synchronized and thus blocking. That is, calling subscribe on a connection will cause
<important>When using Jedis, JRedis or RJC connectors, subscribing commands are synchronous and thus blocking. That is, calling subscribe on a connection will cause
the current thread to block as it will start waiting for messages - the thread will be released only if the subscription
is canceled, that is an additional thread invokes <methodname>unsubscribe</methodname> respectively <methodname>pUnsubscribe</methodname>
is canceled, that is an additional thread invokes <methodname>unsubscribe</methodname> or <methodname>pUnsubscribe</methodname>
on the <emphasis>same</emphasis> connection. See <link linkend="redis:pubsub:subscribe:containers">message listener container</link> below
for a solution to these problem.</important>
for a solution to this problem.</important>
<para>As mentioned above, one subscribed a connection starts waiting for messages - no other commands can be invoked on it except
for adding new subscriptions or modifying/canceling the existing ones, that is invoking anything else then <methodname>subscribe</methodname>,
<methodname>pSubscribe</methodname>, <methodname>unsubscribe</methodname>, <methodname>pUnsubscribe</methodname> or is illegal and will
through an exception.</para>
<para>As mentioned above, once subscribed a connection starts waiting for messages. No other commands can be invoked on it except
for adding new subscriptions or modifying/canceling the existing ones. That is, invoking anything other then <methodname>subscribe</methodname>,
<methodname>pSubscribe</methodname>, <methodname>unsubscribe</methodname>, or <methodname>pUnsubscribe</methodname> is illegal and will
throw an exception.</para>
<para>In order to subscribe for messages, one needs to implement the <interfacename>MessageListener</interfacename> callback: each time
a new message arrives, the callback gets invoked and the user code executed through <methodname>onMessage</methodname> method.
@@ -82,18 +82,18 @@ template.convertAndSend("hello!", "world");]]></programlisting>
support in Spring Framework and its message-driven POJOs (MDPs)</para>
<para><classname>RedisMessageListenerContainer</classname> acts as a message listener container; it is used to receive messages from a
Redis channel and drive the MessageListener that are injected into
Redis channel and drive the MessageListeners that are injected into
it. The listener container is responsible for all threading of message
reception and dispatches into the listener for processing. A message
listener container is the intermediary between an MDP and a messaging
provider, and takes care of registering to receive messages, resource acquisition and release,
exception conversion and suchlike. This allows you as an application
exception conversion and the like. This allows you as an application
developer to write the (possibly complex) business logic associated with
receiving a message (and reacting to it), and delegates
boilerplate Redis infrastructure concerns to the framework.
</para>
<para>Further more, to minimize the application footprint, <classname>RedisMessageListenerContainer</classname> performs allows one connection and one thread
<para>Furthermore, to minimize the application footprint, <classname>RedisMessageListenerContainer</classname> allows one connection and one thread
to be shared by multiple listeners even though they do not share a subscription. Thus no matter how many listeners or channels an application tracks,
the runtime cost will remain the same through out its lifetime. Moreover, the container allows runtime configuration changes so one can add or remove
listeners while an application is running without the need for restart. Additionally, the container uses a lazy subscription approach, using a

22
docs/src/reference/docbook/reference/redis-transactions.xml Normal file
View File

@@ -0,0 +1,22 @@
<?xml version="1.0" encoding="UTF-8"?>
<section xmlns="http://docbook.org/ns/docbook" version="5.0" xml:id="tx">
<title>Redis Transactions</title>
<para>Redis provides support for <ulink url="http://redis.io/topics/transactions">transactions</ulink> through the <literal>multi</literal>,
<literal>exec</literal>, and <literal>discard</literal> commands. These operations are available on <interfacename>RedisTemplate</interfacename>,
however <interfacename>RedisTemplate</interfacename> is not guaranteed to execute all operations in the transaction using the same connection.
</para>
<para>Spring Data Redis provides the <interfacename>SessionCallback</interfacename> interface for use when multiple operations need to be performed with the same <literal>connection</literal>,
as when using Redis transactions. For example:
</para>
<programlisting lang="java"><![CDATA[ //execute a transaction
redisTemplate.execute(new SessionCallback<Object>() {
public Object execute(RedisOperations operations) throws DataAccessException {
operations.multi();
operations.opsForValue().set("key", "value");
List<Object> results = operations.exec();
return null;
}
});]]></programlisting>
</section>

63
docs/src/reference/docbook/reference/redis.xml
View File

@@ -10,18 +10,18 @@
to push/pop elements, add/remove elements, perform server side union, intersection, difference between sets, and so forth.
Redis supports different kind of sorting abilities.</quote>
<para>Spring Data Redis provides easy configuration and access to Redis from Spring application. Offers both low-level and
high-level abstraction for interacting with the store, freeing the user from infrastructural concerns.</para>
<para>Spring Data Redis provides easy configuration and access to Redis from Spring applications. It offers both low-level and
high-level abstractions for interacting with the store, freeing the user from infrastructural concerns.</para>
</para>
<section id="redis:requirements">
<title>Redis Requirements</title>
<para>Spring Redis requires Redis 2.0 or above and Java SE 5.0 or above .
<para>Spring Redis requires Redis 2.2 or above and Java SE 6.0 or above .
In terms of language bindings (or connectors), Spring Redis integrates with <ulink url="http://github.com/xetorthio/jedis">Jedis</ulink>,
<ulink url="http://github.com/alphazero/jredis">JRedis</ulink>, <ulink url="http://github.com/e-mzungu/rjc">RJC</ulink>,
<ulink url="http://github.com/spullara/redis-protocol">SRP</ulink> and
<ulink url="http://github.com/wg/lettuce">Lettuce</ulink>, five popular open source Java libraries for Redis.
If you are aware of any other connector that we should be integrating is, please send us feedback.
If you are aware of any other connector that we should be integrating with, please send us feedback.
</para>
</section>
@@ -32,8 +32,8 @@
<itemizedlist>
<listitem><emphasis>Low-Level Abstractions</emphasis> - for configuring and handling communication with Redis through the various connector libraries supported as
described in <xref linkend="redis:connectors"/>. </listitem>
<listitem><emphasis>High-Level Abstractions</emphasis> - providing a generified, user friendly template classes for interacting with Redis.
<xref linkend="redis:template"/> explains the abstraction builds on top of the low-level <interfacename>Connection</interfacename> API to handle the
<listitem><emphasis>High-Level Abstractions</emphasis> - providing generified, user friendly template classes for interacting with Redis.
<xref linkend="redis:template"/> explains the abstraction built on top of the low-level <interfacename>Connection</interfacename> API to handle the
infrastructural concerns and object conversion.</listitem>
<listitem><emphasis>Support Classes</emphasis> - that offer reusable components (built on the aforementioned abstractions) such as
<interfacename>java.util.Collection</interfacename> or Spring 3.1 <ulink url="http://blog.springsource.com/2011/02/23/spring-3-1-m1-caching/">cache</ulink> implementation backed by
@@ -48,10 +48,10 @@
<title>Connecting to Redis</title>
<para>One of the first tasks when using Redis and Spring is to connect to the store through the IoC container. To do that, a Java connector (or binding) is required.
No matter the library one chooses, there only one set of Spring Redis API that one needs to use that behaves consistently
No matter the library one chooses, there is only one set of Spring Data Redis API that one needs to use that behaves consistently
across all connectors, namely the <literal>org.springframework.data.redis.connection</literal> package and its
<interfacename>RedisConnection</interfacename> and <interfacename>RedisConnectionFactory</interfacename> interfaces for working respectively for retrieving active
<literal>connection</literal> to Redis.</para>
<interfacename>RedisConnection</interfacename> and <interfacename>RedisConnectionFactory</interfacename> interfaces for working with and retrieving active
<literal>connections</literal> to Redis.</para>
<section id="redis:connectors:connection">
<title><interfacename>RedisConnection</interfacename> and <interfacename>RedisConnectionFactory</interfacename></title>
@@ -64,12 +64,12 @@
<note>For the corner cases where the native library API is required, <interfacename>RedisConnection</interfacename> provides a dedicated method
<methodname>getNativeConnection</methodname> which returns the raw, underlying object used for communication.</note>
<para>Active <interfacename>RedisConnection</interfacename> are created through <interfacename>RedisConnectionFactory</interfacename>. In addition, the factories act as
<interfacename>PersistenceExceptionTranslator</interfacename> meaning once declared, allow one to do transparent exception translation for example through the use of the
<para>Active <interfacename>RedisConnection</interfacename>s are created through <interfacename>RedisConnectionFactory</interfacename>. In addition, the factories act as
<interfacename>PersistenceExceptionTranslator</interfacename>s, meaning once declared, they allow one to do transparent exception translation. For example, exception translation through the use of the
<literal>@Repository</literal> annotation and AOP. For more information see the dedicated
<ulink url="http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/orm.html#orm-exception-translation">section</ulink> in Spring Framework documentation.</para>
<note>Depending on the underlying configuration, the factory can return a new connection or an existing connection (in case a pool is used).</note>
<note>Depending on the underlying configuration, the factory can return a new connection or an existing connection (in case a pool or shared native connection is used).</note>
</section>
<para>The easiest way to work with a <interfacename>RedisConnectionFactory</interfacename> is to configure the appropriate connector through the IoC container and
@@ -78,8 +78,7 @@
<sidebar>
<title>Connector features</title>
<para>Unfortunately, currently, not connectors support all of Redis features - in particular JRedis does not have support for hashes yet though this is currently being worked on.
When invoking a method on the <interfacename>Connection</interfacename> API that is unsupported by the underlying library, a <classname>UnsupportedOperationException</classname>
<para>Unfortunately, currently, not all connectors support all Redis features. When invoking a method on the <interfacename>Connection</interfacename> API that is unsupported by the underlying library, a <classname>UnsupportedOperationException</classname>
is thrown.
This situation is likely to be fixed in the future, as the various connectors mature.
</para>
@@ -88,8 +87,8 @@
<section id="redis:connectors:jedis">
<title>Configuring Jedis connector</title>
<para><ulink url="http://github.com/xetorthio/jedis">Jedis</ulink> is one of the connectors supported by the Key Value module through the
<literal>org.springframework.data.redis.connection.jedis</literal> package. In its simples form, the Jedis configuration looks as follow:</para>
<para><ulink url="http://github.com/xetorthio/jedis">Jedis</ulink> is one of the connectors supported by the Spring Data Redis module through the
<literal>org.springframework.data.redis.connection.jedis</literal> package. In its simplest form, the Jedis configuration looks as follow:</para>
<programlisting language="xml"><![CDATA[<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
@@ -119,9 +118,9 @@
<section id="redis:connectors:jredis">
<title>Configuring JRedis connector</title>
<para><ulink url="http://github.com/alphazero/jredis">JRedis</ulink> is another popular, open-source connector supported by Spring Redis through the
<para><ulink url="http://github.com/alphazero/jredis">JRedis</ulink> is another popular, open-source connector supported by Spring Data Redis through the
<literal>org.springframework.data.redis.connection.jredis</literal> package.</para>
<note>Since JRedis itself does not support (yet) Redis 2.x commands, Spring Redis uses an updated fork available
<note>Since JRedis itself did not support Redis 2.x commands at the time of SDR's first release, Spring Data Redis uses a fork available
<ulink url="http://github.com/anthonylauzon/jredis">here</ulink>.</note>
<para>A typical JRedis configuration can looks like this:</para>
@@ -151,10 +150,10 @@
<section id="redis:connectors:rjc">
<title>Configuring RJC connector</title>
<para><ulink url="http://github.com/e-mzungu/rjc">RJC</ulink> is the third, open-source connector supported by Spring Redis through the
<para><ulink url="http://github.com/e-mzungu/rjc">RJC</ulink> is the third, open-source connector supported by Spring Data Redis through the
<literal>org.springframework.data.redis.connection.rjc</literal> package.</para>
<para>Similar to the other connectors, a typical RJC configuration can looks like this:</para>
<para>Similar to the other connectors, a typical RJC configuration can look like this:</para>
<programlisting language="xml"><![CDATA[<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
@@ -182,7 +181,7 @@
<title>Configuring SRP connector</title>
<para><ulink url="https://github.com/spullara/redis-protocol">SRP</ulink> (an acronym for Sam's Redis Protocol) is the forth, open-source connector supported by
Spring Redis through the <literal>org.springframework.data.redis.connection.srp</literal> package.</para>
Spring Data Redis through the <literal>org.springframework.data.redis.connection.srp</literal> package.</para>
<para>By now, its configuration is probably easy to guess:</para>
@@ -203,8 +202,8 @@
<section id="redis:connectors:lettuce">
<title>Configuring Lettuce connector</title>
<para><ulink url="https://github.com/wg/lettuce">Lettuce</ulink> is the fifth, open-source connector supported by
Spring Redis through the <literal>org.springframework.data.redis.connection.lettuce</literal> package.</para>
<para><ulink url="https://github.com/wg/lettuce">Lettuce</ulink> is the fifth open-source connector supported by
Spring Data Redis through the <literal>org.springframework.data.redis.connection.lettuce</literal> package.</para>
<para>Its configuration is probably easy to guess:</para>
@@ -229,7 +228,7 @@
<para>Most users are likely to use <classname>RedisTemplate</classname> and its coresponding package <literal>org.springframework.data.redis.core</literal> - the
template is in fact the central class of the Redis module due to its rich feature set.
The template offers a high-level abstraction for Redis interaction - while <interfacename>RedisConnection</interfacename> offer low level methods that accept and return
The template offers a high-level abstraction for Redis interactions. While <interfacename>RedisConnection</interfacename> offers low level methods that accept and return
binary values (<literal>byte</literal> arrays), the template takes care of serialization and connection management, freeing the user from dealing with such details.</para>
<para>Moreover, the template provides operations views (following the grouping from Redis command <ulink url="http://redis.io/commands">reference</ulink>)
@@ -302,12 +301,12 @@
<para>Once configured, the template is thread-safe and can be reused across multiple instances.</para>
<para>Out of the box, <classname>RedisTemplate</classname> uses a Java-based serializer for most of its operations. This means that any object written or read by the template will be
serializer/deserialized through Java. The serialization mechanism can be easily changed on the template and the Redis module offers several implementations available in the
serializer/deserialized through Java. The serialization mechanism can be easily changed on the template, and the Redis module offers several implementations available in the
<literal>org.springframework.data.redis.serializer</literal> package - see <xref linkend="redis:serializer"/> for more information.
Note that the template requires all keys to be non-null - values can be null as long as the underlying
serializer accepts them; read the javadoc of each serializer for more information.</para>
<para>For cases where a certain template <emphasis>view</emphasis> is needed, one the view as a dependency and inject the template: the container will automatically perform the conversion
<para>For cases where a certain template <emphasis>view</emphasis> is needed, declare the view as a dependency and inject the template: the container will automatically perform the conversion
eliminating the <literal>opsFor[X]</literal> calls:</para>
<programlisting language="xml"><![CDATA[<?xml version="1.0" encoding="UTF-8"?>
@@ -346,10 +345,10 @@
<section id="redis:string">
<title>String-focused convenience classes</title>
<para>Since it's quite the keys and values stored in Redis can be <classname>java.lang.String</classname>, the Redis modules provides two extensions to <interfacename>RedisConnection</interfacename>
and <classname>RedisTemplate</classname> respectively the <interfacename>StringRedisConnection</interfacename> (and its <classname>DefaultStringRedisConnection</classname> implementation)
<para>Since it's quite common for the keys and values stored in Redis to be <classname>java.lang.String</classname>, the Redis modules provides two extensions to <interfacename>RedisConnection</interfacename>
and <classname>RedisTemplate</classname>, respectively the <interfacename>StringRedisConnection</interfacename> (and its <classname>DefaultStringRedisConnection</classname> implementation)
and <classname>StringRedisTemplate</classname> as a convenient one-stop solution
for intensive String operations. In addition to be bound to <literal>String</literal> keys, the template and the connection use the
for intensive String operations. In addition to being bound to <literal>String</literal> keys, the template and the connection use the
<classname>StringRedisSerializer</classname> underneath which means the stored keys and values are human readable (assuming the same encoding is used both in Redis and your code).
For example:
</para>
@@ -401,7 +400,7 @@
<para>From the framework perspective, the data stored in Redis are just bytes. While Redis itself supports various types, for the most part these refer to the way the data is stored
rather then what it represents. It is up to the user to decide whether the information gets translated into Strings or any other objects. The conversion between the user (custom)
types and raw data (and vice-versa) is handled in Spring Redis Redis through the <interfacename>RedisSerializer</interfacename> interface
types and raw data (and vice-versa) is handled in Spring Data Redis through the <interfacename>RedisSerializer</interfacename> interface
(package <literal>org.springframework.data.redis.serializer</literal>) which as the name implies, takes care of the serialization process. Multiple implementations are
available out of the box, two of which have been already mentioned before in this documentation: the <literal>StringRedisSerializer</literal> and
the <literal>JdkSerializationRedisSerializer</literal>. However one can use <classname>OxmSerializer</classname> for Object/XML mapping through Spring 3
@@ -412,6 +411,8 @@
<xi:include href="redis-messaging.xml"/>
<xi:include href="redis-transactions.xml"/>
<section id="redis:support">
<title>Support Classes</title>
@@ -433,7 +434,7 @@
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="queue" class="org.springframework.data.redis.support.collections.DefaultRedisList">
<constructor-arg ref="redisTemplat"/>
<constructor-arg ref="redisTemplate"/>
<constructor-arg value="queue-key"/>
</bean>