Xử lý tệp tin và Serialization

import java.nio.file.*;

// --- Tạo Path ---
Path p1 = Path.of("du_lieu/bao_cao.csv");
Path p2 = Path.of("du_lieu", "2026", "bao_cao.csv");   // ⭐ đa nền tảng
Path p3 = Paths.get("a/b");                             // cách cũ, tương đương

// --- Thông tin đường dẫn (thuần tính toán, KHÔNG chạm đĩa) ---
p2.getFileName();       // bao_cao.csv
p2.getParent();         // du_lieu/2026
p2.getRoot();           // null (tương đối) hoặc / (tuyệt đối)
p2.getNameCount();      // 3
p2.getName(0);         // du_lieu
p2.toAbsolutePath();    // đường dẫn tuyệt đối
p2.normalize();         // bỏ . và ..
p2.resolve("con.txt");  // nối thêm
p1.relativize(p2);      // đường dẫn từ p1 tới p2

// ⭐ Mẫu vàng: định vị tệp cạnh mã nguồn / thư mục người dùng
Path home = Path.of(System.getProperty("user.home"));
Path hienTai = Path.of("").toAbsolutePath();   // thư mục làm việc
Path cauHinh = home.resolve(".myapp").resolve("config.json");

// --- Thao tác trên đĩa (đều ném IOException) ---
Files.exists(p1);
Files.isRegularFile(p1);
Files.isDirectory(p1);
Files.size(p1);                       // byte
Files.createDirectories(p1.getParent());   // tạo cả cây, không lỗi nếu đã có
Files.createFile(p1);
Files.delete(p1);                     // ném NoSuchFileException nếu không có
Files.deleteIfExists(p1);             // trả boolean, không ném
Files.copy(nguon, dich, StandardCopyOption.REPLACE_EXISTING);
Files.move(nguon, dich, StandardCopyOption.ATOMIC_MOVE);

import java.nio.charset.StandardCharsets;

Path p = Path.of("data.txt");

// --- ĐỌC (chỉ dùng cho tệp NHỎ — nạp hết vào RAM) ---
String noiDung = Files.readString(p);                       // Java 11+, UTF-8 mặc định
String nd2 = Files.readString(p, StandardCharsets.UTF_8);   // tường minh
List<String> dong = Files.readAllLines(p);
byte[] byteS = Files.readAllBytes(p);

// --- GHI ---
Files.writeString(p, "Xin chào");                          // Java 11+, GHI ĐÈ
Files.writeString(p, "thêm\n", StandardOpenOption.APPEND);   // nối vào cuối
Files.write(p, List.of("dòng 1", "dòng 2"));               // ghi nhiều dòng
Files.write(p, byteS);

// --- ⭐ ĐỌC LƯỜI: tệp LỚN hơn RAM ---
try (Stream<String> s = Files.lines(p)) {   // ⚠️ PHẢI đóng!
    long soLoi = s.filter(l -> l.contains("ERROR")).count();
}
// Chạy được với tệp 100 GB — mỗi lúc chỉ giữ một dòng trong bộ nhớ

// --- Duyệt thư mục ---
try (Stream<Path> s = Files.list(thuMuc)) {          // một cấp
    s.forEach(System.out::println);
}
try (Stream<Path> s = Files.walk(thuMuc)) {          // ĐỆ QUY
    s.filter(Files::isRegularFile)
     .filter(f -> f.toString().endsWith(".java"))
     .forEach(System.out::println);
}
try (Stream<Path> s = Files.find(thuMuc, 5,
        (path, attr) -> attr.size() > 1_000_000)) {          // tệp lớn hơn 1 MB
    s.forEach(System.out::println);
}

// --- Thư mục tạm ---
Path tam = Files.createTempFile("tien_to", ".tmp");
Path tmDir = Files.createTempDirectory("app");

// ❌ KHÔNG buffer: mỗi read() là MỘT lời gọi hệ thống
try (FileInputStream in = new FileInputStream("lon.txt")) {
    int c;
    while ((c = in.read()) != -1) { ... }
}
// Tệp 10 MB → 10 TRIỆU lời gọi hệ thống → mất hàng chục giây

// ✅ CÓ buffer: đọc 8 KB mỗi lần vào bộ nhớ, phục vụ read() từ đó
try (BufferedInputStream in =
        new BufferedInputStream(new FileInputStream("lon.txt"))) {
    int c;
    while ((c = in.read()) != -1) { ... }
}
// Tệp 10 MB → khoảng 1.250 lời gọi hệ thống → dưới một giây
// Nhanh hơn khoảng 50-100 lần chỉ nhờ một lớp bọc

