DATAREDIS-481 - Some code cleanups, JavaDoc, Builders and tests.

Author: christophstrobl

src/main/java/org/springframework/data/redis/cache/DefaultRedisCacheWriter.java

@@ -28,6 +28,10 @@
 import org.springframework.util.Assert;
 
 /**
+ * {@link RedisCacheWriter} implementation capable of reading/writing binary data from/to Redis in {@literal standalone}
+ * and {@literal cluster} environments. Works upon a given {@link RedisConnectionFactory} to obtain the actual
+ * {@link RedisConnection}.
+ *
  * @author Christoph Strobl
  * @since 2.0
  */
@@ -61,10 +65,14 @@ class DefaultRedisCacheWriter implements RedisCacheWriter {
 	}
 
 	public static DefaultRedisCacheWriter nonLockingRedisCacheWriter(RedisConnectionFactory connectionFactory) {
+
+		Assert.notNull(connectionFactory, "ConnectionFactory must not be null!");
 		return new DefaultRedisCacheWriter(connectionFactory);
 	}
 
 	public static DefaultRedisCacheWriter lockingRedisCacheWriter(RedisConnectionFactory connectionFactory) {
+
+		Assert.notNull(connectionFactory, "ConnectionFactory must not be null!");
 		return new DefaultRedisCacheWriter(connectionFactory, Duration.ofMillis(50));
 	}
 
@@ -128,6 +136,11 @@ public void remove(String name, byte[] key) {
 		execute(name, connection -> connection.del(key));
 	}
 
+	/**
+	 * Explicitly set a write lock on a cache.
+	 *
+	 * @param name the name of the cache to lock.
+	 */
 	public void lock(String name) {
 		execute(name, connection -> doLock(name, connection));
 	}
@@ -136,6 +149,11 @@ private Boolean doLock(String name, RedisConnection connection) {
 		return connection.setNX(createCacheLockKey(name), new byte[] {});
 	}
 
+	/**
+	 * Explicitly remove a write lock from a cache.
+	 *
+	 * @param name the name of the cache to unlock.
+	 */
 	public void unlock(String name) {
 		executeWithoutLockCheck(connection -> doUnlock(name, connection));
 	}
@@ -144,6 +162,12 @@ private Long doUnlock(String name, RedisConnection connection) {
 		return connection.del(createCacheLockKey(name));
 	}
 
+	/**
+	 * Check if a cache has set a lock.
+	 *
+	 * @param name the name of the cache to check for presence of a lock.
+	 * @return {@literal true} if lock found.
+	 */
 	public boolean isLoked(String name) {
 		return executeWithoutLockCheck(connection -> doCheckLock(name, connection));
 	}
@@ -183,7 +207,14 @@ public void clean(String name, byte[] pattern) {
 		});
 	}
 
