• 实现BIO多客户端通讯模式


    背景

     如果服务端需要处理很多个客户端的消息通信请求应该如何处理呢,此时我们就需要在服务端引入线程了,也就是说客户端每发起一个请求,服务端就创建一个新的线程来处理这个客户端的请求,这样就实现了一个客户端一个线程的模型

    思想

    服务端

    • 实现服务端可以同时接收多个客户潘的Socket通信需求。
    • 是服务端每接收到一个客户端socket请求对象之后都交给一个独立的线程来处理客户端的数据交互沾求。

    服务端线程类

    • 处理服务端传来的数据将其输出

    客户端

    • 获取输入的数据并发送给服务端

    实现

    服务端线程类
    1. 继承Thread线程类
    2. 创建有参构造方法
    3. 从Socket中获得字节输入流
    4. 使用缓冲字符输入流包装字节输入流
    5. 再将字符输入流输出出去
    public class ServerThread extends Thread{
        private Socket socket;
        public ServerThread(Socket socket){
            this.socket = socket;
        }
        @Override
        public void run() {
            try {
                //从socket中得到字节输入流
                InputStream is = socket.getInputStream();
                //使用缓冲字符输入流包装字节输入流
                BufferedReader bfr = new BufferedReader(new InputStreamReader(is));
                String msg;
                while ((msg = bfr.readLine())!=null){
                    System.out.println(msg);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    服务端
    1. 注册接口
    2. 定义死循环持续接收客户端的消息
    3. 创建线程类处理socket通讯信息
    public class Server {
        public static void main(String[] args) {
            try {
                //注册接口
                ServerSocket ss = new ServerSocket(8686);
                //定义死循环持续接收客户端的消息
                while (true){
                    Socket socket = ss.accept();
                    //创建线程类处理socket通讯信息
                    new ServerThread(socket).start();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    客户端
    1. 请求与服务端创建连接
    2. 获取socket输出流包装成打印流
    3. 利用循环不断的发消息给服务端
    public class Client {
        public static void main(String[] args) {
            try {
                //请求与服务端创建连接
                Socket socket = new Socket("127.0.0.1",8686);
                //获取socket输出流包装成打印流
                OutputStream os = socket.getOutputStream();
                PrintStream ps = new PrintStream(os);
                //利用循环不断的发消息给服务端    
                Scanner sc = new Scanner(System.in);
                while (true){
                    System.out.print("请输入发送内如:");
                   String msg = sc.nextLine();
                   ps.println(msg);
                   ps.flush();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    结果

    创建多个客户端向服务端发送请求,服务端都成功将其打印
    在这里插入图片描述

  • 相关阅读:
    maven 显式依赖包包含隐式依赖包,引起依赖包冲突
    systemverilog学习 ---- 类(完结)
    波兰计算器的实现(代码实现) [数据结构][Java]
    Docker教程(centos下安装及docker hello world)
    好用的递归子查询
    xstream运用,JAVA对象转xml,xml转JAVA对象
    不再写Python for 循环
    数据结构-- 并查集
    5.理解上下文Context
    Kafaka核心设计与实践原理(第一部分)
  • 原文地址:https://blog.csdn.net/weixin_58286934/article/details/127922772