// BufferedReader còn thêm readLine() — thứ Reader trần không có
try (BufferedReader br = Files.newBufferedReader(Path.of("a.txt"))) {
    String dong;
    while ((dong = br.readLine()) != null) {   // null = hết tệp
        System.out.println(dong);
    }
}

// ⚠️ Ghi có buffer: dữ liệu nằm trong bộ nhớ tới khi flush hoặc close
try (BufferedWriter bw = Files.newBufferedWriter(Path.of("ra.txt"))) {
    bw.write("Xin chào");
    bw.newLine();             // ký tự xuống dòng của hệ điều hành
    bw.flush();               // ép ghi xuống đĩa ngay
}   // try-with-resources tự flush + close ✅

// 💥 Quên đóng → dữ liệu KHÔNG BAO GIỜ xuống đĩa, tệp rỗng!

// --- Đọc CSV thành object (chưa dùng thư viện) ---
record SinhVien(String ma, String ten, double diem) { }

static List<SinhVien> docCsv(Path p) throws IOException {
    try (Stream<String> dong = Files.lines(p)) {
        return dong
            .skip(1)                              // bỏ dòng tiêu đề
            .filter(l -> !l.isBlank())
            .map(l -> l.split(",", -1))            // -1: giữ ô rỗng cuối
            .filter(c -> c.length >= 3)
            .map(c -> new SinhVien(c[0].trim(), c[1].trim(),
                                    Double.parseDouble(c[2].trim())))
            .toList();
    }
}

// --- Ghi CSV ---
static void ghiCsv(Path p, List<SinhVien> ds) throws IOException {
    try (BufferedWriter w = Files.newBufferedWriter(p)) {
        w.write("ma,ten,diem");
        w.newLine();
        for (SinhVien sv : ds) {
            w.write("%s,%s,%.2f".formatted(sv.ma(), sv.ten(), sv.diem()));
            w.newLine();
        }
    }
}

// --- ⭐ GHI AN TOÀN: tệp tạm rồi thay thế nguyên tử ---
static void ghiAnToan(Path dich, String noiDung) throws IOException {
    Path tam = dich.resolveSibling(dich.getFileName() + ".tmp");
    Files.writeString(tam, noiDung);
    Files.move(tam, dich,
        StandardCopyOption.REPLACE_EXISTING,
        StandardCopyOption.ATOMIC_MOVE);
}
// Chương trình sập giữa chừng → tệp gốc VẪN NGUYÊN VẸN,
// chỉ còn lại một tệp .tmp dở dang vô hại

// --- Sao chép tệp lớn theo khối ---
static void saoChep(Path nguon, Path dich) throws IOException {
    try (InputStream  in  = new BufferedInputStream(Files.newInputStream(nguon));
         OutputStream out = new BufferedOutputStream(Files.newOutputStream(dich))) {
        byte[] dem = new byte[8192];
        int n;
        while ((n = in.read(dem)) != -1) {
            out.write(dem, 0, n);     // ⚠️ PHẢI ghi đúng n byte, không phải cả mảng
        }
    }
}

// ✅ Hoặc để JDK lo (nhanh hơn, dùng tối ưu của hệ điều hành)
Files.copy(nguon, dich, StandardCopyOption.REPLACE_EXISTING);
in.transferTo(out);                      // Java 9+

// --- Đọc/ghi kiểu dữ liệu có cấu trúc ---
try (DataOutputStream out = new DataOutputStream(
        new BufferedOutputStream(Files.newOutputStream(p)))) {
    out.writeInt(42);
    out.writeDouble(3.14);
    out.writeUTF("Xin chào");       // độ dài + dữ liệu UTF-8
    out.writeBoolean(true);
}

try (DataInputStream in = new DataInputStream(
        new BufferedInputStream(Files.newInputStream(p)))) {
    int a     = in.readInt();      // ⚠️ PHẢI đọc ĐÚNG THỨ TỰ đã ghi
    double b  = in.readDouble();
    String c  = in.readUTF();
    boolean d = in.readBoolean();
}
// Sai thứ tự → dữ liệu rác, không có lỗi nào báo ra ⚠️

// --- Truy cập ngẫu nhiên: nhảy tới vị trí bất kỳ ---
try (RandomAccessFile raf = new RandomAccessFile("data.bin", "rw")) {
    raf.seek(100);              // nhảy tới byte thứ 100
    int x = raf.readInt();
    raf.seek(200);
    raf.writeInt(42);
    System.out.println(raf.length());
}