-	public <T> T execute(String name, ConnectionCallback<T> callback) {
+	/**
+	 * @return {@literal true} if {@link RedisCacheWriter} uses locks.
+	 */
+	public boolean isLockingCacheWriter() {
+		return !sleepTime.isZero() && !sleepTime.isNegative();
+	}
+
+	<T> T execute(String name, ConnectionCallback<T> callback) {
 
 		RedisConnection connection = connectionFactory.getConnection();
 		try {
@@ -206,10 +237,6 @@ private <T> T executeWithoutLockCheck(ConnectionCallback<T> callback) {
 		}
 	}
 
-	public boolean isLockingCacheWriter() {
-		return !sleepTime.isZero() && !sleepTime.isNegative();
-	}
-
 	private void checkAndPotentiallyWaitUntilUnlocked(String name, RedisConnection connection) {
 
 		if (isLockingCacheWriter()) {
@@ -234,6 +261,11 @@ byte[] createCacheLockKey(String name) {
 		return (name + "~lock").getBytes(Charset.forName("UTF-8"));
 	}
 
+	/**
+	 * @author Christoph Strobl
+	 * @param <T>
+	 * @since 2.0
+	 */
 	interface ConnectionCallback<T> {
 		T doWithConnection(RedisConnection connection);
 	}

src/main/java/org/springframework/data/redis/cache/NRedisCache.java

@@ -26,12 +26,13 @@
 import org.springframework.core.convert.support.ConfigurableConversionService;
 import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
 import org.springframework.format.support.DefaultFormattingConversionService;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.ReflectionUtils;
 
 /**
- * {@link org.springframework.cache.Cache} implementation suitable for Redis.
+ * {@link org.springframework.cache.Cache} implementation using for Redis as underlying store.
  *
  * @author Christoph Strobl
  * @since 2.0
@@ -74,7 +75,7 @@ public NRedisCache(String name, RedisCacheWriter cacheWriter, RedisCacheConfigur
 		this.cacheWriter = cacheWriter;
 		this.cacheConfig = cacheConfig;
 
-		conversionService.addConverter(String.class, byte[].class, source -> source.getBytes(Charset.forName("UTF8")));
+		conversionService.addConverter(String.class, byte[].class, source -> source.getBytes(Charset.forName("UTF-8")));
 	}
 
 	@Override
@@ -125,7 +126,7 @@ public void put(Object key, Object value) {
 					name));
 		}
 
-		cacheWriter.put(name, createAndConvertCacheKey(key), serializeCacheValue(cacheValue), cacheConfig.getTimeout());
+		cacheWriter.put(name, createAndConvertCacheKey(key), serializeCacheValue(cacheValue), cacheConfig.getTtl());
 	}
 
 	@Override
@@ -138,7 +139,7 @@ public ValueWrapper putIfAbsent(Object key, Object value) {
 		}
 
 		byte[] result = cacheWriter.putIfAbsent(name, createAndConvertCacheKey(key), serializeCacheValue(cacheValue),
-				cacheConfig.getTimeout());
+				cacheConfig.getTtl());
 
 		if (result == null) {
 			return null;
@@ -159,7 +160,24 @@ public void clear() {
 		cacheWriter.clean(name, pattern);
 	}
 
-	protected Object preProcessCacheValue(Object value) {
+	/**
+	 * Get {@link RedisCacheConfiguration} used.
+	 *
+	 * @return immutable {@link RedisCacheConfiguration}. Never {@literal null}.
+	 */
+	public RedisCacheConfiguration getCacheConfiguration() {
+		return cacheConfig;
+	}
+
+	/**
+	 * Customization hook called before passing object to
+	 * {@link org.springframework.data.redis.serializer.RedisSerializer}.
+	 *
+	 * @param value can be {@literal null}.
+	 * @return preprocessed value. Can be {@literal null}.
+	 */
+	@Nullable
+	protected Object preProcessCacheValue(@Nullable Object value) {
 
 		if (value != null) {
 			return value;
@@ -168,10 +186,22 @@ protected Object preProcessCacheValue(Object value) {
 		return isAllowNullValues() ? NULL_VALUE : null;
 	}
 
+	/**
+	 * Serialize the key.
+	 *
+	 * @param cacheKey must not be {@literal null}.
+	 * @return never {@literal null}.
+	 */
 	protected byte[] serializeCacheKey(String cacheKey) {
 		return cacheConfig.getKeySerializationPair().write(cacheKey).array();
 	}
 
+	/**
+	 * Serialize the value to cache.
+	 * 
+	 * @param value must not be {@literal null}.
+	 * @return never {@literal null}.
+	 */
 	protected byte[] serializeCacheValue(Object value) {
 
 		if (isAllowNullValues() && value instanceof NullValue) {
@@ -181,6 +211,13 @@ protected byte[] serializeCacheValue(Object value) {
 		return cacheConfig.getValueSerializationPair().write(value).array();
 	}
 
+	/**
+	 * Deserialize the given value to the actual cache value.
+	 *
+	 * @param value must not be {@literal null}.
+	 * @return can be {@literal null}.
+	 */
+	@Nullable
 	protected Object deserializeCacheValue(byte[] value) {
 
 		if (isAllowNullValues() && ObjectUtils.nullSafeEquals(value, BINARY_NULL_VALUE)) {
@@ -205,7 +242,7 @@ private String createCacheKey(Object key) {
 	}
 
 	private String prefixCacheKey(String key) {
-		return cacheConfig.getDefaultPrefix().orElseGet(() -> name + "::") + key;
+		return cacheConfig.getKeyPrefix().orElseGet(() -> name + "::") + key;
 	}
 
 	private <T> T valueFromLoader(Object key, Callable<T> valueLoader) {