Java网络 - BIO阻塞式网络编程

绝地灬酷狼 2022-09-07 14:39 131阅读 0赞

# Java网络 - BIO阻塞式网络编程 #

BIO - Block Input Output

随着技术的发展，两个或以上的程序必然需要进行交互，于是BIO提供了一种端到端的通信，相当于对传输层的一种封装，对于开发人员而言，隐藏了传输的细节，将这些固定的“套路”抽象出来，提供一种端到端的通信，可以使我们更加专注于业务的开发，并且这种通讯是阻塞式的。

阻塞式：服务端启动，等待客户端的连接，在客户端连接到服务端后，服务端启动一个线程去监听客户端消息，客户端发送消息，并等待服务端返回（客户端一直阻塞），服务端收到消息，将消息返回给客户端，此时一次交互完成。若还需交互，则不释放连接，客户端再次将消息发送给服务端，并等待返回，若不需要交互，则客户端释放连接。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjQ3OTk5_size_16_color_FFFFFF_t_70]

**C/S架构使用BIO示例**

public class BIOServer { 
        public static void main(String[] args) throws Exception { 
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("服务器启动成功");
            while (!serverSocket.isClosed()) { 
                Socket request = serverSocket.accept();// 阻塞
                System.out.println("收到新连接 : " + request.toString());
                try { 
                    // 接收数据、打印
                    InputStream inputStream = request.getInputStream(); // net + i/o
                    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
                    String msg;
                    while ((msg = reader.readLine()) != null) {  // 没有数据，阻塞
                        if (msg.length() == 0) { 
                            break;
                        }
                        System.out.println(msg);
                    }
                    System.out.println("收到数据,来自："+ request.toString());
                } catch (IOException e) { 
                    e.printStackTrace();
                } finally { 
                    try { 
                        request.close();
                    } catch (IOException e) { 
                        e.printStackTrace();
                    }
                }
            }
            serverSocket.close();
        }
    }

客户端连接服务端

public class BIOClient { 
        private static Charset charset = Charset.forName("UTF-8");
    
        public static void main(String[] args) throws Exception { 
            Socket s = new Socket("localhost", 8080);
            OutputStream out = s.getOutputStream();
    
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入：");
            String msg = scanner.nextLine();
            out.write(msg.getBytes(charset)); // 阻塞，写完成
            scanner.close();
            s.close();
        }
    }

存在个问题，一个客户端连接没有问题，但是多个客户端连接服务端就出现问题了。原因：多台客户端的情况，首个客户端A连接上服务端时，服务端将阻塞等待A输入数据，等待读完成后，后面的客户端才能连接上服务端。那么对服务端进行改造，一个线程处理一个连接。

public class BIOServer1 { 
        private static ExecutorService threadPool = Executors.newCachedThreadPool();
    
        public static void main(String[] args) throws Exception { 
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("tomcat 服务器启动成功");
            while (!serverSocket.isClosed()) { 
                Socket request = serverSocket.accept();
                System.out.println("收到新连接 : " + request.toString());
                threadPool.execute(() -> { 
                    try { 
                        // 接收数据、打印
                        InputStream inputStream = request.getInputStream();
                        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
                        String msg;
                        while ((msg = reader.readLine()) != null) {  // 阻塞
                            if (msg.length() == 0) { 
                                break;
                            }
                            System.out.println(msg);
                        }
                        System.out.println("收到数据,来自："+ request.toString());
                    } catch (IOException e) { 
                        e.printStackTrace();
                    } finally { 
                        try { 
                            request.close();
                        } catch (IOException e) { 
                            e.printStackTrace();
                        }
                    }
                });
            }
            serverSocket.close();
        }
    }

现在可以处理多个客户端的连接了，但是通过浏览器发送HTTP请求 127.0.0.1:8080 无法连接和响应，先了解一下HTTP协议。

**HTTP协议 - 请求数据包解析**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjQ3OTk5_size_16_color_FFFFFF_t_70 1]

**HTTP协议 - 响应数据包解析**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjQ3OTk5_size_16_color_FFFFFF_t_70 2]

**HTTP协议 - 响应状态码**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjQ3OTk5_size_16_color_FFFFFF_t_70 3]

服务端针对HTTP请求，再次改造。

public class BIOServer2 { 
        private static ExecutorService threadPool = Executors.newCachedThreadPool();
    
        public static void main(String[] args) throws Exception { 
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("服务器启动成功");
            while (!serverSocket.isClosed()) { 
                Socket request = serverSocket.accept();
                System.out.println("收到新连接 : " + request.toString());
                threadPool.execute(() -> { 
                    try { 
                        // 接收数据、打印
                        InputStream inputStream = request.getInputStream();
                        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
                        String msg;
                        while ((msg = reader.readLine()) != null) { 
                            if (msg.length() == 0) { 
                                break;
                            }
                            System.out.println(msg);
                        }
    
                        System.out.println("收到数据,来自："+ request.toString());
                        // 响应结果 200
                        OutputStream outputStream = request.getOutputStream();
                        outputStream.write("HTTP/1.1 200 OK\r\n".getBytes());
                        outputStream.write("Content-Length: 11\r\n\r\n".getBytes());
                        outputStream.write("Hello World".getBytes());
                        outputStream.flush();
                    } catch (IOException e) { 
                        e.printStackTrace();
                    } finally { 
                        try { 
                            request.close();
                        } catch (IOException e) { 
                            e.printStackTrace();
                        }
                    }
                });
            }
            serverSocket.close();
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjQ3OTk5_size_16_color_FFFFFF_t_70]: /images/20220829/1a02974d411341cfb00e0dafb92e03fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjQ3OTk5_size_16_color_FFFFFF_t_70 1]: /images/20220829/e01944e8974f487d9cefe2c769491a9e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjQ3OTk5_size_16_color_FFFFFF_t_70 2]: /images/20220829/537233efc7034e14a935dce9331568fc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjQ3OTk5_size_16_color_FFFFFF_t_70 3]: /images/20220829/cc6d677c57cb46bfa9f9e30c1ff27881.png