Cụm bài Java cơ bản: 1. JVM và JDK · 2. Hello World và ba loại lỗi · 3. Biến và kiểu dữ liệu · 4. Toán tử và rẽ nhánh · 5. Vòng lặp và hàm · 6. Mảng và chuỗi · 7. Console và file text · 8. Byte stream và serialization
Bài trước chỉ đọc ghi text; bài này nhìn vào cả hệ class java.io bên dưới. Đọc xong, bạn biết vì sao “đọc file” có năm, sáu cách viết, chọn cách nào trong code thật, và vì sao serialization có sẵn của Java là rủi ro bảo mật. Đây là bài cuối cụm Java cơ bản; tiếp theo có thể đọc OOP.
1. Byte stream và character stream
Ý chính: ổ đĩa và mạng chỉ biết byte; ký tự chỉ có khi giải mã byte theo một charset (bảng mã, ví dụ UTF-8). Java tách hai tầng này thành hai họ class, và ghép chúng bằng cách bọc lồng nhau.
| Byte stream | Character stream | |
|---|---|---|
| Lớp gốc | InputStream / OutputStream |
Reader / Writer |
| Đơn vị | byte (read() trả về 0–255, hết dữ liệu thì -1) |
char UTF-16 (read() trả về mã ký tự, hết thì -1) |
| Dùng cho | Ảnh, audio, video, zip, PDF, dữ liệu nhị phân bất kỳ | Text: .txt, .csv, .json, .html |
| Làm việc với file | FileInputStream, FileOutputStream |
FileReader, FileWriter |
| Có buffer | BufferedInputStream, BufferedOutputStream |
BufferedReader (readLine), BufferedWriter (newLine) |
| Cầu nối | InputStreamReader (byte → char), OutputStreamWriter (char → byte) |
Cách bọc lồng là mẫu Decorator: mỗi lớp thêm một khả năng (buffer, giải mã charset, định dạng) mà vẫn giữ cùng kiểu InputStream/Reader. Đóng lớp ngoài cùng là đủ, nó đóng các lớp bên trong.
flowchart LR
F["FileInputStream<br/>đọc byte từ file"] --> R["InputStreamReader<br/>giải mã byte → char theo UTF-8"]
R --> B["BufferedReader<br/>gom thành khối, có readLine()"]
B --> P["Code của bạn"]
// Đọc text từ một InputStream bất kỳ (file, socket, HTTP body), chỉ rõ charset
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(new FileInputStream("vi.txt"), StandardCharsets.UTF_8))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
}
InputStreamReader là nơi charset được áp dụng. Sai charset không ném exception, chỉ làm hỏng dữ liệu: file UTF-8 đọc bằng ISO-8859-1 biến "Xin chào Việt Nam" thành "Xin chà o Viá»t Nam".
FileReader/FileWriter trước và sau Java 11
Trước Java 11, FileReader/FileWriter không nhận tham số charset và luôn dùng bảng mã mặc định của máy, nên cùng một code chạy khác nhau giữa Windows và Linux. Từ Java 11 đã có constructor nhận Charset. Với code cũ, bọc InputStreamReader/OutputStreamWriter với StandardCharsets.UTF_8 như ví dụ trên.
2. Buffer: vì sao đọc từng byte lại chậm
Ý chính: mỗi FileInputStream.read() một byte là một system call (lời gọi xuống hệ điều hành, phải chuyển từ user mode sang kernel mode). Buffer gom 8 KB một lần nên số system call giảm từ một mỗi byte xuống một mỗi khối.
- File 20 MB đọc từng byte: khoảng 20 triệu system call để đọc, 20 triệu nữa để ghi.
BufferedInputStreamđọc một khối 8 KB vào RAM; cácread()sau lấy từ mảng đó, hết khối mới gọi xuống OS.BufferedOutputStreamgom đầy 8 KB (hoặc tớiflush()/close()) rồi ghi một lần.
Giống đi chợ: mua cả giỏ một lần thay vì chạy ra chợ cho từng quả trứng.
Một system call đi qua những tầng nào (user mode, kernel, page cache, DMA) và vì sao đọc từng byte vẫn chậm cả khi file đã nằm sẵn trong page cache được đo lại ở I/O model: blocking, epoll và file descriptor.
3. Serialization
Ý chính: serialization biến object thành dãy byte (để ghi file, gửi mạng, đưa vào cache); deserialization dựng lại object từ dãy byte đó. Cơ chế có sẵn của Java (ObjectOutputStream/ObjectInputStream) dễ vỡ và nguy hiểm, nên mặc định dùng JSON hoặc Protobuf.
class User implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private transient String password; // không được ghi ra
private transient int loginCount = 5; // đọc lại sẽ là 0, không phải 5
}
try (var out = new ObjectOutputStream(Files.newOutputStream(Path.of("user.bin")))) {
out.writeObject(user);
}
try (var in = new ObjectInputStream(Files.newInputStream(Path.of("user.bin")))) {
User u = (User) in.readObject(); // password = null, loginCount = 0
}
Serializablelà marker interface (interface không có method, chỉ để đánh dấu). Mọi field khôngtransientcũng phải serializable, nếu không sẽ cóNotSerializableExceptionlúc chạy.transientloại field khỏi dữ liệu (mật khẩu, cache, connection). Đọc lại thì field mang giá trị mặc định (null/0/false), không chạy initializer hay constructor.serialVersionUIDlà số phiên bản của class. Số trong dữ liệu khác số trong class hiện tại thì némInvalidClassException. Luôn khai báo tường minh.- Ngày nay hiếm khi tự gọi
ObjectOutputStream; bạn gặp nó gián tiếp qua Spring Session hay cache dùngJdkSerializationRedisSerializer, RMI, hệ thống cũ.
Chi tiết serialVersionUID và exception
- Không khai báo thì JVM tự tính số từ cấu trúc class, nên thêm một method hay field cũng có thể làm file cũ không đọc được nữa.
- Giá trị nào cũng được (
1Llà phổ biến), các class khác nhau trùng số cũng không sao; chỉ đổi số khi cố ý muốn phá tương thích. - IDE cảnh báo thiếu
serialVersionUIDtrên custom exception vìThrowableimplementSerializable, nên mọi exception đều serializable.
Record khi deserialize: an toàn hơn class thường
Bài tập
Đề đã được viết lại ngắn gọn theo cách của mình. Code đã chạy thử trên JDK 21.
1. Copy một file mp3 bằng BufferedInputStream/BufferedOutputStream và đo thời gian. Mở file nguồn bằng FileInputStream bọc trong BufferedInputStream, file đích bằng FileOutputStream bọc trong BufferedOutputStream, đọc và ghi từng byte, đo thời gian và in Copy completed in XXX ms.
Lời giải Bài 1: ba cách copy, đo hai lượt, kiểm tra file giống hệt
Mình làm thêm hai cách nên dùng trong thực tế để so sánh, và kiểm tra file copy giống hệt file gốc.
import java.io.*;
import java.nio.file.*;
public class CopyTimer {
// Đúng như đề: bọc buffer rồi copy từng byte
static void copyByteByByte(Path src, Path dst) throws IOException {
try (InputStream in = new BufferedInputStream(new FileInputStream(src.toFile()));
OutputStream out = new BufferedOutputStream(new FileOutputStream(dst.toFile()))) {
int b;
while ((b = in.read()) != -1) {
out.write(b);
}
} // close() của BufferedOutputStream sẽ flush phần còn lại trong buffer
}
// Cách nên dùng khi phải copy giữa hai stream
static void copyWithTransferTo(Path src, Path dst) throws IOException {
try (InputStream in = Files.newInputStream(src);
OutputStream out = Files.newOutputStream(dst)) {
in.transferTo(out);
}
}
static void time(String label, Path src, Path dst, IOAction action) throws IOException {
long start = System.nanoTime(); // nanoTime đo khoảng thời gian; currentTimeMillis là giờ đồng hồ, có thể bị chỉnh
action.run(src, dst);
long ms = (System.nanoTime() - start) / 1_000_000;
boolean same = Files.mismatch(src, dst) == -1; // Java 12: -1 nghĩa là hai file giống hệt
System.out.printf("%-22s %6d ms, giống file gốc: %b%n", label, ms, same);
}
interface IOAction { void run(Path src, Path dst) throws IOException; }
public static void main(String[] args) throws IOException {
Path src = Path.of("input.mp3");
System.out.println("Kích thước: " + Files.size(src) + " bytes");
for (int round = 1; round <= 2; round++) { // chạy 2 lượt: lượt đầu còn tốn chi phí JIT và page cache
System.out.println("Lượt " + round);
time("buffered, từng byte", src, Path.of("copy1.mp3"), CopyTimer::copyByteByByte);
time("transferTo", src, Path.of("copy2.mp3"), CopyTimer::copyWithTransferTo);
time("Files.copy", src, Path.of("copy3.mp3"),
(s, d) -> Files.copy(s, d, StandardCopyOption.REPLACE_EXISTING));
}
}
}
File 20 MB, JDK 21, máy mình: lượt 1 là 230 ms / 7 ms / 4 ms, lượt 2 là 140 ms / 3 ms / 3 ms; cả ba bản copy đều giống hệt file gốc.
- Lượt đầu chậm hơn vì JIT chưa biên dịch vòng lặp và file chưa nằm trong page cache. Một lần đo đơn lẻ không đáng tin; đo nghiêm túc thì dùng JMH.
- Đề dùng
System.currentTimeMillis(). Đo khoảng thời gian nên dùngSystem.nanoTime():currentTimeMillislà giờ hệ thống, có thể nhảy khi NTP chỉnh giờ. - Code trong tài liệu gốc không đóng stream khi có lỗi (và còn thừa một dấu
)), nên rò rỉ file descriptor nếu copy hỏng giữa chừng. try-with-resources giải quyết việc đó. - Một senior chỉ viết
Files.copy(src, dst)cho file sang file,in.transferTo(out)cho stream sang stream, và kiểm tra dung lượng đĩa còn trống hoặc ghi ra file tạm rồi đổi tên nếu file đích đang được người khác đọc.
2. Đọc và ghi file nhị phân nhỏ bằng Files.
byte[] data = Files.readAllBytes(Path.of("logo.png")); // cả file vào bộ nhớ: chỉ dùng cho file nhỏ
System.out.println(data.length + " bytes, byte đầu tiên = " + data[0]); // byte có dấu: 0x89 in ra -119
Files.write(Path.of("sample.bin"), new byte[]{10, 20, 30, 40, 50});
Kiểu byte của Java có dấu (-128 tới 127), nên byte 0x89 ở đầu file PNG in ra -119. Muốn giá trị 0–255 thì dùng Byte.toUnsignedInt(data[0]) hoặc data[0] & 0xFF.
Ghi nhớ
- Giải thích được khi nào dùng byte stream, khi nào dùng
Reader/Writer, và charset được áp dụng ở đâu. - Vẽ lại được chuỗi Decorator
FileInputStream→InputStreamReader→BufferedReader. - Giải thích được vì sao đọc từng byte chậm, và biết chọn
Files.copyhaytransferTo. - Nói được
serialVersionUID,transientlàm gì, và giá trị của fieldtransientkhi đọc lại. - Giải thích được gadget chain, và biết thay Java serialization bằng gì hoặc chặn bằng
ObjectInputFilter.
Câu hỏi phỏng vấn
Junior
Byte stream và character stream khác nhau thế nào? Khi nào dùng loại nào?
Byte stream đọc ghi byte thô cho dữ liệu nhị phân; character stream làm việc với ký tự đã giải mã, dùng cho text.
Byte stream (InputStream/OutputStream) dùng cho ảnh, audio, zip. Character stream (Reader/Writer) giải mã theo một charset. InputStreamReader/OutputStreamWriter là cầu nối giữa hai loại, và nên luôn chỉ rõ charset (StandardCharsets.UTF_8).
Marker interface là gì? Serializable có method nào không?
Marker interface là interface không có method, chỉ đánh dấu class có một khả năng. Serializable không có method nào.
JVM hoặc thư viện kiểm tra dấu này lúc chạy: ObjectOutputStream kiểm tra instanceof Serializable, không có thì ném NotSerializableException. Cloneable cũng vậy. Ngày nay người ta thường dùng annotation cho mục đích này, vì annotation mang được thêm thông tin.
Mid
Vì sao copy file bằng read() từng byte lại chậm? BufferedInputStream giúp gì? Có dùng available() để biết kích thước file được không?
Mỗi read() là một system call; buffer gom 8 KB một lần để giảm số lời gọi. available() không cho biết kích thước file.
File 20 MB tốn hàng chục triệu lần chuyển sang kernel. BufferedInputStream đọc từng khối 8 KB vào RAM rồi phục vụ các lần read() từ đó. Trong code thật thì dùng in.transferTo(out) hoặc Files.copy. available() chỉ là ước lượng số byte đọc được mà không bị block, là int nên bị chặn ở 2 GB, và với socket thường là 0; kích thước file phải lấy bằng Files.size.
serialVersionUID và transient dùng để làm gì?
serialVersionUID là số phiên bản của class để kiểm tra tương thích khi đọc lại; transient loại một field khỏi dữ liệu serialize.
Số trong dữ liệu khác số của class hiện tại thì ném InvalidClassException. Không khai báo thì JVM tự tính từ cấu trúc class, nên một thay đổi nhỏ cũng phá tương thích; vì vậy nên khai báo tường minh. Field transient (mật khẩu, cache, connection) đọc lại mang giá trị mặc định, không chạy initializer.
Vì sao các class java.io lại được bọc lồng nhiều lớp?
Đó là mẫu Decorator: mỗi lớp bọc thêm đúng một khả năng mà vẫn giữ cùng kiểu (InputStream hoặc Reader).
FileInputStream đọc byte từ file, BufferedInputStream thêm buffer, InputStreamReader thêm việc giải mã charset, BufferedReader thêm readLine. Nhờ vậy có thể ghép tuỳ ý (buffer cho socket, giải nén GZIPInputStream cho HTTP body) mà không cần một class riêng cho mỗi tổ hợp. Đóng lớp ngoài cùng là đủ, nó đóng dây chuyền vào trong.
Senior
Vì sao Java serialization bị coi là rủi ro bảo mật? Nên dùng gì thay thế?
Vì readObject() dựng bất kỳ class nào trên classpath theo dữ liệu và chạy hook của chúng trước khi ép kiểu, nên có thể bị gadget chain thực thi mã từ xa. Thay bằng JSON hoặc Protobuf/Avro.
Ngoài ra định dạng này chỉ Java đọc được, dễ vỡ khi class thay đổi, và cồng kềnh. Với Jackson, tắt default typing đa hình. Nếu buộc phải dùng thì đặt allow-list bằng ObjectInputFilter (JEP 290), và ưu tiên record vì record đi qua canonical constructor khi deserialize.
Đo thời gian copy file (hay một đoạn code bất kỳ) thế nào cho đúng?
Dùng System.nanoTime(), chạy nhiều lần có warm-up, và dùng JMH cho micro-benchmark.
currentTimeMillis() có thể nhảy khi chỉnh giờ; nanoTime là đồng hồ đơn điệu. Bỏ các lần đầu để JIT kịp biên dịch; với I/O còn phải để ý page cache (lần đọc thứ hai không chạm tới đĩa). Đo trên cùng loại phần cứng và filesystem với production. JMH lo warm-up, fork JVM và tránh việc JIT loại bỏ code “không dùng tới”. Báo cáo phân phối (p50, p99), không chỉ một con số trung bình.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu dùng khi phỏng vấn |
|---|---|---|---|
| byte stream / character stream | luồng byte / luồng ký tự | “I use a byte stream for binary files and a reader with an explicit charset for text.” | |
| system call | /ˈsɪstəm kɔːl/ | lời gọi xuống hệ điều hành | “Buffering cuts the number of system calls from one per byte to one per block.” |
| serialization | /ˌsɪriəlaɪˈzeɪʃn/ | chuyển object thành dãy byte | “I’d rather use JSON than Java serialization for anything that crosses a trust boundary.” |
| gadget chain | /ˈɡædʒɪt tʃeɪn/ | chuỗi class bị lợi dụng khi deserialize | “Deserializing untrusted data can trigger a gadget chain and lead to remote code execution.” |
| decorator pattern | /ˈdekəreɪtər/ | mẫu bọc thêm chức năng | “java.io uses the decorator pattern: each wrapper adds one capability.” |
| marker interface | /ˈmɑːrkər/ | interface đánh dấu, không có method | “Serializable is a marker interface checked at runtime.” |
| transient | /ˈtrænʃnt/ | không được serialize | “I mark the password field transient so it never ends up in the stream.” |
| backward compatibility | /ˈbækwərd/ | tương thích ngược | “Changing serialVersionUID deliberately breaks backward compatibility.” |
Ghi chép dựa trên khoá Fundamentals of Backend (Ronin Engineer) và tài liệu Java Core của Hỏi Dân IT, cộng thêm kiến thức tự tìm hiểu, viết lại theo cách hiểu của mình.