diff --git a/spring-datastore-redis/pom.xml b/spring-datastore-redis/pom.xml
index 679e15f44..eb476bdd2 100644
--- a/spring-datastore-redis/pom.xml
+++ b/spring-datastore-redis/pom.xml
@@ -88,7 +88,7 @@
redis.clientsjedis
- 1.0.0-RC3
+ 1.1.1compile
@@ -98,6 +98,13 @@
a.0-SNAPSHOTcompile
+
+
+ org.springframework.commons
+ spring-commons-serializer
+ 1.0.0.BUILD-SNAPSHOT
+ compile
+
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/CannotGetRedisConnectionException.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/CannotGetRedisConnectionException.java
new file mode 100644
index 000000000..6775acff3
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/CannotGetRedisConnectionException.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.datastore.redis;
+
+import org.springframework.dao.DataAccessResourceFailureException;
+
+/**
+ * Fatal exception thrown when we can't connect to Redis.
+ * @author Mark Pollack
+ *
+ */
+public class CannotGetRedisConnectionException extends
+ DataAccessResourceFailureException {
+
+ public CannotGetRedisConnectionException(String msg) {
+ super(msg);
+ }
+
+ public CannotGetRedisConnectionException(String msg, Throwable cause) {
+ super(msg, cause);
+ }
+
+}
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/AbstractRedisClient.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/AbstractRedisClient.java
new file mode 100644
index 000000000..458c2e0a8
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/AbstractRedisClient.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.datastore.redis.core;
+
+import java.io.UnsupportedEncodingException;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.dao.InvalidDataAccessApiUsageException;
+
+/**
+ * Common base class for RedisClient implementations
+ * @author Mark Pollack
+ *
+ */
+public abstract class AbstractRedisClient implements RedisClient {
+
+ protected final Log logger = LogFactory.getLog(this.getClass());
+
+ public static final String DEFAULT_CHARSET = "UTF-8";
+
+ private volatile String defaultCharset = DEFAULT_CHARSET;
+
+ /**
+ * Specify the default charset to use when converting to or from text-based
+ * Message body content. If not specified, the charset will be "UTF-8".
+ */
+ public void setDefaultCharset(String defaultCharset) {
+ this.defaultCharset = (defaultCharset != null) ? defaultCharset : DEFAULT_CHARSET;
+ }
+
+ public String getDefaultCharset() {
+ return defaultCharset;
+ }
+
+ protected byte[] stringToByte(String string) throws InvalidDataAccessApiUsageException {
+ try {
+ return string.getBytes(this.defaultCharset);
+ } catch (UnsupportedEncodingException e) {
+ throw new InvalidDataAccessApiUsageException(defaultCharset
+ + " encoding not supported.", e);
+ }
+ }
+
+ protected String byteToString(byte[] value) throws InvalidDataAccessApiUsageException {
+ try {
+ return new String(value, defaultCharset);
+ } catch (UnsupportedEncodingException e) {
+ throw new InvalidDataAccessApiUsageException(defaultCharset
+ + " encoding not supported.", e);
+ }
+ }
+}
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/AbstractRedisClientFactory.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/AbstractRedisClientFactory.java
new file mode 100644
index 000000000..a23109bef
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/AbstractRedisClientFactory.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.datastore.redis.core;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.datastore.redis.support.RedisPersistenceExceptionTranslator;
+
+/**
+ * Common base class for RedisClientFactories
+ * @author Mark Pollack
+ *
+ */
+public abstract class AbstractRedisClientFactory implements RedisClientFactory {
+
+ protected final Log logger = LogFactory.getLog(getClass());
+
+ private String hostName;
+
+ private int port;
+
+ private String password;
+
+ public int getPort() {
+ return port;
+ }
+
+ protected void setPort(int port) {
+ this.port = port;
+ }
+
+
+
+ public String getPassword() {
+ return password;
+ }
+
+ public void setPassword(String password) {
+ this.password = password;
+ }
+
+ public String getHostName() {
+ return hostName;
+ }
+
+ protected void setHostName(String hostName) {
+ this.hostName = hostName;
+ }
+
+ public RedisClient createClient() {
+ return doGetClient();
+ }
+
+ public abstract RedisClient doGetClient();
+
+ public abstract RedisPersistenceExceptionTranslator getExceptionTranslator();
+
+
+ protected String getDefaultHostName() {
+ String temp;
+ try {
+ InetAddress localMachine = InetAddress.getLocalHost();
+ temp = localMachine.getHostName();
+ logger.debug("Using hostname [" + temp + "] for hostname.");
+ }
+ catch (UnknownHostException e) {
+ logger.warn("Could not get host name, using 'localhost' as default value", e);
+ temp = "localhost";
+ }
+ return temp;
+ }
+
+ /*
+ public void closeClient() {
+ if (logger.isDebugEnabled()) {
+ logger.debug("Closing Redis Client: " + this.client);
+ }
+ try {
+ client.close();
+ }
+ catch (Throwable ex) {
+ logger.debug("Could not close Redis Client", ex);
+ }
+ }*/
+
+}
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/DefaultServerOperations.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/DefaultServerOperations.java
new file mode 100644
index 000000000..a2cea5aa4
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/DefaultServerOperations.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.datastore.redis.core;
+
+import java.util.Map;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+public class DefaultServerOperations implements ServerOperations {
+
+ protected final Log logger = LogFactory.getLog(getClass());
+
+ private RedisOperations redisOperations;
+
+ public DefaultServerOperations(RedisOperations redisOperations) {
+ this.redisOperations = redisOperations;
+ }
+
+ public Map getServerInfo() {
+ return redisOperations.execute(new RedisCallback>() {
+ public Map doInRedis(RedisClient redisClient)
+ throws Exception {
+ return redisClient.info();
+ }
+ });
+ }
+
+}
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/KeyValueOperations.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/KeyValueOperations.java
new file mode 100644
index 000000000..8e6c8485f
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/KeyValueOperations.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.datastore.redis.core;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Key value operations with 'friendly' names instead of using command names for methods.
+ * Additional helper methods for working with keys and values
+ *
+ * @author Mark Pollack
+ *
+ */
+public interface KeyValueOperations {
+
+ // Set and Set with expiry operations
+
+ void set(String key, String value);
+
+ void set(String key, String value, long expiryInMillis);
+
+ void setAsBytes(String key, byte[] value);
+
+ void setAsBytes(String key, byte[] value, long expiryInMillis);
+
+ void convertAndSet(String key, Object value);
+
+ void convertAndSet(String key, Object value, long expiryInMillis);
+
+ // Get operations
+
+ String get(String key);
+
+ byte[] getAsBytes(String key);
+
+ T getAndConvert(String key, Class requiredType);
+
+ // Get and Set operations
+
+ String getAndSet(String key, String value);
+
+ byte[] getAndSetBytes(String key, byte[] value);
+
+ T getAndSetObject(String key, T value, Class requiredType);
+
+ // Multi-get operations
+
+ List getValues(List keys);
+
+ List getAndConvertValues(List keys, Class requiredType);
+
+
+ // Set if non-existent operations
+
+ void setIfKeyNonExistent(String key, String value);
+
+ void setIfKeyNonExistent(String key, byte[] value);
+
+ void convertAndSetIfKeyNonExistent(String key, Object value);
+
+ // Multiple key-value set
+
+ void setMultiple(Map keysAndValues);
+
+ void setMultipleAsBytes(Map keysAndValues);
+
+ void convertAndSetMultiple(Map keysAndValues);
+
+ // Multiple key-value set if non-existent
+
+ void setMultipleIfKeysNonExistent(Map keysAndValues);
+
+ void setMultipleAsBytesIfKeysNonExistent(Map keysAndValues);
+
+ void convertAndSetMultipleIfKeysNonExistent(Map keysAndValues);
+
+
+
+ // Append
+
+ int append(String key, String value);
+
+
+
+ // Increment
+
+ int increment(String key);
+
+ int incrementBy(String key, int value);
+
+ // Decrement
+
+ int decrement(String key);
+
+ int decrementBy(String key, int value);
+
+
+ // Substring
+
+ String getSubString(String key, int fromIndex, int toIndex);
+
+ boolean containsKey(String key);
+
+ boolean deleteKeys(String... keys);
+
+
+
+
+
+
+
+}
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/ListOperations.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/ListOperations.java
new file mode 100644
index 000000000..481bb84b0
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/ListOperations.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.datastore.redis.core;
+
+/**
+ * List operations with 'friendly' names instead of using Redis command names for methods.
+ *
+ * May also include List specific helper methods from redis recipies.
+ * @author Mark Pollack
+ *
+ */
+public interface ListOperations {
+
+
+ //ListRecipies getListRecipies();
+}
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisAccessor.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisAccessor.java
new file mode 100644
index 000000000..a24228fea
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisAccessor.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.datastore.redis.core;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.util.Assert;
+
+/**
+ * Base class for {@link RedisTemplate} and
+ * other Redis-accessing DAO helpers, defining common properties such as
+ * RedisClientFactory.
+ *
+ * @author Mark Pollack
+ *
+ */
+public class RedisAccessor implements InitializingBean {
+
+ /** Logger available to subclasses */
+ protected final Log logger = LogFactory.getLog(getClass());
+
+ private volatile RedisClientFactory redisClientFactory;
+
+ /**
+ * Set the RedisClientFactory to use for obtaining Redis {@link RedisClient clients}.
+ */
+ public void setRedisClientFactory(RedisClientFactory redisClientFactory) {
+ this.redisClientFactory = redisClientFactory;
+ }
+
+
+ /**
+ * Return the RedisClientFactory that this accessor uses for obtaining
+ * Redis {@link RedisClient Clients}.
+ */
+ public RedisClientFactory getRedisClientFactory() {
+ return this.redisClientFactory;
+ }
+
+ /**
+ * Create a Redis Client
+ * @return the new Redis Client
+ * @throws TODO
+ */
+ protected RedisClient createClient() {
+ return this.redisClientFactory.createClient();
+ }
+
+
+ public void afterPropertiesSet() {
+ Assert.notNull(getRedisClientFactory(), "RedisClientfactory is required");
+ }
+
+}
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisCallback.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisCallback.java
new file mode 100644
index 000000000..9e2de19a4
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisCallback.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.datastore.redis.core;
+
+/**
+ * Basic callback for use in RedisTemplate
+ * @author Mark Pollack
+ *
+ * @param TODO
+ */
+public interface RedisCallback {
+
+ /**
+ * Execute any number of operations against the supplied RedisClient
+ * {@link RedicClient}, possibly returning a result.
+ */
+ T doInRedis(RedisClient redisClient) throws Exception;
+}
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisClient.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisClient.java
new file mode 100644
index 000000000..42373d77d
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisClient.java
@@ -0,0 +1,220 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.datastore.redis.core;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * An interface that is a one to one mapping to Redis commands to method names
+ * that is portable across various Redis driver libraries.
+ *
+ * @author Mark Pollack
+ *
+ */
+public interface RedisClient {
+
+ // Connection Management
+
+ void disconnect() throws IOException;
+
+
+ // Database control commands
+
+ String save();
+
+ String bgsave();
+
+ String bgrewriteaof();
+
+ Integer lastsave();
+
+ String shutdown();
+
+ Map info();
+
+ //bulk reply callback - monitor
+
+ String slaveof(String host, int port);
+
+ String slaveofNoOne();
+
+ String select(int index);
+
+ String flushDb();
+
+ String flushAll();
+
+ Integer move(String key, int dbIndex);
+
+ String auth(String password);
+
+ Integer dbSize();
+
+
+ // Note: JRedis and the SMA client do not return the response code for set, would probably have to catch exception.
+
+ // Commands operating on string values "StringOperations" or "Operations"
+
+
+ /**
+ * Set the string value as value of the key. The string can't be longer than 1073741824 bytes (1 GB).
+ *
Time complexity: O(1)
+ *
Corresponds to Redis command "SET key value"
+ * @see setCommand
+ * @param key key whose associated value is to be returned
+ * @param value value to be associated with the specified key
+ */
+ void set(String key, String value);
+
+ void set(String key, byte[] value);
+
+ String get(String key);
+
+ byte[] getAsBytes(String key);
+
+ String getSet(String key, String value);
+
+ List mget(String... keys);
+
+ //TODO mgetAsBytes? Best to have byte[] overloads somewhere else?
+
+ /**
+ * SETNX works exactly like SET with the only difference that if the key already exists no operation is performed.
+ * SETNX actually means "SET if Not eXists".
+ *
Time complexity: O(1)
+ *
Corresponds to command "SETNX key value"
+ * @see SetnxCommand
+ * @param key key whose associated value is to be set
+ * @param value value to be associated with the specified key
+ * @return 1 if the key was set, 0 if the key was not set
+ */
+ Integer setnx(String key, String value);
+
+ /**
+ * The command is exactly equivalent to the following group of commands:
+ *
SET key value
+ * EXPIRE key time
+ *
+ *
Time complexity: O(1)
+ * @see SetexCommand
+ * @param key key whose associated value is to be set
+ * @param seconds timeout on the specified key. After the timeout the key will automatically be deleted by the server
+ * @param value timeout in seconds
+ * @return Status reply code, OK is success
+ */
+ String setex(String key, int seconds, String value);
+
+ /**
+ * Set the the respective keys to the respective values.
+ *
Time complexity: O(1) to set every key
+ *
Corresponds to the command "MSET key1 value1 key2 value2 ... keyN valueN"
+ * @see MsetCommand
+ * @param keysvalues key value sequence
+ * @return OK as MSET can't fail.
+ */
+ //TODO Consider Map here or in template? Map ?
+ String mset(String... keysvalues);
+
+ Integer msetnx(String... keysvalues);
+
+ Integer incrBy(String key, int increment);
+
+ Integer incr(String key);
+
+ Integer decr(String key);
+
+ Integer decrBy(String key, int decrement);
+
+ //TODO incrementByOne,decrementByOne in template
+
+ /**
+ * If the key already exists and is a string, this command appends the provided value at the
+ * end of the string. If the key does not exist it is created and set as an empty string,
+ * so APPEND will be very similar to SET in this special case.
+ * @see AppendCommand
+ * @param key key whose associated value is to be appended
+ * @param value value to be appended to end of current value associated with the specified key
+ * @return the total length of the string after the append operation.
+ */
+ Integer append(String key, String value);
+
+ String substr(String key, int start, int end);
+
+
+ // Commands operating on all value types "KeySpaceOperations"
+
+ Integer exists(String key);
+
+ Integer del(String... keys);
+
+ String type(String key);
+
+ List keys(String pattern);
+
+ String randomKey();
+
+ String rename(String oldkey, String newkey);
+
+ Integer renamenx(String oldkey, String newkey);
+
+ Integer expire(String key, int seconds);
+
+ Integer expireAt(String key, long unixTime);
+
+ Integer ttl(String key);
+
+ Integer persist(String key);
+
+
+
+
+ // Probably not possible to abstract at this level across different providers....
+ // T sendCommand(String commandName, ReplyTypeMapper mapper, String... commandArgs);
+
+ // Commands operating on Sets
+
+ Integer sadd(String key, String member);
+
+ Set smembers(String key);
+
+ Integer srem(String key, String member);
+
+ String spop(String key);
+
+ Integer smove(String srckey, String dstkey, String member);
+
+ Integer scard(String key);
+
+ Integer sismember(String key, String member);
+
+ Set sinter(String... keys);
+
+ Integer sinterstore(String dstkey, String... keys);
+
+ Set sunion(String... keys);
+
+ Integer sunionstore(String dstkey, String... keys);
+
+ Set sdiff(String... keys);
+
+ Integer sdiffstore(String dstkey, String... keys);
+
+ String srandmember(String key);
+
+}
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisClientFactory.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisClientFactory.java
new file mode 100644
index 000000000..3ac6358a0
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisClientFactory.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.datastore.redis.core;
+
+
+import org.springframework.datastore.redis.support.RedisPersistenceExceptionTranslator;
+
+/**
+ * An interface based ConnectionFactory for creating {@link RedisClient}s.
+ *
+ * @author Mark Pollack
+ *
+ */
+public interface RedisClientFactory {
+
+ RedisClient createClient();
+
+ void setPassword(String password);
+
+ RedisPersistenceExceptionTranslator getExceptionTranslator();
+}
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisOperations.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisOperations.java
new file mode 100644
index 000000000..b677521dd
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisOperations.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.datastore.redis.core;
+
+import java.util.List;
+
+import org.springframework.dao.DataAccessException;
+
+/**
+ * Interface specifying a set of Redis operations.
+ * Implemented by {@link RedisTemplate}.
+ *
+ * @author Mark Pollack
+ *
+ */
+public interface RedisOperations extends KeyValueOperations {
+
+ T execute(RedisCallback action) throws DataAccessException;
+
+ ServerOperations getServerOperations();
+
+ ListOperations getListOperations();
+
+ SetOperations getSetOperations();
+
+
+
+}
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisTemplate.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisTemplate.java
new file mode 100644
index 000000000..5594cb431
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/RedisTemplate.java
@@ -0,0 +1,293 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.datastore.redis.core;
+
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.dao.DataAccessException;
+import org.springframework.dao.DataRetrievalFailureException;
+import org.springframework.datastore.redis.support.RedisUtils;
+import org.springframework.datastore.redis.support.converter.DefaultRedisConverter;
+import org.springframework.datastore.redis.support.converter.RedisConverter;
+import org.springframework.util.Assert;
+
+/**
+ * This is the central class in the Redis core package.
+ * It simplifies the use of Redis and helps to avoid common errors.
+ *
+ * @author Mark Pollack
+ *
+ */
+public class RedisTemplate extends RedisAccessor implements RedisOperations {
+
+ // TODO perform validation to see if value size > 1GB
+ // TODO perform validation to see if key contains space, newline or whitespace.
+ // TODO warning on key size being large > 1024 bytes?
+
+ private RedisConverter redisConverter = new DefaultRedisConverter();
+
+ private ServerOperations serverOperations;
+
+ public RedisTemplate() {
+ initDefaults();
+ }
+ public RedisTemplate(RedisClientFactory redisClientFactory) {
+ this();
+ this.setRedisClientFactory(redisClientFactory);
+ afterPropertiesSet();
+ }
+
+ public void setRedisConverter(RedisConverter redisConverter) {
+ this.redisConverter = redisConverter;
+ }
+
+ protected void initDefaults() {
+ serverOperations = new DefaultServerOperations(this);
+ }
+
+
+
+ public T execute(RedisCallback action) {
+ Assert.notNull(action, "Callback object must not be null");
+
+ RedisClient clientToClose = null;
+ try {
+ RedisClient clientToUse = null; //ConnectionFactoryUtils.doGetTransacxtionChannel(getConnectionFactory, this.transactionResourceFactory);
+ if (clientToUse == null) {
+ clientToClose = createClient();
+ clientToUse = clientToClose;
+ }
+ if (logger.isDebugEnabled()) {
+ logger.debug("Executing callback on Redis Client: " + clientToUse);
+ }
+ return action.doInRedis(clientToUse);
+ }
+ catch (Exception e) {
+ throw convertRedisAccessException(e);
+ } finally {
+ RedisUtils.closeClient(clientToClose);
+ }
+ }
+
+ protected DataAccessException convertRedisAccessException(Exception ex) {
+ //TODO
+ return null;
+ }
+
+ public ServerOperations getServerOperations() {
+ return serverOperations;
+ }
+
+ public ListOperations getListOperations() {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ // Key Value Operations
+
+ public String get(final String key) {
+ return execute(new RedisCallback() {
+ public String doInRedis(RedisClient redisClient) throws Exception {
+ return redisClient.get(key);
+ }
+ });
+ }
+
+ public byte[] getAsBytes(final String key) {
+ return execute(new RedisCallback() {
+ public byte[] doInRedis(RedisClient redisClient) throws Exception {
+ return redisClient.getAsBytes(key);
+ }
+ });
+ }
+
+ public T getAndConvert(String key, Class requiredType) {
+ //TODO deserializer exceptions need to be under DAO exception hierarchy.
+ Object object = redisConverter.deserialize(getAsBytes(key));
+ if (requiredType != null && object != null && !requiredType.isAssignableFrom(object.getClass())) {
+ throw new DataRetrievalFailureException("Can not assign from " + requiredType + " to " + object.getClass());
+ }
+ return (T) object;
+ }
+
+ public String getAndSet(String key, String value) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public byte[] getAndSetBytes(String key, byte[] value) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public T getAndSetObject(String key, T value, Class requiredType) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public void set(final String key, final String value) {
+ execute(new RedisCallback() {
+ public Void doInRedis(RedisClient redisClient) throws Exception {
+ redisClient.set(key, value);
+ return null;
+ }
+ });
+ }
+
+ public void set(String key, String value, long expiryInMillis) {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void setAsBytes(final String key, final byte[] value) {
+ execute(new RedisCallback() {
+ public Void doInRedis(RedisClient redisClient) throws Exception {
+ redisClient.set(key, value);
+ return null;
+ }
+ });
+
+ }
+
+ public void setAsBytes(String key, byte[] value, long expiryInMillis) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public void setIfKeyNonExistent(String key, String value) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public void setIfKeyNonExistent(String key, byte[] value) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public void setMultiple(Map keysAndValues) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public void setMultipleAsBytes(Map keysAndValues) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public void setMultipleAsBytesIfKeysNonExistent(
+ Map keysAndValues) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public void setMultipleIfKeysNonExistent(Map keysAndValues) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public int append(String key, String value) {
+ throw new RuntimeException("unimplemented");
+ }
+
+ public void convertAndSet(String key, Object value) {
+ setAsBytes(key, this.redisConverter.serialize(value));
+ }
+
+ public void convertAndSet(String key, Object value, long expiryInMillis) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public void convertAndSetIfKeyNonExistent(String key, Object value) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public void convertAndSetMultiple(Map keysAndValues) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public void convertAndSetMultipleIfKeysNonExistent(
+ Map keysAndValues) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public int decrement(String key) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public int decrementBy(String key, int value) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public List getValues(List keys) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public int increment(String key) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public int incrementBy(String key, int value) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+
+ public String subString(String key, int fromIndex, int toIndex) {
+ // TODO Auto-generated method stub
+ throw new RuntimeException("unimplemented");
+ }
+ public List getAndConvertValues(List keys,
+ Class requiredType) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+ public String getSubString(String key, int fromIndex, int toIndex) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+ public boolean containsKey(String key) {
+ // TODO Auto-generated method stub
+ return false;
+ }
+ public boolean deleteKeys(final String... keys) {
+ return execute(new RedisCallback() {
+ public Boolean doInRedis(RedisClient redisClient) throws Exception {
+ Integer intVal = redisClient.del(keys);
+ return (intVal == 0) ? false : true;
+ }
+ });
+ }
+
+ public SetOperations getSetOperations() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+
+
+
+
+
+}
\ No newline at end of file
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/ServerOperations.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/ServerOperations.java
new file mode 100644
index 000000000..10e270757
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/ServerOperations.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.datastore.redis.core;
+
+import java.util.Map;
+
+/**
+ * Server operations for Redis
+ *
+ * @author Mark Pollack
+ *
+ */
+public interface ServerOperations {
+
+
+ // Connection handling
+
+
+
+
+ /**
+ * Calls the Redis 'info' command that returns different information and statistics about the server.
+ * The reply is parsed into a Map for easy programmatic access.
+ * Corresponds to the Redis InfoCommand INFO
+ * @see InfoCommand
+ * @return
+ */
+ Map getServerInfo();
+
+ // TODO Commands Monitor, SlaveOf, Config
+}
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/SetOperations.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/SetOperations.java
new file mode 100644
index 000000000..d3026e649
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/SetOperations.java
@@ -0,0 +1,35 @@
+package org.springframework.datastore.redis.core;
+
+import java.util.Set;
+
+public interface SetOperations {
+
+ boolean add(String key, String member);
+
+ Set getAll(String key);
+
+ boolean remove(String key, String member);
+
+ boolean removeRandom(String key);
+
+ boolean moveBetweenSets(String srckey, String dstkey, String member);
+
+ int size(String key);
+
+ boolean contains(String key, String member);
+
+ Set getIntersectionOfSets(String... keys);
+
+ void storeIntersectionOfSets(String dstkey, String... keys);
+
+ Set getUnionOfSets(String... keys);
+
+ void storeUnionOfSets(String dstkey, String... keys);
+
+ Set getDifferenceBetweenSets(String... keys);
+
+ void storeDifferenceBetweenSets(String dstkey, String... keys);
+
+ String getRandom(String key);
+
+}
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/jedis/CachingJedisClientFactory.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/jedis/CachingJedisClientFactory.java
new file mode 100644
index 000000000..1a6d87456
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/jedis/CachingJedisClientFactory.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.datastore.redis.core.jedis;
+
+import java.util.concurrent.TimeoutException;
+
+import org.springframework.datastore.redis.CannotGetRedisConnectionException;
+import org.springframework.datastore.redis.core.AbstractRedisClientFactory;
+import org.springframework.datastore.redis.core.RedisClient;
+import org.springframework.datastore.redis.support.RedisPersistenceExceptionTranslator;
+
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.JedisPool;
+
+/**
+ * A RedisClientFactory implementation that uses Jedis's native connection/client
+ * caching features.
+ *
+ * @author Mark Pollack
+ *
+ */
+public class CachingJedisClientFactory extends AbstractRedisClientFactory {
+
+ private JedisPool pool;
+
+ private int timeout;
+
+ private int clientCacheSize;
+
+ private long maxWaitTime;
+
+ /**
+ *
+ * @param clientCacheSize
+ */
+ public CachingJedisClientFactory(int clientCacheSize) {
+ this.clientCacheSize = clientCacheSize;
+ }
+
+ public CachingJedisClientFactory(JedisPool pool) {
+ this.pool = pool;
+ }
+
+ public int getClientCacheSize() {
+ return this.clientCacheSize;
+ }
+
+ public JedisPool getJedisPool() {
+ return this.pool;
+ }
+
+ public int getTimeout() {
+ return timeout;
+ }
+
+ protected void setTimeout(int timeout) {
+ this.timeout = timeout;
+ }
+
+ public long getMaxWaitTime() {
+ return this.maxWaitTime;
+ }
+
+ /**
+ * Sets the maximum amount of time (in milliseconds) the getResource() method
+ * should block before throwing an TimeoutException.
+ * @param maxWaitTime The maximum time you would like to wait for the resource.
+ */
+ public void setMaxWaitTime(long maxWaitTime) {
+ this.maxWaitTime = maxWaitTime;
+ }
+
+ @Override
+ public RedisClient doGetClient() {
+ Jedis jedis;
+ if (getClientCacheSize() != 0) {
+ pool = new JedisPool(getHostName(), getPort(), getTimeout());
+ pool.setResourcesNumber(getClientCacheSize());
+ }
+ try {
+ if (getMaxWaitTime() != 0)
+ jedis = pool.getResource(getMaxWaitTime());
+ else {
+ jedis = pool.getResource();
+ }
+ } catch (TimeoutException e) {
+ throw new CannotGetRedisConnectionException(
+ "Timed out. Could not get Redis Connection", e);
+ }
+ return new JedisClient(jedis, getExceptionTranslator() );
+ }
+
+ @Override
+ public RedisPersistenceExceptionTranslator getExceptionTranslator() {
+ return new JedisPersistenceExceptionTranslator();
+ }
+
+}
diff --git a/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/jedis/JedisClient.java b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/jedis/JedisClient.java
new file mode 100644
index 000000000..ec57649da
--- /dev/null
+++ b/spring-datastore-redis/src/main/java/org/springframework/datastore/redis/core/jedis/JedisClient.java
@@ -0,0 +1,535 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.datastore.redis.core.jedis;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.springframework.dao.DataAccessException;
+import org.springframework.datastore.redis.core.AbstractRedisClient;
+import org.springframework.datastore.redis.support.RedisPersistenceExceptionTranslator;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+import redis.clients.jedis.Jedis;
+
+/**
+ * Jedis based implementation of Spring's RedisClient interface. Presents a low
+ * level API where method names map onto Redis commands.
+ *
+ * @author Mark Pollack
+ *
+ */
+public class JedisClient extends AbstractRedisClient {
+
+ private Jedis _jedis;
+ private RedisPersistenceExceptionTranslator exceptionTranslator;
+
+ public JedisClient(Jedis jedis,
+ RedisPersistenceExceptionTranslator exceptionTranslator) {
+ this._jedis = jedis;
+ this.exceptionTranslator = exceptionTranslator;
+ }
+
+ public T execute(JedisClientCallback action) {
+ Assert.notNull(action, "Callback object must not be null");
+
+ // TODO jredisClient resource mgmt.
+ try {
+ if (logger.isDebugEnabled()) {
+ logger.debug("Executing callback on Jedis : " + _jedis);
+ }
+ return action.doInJedis(_jedis);
+ } catch (Exception e) {
+ throw convertJedisAccessException(e);
+ }
+
+ }
+
+ protected DataAccessException convertJedisAccessException(Exception ex) {
+ return exceptionTranslator.translateException(ex);
+ }
+
+ public void disconnect() throws IOException {
+ execute(new JedisClientCallback