如何在Java代码中优雅地处理这种异常并重试连接？

在Java中，处理`ConnectException: Connection refused`这样的异常并且优雅地重试连接，可以使用try-catch-finally结构，并结合`java.util.concurrent`库中的`ScheduledExecutorService`或`RetryPolicy`。这里有一个简单的示例，使用`Thread.sleep()`和一个计数器来控制重试次数：

import java.net.InetSocketAddress;
import java.net.SocketTimeoutException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class RetryableConnection {
    private static final int MAX_RETRIES = 3;
    private static final long RETRY_DELAY_MS = 500; // 每次重试间隔500毫秒

    public void connectToServer(String host, int port) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        
        try {
            for (int i = 0; i < MAX_RETRIES; i++) {
                executor.submit(() -> {
                    InetSocketAddress address = new InetSocketAddress(host, port);
                    Socket socket = new Socket();
                    try {
                        socket.connect(address, 5000); // 设置超时时间
                        // 连接成功，执行后续操作
                        handleSuccessfulConnection(socket);
                    } catch (SocketTimeoutException e) {
                        if (i == MAX_RETRIES - 1) { // 最后一次重试失败
                            throw e; // 抛出原始的异常
                        }
                        System.out.println("Connection refused, retrying in " + RETRY_DELAY_MS + "ms...");
                        Thread.sleep(RETRY_DELAY_MS);
                    } finally {
                        socket.close(); // 关闭连接
                    }
                });
                break; // 如果第一次尝试就成功，立即退出循环
            }
        } catch (InterruptedException e) {
            // 调度线程被中断，需要处理
        } finally {
            executor.shutdown();
        }
    }

    private void handleSuccessfulConnection(Socket socket) {
        // 这里处理连接成功的业务逻辑
        // ...
    }

    // 其他方法...
}

在这个例子中，我们创建了一个线程池，然后在循环中尝试连接。如果达到最大重试次数仍然失败，则抛出原异常。注意，实际应用中，可能会使用更复杂的异常处理策略和更精细的重试条件，例如基于延迟指数增长的重试机制。