import java.net.Socket;
import java.net.InetSocketAddress;
import java.io.IOException;
public class ConnectExample {
    public static void main(String[] args) {
        String serverIP = "127.0.0.1"; // 服務(wù)器IP
        int port = 8888; // 服務(wù)器端口
        try (Socket socket = new Socket()) {
            // 創(chuàng)建服務(wù)器地址對(duì)象
            InetSocketAddress serverAddr = new InetSocketAddress(serverIP, port);
            // 發(fā)起連接（設(shè)置超時(shí)時(shí)間為3秒）
            socket.connect(serverAddr, 3000);
            if (socket.isConnected()) {
                System.out.println("連接成功！");
                // 連接成功后可進(jìn)行數(shù)據(jù)傳輸...
            }
        } catch (IOException e) {
            System.out.println("連接失敗：" + e.getMessage());
        }
    }
}

import java.io.*;
import java.net.*;
import java.util.Scanner;
public class Client {
    public static void main(String[] args) {
        // 服務(wù)器IP地址和端口，實(shí)際使用時(shí)替換為服務(wù)器的真實(shí)IP
        String serverAddress = "127.0.0.1"; // 本地測(cè)試使用localhost
        int port = 8888;
        try (Socket socket = new Socket(serverAddress, port)) {
            System.out.println("已連接到服務(wù)器: " + serverAddress + ":" + port);
            // 使用try-with-resources自動(dòng)關(guān)閉資源
            try (
                // 獲取輸出流，向服務(wù)器發(fā)送數(shù)據(jù)
                PrintWriter out = new PrintWriter(
                    socket.getOutputStream(), true);
                // 獲取輸入流，讀取服務(wù)器返回的數(shù)據(jù)
                BufferedReader in = new BufferedReader(
                    new InputStreamReader(socket.getInputStream()));
                // 從控制臺(tái)讀取用戶輸入
                Scanner scanner = new Scanner(System.in)
            ) {
                String userInput;
                // 循環(huán)讀取用戶輸入并發(fā)送給服務(wù)器
                do {
                    System.out.print("請(qǐng)輸入要發(fā)送的消息(輸入bye退出): ");
                    userInput = scanner.nextLine();
                    // 發(fā)送消息到服務(wù)器
                    out.println(userInput);
                    // 讀取服務(wù)器的響應(yīng)
                    String response = in.readLine();
                    System.out.println("服務(wù)器響應(yīng): " + response);
                } while (!"bye".equalsIgnoreCase(userInput));
            }
        } catch (UnknownHostException e) {
            System.out.println("無(wú)法識(shí)別服務(wù)器地址: " + serverAddress);
        } catch (IOException e) {
            System.out.println("與服務(wù)器連接失敗: " + e.getMessage());
        }
    }
}

