refactoring

redisson/src/main/java/org/redisson/api/RemoteInvocationOptions.java

@@ -56,7 +56,7 @@ import java.util.concurrent.TimeUnit;
  *
  * @see RRemoteService#get(Class, RemoteInvocationOptions)
  */
-public class RemoteInvocationOptions implements Serializable {
+public final class RemoteInvocationOptions implements Serializable {
 
     private static final long serialVersionUID = -7715968073286484802L;
     

redisson/src/main/java/org/redisson/remote/BaseRemoteProxy.java

@@ -115,7 +115,7 @@ public abstract class BaseRemoteProxy {
         return promise;
     }
 
-    protected <T extends RRemoteServiceResponse> RPromise<T> pollResponse(long timeout,
+    protected final <T extends RRemoteServiceResponse> RPromise<T> pollResponse(long timeout,
             RequestId requestId, boolean insertFirst) {
         RPromise<T> responseFuture = new RedissonPromise<T>();
 
@@ -130,34 +130,27 @@ public abstract class BaseRemoteProxy {
                 }
             }
 
-            responseFuture.onComplete((res, ex) -> {
+            addCancelHandling(requestId, responseFuture);
-                if (responseFuture.isCancelled()) {
-                    synchronized (responses) {
-                        ResponseEntry e = responses.get(responseQueueName);
-                        List<Result> list = e.getResponses().get(requestId);
-                        if (list == null) {
-                            return;
-                        }
 
-                        for (Iterator<Result> iterator = list.iterator(); iterator.hasNext();) {
+            ScheduledFuture<?> responseTimeoutFuture = createResponseTimeout(timeout, requestId, responseFuture);
-                            Result result = iterator.next();
-                            if (result.getPromise() == responseFuture) {
-                                result.getResponseTimeoutFuture().cancel(true);
-                                iterator.remove();
-                            }
-                        }
-                        if (list.isEmpty()) {
-                            e.getResponses().remove(requestId);
-                        }
 
-                        if (e.getResponses().isEmpty()) {
+            Map<RequestId, List<Result>> entryResponses = entry.getResponses();
-                            responses.remove(responseQueueName, e);
+            List<Result> list = entryResponses.computeIfAbsent(requestId, k -> new ArrayList<>(3));
+
+            Result res = new Result(responseFuture, responseTimeoutFuture);
+            if (insertFirst) {
+                list.add(0, res);
+            } else {
+                list.add(res);
             }
         }
+
+        pollResponse(entry);
+        return responseFuture;
     }
-            });
 
-            ScheduledFuture<?> responseTimeoutFuture = commandExecutor.getConnectionManager().getGroup().schedule(new Runnable() {
+    private <T extends RRemoteServiceResponse> ScheduledFuture<?> createResponseTimeout(long timeout, RequestId requestId, RPromise<T> responseFuture) {
+        return commandExecutor.getConnectionManager().getGroup().schedule(new Runnable() {
                     @Override
                     public void run() {
                         synchronized (responses) {
@@ -180,25 +173,37 @@ public abstract class BaseRemoteProxy {
                         }
                     }
                 }, timeout, TimeUnit.MILLISECONDS);
+    }
 
-            Map<RequestId, List<Result>> entryResponses = entry.getResponses();
+    private <T extends RRemoteServiceResponse> void addCancelHandling(RequestId requestId, RPromise<T> responseFuture) {
-            List<Result> list = entryResponses.get(requestId);
+        responseFuture.onComplete((res, ex) -> {
+            if (!responseFuture.isCancelled()) {
+                return;
+            }
+
+            synchronized (responses) {
+                ResponseEntry e = responses.get(responseQueueName);
+                List<Result> list = e.getResponses().get(requestId);
                 if (list == null) {
-                list = new ArrayList<>(3);
+                    return;
-                entryResponses.put(requestId, list);
                 }
 
-            Result res = new Result(responseFuture, responseTimeoutFuture);
+                for (Iterator<Result> iterator = list.iterator(); iterator.hasNext();) {
-            if (insertFirst) {
+                    Result result = iterator.next();
-                list.add(0, res);
+                    if (result.getPromise() == responseFuture) {
-            } else {
+                        result.getResponseTimeoutFuture().cancel(true);
-                list.add(res);
+                        iterator.remove();
                     }
                 }
+                if (list.isEmpty()) {
+                    e.getResponses().remove(requestId);
+                }
 
-        
+                if (e.getResponses().isEmpty()) {
-        pollResponse(entry);
+                    responses.remove(responseQueueName, e);
-        return responseFuture;
+                }
+            }
+        });
     }
 
     private <V> RBlockingQueue<V> getBlockingQueue(String name, Codec codec) {