【版权声明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权）
https://www.cnblogs.com/cnb-yuchen/p/18032037
出自【进步*于辰的博客】

参考笔记二，P61。

注：“一对一”、“多对多”是相对于Socket而言，而非服务端 / 客户端类的个数。

• 1、概述
• 2、二种聊天模式
  • 2.1 “一对一”
  • 2.2 “多对多”
• 最后

1、概述

两种聊天模式的共同点：Client和Server都是以管道（IO流）的方式进行一对一连接、通信，故在"多对多"聊天模式的实现中，需要循环接收多个Socket（客户端，见第2.2项）。（大家可能云里雾里，继续看）

从IO流的角度：

1. Client，读取input流是获取回复，output流用于发送请求；
2. Server：读取input是获取请求，output流用于响应。

Client 与 Server 发送消息的实现都基于阻塞，实现“聊天”的本质就是循环“发送-接收”消息的过程。

2、二种聊天模式

2.1 “一对一”

看下述代码：
1、服务端类Server。

/**
 * 功能：Server 与 Client 一对一聊天
 */
public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket server = new ServerSocket(8844);
        System.out.println("等待：");

        Socket client = server.accept();// 阻塞，当有 Socket 访问时，返回此 Socket，阻塞放开
        System.out.println("连接成功");

        BufferedReader req = new BufferedReader(new InputStreamReader(client.getInputStream()));// 缓冲输入流，用于获取请求
        PrintWriter resp = new PrintWriter(client.getOutputStream(), true);// 缓冲输出流，用于响应。true → 自动刷新
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));// 用于获取键盘输入

        while (true) {
            String reqStr = req.readLine();// 读取 Socket 输入流，因为 Client 还未输入，阻塞。当 Client 输入后，阻塞放开
            System.out.println("请求 = " + reqStr);

            System.out.print("input：");
            String respStr = in.readLine();// 获取键盘输入，阻塞
            resp.println(respStr);// 输出响应（发送回复）
        }
    }
}

2、客户端类·Client·。

public class Client {
    public static void main(String[] args) throws Exception {
        Socket client = new Socket("127.0.0.1", 8844);

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));// 缓冲输入流，用于获取键盘输入
        PrintWriter req = new PrintWriter(new OutputStreamWriter(client.getOutputStream()), true);// 缓冲输出流，用于发送请求
        BufferedReader resp = new BufferedReader(new InputStreamReader(client.getInputStream()));// 用于获取响应

        while (true) {
            System.out.print("input：");
            String reqStr = in.readLine();// 获取键盘输入，阻塞
            req.println(reqStr);// 发送请求

            String respStr = resp.readLine();// 读取输入流（获取响应）
            System.out.println("响应 = " + respStr);
        }
    }
}

127.0.0.1是本地ip，如果服务端不在本地，可以使用cmd → ipconfig 或 ipconfig/all查询本机ip。

2.2 “多对多”

看下述代码：
1、服务端类Server。

/**
 * 业务：负责将各个客户端发送的信息广播推送
 */
public class Server {

    private static Set<Socket> set = Collections.synchronizedSet(new HashSet<>());

    public static void main(String[] args) throws Exception {
        ServerSocket server = new ServerSocket(8844);
        System.out.println("等待：");

        while (true) {
            Socket client = server.accept();
            System.out.println("连接成功");
            set.add(client);

            /**
             * 为什么使用线程？
             *      1、实时接收各个客户端消息；
             *      2、实时推送；
             *      3、为了能获取各个客户端信息。
             * 这些工作只能在后台运行，而不能在主线程执行，因为一个线程（主线程）会因阻塞、导致后续其他工作一并终止。
             * 因此，需要线程，并且为每个客户端都创建一个。
             */
            new Thread(() -> {
                /**
                 * 为什么在线程内获取输入流等信息，而不是线程外？
                 *      因为线程外属于主线程，如 req 这些变量都是局部变量，会被后续覆盖，
                 *      因此置于线程内，这样每个线程都独立保存着当前客户端的信息。
                 */
                try (BufferedReader req = new BufferedReader(new InputStreamReader(client.getInputStream()))) {
                    while (true) {
                        String reqStr = req.readLine();
                        for (Socket current : set) {
                            if (current == client)// 向所有客户端推送消息，排除发送者
                                continue;
                            // 根据当前客户端对象获取输出管道（输出流）推送消息
                            PrintWriter resp = new PrintWriter(current.getOutputStream(), true);
                            resp.println(reqStr);
                        }
                        System.out.println(new Date());
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

2、客户端类Client。

public class Client {
    public static void main(String[] args) throws Exception {
        Socket client = new Socket("127.0.0.1", 8844);

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter req = new PrintWriter(new OutputStreamWriter(client.getOutputStream()), true);
        BufferedReader resq = new BufferedReader(new InputStreamReader(client.getInputStream()));

        /**
         * 为什么使用线程？
         *      为了实时获取推送消息
         */
        new Thread(() -> {
            try {
                while (true) {
                    String respStr = resq.readLine();
                    System.out.println("响应 = " + respStr);
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }).start();

        // 发送请求
        while (true) {
            System.out.println("input:");
            String reqStr;
            if (!(reqStr = in.readLine()).isEmpty())
                req.println(reqStr);
            else
                System.out.println("info can't empty");
        }
    }
}

若要生成多个客户端进行聊天，正确的做法不是重启类，因为那样的结果是覆盖，结果还是一个客户端。因此，需要再创建Client类。

最后

本文的例子是为了阐述Socket套接字的使用、方便大家理解而简单举出的，不一定有实用性。并且，示例功能比较粗糙。为什么我不添加一些功能？比如：使用swing或html生成一个聊天界面、完善聊天功能，等等。

原由：

1. 本文的核心是阐述Socket套接字的使用；
2. Socket套接字只是网络编程的开端；
3. 单一使用Socket难以开发性能优良、功能完善的聊天功能。

因此，后续我会使用WebSocket实现。

本文完结。