Java - BIO网络编程

2022-06-08 本文已影响0人右耳菌

1. Server端代码

package cn.lazyfennec.net.bio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Author: Neco
 * @Description:
 * @Date: create in 2022/6/7 23:00
 */
public class BIOServer {

    public static void main(String[] args) throws IOException {
        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();
                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();
    }
}

2. Client端代码

package cn.lazyfennec.net.bio;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.Charset;
import java.util.Scanner;

/**
 * @Author: Neco
 * @Description:
 * @Date: create in 2022/6/7 23:07
 */
public class BIOClient {

    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 8080);
        OutputStream out = socket.getOutputStream();

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：");
        String msg = scanner.nextLine();
        out.write(msg.getBytes());
        scanner.close();
        socket.close();
    }
}

3. 总结

以上的方式，仅能对一个连接的请求进行响应，而其他的连接请求将会被阻塞，无法连接成功。

可以处理多连接的方式：

package cn.lazyfennec.net.bio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 多线程支持
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();
    }
}

4. Http协议

请求数据包解析
请求数据包解析
响应数据包解析
响应数据包解析
响应状态码
1xx（临时响应)
表示临时响应并需要请求者继续执行操作的状态代码
2xx(成功)
表示成功处理了请求的状态代码。
3xx(重定向)
表示要完成请求，需要进一步操作。通常，这些状态代码用来重定向。
4xx(请求错误)
这些状态代码表示请求可能出错，妨碍了服务器的处理。
5xx(服务器错误)
这些状态代码表示服务器在尝试处理请求时发生内部错误。这些错误可能是服务器本身的错误，而不是请求出错。
支持浏览器访问返回http内容的方式：

package cn.lazyfennec.net.bio;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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();
    }
}

5. BIO阻塞IO的含义

阻塞(blocking) IO：资源不可用时，IO请求一直阻塞，直到反馈结果（有数据或超时)。
非阻塞(non-blocking)IO：资源不可用时，IO请求离开返回，返回数据标识资源不可用。
同步(synchronous)IO：应用阻塞在发送或接收数据的状态，直到数据成功传输或返回失败。
异步(asynchronous) IO：应用发送或接收数据后立刻返回，实际处理是异步执行的。

阻塞和非阻塞是获取资源的方式，同步/异步是程序如何处理资源的逻辑设计。
代码中使用的APl: ServerSocket#accept、InputStream#read 都是阻塞的APl。操作系统底层API中，默认Socket操作都是Blocking型，send/recv等接口都是阻塞的。

带来的问题:阻塞导致在处理网络I/0时，一个线程只能处理一个网络连接。

如果觉得有收获就点个赞吧，更多知识，请点击关注查看我的主页信息哦~