spring-projectsGH-3805: fix javadoc, convention, lazy init

Author: Meteorkor

spring-integration-redis/src/main/java/org/springframework/integration/redis/util/RedisLockRegistry.java

@@ -22,7 +22,6 @@
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Map.Entry;
-import java.util.Objects;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
@@ -37,8 +36,6 @@
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Function;
 
-import javax.annotation.Nonnull;
-
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
@@ -54,6 +51,7 @@
 import org.springframework.data.redis.listener.RedisMessageListenerContainer;
 import org.springframework.data.redis.listener.Topic;
 import org.springframework.integration.support.locks.ExpirableLockRegistry;
+import org.springframework.lang.NonNull;
 import org.springframework.scheduling.concurrent.CustomizableThreadFactory;
 import org.springframework.util.Assert;
 import org.springframework.util.ReflectionUtils;
@@ -117,10 +115,6 @@ protected boolean removeEldestEntry(Entry<String, RedisLock> eldest) {
 
 	private final StringRedisTemplate redisTemplate;
 
-	private final RedisUnLockNotifyMessageListener unlockNotifyMessageListener;
-
-	private final RedisMessageListenerContainer redisMessageListenerContainer;
-
 	private final long expireAfter;
 
 	private int cacheCapacity = DEFAULT_CAPACITY;
@@ -141,8 +135,18 @@ protected boolean removeEldestEntry(Entry<String, RedisLock> eldest) {
 	private boolean executorExplicitlySet;
 
 	private volatile boolean unlinkAvailable = true;
+
 	private volatile boolean isRunningRedisMessageListenerContainer = false;
 
+	/**
+	 * It is set via lazy initialization when it is a {@link RedisLockType#PUB_SUB_LOCK}.
+	 */
+	private volatile RedisUnLockNotifyMessageListener unlockNotifyMessageListener;
+	/**
+	 * It is set via lazy initialization when it is a {@link RedisLockType#PUB_SUB_LOCK}.
+	 */
+	private volatile RedisMessageListenerContainer redisMessageListenerContainer;
+
 	/**
 	 * Constructs a lock registry with the default (60 second) lock expiration.
 	 * @param connectionFactory The connection factory.
@@ -165,12 +169,13 @@ public RedisLockRegistry(RedisConnectionFactory connectionFactory, String regist
 		this.registryKey = registryKey;
 		this.expireAfter = expireAfter;
 		this.unLockChannelKey = registryKey + "-channel";
-		this.unlockNotifyMessageListener = new RedisUnLockNotifyMessageListener();
-		this.redisMessageListenerContainer = new RedisMessageListenerContainer();
-		setupUnlockMessageListener(connectionFactory);
 	}
 
 	private void setupUnlockMessageListener(RedisConnectionFactory connectionFactory) {
+		Assert.isNull(RedisLockRegistry.this.redisMessageListenerContainer, "'redisMessageListenerContainer' must not have been re-initialized.");
+		Assert.isNull(RedisLockRegistry.this.unlockNotifyMessageListener, "'unlockNotifyMessageListener' must not have been re-initialized.");
+		RedisLockRegistry.this.redisMessageListenerContainer = new RedisMessageListenerContainer();
+		RedisLockRegistry.this.unlockNotifyMessageListener = new RedisUnLockNotifyMessageListener();
 		final Topic topic = new ChannelTopic(this.unLockChannelKey);
 		this.redisMessageListenerContainer.setConnectionFactory(connectionFactory);
 		this.redisMessageListenerContainer.setTaskExecutor(this.executor);
@@ -200,19 +205,23 @@ public void setCacheCapacity(int cacheCapacity) {
 		this.cacheCapacity = cacheCapacity;
 	}
 
+
 	/**
-	 * The default is {@link RedisLockType.SPIN_LOCK}<br>
-	 * {@link RedisLockType.SPIN_LOCK}: The lock is acquired by periodically(100ms) checking whether the lock can be acquired.<br>
-	 * {@link RedisLockType.PUB_SUB_LOCK}: The lock is accuired by redis pub-sub. <br>
-	 *
-	 * Set the type of unlockType
-	 * Select the lock method.
+	 * <p>
+	 * 	Because pub-sub does not work in some settings(RedisStaticMasterReplicaConfiguration), The default is {@link RedisLockType.SPIN_LOCK}
+	 * <ul>
+	 *    <li>{@link RedisLockType#SPIN_LOCK}: The lock is acquired by periodically(100ms) checking whether the lock can be acquired.</li>
+	 *    <li>{@link RedisLockType#PUB_SUB_LOCK}: The lock is accuired by redis pub-sub.</li>
+	 * 	</ul>
+	 * <p>
+	 * Set the type of unlockType, Select the lock method.
 	 *
 	 * @param redisLockType obtain RedisLockType
-	 * @since 6.0.0
+	 * @since 5.5.13
 	 */
-	public void setRedisLockType(@Nonnull RedisLockType redisLockType) {
-		this.redisLockType = Objects.requireNonNull(redisLockType);
+	public void setRedisLockType(@NonNull RedisLockType redisLockType) {
+		Assert.notNull(redisLockType, "'redisLockType' cannot be null");
+		this.redisLockType = redisLockType;
 	}
 
 	@Override
@@ -253,7 +262,7 @@ public enum RedisLockType {
 		PUB_SUB_LOCK, SPIN_LOCK;
 	}
 
-	private Function<String, RedisLock> getRedisLockConstructor(@Nonnull RedisLockType redisLockType) {
+	private Function<String, RedisLock> getRedisLockConstructor(@NonNull RedisLockType redisLockType) {
 		return switch (redisLockType) {
 			case PUB_SUB_LOCK -> RedisPubSubLock::new;
 			case SPIN_LOCK -> RedisSpinLock::new;
@@ -262,6 +271,20 @@ private Function<String, RedisLock> getRedisLockConstructor(@Nonnull RedisLockTy
 
 
 	private abstract class RedisLock implements Lock {
+
+		private static final String OBTAIN_LOCK_SCRIPT =
+				"local lockClientId = redis.call('GET', KEYS[1])\n" +
+				"if lockClientId == ARGV[1] then\n" +
+				"  redis.call('PEXPIRE', KEYS[1], ARGV[2])\n" +
+				"  return true\n" +
+				"elseif not lockClientId then\n" +
+				"  redis.call('SET', KEYS[1], ARGV[1], 'PX', ARGV[2])\n" +
+				"  return true\n" +
+				"end\n" +
+				"return false";
+
+		protected static final RedisScript<Boolean> obtainLockScript = new DefaultRedisScript<>(OBTAIN_LOCK_SCRIPT, Boolean.class);
+
 		protected final String lockKey;
 
 		private final ReentrantLock localLock = new ReentrantLock();
@@ -385,6 +408,13 @@ private boolean tryRedisLock(long time) throws ExecutionException, InterruptedEx
 			return result;
 		}
 
+		protected Boolean obtainLock() {
+			return RedisLockRegistry.this.redisTemplate
+					.execute(obtainLockScript, Collections.singletonList(this.lockKey),
+							RedisLockRegistry.this.clientId,
+							String.valueOf(RedisLockRegistry.this.expireAfter));
+		}
+
 		@Override
 		public final void unlock() {
 			if (!this.localLock.isHeldByCurrentThread()) {
@@ -495,19 +525,10 @@ public boolean equals(Object obj) {
 		private RedisLockRegistry getOuterType() {
 			return RedisLockRegistry.this;
 		}
+
 	}
 
 	private final class RedisPubSubLock extends RedisLock {
-		private static final String OBTAIN_LOCK_SCRIPT =
-				"local lockClientId = redis.call('GET', KEYS[1])\n" +
-				"if lockClientId == ARGV[1] then\n" +
-				"  redis.call('PEXPIRE', KEYS[1], ARGV[2])\n" +
-				"  return true\n" +
-				"elseif not lockClientId then\n" +
-				"  redis.call('SET', KEYS[1], ARGV[1], 'PX', ARGV[2])\n" +
-				"  return true\n" +
-				"end\n" +
-				"return false";
 
 		private static final String UNLINK_UNLOCK_SCRIPT =
 				"if (redis.call('unlink', KEYS[1]) == 1) then " +
@@ -522,9 +543,10 @@ private final class RedisPubSubLock extends RedisLock {
 				"return true " +
 				"end " +
 				"return false";
-		private final RedisScript<Boolean> obtainLockScript = new DefaultRedisScript<>(OBTAIN_LOCK_SCRIPT, Boolean.class);
-		private final RedisScript<Boolean> unLinkUnLockScript = new DefaultRedisScript<>(UNLINK_UNLOCK_SCRIPT, Boolean.class);
-		private final RedisScript<Boolean> deleteUnLockScript = new DefaultRedisScript<>(DELETE_UNLOCK_SCRIPT, Boolean.class);
+
+		private static final RedisScript<Boolean> unLinkUnLockScript = new DefaultRedisScript<>(UNLINK_UNLOCK_SCRIPT, Boolean.class);
+
+		private static final RedisScript<Boolean> deleteUnLockScript = new DefaultRedisScript<>(DELETE_UNLOCK_SCRIPT, Boolean.class);
 
 		private RedisPubSubLock(String path) {
 			super(path);
@@ -538,14 +560,14 @@ protected boolean tryRedisLockInner(long time) throws ExecutionException, Interr
 		@Override
 		protected void removeLockKeyInnerUnlink() {
 			RedisLockRegistry.this.redisTemplate.execute(
-					this.unLinkUnLockScript, Collections.singletonList(this.lockKey),
+					unLinkUnLockScript, Collections.singletonList(this.lockKey),
 					RedisLockRegistry.this.unLockChannelKey);
 		}
 
 		@Override
 		protected void removeLockKeyInnerDelete() {
 			RedisLockRegistry.this.redisTemplate.execute(
-					this.deleteUnLockScript, Collections.singletonList(this.lockKey),
+					deleteUnLockScript, Collections.singletonList(this.lockKey),
 					RedisLockRegistry.this.unLockChannelKey);
 
 		}
@@ -557,6 +579,7 @@ private boolean subscribeLock(long time) throws ExecutionException, InterruptedE
 			}
 
 			if (!(RedisLockRegistry.this.isRunningRedisMessageListenerContainer
+				&& RedisLockRegistry.this.redisMessageListenerContainer != null
 				&& RedisLockRegistry.this.redisMessageListenerContainer.isRunning())) {
 				runRedisMessageListenerContainer();
 			}
@@ -586,23 +609,23 @@ private boolean subscribeLock(long time) throws ExecutionException, InterruptedE
 			return false;
 		}
 
-		private Boolean obtainLock() {
-			return RedisLockRegistry.this.redisTemplate
-					.execute(this.obtainLockScript, Collections.singletonList(this.lockKey),
-							RedisLockRegistry.this.clientId,
-							String.valueOf(RedisLockRegistry.this.expireAfter));
-		}
-
 		private void runRedisMessageListenerContainer() {
-			synchronized (RedisLockRegistry.this.redisMessageListenerContainer) {
+			synchronized (RedisLockRegistry.this.locks) {
 				if (!(RedisLockRegistry.this.isRunningRedisMessageListenerContainer
+					&& RedisLockRegistry.this.redisMessageListenerContainer != null
 					&& RedisLockRegistry.this.redisMessageListenerContainer.isRunning())) {
-					RedisLockRegistry.this.redisMessageListenerContainer.afterPropertiesSet();
+
+					if (RedisLockRegistry.this.redisMessageListenerContainer == null) {
+						setupUnlockMessageListener(RedisLockRegistry.this.redisTemplate.getConnectionFactory());
+						RedisLockRegistry.this.redisMessageListenerContainer.afterPropertiesSet();
+					}
+
 					RedisLockRegistry.this.redisMessageListenerContainer.start();
 					RedisLockRegistry.this.isRunningRedisMessageListenerContainer = true;
 				}
 			}
 		}
+
 	}
 
 	/**
@@ -636,17 +659,6 @@ private void unlockNotify(String lockKey) {
 	}
 
 	private final class RedisSpinLock extends RedisLock {
-		private static final String OBTAIN_LOCK_SCRIPT =
-				"local lockClientId = redis.call('GET', KEYS[1])\n" +
-				"if lockClientId == ARGV[1] then\n" +
-				"  redis.call('PEXPIRE', KEYS[1], ARGV[2])\n" +
-				"  return true\n" +
-				"elseif not lockClientId then\n" +
-				"  redis.call('SET', KEYS[1], ARGV[1], 'PX', ARGV[2])\n" +
-				"  return true\n" +
-				"end\n" +
-				"return false";
-		private final RedisScript<Boolean> obtainLockScript = new DefaultRedisScript<>(OBTAIN_LOCK_SCRIPT, Boolean.class);
 
 		private RedisSpinLock(String path) {
 			super(path);
@@ -681,12 +693,5 @@ protected void removeLockKeyInnerDelete() {
 			RedisLockRegistry.this.redisTemplate.delete(this.lockKey);
 		}
 
-		private boolean obtainLock() {
-			return RedisLockRegistry.this.redisTemplate
-					.execute(this.obtainLockScript,
-							Collections.singletonList(this.lockKey),
-							RedisLockRegistry.this.clientId,
-							String.valueOf(RedisLockRegistry.this.expireAfter));
-		}
 	}
 }

spring-integration-redis/src/test/java/org/springframework/integration/redis/util/RedisLockRegistryTests.java

@@ -832,4 +832,5 @@ private void waitForExpire(String key) throws Exception {
 	private static Map<String, Lock> getRedisLockRegistryLocks(RedisLockRegistry registry) {
 		return TestUtils.getPropertyValue(registry, "locks", Map.class);
 	}
+
 }