Java面试知识点（七十）Socket编程——C/S架构基础入门

ゝ一纸荒年。 2021-09-20 19:06 210阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70]

通信双方一方作为服务器等待客户提出请求并予以响应。客户则在需要服务时向服务器提 出申请。服务器一般作为守护进程始终运行，监听网络端口，一旦有客户请求，就会启动一个服务进程来响应该客户，同时自己继续监听服务端口，使后来的客户也 能及时得到服务。

### 单线程客户端和服务器通信 ###

【服务器】

package test.socket;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class TestServer { 
        public static void main(String[] args) { 
            try { 
                // 服务器socket并指定端口
                ServerSocket server = new ServerSocket(9999);
                // 接收服务器
                Socket socket = server.accept();
                // 获取服务器的输入流
                BufferedReader reader
                        = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                // 获取服务器的输出流
                PrintWriter writer = new PrintWriter(socket.getOutputStream(),true);
    
                // 来自键盘的输入数据
                BufferedReader keyword =
                        new BufferedReader(new InputStreamReader(System.in));
    
                while (true) { 
                    // 当有输入数据的时候，ready返回true
                    if (reader.ready()) { 
                        String str = reader.readLine();
                        System.out.println("Client: "+str);
                    }
                    // 捕获服务器另一个输入流,有数据，发送给client并打印
                    if (keyword.ready()) { 
                        String keyStr = keyword.readLine();
                        writer.println(keyStr);
                        System.out.println("Server: " + keyStr);
                    }
                }
    
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    }

【客户端】

package test.socket;
    
    import java.io.*;
    import java.net.Socket;
    
    public class TestClient { 
        public static void main(String[] args) { 
    
            try { 
                // 连接指定的服务器socket
                Socket socket = new Socket("localhost",9999);
    
                // 输入流
                BufferedReader reader =
                        new BufferedReader(new InputStreamReader(socket.getInputStream()));
    
                // 输出流
                PrintWriter writer =
                        new PrintWriter(socket.getOutputStream(), true);
    
                // 键盘输入
                BufferedReader keyword =
                        new BufferedReader(new InputStreamReader(System.in));
    
                while (true) { 
                    if (reader.ready()) { 
                        String str = reader.readLine();
                        System.out.println("Server:" + str);
                    }
                    if (keyword.ready()) { 
                        String key = keyword.readLine();
                        writer.println(key);
                        System.out.println("Client:" + key);
                    }
                }
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    }

【运行结果】  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70 1]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70 2]

--------------------

### 多线程客户端和服务器通信 ###

上一个例子，只能支持单一客户端和服务器通信，如果想要多个客户端与服务器保持通讯，则需要引入多线程

一个socket只能连接一个客户端和一个服务器，如果想要多个客户端与服务器通讯就需要多线程，这里多线程指的是，服务器方面每接收一个客户端的请求，就起一个子线程，具体操作就是serversocket.accept()方法作为子线程的参数传入，这样就实现多个客户端同时与服务器

**实现runnable接口的服务器线程类**

package test.socket.practice1;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.Socket;
    
    public class SingleServer implements Runnable{ 
        private Socket socket;
    
        public SingleServer(Socket socket) { 
            this.socket = socket;
        }
    
        @Override
        public void run() { 
            try { 
                boolean flag = true;
                // 保证可以循环输入数据
                while (flag) { 
                    // 读取从客户端的信息
                    read();
    
                    // 读取从键盘的信息
                    BufferedReader keyword =
                            new BufferedReader(new InputStreamReader(System.in));
                    if (keyword.ready()) { 
                        String keyStr = keyword.readLine();
                        System.out.println("服务器: "+keyStr);
                        write(keyStr);
                    }
                }
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    
        /** * 在服务器读取客户端发送过来的信息 * */
        private void read() { 
            try { 
                BufferedReader reader =
                        new BufferedReader(new InputStreamReader(socket.getInputStream()));
                if (reader.ready()) { 
                    String readStr = reader.readLine();
                    System.out.println("客户端" + readStr);
                }
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    
        /** * 把服务器写的信息发送给客户端 * */
        private void write(String str) { 
            try { 
                PrintWriter writer =
                        new PrintWriter(socket.getOutputStream(),true);
                writer.println("服务器："+str);
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    }

**服务器类，开启线程，循环侦听客户端，每当一个客户端请求之后，就会启动一个线程与客户端相连**

package test.socket.practice1;
    
    import test.test.thread1;
    
    import java.io.IOException;
    import java.net.ServerSocket;
    
    public class Server { 
        public static void main(String[] args) { 
            try { 
                // 设定监控端口，客户端可以寻找到
                ServerSocket server = new ServerSocket(9999);
                System.out.println("服务器开启...");
                // 循环侦听客户端请求
                while (true) { 
                    SingleServer singleServer = new SingleServer(server.accept());
                    Thread t = new Thread(singleServer);
                    // 开启多线程
                    t.start();
                }
    
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    }

单线程客户端，可以多次启动（在idea中，默认是不能同时运行同一个类的，需要点击设置![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70 4]勾中选择框）

package test.socket.practice1;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.Socket;
    
    public class SingleClient { 
        public static void main(String[] args) { 
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    try { 
                        // 声明socket，并设定连接的服务器
                        Socket socket = new Socket("localhost",9999);
                        System.out.println("客户端开启...");
    
                        // 声明输入输出流
                        BufferedReader reader =
                                new BufferedReader(new InputStreamReader(socket.getInputStream()));
                        BufferedReader key =
                                new BufferedReader(new InputStreamReader(System.in));
                        PrintWriter writer =
                                new PrintWriter(socket.getOutputStream(),true);
    
                        boolean flag = true;
                        while (flag) { 
                            if (reader.ready()) { 
                                String str = reader.readLine();
                                System.out.println("服务器："+str);
                            }
                            if (key.ready()) { 
                                String strKey = key.readLine();
                                writer.println(Thread.currentThread().getName() +": "+ strKey);
                                System.out.println("客户端" + Thread.currentThread().getName() +": "+ strKey);
                                // 客户端退出
                                if ("exit".equals(strKey)) { 
                                    flag = false;
                                    socket.close();
                                }
                            }
                        }
                    } catch (IOException e) { 
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

先启动server，在启动多个SingleClient ，可以实现多个客户端与server通讯  
![在这里插入图片描述][20191011142853976.png]

![在这里插入图片描述][20191011142915360.png]

![在这里插入图片描述][20191011142932346.png]

关于多线程socket编程，这里是有很多内容的，上面的这个只是一个简单的demo，还有很多问题，比如说，多个客户端的信息都可以发送到服务器，但是服务器是无法发送给客户端的，因为socket都在连接着，服务器只发送一个，不知道发给谁（也就说，服务器开启了多线程，但是从客户端看来，依旧只有一个服务器跟自己相连，服务器发送的消息，当只有一个客户端的时候是可以接收到的吗，但是多个客户端就不行。），其次，还有一种场景，服务器作为中间纽带，多客户之间互相通信（也就是聊天室类似的功能），我会一一补充

补充  
[Java面试知识点（七十一）Socket编程——多线客户端和服务器通讯][Java_Socket]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70]: /images/20210920/a27e256d60524d85b97867b3bbc2919b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191010161546222.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70 2]: /images/20210920/a5b05e6bf6594224a1d861c2cf74422e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70 3]: /images/20210920/4724fbe2dd4a401490d85c80c99ca701.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70 4]: /images/20210920/28872c6bd6524003b52fb64dc8faed6e.png
[20191011142853976.png]: /images/20210920/7667220f42a94f899ba94252486625c9.png
[20191011142915360.png]: /images/20210920/cb6601dcf39b4602a51e2ead3d2df515.png
[20191011142932346.png]: /images/20210920/ba06947a405f4f41b5a81d9d41c4bdae.png
[Java_Socket]: https://blog.csdn.net/qq_33945246/article/details/102515670