import java.io.*;

// ① Class PHẢI cài đặt Serializable — interface đánh dấu, không có method nào
public class SinhVien implements Serializable {

    // ② serialVersionUID — BẮT BUỘC khai báo, xem callout bên dưới
    @Serial
    private static final long serialVersionUID = 1L;

    private String ma;
    private String ten;
    private double diem;

    // ③ transient — KHÔNG serialize trường này
    private transient String matKhau;      // dữ liệu nhạy cảm
    private transient Connection ketNoi;    // không serialize được

    // ④ static KHÔNG BAO GIỜ được serialize (thuộc class, không thuộc instance)
    private static int soLuong;

    public SinhVien(String ma, String ten, double diem) { ... }
}


// --- GHI (serialization) ---
SinhVien sv = new SinhVien("SV001", "Việt Anh", 8.5);
try (ObjectOutputStream out = new ObjectOutputStream(
        new BufferedOutputStream(Files.newOutputStream(Path.of("sv.ser"))))) {
    out.writeObject(sv);
}

// --- ĐỌC (deserialization) ---
try (ObjectInputStream in = new ObjectInputStream(
        new BufferedInputStream(Files.newInputStream(Path.of("sv.ser"))))) {
    SinhVien doc = (SinhVien) in.readObject();   // ⚠️ phải ép kiểu
    System.out.println(doc);
} catch (ClassNotFoundException e) {
    // class không có trên classpath khi đọc
}
// ⚠️ Constructor KHÔNG được gọi khi deserialize!
//    JVM tạo object trực tiếp và điền từng trường.
//    matKhau và ketNoi sẽ là null; soLuong giữ giá trị hiện tại của class.

// ❌ CỰC KỲ NGUY HIỂM
ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
Object o = in.readObject();     // 💥 mã của kẻ tấn công có thể chạy NGAY TẠI ĐÂY

// Vì sao? readObject() phải TẠO object trước khi bạn kịp kiểm tra kiểu.
// Nếu classpath có một class nào đó thực thi code trong readObject(),
// readResolve(), hoặc thậm chí trong finalize() — kẻ tấn công lợi dụng được.
// Chuỗi các class như vậy gọi là "gadget chain", và chúng tồn tại trong
// nhiều thư viện phổ biến (Commons Collections, Spring, Groovy...).


// ⚠️ Giảm thiểu (Java 9+): lọc theo danh sách trắng
ObjectInputFilter loc = ObjectInputFilter.Config.createFilter(
    "com.vidu.model.*;java.util.*;!*"   // chỉ cho các gói này, cấm phần còn lại
);
in.setObjectInputFilter(loc);

// ✅✅ GIẢI PHÁP THẬT: đừng dùng Java serialization cho dữ liệu bên ngoài.
//     Dùng JSON, Protocol Buffers, hoặc định dạng riêng.

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.18.2</version>
</dependency>
<!-- Hỗ trợ java.time (LocalDate...) -->
<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jsr310</artifactId>
    <version>2.18.2</version>
</dependency>

import com.fasterxml.jackson.databind.*;

record SinhVien(String ma, String ten, double diem, LocalDate ngaySinh) { }
// ⭐ record hoạt động thẳng với Jackson — không cần getter/setter hay annotation

ObjectMapper mapper = new ObjectMapper()
    .registerModule(new JavaTimeModule())               // cho LocalDate
    .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
    .enable(SerializationFeature.INDENT_OUTPUT);         // in đẹp

// --- Object → JSON ---
SinhVien sv = new SinhVien("SV001", "Việt Anh", 8.5, LocalDate.of(2004, 1, 14));
String json = mapper.writeValueAsString(sv);
mapper.writeValue(Path.of("sv.json").toFile(), sv);
// {
//   "ma" : "SV001",
//   "ten" : "Việt Anh",
//   "diem" : 8.5,
//   "ngaySinh" : "2004-01-14"
// }

// --- JSON → Object ---
SinhVien doc = mapper.readValue(json, SinhVien.class);

// --- Danh sách: cần TypeReference vì type erasure (chương 9!) ---
List<SinhVien> ds = mapper.readValue(jsonMang,
    new TypeReference<List<SinhVien>>() {});

// --- Đọc JSON không có class tương ứng ---
JsonNode goc = mapper.readTree(json);
String ten = goc.get("ten").asText();
double d   = goc.path("diem").asDouble(0);      // path() an toàn với khoá thiếu

// --- Bỏ qua trường lạ trong JSON (rất quan trọng khi gọi API) ---
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);