import java.io.*;
import java.net.*;
public class Server {
    public static void main(String[] args) {
        // 定義服務(wù)器端口
        int port = 8888;
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("服務(wù)器啟動(dòng)，監(jiān)聽(tīng)端口: " + port);
            // 等待客戶端連接
            while (true) {
                // 阻塞等待客戶端連接
                Socket clientSocket = serverSocket.accept();
                System.out.println("客戶端已連接: " + clientSocket.getInetAddress());
                // 使用try-with-resources自動(dòng)關(guān)閉資源
                try (
                    // 獲取輸入流，讀取客戶端發(fā)送的數(shù)據(jù)
                    BufferedReader in = new BufferedReader(
                        new InputStreamReader(clientSocket.getInputStream()));
                    // 獲取輸出流，向客戶端發(fā)送數(shù)據(jù)
                    PrintWriter out = new PrintWriter(
                        clientSocket.getOutputStream(), true)
                ) {
                    String inputLine;
                    // 讀取客戶端發(fā)送的信息
                    while ((inputLine = in.readLine()) != null) {
                        System.out.println("收到客戶端消息: " + inputLine);
                        // 向客戶端發(fā)送響應(yīng)
                        out.println("服務(wù)器已收到: " + inputLine);
                        // 如果客戶端發(fā)送"bye"，則關(guān)閉連接
                        if ("bye".equalsIgnoreCase(inputLine)) {
                            break;
                        }
                    }
                } catch (IOException e) {
                    System.out.println("與客戶端通信時(shí)發(fā)生錯(cuò)誤: " + e.getMessage());
                } finally {
                    try {
                        clientSocket.close();
                        System.out.println("客戶端連接已關(guān)閉");
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            System.out.println("服務(wù)器啟動(dòng)失敗: " + e.getMessage());
        }
    }
}

// 客戶端心跳線程
class HeartbeatSender implements Runnable {
    private Socket socket;
    private boolean running = true;
    public HeartbeatSender(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        try (OutputStream out = socket.getOutputStream()) {
            while (running) {
                // 發(fā)送心跳包（簡(jiǎn)單的字符串或空包）
                out.write("HEARTBEAT".getBytes());
                out.flush();
                System.out.println("發(fā)送心跳包");
                // 間隔30秒發(fā)送一次
                Thread.sleep(30000);
            }
        } catch (Exception e) {
            System.out.println("心跳發(fā)送失敗，連接可能已斷開(kāi)");
            // 觸發(fā)重連邏輯
        }
    }
    public void stop() {
        running = false;
    }
}

// 服務(wù)器心跳檢測(cè)線程
class HeartbeatChecker implements Runnable {
    private Socket socket;
    private boolean running = true;
    private long lastHeartbeatTime;
    private static final long TIMEOUT = 60000; // 超時(shí)時(shí)間60秒
    public HeartbeatChecker(Socket socket) {
        this.socket = socket;
        this.lastHeartbeatTime = System.currentTimeMillis();
    }
    @Override
    public void run() {
        try (InputStream in = socket.getInputStream()) {
            byte[] buffer = new byte[1024];
            while (running) {
                // 檢查是否超時(shí)
                if (System.currentTimeMillis() - lastHeartbeatTime > TIMEOUT) {
                    System.out.println("心跳超時(shí)，關(guān)閉連接");
                    socket.close();
                    running = false;
                    break;
                }
                // 讀取數(shù)據(jù)（包括心跳包）
                if (in.available() > 0) {
                    int len = in.read(buffer);
                    String data = new String(buffer, 0, len);
                    if ("HEARTBEAT".equals(data)) {
                        // 收到心跳包，更新時(shí)間
                        lastHeartbeatTime = System.currentTimeMillis();
                        System.out.println("收到心跳包");
                    }
                }
                // 短暫休眠，減少CPU占用
                Thread.sleep(1000);
            }
        } catch (Exception e) {
            System.out.println("連接已斷開(kāi)");
        }
    }
}

import java.net.Socket;
import java.net.InetSocketAddress;
import java.io.IOException;
public class ReconnectClient {
    private static final String SERVER_IP = "127.0.0.1";
    private static final int SERVER_PORT = 8888;
    private static final int MAX_RECONNECT_ATTEMPTS = 10; // 最大重連次數(shù)
    private static final int BASE_DELAY = 1000; // 基礎(chǔ)重連延遲（毫秒）
    private Socket socket;
    private boolean isRunning = true;
    public static void main(String[] args) {
        ReconnectClient client = new ReconnectClient();
        client.start();
    }
    public void start() {
        // 初始連接
        if (connect()) {
            // 連接成功后啟動(dòng)通信線程
            startCommunication();
        } else {
            // 初始連接失敗，進(jìn)入重連流程
            startReconnectLoop();
        }
    }
    // 建立連接
    private boolean connect() {
        try {
            socket = new Socket();
            socket.connect(new InetSocketAddress(SERVER_IP, SERVER_PORT), 3000); // 3秒超時(shí)
            System.out.println("成功連接到服務(wù)器：" + SERVER_IP + ":" + SERVER_PORT);
            return true;
        } catch (IOException e) {
            System.out.println("連接失?。? + e.getMessage());
            closeSocket();
            return false;
        }
    }
    // 啟動(dòng)通信線程（實(shí)際業(yè)務(wù)邏輯）
    private void startCommunication() {
        new Thread(() -> {
            try {
                // 這里是正常通信邏輯（讀取/發(fā)送數(shù)據(jù)）
                // ...
                // 模擬通信過(guò)程中可能發(fā)生的異常斷開(kāi)
                // Thread.sleep(5000);
                // throw new IOException("模擬連接中斷");
            } catch (Exception e) {
                System.out.println("通信異常，連接斷開(kāi)：" + e.getMessage());
                closeSocket();
                // 啟動(dòng)重連
                startReconnectLoop();
            }
        }).start();
    }
    // 重連循環(huán)
    private void startReconnectLoop() {
        new Thread(() -> {
            int attempt = 0;
            while (isRunning && attempt < MAX_RECONNECT_ATTEMPTS) {
                attempt++;
                // 指數(shù)退避策略：重連間隔逐漸增加（1s, 2s, 4s...）
                long delay = (long) (BASE_DELAY * Math.pow(2, Math.min(attempt, 10)));
                System.out.println("第" + attempt + "次重連嘗試，延遲" + delay + "ms...");
                try {
                    Thread.sleep(delay);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
                // 嘗試重連
                if (connect()) {
                    // 重連成功，恢復(fù)通信
                    startCommunication();
                    break;
                }
            }
            if (attempt >= MAX_RECONNECT_ATTEMPTS) {
                System.out.println("達(dá)到最大重連次數(shù)，停止嘗試");
                // 可以通知用戶或觸發(fā)其他處理
            }
        }).start();
    }
    // 關(guān)閉Socket
    private void closeSocket() {
        try {
            if (socket != null && !socket.isClosed()) {
                socket.close();
            }
        } catch (IOException e) {
            System.out.println("關(guān)閉Socket失?。? + e.getMessage());
        }
        socket = null;
    }
    // 停止客戶端
    public void stop() {
        isRunning = false;
        closeSocket();
    }
}