MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java BIO 编程的实际应用

2021-01-135.3k 阅读

Java BIO 编程基础

BIO 简介

BIO（Blocking I/O，阻塞式 I/O）是Java早期的I/O编程模型。在BIO模型中，当一个线程执行I/O操作时，该线程会被阻塞，直到I/O操作完成。例如，当从网络套接字读取数据时，如果数据还没有到达，线程会一直等待，在等待期间，该线程无法执行其他任务。

BIO模型基于流（Stream）的概念，无论是从文件读取数据，还是通过网络进行数据传输，都通过字节流或字符流来处理。字节流主要用于处理二进制数据，如图片、音频等，而字符流则用于处理文本数据。

Java BIO 核心类

  1. InputStream 和 OutputStream：这两个抽象类是字节流的基础。InputStream用于从数据源（如文件、网络套接字）读取数据，而OutputStream用于向目的地（如文件、网络套接字）写入数据。例如，FileInputStream和FileOutputStream分别用于从文件读取和向文件写入字节数据。
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {
            int data;
            while ((data = fis.read()) != -1) {
                fos.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，FileInputStream从input.txt文件中读取字节数据，每次读取一个字节，FileOutputStream将读取到的字节写入output.txt文件。read()方法返回读取到的字节数据，如果到达流的末尾，则返回 -1。

  1. Reader 和 Writer：这两个抽象类是字符流的基础，用于处理字符数据。它们基于InputStream和OutputStream进行了字符编码的处理，更适合处理文本。例如，FileReader和FileWriter分别用于从文件读取和向文件写入字符数据。
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CharacterStreamExample {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("input.txt");
             FileWriter fw = new FileWriter("output.txt")) {
            int character;
            while ((character = fr.read()) != -1) {
                fw.write(character);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这里FileReader从input.txt文件读取字符数据，FileWriter将字符写入output.txt文件。read()方法读取一个字符，返回值为字符的Unicode码点，如果到达流末尾则返回 -1。

Java BIO 在文件操作中的应用

读取文件内容

  1. 字节流读取文件：使用FileInputStream可以读取二进制文件或文本文件的字节数据。对于文本文件，读取后可能需要进行字符编码转换。
import java.io.FileInputStream;
import java.io.IOException;

public class ByteFileReadExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("image.jpg")) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                // 处理读取到的字节数据，这里可以进行数据传输等操作
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，创建了一个大小为1024字节的缓冲区buffer，read(buffer)方法将文件中的字节数据读取到缓冲区中，返回值为实际读取到的字节数。通过循环不断读取，直到文件末尾。

  1. 字符流读取文件：FileReader用于读取文本文件，它会自动根据系统默认字符编码将字节转换为字符。
import java.io.FileReader;
import java.io.IOException;

public class CharacterFileReadExample {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("text.txt")) {
            char[] buffer = new char[1024];
            int charactersRead;
            while ((charactersRead = fr.read(buffer)) != -1) {
                String text = new String(buffer, 0, charactersRead);
                System.out.print(text);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这里FileReader将文本文件中的字符读取到字符数组buffer中，read(buffer)返回实际读取到的字符数。通过new String(buffer, 0, charactersRead)将读取到的字符转换为字符串并输出。

写入文件内容

  1. 字节流写入文件：FileOutputStream用于将字节数据写入文件。如果文件不存在，会自动创建；如果文件已存在，默认会覆盖原有内容。
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteFileWriteExample {
    public static void main(String[] args) {
        byte[] data = "Hello, BIO!".getBytes();
        try (FileOutputStream fos = new FileOutputStream("output.txt")) {
            fos.write(data);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这段代码将字符串"Hello, BIO!"转换为字节数组，然后使用FileOutputStream将字节数组写入output.txt文件。

  1. 字符流写入文件：FileWriter用于将字符数据写入文件，同样会根据系统默认字符编码进行转换。
import java.io.FileWriter;
import java.io.IOException;

public class CharacterFileWriteExample {
    public static void main(String[] args) {
        String text = "Hello, BIO in characters!";
        try (FileWriter fw = new FileWriter("output.txt")) {
            fw.write(text);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这里直接将字符串text通过FileWriter写入output.txt文件。

追加内容到文件

  1. 字节流追加：通过在FileOutputStream的构造函数中传入第二个参数true，可以实现追加模式。
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteFileAppendExample {
    public static void main(String[] args) {
        byte[] data = "Appending with byte stream".getBytes();
        try (FileOutputStream fos = new FileOutputStream("output.txt", true)) {
            fos.write(data);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  1. 字符流追加：FileWriter同样支持追加模式，在构造函数中传入true。
import java.io.FileWriter;
import java.io.IOException;

public class CharacterFileAppendExample {
    public static void main(String[] args) {
        String text = "Appending with character stream";
        try (FileWriter fw = new FileWriter("output.txt", true)) {
            fw.write(text);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Java BIO 在网络编程中的应用

基于TCP的Socket编程

  1. 服务器端实现：使用ServerSocket监听指定端口，当有客户端连接时，创建一个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 TCPServer {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(8080)) {
            System.out.println("Server started on port 8080");
            while (true) {
                try (Socket clientSocket = serverSocket.accept()) {
                    System.out.println("Client connected: " + clientSocket);
                    BufferedReader in = new BufferedReader(
                            new InputStreamReader(clientSocket.getInputStream()));
                    PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
                    String inputLine;
                    while ((inputLine = in.readLine()) != null) {
                        System.out.println("Received from client: " + inputLine);
                        out.println("Echo: " + inputLine);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，ServerSocket监听8080端口。当有客户端连接时，serverSocket.accept()方法返回一个Socket对象，通过这个Socket对象获取输入流和输出流，使用BufferedReader读取客户端发送的文本数据，使用PrintWriter向客户端发送响应数据。

  1. 客户端实现：使用Socket类连接到服务器端指定的IP地址和端口，进行数据的发送和接收。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class TCPClient {
    public static void main(String[] args) {
        try (Socket socket = new Socket("localhost", 8080)) {
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            BufferedReader in = new BufferedReader(
                    new InputStreamReader(socket.getInputStream()));
            BufferedReader stdIn = new BufferedReader(
                    new InputStreamReader(System.in));
            String userInput;
            while ((userInput = stdIn.readLine()) != null) {
                out.println(userInput);
                System.out.println("Server response: " + in.readLine());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这里客户端连接到本地服务器的8080端口，从控制台读取用户输入，通过PrintWriter发送到服务器，然后使用BufferedReader读取服务器的响应并输出。

基于UDP的Socket编程

  1. 服务器端实现：使用DatagramSocket监听指定端口，接收DatagramPacket数据包。
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UDPServer {
    public static void main(String[] args) {
        try (DatagramSocket socket = new DatagramSocket(8888)) {
            byte[] receiveBuffer = new byte[1024];
            DatagramPacket receivePacket = new DatagramPacket(receiveBuffer, receiveBuffer.length);
            socket.receive(receivePacket);
            String message = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("Received from client: " + message);
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

DatagramSocket监听8888端口，创建一个DatagramPacket用于接收数据，socket.receive(receivePacket)方法阻塞等待数据包的到来，接收到数据包后将其内容转换为字符串输出。

  1. 客户端实现：使用DatagramSocket发送DatagramPacket数据包到服务器端。
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.SocketTimeoutException;

public class UDPClient {
    public static void main(String[] args) {
        String message = "Hello, UDP Server!";
        try (DatagramSocket socket = new DatagramSocket()) {
            InetAddress serverAddress = InetAddress.getByName("localhost");
            byte[] sendBuffer = message.getBytes();
            DatagramPacket sendPacket = new DatagramPacket(sendBuffer, sendBuffer.length, serverAddress, 8888);
            socket.send(sendPacket);
            byte[] receiveBuffer = new byte[1024];
            DatagramPacket receivePacket = new DatagramPacket(receiveBuffer, receiveBuffer.length);
            socket.setSoTimeout(2000);
            try {
                socket.receive(receivePacket);
                String response = new String(receivePacket.getData(), 0, receivePacket.getLength());
                System.out.println("Server response: " + response);
            } catch (SocketTimeoutException e) {
                System.out.println("Timeout waiting for server response");
            }
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端创建一个DatagramSocket，将消息转换为字节数组并封装成DatagramPacket发送到服务器的8888端口。同时设置了2秒的超时时间来接收服务器的响应。

Java BIO 在缓冲区处理中的应用

缓冲流的使用

  1. 字节缓冲流：BufferedInputStream和BufferedOutputStream用于字节流的缓冲。通过缓冲，减少了实际的I/O操作次数，提高了性能。
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteBufferedStreamExample {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.txt"));
             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.txt"))) {
            int data;
            while ((data = bis.read()) != -1) {
                bos.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，BufferedInputStream从input.txt文件读取字节数据，BufferedOutputStream将字节数据写入output.txt文件。缓冲流内部维护一个缓冲区，当缓冲区满时才进行实际的I/O操作。

  1. 字符缓冲流：BufferedReader和BufferedWriter用于字符流的缓冲，它们提供了更高效的字符读取和写入方法。
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CharacterBufferedStreamExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("input.txt"));
             BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这里BufferedReader逐行读取input.txt文件的内容，BufferedWriter将读取到的内容逐行写入output.txt文件，并使用newLine()方法写入换行符。

自定义缓冲区

在某些情况下，可能需要自定义缓冲区来满足特定的需求。例如，在处理大文件时，可以根据实际情况调整缓冲区的大小。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CustomBufferExample {
    public static void main(String[] args) {
        int bufferSize = 4096; // 自定义缓冲区大小为4KB
        byte[] buffer = new byte[bufferSize];
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这段代码创建了一个大小为4KB的自定义字节缓冲区，通过FileInputStream读取文件数据到缓冲区，再由FileOutputStream将缓冲区中的数据写入目标文件。

Java BIO 的性能优化与局限性

性能优化

  1. 合理使用缓冲区：如前文所述，缓冲流可以显著提高I/O性能。在进行文件读写或网络通信时，应优先使用缓冲流。对于大文件的读写，适当增大缓冲区的大小也能进一步提升性能，但需要注意不要占用过多内存。

  2. 减少I/O操作次数：尽量批量处理数据，而不是每次只读写少量数据。例如，在网络编程中，将多个小的数据包合并成一个大的数据包发送，减少网络传输的开销。

  3. 优化线程管理：在多线程环境下使用BIO时，合理管理线程池，避免线程过多导致的上下文切换开销。例如，可以根据系统资源和并发请求的数量来调整线程池的大小。

局限性

  1. 阻塞问题：BIO的阻塞特性导致在进行I/O操作时，线程会被阻塞，无法执行其他任务。在高并发场景下，大量线程可能会被阻塞在I/O操作上，导致系统资源浪费和性能下降。

  2. 资源消耗：每个连接都需要一个独立的线程来处理I/O操作，随着并发连接数的增加，线程数量也会相应增加，这会消耗大量的系统资源，如内存和CPU。

  3. 可扩展性差：由于上述阻塞和资源消耗问题，BIO在处理高并发、大规模连接时，可扩展性较差，难以满足现代互联网应用的需求。

尽管BIO存在这些局限性，但在一些简单场景或对性能要求不高的情况下，仍然可以发挥其作用，并且它作为Java I/O编程的基础，对于理解后续的NIO（Non - Blocking I/O）和AIO（Asynchronous I/O）模型也有重要意义。