使用Socket编程、NIO和多线程技术来构建一个简单的聊天应用

设计小案例：一个简单的基于Java的聊天室服务器和客户端。这个案例将综合运用Socket编程、NIO和多线程技术。我们将构建一个可以支持多个客户端同时在线并交换消息的聊天室。

项目概述
服务器：使用ServerSocketChannel和Selector处理来自多个客户端的连接请求和消息，以非阻塞方式读写数据。服务器将接收到的消息广播给所有在线的客户端。
客户端：使用SocketChannel与服务器建立连接，并在独立的线程中监听来自服务器的消息。客户端可以发送消息到服务器，服务器再将消息广播给所有客户端。
服务器端实现

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class ChatServer {
    private Selector selector;
    private final ConcurrentHashMap<SocketChannel, String> clients = new ConcurrentHashMap<>();

    public ChatServer(int port) throws IOException {
        selector = Selector.open();
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(port));
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("Chat Server started on port " + port);
    }

    public void start() throws IOException {
        while (true) {
            selector.select();
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iter = selectedKeys.iterator();
            while (iter.hasNext()) {
                SelectionKey key = iter.next();
                if (key.isAcceptable()) {
                    registerClient(key);
                }
                if (key.isReadable()) {
                    broadcastMessage(key);
                }
                iter.remove();
            }
        }
    }

    private void registerClient(SelectionKey key) throws IOException {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        SocketChannel client = serverChannel.accept();
        client.configureBlocking(false);
        client.register(selector, SelectionKey.OP_READ);
        clients.put(client, "");
        System.out.println("New client connected: " + client.getRemoteAddress());
    }

    private void broadcastMessage(SelectionKey key) throws IOException {
        SocketChannel sender = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = sender.read(buffer);
        if (bytesRead <= 0) {
            sender.close();
            clients.remove(sender);
            System.out.println("Client disconnected: " + sender.getRemoteAddress());
            return;
        }
        buffer.flip();
        String message = new String(buffer.array(), 0, bytesRead);
        for (SocketChannel client : clients.keySet()) {
            if (client != sender) {
                buffer.rewind();
                client.write(buffer);
            }
        }
    }

    public static void main(String[] args) throws IOException {
        ChatServer server = new ChatServer(5555); // 指定监听的端口为5555
        server.start();
    }
}

客户端实现

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.Scanner;

public class ChatClient {
    public static void main(String[] args) {
        try {
            SocketChannel client = SocketChannel.open(new InetSocketAddress("localhost", 5555)); // 连接到服务器的5555端口
            System.out.println("Connected to Chat Server");

            Scanner scanner = new Scanner(System.in);
            while (true) {
                System.out.print("Enter your message: ");
                String message = scanner.nextLine();
                ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
                client.write(buffer);

                buffer.clear();
                int bytesRead = client.read(buffer);
                if (bytesRead == -1) {
                    System.out.println("Server has closed the connection");
                    break;
                }

                String response = new String(buffer.array(), 0, bytesRead);
                System.out.println("Server response: " + response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务器：使用Selector来管理多个SocketChannel的连接和读取操作，实现非阻塞I/O。当读取到客户端消息时，服务器将该消息广播给所有其他客户端。

客户端：通过一个单独的线程监听服务器发来的消息，并在主线程中读取用户输入，发送给服务器。
多线程：服务器利用NIO的非阻塞特性处理多个连接，而客户端使用一个额外的线程来异步地接收来自服务器的消息。

这个案例展示了如何结合使用Socket编程、NIO和多线程技术来构建一个简单的聊天应用。这只是一个基础版本，实际应用中可能需要考虑更多的细节，比如更健壮的异常处理、更复杂的协议来处理消息边界等。

测试打开xshell 连接本地127.0.0.1 5555端口 telnet连接方式 同时打开多个会话窗口，不同窗口输入不同内容