diff --git a/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/DefaultBoundHashOperations.java b/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/DefaultBoundHashOperations.java index 7639ed704..8387c45be 100644 --- a/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/DefaultBoundHashOperations.java +++ b/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/DefaultBoundHashOperations.java @@ -27,7 +27,6 @@ import java.util.Set; class DefaultBoundHashOperations extends DefaultKeyBound implements BoundHashOperations { private final HashOperations ops; - private RedisOperations template; /** * Constructs a new DefaultBoundHashOperations instance. @@ -52,7 +51,7 @@ class DefaultBoundHashOperations extends DefaultKeyBound implement @Override public RedisOperations getOperations() { - return template; + return ops.getOperations(); } @Override diff --git a/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/HashOperations.java b/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/HashOperations.java index 82618e745..23755be71 100644 --- a/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/HashOperations.java +++ b/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/HashOperations.java @@ -43,4 +43,6 @@ public interface HashOperations { void set(H key, HK hashKey, HV value); Collection values(H key); + + RedisOperations getOperations(); } diff --git a/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/RedisTemplate.java b/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/RedisTemplate.java index 01b7d0e70..260a02968 100644 --- a/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/RedisTemplate.java +++ b/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/core/RedisTemplate.java @@ -56,7 +56,8 @@ public class RedisTemplate extends RedisAccessor implements RedisOperation private boolean exposeConnection = false; private RedisSerializer keySerializer = new StringRedisSerializer(); private RedisSerializer valueSerializer = new SimpleRedisSerializer(); - private RedisSerializer defaultSerializer = new SimpleRedisSerializer(); + private RedisSerializer hashKeySerializer = new SimpleRedisSerializer(); + private RedisSerializer hashValueSerializer = new SimpleRedisSerializer(); public RedisTemplate() { } @@ -82,7 +83,7 @@ public class RedisTemplate extends RedisAccessor implements RedisOperation } public T execute(RedisCallback action, boolean exposeConnection) { - return execute(action, isExposeConnection(), defaultSerializer); + return execute(action, exposeConnection, valueSerializer); } public T execute(RedisCallback action, boolean exposeConnection, RedisSerializer returnSerializer) { @@ -133,18 +134,43 @@ public class RedisTemplate extends RedisAccessor implements RedisOperation this.exposeConnection = exposeConnection; } + /** + * Sets the key serializer to be used by this template. Defaults to {@link SimpleRedisSerializer}. + * + * @param serializer + */ public void setKeySerializer(RedisSerializer serializer) { this.keySerializer = serializer; } + /** + * Sets the value serializer to be used by this template. Defaults to {@link SimpleRedisSerializer}. + * + * @param serializer + */ public void setValueSerializer(RedisSerializer serializer) { this.valueSerializer = serializer; } - public void setDefaultSerializer(RedisSerializer serializer) { - this.defaultSerializer = serializer; + /** + * Sets the hash key (or field) serializer to be used by this template. Defaults to {@link SimpleRedisSerializer}. + * + * @param hashKeySerializer The hashKeySerializer to set. + */ + public void setHashKeySerializer(RedisSerializer hashKeySerializer) { + this.hashKeySerializer = hashKeySerializer; } + /** + * Sets the hash value serializer to be used by this template. Defaults to {@link SimpleRedisSerializer}. + * + * @param hashValueSerializer The hashValueSerializer to set. + */ + public void setHashValueSerializer(RedisSerializer hashValueSerializer) { + this.hashValueSerializer = hashValueSerializer; + } + + /** * Invocation handler that suppresses close calls on JDO PersistenceManagers. * Also prepares returned Query objects. @@ -202,37 +228,76 @@ public class RedisTemplate extends RedisAccessor implements RedisOperation return rawKeys; } + private byte[] rawHashKey(HK value) { + return (value != null ? hashKeySerializer.serialize(value) : null); + } + + private byte[] rawHashValue(HV value) { + return (value != null ? hashValueSerializer.serialize(value) : null); + } + + @SuppressWarnings("unchecked") private > T values(Collection rawValues, Class type) { Collection values = (List.class.isAssignableFrom(type) ? new ArrayList(rawValues.size()) : new LinkedHashSet(rawValues.size())); for (byte[] bs : rawValues) { - values.add((V) valueSerializer.deserialize(bs)); + if (bs != null) { + values.add((V) valueSerializer.deserialize(bs)); + } } return (T) values; } @SuppressWarnings("unchecked") - private Collection arbitraryValues(Collection rawValues, Class type) { + private Collection hashValues(Collection rawValues, Class type) { Collection values = (List.class.isAssignableFrom(type) ? new ArrayList(rawValues.size()) : new LinkedHashSet(rawValues.size())); for (byte[] bs : rawValues) { - values.add((H) valueSerializer.deserialize(bs)); + if (bs != null) { + values.add((H) hashValueSerializer.deserialize(bs)); + } } return values; } + @SuppressWarnings("unchecked") + private K deserializeKey(byte[] value) { + return (K) deserialize(value, keySerializer); + } + + @SuppressWarnings("unchecked") + private V deserializeValue(byte[] value) { + return (V) deserialize(value, valueSerializer); + } + + @SuppressWarnings("unchecked") + private HK deserializeHashKey(byte[] value) { + return (HK) deserialize(value, hashKeySerializer); + } + + @SuppressWarnings("unchecked") + private HV deserializeHashValue(byte[] value) { + return (HV) deserialize(value, hashValueSerializer); + } + + private T deserialize(byte[] value, RedisSerializer serializer) { + if (isEmpty(value)) { + return null; + } + return (T) serializer.deserialize(value); + } + + private static boolean isEmpty(byte[] data) { + return (data == null || data.length == 0); + } + // utility methods for the template internal methods private abstract class ValueDeserializingRedisCallback implements RedisCallback { private K key; - public ValueDeserializingRedisCallback() { - this(null); - - } - public ValueDeserializingRedisCallback(K key) { this.key = key; } @@ -241,10 +306,7 @@ public class RedisTemplate extends RedisAccessor implements RedisOperation @Override public final V doInRedis(RedisConnection connection) { byte[] result = inRedis(rawKey(key), connection); - if (result != null) { - return (V) valueSerializer.deserialize(result); - } - return null; + return deserializeValue(result); } protected abstract byte[] inRedis(byte[] rawKey, RedisConnection connection); @@ -558,7 +620,7 @@ public class RedisTemplate extends RedisAccessor implements RedisOperation public void diffAndStore(final K key, K destKey, final K... keys) { final byte[][] rawKeys = rawKeys(aggregateKeys(key, keys)); final byte[] rawDestKey = rawKey(destKey); - Object rawValues = execute(new RedisCallback() { + execute(new RedisCallback() { @Override public Object doInRedis(RedisConnection connection) { connection.sDiffStore(rawDestKey, rawKeys); @@ -881,10 +943,15 @@ public class RedisTemplate extends RedisAccessor implements RedisOperation private class DefaultHashOperations implements HashOperations { + @Override + public RedisOperations getOperations() { + return RedisTemplate.this; + } + @Override public HV get(K key, Object hashKey) { final byte[] rawKey = rawKey(key); - final byte[] rawHashKey = rawValue(hashKey); + final byte[] rawHashKey = rawHashKey(hashKey); byte[] rawHashValue = execute(new RedisCallback() { @Override @@ -893,13 +960,13 @@ public class RedisTemplate extends RedisAccessor implements RedisOperation } }, true); - return (HV) valueSerializer.deserialize(rawHashValue); + return (HV) deserializeHashValue(rawHashValue); } @Override public Boolean hasKey(K key, Object hashKey) { final byte[] rawKey = rawKey(key); - final byte[] rawHashKey = rawValue(hashKey); + final byte[] rawHashKey = rawHashKey(hashKey); return execute(new RedisCallback() { @Override @@ -912,7 +979,7 @@ public class RedisTemplate extends RedisAccessor implements RedisOperation @Override public Integer increment(K key, HK hashKey, final int delta) { final byte[] rawKey = rawKey(key); - final byte[] rawHashKey = rawValue(hashKey); + final byte[] rawHashKey = rawHashKey(hashKey); return execute(new RedisCallback() { @Override @@ -934,7 +1001,7 @@ public class RedisTemplate extends RedisAccessor implements RedisOperation } }, true); - return (Set) arbitraryValues(rawValues, Set.class); + return (Set) hashValues(rawValues, Set.class); } @Override @@ -951,12 +1018,16 @@ public class RedisTemplate extends RedisAccessor implements RedisOperation @Override public void multiSet(K key, Map m) { + if (m.isEmpty()) { + return; + } + final byte[] rawKey = rawKey(key); final Map hashes = new LinkedHashMap(m.size()); - for (Map.Entry entry : hashes.entrySet()) { - hashes.put(rawValue(entry.getKey()), rawValue(entry.getValue())); + for (Map.Entry entry : m.entrySet()) { + hashes.put(rawHashKey(entry.getKey()), rawHashValue(entry.getValue())); } execute(new RedisCallback() { @@ -971,8 +1042,8 @@ public class RedisTemplate extends RedisAccessor implements RedisOperation @Override public void set(K key, HK hashKey, HV value) { final byte[] rawKey = rawKey(key); - final byte[] rawHashKey = rawValue(hashKey); - final byte[] rawHashValue = rawValue(value); + final byte[] rawHashKey = rawHashKey(hashKey); + final byte[] rawHashValue = rawHashValue(value); execute(new RedisCallback() { @Override @@ -994,13 +1065,13 @@ public class RedisTemplate extends RedisAccessor implements RedisOperation } }, true); - return (List) arbitraryValues(rawValues, List.class); + return (List) hashValues(rawValues, List.class); } @Override public void delete(K key, Object hashKey) { final byte[] rawKey = rawKey(key); - final byte[] rawHashKey = rawValue(hashKey); + final byte[] rawHashKey = rawHashKey(hashKey); execute(new RedisCallback() { @Override diff --git a/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/serializer/SimpleRedisSerializer.java b/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/serializer/SimpleRedisSerializer.java index 1741e38e5..a9edfc0aa 100644 --- a/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/serializer/SimpleRedisSerializer.java +++ b/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/serializer/SimpleRedisSerializer.java @@ -31,8 +31,8 @@ public class SimpleRedisSerializer implements RedisSerializer { private Converter serializer = new SerializingConverter(); private Converter deserializer = new DeserializingConverter(); - private sun.misc.BASE64Encoder encoder = new sun.misc.BASE64Encoder(); - private sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder(); + // private sun.misc.BASE64Encoder encoder = new sun.misc.BASE64Encoder(); + // private sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder(); @SuppressWarnings("unchecked") @Override diff --git a/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/util/DefaultRedisMap.java b/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/util/DefaultRedisMap.java index e1b3440ea..ff580c50b 100644 --- a/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/util/DefaultRedisMap.java +++ b/spring-data-redis/src/main/java/org/springframework/data/keyvalue/redis/util/DefaultRedisMap.java @@ -31,10 +31,21 @@ public class DefaultRedisMap implements RedisMap { private final BoundHashOperations hashOps; + /** + * Constructs a new DefaultRedisMap instance. + * + * @param key + * @param operations + */ public DefaultRedisMap(String key, RedisOperations operations) { this.hashOps = operations.forHash(key); } + /** + * Constructs a new DefaultRedisMap instance. + * + * @param boundOps + */ public DefaultRedisMap(BoundHashOperations boundOps) { this.hashOps = boundOps; } @@ -126,4 +137,31 @@ public class DefaultRedisMap implements RedisMap { public Collection values() { return hashOps.values(); } + + @Override + public boolean equals(Object o) { + if (o == this) + return true; + + if (o instanceof RedisMap) { + return o.hashCode() == hashCode(); + } + return false; + } + + @Override + public int hashCode() { + int result = 17 + getClass().hashCode(); + result = result * 31 + getKey().hashCode(); + return result; + } + + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("RedisStore for key:"); + sb.append(getKey()); + return sb.toString(); + } } \ No newline at end of file diff --git a/spring-data-redis/src/test/java/org/springframework/data/keyvalue/redis/util/AbstractRedisMapTests.java b/spring-data-redis/src/test/java/org/springframework/data/keyvalue/redis/util/AbstractRedisMapTests.java new file mode 100644 index 000000000..5ad668e4f --- /dev/null +++ b/spring-data-redis/src/test/java/org/springframework/data/keyvalue/redis/util/AbstractRedisMapTests.java @@ -0,0 +1,351 @@ +/* + * Copyright 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.data.keyvalue.redis.util; + +import static org.hamcrest.CoreMatchers.*; +import static org.junit.Assert.*; +import static org.junit.matchers.JUnitMatchers.*; + +import java.util.Collection; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Set; +import java.util.UUID; +import java.util.Map.Entry; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.springframework.beans.factory.DisposableBean; +import org.springframework.dao.InvalidDataAccessApiUsageException; +import org.springframework.data.keyvalue.redis.connection.RedisConnection; +import org.springframework.data.keyvalue.redis.connection.RedisConnectionFactory; +import org.springframework.data.keyvalue.redis.core.RedisCallback; +import org.springframework.data.keyvalue.redis.core.RedisOperations; +import org.springframework.data.keyvalue.redis.core.RedisTemplate; + +/** + * Integration test for Redis Map. + * + * @author Costin Leau + */ +@RunWith(Parameterized.class) +public abstract class AbstractRedisMapTests { + + protected RedisMap map; + protected ObjectFactory keyFactory; + protected ObjectFactory valueFactory; + protected RedisTemplate template; + + private static Set connFactories = new LinkedHashSet(); + + abstract RedisMap createMap(); + + @Before + public void setUp() throws Exception { + map = createMap(); + } + + public AbstractRedisMapTests(ObjectFactory keyFactory, ObjectFactory valueFactory, RedisTemplate template) { + this.keyFactory = keyFactory; + this.valueFactory = valueFactory; + this.template = template; + connFactories.add(template.getConnectionFactory()); + } + + @AfterClass + public static void cleanUp() { + if (connFactories != null) { + for (RedisConnectionFactory connectionFactory : connFactories) { + try { + ((DisposableBean) connectionFactory).destroy(); + System.out.println("Succesfully cleaned up factory " + connectionFactory); + } catch (Exception ex) { + System.err.println("Cannot clean factory " + connectionFactory + ex); + } + } + } + } + + protected K getKey() { + return keyFactory.instance(); + } + + protected V getValue() { + return valueFactory.instance(); + } + + protected RedisStore copyStore(RedisStore store) { + return new DefaultRedisMap(store.getKey(), store.getOperations()); + } + + @After + public void tearDown() throws Exception { + // remove the collection entirely since clear() doesn't always work + map.getOperations().delete(map.getKey()); + template.execute(new RedisCallback() { + + @Override + public Object doInRedis(RedisConnection connection) { + connection.flushDb(); + return null; + } + }); + } + + @Test + public void testClear() { + map.clear(); + assertEquals(0, map.size()); + map.put(getKey(), getValue()); + assertEquals(1, map.size()); + map.clear(); + assertEquals(0, map.size()); + } + + @Test + public void testContainsKey() { + K k1 = getKey(); + K k2 = getKey(); + + assertFalse(map.containsKey(k1)); + assertFalse(map.containsKey(k2)); + map.put(k1, getValue()); + assertTrue(map.containsKey(k1)); + map.put(k2, getValue()); + assertTrue(map.containsKey(k2)); + } + + @Test(expected = UnsupportedOperationException.class) + public void testContainsValue() { + V v1 = getValue(); + V v2 = getValue(); + + assertFalse(map.containsValue(v1)); + assertFalse(map.containsValue(v2)); + map.put(getKey(), v1); + assertTrue(map.containsValue(v1)); + map.put(getKey(), v2); + assertTrue(map.containsValue(v2)); + } + + public Set> entrySet() { + return map.entrySet(); + } + + @Test + public void testEquals() { + RedisStore clone = copyStore(map); + assertEquals(clone, map); + assertEquals(clone, clone); + assertEquals(map, map); + } + + @Test + public void testNotEquals() { + RedisOperations ops = map.getOperations(); + RedisStore newInstance = new DefaultRedisMap(ops. forHash(map.getKey() + ":new")); + assertFalse(map.equals(newInstance)); + assertFalse(newInstance.equals(map)); + } + + @Test + public void testGet() { + K k1 = getKey(); + V v1 = getValue(); + + assertNull(map.get(UUID.randomUUID())); + assertNull(map.get(k1)); + map.put(k1, v1); + assertEquals(v1, map.get(k1)); + } + + @Test + public void testGetKey() { + assertNotNull(map.getKey()); + } + + @Test + public void testGetOperations() { + assertEquals(template, map.getOperations()); + } + + @Test + public void testHashCode() { + assertThat(map.hashCode(), not(equalTo(map.getKey().hashCode()))); + assertEquals(map.hashCode(), copyStore(map).hashCode()); + } + + @Test(expected = InvalidDataAccessApiUsageException.class) + public void testIncrement() { + K k1 = getKey(); + V v1 = getValue(); + + map.put(k1, v1); + Integer value = map.increment(k1, 1); + System.out.println("Value is " + value); + } + + @Test + public void testIsEmpty() { + map.clear(); + assertTrue(map.isEmpty()); + map.put(getKey(), getValue()); + assertFalse(map.isEmpty()); + map.clear(); + assertTrue(map.isEmpty()); + } + + @Test + public void testKeySet() { + map.clear(); + assertTrue(map.keySet().isEmpty()); + K k1 = getKey(); + K k2 = getKey(); + K k3 = getKey(); + + map.put(k1, getValue()); + map.put(k2, getValue()); + map.put(k3, getValue()); + + Iterator iterator = map.keySet().iterator(); + assertEquals(k1, iterator.next()); + assertEquals(k2, iterator.next()); + assertEquals(k3, iterator.next()); + assertFalse(iterator.hasNext()); + } + + @Test + public void testPut() { + K k1 = getKey(); + K k2 = getKey(); + V v1 = getValue(); + V v2 = getValue(); + + map.put(k1, v1); + map.put(k2, v2); + + assertEquals(v1, map.get(k1)); + assertEquals(v2, map.get(k2)); + } + + @Test + public void testPutAll() { + Map m = new LinkedHashMap(); + K k1 = getKey(); + K k2 = getKey(); + + V v1 = getValue(); + V v2 = getValue(); + + m.put(k1, v1); + m.put(k2, v2); + + assertNull(map.get(k1)); + assertNull(map.get(k2)); + + map.putAll(m); + + assertEquals(v1, map.get(k1)); + assertEquals(v2, map.get(k2)); + } + + @Test + public void testPutIfAbsent() { + K k1 = getKey(); + K k2 = getKey(); + + V v1 = getValue(); + V v2 = getValue(); + + assertNull(map.get(k1)); + assertTrue(map.putIfAbsent(k1, v1)); + assertFalse(map.putIfAbsent(k1, v2)); + assertEquals(v1, map.get(k1)); + + assertTrue(map.putIfAbsent(k2, v2)); + assertFalse(map.putIfAbsent(k2, v1)); + + assertEquals(v2, map.get(k2)); + } + + @Test + public void testRemove() { + K k1 = getKey(); + K k2 = getKey(); + + V v1 = getValue(); + V v2 = getValue(); + + assertNull(map.remove(k1)); + assertNull(map.remove(k2)); + + map.put(k1, v1); + map.put(k2, v2); + + assertEquals(v1, map.remove(k1)); + assertNull(map.remove(k1)); + assertNull(map.get(k1)); + + assertEquals(v2, map.remove(k2)); + assertNull(map.remove(k2)); + assertNull(map.get(k2)); + } + + @Test + public void testSize() { + assertEquals(0, map.size()); + map.put(getKey(), getValue()); + assertEquals(1, map.size()); + K k = getKey(); + map.put(k, getValue()); + assertEquals(2, map.size()); + map.remove(k); + assertEquals(1, map.size()); + + map.clear(); + assertEquals(0, map.size()); + } + + @Test + public void testValues() { + V v1 = getValue(); + V v2 = getValue(); + V v3 = getValue(); + + map.put(getKey(), v1); + map.put(getKey(), v2); + + Collection values = map.values(); + assertEquals(2, values.size()); + assertThat(values, hasItems(v1, v2)); + + map.put(getKey(), v3); + values = map.values(); + assertEquals(3, values.size()); + assertThat(values, hasItems(v1, v2, v3)); + } + + @Test(expected = UnsupportedOperationException.class) + public void testEntrySet() { + map.entrySet(); + } +} \ No newline at end of file diff --git a/spring-data-redis/src/test/java/org/springframework/data/keyvalue/redis/util/RedisMapTests.java b/spring-data-redis/src/test/java/org/springframework/data/keyvalue/redis/util/RedisMapTests.java new file mode 100644 index 000000000..ea74a089d --- /dev/null +++ b/spring-data-redis/src/test/java/org/springframework/data/keyvalue/redis/util/RedisMapTests.java @@ -0,0 +1,66 @@ +/* + * Copyright 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.data.keyvalue.redis.util; + +import java.util.Arrays; +import java.util.Collection; + +import org.junit.runners.Parameterized.Parameters; +import org.springframework.data.keyvalue.redis.Person; +import org.springframework.data.keyvalue.redis.connection.jedis.JedisConnectionFactory; +import org.springframework.data.keyvalue.redis.core.RedisTemplate; + +/** + * Integration test for RedisMap. + * + * @author Costin Leau + */ +public class RedisMapTests extends AbstractRedisMapTests { + + public RedisMapTests(ObjectFactory keyFactory, ObjectFactory valueFactory, RedisTemplate template) { + super(keyFactory, valueFactory, template); + } + + @Override + RedisMap createMap() { + String redisName = getClass().getName(); + return new DefaultRedisMap(redisName, template); + } + + @Parameters + public static Collection testParams() { + // create Jedis Factory + ObjectFactory stringFactory = new StringObjectFactory(); + ObjectFactory personFactory = new PersonObjectFactory(); + + JedisConnectionFactory jedisConnFactory = new JedisConnectionFactory(); + jedisConnFactory.setPooling(false); + jedisConnFactory.afterPropertiesSet(); + + RedisTemplate stringTemplate = new RedisTemplate(jedisConnFactory); + RedisTemplate personTemplate = new RedisTemplate(jedisConnFactory); + + // JredisConnectionFactory jredisConnFactory = new JredisConnectionFactory(); + // jredisConnFactory.setPooling(false); + // jredisConnFactory.afterPropertiesSet(); + // + // RedisTemplate stringTemplateJR = new RedisTemplate(jredisConnFactory); + // RedisTemplate personTemplateJR = new RedisTemplate(jredisConnFactory); + + return Arrays.asList(new Object[][] { { stringFactory, stringFactory, stringTemplate }, + { personFactory, personFactory, personTemplate } }); + } +} \ No newline at end of file