Java Socket实现聊天室附1500行源代码

Java Socket实现聊天室是一种常见的网络应用程序，该应用程序使用Socket API实现了客户端和服务器端之间的连接。本攻略通过讲解如何使用Java Socket API实现一个聊天室，来帮助开发者了解Java Socket编程的基本原理和用法。

概述

Java Socket API是Java语言提供的一个用于网络通信的API，它允许程序员使用Socket、ServerSocket和DatagramSocket等类来实现基于TCP和UDP的网络通信。在本攻略中，我们将使用Java Socket API来开发一个简单的聊天室程序，用户可以通过这个聊天室和其他用户进行交流。

程序设计

客户端

1. 首先，我们需要创建一个客户端类，该类用于连接到服务器和发送、接收数据。

public class Client {
    private String serverIp;
    private int serverPort;
    private Socket socket;
    private BufferedReader bufferedReader;
    private PrintWriter printWriter;

    public Client(String serverIp, int serverPort) throws IOException {
        this.serverIp = serverIp;
        this.serverPort = serverPort;
        this.socket = new Socket(serverIp, serverPort);
        this.bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        this.printWriter = new PrintWriter(socket.getOutputStream());
    }

    public void send(String message) {
        printWriter.println(message);
        printWriter.flush();
    }

    public String receive() throws IOException {
        return bufferedReader.readLine();
    }

    public void close() throws IOException {
        socket.close();
    }
}

1. 然后，我们需要创建一个用于等待用户输入并发送消息的类。

public class WriteThread implements Runnable {
    private Client client;

    public WriteThread(Client client) {
        this.client = client;
    }

    @Override
    public void run() {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            String message = scanner.nextLine();
            client.send(message);
        }
    }
}

1. 接下来，我们需要创建一个用于接收消息的类。

public class ReadThread implements Runnable {
    private Client client;

    public ReadThread(Client client) {
        this.client = client;
    }

    @Override
    public void run() {
        try {
            while (true) {
                String message = client.receive();
                System.out.println(message);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1. 最后，我们将客户端连接到服务器并启动读写线程。

public class ClientMain {
    public static void main(String[] args) throws Exception {
        Client client = new Client("localhost", 8000);

        Thread writeThread = new Thread(new WriteThread(client));
        writeThread.start();

        Thread readThread = new Thread(new ReadThread(client));
        readThread.start();
    }
}

服务器端

1. 首先，我们需要创建一个服务器类，该类用于等待客户端的连接并处理客户端的请求。

public class Server {
    private int port;
    private Map<String, Socket> socketMap;

    public Server(int port) {
        this.port = port;
        this.socketMap = new HashMap<>();
    }

    public void start() throws IOException {
        ServerSocket serverSocket = new ServerSocket(port);
        while (true) {
            Socket socket = serverSocket.accept();
            String user = UUID.randomUUID().toString();
            socketMap.put(user, socket);
            new Thread(new HandlerThread(user, socket)).start();
        }
    }

    public void send(String user, String message) throws IOException {
        Socket socket = socketMap.get(user);
        PrintWriter printWriter = new PrintWriter(socket.getOutputStream(), true);
        printWriter.println(message);
    }

    public void broadcast(String message) throws IOException {
        for (Socket socket : socketMap.values()) {
            PrintWriter printWriter = new PrintWriter(socket.getOutputStream(), true);
            printWriter.println(message);
        }
    }

    public void close() throws IOException {
        for (Socket socket : socketMap.values()) {
            socket.close();
        }
    }
}

1. 然后，我们需要创建一个线程类，该类用于处理客户端的请求。

public class HandlerThread implements Runnable {
    private String user;
    private Socket socket;

    public HandlerThread(String user, Socket socket) {
        this.user = user;
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            while (true) {
                String message = bufferedReader.readLine();
                if (message.equals("exit")) {
                    socket.close();
                    break;
                }
                ServerMain.server.send(user, message);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1. 最后，我们将服务器端启动。

public class ServerMain {
    public static Server server;

    public static void main(String[] args) throws Exception {
        server = new Server(8000);
        server.start();
    }
}

示例说明

下面给出两个示例说明。

示例一：本地运行

1. 首先，我们需要打开一个命令行窗口，进入到聊天室程序的源代码目录。

2. 然后，我们需要启动服务器端程序以等待客户端的连接。

java ServerMain

1. 接下来，我们需要启动客户端程序以连接到服务器。

java ClientMain

1. 现在，我们可以在客户端程序中输入消息并发送到服务器端，同时可以在客户端程序中接收其他客户端发送的消息。

示例二：远程运行

1. 首先，我们需要在远程计算机上启动服务器端程序。

java ServerMain

1. 然后，我们需要在本地计算机上启动客户端程序并连接到远程服务器。

java ClientMain "server_ip_address"

其中，"server_ip_address"表示远程服务器的公网IP地址。

1. 现在，我们可以在本地客户端程序中输入消息并发送到远程服务器端，同时可以在本地客户端程序中接收其他客户端发送的消息。