Socket 通讯：从原理到 Java 实战

import java.io.*;
import java.net.*;

public class BioServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("服务器启动，监听端口 8080");

        while (true) {
            Socket socket = serverSocket.accept(); // 阻塞等待连接
            new Thread(() -> handleClient(socket)).start();
        }
    }

    private static void handleClient(Socket socket) {
        try (BufferedReader in = new BufferedReader(
                new InputStreamReader(socket.getInputStream()));
             PrintWriter out = new PrintWriter(
                socket.getOutputStream(), true)) {

            String line;
            while ((line = in.readLine()) != null) { // 阻塞等待数据
                System.out.println("收到: " + line);
                out.println("Echo: " + line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;
import java.net.*;
import java.util.Scanner;

public class BioClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 8080);

        try (BufferedReader in = new BufferedReader(
                new InputStreamReader(socket.getInputStream()));
             PrintWriter out = new PrintWriter(
                socket.getOutputStream(), true);
             Scanner scanner = new Scanner(System.in)) {

            System.out.println("连接成功，输入消息：");
            while (scanner.hasNextLine()) {
                String msg = scanner.nextLine();
                out.println(msg);
                System.out.println("服务器: " + in.readLine());
            }
        }
    }
}

import java.io.*;
import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.*;

public class NioServer {
    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(8080));
        serverChannel.configureBlocking(false);
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("NIO 服务器启动");

        while (true) {
            selector.select(); // 阻塞等待事件
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> iter = keys.iterator();

            while (iter.hasNext()) {
                SelectionKey key = iter.next();
                iter.remove();

                if (key.isAcceptable()) {
                    // 新连接
                    SocketChannel client = serverChannel.accept();
                    client.configureBlocking(false);
                    client.register(selector, SelectionKey.OP_READ);
                    System.out.println("新连接: " + client.getRemoteAddress());
                } else if (key.isReadable()) {
                    // 可读
                    SocketChannel client = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = client.read(buffer);

                    if (bytesRead == -1) {
                        client.close();
                    } else {
                        buffer.flip();
                        byte[] data = new byte[buffer.remaining()];
                        buffer.get(data);
                        String msg = new String(data);
                        System.out.println("收到: " + msg.trim());

                        // 回写
                        client.write(ByteBuffer.wrap(("Echo: " + msg).getBytes()));
                    }
                }
            }
        }
    }
}

import java.io.*;
import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.concurrent.*;

public class AioServer {
    public static void main(String[] args) throws IOException {
        AsynchronousServerSocketChannel server =
            AsynchronousServerSocketChannel.open()
                .bind(new InetSocketAddress(8080));

        System.out.println("AIO 服务器启动");

        server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
            @Override
            public void completed(AsynchronousSocketChannel client, Void att) {
                server.accept(null, this); // 继续接受新连接

                ByteBuffer buffer = ByteBuffer.allocate(1024);
                client.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                    @Override
                    public void completed(Integer bytesRead, ByteBuffer buffer) {
                        buffer.flip();
                        byte[] data = new byte[buffer.remaining()];
                        buffer.get(data);
                        String msg = new String(data);
                        System.out.println("收到: " + msg.trim());

                        client.write(ByteBuffer.wrap(
                            ("Echo: " + msg).getBytes()));
                    }

                    @Override
                    public void failed(Throwable exc, ByteBuffer buffer) {
                        exc.printStackTrace();
                    }
                });
            }

            @Override
            public void failed(Throwable exc, Void att) {
                exc.printStackTrace();
            }
        });

        // 阻塞主线程
        new CountDownLatch(1).await();
    }
}

import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.*;

public class ChatServer {
    private static final Set<PrintWriter> clients =
        ConcurrentHashMap.newKeySet();
    private static final ExecutorService pool =
        Executors.newFixedThreadPool(20);

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9090);
        System.out.println("聊天室服务端启动，端口 9090");

        while (true) {
            Socket socket = serverSocket.accept();
            pool.execute(() -> handleClient(socket));
        }
    }

    private static void handleClient(Socket socket) {
        try (BufferedReader in = new BufferedReader(
                new InputStreamReader(socket.getInputStream()));
             PrintWriter out = new PrintWriter(
                socket.getOutputStream(), true)) {

            clients.add(out);
            System.out.println("新用户加入，当前在线: " + clients.size());

            String line;
            while ((line = in.readLine()) != null) {
                System.out.println("收到: " + line);
                broadcast(line, out);
            }
        } catch (IOException e) {
            // 断开连接
        } finally {
            clients.remove(null);
            System.out.println("用户离开，当前在线: " + clients.size());
        }
    }

    private static void broadcast(String message, PrintWriter sender) {
        for (PrintWriter client : clients) {
            if (client != sender) {
                client.println(message);
            }
        }
    }
}

import java.io.*;
import java.net.*;
import java.util.Scanner;

public class ChatClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 9090);
        System.out.println("连接聊天室成功！");

        // 接收消息线程
        new Thread(() -> {
            try (BufferedReader in = new BufferedReader(
                    new InputStreamReader(socket.getInputStream()))) {
                String line;
                while ((line = in.readLine()) != null) {
                    System.out.println(line);
                }
            } catch (IOException e) {
                System.out.println("连接断开");
            }
        }).start();

        // 发送消息
        try (PrintWriter out = new PrintWriter(
                socket.getOutputStream(), true);
             Scanner scanner = new Scanner(System.in)) {

            while (scanner.hasNextLine()) {
                out.println(scanner.nextLine());
            }
        }
    }
}

// 使用 HikariCP 等连接池管理 TCP 连接
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/db");
config.setMaximumPoolSize(20);        // 最大连接数
config.setMinimumIdle(5);             // 最小空闲连接
config.setConnectionTimeout(30000);   // 获取连接超时 30s
config.setIdleTimeout(600000);        // 空闲连接存活 10min
config.setMaxLifetime(1800000);       // 连接最大生命周期 30min

Socket socket = new Socket();
socket.connect(new InetSocketAddress(host, port), 5000);  // 连接超时 5s
socket.setSoTimeout(30000);  // 读超时 30s
socket.setKeepAlive(true);   // 开启 TCP keepalive