src/org/redkale/net/http/WebSocket.java

@@ -754,12 +754,12 @@ public abstract class WebSocket<G extends Serializable, T> {
     }
 
     /**
-     * 当Single模式下用户重复登陆时回调函数，调用完之后关闭之前的WebSocket连接
+     * 当Single模式下用户重复登陆时回调函数，默认处理方式: 关闭旧连接
      *
-     * @return Future 可以为null
+     * @return Future 可以为null, 为null或者Future值为false表示关闭新连接， Future值为true表示关闭旧连接
      */
-    public CompletableFuture<Integer> onSingleRepeatConnect() {
-        return null;
+    public CompletableFuture<Boolean> onSingleRepeatConnect() {
+        return forceCloseWebSocket(getUserid()).thenApply((r) -> true);
     }
 
     /**

src/org/redkale/net/http/WebSocketServlet.java

@@ -13,7 +13,7 @@ import java.nio.channels.CompletionHandler;
 import java.security.*;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
-import java.util.function.BiConsumer;
+import java.util.function.*;
 import java.util.logging.*;
 import javax.annotation.*;
 import org.redkale.convert.Convert;
@@ -242,20 +242,28 @@ public abstract class WebSocketServlet extends HttpServlet implements Resourcabl
                                 if (single && !anyuser) {
                                     WebSocketServlet.this.node.existsWebSocket(userid).whenComplete((rs, nex) -> {
                                         if (rs) {
-                                            CompletableFuture rcFuture = webSocket.onSingleRepeatConnect();
-                                            Runnable task = () -> {
-                                                node.forceCloseWebSocket(userid).whenComplete((fr, fex) -> {
+                                            CompletableFuture<Boolean> rcFuture = webSocket.onSingleRepeatConnect();
+                                            Consumer<Boolean> task = (oldkilled) -> {
+                                                if (oldkilled) {
                                                     WebSocketServlet.this.node.localEngine.add(webSocket);
                                                     WebSocketRunner runner = new WebSocketRunner(context, webSocket, restMessageConsumer, response.removeChannel());
                                                     webSocket._runner = runner;
                                                     context.runAsync(runner);
                                                     response.finish(true);
-                                                });
+                                                } else { //关闭新连接
+                                                    response.finish(true);
+                                                }
                                             };
                                             if (rcFuture == null) {
-                                                task.run();
+                                                task.accept(false);
                                             } else {
-                                                rcFuture.whenComplete((r, e) -> task.run());
+                                                rcFuture.whenComplete((r, e) -> {
+                                                    if (e != null) {
+                                                        response.finish(true);
+                                                    } else {
+                                                        task.accept(r);
+                                                    }
+                                                });
                                             }
                                         } else {
                                             WebSocketServlet.this.node.localEngine.add(webSocket);