refactor: improve connection handling and add ConnectionException

Author: getCurrentThread

lib/src/main/java/com/github/getcurrentthread/soopapi/client/SOOPChatClient.java

@@ -9,6 +9,8 @@
 
 import com.github.getcurrentthread.soopapi.config.SOOPChatConfig;
 import com.github.getcurrentthread.soopapi.connection.ConnectionManager;
+import com.github.getcurrentthread.soopapi.connection.SOOPConnection;
+import com.github.getcurrentthread.soopapi.exception.ConnectionException;
 import com.github.getcurrentthread.soopapi.model.Message;
 import com.github.getcurrentthread.soopapi.util.SOOPChatUtils;
 
@@ -19,6 +21,7 @@ public class SOOPChatClient implements AutoCloseable {
     private final ConnectionManager connectionManager;
     private final List<IChatMessageObserver> observers;
     private volatile boolean isConnected;
+    private volatile SOOPConnection connection;
 
     public SOOPChatClient(SOOPChatConfig config) {
         this.config = validateConfig(config);
@@ -56,6 +59,11 @@ private void notifyObservers(Message message) {
         }
     }
 
+    /**
+     * 채팅에 비동기적으로 연결합니다.
+     *
+     * @return 연결 작업을 나타내는 CompletableFuture
+     */
     public CompletableFuture<Void> connectToChat() {
         if (isConnected) {
             return CompletableFuture.completedFuture(null);
@@ -64,30 +72,89 @@ public CompletableFuture<Void> connectToChat() {
         return CompletableFuture.runAsync(
                 () -> {
                     try {
-                        connectionManager
-                                .connect(config, this::notifyObservers)
-                                .thenRun(() -> isConnected = true)
-                                .exceptionally(
-                                        throwable -> {
-                                            LOGGER.log(
-                                                    Level.SEVERE, "Failed to connect", throwable);
-                                            return null;
-                                        })
-                                .join();
+                        connection =
+                                connectionManager.connect(config, this::notifyObservers).join();
+                        isConnected = true;
                     } catch (Exception e) {
-                        throw new CompletionException("Failed to connect to chat", e);
+                        LOGGER.log(Level.SEVERE, "채팅 연결 실패", e);
+                        if (e.getCause() instanceof ConnectionException) {
+                            throw new CompletionException(e.getCause());
+                        } else {
+                            throw new CompletionException("채팅 연결 실패", e);
+                        }
                     }
                 });
     }
 
+    /**
+     * 채팅 연결을 시도하고 완료될 때까지 현재 스레드를 차단합니다.
+     *
+     * @throws ConnectionException 연결 오류가 발생한 경우
+     */
+    public void connectToChattingBlocking() throws ConnectionException {
+        try {
+            connectToChat().join();
+        } catch (CompletionException e) {
+            if (e.getCause() instanceof ConnectionException) {
+                throw (ConnectionException) e.getCause();
+            } else {
+                throw new ConnectionException("채팅 연결 실패", e);
+            }
+        }
+    }
+
+    /**
+     * 연결이 끊어진 경우 재연결을 시도합니다.
+     *
+     * @return 재연결 작업을 나타내는 CompletableFuture
+     */
+    public CompletableFuture<Void> reconnect() {
+        if (connection == null) {
+            return CompletableFuture.failedFuture(
+                    new IllegalStateException("연결이 초기화되지 않았습니다. 먼저 connectToChat을 호출하세요."));
+        }
+
+        return connection
+                .reconnect()
+                .thenRun(() -> isConnected = true)
+                .exceptionally(
+                        e -> {
+                            isConnected = false;
+                            LOGGER.log(Level.SEVERE, "재연결 실패", e);
+                            throw new CompletionException(e);
+                        });
+    }
+
+    /**
+     * 현재 연결 상태를 확인합니다.
+     *
+     * @return 연결 상태 정보를 포함하는 CompletableFuture
+     */
+    public CompletableFuture<ConnectionStatus> getConnectionStatus() {
+        if (connection == null) {
+            return CompletableFuture.completedFuture(new ConnectionStatus(false, false, 0));
+        }
+
+        return connection
+                .getStatus()
+                .thenApply(
+                        status ->
+                                new ConnectionStatus(
+                                        status.isConnected(),
+                                        status.isReconnecting(),
+                                        status.getRetryCount()));
+    }
+
+    /** 현재 연결을 해제합니다. */
     public void disconnect() {
         if (!isConnected) {
             return;
         }
 
         try {
-            connectionManager.disconnect(config.getBid());
+            connectionManager.disconnect(config.getBid()).join();
             isConnected = false;
+            connection = null;
         } catch (Exception e) {
             LOGGER.log(Level.WARNING, "Error during disconnect", e);
         }
@@ -98,11 +165,46 @@ public void close() {
         disconnect();
     }
 
+    /**
+     * 현재 연결 상태를 반환합니다.
+     *
+     * @return 연결 상태
+     */
     public boolean isConnected() {
-        return isConnected;
+        return isConnected && (connection != null && connection.isConnected());
     }
 
+    /**
+     * 방송인 ID를 반환합니다.
+     *
+     * @return 방송인 ID
+     */
     public String getBid() {
         return config.getBid();
     }
+
+    /** 연결 상태 정보를 제공하는 클래스 */
+    public static class ConnectionStatus {
+        private final boolean connected;
+        private final boolean reconnecting;
+        private final int retryCount;
+
+        public ConnectionStatus(boolean connected, boolean reconnecting, int retryCount) {
+            this.connected = connected;
+            this.reconnecting = reconnecting;
+            this.retryCount = retryCount;
+        }
+
+        public boolean isConnected() {
+            return connected;
+        }
+
+        public boolean isReconnecting() {
+            return reconnecting;
+        }
+
+        public int getRetryCount() {
+            return retryCount;
+        }
+    }
 }

lib/src/main/java/com/github/getcurrentthread/soopapi/config/SOOPChatConfig.java

@@ -1,50 +1,140 @@
 package com.github.getcurrentthread.soopapi.config;
 
+import java.time.Duration;
+
 import javax.net.ssl.SSLContext;
 
 public class SOOPChatConfig {
     private final String bid;
     private final String bno;
     private final SSLContext sslContext;
+    private final Duration connectionTimeout;
+    private final int maxRetryAttempts;
+
+    private static final Duration DEFAULT_CONNECTION_TIMEOUT = Duration.ofSeconds(30);
+    private static final int DEFAULT_MAX_RETRY_ATTEMPTS = 5;
 
     private SOOPChatConfig(Builder builder) {
         this.bid = builder.bid;
         this.bno = builder.bno;
         this.sslContext = builder.sslContext;
+        this.connectionTimeout = builder.connectionTimeout;
+        this.maxRetryAttempts = builder.maxRetryAttempts;
     }
 
+    /**
+     * 방송인 ID를 반환합니다.
+     *
+     * @return 방송인 ID
+     */
     public String getBid() {
         return bid;
     }
 
+    /**
+     * 방송 번호를 반환합니다.
+     *
+     * @return 방송 번호 (null일 수 있음)
+     */
     public String getBno() {
         return bno;
     }
 
+    /**
+     * SSL Context를 반환합니다.
+     *
+     * @return SSL Context (null일 수 있음)
+     */
     public SSLContext getSSLContext() {
         return sslContext;
     }
 
+    /**
+     * 연결 타임아웃을 반환합니다.
+     *
+     * @return 연결 타임아웃
+     */
+    public Duration getConnectionTimeout() {
+        return connectionTimeout;
+    }
+
+    /**
+     * 최대 재시도 횟수를 반환합니다.
+     *
+     * @return 최대 재시도 횟수
+     */
+    public int getMaxRetryAttempts() {
+        return maxRetryAttempts;
+    }
+
+    /** SOOPChatConfig 빌더 클래스 */
     public static class Builder {
         private String bid;
         private String bno;
         private SSLContext sslContext;
+        private Duration connectionTimeout = DEFAULT_CONNECTION_TIMEOUT;
+        private int maxRetryAttempts = DEFAULT_MAX_RETRY_ATTEMPTS;
 
+        /**
+         * 방송인 ID를 설정합니다.
+         *
+         * @param bid 방송인 ID
+         * @return 빌더 인스턴스
+         */
         public Builder bid(String bid) {
             this.bid = bid;
             return this;
         }
 
+        /**
+         * 방송 번호를 설정합니다.
+         *
+         * @param bno 방송 번호
+         * @return 빌더 인스턴스
+         */
         public Builder bno(String bno) {
             this.bno = bno;
             return this;
         }
 
+        /**
+         * SSL Context를 설정합니다.
+         *
+         * @param sslContext SSL Context
+         * @return 빌더 인스턴스
+         */
         public Builder sslContext(SSLContext sslContext) {
             this.sslContext = sslContext;
             return this;
         }
 
+        /**
+         * 연결 타임아웃을 설정합니다.
+         *
+         * @param connectionTimeout 연결 타임아웃
+         * @return 빌더 인스턴스
+         */
+        public Builder connectionTimeout(Duration connectionTimeout) {
+            this.connectionTimeout = connectionTimeout;
+            return this;
+        }
+
+        /**
+         * 최대 재시도 횟수를 설정합니다.
+         *
+         * @param maxRetryAttempts 최대 재시도 횟수
+         * @return 빌더 인스턴스
+         */
+        public Builder maxRetryAttempts(int maxRetryAttempts) {
+            this.maxRetryAttempts = maxRetryAttempts;
+            return this;
+        }
+
+        /**
+         * SOOPChatConfig 인스턴스를 생성합니다.
+         *
+         * @return 구성된 SOOPChatConfig 인스턴스
+         */
         public SOOPChatConfig build() {
             return new SOOPChatConfig(this);
         }