Java Socket 编程简介

// server端
public class SocketServer {
  public static void main(String[] args) throws Exception {
    ServerSocket server = new ServerSocket(8080);
    
    // 阻塞等待连接
    Socket socket = server.accept();

    // 从socket中获取输入流，并建立缓冲区进行读取
    InputStream inputStream = socket.getInputStream();
    byte[] bytes = new byte[1024];
    int len;
    StringBuilder sb = new StringBuilder();
    while ((len = inputStream.read(bytes)) != -1) {
      sb.append(new String(bytes, 0, len,"UTF-8"));
    }
    System.out.println("Received: " + sb);
    OutputStream outputStream = socket.getOutputStream();
    outputStream.write("hello client".getBytes("UTF-8"));
    outputStream.flush();

    // 关闭流&连接
    inputStream.close();
    outputStream.close();
    socket.close();
    server.close();
  }
}
// client 端
public class SocketClient {
  public static void main(String args[]) throws Exception {
    Socket socket = new Socket("127.0.0.1", 8080);
    // 建立连接后获得输出流
    OutputStream outputStream = socket.getOutputStream();
    String message="hello server";
    outputStream.write(message.getBytes("UTF-8"));
    //通知server消息发送完成
    socket.shutdownOutput();
    
    // 读取消息
    InputStream inputStream = socket.getInputStream();
    byte[] bytes = new byte[1024];
    int len;
    StringBuilder sb = new StringBuilder();
    while ((len = inputStream.read(bytes)) != -1) {
      sb.append(new String(bytes, 0, len,"UTF-8"));
    }
    System.out.println("Received: " + sb);

    // 关闭流&连接
    inputStream.close();
    outputStream.close();
    socket.close();
  }
}

public class NIOServer {
    public static void main(String[] args) throws IOException {
        // 创建Selector
        Selector selector = Selector.open();

        // 创建ServerSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false); // 设置为非阻塞模式
        serverSocketChannel.bind(new InetSocketAddress(8888)); // 绑定端口

        // 注册到Selector，监听ACCEPT事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 循环等待事件
        while (true) {
            selector.select(); // 阻塞直到有事件发生
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();

            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove(); // 移除当前处理的key

                if (key.isAcceptable()) { // 有新的客户端连接
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel socketChannel = server.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector, SelectionKey.OP_READ); // 注册到Selector，监听READ事件
                    System.out.println("客户端已连接：" + socketChannel.getRemoteAddress());
                } else if (key.isReadable()) { // 有可读数据
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = socketChannel.read(buffer);

                    if (bytesRead > 0) { // 读取到数据
                        buffer.flip();
                        byte[] data = new byte[buffer.remaining()];
                        buffer.get(data);
                        String message = new String(data, "UTF-8").trim();
                        System.out.println("收到客户端消息：" + message);

                        // 回显消息给客户端
                        String response = "服务器已收到：" + message;
                        ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes("UTF-8"));
                        socketChannel.write(responseBuffer);
                    } else if (bytesRead == -1) { // 客户端断开连接
                        socketChannel.close();
                        System.out.println("客户端已断开连接：" + socketChannel.getRemoteAddress());
                    }
                }
            }
        }
    }
}

public class AIOServer {
    private final AsynchronousServerSocketChannel serverChannel;

    public AIOServer(int port) throws IOException {
        this.serverChannel = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(port));
        System.out.println("服务器已启动，端口：" + port);
        accept();
    }

    private void accept() {
        serverChannel.accept(this, new CompletionHandler<AsynchronousSocketChannel, AIOServer>() {
            @Override
            public void completed(AsynchronousSocketChannel clientChannel, AIOServer server) {
                System.out.println("新客户端已连接：" + clientChannel.getRemoteAddress());
                // 继续监听新的连接
                server.accept();
                // 处理新连接的读写
                handleClient(clientChannel);
            }

            @Override
            public void failed(Throwable exc, AIOServer server) {
                exc.printStackTrace();
                server.accept();
            }
        });
    }

    private void handleClient(final AsynchronousSocketChannel clientChannel) {
        ByteBuffer buffer = ByteBuffer.allocate(256);

        clientChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                if (result == -1) {
                    try {
                        clientChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    return;
                }

                attachment.flip();
                String message = new String(attachment.array(), 0, result).trim();
                System.out.println("收到客户端消息：" + message);

                // 回显消息给客户端
                clientChannel.write(ByteBuffer.wrap(("服务器已收到：" + message).getBytes()), null,
                        new CompletionHandler<Integer, Void>() {
                            @Override
                            public void completed(Integer result, Void attachment) {
                                // 准备下一次读取
                                attachment.clear();
                                clientChannel.read(attachment, attachment, this);
                            }

                            @Override
                            public void failed(Throwable exc, Void attachment) {
                                exc.printStackTrace();
                                try {
                                    clientChannel.close();
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                        });
            }

            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                exc.printStackTrace();
                try {
                    clientChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }
    public static void main(String[] args) throws IOException {
        new AIOServer(8888);
    }
}