Đến nội dung chính
Sổ ôn Backend

Tìm kiếm

Ôn tập

Khung Nhớ nhanh của mọi bài, xếp theo roadmap. Học chắc phần lõi trước; bấm tiêu đề để đọc bài.

1. Java cơ bản

JDK, JRE, JVM

Java cơ bản: JVM, JDK, các bản LTS và Java được dùng ở đâu
  • javac dịch code ra bytecode; JVM của từng nền tảng chạy bytecode đó. Nhờ JVM mà "viết một lần, chạy mọi nơi", không phải nhờ ngôn ngữ bậc cao.
  • JVM thông dịch trước, rồi JIT biên dịch code nóng ra mã máy: khởi động chậm, chạy lâu thì nhanh (cần warm-up).
  • JVM ⊂ JRE (JVM + thư viện chuẩn) ⊂ JDK (JRE + javac, jar, jshell...).
  • Các bản LTS: 8, 11, 17, 21, 25. Từ 17 cứ 2 năm một bản; bản thường chỉ được vá 6 tháng.
  • Dự án mới: LTS mới nhất mà thư viện đã hỗ trợ (25, hoặc 21), và ghim phiên bản trong build và Docker.
  • Bẫy hay gặp: Java không thuần OOP (8 kiểu nguyên thuỷ không phải object), và "an toàn nhờ sandbox" đã lỗi thời.

Hình dung: bytecode như bản nhạc viết một lần; mỗi nền tảng có một nhạc công (JVM) riêng đọc nó, chơi vài lần là thuộc và chơi nhanh hơn (JIT).

Java cơ bản: Hello World, biên dịch, ba loại lỗi và bài tập đầu tiên
flowchart LR
  SRC["Greeting.java"] -->|javac| BC["Greeting.class"]
  BC -->|"java Greeting"| JVM[JVM chạy main]
  SRC -.->|javac bắt| E1[Lỗi biên dịch]
  JVM -.->|exception| E2[Lỗi runtime]
  JVM -.->|"im lặng, kết quả sai"| E3[Lỗi logic]
  E3 --> X["7 / 2 == 3, tràn int"]
  • Một file có tối đa một class public, tên file trùng tên class. main là public static void vì JVM gọi nó khi chưa có object.
  • javac Greeting.java sinh bytecode Greeting.class; java Greeting nhận tên class, không nhận Greeting.class.
  • Ba loại lỗi: biên dịch (javac bắt), runtime (exception lúc chạy), logic (không báo gì, chỉ sai kết quả, nguy hiểm nhất).
  • Bẫy số 1: hai int chia nhau là chia nguyên: 7 / 2 == 3, 1/3 == 0. Một vế là số thực thì mới ra số thực.
  • int * int tràn thì quay vòng âm thầm: 1_000_000 * 1_000_001 ra số âm. Dùng long hoặc Math.multiplyExact.
  • 1 / 0 ném ArithmeticException, còn 1.0 / 0 ra Infinity. double không so bằng ==, so bằng ngưỡng.

Hình dung: javac là người dịch sách sang ngôn ngữ chung (bytecode), java là người đọc bản dịch đó; lỗi biên dịch là người dịch từ chối, lỗi runtime là người đọc vấp giữa chừng, lỗi logic là đọc trôi chảy một câu chuyện sai.

Kiểu dữ liệu, toán tử, điều kiện

Java cơ bản: biến, kiểu dữ liệu và ép kiểu
  • 8 kiểu nguyên thuỷ: byte, short, int, long, float, double, char, boolean. String là class, không phải primitive.
  • Biến primitive chứa luôn giá trị; biến reference chỉ chứa địa chỉ của object trên heap.
  • Wrapper (Integer...) cho phép dùng với collection và null, đổi lại tốn bộ nhớ. Unboxing null ném NullPointerException.
  • Biến cục bộ không có giá trị mặc định; chỉ field và phần tử mảng mới có.
  • Ép kiểu thu hẹp ((int) 3.99, (byte) 200) mất dữ liệu không cảnh báo. Dùng Math.toIntExact khi cần an toàn.
  • Bẫy số 1: tiền không dùng double (0.1 + 0.2 = 0.30000000000000004), dùng BigDecimal hoặc long theo đơn vị nhỏ nhất.

Hình dung: kiểu dữ liệu là loại cốc. Rót sang cốc nhỏ hơn (ép kiểu thu hẹp) thì phần tràn ra mất luôn, và Java không báo gì.

Java cơ bản: toán tử, if và switch
mindmap
  root((Toán tử và rẽ nhánh))
    Số học
      Chia nguyên cắt về 0
      Số dư mang dấu số bị chia
      Tràn số quay vòng
    == trên object so địa chỉ
    && và || ngắn mạch
    a++ trả giá trị cũ
    Rẽ nhánh
      if: điều kiện bất kỳ
      switch: giá trị cụ thể
  • Chia số nguyên cắt về phía 0; % mang dấu số bị chia (-7 % 2 == -1). Cần số dư không âm thì dùng Math.floorMod.
  • &&/|| ngắn mạch: vế phải chỉ chạy khi cần, nên user != null && user.isActive() an toàn.
  • Bẫy số 1: == trên object so địa chỉ, nên Integer 128 == 128 là false. So wrapper luôn bằng equals.
  • a++ trả giá trị cũ, ++a trả giá trị mới; x = x++ giữ nguyên x; count++ không atomic.
  • int có 32 bit, lưu theo bù hai: MAX_VALUE + 1 quay về MIN_VALUE, ~x == -x - 1.
  • s += 1 có ép kiểu ngầm nên biên dịch được; s = s + 1 với short thì không.
  • if cho điều kiện bất kỳ, switch expression (Java 14+) cho giá trị/kiểu cụ thể; chuỗi nhánh theo "loại" dài ra thì chuyển sang đa hình.

Hình dung: toán tử chạy trên 32 ô bit của máy chứ không phải số trên giấy: tràn thì quay vòng, chia thì cắt, còn == hỏi "cùng một cái hộp?" chứ không hỏi "cùng nội dung?".

Vòng lặp, hàm, mảng, chuỗi

Java cơ bản: vòng lặp, hàm, call stack và pass-by-value
  • while kiểm tra trước (có thể chạy 0 lần), do-while chạy trước (ít nhất 1 lần), for gom khởi tạo; điều kiện; cập nhật.
  • Sau continue: for chạy i++ rồi mới kiểm tra; while/do-while nhảy thẳng tới điều kiện. Bẫy số 1: continue bỏ qua lệnh tăng biến, lặp vô hạn.
  • Hai vòng lồng nhau thường là O(n²); với n = 10⁵ là 10¹⁰ phép tính, không chạy kịp.
  • Mỗi lời gọi hàm đẩy một stack frame (tham số, biến cục bộ, địa chỉ quay về) lên stack của thread; đệ quy quá sâu gây StackOverflowError.
  • Java chỉ có pass-by-value: với object, thứ được sao chép là tham chiếu. Sửa nội dung object thì caller thấy, gán lại tham số thì không.
  • Trade-off API: hàm âm thầm sửa tham số đầu vào là side effect dễ gây bug; nên trả về giá trị mới hoặc ghi rõ trong tên (sortInPlace).

Hình dung: truyền object vào hàm giống đưa người khác bản photo địa chỉ nhà bạn. Họ đến sơn lại nhà thì bạn thấy, còn họ sửa địa chỉ trên tờ giấy thì nhà bạn không chuyển đi đâu.

Java cơ bản: mảng và chuỗi
  • Mảng: kích thước cố định, cùng kiểu, nằm liền nhau, chỉ số từ 0 tới length - 1. Truy cập O(1), ngoài biên ném ArrayIndexOutOfBoundsException.
  • array.length là field; string.length() và list.size() là method.
  • Mảng 2D là mảng của các mảng: các hàng có thể dài khác nhau (răng cưa), duyệt theo hàng nhanh hơn theo cột.
  • Arrays.copyOf/clone() chỉ copy nông. So sánh mảng bằng Arrays.equals, in bằng Arrays.toString/deepToString.
  • String bất biến: so sánh nội dung bằng equals (hằng số bên trái), nối trong vòng lặp bằng StringBuilder (tránh O(n²)).
  • Trade-off: mảng nhanh, gọn nhưng không co giãn; cần co giãn thì dùng ArrayList (cũng là mảng, đầy thì copy sang mảng lớn hơn).
  • Bẫy số 1: == với chuỗi đôi khi "tình cờ" đúng nhờ string pool. Ngoài ra split nhận regex, toUpperCase() phụ thuộc locale.

Hình dung: mảng như dãy tủ khoá đánh số ở phòng gym: biết số tủ là đi thẳng tới, nhưng không gắn thêm tủ vào dãy được.

Nhập xuất, file, serialization

Java cơ bản: nhập xuất console và đọc ghi file text
  • printf dùng %n thay cho \n; String.format/formatted cùng cú pháp nhưng trả về chuỗi. Log thật thì dùng logger, không dùng System.out.
  • Bẫy nextInt() rồi nextLine(): ký tự xuống dòng còn sót làm nextLine() trả chuỗi rỗng. Cách chắc nhất: luôn đọc cả dòng rồi tự parse.
  • FileWriter, PrintWriter, Files.write mặc định ghi đè; muốn ghi nối phải nói rõ (true hoặc APPEND).
  • PrintWriter nuốt lỗi ghi, chỉ bật cờ checkError(); dữ liệu quan trọng thì dùng Files.newBufferedWriter (ném IOException).
  • Mở ở đâu đóng ở đó bằng try-with-resources, kể cả Files.lines/Files.walk. Quên đóng thì cạn file descriptor: "Too many open files".
  • Trade-off chính: file nhỏ thì readAllLines/readString (đọc hết vào RAM), file lớn thì Files.lines/BufferedReader (đọc lười, RAM không đổi).
  • Luôn ghi rõ StandardCharsets.UTF_8; ghi an toàn thì ghi file tạm cùng thư mục rồi ATOMIC_MOVE.

Hình dung: file descriptor như chìa khoá phòng mà lễ tân (hệ điều hành) chỉ có số lượng hạn chế; try-with-resources là quy tắc luôn trả chìa khi ra khỏi phòng, dù đi bình thường hay chạy ra vì báo cháy.

Java I/O: byte stream, buffer và serialization
  • Byte stream (InputStream/OutputStream) cho dữ liệu nhị phân; character stream (Reader/Writer) cho text, luôn chỉ rõ charset.
  • java.io ghép class theo mẫu Decorator: mỗi lớp bọc thêm một khả năng; đóng lớp ngoài cùng là đủ.
  • Đọc từng byte không buffer = một system call mỗi byte: copy 20 MB mất ~37 giây thay vì vài ms.
  • Code thật: Files.copy cho file sang file, in.transferTo(out) cho stream sang stream.
  • available() không phải kích thước file; dùng Files.size.
  • serialVersionUID khai báo tường minh; transient loại field khỏi dữ liệu, đọc lại thành giá trị mặc định.
  • Bẫy số 1: deserialize dữ liệu không tin cậy bằng ObjectInputStream có thể bị thực thi mã từ xa. Mặc định dùng JSON hoặc Protobuf.

Hình dung: byte stream là đường ống chở byte; mỗi lớp bọc là một khớp nối thêm vào ống (bể chứa, bộ chuyển đổi), đầu ra vẫn là một đoạn ống cùng kiểu.

OOP: 4 tính chấtLõi

Lập trình hướng đối tượng: class, object, constructor, static và access modifier
  • Class là khuôn, object là một instance đúc từ khuôn, có trạng thái, hành vi và định danh riêng.
  • Constructor trùng tên class, không có kiểu trả về; viết bất kỳ constructor nào là mất default constructor.
  • Constructor phải làm object hợp lệ ngay khi sinh ra (kiểm tra invariant).
  • static thuộc về class: một bản dùng chung, không có this.
  • Bốn mức truy cập: private < default (package) < protected < public. Bắt đầu từ private.
  • Bẫy số 1: protected mở cho cả package, không chỉ lớp con. Bẫy số 2: static mutable state là biến toàn cục trá hình.

Hình dung: class là khuôn bánh, object là từng cái bánh; access modifier là cửa phòng: khoá (private), mở cho người trong nhà (package), cho con cháu (protected) hay cho mọi người (public).

Lập trình hướng đối tượng: object bất biến, equals/hashCode và final
flowchart TD
  I[Class bất biến] --> I1["private final, không setter"]
  I --> I2[Class final]
  I --> I3[Copy phòng thủ]
  I --> R["record: bất biến nông"]
  E[Override equals] -->|bắt buộc| H[Override hashCode]
  H --> HM["HashMap/HashSet chạy đúng"]
  FN[final] --> FR["Khoá tham chiếu, không object"]
  ST[static] --> SC["Thuộc class hay object"]
  SF["Hằng static final"] -.->|bẫy| IN["Bị chép vào nơi dùng"]
  • Class bất biến: field private final, không setter, class final, copy phòng thủ field có thể sửa.
  • record (Java 16+) cho class bất biến trong một dòng, nhưng chỉ bất biến nông: vẫn phải List.copyOf.
  • Override equals thì bắt buộc override hashCode, nếu không HashMap/HashSet chạy sai.
  • final khoá tham chiếu, không khoá object: final List vẫn add được.
  • static và final là hai trục độc lập: "thuộc class hay object" và "gán lại được không".
  • Bẫy số 1: hằng static final kiểu nguyên thuỷ/String bị chép vào class dùng nó; không biên dịch lại thì nơi dùng vẫn thấy giá trị cũ.

Hình dung: object bất biến như tờ hoá đơn đã in: muốn sửa thì in tờ mới, tờ cũ ai cầm cũng yên tâm.

Lập trình hướng đối tượng: kế thừa, đóng gói và đa hình
  • Kế thừa là quan hệ "is-a" và là liên kết chặt nhất giữa hai class. Mặc định ưu tiên composition.
  • Lớp con phải thay được lớp cha mà không sai hành vi (Liskov). Square extends Rectangle có setter là phản ví dụ kinh điển.
  • Đóng gói = giữ invariant bằng hành vi (withdraw), không phải getter/setter cho mọi field.
  • Overload chọn lúc biên dịch theo kiểu khai báo của đối số; override chọn lúc chạy theo kiểu thật của object.
  • Kiểu khai báo quyết định gọi được gì, kiểu thật quyết định bản nào chạy. Field và method static không có đa hình (chỉ bị che).
  • Bẫy số 1: list.remove(1) trên List<Integer> xoá theo vị trí, không theo giá trị.

Hình dung: lời gọi shape.area() giống bấm nút "phát" trên điều khiển: cùng một nút, nhưng TV, loa hay máy chiếu tự biết mình phải làm gì.

Lập trình hướng đối tượng: abstract class, interface và thứ tự khởi tạo
  • Abstract class: có field, constructor, method có thân; chỉ extends được một. Dùng cho các lớp con cùng họ chia sẻ code và trạng thái.
  • Interface: hợp đồng "làm được gì", không có trạng thái instance; một class implements được nhiều. Từ Java 8 có default/static, Java 9 có private method.
  • Hai interface cùng default method: class bắt buộc override, gọi lại bằng A.super.method(). Method của class luôn thắng default.
  • Sealed interface (Java 17) giới hạn ai được cài đặt, nên switch được compiler kiểm tra đủ trường hợp.
  • Thứ tự khởi tạo: static trước instance, cha trước con, initializer trước thân constructor. Phần static chỉ chạy một lần.
  • Bẫy số 1: constructor cha gọi method bị lớp con override, bản override đọc field của con khi còn null/0.

Hình dung: interface là tiêu chuẩn ổ cắm điện, abstract class là khung máy chung của một dòng sản phẩm. Thiết bị nào đúng phích cắm cũng dùng được ổ, còn chỉ máy cùng dòng mới chung được khung.

Thiết kế class, UML

Lập trình hướng đối tượng: UML class diagram và 6 quan hệ giữa các class
  • Class diagram: hộp 3 ngăn (tên, thuộc tính, method); + public, - private, # protected, ~ package-private, gạch chân = static.
  • 6 quan hệ, từ gắn chặt tới lỏng: kế thừa ≈ triển khai > composition > aggregation > association > dependency.
  • Composition (thoi đặc): tổng thể tự tạo phần, phần chết theo. Aggregation (thoi rỗng): phần tạo ở ngoài rồi truyền vào, sống độc lập.
  • Phân biệt bằng câu hỏi ai gọi new và ai chịu trách nhiệm vòng đời; câu trả lời quyết định cascade delete ở database.
  • Association = giữ tham chiếu lâu dài (field). Dependency = dùng tạm (tham số, biến cục bộ, gọi static).
  • Bẫy số 1: class có setter public nhận phần từ ngoài là aggregation, không phải composition.

Hình dung: composition như phòng trong một ngôi nhà (phá nhà thì mất phòng); aggregation như đồ nội thất (dọn nhà thì mang đi được).

Tạo và huỷ object đúng cách: static factory, builder, singleton và những cách phá singleton
flowchart TD
  Q{"Tạo object thế nào?"} -->|"vài tham số, ý nghĩa rõ"| C["Constructor"]
  Q -->|"cần tên, cache, lớp con ẩn"| SF["Static factory: of/from/valueOf"]
  Q -->|"nhiều tham số tuỳ chọn"| B["Builder + kiểm tra trong build()"]
  Q -->|"chỉ một instance"| S{"Có Spring?"}
  S -->|có| BEAN["Bean scope singleton"]
  S -->|không| EN["Enum một hằng / holder idiom"]
  Q -->|"chỉ có method static"| U["Utility class: constructor private"]
  • Static factory method (of, from, valueOf) có tên, được trả object có sẵn (cache) và trả lớp con ẩn; cái giá là khó kế thừa và khó tìm trong tài liệu.
  • Builder hợp khi có nhiều tham số tuỳ chọn và ràng buộc giữa các field: kiểm tra tập trung trong build(), object tạo ra bất biến.
  • Utility class: constructor private ném AssertionError, không cần abstract.
  • Singleton viết tay bị phá bởi reflection, serialization, clone và nhiều ClassLoader. Enum một hằng chống được ba cái đầu; trong Spring, dùng bean.
  • Tránh object thừa ở hot path (boxing trong vòng lặp chậm ~5 lần), nhưng đừng tự làm object pool trừ khi object thật sự đắt (connection, thread).
  • Bẫy số 1: tự quản lý mảng/collection mà quên gán null cho phần tử đã bỏ là memory leak; dọn tài nguyên bằng try-with-resources, không bằng finalize.

Hình dung: constructor là cửa sau xưởng: ai vào cũng ra một sản phẩm mới tinh. Static factory là quầy bán hàng có tên, có thể đưa hàng có sẵn trong kho. Builder là tờ đơn đặt hàng điền dần rồi nộp một lần. Singleton là "chỉ có một chiếc", và reflection, serialization, clone là ba cái máy photocopy lén.

Lập trình hướng đối tượng: wrapper class, BigInteger/BigDecimal và String
mindmap
  root((Wrapper, BigDecimal, String))
    Wrapper
      So bằng equals
      Cache từ -128 đến 127
      Unbox null ném NPE
    BigDecimal cho tiền
      Tạo từ String
      Chia kèm scale, RoundingMode
      So bằng compareTo
    String bất biến
      Vòng lặp dùng StringBuilder
  • Wrapper (Integer, Long...) bọc primitive để dùng được trong generics và nhận null. Wrapper bất biến và final.
  • Integer.valueOf cache -128..127, nên == chỉ "tình cờ" đúng trong khoảng đó. Luôn so wrapper bằng equals.
  • Unbox null ném NullPointerException. new Integer(..) đã deprecated để xoá: dùng valueOf hoặc autoboxing.
  • Tiền dùng BigDecimal tạo từ String, chia luôn kèm scale + RoundingMode, so sánh bằng compareTo.
  • BigInteger.mod luôn không âm, remainder giữ dấu số bị chia (giống %).
  • String bất biến; nối chuỗi trong vòng lặp là O(n²), dùng StringBuilder hoặc String.join.
  • Bẫy số 1: new BigDecimal(0.1) ra 0.1000000000000000055..., và 2.0.equals(2.00) là false.

Hình dung: wrapper là cái hộp đựng một con số. Hai hộp giống nhau chưa chắc là cùng một hộp (==), và hộp rỗng (null) mà mở ra thì nổ.

Enum, nested class

Enum trong Java: từ hằng số tới class, strategy và switch đủ trường hợp
flowchart TD
  Q{Mọi giá trị cùng hình dạng?} -->|có| E["Enum: tập giá trị đóng"]
  Q -->|không| SI["Sealed interface + record"]
  E --> C["Hằng duy nhất, so bằng =="]
  E --> F["Field, method, thân riêng"]
  E --> V["Input ngoài: Map + Optional"]
  V -.-> ST["Bảng tra trong static {}"]
  E --> SW["Switch không default"]
  • Enum là một kiểu riêng với tập giá trị đóng: compiler chặn giá trị lạ, điều hằng String/int không làm được.
  • Enum là class: ngầm extends Enum, constructor luôn private, mỗi hằng là một object duy nhất nên so bằng ==.
  • Gắn được field final, method, thân riêng từng hằng, implement interface: mỗi hằng thành một strategy có sẵn.
  • valueOf ném exception và phân biệt hoa thường; input bên ngoài thì tra qua Map dựng sẵn, Locale.ROOT, trả Optional. Đừng dùng ordinal() trong nghiệp vụ.
  • Switch expression không default: thêm hằng là compiler báo mọi chỗ cần sửa. Chỉ viết default (và làm nó ồn ào) cho enum của bên ngoài.
  • Bẫy số 1: constructor enum không dùng được static field của chính enum; dựng bảng tra trong khối static {} đặt sau các hằng.
  • Trade-off: mọi giá trị cùng hình dạng thì dùng enum; mỗi trường hợp mang dữ liệu khác thì dùng sealed interface + record.

Hình dung: enum như bộ quân cờ trong hộp: số quân biết trước, mỗi quân là duy nhất, không ai đúc thêm quân giữa ván, và mỗi loại quân có luật đi riêng.

Enum ở production: EnumSet, EnumMap, singleton, lưu database và tiến hoá API
flowchart TD
  E[Enum] --> DB{Lưu DB thế nào?}
  DB -->|ORDINAL| O["Chèn hằng: dữ liệu sai"]
  DB -->|STRING| S["An toàn sắp xếp, gắn tên"]
  DB -->|AttributeConverter| AC["Mã ổn định, thêm code"]
  E --> API[API]
  API --> CL["Client: UNKNOWN + @JsonEnumDefaultValue"]
  API --> SV["Server: 400 cho giá trị lạ"]
  E --> COL["EnumSet / EnumMap: nhanh"]
  E --> SG["Một hằng: singleton"]
  • EnumSet là bit vector (≤ 64 hằng thì chỉ là một long), EnumMap là mảng theo ordinal: nhanh hơn HashSet/HashMap, duyệt theo thứ tự khai báo, không nhận null.
  • Enum một hằng là singleton tốt nhất: thread-safe, chống reflection, chống serialization. Trong Spring thì dùng bean.
  • Bẫy số 1: EnumType.ORDINAL lưu vị trí, chèn một hằng vào giữa là dữ liệu cũ lặng lẽ sai.
  • STRING an toàn khi sắp xếp lại nhưng gắn tên hằng với DB; AttributeConverter + mã ổn định tách hẳn hai thứ (trade-off: thêm code).
  • Thêm một hằng vào response API cũng có thể là breaking change: Jackson mặc định ném InvalidFormatException.
  • Client nên là tolerant reader (UNKNOWN + @JsonEnumDefaultValue); server vẫn trả 400 cho giá trị lạ ở request.
  • Serialization chỉ ghi tên hằng; hashCode() của enum đổi giữa các lần chạy JVM.

Hình dung: tên và thứ tự hằng enum giống số nhà trên một con phố. Trong nhà mình đổi gì cũng được, nhưng khi bưu điện (DB, client) đã ghi lại địa chỉ thì đánh lại số nhà là thư gửi nhầm.

Nested class trong Java: static nested, inner, local, anonymous class và lambda
  • Bốn loại: static nested (không gắn outer), inner (gắn một outer instance), local (có tên, trong method), anonymous (không tên, dùng một lần).
  • Mặc định là static nested; chỉ bỏ static khi thật sự cần outer instance. Builder luôn là static.
  • Inner class, anonymous class và lambda dùng this đều giữ tham chiếu mạnh tới outer object.
  • Bẫy số 1: listener là inner class đăng ký vào chỗ sống lâu (event bus tĩnh, executor, cache) giữ outer mãi, dẫn tới OutOfMemoryError.
  • Lambda chỉ đọc được biến cục bộ effectively final vì nó nhận bản sao giá trị, không phải biến.
  • Trong lambda, this là class bao quanh; trong anonymous class, this là chính nó.
  • Túi dữ liệu bất biến thì dùng record; tập trường hợp mang dữ liệu riêng thì dùng sealed interface + record.

Hình dung: inner class như đứa trẻ luôn nắm tay bố mẹ (outer). Chừng nào có ai giữ đứa trẻ, bố mẹ cũng không đi đâu được.

ExceptionLõi

Exception trong Java: checked/unchecked, try-catch-finally và call stack
  • Exception là object; chỗ phát hiện lỗi throw, chỗ đủ ngữ cảnh thì catch. Không ai bắt thì thread chết.
  • Checked (Exception trừ RuntimeException): compiler bắt "catch or declare". Unchecked (RuntimeException, Error): không bắt buộc.
  • catch xét từ trên xuống, chỉ chạy handler khớp đầu tiên, nên lớp con đặt trước lớp cha.
  • finally chạy cả khi try ném hay return; với resource thì dùng try-with-resources (giữ suppressed exception).
  • Bọc exception thì luôn giữ cause; đừng nuốt lỗi, đừng ném Exception chung chung.
  • Chi phí chính là chụp stack trace lúc tạo exception, nên đừng dùng exception cho luồng điều khiển thường.
  • Bẫy số 1: return trong finally nuốt mất exception của try.

Hình dung: exception như chuông báo cháy: người thấy khói chỉ bấm chuông, còn đội cứu hoả (tầng biết xử lý) mới quyết định làm gì.

Git

Git: version control, staging area, object model và commit convention
  • Git là VCS phân tán: mỗi máy có đủ lịch sử, commit/branch/log/diff chạy offline.
  • Ba vùng: working directory → git add → staging area (bản nháp commit) → git commit → repository.
  • Commit là snapshot của cả cây, không phải diff; file không đổi dùng lại đúng blob cũ (cùng nội dung → cùng hash).
  • Branch chỉ là một file chứa hash; HEAD trỏ tới branch hiện tại.
  • Lịch sử bất biến: amend/rebase luôn tạo commit mới với hash mới, nên chỉ amend commit chưa push.
  • Conventional Commits: type(scope): description; format là style, không phải refactor; !/BREAKING CHANGE tăng major.
  • Bẫy số 1: lỡ push secret thì rotate ngay, xoá khỏi lịch sử là việc sau.

Hình dung: Git là một kho ảnh chụp đánh số theo nội dung. Ảnh trùng chỉ cất một lần, còn branch là tờ giấy ghi "ảnh mới nhất là số mấy".

Git: remote, clone, tag phiên bản và thói quen push hằng ngày
flowchart LR
  W[Thư mục làm việc] -->|commit| L[Repo local]
  L -->|push| R["Remote (GitHub)"]
  R -->|"fetch / pull"| L
  R -->|"clone (máy mới)"| L
  ST["Stash, nhánh chưa push, file ignore"] -.->|chỉ trên máy| W
  L -->|annotated tag| TG["Tag: SemVer MAJOR.MINOR.PATCH"]
  TG -->|"phải push tag riêng"| R
  • Remote là bản repo ở xa (GitHub, GitLab). Git là công cụ, GitHub là dịch vụ.
  • clone một lần cho máy mới; sau đó chỉ fetch (tải về) hoặc pull (= fetch + merge/rebase).
  • Git chỉ backup cái đã commit và đã push. Stash, nhánh chưa push, file bị ignore vẫn chỉ nằm trên máy.
  • .gitignore không gỡ file đã commit: phải git rm --cached, và secret đã commit coi như lộ.
  • SemVer MAJOR.MINOR.PATCH: phá tương thích → MAJOR, thêm tính năng → MINOR, sửa bug → PATCH.
  • Release dùng annotated tag. Bẫy số 1: git push mặc định không đẩy tag.

Hình dung: commit là lưu bài vào ổ cứng, push là gửi một bản vào két ở ngân hàng. Chưa gửi thì cháy nhà là mất.

Git: branching, merge vs rebase, conflict, reflog và quy trình Pull Request
  • Fast-forward chỉ dời con trỏ; khi cả hai nhánh có commit mới, Git tạo merge commit có hai cha. --no-ff ép tạo merge commit.
  • Resolve conflict xong phải build và chạy test: sạch cú pháp vẫn có thể sai logic.
  • Merge giữ lịch sử thật; rebase cho lịch sử thẳng nhưng tạo commit mới (hash mới).
  • Bẫy số 1: rebase commit đã push lên nhánh người khác đang dùng. Nếu phải đẩy lại nhánh riêng, dùng --force-with-lease.
  • Trên nhánh chung, hoàn tác bằng revert (thêm commit ngược), không dùng reset (viết lại lịch sử).
  • Git Flow hợp sản phẩm nhiều phiên bản song song; trunk-based hợp dịch vụ deploy liên tục, đổi lại cần CI và feature flag.
  • Reflog cứu được gần như mọi commit "đã mất", trừ thay đổi chưa từng commit hay stage.

Hình dung: branch là bookmark trong một cuốn sổ chung. Merge viết thêm một trang "gộp hai mạch", rebase chép lại các trang của bạn ra sau trang mới nhất, còn reflog là lịch sử trình duyệt ghi mọi lần bạn lật trang.

2. Cấu trúc dữ liệu & thuật toán

Big-O

Thuật toán cơ bản: Big-O và ba thuật toán sắp xếp O(n²)
flowchart TD
  A["Big-O: tốc độ tăng theo n"] --> B["Nối tiếp: cộng"]
  A --> C["Lồng nhau: nhân"]
  A --> D["Chia đôi: O(log n)"]
  E{"Chọn sort O(n²) nào?"} -->|"Mặc định"| F["Insertion: stable, gần O(n)"]
  E -->|"Ghi rất đắt"| G["Selection: tối đa n-1 swap"]
  E -->|"Gần như không"| H["Bubble"]
  • Big-O là cận trên của tốc độ tăng chi phí theo n: bỏ hằng số, chỉ giữ số hạng tăng nhanh nhất.
  • Đọc từ code: khối nối tiếp thì cộng, khối lồng nhau thì nhân, vòng chạy số lần cố định là hằng số, mỗi bước chia đôi là O(log n).
  • Phép thử nhân đôi: n gấp đôi thì O(n) gấp đôi, O(n²) gấp bốn, O(log n) chỉ thêm một bước.
  • Java làm khoảng 10⁸ phép đơn giản mỗi giây: O(n²) với n = 10⁶ mất cỡ 3 tiếng.
  • Insertion và bubble sort là stable; selection sort không stable nhưng chỉ swap tối đa n - 1 lần.
  • Chọn một trong ba thì chọn insertion sort: gần O(n) với dữ liệu gần sắp xếp, JDK dùng nó cho đoạn ngắn.
  • Bẫy số 1: selection sort trong slide so với a[i] thay vì a[min], nên sắp xếp sai.

Hình dung: Big-O giống hỏi "thêm khách thì bếp vất vả thêm bao nhiêu", không phải "nấu một món mất mấy phút".

Array, List, Stack, Queue, MapLõi

Cấu trúc dữ liệu tuyến tính: Array, Linked List, Stack và Queue
  • Array: các ô nhớ liền kề, nên đọc theo index là O(1); chèn/xoá ở giữa là O(n).
  • Linked list: mỗi phần tử là một node rời, nối bằng tham chiếu. Chèn/xoá O(1) khi đã có node, nhưng tìm tới node là O(n).
  • Trade-off chính: đọc ngẫu nhiên nhanh (array) hay chèn/xoá rẻ ở hai đầu (linked list).
  • Bẫy số 1: tin Big-O mà chọn LinkedList. Nhờ CPU cache, ArrayList thường nhanh hơn, kể cả chèn giữa.
  • Stack = LIFO, chỉ đụng vào đỉnh. Queue = FIFO, thêm ở cuối, lấy ở đầu. Thao tác nào cũng O(1).
  • Trong Java: mặc định ArrayList; cần stack hay queue thì ArrayDeque.
  • Mảng Java luôn là object trên heap, không nằm trên stack.

Hình dung: array là dãy ghế đánh số (biết số là tới thẳng ghế), linked list là trò truy tìm kho báu (mỗi mảnh giấy chỉ chỗ mảnh kế tiếp), stack là chồng đĩa, queue là hàng mua vé.

Java Collections: List, Set và Map
  • List: có thứ tự, cho trùng. Set: không trùng. Map: key/value, không kế thừa Collection. Queue/Deque: lấy ra theo FIFO, LIFO hoặc độ ưu tiên.
  • Khai báo bằng interface (List<String> x = new ArrayList<>()) để đổi implementation chỉ sửa một dòng.
  • HashSet = HashMap chỉ dùng key: hashCode chọn bucket, equals quyết định trùng.
  • Bẫy số 1: override equals mà quên hashCode thì set chứa hai object "bằng nhau".
  • Xoá trong for-each ném ConcurrentModificationException; dùng removeIf hoặc iterator.remove().
  • list.remove(1) trên List<Integer> xoá theo index; removeAll(ArrayList lớn) là O(n·m), bọc tham số bằng HashSet.
  • merge/computeIfAbsent thay cho "get, kiểm tra null, put"; hàm trả null nghĩa là xoá entry.

Hình dung: List là hàng người xếp số, Set là danh sách khách mời (mỗi người một lần), Map là danh bạ tra theo tên.

Java Collections: TreeSet, TreeMap, Comparator và Iterator
flowchart TD
  A{"Cần gì?"} -->|"Tra key nhanh"| B["HashMap O(1)"]
  A -->|"Thứ tự, gần nhất, khoảng"| C["TreeMap O(log n)"]
  C --> D["floorEntry, ceilingKey, subMap"]
  C --> E["Trùng theo compareTo"]
  E --> F{"Thứ tự nào?"}
  F -->|"Tự nhiên"| G["Comparable"]
  F -->|"Nghiệp vụ"| H["Comparator"]
  I["Sửa khi đang duyệt"] -->|"Qua iterator"| J["iterator.remove, removeIf"]
  I -->|"Đường khác"| K["ConcurrentModificationException"]
  • TreeMap là cây đỏ-đen: mọi thao tác O(log n), duyệt luôn theo key tăng dần. TreeSet là TreeMap chỉ dùng key.
  • Lý do chính để chọn TreeMap: truy vấn "gần nhất" và "theo khoảng" (floorEntry, ceilingKey, subMap).
  • Bẫy số 1: TreeSet/TreeMap xác định trùng bằng compareTo, không bằng equals. Thiếu khoá phân biệt là mất phần tử âm thầm.
  • Comparable = thứ tự tự nhiên, một cái mỗi class. Comparator = thứ tự bên ngoài, bao nhiêu cũng được.
  • Iterator fail-fast ném ConcurrentModificationException khi collection bị sửa ngoài iterator, nhưng chỉ là best effort.
  • "Fail-safe" không có trong Javadoc: đó là weakly consistent (ConcurrentHashMap) và snapshot (CopyOnWriteArrayList).

Hình dung: HashMap là tủ đồ đánh số ngẫu nhiên, mở đúng ô rất nhanh. TreeMap là kệ sách xếp theo vần: tìm chậm hơn một chút, nhưng hỏi được "cuốn gần nhất trước chữ M".

Bên trong Java Collections: ArrayList, LinkedList, ArrayDeque và HashMap
  • ArrayList: mảng cấp phát lười, 10 ô ở lần add đầu, đầy thì tăng ~1.5 lần. add cuối là O(1) amortized, nhưng lần resize riêng lẻ là O(n).
  • LinkedList thường thua ArrayList kể cả khi chèn giữa: tìm vị trí vẫn O(n), mỗi node tốn ~24 byte và rải rác trong bộ nhớ.
  • Làm stack/queue thì dùng ArrayDeque (mảng vòng), không dùng Stack (kế thừa Vector, mọi method synchronized).
  • HashMap: bucket là lũy thừa 2, index = hash & (n - 1). Bucket ≥ 8 node và table ≥ 64 thì thành cây đỏ-đen; vượt load factor 0.75 thì gấp đôi table.
  • Trade-off hệ số tăng: 2x ít copy hơn nhưng tốn bộ nhớ hơn 1.5x. Tăng theo hằng số cộng (+10) mới là sai: O(n²).
  • Bẫy số 1: dùng object mutable làm key của HashMap. Đổi field tham gia hashCode sau khi put thì không bao giờ get lại được.
  • Producer/consumer trong production: dùng queue có giới hạn để có backpressure, tránh OutOfMemoryError.

Hình dung: ArrayList như dãy ghế liền nhau trong rạp, hết chỗ thì cả nhóm chuyển sang dãy dài hơn. LinkedList như các ghế rải khắp rạp, mỗi người cầm giấy ghi chỗ người kế tiếp.

Sắp xếp, tìm kiếm, đệ quy

Đệ quy, tìm kiếm nhị phân và các thuật toán thông dụng
  • Hàm đệ quy cần base case (điều kiện dừng) và lời gọi luôn nhỏ dần về base case.
  • Độ sâu đệ quy d tốn O(d) stack. Java không có tail-call optimization, stack ~1 MB nổ ở vài chục nghìn tầng.
  • Đệ quy ổn khi độ sâu O(log n); độ sâu tuyến tính theo input thì dùng vòng lặp hoặc ArrayDeque.
  • Memoization = đổi bộ nhớ lấy thời gian: Fibonacci từ O(2ⁿ) xuống O(n).
  • Binary search O(log n) cần mảng đã sắp xếp và truy cập ngẫu nhiên; mảng nhỏ thì linear search có khi nhanh hơn.
  • Bẫy số 1: mid = (low + high) / 2 tràn số; dùng low + (high - low) / 2 hoặc (low + high) >>> 1.
  • Java tràn số nguyên âm thầm: int chứa tới F(46), long tới F(92).

Hình dung: đệ quy như chồng đĩa: mỗi lời gọi đặt thêm một đĩa (stack frame), tới base case mới lấy dần ra. Chồng quá cao thì đổ.

Thuật toán cơ bản: Merge sort, Quick sort và cách Java thực sự sắp xếp
  • Merge sort: chia đôi, sort từng nửa, gộp. O(n log n) mọi trường hợp, stable, tốn O(n) bộ nhớ phụ.
  • Quick sort: chọn pivot, phân hoạch, đệ quy hai bên. In-place, thường nhanh nhất trên thực tế, không stable.
  • Bẫy số 1 của quick sort: pivot cố định trên mảng đã sắp xếp, hoặc Lomuto trên mảng toàn phần tử trùng, đều ra O(n²).
  • Chống worst case: pivot ngẫu nhiên, phân hoạch 3 đường, đệ quy vào nửa nhỏ, introsort (chuyển sang heap sort).
  • Sort dựa trên so sánh cần ít nhất Ω(n log n); counting/radix sort vượt qua vì không so sánh.
  • Java: primitive dùng Dual-Pivot Quicksort (không cần stable), object dùng TimSort (stable, O(n) khi đã sắp xếp).
  • Comparator: đừng dùng a - b (tràn số); vi phạm contract làm TimSort ném IllegalArgumentException. Ở backend, sort ở nơi dữ liệu nằm.

Hình dung: merge sort như gộp hai chồng bài đã xếp, mỗi lần lật lá nhỏ hơn; quick sort như xếp hàng quanh một bạn làm mốc, thấp hơn đứng trái, cao hơn đứng phải.

Thực hành thuật toán: đệ quy, sắp xếp và cách khử đệ quy
flowchart TD
  R[Hàm đệ quy] --> T["Hệ thức T(n)"]
  R --> S["Stack: O(độ sâu)"]
  R --> Q{Bài toán con lặp?}
  Q -->|có| M[Memoization]
  Q -->|không| D{Độ sâu theo dữ liệu?}
  D -->|có| L["Vòng lặp + ArrayDeque"]
  D -->|không| K[Giữ đệ quy]
  SO[Sắp xếp] --> P["int[]: Dual-Pivot Quicksort"]
  SO --> TS["Object[]: TimSort ổn định"]
  • Độ phức tạp hàm đệ quy: viết hệ thức truy hồi T(n), ví dụ T(n) = T(n/2) + O(1) cho O(log n).
  • Bộ nhớ của đệ quy gồm cả stack: sum(n) tốn O(n) dù không cấp phát gì.
  • Bài toán con lặp lại → memoization: Fibonacci từ O(1,618ⁿ) xuống O(n).
  • Java không tối ưu tail call; độ sâu phụ thuộc dữ liệu → dùng vòng lặp + ArrayDeque.
  • Arrays.sort(int[]): Dual-Pivot Quicksort; Object[]/List.sort: TimSort ổn định.
  • Bẫy số 1: đệ quy chạy đúng với test nhỏ nhưng StackOverflowError trên dữ liệu thật; tăng -Xss chỉ là chữa cháy.

Hình dung: mỗi lời gọi đệ quy là một tờ giấy chồng lên bàn; bàn (stack) có giới hạn, còn kho (heap) chứa được nhiều hơn nhiều.

Cây, heap

Luyện phỏng vấn: cây nhị phân, BST và heap trong Java
flowchart TD
  Q{"Đề hỏi gì?"} -->|"Thông tin cả cây"| R["Đệ quy: hỏi hai con, gộp"]
  Q -->|"Theo tầng, gần gốc nhất"| B["BFS với queue"]
  Q -->|"Có thứ tự, BST"| I["Inorder hoặc khoảng min-max"]
  Q -->|"K lớn nhất, nhỏ nhất"| H["Heap kích thước K"]
  Q -->|"Median luồng số"| T["Hai heap"]
  Q -->|"Tìm khoảng gần nhất"| M["TreeMap floor, ceiling"]
  R --> S["Cây lệch: dùng stack tường minh"]
  • Hầu hết bài cây là đệ quy "hỏi hai con rồi gộp lại": chiều cao, đường kính, LCA đều cùng một khuôn, O(n).
  • DFS dùng stack (hoặc call stack), BFS dùng queue; đề có chữ "theo tầng", "gần gốc nhất" thì nghĩ ngay BFS.
  • BST: duyệt inorder ra dãy tăng. Kiểm tra BST phải truyền khoảng (min, max) xuống, không chỉ so với con trực tiếp.
  • PriorityQueue mặc định là min-heap; max-heap dùng Comparator.reverseOrder(). offer/poll O(log n), peek O(1).
  • Top-K lớn nhất: giữ min-heap kích thước K, O(n log K). Median của luồng: hai heap lệch nhau tối đa 1 phần tử.
  • Bẫy số 1: đệ quy trên cây lệch (sâu n) làm tràn stack; comparator viết b - a bị tràn số.

Hình dung: cây là sơ đồ tổ chức công ty: muốn biết điều gì về cả phòng, sếp hỏi hai trưởng nhóm rồi gộp câu trả lời. Heap là quầy cấp cứu: ai nặng nhất được gọi trước, không cần xếp cả hàng theo thứ tự.

Đồ thị, quy hoạch động

Luyện phỏng vấn: đồ thị và quy hoạch động trong Java
flowchart TD
  Q{"Tín hiệu trong đề"} -->|"Lưới, vùng liền nhau"| G["BFS/DFS trên lưới"]
  Q -->|"Ngắn nhất, không trọng số"| B["BFS theo tầng"]
  Q -->|"Ngắn nhất, trọng số không âm"| D["Dijkstra + PriorityQueue"]
  Q -->|"Thứ tự có phụ thuộc"| T["Topological sort, Kahn"]
  Q -->|"Cùng nhóm, cạnh thêm dần"| U["Union-find"]
  Q -->|"Số cách, min, max, bài con lặp"| P["Quy hoạch động"]
  P --> P1["Memo top-down"]
  P --> P2["Bảng bottom-up"]
  • Đồ thị gần như luôn lưu bằng danh sách kề; lưới 2D là đồ thị ngầm, mỗi ô nối 4 ô kề. BFS/DFS đều O(V + E).
  • Đường ngắn nhất: không trọng số thì BFS; trọng số không âm thì Dijkstra với PriorityQueue, O(E log V).
  • Thứ tự có phụ thuộc ("môn tiên quyết") là topological sort; không xếp được hết đỉnh nghĩa là có chu trình.
  • Hỏi "có cùng nhóm không" khi cạnh được thêm dần: union-find, gần O(1) mỗi thao tác.
  • Quy hoạch động = bài con lặp lại + đáp án lớn dựng từ đáp án nhỏ. Định nghĩa dp[...] bằng lời trước, rồi mới viết công thức.
  • Bẫy số 1: đánh dấu visited khi lấy ra khỏi queue (phải đánh dấu khi cho vào); knapsack 0/1 duyệt dung lượng xuôi thành dùng một món nhiều lần.

Hình dung: BFS là vết dầu loang trên bản đồ, Dijkstra là loang theo thời gian đi thật. Quy hoạch động là điền bảng tính: mỗi ô dùng vài ô đã điền trước nó.

3. Java nâng cao

GenericsLõi

Generics trong Java: generic class, generic method, bounded type và invariance
flowchart TD
  G[Generics] --> CT["Lỗi kiểu: lúc compile"]
  G --> GC["Generic class: theo object"]
  G --> GM["Generic method: theo lần gọi"]
  GM --> SM["Static method: tự khai báo T"]
  G --> B["Bound: T extends X"]
  G --> INV["Invariant: List#lt;Integer#gt; ≠ List#lt;Number#gt;"]
  INV -.->|khác| ARR["Mảng covariant: ArrayStoreException"]
  V["var + new ArrayList#lt;#gt;()"] -.->|bẫy| OB["ArrayList#lt;Object#gt;"]
  • Generics chuyển lỗi kiểu từ runtime sang compile time. Cast vẫn còn trong bytecode, nhưng do compiler sinh ra và chứng minh là đúng.
  • Generic class: class Box<T>, kiểu gắn với từng object. Generic method: <T> đặt trước kiểu trả về, kiểu gắn với một lần gọi.
  • Static method không thấy type parameter của class, nên phải tự là generic method.
  • Bound <T extends X> cho phép gọi method của X. Luôn dùng extends, kể cả với interface; nhiều bound nối bằng &, class đứng đầu.
  • Generics invariant: List<Integer> không phải List<Number>. Mảng covariant: Integer[] là Number[], ghi sai kiểu nổ ArrayStoreException lúc chạy.
  • Bẫy số 1: var list = new ArrayList<>(); ra ArrayList<Object>, add gì cũng compile.

Hình dung: type parameter giống ô trống trên một mẫu đơn; điền String vào thì cả mẫu đơn chỉ nhận chuỗi, và người kiểm tra (compiler) soát ngay lúc bạn điền.

Generics trong Java: wildcard và quy tắc PECS
  • List<?>: list của một kiểu chưa biết. Nhận mọi list, đọc ra Object, không add được (trừ null).
  • ? extends T: đọc ra T, không ghi được. ? super T: ghi T vào, đọc ra chỉ là Object.
  • PECS: tham số cung cấp dữ liệu (producer) → extends; tham số nhận dữ liệu (consumer) → super; vừa đọc vừa ghi → T.
  • Type parameter chỉ xuất hiện một lần trong chữ ký → dùng wildcard. Cần liên kết nhiều vị trí hoặc cần ghi → dùng T.
  • Đánh đổi: wildcard làm API nhận được nhiều đối số hơn, nhưng chữ ký khó đọc hơn. Không trả về kiểu có wildcard.
  • Bẫy số 1: <T> total(List<Item<T>>) buộc mọi phần tử cùng một T, nên không nhận list trộn Item<Integer> và Item<String>.

Hình dung: ? extends Number là chiếc hộp dán nhãn "bên trong là một loại số nào đó": lấy ra chắc chắn được số, nhưng không dám bỏ gì vào. ? super Integer là chiếc thùng "nhận Integer": bỏ vào luôn được, lấy ra thì chỉ biết đó là một đồ vật.

Generics trong Java: type erasure, raw type và type token
flowchart LR
  S["List#lt;String#gt;"] -->|compiler kiểm tra| E[Erasure]
  E --> B["T → bound/Object + cast"]
  E --> BR[Bridge method]
  E --> RT["Runtime: cùng một class"]
  RT --> L["Không new T(), List#lt;int#gt;, instanceof"]
  E --> D["Khai báo trong .class còn giữ"]
  D --> TT[Type token]
  RAW["Raw type / unchecked cast"] -.->|bẫy| CCE["ClassCastException ở chỗ đọc"]
  • Type erasure: compiler kiểm tra kiểu xong thì thay T bằng bound (hoặc Object) và tự chèn cast.
  • Lúc chạy, ArrayList<String> và ArrayList<Integer> là cùng một class.
  • Hệ quả: không có List<int>, new T(), new T[n], instanceof List<String> trên Object, overload chỉ khác type argument.
  • Bridge method: method compiler tự sinh để overriding vẫn đúng sau erasure.
  • Erasure xoá type argument khỏi object, không xoá khỏi khai báo trong file .class. Type token dựa vào đó.
  • Đánh đổi: erasure mua tương thích ngược với code trước Java 5, trả giá bằng các hạn chế trên.
  • Bẫy số 1: raw type và unchecked cast làm ClassCastException nổ ở chỗ đọc, xa chỗ ghi sai.

Hình dung: type argument như nhãn dán trên thùng hàng. Nhãn được soát kỹ lúc nhập kho (compile) rồi bị bóc khỏi thùng, nhưng sổ kho (khai báo trong file .class) vẫn ghi thùng nào chứa gì.

Lambda, Stream API

Lambda và Stream API: functional interface, pipeline lười, Collectors và các bẫy
flowchart LR
  SRC["Nguồn: list, array, Stream.of"] --> MID["Trung gian (lười): filter, map, flatMap, sorted"]
  MID --> TERM["Kết thúc: collect, reduce, findFirst"]
  TERM --> RES["Kết quả"]
  MID -.->|"thiếu terminal"| NONE["Không chạy gì"]
  TERM -.->|"dừng sớm"| SC["findFirst, anyMatch, limit"]
  TERM --> COL["Collectors: groupingBy, toMap + merge"]
  MID -.->|"bẫy"| SE["Side effect, peek, dùng lại stream"]
  • Functional interface = interface có đúng một abstract method; lambda và method reference chỉ là cách viết gọn một instance của nó.
  • Pipeline = nguồn → thao tác trung gian (lười, trả về stream) → một thao tác kết thúc (chạy cả pipeline). Không có thao tác kết thúc thì không có gì chạy.
  • Phần tử đi từng cái một qua cả chuỗi, nên findFirst, anyMatch, limit dừng sớm được (short-circuit).
  • Stream.toList() trả list không sửa được; Collectors.toList() hiện trả ArrayList nhưng không được đặc tả.
  • toMap gặp key trùng thì ném IllegalStateException; luôn cân nhắc tham số merge thứ ba.
  • Bẫy số 1: side effect trong lambda (ghi vào list ngoài, đếm bằng biến ngoài), đặc biệt với parallel(): mình đo 100.000 phần tử còn lại 21.630.
  • Boxing tốn thật: Stream<Long> + reduce chậm hơn IntStream khoảng 2,4 lần trong benchmark thô của mình.

Hình dung: stream như dây chuyền nhà máy: lắp xong băng chuyền (trung gian) chưa có gì chạy; bấm nút ở cuối (thao tác kết thúc) thì từng sản phẩm mới đi qua lần lượt các trạm.

Java 17–21: record, sealed, pattern matching

Java 17 và 21 cho backend: record, sealed, pattern matching và những gì đáng nâng cấp
flowchart LR
  J8["Java 8: lambda, stream"] --> J11["11: var lambda, HttpClient, String helpers"]
  J11 --> J17["17: record, sealed, text block, switch expression"]
  J17 --> J21["21: switch pattern, record pattern, sequenced, virtual thread"]
  J17 --> SB3["Spring Boot 3+: cần 17, jakarta.*"]
  J21 --> DOM["Domain: sealed + record + switch không default"]
  DOM --> CHK["Thêm kiểu con = lỗi biên dịch"]
  • LTS (bản hỗ trợ dài hạn) là 8, 11, 17, 21, 25. Spring Boot 3 và 4 đều cần Java 17+; virtual thread cần 21.
  • Record = class dữ liệu bất biến (nông): validation và chuẩn hoá trong compact constructor. Hợp làm DTO (Jackson 2.12+), không làm JPA entity.
  • Sealed interface liệt kê đủ các kiểu con; compiler biết tập đó là đóng.
  • Switch pattern (Java 21) trên sealed type không cần default: thêm một kiểu con là lỗi biên dịch ở mọi chỗ chưa xử lý.
  • Bẫy số 1: viết default trong switch trên sealed type, tắt luôn kiểm tra exhaustive mà ta muốn có.
  • Polymorphic JSON với sealed vẫn cần @JsonTypeInfo + @JsonSubTypes; serialize List<Result> trực tiếp bằng ObjectMapper làm mất field type.
  • Migrate 8 → 17: lỗi thường không ở cú pháp mà ở javax → jakarta, module Java EE bị bỏ, và thư viện cũ đụng vào nội bộ JDK.

Hình dung: sealed + record như một tờ khai có danh sách ô cố định: mỗi trường hợp có đúng các ô của nó, và compiler là người kiểm tra không ai bỏ sót ô nào.

Thread, ExecutorServiceLõi

Thread trong Java: tạo thread, vòng đời và interrupt
  • Process có vùng nhớ riêng; các thread trong process chung heap, mỗi thread có stack riêng.
  • Concurrency = nhiều việc dở dang cùng lúc (cấu trúc); parallelism = chạy thật cùng lúc trên nhiều core (thực thi).
  • Thread giúp nhiều nhất với việc I/O bound; với CPU bound, thêm thread quá số core chỉ thêm context switch.
  • Viết task là Runnable/Callable, để executor chọn thread; Callable trả kết quả qua Future.
  • run() gọi thẳng không tạo thread mới; start() chỉ gọi được một lần.
  • 6 trạng thái: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; không có RUNNING.
  • Bẫy số 1: bắt InterruptedException rồi chỉ log là nuốt mất yêu cầu dừng; phải ném tiếp hoặc bật lại cờ.

Hình dung: process là một bếp, thread là các đầu bếp dùng chung kho (heap) nhưng mỗi người có thớt riêng (stack); interrupt là lời nhắc "nghỉ tay", đầu bếp tự chọn lúc dừng.

ExecutorService, thread pool và virtual thread trong Java
  • Thứ tự của ThreadPoolExecutor: đủ core → vào hàng đợi → hàng đợi đầy mới tạo thêm tới max → rồi mới reject.
  • Bẫy số 1: newFixedThreadPool dùng hàng đợi không giới hạn, nên max và rejection policy vô dụng, quá tải là OOM trong im lặng.
  • Hàng đợi có giới hạn buộc chọn: Abort (fail fast) hay CallerRuns (back-pressure).
  • Số thread: CPU bound ≈ số core; I/O bound ≈ core × (1 + chờ/tính); luôn bị chặn bởi tài nguyên hẹp nhất phía sau.
  • Tắt pool: shutdown() → awaitTermination có hạn → shutdownNow().
  • Virtual thread tăng throughput cho việc chờ I/O, không giảm latency. Đừng pool chúng; giới hạn bằng Semaphore. Pinning với synchronized được gỡ ở Java 24.
  • ThreadLocal trong pool: set ở đâu thì remove() trong finally ở đó.

Hình dung: thread pool là quầy có vài nhân viên và một hàng ghế chờ; virtual thread là phát số cho mọi khách, ai phải chờ giấy tờ thì đứng sang bên để nhân viên phục vụ người khác.

Race condition, volatile, deadlockLõi

Concurrency trong Java: race condition, volatile và deadlock
  • count++ là ba bước đọc-cộng-ghi; 4 thread × 1 triệu lần chỉ ra ~1,25 triệu.
  • Sửa: synchronized (nhiều biến, check-then-act), AtomicInteger (một biến, CAS), LongAdder (rất nhiều thread cùng cộng).
  • volatile bảo đảm nhìn thấy và thứ tự, không bảo đảm nguyên tử.
  • Thread B chỉ chắc chắn thấy ghi của thread A khi có quan hệ happens-before.
  • Deadlock cần đủ bốn điều kiện Coffman; khoá theo thứ tự cố định hoặc tryLock có timeout để phá một điều kiện.
  • Bẫy số 1: lock trong JVM không bảo vệ gì giữa nhiều instance; bất biến dùng chung phải giữ ở database.

Hình dung: biến dùng chung là một tấm bảng trắng; race là hai người cùng đọc số 10, cùng xoá rồi cùng viết 11.

CompletableFuture, virtual thread

CompletableFuture và lập trình bất đồng bộ trong Java
flowchart LR
  R[Request] --> E["Executor riêng hoặc virtual thread"]
  E --> A[supplyAsync A]
  E --> B[supplyAsync B]
  E --> C[supplyAsync C]
  A --> J["allOf / thenCombine"]
  B --> J
  C --> J
  J --> T["orTimeout + exceptionally"]
  T --> O["Kết quả hoặc fallback"]
  X["Bẫy: commonPool, mất MDC, cancel không dừng task"] -.-> E
  • Future chỉ có get() chặn; CompletableFuture (CF) cho nối bước tiếp theo, gộp nhiều kết quả, xử lý lỗi và timeout mà không chặn.
  • Bẫy số 1: supplyAsync(...) không truyền executor chạy trên common ForkJoinPool (số core − 1 thread, dùng chung cả JVM). Gọi I/O blocking ở đó là nghẽn: 50 lệnh 100 ms mất 620 ms thay vì ~100 ms.
  • thenApply = đổi giá trị, thenCompose = nối một CF khác (flatMap), thenCombine/allOf = chờ nhiều nhánh, anyOf = lấy nhánh xong đầu tiên.
  • Lỗi đi qua chuỗi được gói trong CompletionException; join() ném nó, get() ném ExecutionException. Luôn unwrap trước khi xét loại lỗi.
  • orTimeout/completeOnTimeout chỉ hoàn thành CF; cancel(true) không interrupt task đang chạy. Việc bên dưới vẫn chạy tiếp, nên timeout thật phải đặt ở HTTP/JDBC client.
  • ThreadLocal (MDC, SecurityContext) không tự sang thread khác: bọc executor bằng TaskDecorator/wrapper. @Async chỉ chạy qua proxy: tự gọi trong cùng class thì chạy đồng bộ.
  • Trade-off: trên Java 21, virtual thread + code blocking thường dễ đọc hơn chuỗi CF mà nhanh ngang (508 ms so với 506 ms ở bài đo fan-out).

Hình dung: CF là phiếu hẹn ở quầy giặt đồ. Bạn không đứng chờ, mà dặn trước "giặt xong thì ủi, ủi xong thì gửi về nhà", và ghi luôn "quá 2 giờ thì báo tôi".

Design pattern qua refactor

SOLID qua ví dụ Java: năm nguyên lý, cách nhận ra vi phạm và khi nào không cần
flowchart LR
  CHG["Yêu cầu thay đổi"] --> S["S: ai yêu cầu? tách theo actor"]
  CHG --> O["O: biến thể mới? thêm class qua điểm mở rộng"]
  O --> L["L: cài đặt mới giữ hợp đồng"]
  L --> CT["Contract test cho mọi cài đặt"]
  CHG --> I["I: client chỉ thấy method nó dùng"]
  CHG --> D["D: nghiệp vụ sở hữu interface, hạ tầng implement"]
  D --> DI["DI/Spring: lắp ráp ở composition root"]
  • SOLID là năm cách giảm chi phí thay đổi: thay đổi chạm ít file, ít người, ít test.
  • S: một class chỉ có một actor (nhóm người) yêu cầu nó thay đổi; không phải "một method".
  • O: thêm biến thể mới bằng code mới thay vì sửa code đang chạy, nhờ điểm mở rộng (interface, strategy). Với tập biến thể đóng, switch trên sealed type cũng hợp lệ.
  • L: lớp con phải giữ hợp đồng của lớp cha: không đòi hỏi nhiều hơn (tiền điều kiện), không hứa ít hơn (hậu điều kiện), giữ bất biến. Kiểm bằng contract test chạy cho mọi cài đặt.
  • I: interface nhỏ theo vai trò của client; dấu hiệu vi phạm là method rỗng hoặc throw new UnsupportedOperationException().
  • D: nghiệp vụ và hạ tầng cùng phụ thuộc abstraction, và abstraction thuộc về phía nghiệp vụ. DI (Spring inject) chỉ là cách lắp ráp.
  • Bẫy số 1: áp SOLID trước khi có thay đổi thật: interface một cài đặt, factory cho một class, mười class cho một việc. Thêm điểm mở rộng khi biến thể thứ hai xuất hiện.

Hình dung: một căn bếp tốt. Mỗi người một việc (S), thêm món mới thì thêm công thức chứ không đập bếp (O), đầu bếp thay ca phải nấu đúng món trong thực đơn (L), người rửa bát không phải học cầm dao (I), và bếp dùng ổ cắm chuẩn nên đổi nồi cơm hãng nào cũng được (D).

Design pattern qua refactor: Strategy
flowchart TD
  SM["Smell: cùng câu hỏi lặp lại"] --> Q{Tập lựa chọn?}
  Q -->|"2–3 nhánh không đổi"| IF["if/else"]
  Q -->|tập đóng| EN[Enum có method]
  Q -->|"tập mở / có dependency"| ST[Strategy]
  ST --> CTX[Context giữ một tham chiếu]
  ST --> LB["Lambda, ghép composite"]
  ST --> SP["Spring: List → Map, kiểm lúc khởi động"]
  SP -.->|bẫy| SF[Strategy có state dùng chung]
  • Smell của Strategy: cùng một câu hỏi (online?, loại gì?) bị hỏi lại ở nhiều method.
  • Strategy = tách "cách làm" thành interface, mỗi cách một class; context chỉ giữ một tham chiếu.
  • Strategy chỉ dời chỗ rẽ nhánh: quyết định nằm ở một chỗ duy nhất (cấu hình, registry, hoặc Observer).
  • Trade-off: if/else cho 2–3 nhánh không đổi, enum có method cho tập đóng, Strategy cho tập mở hoặc có dependency.
  • Interface một method = functional interface, nên lambda là strategy và ghép được (composite).
  • Spring: inject List<Strategy>, dựng Map theo key, kiểm tra trùng/thiếu lúc khởi động.
  • Bẫy số 1: strategy có state làm singleton bean dùng chung, dữ liệu các user trộn nhau.

Hình dung: context là cái máy khoan, strategy là mũi khoan: đổi mũi là đổi cách làm, máy không cần biết có bao nhiêu loại mũi.

Template Method hay composition: refactor luồng đặt phòng v0 đến v2
  • Template Method: lớp cha giữ thứ tự bước trong một method cố định, lớp con thay nội dung vài bước.
  • Ba quy tắc: template là final, bước bất biến là private, phân biệt bước abstract (bắt buộc) với hook (tuỳ chọn, mặc định rỗng).
  • Bẫy số 1: override một bước mà quên super là bỏ mất kiểm tra của lớp cha một cách im lặng.
  • Trong Spring: @Transactional trên một bước bị bỏ qua (self-invocation); @SneakyThrows làm checked exception không rollback; constructor injection phải lặp ở mọi lớp con.
  • Composition: biến thể là danh sách rule và listener ghép theo loại; kết hợp dễ, đổi được lúc chạy.
  • Trade-off: Template Method thấy cả luồng ở một chỗ; composition thắng khi biến thể bắt đầu kết hợp hoặc lớp con override quá nửa số bước.

Hình dung: Template Method là một tờ đơn in sẵn thứ tự các mục, mỗi phòng ban chỉ điền vài ô của mình; composition là bộ thẻ quy tắc, mỗi loại phòng rút những thẻ nó cần.

Observer: từ danh sách listener đến Spring event và outbox
  • Observer: publisher chỉ biết interface listener, gọi lần lượt khi trạng thái thật sự đổi. Thêm subscriber không sửa publisher.
  • Publisher ngây thơ vỡ bốn cách: listener tự huỷ đăng ký, listener ném lỗi, quên huỷ đăng ký (leak), notify đồng bộ không thread-safe.
  • Sửa: CopyOnWriteArrayList, try/catch từng listener, subscribe trả handle AutoCloseable, không subscribe(this) trong constructor.
  • Spring: @EventListener chạy đồng bộ, cùng thread, cùng transaction; @TransactionalEventListener(AFTER_COMMIT) chỉ chạy khi commit thành công nhưng không bền.
  • Trade-off: event trong process để tách code, broker + outbox để tách hệ thống.
  • Bẫy số 1: phát Kafka trong transaction DB là dual write, gây event ma hoặc mất event. Lời giải: transactional outbox.

Hình dung: publisher như tổng đài nhắn tin: chỉ giữ danh bạ số đăng ký, không cần biết ai làm gì với tin nhắn; ai không muốn nhận nữa thì phải tự huỷ, nếu không tổng đài cứ nhắn mãi.

Adapter và Factory: tích hợp cổng thanh toán và chọn đúng implementation
flowchart LR
  A[Code của mình] --> AD[Adapter]
  AD -->|"dịch kiểu, đơn vị, lỗi"| PG[Cổng thanh toán]
  AD -.-> M["Tiền: BigDecimal/long"]
  AD -.-> T["Timeout = chưa biết"]
  F{Cần factory nào?} -->|chọn theo key| S[Simple factory]
  F -->|lớp con chọn| FM[Factory Method]
  F -->|họ object khớp nhau| AF[Abstract Factory]
  F -->|Spring| R[Registry chọn bean]
  • Adapter dịch cả ngôn ngữ của bên thứ ba sang của mình: kiểu, đơn vị, mã lỗi, exception. Không chỉ đổi tên method.
  • (int) amount * 26000 ép kiểu trước khi nhân: 0,99 USD thành 0 đồng. Tiền dùng BigDecimal từ chuỗi hoặc long theo đơn vị nhỏ nhất.
  • Làm tròn theo số chữ số của tiền tệ, chỉ đổi tiền một lần và lưu tỷ giá trên giao dịch.
  • Ba thứ tên "factory": simple factory (chọn bằng switch/bảng tra), Factory Method (lớp con chọn), Abstract Factory (một họ object phải khớp nhau).
  • Trong Spring, code thường cần chọn bean (registry), không cần tạo object.
  • Bẫy số 1: @RequiredArgsConstructor chỉ inject field final. Quên final thì field là null, app vẫn khởi động, NPE ở request đầu tiên.
  • Timeout khi gọi cổng thanh toán là "chưa biết", không phải thất bại.

Hình dung: adapter là ổ cắm chuyển đổi khi đi nước ngoài: thiết bị của bạn không đổi, ổ điện cũng không đổi, chỉ có cục chuyển ở giữa.

Clean code, refactoring

Clean code: vì sao, đặt tên, hàm và luồng điều khiển
  • Clean code = code dễ hiểu và dễ thay đổi. Code bẩn chỉ rẻ hơn vài tuần đầu, sau đó chi phí mỗi thay đổi tăng gần hàm mũ.
  • Độ phức tạp (Ousterhout) có ba triệu chứng: change amplification, cognitive load, unknown unknowns (tệ nhất). Gốc: phụ thuộc và mơ hồ.
  • Tên theo câu hỏi mà giá trị trả lời (hasScope, không phải checkScope). Một khái niệm một từ.
  • Hàm làm một việc, theo CQS (hoặc đổi trạng thái, hoặc trả lời). Ngoại lệ: thao tác nguyên tử như putIfAbsent.
  • DRY là về tri thức, không về ký tự. Bẫy số 1: gộp quá sớm sinh abstraction sai đầy cờ boolean; dùng rule of three.
  • Thêm biến thể bằng class anh em (sealed interface + record), không kế thừa class cũ.
  • Guard clause làm phẳng luồng; ném exception theo domain, không ném RuntimeException chung chung.

Hình dung: code như bếp dùng chung: dọn ngay sau mỗi lần nấu tốn vài phút, để dồn thì bữa nào cũng phải dọn trước.

Clean code: xử lý lỗi, boundary, test và refactor một đoạn code thật
flowchart LR
  SDK[SDK bên thứ ba] --> AD[Adapter]
  AD -->|"bọc checked exception"| SV["Service: exception unchecked"]
  AU[ArchUnit] -.->|chặn rò rỉ kiểu| AD
  T{Test dùng gì?} -->|logic thuần| O[Object thật]
  T -->|phụ thuộc có trạng thái| FK[Fake]
  T -->|tương tác là hành vi| MK[Mock]
  GM[Golden master] --> SS[Bước nhỏ]
  SS --> CO[Tách commit refactor]
  • catch phải để lại trạng thái nhất quán; message lỗi nói cái gì hỏng, với ai, vì sao, và giữ cause.
  • Service Spring: exception domain là unchecked; checked exception của thư viện được bọc ở boundary.
  • Test: object thật cho logic thuần, fake cho phụ thuộc có trạng thái, mock chỉ khi tương tác chính là hành vi.
  • Kiểu của SDK bên thứ ba chỉ được sống trong adapter; chặn rò rỉ bằng ArchUnit.
  • Refactor = đổi cấu trúc, giữ hành vi: golden master trước, bước nhỏ, tách commit refactor khỏi commit đổi hành vi.
  • Bẫy số 1: làm tròn tiền ở bước trung gian lệch 1 đồng ở 338/20.000 đơn. Cách làm tròn là quy tắc nghiệp vụ.
  • Golden master chỉ bảo vệ input mà bộ sinh tạo ra; chỗ đổi kiểu (double sang BigDecimal) cần probe riêng.

Hình dung: golden master giống chụp ảnh căn phòng trước khi dọn: dọn xong so từng góc với ảnh, chỗ nào khác là bạn đã lỡ tay đổi đồ.

Regex: cú pháp, engine, ReDoS

Regex: cú pháp, Java API và các bài tập validate cơ bản
mindmap
  root((Regex trong Java))
    Flavor: thử regex101
    Cú pháp
      Lớp ký tự, quantifier
      Anchor, lookaround, group
    Java API
      Pattern static final
      matches tự neo, find thì không
      split nhận regex, dùng quote
      w và d chỉ ASCII
    Engine
      Backtracking, không timeout
  • Mỗi ngôn ngữ có một flavor regex riêng: thử trên regex101 với đúng flavor nơi regex sẽ chạy (Java 8 cho Java).
  • . mặc định không khớp xuống dòng (cần DOTALL); MULTILINE chỉ đổi nghĩa của ^ và $.
  • Bẫy số 1: validate bằng find() mà quên ^...$ thì \d{6} chấp nhận "abc1234567". matches() tự neo cả chuỗi.
  • \w, \d của Java mặc định chỉ ASCII: \w+ cắt "Nguyễn". Dùng \p{L} hoặc cờ (?U).
  • split và replaceAll nhận regex: split(".") ra mảng rỗng, "$5" trong chuỗi thay thế ném exception. Dùng Pattern.quote, Matcher.quoteReplacement.
  • Trade-off: Pattern thread-safe, để static final trên đường nóng; String.matches gọn nhưng compile lại mỗi lần (~500 ns so với ~240 ns).
  • "Engine Java kém hơn JavaScript" là sai; điểm yếu thật của cả hai là backtracking.

Hình dung: cú pháp regex là một interface, engine của mỗi ngôn ngữ là một implementation: cùng chữ ký, khác chi tiết hành vi.

Regex qua bài tập: cấu hình mạng, log sang CSV, lookbehind và dòng trùng
flowchart TD
  A["Case phải khớp"] --> C["Thử regex101 đúng flavor"]
  B["Case gần giống không khớp"] --> C
  C --> D["Khoá bằng unit test"]
  D --> E{"So giữa các dòng?"}
  E -->|"Không"| F["Regex từng dòng, có neo"]
  E -->|"Có"| G["HashSet, awk, sort uniq"]
  • Test regex luôn cần hai nhóm input: phải khớp, và gần giống nhưng không được khớp (U109 cạnh U1092).
  • Nhóm tuỳ chọn (?:...)? không khớp thì group() trả null, không phải "".
  • \h cho khoảng trắng ngang, \R cho xuống dòng (cả \r\n): pattern không nuốt sang dòng sau.
  • POSIX ERE (sed -E, grep -E) không có \d, \S, lookaround: viết [0-9], [^ ].
  • Lookbehind trong Java phải có độ dài tối đa xác định; trong code, capturing group thường dễ hơn.
  • Bẫy số 1: backreference \1 khớp chuỗi con, phải neo ^\1$ khi so cả dòng.
  • So sánh giữa các dòng (trùng, đếm) bằng regex là O(n²); LinkedHashSet, awk, sort | uniq làm trong O(n) hoặc O(n log n).

Hình dung: regex là kính lúp soi từng dòng một; muốn so các dòng với nhau thì cần một cuốn sổ ghi lại những gì đã thấy (HashSet).

Regex engine trong Java: backtracking, possessive quantifier và catastrophic backtracking
  • Engine Java thử nhánh theo thứ tự, thất bại thì quay lại điểm lựa chọn gần nhất; match đầu tiên thắng (car|carpet trên "carpet" ra "car").
  • Greedy lấy nhiều rồi nhả, lazy lấy ít rồi thêm, possessive/atomic group lấy nhiều và không bao giờ nhả (cắt backtracking nhưng có thể đổi nghĩa).
  • Engine automaton (RE2/J) luôn chạy tuyến tính, đổi lại mất backreference và lookaround.
  • Catastrophic backtracking: một đoạn input khớp cùng một phần pattern theo nhiều cách (quantifier lồng nhau, alternation chồng lấn, .* liền nhau).
  • JDK hiện đại ghi nhớ vòng lặp */+ của group nên (a+)+b chạy tức thì; nhưng {n,m}, backreference, lồng ba tầng và dạng đa thức vẫn nổ.
  • Bẫy số 1: thêm {1,20} "cho an toàn" đưa ^(\w+\s?){1,20}$ lên 13 giây với 30 ký tự. Cách sửa là bỏ sự mơ hồ, không phải đổi quantifier.

Hình dung: engine như người đi mê cung, thử từng ngã rẽ rồi quay lại; nếu mỗi bước có hai đường tới cùng một chỗ, số lối phải thử nhân đôi theo từng bước.

ReDoS trong Java: sự cố thật, timeout tự làm và checklist phòng thủ
flowchart TD
  A["Thread RUNNABLE kẹt trong regex"] -->|"Nhận ra bằng"| B["Thread dump"]
  B --> C["Phòng thủ nhiều lớp"]
  C --> D["Pattern chỉ một cách khớp"]
  C --> E["Giới hạn độ dài trước regex"]
  C --> F["CharSequence có deadline"]
  C --> G["Input lạ: RE2/J"]
  C --> H["Lớp ký tự thay alternation"]
  • ReDoS không để lại lỗi: chỉ có thread RUNNABLE kẹt trong java.util.regex. Thread dump là cách nhận ra.
  • Sửa tận gốc: mỗi đoạn input chỉ có một cách khớp (lớp ký tự phủ định, dấu phân cách bắt buộc, neo, lookbehind).
  • Giới hạn độ dài input là lớp rẻ nhất, nhưng @Size đứng cạnh @Pattern không chặn được regex chạy.
  • Java không có timeout cho regex. Future.cancel(true) vô dụng; dùng CharSequence có deadline.
  • Pattern hay input từ người ngoài: dùng engine tuyến tính RE2/J.
  • (a|b)* trên input dài gây StackOverflowError, đi xuyên catch (Exception e); dùng [ab]*.
  • Bẫy số 1: nghĩ "đặt timeout bằng thread khác là xong". Client nhận lỗi, còn CPU vẫn bị chiếm.

Hình dung: regex mơ hồ như một ổ khoá số mà kẻ trộm biết chắc bạn sẽ thử hết mọi tổ hợp trước khi bỏ cuộc. Phòng thủ là bớt tổ hợp, giới hạn số chữ số, và đặt đồng hồ bấm giờ.

Ngày giờ, timezone

Ngày giờ trong backend: epoch, UTC, timezone, ISO 8601 và java.time
flowchart TD
  Q{Giá trị nghĩa là gì?} -->|thời điểm| I[Instant]
  Q -->|ngày trên lịch| LD[LocalDate]
  Q -->|lịch hẹn tương lai| LZ["Giờ địa phương + ZoneId"]
  E["Epoch: ms hay giây?"] --> I
  Z["Lưu zone id IANA, không offset"] --> LZ
  LZ -.-> DST["DST: ngày 23 hoặc 25 giờ"]
  S["JVM, DB, container: UTC"] --> CL["Inject Clock, ZoneId tường minh"]
  • Epoch là một con số, không có timezone. Ghi rõ đơn vị: JS/Java dùng mili giây, Unix/JWT dùng giây.
  • Offset (+07:00) chỉ là độ lệch tại một thời điểm; zone id IANA (Europe/Paris) mới mang luật DST. Lưu zone id.
  • Có DST thì một ngày có thể dài 23 hoặc 25 giờ: plusDays(1) khác plus(Duration.ofHours(24)).
  • Chọn kiểu theo ý nghĩa: Instant cho thời điểm, LocalDate cho ngày trên lịch, giờ địa phương + ZoneId cho lịch hẹn tương lai.
  • JVM, DB session, container chạy UTC; mọi phép tính theo lịch truyền ZoneId tường minh; inject Clock.
  • Bẫy số 1: LocalDate.now() không tham số lấy "hôm nay" của server, không phải của người dùng hay homestay.

Hình dung: Instant là một điểm trên dây thời gian chung của cả thế giới; timezone chỉ là chiếc đồng hồ treo tường mỗi nơi dùng để đọc điểm đó.

Lưu ngày giờ trong PostgreSQL, MySQL và JSON: timestamptz, DATETIME, Jackson và các bẫy
flowchart TD
  A{"Dữ liệu là gì?"} -->|"Thời điểm"| B["Lưu ở UTC"]
  A -->|"Lịch hẹn tương lai"| C["Giờ đồng hồ + zone id"]
  B --> D["PostgreSQL: timestamptz"]
  B --> E["MySQL: DATETIME(6) ở UTC"]
  C --> F["Instant: cột tính sẵn"]
  D --> G["JVM, Hibernate, driver đều UTC"]
  E --> G
  G --> H["JSON: RFC 3339 có Z"]
  • Thời điểm (created_at, paid_at) khác giờ đồng hồ (lịch hẹn, giờ mở cửa). Lưu nhầm loại là gốc của hầu hết bug.
  • PostgreSQL: timestamptz không lưu timezone, nó lưu UTC. timestamp lặng lẽ bỏ offset.
  • MySQL: TIMESTAMP đổi theo session và hết hạn năm 2038; hệ mới thường dùng DATETIME(6) ở UTC, ép ở driver.
  • Cả hai DB làm tròn phần lẻ của giây (MySQL mặc định 0 chữ số lẻ), nên test "lưu rồi đọc lại" fail ngẫu nhiên.
  • Lịch hẹn tương lai: lưu giờ đồng hồ + zone id làm nguồn sự thật, Instant chỉ là cột tính sẵn.
  • JSON: chuỗi RFC 3339 có Z. Bẫy số 1: new ObjectMapper() tự tạo, quên tắt WRITE_DATES_AS_TIMESTAMPS.

Hình dung: thời điểm là tia chớp, ai ở đâu cũng thấy cùng lúc; giờ đồng hồ là lời hẹn "9 giờ sáng ở Paris", chỉ có nghĩa khi biết đồng hồ của Paris chạy theo luật nào.

Bộ nhớ JVM, GC

JVM bên trong: các vùng nhớ runtime, nạp class và ClassLoader
flowchart LR
  SRC[".java"] -->|javac| CLS[".class bytecode"]
  CLS --> CL["ClassLoader: load, link, init"]
  CL --> META["Metaspace: metadata class"]
  CL --> MIRROR["Object Class trên heap: field static"]
  META --> EXE["Execution engine"]
  EXE --> INT["Interpreter"]
  EXE --> JIT["JIT C1/C2 → code cache"]
  EXE --> T["Mỗi thread: PC + stack frame"]
  T --> HEAP["Heap: object, mảng"]
  HEAP --> GC["GC dọn object không còn reachable"]
  • Mỗi thread có riêng: PC register, JVM stack (các frame), native stack. Dùng chung: heap, metaspace, code cache.
  • Object và mảng nằm trên heap; biến cục bộ và tham chiếu nằm trong frame. Field static nằm trong object Class trên heap (từ JDK 8), không nằm trong metaspace.
  • Class đi qua ba bước: loading, linking (verify, prepare, resolve), initialization (<clinit>). Khởi tạo chỉ xảy ra ở lần dùng thật đầu tiên.
  • ClassLoader có ba tầng: bootstrap, platform, application. Parent delegation: hỏi cha trước, cha không có mới tự nạp.
  • Một class được xác định bởi tên + loader đã định nghĩa nó. Hai loader nạp cùng một file .class cho ra hai kiểu khác nhau.
  • Bẫy số 1: giữ một reference tới class do loader con nạp (static map, ThreadLocal, thread chưa dừng) làm cả loader và mọi class của nó không được dọn, metaspace phình sau mỗi lần redeploy.

Hình dung: JVM là một xưởng. Metaspace là tủ bản vẽ, heap là kho thành phẩm, mỗi thread là một công nhân có bàn làm việc (stack) và tờ ghi "đang làm tới bước nào" (PC register). ClassLoader là người đi lấy bản vẽ, và hai người lấy cùng một bản vẽ về hai tủ khác nhau thì xưởng coi là hai sản phẩm khác nhau.

Garbage collector trong JVM: G1, ZGC, đọc GC log và chẩn đoán OutOfMemoryError
flowchart LR
  NEW["new Object()"] --> EDEN["Eden"]
  EDEN -->|"Minor GC: còn sống"| SUR["Survivor (tuổi +1)"]
  SUR -->|"đủ tuổi / hết chỗ"| OLD["Old"]
  EDEN -->|"chết trẻ: bỏ"| FREE["Giải phóng"]
  OLD -->|"Mixed/Major GC"| FREE
  OLD -->|"đầy, GC không cứu được"| OOM["OutOfMemoryError"]
  OOM --> DUMP["Heap dump → MAT"]
  • Rác là object không còn đường đi từ GC root (biến cục bộ của thread đang chạy, field static, thread đang sống, JNI). Vòng tham chiếu không cứu được object nào.
  • Heap chia thế hệ vì hầu hết object chết trẻ: Eden → Survivor → Old. Minor GC dọn young rẻ; dọn old đắt.
  • G1 (mặc định từ JDK 9) chia heap thành region, nhắm pause ~200 ms. ZGC làm gần hết việc song song với app, pause dưới 1 ms, đổi lại tốn CPU hơn.
  • Chọn GC theo mục tiêu: throughput (batch) → Parallel; cân bằng (đa số service) → G1; latency ổn định với heap lớn → ZGC.
  • Sáu loại OOM chỉ ra sáu chỗ khác nhau: heap, GC overhead, Metaspace, direct buffer, native thread, mảng quá lớn. Pod bị OOMKilled không phải OOM của Java.
  • Bẫy số 1: tăng -Xmx để "chữa" leak chỉ làm app chết chậm hơn. Luôn bật -XX:+HeapDumpOnOutOfMemoryError và đọc heap dump.

Hình dung: GC là người dọn phòng đi theo sợi dây từ cửa ra vào (GC root). Đồ nào còn buộc vào dây thì giữ, đồ không buộc thì vứt, kể cả hai món buộc vào nhau. Serial bắt cả nhà ra ngoài rồi mới dọn; ZGC dọn trong lúc mọi người vẫn đi lại, chỉ xin đứng yên một tích tắc.

Bộ nhớ ảo, page cache, swap và JVM trong container
  • Mỗi process có không gian địa chỉ ảo riêng; MMU dịch sang địa chỉ vật lý qua bảng trang, TLB cache các bản dịch.
  • Bộ nhớ được cấp lười: chạm lần đầu mới gây page fault và có RAM thật. VSZ lớn không đáng lo, RSS mới đáng lo.
  • Hết RAM: kernel bỏ page cache, đẩy ra swap, cuối cùng OOM killer gửi SIGKILL. Trong container là OOMKilled, exit 137, không có heap dump.
  • RSS của JVM = heap + metaspace + code cache + thread stack + direct buffer + GC + malloc. Mặc định heap = 25% limit; đo bằng NMT rồi cộng 20–30% dư.
  • RAM "free" thấp là bình thường: nhìn available. Trong container, cảnh báo theo working set, không theo usage.
  • Bẫy số 1: JVM với swap. GC chạm phần heap bị swap, pause 50 ms thành vài giây.
  • Cache coherence chạy theo cache line 64 byte, nên hai biến nóng chung một line gây false sharing; Java Memory Model mới cho bạn đảm bảo "thread kia thấy".

Hình dung: bộ nhớ ảo như số phòng trong khách sạn: mỗi khách có "phòng 201" của riêng mình trên giấy, lễ tân (MMU) tra sổ (bảng trang) để biết đó là phòng thật nào, và chỉ dọn phòng khi khách thật sự bước vào.

Reflection, annotation

Reflection, annotation và annotation processor: framework Java đọc code của bạn thế nào
flowchart LR
  SRC["Code + @Annotation"] --> JAVAC["javac"]
  JAVAC --> APT["Annotation processor: đọc SOURCE/CLASS, sinh file .java mới"]
  APT --> JAVAC
  JAVAC --> CLS[".class: giữ CLASS, RUNTIME"]
  CLS --> RUN["JVM chạy"]
  RUN --> REFL["Reflection: chỉ thấy RUNTIME"]
  REFL --> FW["Spring, JPA, Jackson, JUnit"]
  REFL --> PROXY["Dynamic proxy / CGLIB: AOP"]
  • Reflection đi qua object Class: liệt kê field, method, constructor, đọc annotation, gọi method và đổi field lúc chạy.
  • setAccessible(true) vượt private trong code của bạn, nhưng từ JDK 17 không vượt được vào bên trong JDK (InaccessibleObjectException) trừ khi --add-opens.
  • Reflection chậm hơn gọi thẳng vì JIT khó inline, có boxing và kiểm tra; framework bù lại bằng cách tra một lần rồi cache Method, hoặc sinh code.
  • Annotation chỉ là dữ liệu. @Retention(RUNTIME) thì reflection mới thấy; CLASS (mặc định) và SOURCE thì không.
  • Annotation processor chạy trong javac, đọc annotation SOURCE và sinh file mới; không sửa được class đang có (Lombok làm được vì dùng API nội bộ của javac).
  • Bẫy số 1: @Inherited chỉ có tác dụng với annotation đặt trên class cha, không với interface, method hay field.

Hình dung: annotation là tờ giấy note dán lên code. Reflection là người đọc note khi máy đang chạy; annotation processor là người đọc note lúc in sách và in thêm vài trang phụ lục. Note dán bằng loại keo "chỉ đến lúc in" (SOURCE) thì người đọc lúc chạy không bao giờ thấy.

4. Database

SQL, JOIN, GROUP BY

Database: bảng, kiểu dữ liệu, khoá chính và SQL cơ bản
flowchart TD
  F[File] -->|"thiếu transaction, ràng buộc, đồng thời"| DB[DBMS]
  DB --> TY[Chọn kiểu]
  TY --> T1["Tiền: DECIMAL"]
  TY --> T2["Id: BIGINT"]
  TY --> T3["Chuỗi: utf8mb4"]
  DB --> PK["PK clustered: ngắn, tăng dần"]
  DB --> N["NULL = không biết"]
  DB --> AL["ALTER: INSTANT / INPLACE / COPY"]
  AL -.->|bẫy| ML["Transaction dài giữ metadata lock"]
  • File không có transaction, ràng buộc hay kiểm soát đồng thời; DBMS lo những việc đó.
  • Tiền dùng DECIMAL, không dùng FLOAT. Id bảng lớn dùng BIGINT ngay từ đầu. Chuỗi dùng utf8mb4.
  • Trong InnoDB, khoá chính là clustered index: nên ngắn và tăng dần (tránh UUID v4).
  • NULL là "không biết": = NULL không bao giờ đúng, NOT IN gặp NULL ra rỗng, AVG/COUNT(col) bỏ qua NULL.
  • ALTER TABLE có ba cách chạy (INSTANT, INPLACE, COPY); ghi rõ ALGORITHM để không lỡ tay chép cả bảng.
  • Bẫy số 1: ALTER "online" vẫn treo cả bảng nếu một transaction dài đang giữ metadata lock.

Hình dung: database như kho có thủ kho: mọi người nhập xuất qua một sổ, có quy tắc, có khoá cửa, thay vì ai cũng tự ghi vào tờ giấy của mình.

Database: ERD, khoá ngoại, JOIN và GROUP BY
  • 1-1 = FK kèm UNIQUE; 1-n = FK ở bảng phía "nhiều"; n-n = bảng trung gian có PK ghép hai FK.
  • ON DELETE mặc định chặn xoá cha còn con; CASCADE tiện nhưng một DELETE có thể xoá lan sang nhiều bảng.
  • INNER JOIN giữ dòng khớp ở cả hai bảng; LEFT JOIN giữ mọi dòng bảng trái, cột bảng phải là NULL nếu không khớp.
  • Bẫy số 1: điều kiện trên bảng phải đặt ở WHERE biến LEFT JOIN thành INNER JOIN. Đặt nó vào ON.
  • WHERE lọc dòng trước khi gom nhóm, HAVING lọc nhóm sau đó. Sau LEFT JOIN, đếm bằng COUNT(cột bảng phải), không phải COUNT(*).
  • Thứ tự logic: FROM/JOIN → WHERE → GROUP BY → HAVING → SELECT → DISTINCT → ORDER BY → LIMIT. Vì thế WHERE không thấy alias.
  • Join cùng lúc hai bảng con 1-n làm nhân dòng (fan-out), SUM bị nhân theo. Gom từng bảng con trước rồi mới join.

Hình dung: JOIN giống ghép hai danh sách theo mã chung. LEFT JOIN là giữ nguyên danh sách bên trái, ai không tìm được cặp thì để ô trống.

Subquery, CTE, CTE đệ quy, window function và bảng tạm
flowchart TD
  N{"Cần gì?"} -->|"Một giá trị, một điều kiện"| SQ["Subquery: IN, EXISTS, scalar"]
  SQ -->|"Tương quan, nhiều dòng ngoài"| J["Viết lại: JOIN bảng đã tổng hợp"]
  N -->|"Chia câu dài thành bước có tên"| CTE["CTE: WITH"]
  N -->|"Cây, đồ thị"| R["WITH RECURSIVE + chặn vòng lặp"]
  N -->|"Tính theo nhóm, giữ từng dòng"| W["Window: OVER (PARTITION BY ... ORDER BY ...)"]
  N -->|"Kết quả trung gian lớn, dùng nhiều lần"| T["Bảng tạm + index + ANALYZE"]
  • Subquery tương quan (correlated, tham chiếu dòng của câu ngoài) chạy lại cho từng dòng ngoài: 200.000 dòng ngoài tốn 13,8 giây, viết lại bằng JOIN với bảng đã tổng hợp còn 110 ms.
  • CTE (WITH) là đặt tên cho một bước, không phải bảng tạm. PostgreSQL 12+ nhúng CTE vào câu chính nếu dùng một lần; ép MATERIALIZED có thể chậm 500 lần.
  • WITH RECURSIVE duyệt cây trong một câu: 5.000 node mất 8 ms so với 778 ms khi Java gửi 5.000 câu.
  • Dữ liệu có vòng lặp làm CTE đệ quy chạy mãi trên PostgreSQL. Chặn bằng mảng path, CYCLE (PG 14+) hoặc giới hạn độ sâu. MySQL tự dừng ở 1.000 vòng.
  • Window function tính trên nhóm mà giữ nguyên từng dòng. Bẫy số 1: có ORDER BY thì frame mặc định là RANGE, các dòng đồng hạng bị cộng chung, tổng luỹ kế sai.
  • Bảng tạm có thống kê thật và tạo được index, nhưng PostgreSQL không tự ANALYZE nó, và nó sống theo connection, rất dễ rò qua connection pool.

Hình dung: subquery là ghi chú kẹp giữa câu, CTE là đặt tên cho từng bước trong công thức nấu ăn, window function là chấm điểm từng học sinh mà vẫn nhìn được điểm cả lớp, bảng tạm là bày nguyên liệu đã sơ chế ra khay riêng.

Stored procedure, function và trigger: khi nào đặt logic trong database
flowchart TD
  Q{"Logic này đặt ở đâu?"} -->|"Quy tắc nghiệp vụ, gọi API, cần test nhanh"| J["Java service"]
  Q -->|"Ràng buộc dữ liệu mọi nơi ghi"| C["Constraint: PK, FK, CHECK, UNIQUE"]
  C -->|"Không diễn đạt được bằng constraint"| T["Trigger (cẩn thận)"]
  Q -->|"Xử lý hàng triệu dòng theo tập hợp"| S["Một câu SQL set-based"]
  S -->|"Nhiều bước, cần gần dữ liệu"| P["Procedure / function"]
  P --> R["Rủi ro: plan cache, volatility, dynamic SQL, version"]
  • Procedure làm một việc (gọi bằng CALL, được ghi dữ liệu, PostgreSQL cho COMMIT bên trong); function trả về giá trị và dùng được trong SELECT, WHERE.
  • Mặc định để logic nghiệp vụ ở Java: dễ test, dễ version, dễ scale. Đặt vào database khi việc xử lý nhiều dữ liệu theo tập hợp, hoặc quy tắc phải đúng cho mọi nơi ghi.
  • Plan được cache cho cả procedure lẫn prepared statement. Plan chung (generic) trên dữ liệu lệch: 57 ms so với 0,85 ms cho cùng một câu.
  • Hàm khai báo VOLATILE trong WHERE làm mất index: Seq Scan 488 ms thay vì 0,13 ms. Khai đúng STABLE/IMMUTABLE.
  • Procedure chỉ chống SQL injection khi không ghép chuỗi thành dynamic SQL. Ghép tham số vào ORDER BY vẫn bị đọc trộm dữ liệu.
  • Bẫy số 1: trigger là logic ẩn. Trigger audit theo từng dòng làm UPDATE 200.000 dòng chậm gần 3 lần, và JPA không biết trigger đã đổi gì.

Hình dung: stored procedure như món ăn nấu sẵn ở bếp nhà hàng: phục vụ nhanh vì gần nguyên liệu, nhưng muốn đổi công thức thì phải vào bếp, và cả nhà hàng dùng chung một bếp.

Thực hành SQL: JOIN, GROUP BY và chuẩn hoá qua 15 câu trên database thư viện
  • Thứ tự logic của SELECT: FROM/JOIN → WHERE → GROUP BY → HAVING → SELECT → DISTINCT → ORDER BY → LIMIT.
  • WHERE lọc dòng trước khi nhóm, HAVING lọc nhóm sau khi tổng hợp.
  • Đề có chữ "kể cả … chưa có" thì dùng LEFT JOIN và đếm COUNT(cột_bên_phải), không phải COUNT(*).
  • Bẫy số 1: điều kiện trên bảng bên phải đặt trong WHERE biến LEFT JOIN thành INNER JOIN. Đặt nó trong ON.
  • Đừng bọc cột trong hàm (DATE(col), DATEDIFF): viết thành khoảng giá trị để dùng được index.
  • "Đã từng có" dùng EXISTS: không sinh dòng trùng, dừng ở dòng khớp đầu tiên.
  • Đánh đổi: chuẩn hoá để tránh dị thường khi cập nhật, phi chuẩn hoá có chủ đích để đọc nhanh.

Hình dung: câu SELECT là một dây chuyền: gom nguyên liệu (FROM/JOIN), loại bớt (WHERE), chia rổ (GROUP BY), bỏ rổ không đạt (HAVING), rồi mới dán nhãn và xếp thứ tự.

Bài tập SQL trên database E-Learning: rating, tiến độ học và review schema
flowchart LR
  U[user] --> UC["user_course: rating"]
  C[course] --> UC
  UC --> UCL["user_course_lesson: tiến độ"]
  Q[Viết truy vấn] --> F["Fan-out: COUNT DISTINCT / CTE"]
  Q --> LJ["Lọc LEFT JOIN trong ON"]
  Q --> P["Tỉ lệ: NULLIF, 100.0"]
  Q --> RK["Giữ đồng hạng: DENSE_RANK"]
  • Rating thuộc về lượt đăng ký (user_course), không thuộc course; tiến độ từng bài nằm ở user_course_lesson.
  • Fan-out: join cha xuống con làm dòng cha lặp lại; đếm cha bằng COUNT(DISTINCT) hoặc tổng hợp từng cấp trong CTE rồi mới ghép.
  • Điều kiện lọc bảng bên phải của LEFT JOIN đặt trong ON; đặt ở WHERE thì nó thành INNER JOIN.
  • Tỉ lệ %: tử và mẫu lọc cùng điều kiện, NULLIF chống chia 0, 100.0 tránh chia nguyên.
  • LIMIT 5 cắt ngang người đồng hạng; muốn giữ thì dùng DENSE_RANK.
  • Bẫy số 1: course_id dư thừa trong user_course_lesson có thể lệch với lesson → chapter → course mà không ràng buộc nào báo.
  • Review schema: một bảng account + role tốt hơn ba bảng tài khoản; trạng thái cần ENUM/CHECK; MySQL lặng lẽ bỏ qua REFERENCES inline.

Hình dung: user_course như phiếu ghi danh: điểm đánh giá và tiến độ ghi lên phiếu của từng học viên, không ghi lên bìa khoá học.

Chuẩn hoá, thiết kế schema

Database: chuẩn hoá dữ liệu 1NF–5NF và phi chuẩn hoá
  • Chuẩn hoá = tách bảng để mỗi sự thật chỉ lưu một chỗ, tránh update/insert/delete anomaly.
  • 1NF: mỗi ô một giá trị, không nhóm cột lặp. 2NF: không cột nào chỉ phụ thuộc một phần khoá ghép. 3NF: không phụ thuộc bắc cầu PK → X → Y.
  • BCNF: vế trái của mọi phụ thuộc hàm phải là superkey. 4NF: không gộp hai tập giá trị độc lập vào một bảng. 5NF: chỉ tách ba chiều khi có quy tắc vòng.
  • OLTP thường dừng ở 3NF/BCNF; 4NF/5NF phụ thuộc quy tắc nghiệp vụ, không nhìn dữ liệu mà biết.
  • Phi chuẩn hoá chỉ khi có số đo, luôn kèm một nguồn sự thật và cơ chế đồng bộ.
  • Bẫy số 1: nhầm "ảnh chụp lịch sử" (giá lúc mua) với dữ liệu trùng lặp, và nhầm dữ liệu lặp giữa các dòng là lỗi 1NF (thật ra là 2NF/3NF).

Hình dung: mỗi sự thật như một số điện thoại trong danh bạ: ghi đúng một chỗ, ai cần thì tra theo khoá, đừng chép tay vào từng tờ giấy.

Database: bài tập thiết kế và truy vấn hệ thống thư viện
  • Trước khi code, kiểm tra mô hình có trả lời được câu hỏi nghiệp vụ không: đề thiếu cột ngày trả returned_at.
  • "Một cuốn chỉ một người mượn" nghĩa là tối đa một phiếu đang mở, không phải UNIQUE(book_id) (cả đời mượn một lần).
  • MySQL không có partial index: giả lập bằng generated column (NULL khi đã trả) + UNIQUE. PostgreSQL: UNIQUE ... WHERE returned_at IS NULL.
  • Ràng buộc trong DB (unique, CHECK, FK) chặn được race condition mà check-then-insert trong Java để lọt.
  • Truy vấn: LEFT JOIN + COUNT(cột) để hiện số 0; EXISTS không nhân dòng; điều kiện so cột trơn để dùng được index.
  • Trả sách bằng một UPDATE ... WHERE returned_at IS NULL (compare-and-set) để bấm hai lần vô hại.
  • Bẫy số 1: đề mơ hồ ("xoá", "không trễ hạn") thì hỏi lại, đừng đoán.

Hình dung: ràng buộc trong database như ổ khoá ở cửa kho. Thủ thư nào nhớ kiểm tra cũng tốt, nhưng chỉ ổ khoá mới chặn được hai người cùng lúc lấy một cuốn sách.

Quy trình data modeling: access pattern, loại bảng, khoá ngoại và table template
  • Viết danh sách truy vấn (tần suất, mục tiêu p95) trước khi vẽ bảng; đó là tiêu chí nghiệm thu của schema.
  • Bốn loại bảng: entity (có vòng đời), relation (N–M), support (dữ liệu phụ 1–N), config (danh mục ít đổi).
  • Chuẩn hoá làm nền, phi chuẩn hoá có chủ đích khi truy vấn nóng lọc ở bảng A, sắp ở bảng B: 125.000 buffer → 23.
  • Mặc định giữ khoá ngoại trong cùng database và service; bỏ khi khác shard/service, dùng gh-ost, hoặc tranh khoá.
  • Bẫy số 1: InnoDB insert dòng con khoá S dòng cha, chặn mọi UPDATE vào dòng cha; PostgreSQL thì không.
  • Cột tham chiếu 1–1 đặt ở entity sinh sau (payment_txn.order_id + UNIQUE).
  • Entity table có cột kỹ thuật version, created_*, updated_*; bảng chỉ thêm (sổ cái) bỏ updated_* và version.

Hình dung: thiết kế schema như xây kho hàng: biết trước hàng nào lấy nhiều nhất thì mới đặt kệ đúng chỗ, xây xong rồi dời kệ rất đắt.

Schema thay đổi theo thời gian: cột JSON, DDL online, kiểu dữ liệu và view
flowchart TD
  Q{Thuộc tính dùng để?} -->|"lọc, JOIN, sắp xếp, ràng buộc"| COL[Cột thật]
  Q -->|"thưa, chỉ hiển thị"| J[JSON]
  J --> IX["Index: generated column / GIN"]
  COL --> ADD["Thêm cột: INSTANT / metadata"]
  ADD -.->|"metadata lock"| ML["lock_timeout ngắn + thử lại"]
  M["Tiền: DECIMAL, không FLOAT"]
  V[View] --> VG["GROUP BY bị JOIN: tính hết"]
  V --> SI[security_invoker]
  V -.-> MV["Materialized view: nhanh, có thể cũ"]
  • Cột dự phòng c1..c6 là anti-pattern: MySQL 8 thêm cột bằng INSTANT (~3 ms trên 1 triệu dòng), PostgreSQL 11+ thêm cột có default hằng chỉ sửa metadata.
  • Trường JSON index được: generated column (MySQL), expression index hoặc GIN (PostgreSQL).
  • Thuộc tính để lọc, JOIN, sắp xếp, ràng buộc → cột thật. Thuộc tính thưa, chỉ hiển thị → JSON.
  • ALTER "online" vẫn cần metadata lock một chốc; transaction dài có thể làm cả bảng đứng. Đặt lock_timeout ngắn và thử lại.
  • Tiền: DECIMAL hoặc số nguyên đơn vị nhỏ nhất, không bao giờ FLOAT/DOUBLE. MySQL: TIMESTAMP mới là kiểu đổi theo time_zone, và dừng ở 2038.
  • Bẫy số 1 của view: view có GROUP BY bị JOIN vào sẽ được tính toàn bộ trước khi lọc (65 ms so với 0,05 ms).
  • View PostgreSQL mặc định chạy với quyền chủ view; security_invoker để kiểm quyền người gọi.

Hình dung: view là công thức nấu ăn, không phải món ăn. Mỗi lần gọi là nấu lại từ đầu; materialized view mới là món nấu sẵn để trong tủ, ăn nhanh nhưng có thể đã nguội.

Thiết kế database đặt vé máy bay: quan hệ, ghế trống và overbooking
  • Viết mỗi quan hệ thành câu có bản số và đọc cả hai chiều; chiều ngược là nơi lộ lỗi (booking khứ hồi thuộc hai chuyến).
  • Một quan hệ dựa trên một cột: chuyến bay có hai khoá ngoại tới sân bay (đi và đến).
  • Giờ bay lưu thời điểm tuyệt đối (timestamptz/UTC), múi giờ IANA nằm ở bảng sân bay.
  • Ghế trống: mỗi ghế một dòng (chọn được ghế, tranh chấp rải đều, không overbook) hay bộ đếm theo hạng (overbook được, nhưng một dòng nóng). Hãng thật kết hợp cả hai.
  • Overbooking đúng: sell_limit = floor(capacity × (1 + rate)), nhận lượt q ghế khi booked + q ≤ sell_limit, đặt ngay trong WHERE của UPDATE.
  • Bẫy số 1: công thức gốc booked < total × rate so số đã bán trước khi cộng lượt mới, nên đoàn khách làm bán vượt giới hạn.
  • Index đi từ truy vấn: cột so bằng trước, cột khoảng cuối; PostgreSQL không tự index khoá ngoại.

Hình dung: bộ đếm như quầy bán vé đứng ở rạp, chỉ đếm số người; mỗi ghế một dòng như rạp có sơ đồ chỗ ngồi, chọn được ghế nhưng không thể bán một ghế hai lần.

Đặt vé máy bay: booking chiều đi/về, ledger double-entry và lịch sử thay đổi
  • Booking = header + chiều bay (booking_direction) + dòng tiền (booking_line), như hoá đơn có line item.
  • Tiền lưu bigint theo đơn vị nhỏ nhất + mã tiền tệ; chốt quy tắc làm tròn VAT ở một chỗ.
  • total_amount trên header là phi chuẩn hoá có chủ đích: con số đã gửi sang cổng; canh bằng CHECK và truy vấn đối soát.
  • Sổ cái: mỗi giao dịch có ≥ 2 bút toán, tổng bằng 0, chỉ thêm không sửa. PostgreSQL ép cân bằng bằng constraint trigger trì hoãn tới COMMIT.
  • Bảng entry nhiều dòng thay vì hai cột nợ/có, vì tiền về trừ phí có ba chân.
  • Khoá lạc quan: UPDATE ... WHERE version = ? + ghi history trong cùng transaction. Bẫy số 1: bulk UPDATE đi vòng @Version và history.
  • Khoá lạc quan hợp với booking (ít tranh chấp), không hợp với bộ đếm ghế (bão retry).

Hình dung: booking là tờ hoá đơn, sổ cái là cuốn sổ kế toán viết bằng mực: chỉ được viết thêm dòng, sai thì ghi dòng đảo, và mỗi trang luôn cộng ra 0.

Case study data modeling: đa ngôn ngữ, sắp xếp, lịch phòng, lịch hẹn, tag và báo cáo
flowchart LR
  CS[Case study] --> T["Bản dịch: JSON hoặc bảng dịch"]
  CS --> K["Kéo thả: khoảng trống / fractional"]
  CS --> H["Homestay: một dòng mỗi ngày"]
  CS --> R["Lịch lặp: local + IANA + RRULE"]
  CS --> TG["Tag: bảng N–N"]
  CS --> CL["Click: tổng hợp theo phút"]
  J{"Trường JSON vào WHERE?"} -->|có| COL[Thành cột]
  J -->|không| KJ[Giữ JSON]
  • Bản dịch: cột JSON khi chỉ hiển thị; bảng dịch khi có quy trình dịch (metadata, ràng buộc). Luôn có ngôn ngữ dự phòng.
  • Kéo thả: số có khoảng trống + đánh số lại, hoặc khoá chuỗi (fractional indexing). Đổi sang float chỉ thêm ~43 lần chia đôi.
  • Lịch homestay: mỗi (homestay, ngày) một dòng; đặt phòng = một UPDATE có điều kiện, phải kiểm tra số dòng bằng số đêm.
  • Sự kiện lặp: lưu giờ địa phương + ID múi giờ IANA + RRULE, sinh từng buổi theo giờ địa phương. Cộng 7 ngày vào UTC lệch giờ qua DST.
  • Tag: bảng N–N là nguồn sự thật; mảng + GIN đọc nhanh nhưng không có FK và đổi tên tag đắt.
  • Tổng click: bảng tổng hợp theo phút. HyperLogLog dùng để đếm số phần tử khác nhau, không phải tổng.
  • Bẫy số 1: "tận dụng JSON" chỉ đúng cho dữ liệu đọc cùng nhau, ít ràng buộc; trường JSON lọt vào WHERE là dấu hiệu nó muốn thành cột.

Hình dung: mỗi case study là một cái cân: một bên là truy vấn chạy nhiều nhất, bên kia là ràng buộc phải giữ.

Index, EXPLAIN, phân trangLõi

Database: index, EXPLAIN, N+1, phân trang và soft delete
  • Index là B+tree 3–4 tầng, lá nối nhau: tra bằng và range scan đều rẻ.
  • InnoDB: PK là clustered index (lá chứa cả dòng); secondary index chứa PK, nên PK phải ngắn và tăng dần.
  • Composite index: cột so sánh bằng trước, cột sort/range sau cùng; chỉ dùng được theo prefix bên trái.
  • Bẫy số 1: bọc cột trong hàm hoặc ép kiểu ngầm (DATE(col)) làm index vô dụng.
  • EXPLAIN chỉ là ước lượng; EXPLAIN ANALYZE chạy thật. Đo trên dữ liệu cỡ production.
  • N+1 do lazy loading trong vòng lặp; sửa bằng JOIN FETCH, entity graph, batch fetching, DTO projection.
  • Trade-off: OFFSET nhảy được trang nhưng chậm dần; keyset nhanh đều nhưng chỉ trước/sau. Soft delete giữ lịch sử nhưng mọi query phải lọc và unique bị vỡ.

Hình dung: index là mục lục cuối sách: có thì lật thẳng tới trang, không có thì đọc từng trang; nhưng thêm trang mới là phải sửa cả mục lục.

Index bên trong: B-tree, B+tree, clustered, heap và chọn khoá chính
  • B+tree: chỉ lá chứa dữ liệu, lá nối nhau. Fan-out hàng nghìn nên 20 triệu dòng chỉ cao 3 tầng.
  • InnoDB: bảng là clustered index theo PK; secondary index lưu PK nên đọc qua nó là hai lần đi cây.
  • PostgreSQL: bảng là heap, index lưu TID; mỗi update không HOT thêm entry vào mọi index.
  • Unique cho phép nhiều NULL (MySQL, PostgreSQL); muốn chặn thì NULLS NOT DISTINCT hoặc partial index.
  • Bẫy số 1: UUIDv4 làm PK gây page split, index to gần gấp đôi, WAL gấp đôi. Dùng bigint hoặc UUIDv7.
  • B+tree không bao giờ mất cân bằng; thứ xấu đi là bloat. Đo rồi mới rebuild.
  • Tạo index trên production: CONCURRENTLY / LOCK=NONE, coi chừng index INVALID và metadata lock.

Hình dung: B+tree như mục lục sách nhiều cấp: các cấp trên chỉ ghi "chữ A–F ở trang 10", chỉ trang cuối mới có nội dung, và các trang cuối xếp liền nhau để đọc lướt một khoảng.

Các loại index ngoài B-tree: hash, GIN, GiST, bitmap và LSM-tree
  • Hash chỉ phục vụ =: hàm băm phá thứ tự nên không range, không sort.
  • GIN là inverted index: mỗi phần tử (tag, key JSON, từ) trỏ tới danh sách dòng chứa nó. Hợp với "chứa", không hợp range.
  • GiST dựng cây hộp bao cho khoảng và toạ độ; exclusion constraint trên GiST chống đặt phòng trùng, đúng cả khi chạy song song.
  • PostgreSQL không có bitmap index lưu sẵn, chỉ dựng bitmap lúc chạy. "Đếm đơn PROCESSING" giải bằng partial index (128 KB).
  • LSM-tree đổi ghi ngẫu nhiên thành ghi tuần tự, trả giá bằng read và space amplification và rủi ro compaction tụt hậu.
  • Bẫy số 1: index được chọn theo toán tử và kiểu, không theo tên cột. 'x' = ANY(tags) không dùng GIN, @> thì có.

Hình dung: B-tree là danh bạ xếp theo tên; GIN là mục lục cuối sách (từ → các trang); GiST là bản đồ chia vùng lồng nhau; LSM là sổ nháp ghi nối tiếp, thỉnh thoảng chép gọn lại.

SQL chạy thế nào và cách đọc execution plan PostgreSQL
  • Planner chọn plan rẻ nhất theo ước lượng số dòng từ statistics. Statistics cũ thì plan tệ.
  • Thứ tự logic: FROM → ON → WHERE → GROUP BY → HAVING → SELECT → DISTINCT → ORDER BY → LIMIT. Plan là thứ tự vật lý.
  • EXPLAIN chỉ ước lượng; EXPLAIN (ANALYZE, BUFFERS) chạy thật, kể cả DELETE.
  • Bốn kiểu scan: Seq (cần phần lớn bảng), Index (ít dòng), Index Only (khỏi đọc bảng nếu đã VACUUM), Bitmap (lượng dòng vừa).
  • Đọc plan từ trong ra ngoài. Bẫy số 1: actual time và rows là số của một vòng lặp, phải nhân với loops.
  • rows ước lượng lệch thực tế trên 10 lần là tín hiệu quan trọng nhất.
  • Chọn câu để tối ưu theo tổng thời gian (pg_stat_statements), không theo câu chậm nhất một lần.

Hình dung: planner như app bản đồ: nó chọn đường theo dữ liệu giao thông đã lưu (statistics), và execution plan là lộ trình nó chọn. Dữ liệu giao thông cũ thì nó dẫn bạn vào đường kẹt.

Lab index PostgreSQL trên dataset hãng bay: B-tree, hash, LIKE, composite và covering
flowchart TD
  Q{Truy vấn kiểu gì?} -->|"= một dòng"| BT["B-tree: ~4 page"]
  Q -->|"LIKE 'abc%'"| CC["COLLATE C / text_pattern_ops"]
  Q -->|"LIKE '%abc'"| TR[pg_trgm]
  Q -->|"lấy ~94% bảng"| SS[Seq Scan]
  CP[Index composite] --> ORD["Cột bằng trước, range sau"]
  CP --> INC["INCLUDE: Index Only Scan"]
  W[Mỗi index thêm] --> WR[Thêm một lần ghi]
  • B-tree tra một dòng trong 3,1 triệu dòng: 4 page thay vì ~29.600 page; số page gần như không tăng theo kích thước bảng.
  • Hash index chỉ phục vụ = và chỉ nhỉnh hơn B-tree chút xíu. Mặc định chọn B-tree.
  • Collation khác C thì B-tree thường không phục vụ LIKE 'abc%'; cần COLLATE "C"/text_pattern_ops. '%abc' cần pg_trgm.
  • Lấy phần lớn bảng (94%) thì Seq Scan đúng; ép index chậm hơn 7,5 lần.
  • Thứ tự cột composite: cột bằng trước, cột range/sort sau cùng. Bẫy số 1: "high cardinality trước" là quy tắc sai.
  • Range trên cột đầu làm mất thứ tự của cột sau: index (a, b) không bỏ được Sort cho a BETWEEN … ORDER BY b.
  • INCLUDE cho Index Only Scan mà không đổi nghĩa UNIQUE; mỗi index thêm là thêm một lần ghi cho mọi INSERT.

Hình dung: index như mục lục sách xếp theo họ rồi tên. Tìm "họ Nguyễn, tên An" rất nhanh; tìm "họ từ A tới M, tên An" thì phải lật cả nửa mục lục.

Transaction, isolation, lockingLõi

Database: transaction, isolation level và locking
  • ACID trong InnoDB: undo log lo atomicity, redo log (WAL) lo durability, lock + MVCC lo isolation.
  • REPEATABLE READ của MySQL không chặn lost update và write skew; PostgreSQL RR chặn lost update (báo lỗi để retry), chỉ SERIALIZABLE (SSI) chặn write skew.
  • Sửa lost update: SET x = x + ?, điều kiện trong WHERE, FOR UPDATE, hoặc cột version.
  • InnoDB khoá bản ghi index nó quét: UPDATE thiếu index có thể khoá cả bảng; gap lock ở RR là nguồn deadlock khó hiểu.
  • "Nếu chưa có thì tạo" phải dựa vào unique constraint, không phải SELECT ... FOR UPDATE.
  • Bẫy số 1: retry bên trong transaction vô nghĩa. Deadlock rollback cả transaction, nên vòng retry phải nằm ngoài, có giới hạn và backoff.

Hình dung: transaction như chuyển khoản ngân hàng: hoặc cả hai tài khoản cùng đổi, hoặc không gì đổi. Isolation level quyết định bạn được nhìn thấy bao nhiêu phần "đang làm dở" của người khác.

Transaction từ bên trong: WAL, MVCC và undo log
  • REPEATABLE READ của InnoDB không chặn lost update; REPEATABLE READ của PostgreSQL thì có (báo lỗi để retry).
  • SERIALIZABLE: MySQL khoá mọi dòng đọc (dễ deadlock), PostgreSQL dùng SSI (huỷ một bên). Cả hai đều cần retry cả transaction.
  • Redo log = làm lại cái đã commit (durability). Undo log = huỷ cái chưa commit và dựng phiên bản cũ (atomicity, MVCC).
  • Read view ở RR tạo ở câu đọc đầu tiên, không phải lúc BEGIN. FOR UPDATE/UPDATE luôn đọc bản mới nhất.
  • InnoDB giữ bản cũ trong undo log; PostgreSQL giữ bản cũ ngay trong bảng (cần VACUUM).
  • Bẫy số 1: một transaction mở lâu, kể cả chỉ đọc, chặn việc dọn phiên bản cũ. Đo bằng history list length: 20.000 bản chưa dọn làm một câu đọc chậm ~60 lần.

Hình dung: bảng là trang hiện tại của một tài liệu, undo log là lịch sử chỉnh sửa. Người đọc bản cũ phải lật ngược lịch sử, và chừng nào họ còn đọc thì không ai được xoá lịch sử.

Transaction gây hại: quá lớn, chạy lâu, treo giữa chừng, bị bỏ rơi
flowchart LR
  A["Transaction gây hại"] --> B["Quá lớn"]
  A --> C["Chạy lâu"]
  A --> D["Treo giữa chừng"]
  A --> E["Bị bỏ rơi"]
  B --> B2["Chia lô theo khoá chính"]
  C --> C2["Tìm gốc: index, N+1, lock"]
  D --> D2["Đưa HTTP ra ngoài"]
  E --> E2["Sửa connection leak"]
  B2 & C2 & D2 & E2 --> F["innodb_trx, pg_stat_activity"]
  F --> G["Timeout mỗi tầng, theo user"]
  • Bốn kiểu: quá lớn (sửa quá nhiều dòng), chạy lâu (BEGIN tới COMMIT quá lâu), treo giữa chừng (đứng yên giữa các câu), bị bỏ rơi (client mất, transaction còn mở).
  • Transaction quá lớn: chia lô theo khoá chính, mỗi lô một transaction ngắn và chạy lại được an toàn.
  • Không gọi HTTP bên trong @Transactional: lock và connection bị giữ suốt thời gian gọi.
  • Tìm: MySQL dùng innodb_trx + processlist Sleep; PostgreSQL dùng pg_stat_activity với state = 'idle in transaction'.
  • Trade-off: timeout ở mỗi tầng (ứng dụng, pool, database, giám sát) bắt một kiểu lỗi; đặt theo user để không giết job batch hợp lệ.
  • Bẫy số 1: connection bị leak giữ transaction mở tới 8 giờ (wait_timeout mặc định của MySQL), pool không thấy nó.

Hình dung: transaction như cầm chìa khoá phòng họp. Họp lâu, bỏ đi gọi điện giữa chừng, hay quên trả chìa đều khiến người khác đứng chờ ngoài cửa.

Connection pool và HikariCP: bên trong, cấu hình và chọn kích thước
  • Mở một connection PostgreSQL tốn TCP + TLS + xác thực + một process mới ở server. Pool trả giá đó một lần rồi cho mượn lại.
  • Pool cạn thì getConnection() chờ tối đa connectionTimeout (mặc định 30 giây) rồi ném SQLTransientConnectionException.
  • Số connection cần ≈ throughput × thời gian giữ connection (Little's Law). Giữ ngắn quan trọng hơn pool to.
  • Pool to hơn không nhanh hơn: điểm khởi đầu là (số core của DB × 2) + số đĩa, và tổng mọi instance phải nhỏ hơn max_connections.
  • maxLifetime phải ngắn hơn mọi timeout của DB, LB, NAT; keepaliveTime giữ connection rảnh còn sống.
  • Bẫy số 1: gọi HTTP bên trong @Transactional. Đo thật: giữ connection thêm 50 ms làm cùng 200 task chậm từ 55 ms lên 1.100 ms.

Hình dung: pool là bãi 10 xe của công ty. Ai mượn xe đi ăn trưa thì người cần chở hàng phải xếp hàng; mua thêm xe không giúp nếu con đường (database) chỉ chịu chừng ấy xe.

Lock trong InnoDB: từ global lock tới gap lock, đọc bằng data_locks
  • Đọc-kiểm tra-ghi là race check-then-act; bọc trong transaction RR vẫn sai vì SELECT thường không khoá.
  • Cách rẻ nhất: gộp điều kiện vào câu ghi (... WHERE amount >= 30). Nếu cần đọc trước thì FOR UPDATE, không phải FOR SHARE (dễ deadlock).
  • UPDATE theo khoá chính so sánh bằng chỉ lấy một record lock (X,REC_NOT_GAP) ở cả RR lẫn RC.
  • Ở RR, InnoDB khoá khoảng index đã quét (gap, next-key) để chống phantom; RC khoá ít hơn hẳn.
  • Bẫy số 1: UPDATE trên cột không index ở RR khoá cả bảng. Đừng đoán, hãy đọc data_locks trên đúng phiên bản bạn dùng.
  • Dòng nóng: giữ khoá 5 ms thì tối đa ~200 transaction/giây, thêm máy chủ không giúp.

Hình dung: record lock là khoá một căn phòng; gap lock là chặn hành lang giữa hai phòng để không ai xây thêm phòng mới vào đó.

Optimistic hay pessimistic locking: đo trên bài đặt vé 100 ghế
flowchart TD
  A{"Mức tranh chấp?"} -->|"Thấp"| B["Optimistic: kiểm version"]
  A -->|"Dòng nóng"| C["Pessimistic: người sau chờ"]
  A -->|"Bộ đếm ghế"| D["UPDATE có điều kiện"]
  A -->|"Nhiều instance"| G["Distributed lock có TTL"]
  B --> E["Thất bại thì retry"]
  C --> F["Khoá theo thứ tự id"]
  G --> H["Kèm version làm fencing"]
  • Pessimistic: khoá trước, người sau chờ. Optimistic: kiểm version lúc ghi, người sau thất bại và thử lại.
  • Chọn theo mức contention (tranh chấp): thấp thì optimistic, dòng nóng thì pessimistic hoặc conditional update.
  • Với bộ đếm (số ghế còn), UPDATE ... WHERE available_seats > 0 là mặc định: đúng và nhanh nhất (203 ms, 0 retry).
  • Bẫy số 1: optimistic trên dòng nóng sinh retry storm, 176/400 khách bị từ chối khi vẫn còn ghế.
  • Distributed lock có TTL nên có lúc hết hạn giữa chừng; luôn kèm version làm fencing token ở database (không có: bán 311 vé cho 100 ghế).
  • synchronized chỉ khoá trong một JVM; dữ liệu trong database phải khoá ở database.
  • Chống deadlock bằng khoá theo thứ tự cố định (id nhỏ trước), không phải bằng "trừ trước, cộng sau".

Hình dung: pessimistic là xếp hàng trước quầy, optimistic là ai cũng chạy tới quầy và người đến sau bị bảo "quay lại từ đầu", conditional update là quầy tự động chỉ nhả vé khi còn vé.

Đặt vé máy bay: giữ ghế đúng khi nhiều người cùng đặt
flowchart TD
  X[Check-then-act] -->|bán trùng| BAD[Sai]
  Q{Mô hình chỗ?} -->|bộ đếm| U["UPDATE có điều kiện + đếm dòng"]
  Q -->|tự xếp ghế| S["FOR UPDATE SKIP LOCKED"]
  Q -->|khách chọn ghế| O["ORDER BY seat_code FOR UPDATE"]
  U -.-> H["Dòng nóng: trần ≈ 1/giữ khoá"]
  S -.->|bẫy| RC["Hết chỗ? Đếm lại không khoá"]
  EX[Hết hạn giữ chỗ] --> J["Job dọn + điều kiện lười"]
  LY["Nhiều lớp: app, schema, đối soát"]
  • Check-then-act (đọc, kiểm tra trong Java, rồi ghi) bán trùng kể cả trong @Transactional, vì SELECT thường không khoá gì.
  • Bộ đếm: một câu UPDATE ... WHERE booked + :q <= sell_limit rồi đếm số dòng; không cần SELECT trước.
  • Dòng nóng: trần ≈ 1 / thời gian giữ khoá. Giữ 2 ms ≈ 500 lượt/giây, giữ 200 ms chỉ còn 5.
  • Tự xếp ghế: FOR UPDATE SKIP LOCKED. Khách tự chọn ghế: khoá mọi ghế trong một câu ORDER BY seat_code FOR UPDATE.
  • Bẫy số 1: SKIP LOCKED báo hết chỗ oan khi ghế chỉ đang bị giữ tạm; kiểm tra lại bằng câu đếm không khoá.
  • Hết hạn giữ chỗ: dùng cả job dọn lẫn điều kiện lười; không trả ghế khi thanh toán đang dở.
  • Không tin một lớp: ứng dụng + ràng buộc schema + truy vấn đối soát.

Hình dung: bộ đếm là một quầy vé duy nhất, ai đứng ở quầy càng lâu thì cả hàng càng chậm; bảng ghế là mỗi ghế một quầy riêng.

ORM, JPA, HibernateLõi

ORM và JPA: JDBC, Hibernate, entity và repository
  • Các tầng: Spring Data JPA (sinh repository) → JPA (đặc tả) → Hibernate (implementation) → JDBC + driver → DB.
  • Entity cần @Id, constructor không tham số (protected), không final; enum lưu bằng EnumType.STRING.
  • IDENTITY tắt batch insert; SEQUENCE batch được; UUID thì chọn v7 có thứ tự.
  • Connection bị giữ suốt transaction, không chỉ lúc chạy SQL. Pool lớn không làm DB nhanh hơn.
  • Production: Flyway/Liquibase + ddl-auto=validate; migration đã chạy là bất biến.
  • equals theo id (qua getter, dùng instanceof), hashCode hằng số; không Lombok @Data trên entity.
  • Bẫy số 1: gọi API chậm bên trong @Transactional làm cạn pool.

Hình dung: ORM là phiên dịch viên giữa hai ngôn ngữ (object và bảng); connection pool là một quầy có 10 nhân viên, khách nào ngồi lâu thì người sau phải xếp hàng.

ORM và JPA: quan hệ entity 1-1, 1-n, n-n và mappedBy
  • FK đặt ở phía "nhiều"; 1-1 đặt ở bảng phụ thuộc kèm UNIQUE; n-n cần bảng trung gian.
  • Owning side = bên giữ FK (@JoinColumn/@JoinTable); bên có mappedBy là inverse side. Slide gọi ngược.
  • Bẫy số 1: chỉ sửa phía mappedBy thì FK vẫn null. Dùng helper method cập nhật cả hai chiều.
  • Mọi quan hệ để LAZY, fetch có chủ đích khi cần.
  • Cascade ALL/orphanRemoval chỉ cho composition thật (con không sống thiếu cha); không bao giờ cho @ManyToMany.
  • @ManyToMany dùng Set, không dùng List. Quan hệ cần thêm cột thì tách thành entity trung gian.

Hình dung: FK giống tên chủ ghi trên giấy đăng ký xe. Danh sách xe trong sổ tay của chủ (mappedBy) chỉ để tra cứu; muốn đổi chủ thật thì phải sửa giấy đăng ký.

ORM và JPA: ánh xạ schema E-Learning, DTO và vòng lặp JSON
  • 1-1 User–FullName: FK user_id ở full_name nên FullName là owning side, kèm unique = true.
  • n-n thuần (User–Address) dùng @ManyToMany; n-n có thuộc tính (User–Course có rating, status) phải thành entity UserCourse với @EmbeddedId + @MapsId.
  • Tiến độ user_course_lesson: FK ghép (user_id, course_id) sang user_course chặn ghi khi chưa đăng ký, nhưng không đảm bảo bài thuộc đúng khoá.
  • Sửa slide: Tearcher, Lession, SLICE; tránh tên order và user (từ khoá SQL); lưu enum dạng chuỗi.
  • Bẫy số 1: trả entity hai chiều ra API làm Jackson lặp vô hạn, và trả entity là lộ mọi cột, kể cả password.
  • Trade-off: @JsonIgnore sửa nhanh nhưng mất một chiều và vẫn lộ cột; DTO map trong service tốn thêm một lớp nhưng kiểm soát hoàn toàn JSON.

Hình dung: entity là hồ sơ gốc trong tủ lưu trữ, DTO là bản trích lục: chỉ chép đúng những dòng người nhận cần, không đưa cả tập hồ sơ ra quầy.

ORM và JPA: persistence context, dirty checking và N+1
  • Persistence context = cache cấp 1 gắn với một transaction: một dòng DB ứng với đúng một object Java.
  • Bốn trạng thái: transient, managed, detached, removed. merge trả về bản managed mới, object truyền vào vẫn detached.
  • Dirty checking: entity managed bị sửa thì tự có UPDATE khi flush, không cần save. Flush khác commit.
  • Mặc định LAZY mọi quan hệ, fetch có chủ đích theo từng use case. EAGER là quyết định tĩnh mọi màn hình phải trả giá.
  • N+1: 1 query lấy N dòng cha, rồi N query lazy lấy quan hệ. Chữa bằng fetch join, @EntityGraph, batch fetching hoặc DTO projection.
  • Bẫy số 1: join fetch collection kèm Pageable thì phân trang trong RAM, bảng lớn là OOM.

Hình dung: persistence context như bàn làm việc của thủ thư: hồ sơ đã mượn ra nằm trên bàn (không đi kho lần nữa), thủ thư ghi lại chỗ bị sửa và cuối ngày (commit) mới cập nhật vào kho.

ORM và JPA: JPQL, native query, @Transactional và locking
  • Derived query cho 1–2 điều kiện; JPQL cho truy vấn cố định có join/aggregate; native cho tính năng riêng của DB; Specification cho bộ lọc động.
  • @Modifying (bulk update/delete) cần transaction, và bỏ qua persistence context, @Version, cascade, callback.
  • @Transactional chạy qua proxy: this.method(), method private/final thì không có transaction.
  • Mặc định chỉ rollback với RuntimeException/Error; nuốt exception của method con REQUIRED gây UnexpectedRollbackException.
  • Chống lost update: @Version khi xung đột hiếm, FOR UPDATE khi xung đột nhiều, conditional UPDATE khi thao tác đơn giản.
  • Tắt open-session-in-view: nó giữ connection suốt request và che N+1.
  • Bẫy số 1: tưởng có transaction mà không có (self-invocation), hoặc tưởng rollback mà vẫn commit (checked exception).

Hình dung: proxy của @Transactional như lễ tân: khách đi qua cửa chính thì được mở sổ (transaction). Người trong nhà gọi nhau qua this thì lễ tân không hề biết.

Redis, NoSQL

Redis bên trong: vì sao nhanh, lưu dữ liệu thế nào và xoá key hết hạn ra sao
  • Nút thắt của Redis là mạng và bộ nhớ, không phải CPU: một GET tốn vài trăm ns CPU, một vòng mạng tốn 100–500 µs.
  • Thực thi lệnh vẫn một luồng (kể cả Redis 7): không lock, mỗi lệnh tự nguyên tử. io-threads (bản 6) chỉ song song đọc/ghi socket.
  • Bẫy số 1: một lệnh O(N) (KEYS *, HGETALL hash khổng lồ) chặn mọi client. Dùng SCAN.
  • Tập nhỏ lưu nén (listpack, intset), vượt ngưỡng thì chuyển hẳn sang hashtable/skiplist: hash 513 field tốn gấp 5,6 lần hash 512 field.
  • Key hết hạn bị xoá theo hai cách: thụ động khi có người đọc, chủ động bằng vòng lấy mẫu 10 lần/giây.
  • Trade-off chính: cache thuần dùng allkeys-lru/lfu; dữ liệu không được mất dùng noeviction và tách instance.

Hình dung: Redis là một quầy thu ngân duy nhất cực nhanh. Không bao giờ có hai người tranh nhau một ngăn kéo, nhưng một khách thanh toán lâu thì cả hàng phải chờ.

Redis: persistence, replication, Sentinel và Cluster
  • RDB = snapshot toàn bộ qua fork(): nạp nhanh, nhưng mất mọi thay đổi từ lần chụp cuối.
  • AOF everysec (mặc định) mất tối đa ~1 giây khi cả máy chết; tiến trình chết thì không mất gì đã write().
  • Hybrid (mặc định từ 5.0): base dạng RDB + đuôi dạng AOF, nạp nhanh mà mất ít.
  • Replication bất đồng bộ: lệnh đã trả "OK" có thể mất khi failover. WAIT, min-replicas-to-write chỉ thu hẹp cửa sổ.
  • Sentinel: quorum đánh dấu master chết, nhưng bầu leader cần đa số, nên tối thiểu 3 sentinel.
  • Cluster: 16.384 slot, CRC16(key) mod 16384; lệnh nhiều key chỉ chạy trong một slot, gom bằng hash tag {...}.
  • Bẫy số 1: fork() trên instance lớn chặn luồng chính hàng trăm ms và có thể gây OOM. Không chế độ nào làm Redis thành kho không mất dữ liệu.

Hình dung: RDB là ảnh chụp cả căn phòng, AOF là cuốn nhật ký ghi từng việc; replica là người chép lại nhật ký, nhưng luôn chép chậm vài dòng.

Redis: chọn cấu trúc dữ liệu cho bài toán thật
flowchart TD
  A{"Bài toán là gì?"} -->|"Cache, đếm, lock"| B["String"]
  A -->|"Sửa từng field"| C["Hash"]
  A -->|"Hàng đợi không ack"| D["List"]
  A -->|"Cần ack"| E["Stream"]
  A -->|"Like, khử trùng"| F["Set"]
  A -->|"Xếp hạng, hàng đợi trễ"| G["Sorted set"]
  G --> H["Claim nguyên tử"]
  H --> I["DB vẫn là nguồn sự thật"]
  • Chọn đúng cấu trúc = một round-trip thay vì năm, và hết race condition.
  • Hash: đọc/sửa từng field bằng một lệnh nguyên tử. Chuỗi JSON: khi luôn đọc/ghi cả object.
  • List làm hàng đợi không có ack: BRPOP xong rồi crash là mất message. Cần ack thì dùng Stream.
  • Set: like, khử trùng, bạn chung (SINTER trên tập lớn chặn cả Redis). Sorted set: bảng xếp hạng, hàng đợi trễ.
  • Bẫy số 1: đọc rồi ghi/xoá ở hai lệnh riêng. Đo được 784 lần xử lý trùng trên 2.000 cuốc.
  • Đánh đổi: Redis nhanh nhưng có thể mất dữ liệu; DB vẫn là nguồn sự thật.

Hình dung: Redis là hộp đồ nghề, mỗi kiểu dữ liệu là một dụng cụ. Nhét mọi thứ vào chuỗi JSON là chỉ dùng mỗi cái búa.

5. Backend với Spring

Spring Boot: auto-config, cấu hình, vòng đời

Spring Boot từ bên trong: auto-configuration, cấu hình, profile và vòng đời khởi động
  • Auto-config là các class @AutoConfiguration liệt kê trong file META-INF/spring/...AutoConfiguration.imports, không được component scan tìm ra.
  • Mỗi auto-config có điều kiện (@ConditionalOnClass, @ConditionalOnProperty, @ConditionalOnMissingBean...). Bạn tự khai báo bean là nó lùi lại.
  • Muốn biết vì sao một bean có hay không: chạy --debug (condition evaluation report) hoặc /actuator/conditions.
  • Thứ tự ưu tiên: tham số dòng lệnh > biến môi trường > file theo profile > application.properties. Cùng chỗ thì .properties thắng .yml.
  • Gom cấu hình vào @ConfigurationProperties (record, có kiểm tra) thay vì rải @Value: sai là chết ngay lúc khởi động.
  • Bẫy số 1: viết @ConditionalOnMissingBean trong class @Configuration thường; nó phụ thuộc thứ tự quét bean và có thể không lùi lại.

Hình dung: auto-configuration như nhân viên setup phòng họp: thấy có máy chiếu (thư viện trên classpath) thì cắm sẵn dây, nhưng nếu bạn đã tự mang dây (bean của bạn) thì họ để yên.

Spring MVC, form, upload, phân trang

Spring MVC: DispatcherServlet, controller và view
  • Mọi request vào DispatcherServlet; nó hỏi HandlerMapping ai xử lý, nhờ HandlerAdapter gọi controller, rồi nhờ ViewResolver biến tên view thành trang.
  • Bảng URL → method được dựng một lần lúc khởi động, không quét controller ở mỗi request.
  • @Controller trả tên view (render HTML ở server); @RestController ghi object thành JSON vào body.
  • Sau POST thành công thì redirect (PRG), dùng flash attribute để mang thông báo qua redirect.
  • Trong Spring Boot, đừng thêm @EnableWebMvc: nó tắt auto-config MVC; thí nghiệm cho thấy file tĩnh trả 404.
  • Bẫy số 1: tên view bắt đầu bằng /. Với JSP + Spring Security 6, đường dẫn có // bị firewall chặn khi forward; với Thymeleaf, chạy trong IDE được nhưng lỗi 500 trong fat jar.

Hình dung: DispatcherServlet là lễ tân khách sạn. Lễ tân không tự dọn phòng hay nấu ăn; lễ tân tra sổ xem việc này của bộ phận nào, chuyển đi, rồi nhận kết quả trả cho khách.

Form binding và validation trong Spring MVC
  • @ModelAttribute tạo object, chép từng tham số request vào field qua WebDataBinder, đổi kiểu (String → enum, số, ngày). Lỗi đổi kiểu là binding error (typeMismatch), khác lỗi validation.
  • Đừng bind thẳng entity: client gửi thêm role=ADMIN là được ghi. Dùng form DTO chỉ có field được phép sửa.
  • Bean Validation là spec, Hibernate Validator là implementation. spring-boot-starter-validation mang cả hai, không cần tự khai báo version.
  • BindingResult phải đứng ngay sau tham số @Valid. Đặt sai chỗ thì handler không chạy, người dùng nhận 400 thay vì form có lỗi.
  • Validator mức class (so hai field) và validator inject repository (email trùng) đều làm được, nhưng email trùng vẫn cần unique constraint trong DB.
  • Sau POST thành công: redirect (PRG), thông báo bằng flash attribute. Xoá bằng POST + CSRF, không bằng link GET.

Hình dung: binder là nhân viên nhập liệu chép từ tờ đơn giấy sang hồ sơ; validator là người duyệt hồ sơ. Nhân viên chép sai kiểu (ghi chữ vào ô số) là lỗi binding; hồ sơ chép đúng nhưng thiếu chữ ký là lỗi validation.

Upload file trong Spring MVC: nhận, kiểm, lưu và trả file an toàn
flowchart TD
  A["Form multipart/form-data"] --> B["MultipartFile"]
  B --> C{"Quá 1MB hoặc 10MB?"}
  C -->|"Có"| D["Bắt MaxUploadSizeExceededException"]
  C -->|"Không"| E["Kiểm magic bytes"]
  E --> F["Tự đặt tên UUID"]
  F --> G["Đường dẫn trong thư mục gốc"]
  G --> H["Ghi bằng stream"]
  H --> I["Object storage, DB lưu key"]
  I -.->|"Rollback"| J["Dọn file mồ côi"]
  • Form upload cần method="post" và enctype="multipart/form-data"; controller nhận MultipartFile. Spring Boot tự cấu hình resolver.
  • Mặc định mỗi file tối đa 1MB, cả request 10MB. Quá giới hạn thì Spring ném MaxUploadSizeExceededException, nên bắt nó để trả trang lỗi rõ ràng.
  • Không lưu vào servletContext.getRealPath(...): chạy bằng jar thì đó là thư mục tạm, deploy lại là mất file.
  • Không tin tên file và Content-Type client gửi: tự sinh tên (UUID), đoán loại file theo magic bytes, chuẩn hoá đường dẫn và kiểm nó vẫn nằm trong thư mục gốc.
  • Ghi file bằng stream, không getBytes() cả file vào RAM.
  • Nhiều instance hay cần backup thì dùng object storage (S3, MinIO); DB chỉ lưu key của file.

Hình dung: upload như nhận một kiện hàng không rõ người gửi: không dán nhãn theo lời người gửi, tự mở ra xem bên trong là gì, tự dán mã kho, và cất vào đúng kệ của mình.

Phân trang và lọc động trong Spring: Pageable, Page, Slice và JPA Specification
flowchart LR
  A["URL: page, size, sort, lọc"] --> B["Controller: Pageable + filter"]
  B --> C["Whitelist cột sort, enum giá"]
  C --> D["Specification.allOf"]
  D --> E["(giá1 OR giá2) AND hãng"]
  E --> F{"Cần tổng số dòng?"}
  F -->|"Có"| G["Page: thêm count(*)"]
  F -->|"Xem thêm"| H["Slice: lấy size + 1"]
  • Controller nhận Pageable (Spring tự đọc page, size, sort), repository trả Page<T> = dữ liệu trang + tổng số dòng.
  • Pageable đếm trang từ 0. Muốn URL đếm từ 1 thì bật spring.data.web.pageable.one-indexed-parameters=true; chặn size bằng max-page-size.
  • Page chạy thêm một câu count(*); Slice chỉ lấy size + 1 dòng để biết còn trang sau không, rẻ hơn cho "xem thêm".
  • Specification<T> là một mảnh WHERE (một Predicate); ghép bằng Specification.allOf(...), mảnh null bị bỏ qua.
  • Nhiều khoảng giá phải OR với nhau trước, rồi mới AND với hãng và mục đích: (r1 OR r2) AND factory IN (...).
  • Bẫy số 1: tham số sort và giá trị lọc đi thẳng từ URL. Chỉ nhận cột trong danh sách trắng, và chỉ nhận khoảng giá có trong enum.

Hình dung: Pageable là số trang và số dòng mỗi trang của một cuốn danh bạ; Specification là những tấm lọc trong suốt chồng lên nhau, tấm nào không dùng thì rút ra.

HTTP, REST, thiết kế APILõi

Web và HTTP: Internet, HTTPS, method, status code và các phiên bản HTTP
  • Một request đi qua DNS (tên → IP), TCP (kết nối tin cậy), TLS (mã hoá), rồi mới tới HTTP.
  • Safe = không đổi trạng thái server; idempotent = gọi 1 hay N lần, trạng thái cuối như nhau. POST không idempotent, PATCH không đảm bảo.
  • Retry POST an toàn nhờ Idempotency-Key + UNIQUE constraint. GET không bao giờ được có side effect.
  • 401 = chưa xác thực, 403 = không có quyền. 4xx đừng retry (trừ 408, 429); 502/503/504 retry với backoff.
  • HTTP/2 multiplex trên một TCP connection nhưng còn head-of-line blocking ở TCP; HTTP/3 chuyển sang QUIC để hết.
  • Bẫy số 1: HTTP client không timeout, tạo mới mỗi request. Phải dùng chung (connection pool) và luôn đặt connect/read timeout.
  • CORS do trình duyệt thực thi để bảo vệ người dùng, không thay thế xác thực ở server.

Hình dung: gửi thư qua bưu điện: DNS là danh bạ, TCP là chuyển phát có ký nhận, TLS là phong bì niêm phong, method và status code là mẫu thư cả hai bên đều hiểu.

REST API: nguyên tắc REST, quy ước thiết kế API và cấu trúc dự án Spring Boot
  • Spring Boot = Spring + auto-configuration + starter/BOM + server nhúng. Bạn vẫn override được mọi mặc định.
  • REST là phong cách kiến trúc với sáu ràng buộc; phần lớn API "REST" chỉ đạt level 2 Richardson, gần như không ai làm HATEOAS.
  • URL: danh từ số nhiều, kebab-case, có /v1. Naming JSON (snake_case hay camelCase) chỉ cần nhất quán.
  • Offset pagination chậm dần ở trang sâu và lặp/nhảy phần tử; cursor (keyset) ổn định nhưng không nhảy trang được.
  • Version đặt ở đâu không quan trọng bằng chính sách tương thích: thêm field thì tương thích, đổi tên/xoá/đổi kiểu là breaking.
  • Lỗi theo RFC 9457 Problem Details; ETag + If-Match là optimistic locking trên HTTP.
  • Bẫy số 1: trả thẳng entity ra API (lộ field, lazy loading, schema DB thành hợp đồng). Luôn đi qua DTO.

Hình dung: API là thực đơn của nhà hàng: khách gọi món theo tên trên thực đơn (URL + method), không cần biết bếp (controller → service → repository) nấu thế nào, và thực đơn đổi thì phải báo trước (versioning).

REST API nâng cao: method idempotent, URL qua gateway, phân trang và sắp xếp
mindmap
  root((REST API nâng cao))
    Idempotent
      PUT, DELETE idempotent
      POST không, PATCH không đảm bảo
      Retry chỉ với idempotent
    URL
      Tên service chỉ cho nội bộ
    Phân trang
      OFFSET chậm và sót dòng
      Cursor: lấy sau dòng cuối
      Deferred join vẫn theo offset
    Sort qua whitelist
  • Idempotent = gọi 1 hay N lần thì trạng thái server như nhau, không cần response giống nhau (DELETE lần hai trả 404 vẫn đúng).
  • PUT, DELETE idempotent; POST không; PATCH không đảm bảo. Retry tự động chỉ an toàn với method idempotent.
  • Tên service trong URL giúp gateway route theo prefix nhưng lộ cấu trúc nội bộ: tách service là breaking change.
  • OFFSET có hai vấn đề: chậm O(offset) và sót/lặp dòng khi dữ liệu đổi giữa hai trang. Bẫy số 1: job đồng bộ lặp theo số trang sẽ mất dữ liệu.
  • Cursor pagination: khoá sort duy nhất (thêm id), index khớp ORDER BY, cursor mờ; đổi lại không nhảy trang được.
  • Deferred join giảm ~10 lần số trang đọc nhưng vẫn O(offset); trên PostgreSQL cần VACUUM mới nhanh.
  • Sort phải qua whitelist: chống SQL injection và chặn full scan.

Hình dung: OFFSET là "đếm 100.000 trang sách rồi đọc tiếp", cursor là "mở đúng chỗ kẹp bookmark".

REST API nâng cao: export bất đồng bộ, Idempotency-Key và tài liệu API
  • Việc lâu hơn timeout của gateway (thường 60 giây) thành async job: POST trả 202 + Location, client hỏi trạng thái, tải kết quả qua presigned URL.
  • Worker đọc DB theo luồng (fetch size, cursor phía server), upload multipart: bộ nhớ không đổi dù file to cỡ nào.
  • Webhook phải ký HMAC trên raw body + timestamp; receiver dedupe theo event_id. API trạng thái luôn phải có để dự phòng.
  • UNIQUE constraint chưa phải idempotency: retry phải nhận lại đúng response lần đầu; cùng key khác body → 422; đang xử lý → 409 hoặc chờ.
  • Mã lỗi 6 chữ số = HTTP status + số thứ tự nghiệp vụ; prefix luôn khớp status thật, kiểm bằng test.
  • Bẫy số 1: tạo job bằng GET. Crawler, prefetch, retry của proxy gọi lại GET thoải mái, mỗi lần là một job nặng mới.

Hình dung: async job như gửi đồ ở tiệm giặt: đưa đồ, nhận phiếu (202 + Location), lát quay lại hỏi bằng phiếu đó. Idempotency-Key là số phiếu: đưa lại cùng phiếu thì nhận lại đúng túi đồ cũ, không bị giặt lần hai.

DTO, response và validation cho REST API Spring Boot
flowchart LR
  C[Client] -->|"Request DTO + validate"| CT[Controller]
  CT --> SV[Service]
  SV --> DB["Entity + UNIQUE trong DB"]
  SV -.-> FA["findAllById: so số lượng → 404"]
  SV -->|Response DTO| CT
  CT -->|"201 + Location / 204"| C
  SV -.->|ném exception| AD[ControllerAdvice]
  AD -->|ProblemDetail| C
  • POST tạo mới trả 201 + header Location, DELETE trả 204 không body, lỗi thì ném exception cho advice xử lý.
  • Thành công: envelope gọn (data, meta) hoặc body trần; lỗi: ProblemDetail. Đừng lặp lại HTTP status trong body.
  • Không bao giờ trả entity: lộ password, LazyInitializationException, đệ quy JSON, khoá chặt schema vào API.
  • Request DTO và response DTO là hai hợp đồng khác nhau; record + from() đủ cho đa số dự án.
  • PATCH cần phân biệt "không gửi" với "gửi null"; DTO toàn field nullable không làm được việc đó.
  • findAllById bỏ qua im lặng id không tồn tại: phải so số lượng rồi báo 404.
  • Bẫy số 1: validate đặt trên entity thay vì DTO, và tin vào câu kiểm trùng trong code thay vì UNIQUE của database.

Hình dung: DTO là quầy giao dịch của ngân hàng: khách chỉ thấy phiếu điền và biên lai, không bao giờ thấy sổ cái bên trong.

IoC, DI, Spring containerLõi

IoC và Dependency Injection: Spring container hoạt động thế nào
  • IoC là nguyên lý (framework nắm quyền tạo và nối object); DI là cách hiện thực nó (dependency được đưa vào object).
  • Bean = object do container tạo và quản lý. Singleton được tạo sẵn lúc startup, nên lỗi cấu hình lộ ra ngay (fail fast).
  • Constructor injection là mặc định: field final, test bằng new, vòng phụ thuộc báo ngay lúc startup.
  • Singleton dùng chung cho mọi thread, nên phải stateless. Prototype inject vào singleton chỉ được lấy một lần.
  • @Transactional, @Async, @Cacheable chạy qua proxy. Bẫy số 1: gọi this.method() trong cùng class không qua proxy, annotation bị bỏ qua.
  • Circular dependency: constructor injection báo lỗi, từ Boot 2.6 bị cấm mặc định; cách đúng là thiết kế lại.

Hình dung: container là nhà máy giao xe tận nhà: bạn chỉ nói "tôi cần xe máy", nhà máy lo sản xuất, lắp ráp và giao tới.

Spring AOP và BeanPostProcessor: proxy, pointcut và thứ tự advice
flowchart LR
  BD[BeanDefinition] --> BF[BFPP sửa định nghĩa]
  BF --> NEW[Tạo instance + inject]
  NEW --> B1[BPP before + @PostConstruct]
  B1 --> INIT[afterPropertiesSet, init-method]
  INIT --> B2[BPP after: auto-proxy creator]
  B2 --> PX[Proxy vào context]
  C[Caller] --> PX
  PX --> ADV[Chuỗi advice theo @Order]
  ADV --> T[Object thật]
  T -. "this.method()" .-> T
  • AOP tách việc lặp lại ở nhiều nơi (log, transaction, phân quyền, đo thời gian) ra một aspect; Spring cài nó bằng proxy bọc ngoài bean.
  • Proxy được tạo trong postProcessAfterInitialization của một BeanPostProcessor (AnnotationAwareAspectJAutoProxyCreator). Không có BPP thì không có AOP.
  • Spring AOP chỉ chặn lời gọi method đi qua proxy: không chặn this.method(), method private/final/static, constructor hay field.
  • Trong một aspect: @Around (trước) → @Before → method → @AfterReturning/@AfterThrowing → @After → @Around (sau). Giữa các aspect: @Order nhỏ hơn bọc ngoài cùng.
  • BFPP sửa định nghĩa bean trước khi tạo; BPP sửa hoặc thay instance sau khi tạo.
  • Bẫy số 1: bean bị inject vào một BPP được tạo quá sớm, trước bộ tạo proxy, nên mất mọi aspect mà không báo lỗi (chỉ có một dòng WARN).

Hình dung: proxy là lễ tân đứng trước phòng làm việc: khách gọi qua lễ tân thì được ghi sổ, kiểm thẻ, bấm giờ; người trong phòng tự nói chuyện với nhau thì lễ tân không biết.

Spring Boot, xử lý lỗi toàn cục

Custom exception và xử lý lỗi tập trung trong Spring Boot: @RestControllerAdvice, ProblemDetail, validation
  • Lỗi nghiệp vụ là exception unchecked mang mã lỗi ổn định (enum gồm HTTP status + message mặc định).
  • Controller không try-catch; một @RestControllerAdvice map exception sang HTTP status, body và mức log.
  • Trả lỗi dạng ProblemDetail (RFC 9457): type, title, status, detail + code, traceId, errors.
  • Không bao giờ trả stack trace, SQL, message lỗi hệ thống cho client. Chi tiết vào log, client nhận traceId.
  • Lỗi từ filter/Spring Security không tới @ControllerAdvice: dùng AuthenticationEntryPoint, AccessDeniedHandler.
  • Hầu hết constraint Bean Validation coi null là hợp lệ; cần thêm @NotNull/@NotBlank.
  • Bẫy số 1: @Transactional vẫn commit khi ném checked exception; và check-then-insert có race, UNIQUE constraint mới là chốt chặn thật.

Hình dung: controller như nhân viên quầy chỉ việc chuyển khiếu nại lên; @RestControllerAdvice là một phòng chăm sóc khách hàng duy nhất trả lời theo cùng một mẫu.

Lỗi thường gặp trong Spring Boot và cách debug: từ trùng port tới 403 thành 500
flowchart TD
  S[Triệu chứng] --> Q{Loại lỗi?}
  Q -->|stack trace| ST["Caused by cuối + dòng code mình"]
  Q -->|không khởi động| AF["Đọc APPLICATION FAILED TO START"]
  Q -->|LazyInitializationException| LZ["Lấy đủ trong service, trả DTO"]
  Q -->|401| A1["Token thiếu/sai/hết hạn"]
  Q -->|403| A3[Biết bạn nhưng không cho]
  A3 -.->|"bẫy: handler Exception.class"| E5["403 thành 500"]
  K["Dừng: SIGTERM trước, kill -9 cuối"]
  • Đọc stack trace từ dòng Caused by cuối cùng và dòng đầu tiên thuộc package của bạn, không phải từ dòng trên cùng.
  • Khối APPLICATION FAILED TO START đã nói sẵn nguyên nhân và gợi ý ("Action:"); đọc nó trước khi làm gì khác.
  • LazyInitializationException: chạm vào quan hệ lazy sau khi transaction đã đóng. Sửa bằng cách lấy đủ dữ liệu trong service và trả DTO.
  • 401 là "không biết bạn là ai" (token thiếu/sai/hết hạn), 403 là "biết nhưng không cho". Xem header WWW-Authenticate và bật log org.springframework.security=TRACE.
  • Bẫy số 1 của lab: @ExceptionHandler(Exception.class) nuốt AccessDeniedException của @PreAuthorize, biến 403 thành 500.
  • Dừng ứng dụng bằng kill (SIGTERM) trước, kill -9 là phương án cuối.

Hình dung: debug như bác sĩ khám: hỏi triệu chứng (log, status code), khoanh vùng (tầng nào), làm xét nghiệm (breakpoint, test tái hiện), rồi mới kê thuốc.

Cron job, @Scheduled

Cron job: biểu thức cron và @Scheduled trong Spring Boot
  • Ba phương ngữ cron: Unix 5 field, Spring 6 field (có giây, không có năm), Quartz 6-7 field và đánh số 1 = Chủ nhật.
  • Dùng tên thứ (MON, FRI) thay vì số, vì 5L ở Spring và Quartz lệch nhau một ngày.
  • fixedRate đo giữa các lần bắt đầu, fixedDelay đo từ lúc lần trước kết thúc; với scheduler mặc định cả hai không chạy chồng.
  • Mặc định mọi @Scheduled dùng chung một thread; exception bị log rồi nuốt; mốc bị lỡ thì mất, không chạy bù.
  • Bẫy số 1: deploy 3 pod thì job chạy 3 lần. Dùng ShedLock (hoặc Quartz cluster, Kubernetes CronJob) và vẫn giữ job idempotent.
  • Luôn đặt zone; ở vùng có DST, job lúc 02 có thể bị bỏ qua hoặc chạy hai lần.

Hình dung: @Scheduled như đồng hồ báo thức: lỡ giờ thì nó không reo bù, và đặt ba cái ở ba phòng thì cả ba cùng reo.

Lập lịch job phân tán: Quartz cluster, misfire và chia job lớn cho nhiều worker
flowchart LR
  T[Trigger: cron, simple] --> S[Scheduler trên mỗi node]
  S -->|"SELECT ... FOR UPDATE trên QRTZ_LOCKS"| DB[(Bảng QRTZ_* dùng chung)]
  S --> J[Job planner chạy trên 1 node]
  J -->|chia khoảng user_id| C[(Bảng job_chunk)]
  W1[Worker 1] -->|SKIP LOCKED + lease| C
  W2[Worker 2] -->|SKIP LOCKED + lease| C
  W3[Worker N] -->|SKIP LOCKED + lease| C
  • Quartz tách việc (Job, JobDetail) khỏi lịch (Trigger); JobStore lưu cả hai, trong RAM hoặc trong database.
  • Mặc định mỗi lần chạy là một instance Job mới; trạng thái giữa các lần chạy nằm trong JobDataMap, không nằm trong field.
  • Cluster: mọi node dùng chung bảng QRTZ_*, giành trigger dưới khoá dòng QRTZ_LOCKS (SELECT … FOR UPDATE), nên mỗi lần kích hoạt chỉ chạy trên một node.
  • Node chết giữa chừng: node khác phát hiện qua check-in và chạy lại job có requestsRecovery. Vì vậy job phải idempotent.
  • Misfire: trigger lỡ giờ quá misfireThreshold (mặc định 60 giây) thì xử lý theo misfire instruction: chạy bù một lần, bỏ qua, hay chạy hết.
  • Quartz cluster không chia một job cho nhiều node. Job lớn: một job lập kế hoạch chia thành chunk, nhiều worker giành chunk bằng lease (FOR UPDATE SKIP LOCKED).
  • Bẫy số 1: đồng hồ các node lệch nhau. Quartz cluster yêu cầu đồng bộ giờ (NTP), nếu không trigger chạy sai giờ hoặc bị coi là node chết.

Hình dung: Quartz như bảng phân ca trong bệnh viện: lịch ghi ở một cuốn sổ chung, ai đến trước ký tên nhận ca thì làm ca đó; một ca mổ quá lớn thì trưởng khoa chia thành nhiều phần cho nhiều bác sĩ.

Cron job dọn dữ liệu: xoá theo batch, archive và partition
  • Không xoá hàng triệu dòng bằng một câu DELETE: transaction dài, lock lâu, WAL/binlog dồn, replica trễ.
  • Xoá theo batch 500–5000 dòng, mỗi batch một transaction ngắn, nghỉ ngắn giữa các batch.
  • Archive và xoá trong cùng transaction: không dòng nào bị xoá mà chưa backup.
  • Cần index cho điều kiện lọc, ví dụ (status, updated_at); không có thì mỗi batch là một full scan.
  • Đánh đổi: xoá theo batch dùng được cho mọi bảng nhưng vẫn tốn WAL và lock; DROP PARTITION gần như tức thì nhưng bảng phải partition theo thời gian.
  • Bẫy số 1: job không chạy thì không có log lỗi nào. Cần dead man's switch: alert khi quá 25 giờ chưa thành công.
  • Job chạy "mỗi năm một lần" lỡ một lần là chờ 12 tháng; chạy hàng đêm với điều kiện theo dữ liệu thì tự bù.

Hình dung: dọn kho bằng cách chở từng xe nhỏ ra bãi lưu trữ, mỗi chuyến ghi sổ xong mới đi chuyến sau; không chặn cổng kho cả ngày để chở một chuyến khổng lồ.

Mật mã, xác thực, phân quyềnLõi

Encoding, hash, mã hoá và chữ ký: chọn đúng công cụ mật mã cho backend
  • Encoding (Base64) chỉ đổi định dạng, ai cũng đảo ngược được: không bảo vệ gì.
  • Hash thuần chỉ chứng minh toàn vẹn khi không có kẻ tấn công; MD5, SHA-1 đã bị phá.
  • MAC (HMAC) = hash có khoá: toàn vẹn + nguồn gốc với secret chung. Chữ ký số: một bên ký, nhiều bên kiểm, chống chối bỏ.
  • Đối xứng và bất đối xứng khác nhau ở phân phối khoá và tốc độ, không phải độ an toàn. TLS dùng lai cả hai.
  • AES phải đi với mode AEAD: AES/GCM/NoPadding, không bao giờ Cipher.getInstance("AES") (ra ECB).
  • TLS bảo vệ từng chặng, không phủ chặng qua trình duyệt; tắt kiểm chứng chỉ là tắt TLS.
  • Bẫy số 1: tự ghép sha256(secret + message) thay HMAC (length extension) và so chữ ký bằng String.equals.

Hình dung: encoding là đổi tên quả, hash là dấu vân tay, MAC là con dấu chung của hai bên, chữ ký số là chữ ký tay ai cũng đối chiếu được, encryption là két sắt.

Lưu mật khẩu và mã hoá dữ liệu cá nhân: salt, Argon2id, AES-GCM và blind index
  • Mật khẩu: băm bằng hàm chậm có salt (Argon2id > scrypt > bcrypt > PBKDF2), không mã hoá, không dùng SHA-256/MD5.
  • Bcrypt không lỗi thời (vẫn là mặc định của Spring Security), nhưng chỉ dùng 72 byte đầu.
  • Lưu chuỗi có tiền tố thuật toán ({bcrypt}...) để nâng cấp dần khi người dùng đăng nhập.
  • Dữ liệu cá nhân: AES-GCM ở tầng ứng dụng, nonce mới mỗi lần, AAD gắn id dòng.
  • Khoá nằm trong KMS (envelope encryption), không nằm trong application.yml; lưu ciphertext dạng nhị phân.
  • Tìm trên dữ liệu mã hoá: blind index (HMAC), chỉ so bằng, rò rỉ trùng giá trị.
  • Bẫy số 1: lặp nonce với AES-GCM là mất cả bí mật lẫn tính toàn vẹn.

Hình dung: mật khẩu như thịt xay (không lấy lại được miếng thịt, chỉ so được hai mẻ xay); dữ liệu cá nhân nằm trong két, chìa két gửi ở ngân hàng (KMS).

Xác thực: Basic, API key, session cookie và JWT
  • 401 = chưa xác thực (đăng nhập lại có ích); 403 = biết bạn là ai nhưng không có quyền.
  • Session cookie: id ngẫu nhiên trỏ tới dữ liệu ở server, thu hồi tức thì. Đặt HttpOnly, Secure, SameSite, __Host-; đổi id khi đăng nhập.
  • JWT được ký, không được mã hoá: ai cũng đọc được payload. Server kiểm chữ ký, cố định thuật toán, và kiểm iss, aud, exp.
  • JWT không thu hồi được trước hạn nếu không thêm trạng thái: access 5–15 phút + refresh token xoay vòng, phát hiện dùng lại.
  • Trade-off: session + Redis đơn giản, thu hồi ngay; JWT hợp nhiều service, nhiều loại client nhưng nhiều bẫy.
  • Bẫy số 1: token trong localStorage, một lỗi XSS là kẻ gian mang token đi. Web nên dùng BFF và cookie HttpOnly.

Hình dung: session id là số phiếu gửi xe, thông tin xe nằm ở bãi; JWT là thẻ tên có dấu mộc, ai nhìn cũng đọc được, bảo vệ chỉ cần kiểm con dấu.

Phân quyền, SSO và OAuth2: từ RBAC tới OpenID Connect
  • RBAC thuần kiểm role trong code: role chồng lấn, bùng nổ role, đổi quyền phải deploy.
  • Role + permission: code chỉ kiểm permission (flights:create), role là dữ liệu đổi lúc runtime. Mặc định cho đa số backend.
  • Bẫy số 1: kiểm permission mà quên kiểm quyền sở hữu là IDOR. Đưa owner_id/tenant_id vào câu truy vấn, trả 404.
  • Permission trong JWT: không gọi DB, nhưng quyền cũ tới khi token hết hạn. Access token 5–15 phút, quyền nhạy cảm tra lại.
  • SSO bằng cookie domain cha: chỉ một domain, mọi subdomain nằm trong biên tin cậy. Cách chuẩn: IdP trung tâm + OIDC.
  • OAuth2 là uỷ quyền (access token cho API); OIDC là xác thực (ID token cho client). Đăng nhập không dùng access token.
  • Authorization code + PKCE cho mọi app có người dùng; client credentials cho service gọi service.

Hình dung: sân bay. Cửa an ninh kiểm căn cước (xác thực), cửa ra máy bay kiểm thẻ lên tàu cho đúng chuyến (phân quyền trên đối tượng), và IdP là quầy cấp thẻ chung cho mọi hãng.

Form login với Spring Security: filter chain, UserDetailsService và phân quyền theo role
  • Spring Security là một chuỗi servlet filter chạy trước DispatcherServlet: DelegatingFilterProxy → FilterChainProxy → SecurityFilterChain đầu tiên khớp URL → khoảng 15 filter theo thứ tự cố định.
  • Đăng nhập: UsernamePasswordAuthenticationFilter → ProviderManager → DaoAuthenticationProvider → UserDetailsService + PasswordEncoder → lưu SecurityContext vào session.
  • Chỉ cần khai một bean UserDetailsService và một bean PasswordEncoder; Spring Boot tự ráp AuthenticationManager.
  • GET /login là trang của bạn, POST /login do filter xử lý. Form POST nào cũng phải có CSRF token; th:action của Thymeleaf tự chèn.
  • Luật URL xét từ trên xuống, luật đầu tiên khớp thắng. hasRole("ADMIN") kiểm ROLE_ADMIN, hasAuthority kiểm đúng chuỗi.
  • Chưa đăng nhập thì redirect tới login (hoặc 401), đã đăng nhập mà thiếu quyền thì 403. Logout phải là POST.
  • Bẫy số 1: setHideUserNotFoundExceptions(false) để "debug cho dễ" làm lộ email nào có tài khoản.

Hình dung: filter chain là dãy cửa kiểm soát ở sân bay. Mỗi cửa làm đúng một việc (soi vé, soi hành lý, kiểm hộ chiếu), và hành khách chỉ tới cổng bay (controller) khi qua hết các cửa.

Session và remember-me trong Spring: Spring Session JDBC, giới hạn phiên và ba kiểu ghi nhớ đăng nhập
sequenceDiagram
  participant B as Trình duyệt
  participant S as Ứng dụng
  participant K as Kho session chung
  B->>S: Đăng nhập
  S->>S: changeSessionId
  S->>K: Lưu SecurityContext
  S-->>B: Cookie chỉ chứa session id
  B->>S: Request kèm cookie
  S->>K: Đọc session theo id
  Note over S,K: Attribute phải serialize được
  B->>S: Session hết, còn remember-me
  S-->>B: Đăng nhập lại tự động
  • Cookie chỉ chứa session id; dữ liệu (SecurityContext, saved request, CSRF token) nằm ở server.
  • Spring Security đổi session id khi đăng nhập (changeSessionId) để chống session fixation.
  • spring.session.timeout thắng server.servlet.session.timeout; absolute timeout không có sẵn, phải tự làm.
  • maximumSessions(1): mặc định phiên cũ bị đá; maxSessionsPreventsLogin(true) thì chặn lần đăng nhập mới. Chạy nhiều instance cần SpringSessionBackedSessionRegistry.
  • Spring Session thay HttpSession bằng một filter; JDBC lưu vào bảng SPRING_SESSION, attribute ở dạng byte, nên mọi thứ bỏ vào session phải serialize được.
  • Ba kiểu remember-me: cookie băm (không thu hồi lẻ được), token lưu DB (phát hiện bị trộm), và kéo dài chính session (Spring Session).
  • Bẫy số 1: setAlwaysRemember(true) biến mọi phiên thành phiên dài hạn, ô "ghi nhớ" thành vô nghĩa.

Hình dung: session id là thẻ gửi xe. Thẻ chỉ có một con số; chiếc xe (dữ liệu) nằm trong bãi. Spring Session là chuyển bãi từ sân nhà (RAM của một server) ra bãi chung (database) để server nào cũng trả được xe.

Spring Security cho REST API: filter chain stateless, đăng nhập và JWT với resource server
  • API stateless = một SecurityFilterChain với securityMatcher("/api/**"), STATELESS, tắt CSRF (chỉ an toàn vì token đi trong header, không phải cookie).
  • Không tự viết filter JWT: dùng oauth2ResourceServer().jwt(), Spring đã có BearerTokenAuthenticationFilter.
  • Đăng nhập: AuthenticationManager + DaoAuthenticationProvider kiểm mật khẩu, rồi NimbusJwtEncoder ký token HS256.
  • JwtDecoder phải cố định thuật toán, kiểm iss, khoá HMAC ≥ 256 bit.
  • Mặc định claim scope thành SCOPE_xxx; muốn hasRole thì đổi bằng JwtAuthenticationConverter (claim roles → ROLE_xxx).
  • Bẫy số 1: lỗi xác thực xảy ra trong filter, trước @RestControllerAdvice, nên 401/403 JSON phải viết bằng AuthenticationEntryPoint và AccessDeniedHandler.

Hình dung: filter chain là dãy bảo vệ ở cổng toà nhà; controller là phòng làm việc bên trong. Người bị chặn ở cổng không bao giờ gặp lễ tân trong phòng (controller advice).

Refresh token xoay vòng và phân quyền theo permission trong Spring Security
  • Refresh token là chuỗi ngẫu nhiên 256 bit, không phải JWT, và DB chỉ lưu SHA-256 của nó.
  • Mỗi lần refresh: thu hồi token cũ, phát token mới cùng family. Token đã thu hồi bị dùng lại → thu hồi cả family.
  • Khoá dòng (PESSIMISTIC_WRITE) để hai request refresh song song không cùng thành công; noRollbackFor để việc thu hồi vẫn commit khi trả 401.
  • Cookie HttpOnly; Secure; SameSite=Strict; Path=/api/v1/auth: JS không đọc được, chỉ gửi tới refresh/logout.
  • Role là authority có tiền tố ROLE_; permission là (method, path) trong DB, kiểm bằng AuthorizationManager tự viết.
  • Bẫy số 1: handler @ExceptionHandler(Exception.class) biến 403 của @PreAuthorize thành 500.

Hình dung: refresh token như vé gửi xe có số seri: mỗi lần lấy xe ra đổi vé mới. Ai cầm vé cũ quay lại nghĩa là vé đã bị sao chép, nên bãi khoá luôn cả chuỗi vé.

Test: unit, slice, integrationLõi

Unit test với JUnit 5 và Mockito: test quyết định, không test dây nối
flowchart TD
  A{"Code là gì?"} -->|"Quyết định"| B["Unit test"]
  A -->|"Dây nối"| C["Slice hoặc integration test"]
  B --> D["Arrange, Act, Assert"]
  D --> E["Stub cấp dữ liệu"]
  D --> F["Verify tác dụng phụ"]
  E --> G{"Xoá logic, test đỏ?"}
  F --> G
  G -->|"Không"| H["Test vô dụng"]
  G -->|"Có"| I["Đo bằng mutation testing"]
  • Test để bắt regression (lỗi cũ quay lại) và để refactor không sợ, không phải để "chứng minh code đúng".
  • Unit test dành cho quyết định (if, tính toán, chuẩn hoá, thứ tự gọi); phần dây nối (mapping HTTP, query, cấu hình) để slice/integration test.
  • Cấu trúc mỗi test: Arrange – Act – Assert, một hành vi một test, tên nói kết quả mong đợi.
  • Mockito: stub để cấp dữ liệu, verify để kiểm tác dụng phụ; đừng verify mọi thứ.
  • MockitoExtension bật strict stubs: stub không dùng làm test fail, giúp test gọn.
  • Bẫy số 1: test vẫn xanh khi xoá logic. Hỏi "xoá dòng này thì test nào đỏ?"; đo bằng mutation testing, không bằng % coverage.

Hình dung: unit test như kiểm tra từng bánh răng trên bàn, có giá đỡ giả thay cho máy; nó không nói được máy lắp có chạy không, đó là việc của integration test.

Test Spring Boot: slice test, integration test và Testcontainers
flowchart TD
  A{"Cần trả lời câu gì?"} -->|"Tầng HTTP"| C["@WebMvcTest"]
  A -->|"Repository và SQL"| D["@DataJpaTest + flush/clear"]
  A -->|"Cả luồng"| E["@SpringBootTest"]
  E --> F{"Cần HTTP thật?"}
  F -->|"Không"| G["MockMvc"]
  F -->|"Có"| H["RANDOM_PORT"]
  D --> I["Testcontainers + @ServiceConnection"]
  E --> I
  I --> J["Ít cấu hình, cache context"]
  • Slice test nạp một lát của ứng dụng: @WebMvcTest (controller, advice, JSON, validation, security), @DataJpaTest (JPA + DB, rollback sau mỗi test).
  • @SpringBootTest nạp cả ứng dụng; với MockMvc request chạy trên thread test, với RANDOM_PORT là HTTP thật qua server.
  • Trong @DataJpaTest, gọi flush() + clear() để SQL thật chạy, nếu không bạn chỉ test cache cấp 1.
  • @Transactional trên test dễ che bug: lazy loading, lỗi constraint lúc commit. Integration test quan trọng nên commit thật và tự dọn dữ liệu.
  • Testcontainers + @ServiceConnection: DB thật trong Docker, Boot tự lấy URL/user/password.
  • Bẫy số 1: mỗi tổ hợp @MockitoBean khác nhau tạo một Spring context mới, bộ test chậm dần mà không ai biết vì sao.

Hình dung: unit test kiểm từng bánh răng, slice test lắp riêng một cụm (hộp số) lên giá thử, integration test nổ máy cả xe trong xưởng với nhiên liệu thật.

Dự án thực hành

MiniWallet: một pet project ví điện tử lớn dần theo lộ trình backend
  • Một dự án lớn dần theo lộ trình; mỗi bài lõi thêm một mảnh, làm trong 30–45 phút.
  • Chọn ví điện tử vì chuyển tiền buộc phải dùng transaction, lock, idempotency, outbox, cache, messaging.
  • Sáu phase: Java thuần → một service → tin cậy → tách service → gateway và auth → vận hành.
  • Bắt đầu bằng một service; phase 3 mới tách, để trả lời được "vì sao tách, cái gì khó lên".
  • Service nghiệp vụ dùng Spring MVC + virtual thread; WebFlux chỉ ở gateway và endpoint đẩy SSE.
  • Bẫy số 1: để agent viết phần lõi rồi chỉ đọc lại. Lõi tự gõ; agent viết khung và hỏi vặn.

Hình dung: xây một căn nhà rồi cơi nới dần, thay vì dựng hai mươi mô hình bìa.

Phân tích yêu cầu và thiết kế dữ liệu qua ví dụ đặt phòng khách sạn
  • Quy trình: câu hỏi mở → phạm vi (cả "ngoài phạm vi") → BDD Given/When/Then → NFR có số đo → rồi mới thiết kế.
  • Câu hỏi quan trọng nhất hay bị bỏ qua: "hai người cùng đặt căn phòng cuối cùng thì sao?".
  • NFR phải có số, điều kiện tải và cách đo: "p95 < 300 ms ở 50 req/s", không phải "phải nhanh".
  • Tồn kho lưu theo loại phòng × từng đêm (room_inventory), kèm giá theo đêm, không phải một cột available_rooms.
  • Booking lưu ảnh chụp giá lúc đặt; tiền dùng DECIMAL, không dùng FLOAT/DOUBLE.
  • Lưới an toàn cuối: CHECK (booked_rooms BETWEEN 0 AND total_rooms) (MySQL 8.0.16+ mới thực thi).
  • Bẫy số 1 ở E-Learning: trạng thái lượt đăng ký và tiến độ từng bài là hai nguồn cho cùng một sự thật, phải cập nhật trong một transaction.

Hình dung: đặc tả giống bản vẽ trước khi xây nhà: hỏi chủ nhà ở mấy người, ngân sách bao nhiêu, rồi mới đổ móng.

Ví dụ đặt phòng khách sạn: API, chống overbooking và kế hoạch triển khai Spring Boot
  • Tìm kiếm là GET với query param (chỉ đọc, cache được); đặt phòng là POST /bookings kèm header Idempotency-Key, trả 201 + Location, hết phòng trả 409.
  • Chống overbooking bằng một câu UPDATE có điều kiện total - booked >= qty trên mọi đêm, rồi kiểm tra số dòng bị ảnh hưởng == số đêm; sai thì rollback.
  • Bẫy số 1: check-then-act (đọc "còn phòng" rồi mới ghi) để hai request cùng lọt qua.
  • Chốt chặn idempotency thật là UNIQUE (user_id, idempotency_key), không phải câu findBy... ở đầu method.
  • Package theo tính năng, bên trong chia layer controller → service → repository; entity không ra khỏi service; khoá quy tắc bằng ArchUnit.
  • "Hôm nay" và "24 giờ trước check-in" tính theo múi giờ khách sạn, không theo JVM.
  • Test bằng MySQL thật (Testcontainers), có test đồng thời: 20 thread tranh 1 phòng → đúng 1 thành công.

Hình dung: quầy bán vé chỉ xé vé khi ghế còn trống ngay lúc xé, không phải lúc khách hỏi "còn ghế không".

Ôn tập phỏng vấn backend: Java Core, Spring Boot và web
  • JDK = JRE + công cụ build; JRE = JVM + thư viện chuẩn; JVM chạy bytecode. Từ Java 11 không còn JRE riêng.
  • equals() mặc định chính là ==. Override equals thì phải override hashCode.
  • Overload chọn lúc biên dịch theo kiểu khai báo; override chọn lúc chạy theo kiểu thật của object.
  • Java luôn truyền tham trị. Với object, thứ được copy là tham chiếu.
  • Mặc định chọn interface, ArrayList, constructor injection; đổi khi có lý do cụ thể.
  • HTTPS = HTTP trên TLS: mã hoá, toàn vẹn, xác thực server; không chữa lỗi của ứng dụng.
  • Bẫy số 1: thuộc đáp án gọn nhưng sai, và ghi lên CV con số không giải thích được cách đo.

Hình dung: mỗi tiêu đề là một thẻ flashcard: tự trả lời một câu trước, rồi mới lật xem ví dụ và chỗ hay sai.

Giỏ hàng và đặt hàng với Spring: mô hình, transaction và chống bán quá kho
  • Bốn bảng: cart (1-1 với user), cart_item (unique cart_id, product_id), orders, order_line. order là từ khoá SQL, nên đặt tên bảng orders.
  • Thêm cùng sản phẩm hai lần thì cộng số lượng vào dòng cũ, không thêm dòng mới. Số trên icon giỏ hàng là giá trị tính ra, không lưu thành cột.
  • Dòng đơn hàng chụp lại tên và giá lúc đặt. Giá sản phẩm đổi sau đó không làm đổi đơn cũ.
  • Tiền dùng BigDecimal, tổng đơn = tổng các dòng, tính một chỗ.
  • Đặt hàng = một transaction: kiểm requestId (chống bấm hai lần), trừ kho bằng UPDATE ... WHERE stock >= :qty, tạo đơn, xoá giỏ. Một bước lỗi thì rollback hết.
  • Bẫy số 1: @Modifying(clearAutomatically = true) xoá persistence context giữa chừng, thay đổi trên giỏ đã nạp bị mất mà không báo lỗi.

Hình dung: giỏ hàng là tờ nháp khách tự sửa thoải mái; đơn hàng là hoá đơn đã in, có giá cố định, và chỉ được in khi kho thật sự còn hàng.

6. Đưa lên production

Maven, Gradle

Maven và cấu trúc dự án Spring Boot
flowchart LR
  A["pom.xml: toạ độ GAV"] --> B["Parent/BOM quản lý version"]
  B --> C["Dependency, scope, bắc cầu"]
  C --> D{"Có trong ~/.m2?"}
  D -->|"Không"| E["Tải từ Maven Central"]
  D -->|"Có"| F["Lifecycle: compile, test, package"]
  E --> F
  F --> G["Fat jar: java -jar"]
  • POM mô tả dự án; mỗi thư viện có toạ độ groupId:artifactId (GAV).
  • Lifecycle gồm các phase theo thứ tự; gọi package là chạy luôn compile và test trước nó. Việc thật do goal của plugin gắn vào phase.
  • Scope quyết định thư viện có mặt lúc compile, test hay chỉ lúc chạy; thư viện kéo theo thư viện khác (bắc cầu), xem bằng mvn dependency:tree.
  • spring-boot-starter-parent quản lý version cho hàng trăm thư viện: đừng tự ghi version cho thư viện Boot đã quản lý.
  • ~/.m2/repository là cache cục bộ; lỗi tải thì xoá đúng thư mục hỏng hoặc chạy mvn -U, không cần xoá cả .m2.
  • Bẫy số 1: toạ độ cũ mysql:mysql-connector-java đã bị chuyển; dùng com.mysql:mysql-connector-j không ghi version.

Hình dung: POM là công thức nấu ăn, ~/.m2 là tủ lạnh, Maven Central là chợ. Maven đọc công thức, lấy nguyên liệu trong tủ, thiếu thì đi chợ, rồi nấu theo đúng thứ tự các bước.

Hệ điều hành, I/O, Linux

Hệ điều hành cho backend: kernel, system call, process và thread
  • System call là một trap (chuyển sang kernel mode có chủ đích), không phải ngắt phần cứng. Mỗi lần ~100 ns đến vài µs; cái hại là gọi quá dày.
  • Với Linux, thread chỉ là một task (task_struct) dùng chung bảng trang. Platform thread Java là 1 với thread OS; virtual thread là M.
  • Context switch: trực tiếp 1–5 µs, gián tiếp (cache, TLB nguội) thường lớn hơn.
  • Load average trên Linux đếm cả task chờ đĩa (D), nên load cao chưa chắc là thiếu CPU.
  • CPU limit là quota theo chu kỳ 100 ms: usage trung bình thấp vẫn có thể bị throttle và tăng p99.
  • Bẫy số 1: ENTRYPOINT dạng shell khiến sh là PID 1, Java không nhận SIGTERM, không graceful shutdown.

Hình dung: kernel là quầy lễ tân của toà nhà. Khách (ứng dụng) không tự vào kho mà phải ra quầy (system call); lễ tân quyết định ai dùng phòng họp (CPU) bao lâu.

I/O model: blocking, non-blocking, epoll và file descriptor
  • Chờ thiết bị lâu hơn system call hàng nghìn lần; điều quyết định là thread làm gì khi chờ.
  • Năm mô hình: blocking, non-blocking, multiplexing, signal-driven, async. Bốn cái đầu vẫn là synchronous.
  • epoll đăng ký fd một lần, epoll_wait chỉ trả fd sẵn sàng: chi phí theo số fd sẵn sàng, không theo tổng.
  • Tomcat giữ 8.192 kết nối nhưng chỉ xử lý 200 request cùng lúc; virtual thread dời trần đó sang connection pool.
  • write() thành công chỉ nghĩa là dữ liệu vào page cache; muốn bền phải fsync hoặc replication.
  • Trade-off: event loop phục vụ nhiều kết nối bằng ít thread, nhưng một lệnh chặn làm đứng cả loop.
  • Bẫy số 1: read() không buffer là một system call mỗi byte (20 MB: 7 giây so với 10 ms).

Hình dung: blocking là mỗi khách một người phục vụ đứng chờ món; epoll là một người phục vụ nhìn bảng đèn, bàn nào bật đèn thì tới bàn đó.

Linux cho backend: inode, link, phân quyền và shell script
flowchart TD
  DIR["Thư mục: tên → inode"] --> IN["Inode + dữ liệu"]
  HL[Hard link] -->|thêm tên| IN
  SL[Soft link] -->|chứa đường dẫn| DIR
  RM[rm] -->|xoá một tên| DIR
  IN --> FR{"Link = 0 và không ai mở?"}
  FR -->|có| OK[Giải phóng]
  FR -->|không| DF["df vẫn đầy: lsof +L1"]
  PERM["Quyền rwx = 4/2/1"] --> DEL["Xoá file: quyền thư mục chứa"]
  SH["Script: set -euo pipefail"]
  • Tên file nằm trong thư mục (tên → số inode), không nằm trong inode. Hard link = thêm một tên cho cùng inode; soft link = file chứa đường dẫn.
  • rm chỉ xoá một tên. Dữ liệu được giải phóng khi link count về 0 và không còn process nào mở file.
  • Bẫy số 1: xoá log đang được ghi thì df vẫn đầy. Tìm bằng lsof +L1; làm rỗng bằng truncate -s 0, đừng rm.
  • Quyền r=4, w=2, x=1 cho user, group, other. Quyền xoá file nằm ở thư mục chứa, không ở file.
  • Container nên chạy non-root; lỗi ghi volume sửa bằng fsGroup, không bằng chmod 777.
  • Script: set -euo pipefail, biến trong nháy kép, shellcheck, có dry-run. set -e vẫn không bắt mọi lỗi.
  • Trade-off: logrotate create không mất dòng nhưng app phải mở lại file; copytruncate không cần app hợp tác nhưng có thể mất dòng.

Hình dung: inode là căn nhà, tên file là địa chỉ ghi trong sổ của thư mục. Xoá địa chỉ không phá nhà khi vẫn còn người ở bên trong.

Mạng máy tính cho backend: DNS, TCP, TLS và cách debug kết nối
  • Một lần gọi HTTPS mới tốn DNS + 1 RTT TCP + 1 RTT TLS 1.3 + 1 RTT request. Đo thật: ~166 ms cho connection mới, ~52 ms khi dùng lại connection.
  • JVM tự cache DNS: mặc định 30 giây (không có SecurityManager), lookup lỗi cache 10 giây. Connection đã mở thì không bao giờ hỏi lại DNS.
  • Refused = tới được máy nhưng không ai nghe port (RST ngay). Connect timeout = SYN rơi vào hư không. Reset = bên kia (hoặc thiết bị giữa đường) huỷ connection đang mở.
  • TIME_WAIT nằm ở bên đóng trước (Linux 60 giây); nó chỉ làm cạn port ở phía gọi ra nhiều connection ngắn.
  • L4 cân bằng theo connection, L7 theo request. Mỗi LB, NAT, firewall có idle timeout riêng và lặng lẽ xoá connection rảnh.
  • Bẫy số 1: connection trong pool rảnh lâu hơn idle timeout của NAT/LB, lần dùng sau bị reset hoặc treo. Chữa bằng tuổi thọ connection ngắn hơn timeout đó.

Hình dung: gọi API như gửi hàng bằng xe tải: tra địa chỉ (DNS), bắt tay bảo vệ cổng (TCP), kiểm tra giấy tờ (TLS), rồi mới chở hàng (HTTP). Giữ xe lại cho chuyến sau (keep-alive) thì bỏ được ba bước đầu.

Docker

Docker cho Spring Boot: image, Dockerfile nhiều stage, JVM trong container và Compose
  • Container là process thường của Linux, bị namespace che tầm nhìn và cgroup giới hạn tài nguyên; nó dùng chung kernel với host, khác máy ảo.
  • Image là chồng layer chỉ đọc; đổi một layer thì mọi layer sau build lại. Đặt thứ ít đổi (JRE, dependency) trước, code sau.
  • Spring Boot: build trong stage riêng, tách jar thành 4 layer (extract --layers); sửa code chỉ đẩy layer application vài KB thay vì cả fat jar 22 MB.
  • Base image: JRE trên Debian/Ubuntu là mặc định an toàn; distroless nhỏ và ít lỗ hổng nhưng không có shell; Alpine dùng musl, cẩn thận thư viện native.
  • JVM: đặt -XX:MaxRAMPercentage (thường 75) thay vì -Xmx cứng; OOMKilled (137) là kernel giết, OutOfMemoryError là heap đầy.
  • Bẫy số 1: ENTRYPOINT dạng shell làm Java không nhận SIGTERM, mỗi lần deploy cắt ngang request. Dùng dạng exec, chạy non-root.

Hình dung: container giống một phòng trong khách sạn: cùng toà nhà (kernel), nhưng mỗi phòng có khoá riêng, đồng hồ điện riêng và chỉ thấy đồ của mình.

CI/CD

CI/CD cho backend Spring Boot: pipeline GitHub Actions từ commit tới production
  • CI = mọi commit được build và test tự động. Continuous delivery = luôn có bản deploy được, bấm nút là lên production. Continuous deployment = không cần nút.
  • Build một lần, promote nhiều lần: image build từ main một lần, staging và production chạy đúng digest đó, không build lại.
  • Thứ tự bước theo "rẻ và hay hỏng trước": compile, unit test, Testcontainers, static analysis, image, quét lỗ hổng, deploy.
  • Secret: ưu tiên OIDC (credential ngắn hạn) thay vì key dài hạn; permissions tối thiểu; ghim action bên thứ ba theo commit SHA.
  • Migration Flyway chạy trước rollout và phải tương thích ngược (expand → contract), vì code cũ và mới cùng chạy trên schema mới.
  • Bẫy số 1: rollback code không rollback được database. Rollback = deploy lại digest cũ; schema chỉ đi tiến.

Hình dung: pipeline giống dây chuyền kiểm định ở nhà máy: mỗi trạm loại hàng lỗi càng sớm càng rẻ, và sản phẩm đã qua kiểm định được dán tem rồi chuyển đi, không ai làm lại một chiếc mới ở cửa hàng.

Chiến lược deploy, Kubernetes

Chiến lược deploy: rolling, blue-green, canary, feature flag và zero-downtime trên Kubernetes
  • Rolling thay dần từng pod (mặc định của Kubernetes), blue-green đổi cả cụm một lần, canary cho một phần nhỏ traffic đi trước rồi mới tăng.
  • Mọi chiến lược trừ recreate đều có lúc bản cũ và bản mới chạy cùng nhau, nên schema và API phải tương thích hai chiều.
  • Expand/contract: thêm cái mới, chạy song song, chuyển dần, rồi mới xoá cái cũ. Không đổi tên hay xoá cột trong cùng release với code ngừng dùng nó.
  • Readiness quyết định có nhận traffic, liveness quyết định có restart, startup che hai cái kia lúc khởi động chậm.
  • Bẫy số 1: liveness kiểm tra database. Database chậm là cả cụm bị restart cùng lúc.
  • Deploy khác release: feature flag tách "code đã lên production" khỏi "người dùng thấy tính năng".
  • Canary chỉ có ý nghĩa khi có tiêu chí dừng bằng số: error rate, p99, tốc độ đốt SLO, so với nhóm bản cũ.

Hình dung: thay lốp xe đang chạy: mỗi lần chỉ thay một bánh, bánh mới phải vừa trục cũ, và chỉ tháo bánh cũ khi bánh mới đã bám đường.

Kubernetes cho backend dev: kiến trúc, Pod, Service, ConfigMap, autoscaling và debug pod lỗi
flowchart LR
  U[kubectl apply] --> API[API server]
  API --> E[(etcd)]
  CM[Controller manager] -->|tạo Pod| API
  S[Scheduler] -->|chọn node| API
  K[kubelet trên node] -->|chạy container| P[Pod]
  API --> K
  C[Client] --> I[Ingress / Gateway] --> SV[Service] --> P
  • Kubernetes chạy theo trạng thái mong muốn: bạn khai báo YAML, các controller liên tục so với thực tế và sửa cho khớp (pod chết thì tạo pod mới).
  • Control plane (API server, etcd, scheduler, controller manager) quyết định; mỗi node có kubelet chạy container và kube-proxy lo mạng của Service.
  • Pod là đơn vị nhỏ nhất, có IP riêng nhưng tạm thời; Deployment giữ số pod, Service cho một địa chỉ ổn định trỏ tới các pod ready.
  • Ra ngoài cluster: LoadBalancer cho từng service, hoặc Ingress/Gateway API làm một cửa vào định tuyến theo host và path.
  • requests để xếp lịch và làm mốc cho HPA, limits là trần: vượt memory bị OOMKilled (exit 137), vượt CPU bị throttle.
  • Secret chỉ là base64, không phải mã hoá. Biến môi trường từ ConfigMap không tự cập nhật khi ConfigMap đổi.
  • Bẫy số 1 khi debug: chỉ nhìn kubectl get pods. Câu trả lời thường nằm ở kubectl describe (Events) và kubectl logs --previous.

Hình dung: Kubernetes như máy điều hoà có cài nhiệt độ: bạn đặt 25 độ (trạng thái mong muốn), máy tự đo và bật tắt cho tới khi phòng đúng 25, chứ bạn không ra lệnh "chạy thêm 10 phút".

AWS cơ bản: IAM, VPC, EC2, S3, RDS

AWS IAM: user, role, policy và credential tạm thời cho Spring Boot
flowchart LR
  App["Spring Boot trên ECS / EC2"] -->|"1. mượn role"| STS["STS"]
  STS -->|"2. credential tạm thời"| App
  App -->|"3. request đã ký"| S3["S3, SQS, ..."]
  S3 -->|"4. hỏi quyền"| IAM{"Policy của role"}
  IAM -->|"Allow"| OK["Thực hiện"]
  IAM -->|"Deny hoặc không có allow"| NO["AccessDenied"]
  • Root là chủ tài khoản AWS, có mọi quyền: bật MFA, không tạo access key, không dùng hằng ngày.
  • IAM user là danh tính cố định có mật khẩu hoặc access key dài hạn; group chỉ để gắn policy cho nhiều user.
  • Role không có mật khẩu: ai được tin cậy thì "mượn" role và nhận credential tạm thời từ STS, tự hết hạn.
  • Policy là JSON gồm Effect, Action, Resource, Condition. Mặc định mọi thứ bị từ chối.
  • Thứ tự quyết định: có explicit deny thì từ chối, không thì cần ít nhất một allow.
  • Service trên EC2, ECS, Lambda dùng role; AWS SDK tự tìm credential qua chuỗi mặc định.
  • Bẫy số 1: access key nằm trong application.yml hoặc bị commit lên Git.

Hình dung: IAM user là thẻ nhân viên dùng mãi; role là thẻ khách lấy ở quầy lễ tân, ghi rõ được vào phòng nào và hết hạn sau vài giờ.

AWS VPC: subnet public và private, route table, NAT gateway và security group
flowchart TD
  U["Người dùng"] --> IGW["Internet gateway"]
  subgraph VPC["VPC 10.0.0.0/16"]
    subgraph PUB["Public subnet (AZ a, AZ b)"]
      ALB["Load balancer"]
      NAT["NAT gateway"]
    end
    subgraph APP["Private subnet app (AZ a, AZ b)"]
      S["Spring Boot"]
    end
    subgraph DB["Private subnet data (AZ a, AZ b)"]
      R[("RDS")]
    end
  end
  IGW --> ALB
  ALB -->|"8080"| S
  S -->|"5432"| R
  S -.->|"gọi API ngoài"| NAT
  NAT -.-> IGW
  • VPC là mạng riêng trong một region, có dải IP dạng CIDR (10.0.0.0/16); subnet là một phần dải đó, nằm trong đúng một AZ.
  • Subnet là public khi route table có đường 0.0.0.0/0 tới internet gateway; không có thì là private.
  • Máy ở private subnet ra Internet qua NAT gateway (chỉ chiều đi ra).
  • Security group gắn vào từng máy, stateful, chỉ có allow; network ACL gắn vào subnet, stateless, có cả deny.
  • Bố cục chuẩn: load balancer ở public subnet, app và database ở private subnet, trên ít nhất 2 AZ.
  • Bẫy số 1: mở port 22 hay port database cho 0.0.0.0/0.

Hình dung: VPC là khu chung cư có tường rào, subnet là từng toà, internet gateway là cổng chính; security group là khoá cửa từng căn, network ACL là bảo vệ ở sảnh mỗi toà.

AWS EC2, load balancer và Auto Scaling: chạy Spring Boot nhiều máy và tắt êm
flowchart LR
  U["Người dùng"] --> ALB["ALB"]
  ALB --> TG["Target group + health check"]
  TG --> A["EC2 (AZ a)"]
  TG --> B["EC2 (AZ b)"]
  ASG["Auto Scaling group"] -.->|"tạo, thay, xoá máy"| A
  ASG -.-> B
  LT["Launch template: AMI, type, user data"] --> ASG
  CW["CloudWatch: CPU, số request"] -->|"scaling policy"| ASG
  • EC2 là máy ảo thuê theo giây; AMI là khuôn đĩa để tạo máy, instance type quyết định CPU và RAM.
  • EBS là ổ đĩa mạng, còn dữ liệu khi stop máy; instance store gắn liền máy chủ vật lý, mất khi stop hoặc terminate.
  • ALB chia tải ở tầng 7 (HTTP, theo host và path); NLB ở tầng 4 (TCP/UDP, IP tĩnh).
  • Load balancer gửi request tới target group và chỉ gửi cho máy qua được health check.
  • Auto Scaling group giữ số máy giữa min và max, thay máy hỏng, thêm bớt máy theo scaling policy.
  • Bẫy số 1: máy bị rút làm request đang chạy bị cắt, vì thiếu connection draining và graceful shutdown.

Hình dung: load balancer là lễ tân chia khách cho các quầy; Auto Scaling group là quản lý ca, mở thêm quầy khi đông, đóng bớt khi vắng, nhưng để quầy phục vụ xong khách đang đứng.

AWS S3 và CloudFront: lưu file, presigned URL từ Spring Boot và CDN phía trước
  • S3 lưu object trong bucket, định danh bằng key; không có thư mục thật, chỉ có prefix trong key.
  • S3 nhất quán mạnh: ghi xong, đọc hoặc list ngay là thấy bản mới.
  • Bucket mặc định riêng tư và mã hoá sẵn. Đừng mở public.
  • Presigned URL: Spring Boot ký một URL có hạn, trình duyệt upload/download thẳng với S3.
  • File lớn dùng multipart upload, kèm lifecycle rule dọn upload dở.
  • CloudFront cache file ở edge gần người dùng, đọc bucket riêng tư qua OAC.
  • Bẫy số 1: URL ký bằng role chết theo credential tạm của role, dù bạn đặt hạn 7 ngày.

Hình dung: S3 là kho gửi đồ, mỗi món có một mã vé (key); presigned URL là vé dùng trong vài phút; CloudFront là các quầy phát đồ đặt gần nhà khách.

AWS RDS, Aurora và DynamoDB: database được quản lý cho service Spring Boot
  • RDS là MySQL/PostgreSQL do AWS vận hành: vá, backup, failover. Schema, query và số kết nối vẫn là việc của bạn.
  • Multi-AZ để sẵn sàng: standby đồng bộ ở AZ khác, tự failover. Read replica để chia tải đọc: bất đồng bộ, có độ trễ.
  • Backup tự động cho khôi phục về một thời điểm bất kỳ (PITR), luôn ra một instance mới.
  • max_connections tính theo RAM của instance: tổng pool của mọi instance app phải nhỏ hơn nó.
  • Aurora: tương thích MySQL/PostgreSQL, storage dùng chung, failover nhanh, replica gần như không trễ.
  • DynamoDB: key-value, thiết kế bảng theo câu truy vấn đã biết trước.
  • Bẫy số 1: tưởng read replica hay Multi-AZ là backup.

Hình dung: RDS là thuê xe kèm bảo dưỡng: hãng lo sửa chữa, đổi xe khi hỏng, còn lái thế nào và chở bao nhiêu người vẫn do bạn.

Triển khai Spring Boot trên AWS: ECS Fargate, Lambda, SQS, CloudWatch và Secrets Manager
  • Mặc định hợp lý: ECS trên Fargate, image ở ECR, đứng sau ALB. Không phải quản lý máy.
  • EKS khi team đã dùng Kubernetes; Lambda cho việc theo sự kiện, ngắn, thưa.
  • ECS có hai role: execution role để kéo image, ghi log, đọc secret; task role là quyền của code.
  • SQS standard giao ít nhất một lần, consumer phải idempotent; FIFO giữ thứ tự theo nhóm.
  • Message lỗi nhiều lần sang DLQ; SNS phát một sự kiện ra nhiều queue.
  • Lambda Java có cold start; giảm bằng SnapStart hoặc provisioned concurrency.
  • Bẫy số 1: visibility timeout ngắn hơn thời gian xử lý, một message bị làm hai lần.

Hình dung: Fargate là thuê bếp theo giờ; Lambda là gọi đầu bếp tới khi có đơn; SQS là dãy phiếu gọi món, đầu bếp lấy phiếu nào thì phiếu đó tạm bị che đi.

Performance test

Performance test: load, stress, spike, soak và coordinated omission
  • Load = tải dự kiến, stress = vượt tải tới khi gãy, spike = tăng vọt đột ngột, soak = tải vừa trong nhiều giờ, capacity = tìm điểm tối đa còn đạt SLO.
  • Mục tiêu viết bằng số từ SLO: "500 req/s, p99 < 300 ms, lỗi < 0,1%", và test tự fail khi trượt.
  • Người dùng thật đến theo open model (tốc độ đến không phụ thuộc server). Công cụ chạy closed model (N user, chờ response mới gửi tiếp) sẽ tự giảm tải khi server chậm.
  • Bẫy số 1: coordinated omission. Thí nghiệm: server đứng hình 1 s mỗi 5 s, đo kiểu closed cho p99 2,6 ms, đo đúng cho p99 975 ms.
  • Đọc percentile, không đọc trung bình; không lấy trung bình của p99 giữa các instance.
  • RED (Rate, Errors, Duration) cho service, USE (Utilization, Saturation, Errors) cho tài nguyên: CPU, pool, thread, lock, GC.
  • JMH đo một đoạn code trong một JVM; load test đo cả hệ thống. Hai câu hỏi khác nhau.

Hình dung: kiểm tra một cây cầu: load test cho xe chạy đúng lưu lượng giờ cao điểm, stress test chất thêm tới khi nứt, soak test để xe chạy cả tuần xem có mỏi kim loại.

Reverse proxy, Nginx

Reverse proxy với Nginx: định tuyến theo path và các header X-Forwarded
  • Reverse proxy đứng phía server: client chỉ thấy một địa chỉ, proxy đọc path rồi chuyển tới đúng service.
  • Chọn location: = khớp chính xác thì dừng; prefix dài nhất được nhớ, nhưng regex (xét theo thứ tự file) thắng nó, trừ khi prefix có ^~.
  • proxy_pass không có URI thì path đi nguyên; có URI (dù chỉ /) thì phần khớp location bị thay. Location và URI phải cùng có hoặc cùng không có / cuối.
  • proxy_set_header ở location con làm mất toàn bộ header khai báo ở server.
  • Bẫy số 1: lấy phần tử đầu của X-Forwarded-For làm IP client là cho client tự khai IP. Đọc từ phải sang, bỏ qua IP proxy của mình.
  • Production: keepalive cần đủ ba dòng, tắt buffering cho SSE, không retry POST, Nginx phân giải DNS upstream một lần lúc start.
  • Trade-off: cắt prefix ở proxy (service chạy ở /) hay giữ prefix (link và redirect tự đúng).

Hình dung: reverse proxy là quầy lễ tân của toà nhà: khách chỉ biết một cửa, lễ tân đọc tên phòng (path) rồi dẫn lên đúng tầng, và chỉ tin ghi chú "khách từ đâu tới" do lễ tân của chính toà nhà viết.

Ứng dụng 12-factor

12-Factor App: 12 nguyên tắc cho ứng dụng chạy trên cloud, áp dụng với Spring Boot và Kubernetes
flowchart LR
  A["Một codebase"] --> B["Build image một lần"]
  B --> C["Release = image + config"]
  E["Config từ môi trường"] --> C
  C --> D["Process không trạng thái"]
  F["Backing service qua URL"] --> D
  D --> G["Scale bằng process"]
  D --> H["Tắt êm khi SIGTERM"]
  D --> I["Log ra stdout"]
  C --> J["Admin: chạy một lần"]
  • Config (thứ khác nhau giữa các deploy) nằm ngoài code và image. Phép thử: mở mã nguồn repo ngay mà không lộ secret.
  • Build image một lần, tag bằng commit SHA, promote cùng image qua mọi môi trường. Rollback = chạy lại release trước.
  • Process không trạng thái: session, file, dữ liệu nằm ở backing service. Sticky session là vi phạm.
  • Tắt êm khi nhận SIGTERM; trên Kubernetes cần ENTRYPOINT dạng exec, preStop sleep và grace period đủ dài.
  • Log ra stdout dạng JSON; migration chạy như process một lần từ cùng image.
  • Trade-off chính: biến môi trường đơn giản nhưng dễ lộ; secret manager an toàn hơn nhưng thêm phụ thuộc.
  • Bẫy số 1: @Scheduled trong ứng dụng web chạy trên mọi replica, scale lên 5 pod là job chạy 5 lần.

Hình dung: ứng dụng 12-factor giống một container hàng tiêu chuẩn: bên trong đóng gói xong một lần, cảng nào (môi trường nào) cũng bốc dỡ được, chỉ khác tờ khai đi kèm (config).

Log, metric, tracing

Logging cho backend: log level, structured log, MDC và pipeline log tập trung với ELK hoặc Loki
flowchart LR
  A[Spring Boot ghi JSON ra stdout] --> N[File log của container trên node]
  N --> F[Agent: Fluent Bit / Filebeat]
  F --> Q[(Kafka, tuỳ chọn)]
  Q --> L[Logstash: parse, làm giàu]
  F --> L
  L --> ES[(Elasticsearch / OpenSearch)]
  ES --> K[Kibana: tìm, dashboard, cảnh báo]
  F -.->|thay thế rẻ hơn| LO[(Loki + Grafana)]
  • Level có nghĩa: ERROR là cần người xử lý, WARN là bất thường nhưng tự lo được, INFO là sự kiện nghiệp vụ, DEBUG chỉ bật khi điều tra.
  • Log JSON có cấu trúc với field cố định (traceId, orderId, userId) để lọc và đếm được, thay vì grep câu chữ.
  • Mỗi lỗi chỉ log một lần, ở nơi xử lý nó; không "log rồi ném lại" ở mọi tầng.
  • MDC gắn traceId vào mọi dòng log của một request, nhưng là ThreadLocal: qua thread pool phải tự truyền.
  • Không bao giờ log mật khẩu, token, số thẻ đầy đủ, OTP; che ngay ở ứng dụng, không trông vào pipeline.
  • Ứng dụng ghi ra stdout; agent trên node (Fluent Bit, Filebeat, OTel Collector) đẩy về Elasticsearch/OpenSearch hoặc Loki.
  • Bẫy số 1: log DEBUG mỗi request trên production. Vài chục pod là hàng TB mỗi ngày, và cụm log chết trước ứng dụng.

Hình dung: log như hộp đen máy bay: phải ghi đủ để dựng lại chuyện gì đã xảy ra, nhưng không ghi mọi tiếng động trong cabin, và phải nằm ở chỗ tìm được sau tai nạn.

Spring Boot Actuator: health, metrics và giám sát production
flowchart LR
  APP[Spring Boot app] --> ACT[Actuator, management port]
  ACT --> H[health]
  H --> LIV[liveness: restart?]
  H --> RDY[readiness: nhận traffic?]
  ACT --> M[metrics, Micrometer]
  M --> PROM[Prometheus kéo]
  PROM --> GRAF[Grafana, cảnh báo]
  K8S[Kubernetes] -.-> LIV
  K8S -.-> RDY
  ACT --> LOG[loggers, env, threaddump]
  • Actuator = các endpoint vận hành (/actuator/health, metrics, loggers, env...). Boot 4.0.5 qua HTTP mặc định chỉ mở health.
  • Expose đúng cái cần, chạy trên management port riêng không ra internet, và env/heapdump/threaddump phải có xác thực.
  • Health có nhóm: liveness ("có cần restart không") và readiness ("có nhận traffic được không"). DB, cổng thanh toán chỉ vào readiness, không bao giờ vào liveness.
  • Metric do Micrometer thu: Counter, Gauge, Timer, DistributionSummary; Prometheus kéo về qua /actuator/prometheus.
  • Cảnh báo theo p95/p99 và tỷ lệ lỗi, không theo trung bình: 2% request chậm 900 ms làm p99 = 905 ms trong khi trung bình chỉ 38 ms.
  • Bẫy số 1: gắn tag có giá trị không giới hạn (userId, URL thô) làm số time series nổ tung: 10.000 request thành 10.000 series.

Hình dung: Actuator là bảng đồng hồ trên xe: đèn báo động cơ (health), đồng hồ tốc độ và nhiệt độ (metrics), và một nút chỉnh độ nhạy cảm biến (loggers). Bảng đồng hồ nằm trong khoang lái, không gắn ra ngoài cho người qua đường bấm.

Distributed tracing với OpenTelemetry: trace, span, traceparent và sampling
  • Trace = hành trình của một request (trace_id 16 byte). Span = một đoạn công việc (span_id 8 byte, có cha, thời điểm bắt đầu/kết thúc).
  • traceparent đúng có bốn trường hex chữ thường: 00-<trace 32 hex>-<span cha 16 hex>-<flags>. Bản rút gọn <trace>-<span> của slide sẽ bị bỏ qua và trace đứt.
  • Context nằm trong ThreadLocal: mất khi nhảy thread, qua broker hay outbox nếu không ai mang theo.
  • Kiến trúc: API → SDK (hoặc Java agent) → OTLP (4317 gRPC / 4318 HTTP) → Collector → kho lưu trữ → giao diện.
  • Head sampling rẻ nhưng mù với lỗi; tail sampling giữ được lỗi và request chậm nhưng Collector có trạng thái, mọi span của một trace phải tới cùng một instance.
  • Bẫy số 1: span name chứa id thật (GET /bookings/123) làm bùng nổ cardinality; dùng route template.

Hình dung: trace như vận đơn của một kiện hàng. Mỗi kho trung chuyển đóng một dấu (span) có giờ vào, giờ ra, và ghi số vận đơn cũ lên dấu mới.

OWASP Top 10

Tấn công web và OWASP Top 10: MITM, SQL injection, XSS, CSRF, DDoS
  • Chữ ký không chống replay: phải ký cả timestamp + nonce.
  • SQL injection: bind mọi giá trị; tên cột và ORDER BY không bind được nên phải qua whitelist.
  • XSS: encode lúc xuất, theo ngữ cảnh, thêm CSP nonce. HttpOnly không chặn XSS.
  • CSRF chỉ xảy ra khi trình duyệt tự gửi credential (cookie). Phòng: CSRF token + SameSite.
  • DDoS chỉ giảm nhẹ được: L3/L4 giao nhà cung cấp, L7 tự lo bằng cache, rate limit, giới hạn input.
  • OWASP Top 10 là tài liệu nâng nhận thức; chuẩn kiểm tra được là ASVS.
  • Bẫy số 1: tắt cơ chế bảo vệ vì gặp lỗi (csrf.disable() vì 403), trong khi lỗi nghĩa là nó đang chạy đúng.

Hình dung: backend là người gác cổng; mỗi kiểu tấn công là một chỗ người gác tin nhầm, như tin tờ giấy ghi "cho tôi vào" là lệnh của sếp.

7. System design

Quy trình phỏng vấn system design, ước lượngLõi

Phỏng vấn system design: quy trình 4 bước và cách làm rõ yêu cầu
  • System design = giải quyết vấn đề + kiến thức khoa học máy tính. Phỏng vấn thì làm từ đầu; thực tế thì bị giới hạn bởi thời gian, tiền, người.
  • Bốn bước: hiểu vấn đề và chốt phạm vi → ước lượng → high-level design (API, data model, sơ đồ) → deep dive.
  • Functional requirement: chọn tối đa 3, ưu tiên cái giải trực tiếp nỗi đau của khách và cái trực tiếp ra tiền.
  • Non-functional requirement phải có con số: DAU, QPS, p99, % availability, dung lượng, retention.
  • NFR quan trọng = thứ làm hỏng trải nghiệm hoặc chặn tăng trưởng. Phỏng vấn hay xoáy vào scalability, performance, availability, reliability.
  • Bẫy số 1: nhảy vào giải pháp (Kafka, Redis, sharding) trước khi biết mình đang giải bài gì.

Hình dung: như khám bệnh: hỏi triệu chứng và đo chỉ số trước, kê đơn sau. Bác sĩ kê thuốc ngay từ câu đầu là bác sĩ đáng sợ.

Ước lượng back-of-the-envelope: con số phải thuộc và cách tính nhanh
flowchart LR
  A["Giả định và nói ra"] --> B["Quy về mỗi giây"]
  B --> C["Nhân hệ số đỉnh"]
  C --> D["Little's Law: thread, connection"]
  C --> E["Dung lượng, RAM, băng thông"]
  D --> F["Quyết định: server, cache, sharding"]
  E --> F
  • Mục đích: biết hệ thống cỡ nào, tìm bottleneck, quyết định có cần sharding, cache, bao nhiêu server. Không cần chính xác, cần đúng bậc độ lớn.
  • 1 ngày ≈ 10⁵ giây, nên 1 triệu/ngày ≈ 12/giây. Luôn quy về "mỗi giây" trước rồi mới tính tiếp.
  • Gom luỹ thừa 10: M × K = G, 10⁷ × 10³ = 10¹⁰. Viết đơn vị bên cạnh mọi con số.
  • Little's Law: số request đang xử lý cùng lúc = throughput × thời gian xử lý trung bình. Dùng để ra số thread, connection, server.
  • Bảng số 9: 99,9% ≈ 8,8 giờ chết/năm, 99,99% ≈ 52 phút, 99,999% ≈ 5 phút.
  • Bẫy số 1: tính theo trung bình mà quên đỉnh (thường gấp 2–10 lần).

Hình dung: như đi chợ cho đám cưới: không ai đếm từng hạt gạo, nhưng phải biết 300 khách hay 3.000 khách, vì đó là khác biệt giữa thuê nhà hàng và dựng rạp.

Nguyên tắc: CAP, scalability, availabilityLõi

Nguyên tắc thiết kế: CAP, PACELC, scalability, performance và availability
  • CAP: khi mạng bị chia cắt (partition), phải chọn C hoặc A. P không phải thứ được bỏ. PACELC thêm vế: lúc bình thường thì chọn latency hay consistency.
  • Chữ C trong CAP (mọi node thấy cùng giá trị mới nhất) khác chữ C trong ACID (dữ liệu không phá ràng buộc).
  • Scalability: dùng tài nguyên hiệu quả, giữ service stateless, tách theo dữ liệu, nghiệp vụ và thao tác (đọc/ghi, cache).
  • Performance: đặt mục tiêu bằng p99 và throughput, tìm bottleneck, tối ưu theo loại tải CPU hay I/O, đo liên tục.
  • Availability = MTBF / (MTBF + MTTR). Giảm thời gian khôi phục thường rẻ hơn tăng thời gian giữa hai lần hỏng.
  • Bẫy số 1: tối ưu sớm (premature optimization) khi chưa có số đo và chưa biết bottleneck ở đâu.

Hình dung: một quán ăn. Scalability là thêm được bếp khi khách đông; performance là mỗi món ra nhanh; availability là quán không đóng cửa khi một đầu bếp nghỉ ốm.

Kiến trúc phần mềm thực dụng: architectural driver, vai trò kiến trúc sư và quyết định theo bối cảnh
  • Kiến trúc không chọn theo cảm giác hay theo công ty khác, mà theo architectural driver: functional requirement, business constraint, technical constraint, quality attribute.
  • Bốn nhóm này nối với nhau: kéo một cái (deadline sớm hơn, availability cao hơn) thì phải nhả cái khác (bớt tính năng, thêm hạ tầng, dời ngày).
  • Mỗi "số 9" availability thêm vào giảm downtime đi 10 lần và thường kéo theo thêm thành phần hạ tầng.
  • Thực dụng = giải bài toán đang có hoặc sắp có (vài tuần tới), dựa trên số liệu thật, nhưng giữ cửa mở bằng ranh giới module rõ ràng.
  • Bẫy số 1: chạy theo hype (microservices, Kubernetes, cache khắp nơi) khi driver không đòi hỏi.
  • Kiến trúc sư hiện đại là một chức năng trong team, không phải tháp ngà: hiểu nghiệp vụ, nói được với cả dev lẫn business, và dám nói "dừng".

Hình dung: kiến trúc sư giống người quản lý công trình. Không cần giỏi trát tường hay đi ống nước nhất, nhưng phải biết ghép mọi thứ để căn nhà ở được và không rò nước trong tường.

Chọn database: SQL, NoSQL, NewSQL

Chọn database trong system design: SQL, NoSQL, NewSQL, columnar và time-series
  • Trần thô của một node quan hệ tầm trung: ~20K QPS đọc đơn giản, ~1.000 TPS ghi khi ít tranh chấp, ~200 TPS khi nhiều request cùng tranh một dòng.
  • Bảng to: leo thang từ query, index, archive, cache, replica rồi mới partition, shard, đổi database.
  • RDBMS khó scale ngang vì: consistency mạnh, join trong một máy, ghi B+tree là random I/O, không tự shard.
  • NoSQL đổi consistency và truy vấn linh hoạt lấy khả năng ghi và scale: key-value, document, wide-column, graph, time-series.
  • Columnar (ClickHouse) cho báo cáo quét nhiều dòng ít cột; time-series (TimescaleDB) cho metric theo thời gian.
  • Bẫy số 1: chọn theo "nhiều QPS" mà quên mức tranh chấp. Nhiều người ghi cùng một dòng thì đổi database không cứu được.

Hình dung: chọn database giống chọn xe: xe tải (RDBMS) chở được mọi thứ nhưng chậm khi đông, xe máy (key-value) luồn nhanh nhưng chỉ chở một kiện, xe bồn (columnar) chỉ chở một loại hàng nhưng chở rất nhiều.

Cache: cache-aside, sự cố, distributed lockLõi

Cache-aside, write-around và bài toán lệch dữ liệu cache–DB
  • Hit rate 95% → 99%: latency giảm 0,8 ms, tải DB giảm 5 lần.
  • Combo phổ biến nhất: đọc cache-aside, ghi write-around (commit DB rồi xoá key), kèm TTL.
  • Writer xoá key, không ghi giá trị: hai writer có thể SET cache ngược thứ tự với DB.
  • Xoá sau commit, không phải trong @Transactional. Xoá trước thì lệch suốt lần ghi DB.
  • Race còn sót (reader chậm nạp lại bản cũ) rất hiếm; đóng bằng TTL, double delete, version + tombstone, lease.
  • DB và Redis không có transaction chung: lần xoá có thể lỗi, cần retry, outbox hoặc CDC.
  • Bẫy số 1: nạp cache từ replica đang trễ thì xoá đúng thứ tự vẫn nạp lại bản cũ.

Hình dung: cache là tờ ghi chú dán trên bàn, DB là sổ cái. Sửa sổ cái xong thì xé tờ ghi chú; ai cần thì chép lại từ sổ. Đừng tự viết tờ ghi chú mới, vì hai người viết cùng lúc sẽ không biết tờ nào mới hơn.

Các sự cố cache: avalanche, breakdown, penetration, hot key, big key
  • Hit rate 99% nghĩa là DB chỉ được thiết kế cho 1% tải: mất cache là sự cố, không phải chậm đi.
  • Avalanche: cache sập hoặc rất nhiều key hết hạn cùng lúc. Chữa: HA, bảo vệ DB (bulkhead, circuit breaker), TTL có jitter.
  • Breakdown: một key nóng hết hạn, hàng nghìn request cùng nạp lại. Chữa: refresh nền, mutex, single-flight.
  • Penetration: key không có ở cả cache lẫn DB. Chữa: cache giá trị rỗng TTL ngắn, validate, Bloom filter.
  • Hot key: thêm node không giúp vì một key luôn nằm trên một node. Chữa: local cache, nhân bản key.
  • Big key: chia nhỏ, nén, xoá bằng UNLINK. Redis thuần cache dùng allkeys-lru/allkeys-lfu.
  • Bẫy số 1: @Cacheable(sync = true) chỉ chống stampede trong một JVM, và disableCachingNullValues() mở cửa cho penetration.

Hình dung: cache là con đê, DB là cánh đồng phía sau chỉ chịu được một vũng nước. Đê vỡ, rò một lỗ, hay bị đục xuyên, cánh đồng đều ngập.

Review code distributed lock bằng Redis: 6 lỗi thường gặp
flowchart TD
  A{"Lock cho việc gì?"} -->|"Dòng DB"| B["Điều kiện, version, FOR UPDATE"]
  A -->|"Việc ngoài DB"| C["SET token NX PX ttl"]
  C --> D["Nhiều khoá: theo thứ tự"]
  D --> E["Làm việc trong lease"]
  E --> F["Unlock: Lua so token"]
  E -.->|"GC pause, failover"| G["Hai người cùng giữ"]
  G --> H["Fencing token ở tài nguyên"]
  • Lấy khoá: SET key <token ngẫu nhiên> NX PX ttl. Mở khoá: script Lua so token rồi mới DEL.
  • Giá trị khoá hằng số + DEL mù = xoá nhầm khoá của người khác, hai bên cùng vào vùng găng.
  • Nhiều khoá: lấy tuần tự theo thứ tự đã sắp xếp (hoặc một script Lua tất-cả-hoặc-không), chỉ nhả khoá mình giữ.
  • Thời lượng trong cấu hình phải mang đơn vị (Duration, 30s): code mẫu nhân 1000 hai lần, 5 phút thành 9,5 năm.
  • Redis lock là một lease (tự hết hạn): GC pause hoặc failover làm hai người cùng giữ. Cần đúng đắn thì thêm fencing token ở tài nguyên.
  • Trade-off chính: Redis lock cho việc nằm ngoài transaction DB; dữ liệu là dòng DB thì dùng câu lệnh có điều kiện, version, FOR UPDATE.
  • Bẫy số 1: tin rằng Redis lock một mình đảm bảo đúng đắn.

Hình dung: Redis lock như thẻ giữ chỗ có hạn giờ. Hết giờ thì người khác được lấy, dù bạn chưa xong; chỉ khi quầy (tài nguyên) kiểm tra số thẻ thì người cầm thẻ cũ mới bị chặn.

Cache trong system design: các tầng cache, giới hạn của Redis và case study bộ đếm 1 triệu QPS
  • Cache có ở mọi tầng: client, CDN, reverse proxy, bộ nhớ trong service, cache dùng chung (Redis), và buffer của database. Tầng càng gần client càng rẻ nhưng càng khó xoá.
  • Ba công dụng: tăng tốc đọc, đệm (buffer, khác cache), và chia sẻ dữ liệu giữa các instance.
  • Một Redis: ~50K SET/s, ~80K GET/s, nên giữ ≤ 32 GB mỗi instance. Vượt thì Cluster.
  • Bộ đếm like/view: không UPDATE ... SET count = count + 1 trên DB; dùng HINCRBY trong Redis, đẩy xuống DB theo lô.
  • Bộ đếm broadcast chưa đọc: không tăng cho 10 triệu user; mỗi user giữ một con trỏ "đã đọc tới đâu".
  • Bẫy số 1: tin rằng Redis đơn luồng là hết race. Chỉ một lệnh là atomic; đọc rồi ghi từ client vẫn race.

Hình dung: cache nhiều tầng như kho hàng: tủ lạnh ở nhà (client), cửa hàng đầu ngõ (CDN), kho quận (Redis), nhà máy (database). Lấy ở chỗ càng gần càng nhanh, nhưng đổi hàng ở mọi chỗ càng khó.

Message broker, KafkaLõi

Message broker: 4 bài toán của request-response và cách chọn broker
  • Request-response: latency là tổng các lần gọi, độ sẵn sàng là tích. Ba service 99,9% thì chuỗi còn ~99,7%.
  • Broker giải bốn bài toán: chờ nhau (bất đồng bộ), chết theo nhau (decoupling), thêm bên nhận (fan-out), traffic đột biến (làm phẳng tải).
  • Cái giá: eventual consistency, message trùng (consumer phải idempotent), thứ tự chỉ trong một partition, debug khó, thêm hệ thống phải vận hành.
  • Event là sự việc đã xảy ra, bất biến, phát lại được. Response chỉ dành cho một bên. Command là mệnh lệnh cho một bên cụ thể.
  • Chọn broker theo thứ tự: delivery guarantee → chức năng → hiệu năng → mở rộng → hệ sinh thái.
  • Đánh đổi chính: hiệu năng mua thêm được, đảm bảo giao nhận và chức năng thì không.
  • Bẫy số 1: save() rồi send() là dual write, hai bên có thể lệch nhau. Dùng transactional outbox.

Hình dung: gọi đồng bộ là gọi điện thoại, cả hai phải rảnh cùng lúc; broker là bưu điện, người gửi bỏ thư rồi đi, người nhận lấy khi sẵn sàng.

Vì sao Kafka nhanh và bền: log, zero-copy, batching, replication
  • Kafka đổi vài ms latency lấy throughput: gom batch, chờ linger.ms, nén cả batch.
  • Nhanh nhờ: log append-only (I/O tuần tự), zero-copy sendfile, ghi vào page cache không fsync, không xoá khi đọc (chỉ lưu offset).
  • Partition là đơn vị song song; thứ tự chỉ đảm bảo trong một partition. Cùng key → cùng partition.
  • Tăng số partition làm key đổi partition (mất thứ tự theo key), và không giảm được.
  • Bền nhờ replication, không nhờ fsync: replication.factor=3 + min.insync.replicas=2 + acks=all ở mọi producer.
  • Bẫy số 1: min.insync.replicas bị bỏ qua với acks=1; khi thiếu ISR, ứng dụng chỉ thấy TimeoutException.

Hình dung: Kafka như một cuốn sổ chỉ ghi thêm, có ba bản chép tay ở ba phòng. Người đọc chỉ cần nhớ mình đang ở trang nào; cháy một phòng vẫn còn hai cuốn.

Cấu hình Kafka theo mục tiêu: throughput, latency, durability, availability
flowchart TD
  G{Ưu tiên gì?} -->|Durability| D["acks=all, RF=3, min ISR=2"]
  G -->|Throughput| T["linger.ms, batch.size lớn, zstd"]
  G -->|Latency| L["linger.ms=0, fetch.min.bytes=1"]
  D -.->|đánh đổi| X["Broker chết: partition ngừng ghi"]
  C[Consumer] --> CM[Commit sau khi xử lý]
  CM --> ID[Ghi idempotent]
  B["Mặc định an toàn ở broker"] --> TP[Ghi đè theo topic]
  TP --> BM["Benchmark, monitor, tune"]
  • Hỏi "ưu tiên gì" trước "linger.ms bao nhiêu". Tài chính: durability đầu; ingestion: throughput đầu.
  • Durability: acks=all, idempotence, RF=3, min.insync.replicas=2, tắt unclean election.
  • Throughput: linger.ms và batch.size lớn, nén zstd, nhiều partition. Latency: linger.ms=0, fetch.min.bytes=1.
  • Trade-off chính: min ISR cao và tắt unclean thì không mất record, nhưng partition ngừng nhận ghi khi broker chết.
  • Bẫy số 1: auto-commit với xử lý bất đồng bộ commit offset trước khi xử lý xong, crash là mất. Commit sau khi xử lý, ghi idempotent.
  • Mặc định đổi theo phiên bản client (3.0: acks=all; 4.0: linger.ms=5), nên đặt tường minh.
  • Đặt mặc định an toàn ở broker, ghi đè theo topic; rồi benchmark, monitor, tune từng tham số.

Hình dung: như chọn cách gửi hàng: bảo đảm có ký nhận (durability), xe tải đầy mới chạy (throughput), hay xe máy giao ngay (latency). Không dịch vụ nào vừa rẻ, vừa nhanh, vừa chắc nhất.

Kafka producer bên trong: send(), batching, partitioner và transaction
  • send() không gửi gì cả: nó serialize, chọn partition rồi bỏ record vào RecordAccumulator (bộ đệm theo partition). Một sender thread riêng gom batch và gửi.
  • send() có thể chặn tới max.block.ms (60 s) khi chưa có metadata hoặc bộ đệm buffer.memory (32 MB) đầy. Callback chạy trên sender thread, không được làm việc nặng trong đó.
  • Đo ở 5.000 msg/s: linger.ms=0 tốn 14.333 request, linger.ms=5 còn 554 request (thêm ~3 ms), linger.ms=20 còn 147 request (thêm ~11 ms).
  • Không có key: partitioner "dính" vào một partition tới khi đủ khoảng batch.size byte rồi mới chuyển (uniform sticky, từ Kafka 3.3), và né broker chậm.
  • Retry: để retries mặc định (vô hạn) và giới hạn bằng delivery.timeout.ms, không đặt retries=30 như slide.
  • Transaction = transactional.id + epoch để fencing (chặn instance cũ), coordinator ghi control marker vào từng partition. Consumer read_committed chỉ đọc tới LSO (offset ổn định cuối cùng).
  • Bẫy số 1: transaction mở lâu chặn mọi consumer read_committed trên partition đó, tới khi commit, abort hoặc hết transaction.timeout.ms.

Hình dung: producer như bưu cục: bạn bỏ thư vào ngăn theo tuyến (accumulator), xe thư (sender thread) chạy khi ngăn đầy hoặc tới giờ (linger.ms). Transaction là bao thư bảo đảm: người nhận chỉ mở khi bưu cục đóng dấu "đã giao đủ".

Kafka serialization và Schema Registry: chọn format, wire format và compatibility mode
  • Kafka không có serializer mặc định; key và value mỗi cái một serializer, và deserializer phía consumer phải khớp.
  • Lỗi hay gặp: deserialize byte thành String rồi mới parse JSON. Đọc thẳng từ byte sang object, đỡ một lần copy.
  • Cùng một đơn hàng: JSON 85 byte, Avro qua Schema Registry 29 byte (đã gồm 5 byte header).
  • Schema Registry: producer đăng ký schema, nhận schema id; mỗi message mang 0x00 + 4 byte id + dữ liệu. Consumer lấy schema theo id (có cache).
  • Compatibility mặc định là BACKWARD: schema mới đọc được dữ liệu cũ, nên nâng consumer trước. FORWARD thì nâng producer trước, FULL thì thứ tự nào cũng được.
  • Quy tắc an toàn với Avro: thêm hay xoá field luôn kèm default; không đổi tên (trừ khi dùng alias), không đổi kiểu.
  • Bẫy số 1: tắt auto.register.schemas ở production, nếu không mỗi bản build lạ của producer có thể đăng ký một schema mới.

Hình dung: Schema Registry như kho bản vẽ: mỗi kiện hàng chỉ dán số bản vẽ, người nhận tra số để biết cách mở. Compatibility mode là luật "bản vẽ mới phải lắp được với linh kiện cũ".

Kafka consumer group bên trong: rebalance, assignor, static membership và liveness
  • Mỗi group có một coordinator (broker giữ partition hash(group.id) % 50 của __consumer_offsets). Giao thức cũ còn chọn một consumer làm group leader để tính phân chia.
  • Rebalance cũ (eager): mọi consumer trả hết partition rồi nhận lại. Đo: thêm 2 consumer vào group 6 partition, consumer đầu bị thu hồi 10 lần partition dù chỉ cần chuyển 4.
  • Cooperative-sticky chỉ thu hồi partition phải chuyển (4 lần thu hồi), đổi lại mất hai vòng. KIP-848 (Kafka 4.0+) đưa việc chia về broker, không còn rào chắn toàn group.
  • Static membership (group.instance.id): restart trong session.timeout.ms thì không rebalance, giữ nguyên partition.
  • Hai kiểm tra liveness: heartbeat (thread nền, session.timeout.ms 45 s) và tiến độ poll (max.poll.interval.ms 5 phút). Sống mà không poll vẫn bị đá.
  • Bẫy số 1: xử lý một lần poll lâu hơn max.poll.interval.ms gây vòng lặp: bị đá, commit thất bại, nhận lại đúng các record đó, xử lý lại mãi.
  • Poison pill ở client thuần: poll() ném RecordDeserializationException ở cùng offset mãi cho tới khi bạn seek qua.

Hình dung: group như ca trực ở bếp: quản lý ca (coordinator) phân bàn cho đầu bếp (partition cho consumer). Kiểu cũ: có người vào ca là cả bếp dừng tay, trả hết bàn, phân lại. Kiểu cooperative: chỉ chuyển vài bàn, ai đang nấu cứ nấu.

Case study: gọi fraud-check đồng bộ qua Kafka và Redis — nên hay không?
  • Request-reply qua Kafka = nhược điểm của RPC (bên kia chậm thì mình chậm) mà mất ưu điểm của messaging (không phải chờ). Không làm mặc định.
  • Event ("đã xảy ra") và command ("hãy làm") khác vòng đời và chủ sở hữu, nên tách topic.
  • Nhiều instance chờ reply: dùng correlation id + group riêng hoặc partition reply riêng mỗi instance (ReplyingKafkaTemplate), không poll.
  • Timeout nghiệp vụ ngắn (1–2 s) và tường minh; kết quả có trạng thái thứ ba UNKNOWN.
  • Bẫy số 1: timeout biến thành null rồi HTTP 200 rỗng, tức fail-open ngầm: giao dịch đáng ngờ đi qua đúng lúc fraud-check sự cố.
  • Ghi DB và gửi Kafka riêng lẻ là dual write; transactional outbox biến nó thành at-least-once, consumer phải khử trùng.
  • Tốt nhất: gọi HTTP/gRPC có timeout nếu sửa được bên kia, hoặc đổi UX sang bất đồng bộ (202 + PENDING).

Hình dung: gửi thư bảo đảm rồi đứng ở hộp thư chờ hồi âm. Thư thì tới chắc, nhưng bạn vẫn đứng đó, và không ai nói bạn phải bỏ về sau bao lâu.

Kafka trong thực tế (1): số partition, message lớn, lag và tác vụ chạy lâu
  • Số partition = throughput mong muốn / throughput một partition, tính cho cả phía ghi và phía đọc, lấy số lớn hơn, chọn số chia hết nhiều (12, 24).
  • Partition chỉ tăng được, và tăng làm đổi partition của key. Muốn giảm thì chuyển sang topic mới.
  • Message lớn: đừng nâng giới hạn 1 MB lên 10 MB; đưa file lên object storage và gửi URL (claim check).
  • Lag là KPI số một của consumer. Đo và tìm nguyên nhân trước, scale consumer sau (và scale bị chặn bởi số partition).
  • Tác vụ chạy lâu: async thì mất at-least-once, chỉnh liveness thì mong manh, pipeline nhiều stage là cách bền nhất.
  • Bẫy số 1: một record lỗi (poison pill) retry vô hạn làm kẹt cả partition. Cần retry có trần rồi đẩy sang dead letter topic.

Hình dung: partition là số làn của đường cao tốc. Làn ít thì kẹt, làn nhiều thì tốn đường; xe quá khổ (message lớn) nên đi đường khác, và một xe chết máy (poison pill) phải được kéo ra lề.

Kafka trong thực tế (2): dual write, exactly-once và thứ tự message
  • Không có transaction nào bao cả database lẫn Kafka. Ghi DB rồi gửi event (hoặc ngược lại) sẽ có lúc lệch.
  • Hai lần ghi đều vào Kafka: dùng Kafka transaction. Một lần vào DB, một lần vào Kafka: dùng transactional outbox (ghi event vào bảng outbox trong cùng transaction, CDC đẩy ra Kafka).
  • Exactly-once của Kafka chỉ phủ luồng Kafka → Kafka. Luồng có side effect (ghi DB) = at-least-once + consumer idempotent.
  • At-least-once cần cả hai đầu: producer acks=all + retry + idempotence; consumer commit sau khi xử lý, group cố định.
  • Kafka chỉ giữ thứ tự trong một partition. Thứ tự đầu-cuối = cùng key + idempotent producer + xử lý tuần tự trong partition.
  • Bẫy số 1: tin rằng "Kafka có exactly-once" nghĩa là email, lệnh chuyển tiền hay bản ghi DB của bạn cũng chỉ xảy ra một lần.

Hình dung: outbox giống phiếu gửi hàng dán ngay vào hoá đơn: thu tiền và lập phiếu xảy ra cùng lúc, còn shipper (CDC) đến lấy phiếu sau. Shipper có thể giao hai lần, nên người nhận phải kiểm mã phiếu.

Case study: phát hiện gian lận với Kafka và Redis — topic, key, cửa sổ và hỏng hóc
  • Kiểm tra bất đồng bộ: ví ghi giao dịch rồi phát event; detector đọc Kafka, đếm trong Redis, phát "rule hit". Không thêm latency vào luồng thanh toán.
  • Key Kafka = account_id: mọi giao dịch của một tài khoản vào cùng partition, đúng thứ tự, một consumer xử lý.
  • Đếm bằng cửa sổ trượt trong Redis sorted set (score = thời điểm, member = transaction_id), gói trong một script Lua cho nguyên tử.
  • Member là transaction_id nên Kafka giao lại không đếm hai lần: phép đếm tự idempotent.
  • Redis chỉ là bản sao tính được từ log: mất Redis thì reset offset về 5 phút trước và replay.
  • Bẫy số 1: dùng INCR theo cửa sổ cố định. Vừa đếm trùng khi giao lại, vừa bỏ sót kẻ gian dàn 100 giao dịch vắt qua ranh giới hai cửa sổ.

Hình dung: detector như nhân viên ngân hàng có một cuốn sổ cho mỗi khách, chỉ ghi giờ của 5 phút gần nhất; mỗi phiếu mới tới, xé trang cũ, đếm số dòng còn lại. Mất sổ thì đọc lại băng camera 5 phút gần nhất là chép lại được.

Ôn CCDAK: 40 câu hỏi Kafka đáng nhớ
mindmap
  root((Ôn thi CCDAK))
    KRaft thay ZooKeeper
      Metadata là record trong log
    Độ bền
      acks=all, RF 3, min ISR 2
    Consumer
      auto.offset.reset khi chưa có offset
      Commit trước hay sau xử lý
    Thêm partition đổi ánh xạ key
    Schema Registry từ chối schema
    Bẫy: học dump cũ
  • Kafka 4.0 bỏ hẳn ZooKeeper: ACL, cấu hình động, controller giờ là record trong log __cluster_metadata do quorum KRaft quản lý.
  • Độ bền chuẩn: acks=all + RF 3 + min.insync.replicas=2. Min ISR chỉ có tác dụng với acks=all, và chỉ chặn ghi, không chặn đọc.
  • auto.offset.reset chỉ dùng khi group chưa có offset hợp lệ. Commit trước khi xử lý = at-most-once, sau = at-least-once.
  • Consumer chỉ đọc tới high watermark, nên acks=1 không làm dữ liệu hiện ra sớm hơn.
  • Tăng partition làm đổi ánh xạ key → partition cho record mới; record cũ nằm yên.
  • Schema Registry (không phải broker) từ chối schema không tương thích. Exactly-once của Streams chỉ cho luồng Kafka → Kafka.
  • Bẫy số 1: học "dump" thời ZooKeeper, vừa sai vừa lỗi thời.

Hình dung: đề ôn cũ như bản đồ trước khi làm đường mới: đường vẫn dẫn tới đúng chỗ, nhưng tên đường (znode → record metadata) đã đổi hết.

Luyện CCDAK phần 2: 34 câu tự luyện về client, Connect, Schema Registry và Streams
mindmap
  root((Luyện đề CCDAK 2))
    Cluster: một controller hoạt động
    Producer: linger.ms gom batch
    Consumer: assign khác subscribe
    Schema Registry chỉ giữ schema
    Connect: source vào, sink ra
    KTable trạng thái, KStream sự kiện
    Bẫy: đáp án lưu hành sai
  • assign() để đọc partition cụ thể; không dùng chung với subscribe(), và gọi subscribe() lần nữa là thay danh sách cũ, không cộng thêm.
  • linger.ms tăng cơ hội gom batch; khi batch đã đầy thì tăng batch.size và bật nén.
  • Mỗi cluster có đúng một controller hoạt động; --zookeeper đã bị bỏ khỏi kafka-topics từ Kafka 3.0.
  • Schema Registry lưu schema (topic _schemas), cấp id và kiểm tra tương thích; nó không lưu dữ liệu, và client tự hỏi nó khi gặp id lạ.
  • Connect: source đưa dữ liệu vào Kafka, sink đưa ra; task hữu ích của sink không vượt số partition.
  • KTable cho trạng thái hiện tại (tồn kho, tổng tiền), KStream cho chuỗi sự kiện.
  • Bẫy số 1: tin đáp án của bộ câu hỏi lưu hành. Ít nhất 10 câu trong bộ mình xem có đáp án sai hoặc đã lỗi thời.

Hình dung: làm đề như tập võ với bao cát: bao cát không phải đối thủ thật, nhưng đấm sai tư thế thì vào trận cũng sai.

CAP, consistency, idempotencyLõi

Idempotency phần 1: at-least-once, unique constraint và Idempotency-Key trên PostgreSQL
  • Bên gửi không phân biệt được "request mất" với "response mất", nên phải retry: mọi kênh là at-least-once.
  • Exactly-once làm được ở mức xử lý (at-least-once + bên nhận khử trùng), không phải ở mức giao nhận.
  • Ba cách: conditional update theo state machine, unique constraint/upsert, bảng dedupe cùng transaction với nghiệp vụ.
  • Idempotency-Key: claim key bằng INSERT ... ON CONFLICT DO NOTHING trong cùng transaction; request trùng tự chờ ở unique index.
  • Có lời gọi ra ngoài thì chuyển sang hai pha IN_PROGRESS → COMPLETED, và truyền key xuống hệ thống ngoài.
  • Bẫy số 1: lưu request_id mà không có UNIQUE, hoặc kiểm tra "đã có chưa" bằng code, thì không chống trùng được gì.
  • Lock chặn chạy song song, không chặn chạy lặp lại.

Hình dung: idempotency giống sổ ký nhận ở quầy: ai mang cùng số phiếu tới lần hai thì được chỉ vào chữ ký cũ, không được phát hàng lần nữa.

Idempotency phần 2: consumer Kafka, idempotent producer và IPN cổng thanh toán
  • Consumer khử trùng bằng bảng processed_message: INSERT ON CONFLICT DO NOTHING cùng transaction với thay đổi nghiệp vụ, commit offset sau.
  • Bẫy số 1: producer retry ở tầng ứng dụng mà sinh message_id mới thì dedupe theo id không chặn được. Dùng khoá nghiệp vụ ổn định.
  • Idempotent producer (PID + sequence) chỉ chống trùng do retry nội bộ của client, trong một phiên. Cần acks=all, max.in.flight ≤ 5.
  • Mặc định bật từ Kafka 3.0, nhưng đặt acks=1 mà không ghi rõ enable.idempotence là bị tắt âm thầm.
  • IPN là nguồn sự thật, return URL chỉ để hiển thị, job đối soát vá đơn bị lỡ.
  • Handler IPN: chữ ký → số tiền → state machine (chỉ chuyển từ PENDING_PAYMENT). Lần gửi lại trả "đã xác nhận", không trả lỗi.
  • Side effect ra ngoài DB (email, API): chấp nhận trùng, hoặc đi qua bảng việc cần làm.

Hình dung: bảng dedupe như sổ ký nhận: kiện đã ký thì shipper mang lại lần nữa cũng chỉ nghe "đã nhận rồi".

Distributed transaction: 2PC, TCC, saga, pivot transaction và transactional outbox
  • Mục tiêu chính của transaction là atomicity. Distributed transaction chạy đồng thời gần như luôn vi phạm isolation.
  • 2PC cho nhất quán mạnh ở trường hợp suôn sẻ, nhưng giữ khoá suốt hai pha và kẹt khi coordinator chết.
  • Thang nhất quán giảm dần: 2PC (XA) > AT > TCC > 2-phase message > saga. Đi xuống thì đồng thời và khả năng scale tăng.
  • Saga: chuỗi transaction cục bộ, lỗi thì chạy bù (compensation). Cần idempotency và cách bù cho thiếu isolation (semantic lock, đọc lại, đổi thứ tự).
  • Pivot transaction là bước "qua được là chắc chắn xong": trước nó phải bù được, sau nó phải retry tới khi thành công.
  • Bẫy số 1: nghĩ outbox hay event sourcing "giải quyết distributed transaction". Outbox chỉ giải bài dual write (ghi DB và gửi message cùng nhau).

Hình dung: saga như đặt tour: đặt vé máy bay, khách sạn, xe; khách sạn hết phòng thì huỷ vé máy bay và xe đã đặt, chứ không có cách nào "đặt cả ba cùng một lúc".

JOIN, partition, replication, shardingLõi

JOIN chạy thế nào (nested loop, hash join, merge join) và khi nào partition bảng
  • Nested loop: với mỗi dòng ngoài, tra bảng trong. Cần index trên cột join của bảng trong; trả dòng đầu ngay, hợp LIMIT.
  • Hash join: build hash table từ input nhỏ, probe bằng input lớn. Không cần index nhưng cần bộ nhớ; thiếu thì tràn đĩa (Batches > 1).
  • Merge join: đi song song hai input đã sắp xếp. PostgreSQL dùng thường xuyên, MySQL không có.
  • Điều kiện trên bảng bên phải đặt ở WHERE biến LEFT JOIN thành INNER JOIN.
  • Partition chia bảng trong một server (đọc ít hơn, xoá dữ liệu cũ rẻ); shard chia qua nhiều server (tăng khả năng ghi).
  • Bẫy số 1 của partition: PK/unique phải chứa partition key, và truy vấn không lọc theo key phải đọc mọi partition.
  • Bảng quá lớn: leo từng bậc query → index → archive → cache → replica → partition/shard → database khác.

Hình dung: nested loop là tra từ điển cho từng từ; hash join là chép danh sách nhỏ lên bảng rồi dò danh sách lớn một lượt; merge join là hai người cầm hai danh sách đã xếp theo ABC cùng dò xuống.

Replication primary–replica và tách đọc/ghi: replication lag, read-your-writes và failover
flowchart LR
  App[Ứng dụng] -->|ghi| P[(Primary)]
  App -->|đọc thường| R1[(Replica 1)]
  App -->|đọc thường| R2[(Replica 2)]
  App -->|đọc ngay sau khi ghi| P
  P -->|"binlog / WAL, bất đồng bộ"| R1
  P -->|"binlog / WAL"| R2
  F{Primary chết?} -->|promote| R1
  F -.->|fencing| P
  • Primary nhận mọi lệnh ghi và đẩy log thay đổi (binlog của MySQL, WAL của PostgreSQL) cho replica phát lại. Replica phục vụ đọc.
  • Mặc định là bất đồng bộ: commit trả về trước khi replica nhận được, nên replica trễ (replication lag) và failover có thể mất vài giao dịch cuối.
  • Replica scale đọc, không scale ghi: mọi lệnh ghi vẫn dồn vào một primary.
  • Read-your-writes: đọc primary ngay sau khi ghi, ghim user vào primary vài giây, hoặc mang LSN/GTID của lần ghi theo request.
  • Spring Boot: AbstractRoutingDataSource + LazyConnectionDataSourceProxy, chọn replica khi @Transactional(readOnly = true).
  • Bẫy số 1: kiểm tra điều kiện trên replica rồi ghi lên primary (số dư, tồn kho, trùng email). Mọi "đọc để quyết định ghi" phải đọc primary.
  • Replica không phải backup: DROP TABLE cũng được sao chép sang ngay.

Hình dung: primary là thầy giáo viết bảng, replica là học sinh chép bài; đọc vở học sinh thì nhanh và nhiều người đọc được, nhưng có lúc vở chép chậm hơn bảng vài dòng.

Sharding trong system design: chọn shard key, bốn case study và resharding
  • Đừng shard nếu chưa có nút thắt. Gợi ý ngưỡng: ≥ 50M dòng thì partition, ≥ 200M dòng hoặc ≥ 3.000 TPS ghi thì nghĩ tới shard.
  • Shard key tốt: là thực thể gốc của truy vấn (để không phải đi nhiều shard), nhỏ, và nhiều giá trị khác nhau (chia đều).
  • Range dễ hiểu nhưng tạo điểm nóng; hash chia đều nhưng mất truy vấn theo khoảng. Thường chọn hash.
  • hash % N làm gần như mọi key đổi chỗ khi N đổi; dùng logical shard hoặc consistent hashing.
  • Truy vấn không có shard key thành scatter-gather (hỏi mọi shard). Transaction và join xuyên shard gần như không có.
  • Bẫy số 1: shard sớm "cho chắc". Nếu làm, làm một lần cho vài năm: ví dụ 16 database × 64 logical shard.

Hình dung: shard như chia một thư viện ra nhiều toà nhà. Chọn quy tắc xếp sách (shard key) sai thì người đọc phải chạy qua mọi toà để tìm một cuốn.

Thanh toán, cổng thanh toán, ledger

Tích hợp cổng thanh toán kiểu VNPay: redirect, chữ ký và IPN
  • IPN (cổng gọi thẳng server mình, có chữ ký) là nguồn sự thật; return URL (trình duyệt quay về) chỉ để hiển thị.
  • Mỗi lần thử thanh toán là một dòng payment với txn_ref riêng; partial unique index giữ tối đa một lần thử PENDING mỗi booking.
  • Ký URL: sắp tham số theo tên, nối ten=giatri_da_encode bằng &, HMAC-SHA512 với hash secret. Số tiền do backend tính, vnp_Amount = VND × 100.
  • Handler IPN: lưu nguyên văn → chữ ký → đơn → số tiền → trạng thái → cập nhật; trả 00 khi đã ghi (cả thất bại), 99 để cổng gửi lại.
  • UPDATE ... WHERE status IN (...) làm handler idempotent; việc chậm (xuất vé, email) đi qua outbox.
  • Bẫy số 1: "invalid checksum" thường do chuỗi đem ký khác cổng (dấu cách thành + hay %20), không phải sai khoá.

Hình dung: return URL là khách tự kể "tôi trả rồi", IPN là sao kê ngân hàng có đóng dấu. Chỉ ghi sổ theo sao kê.

Thanh toán sau khi tích hợp: IPN tới muộn, đối soát và bảng failure mode
flowchart TD
  A["IPN từ cổng"] --> C["apply idempotent"]
  B["Job querydr định kỳ"] --> C
  C --> D["Ghi SUCCEEDED"]
  D --> E{"Booking còn giữ chỗ?"}
  E -->|"Còn"| F["Booking PAID"]
  E -->|"Đã nhả"| G{"Còn ghế cùng hạng?"}
  G -->|"Có"| F
  G -->|"Không"| H["REFUND_PENDING, hoàn tiền"]
  I["Đối soát hằng ngày"] --> J["FULL JOIN sao kê và payment"]
  J --> K["5 loại, OURS_ONLY nặng nhất"]
  • IPN thành công tới muộn vẫn là tiền thật: luôn ghi SUCCEEDED, rồi giữ lại chỗ hoặc chuyển REFUND_PENDING.
  • Làm nó hiếm: hạn URL ngắn hơn hạn giữ chỗ (15 vs 20 phút), job hết hạn không nhả booking còn payment đang mở.
  • IPN là đường chính, job truy vấn giao dịch (querydr) là lưới; cả hai đổ vào cùng hàm apply idempotent.
  • Đối soát hằng ngày: FULL JOIN sao kê với payment, ra 5 loại; OURS_ONLY nghiêm trọng nhất.
  • Bẫy số 1: cắt ngày đối soát theo UTC trong khi sao kê theo giờ Việt Nam (+07).
  • CI không phụ thuộc sandbox: test tự ký IPN bằng khoá test, mỗi failure mode một kịch bản BDD.

Hình dung: IPN là thư báo của ngân hàng; job truy vấn là gọi điện hỏi khi thư chưa tới; đối soát là cuối ngày so sổ của mình với sao kê.

Tìm kiếm full-text, Elasticsearch

Elasticsearch: analyzer, inverted index, doc values và mapping cho tìm kiếm homestay
  • Inverted index (term → document) phục vụ tìm văn bản; doc values (document → giá trị, theo cột) phục vụ sort và aggregation; BKD tree phục vụ range số, ngày, geo.
  • text đi qua analyzer để tìm; keyword giữ nguyên để lọc, sort, aggregate. Cần cả hai thì dùng multi-field.
  • Tìm không dấu: lowercase + asciifolding, kèm một field con giữ dấu được boost cao hơn.
  • Mảng object phải là nested nếu lọc nhiều field trên cùng phần tử; object làm phẳng và khớp chéo.
  • ES là near real-time và là bản sao trễ của DB: đồng bộ qua outbox/CDC, _id = khoá chính, version_type=external.
  • Đổi mapping = index mới + reindex + đổi alias. Bẫy số 1: tin ES làm nguồn sự thật cho dữ liệu cần nhất quán như phòng trống hay tiền.

Hình dung: ES là mục lục cuối sách (inverted index) cộng một bảng tính theo cột (doc values), dựng lại từ cuốn sách gốc là PostgreSQL.

Tích hợp bên thứ ba, resilience

Tích hợp bên thứ ba: chọn nhà cung cấp, đồng bộ hay bất đồng bộ, webhook và lớp chống ăn mòn
  • Đánh giá theo thứ tự: bảo mật → độ tin cậy → hiệu năng → độ phức tạp (theo chi phí sửa sai).
  • Tác vụ lâu (thanh toán, eKYC): gọi đồng bộ để tạo, nhận kết quả bất đồng bộ qua webhook.
  • Webhook là đường chính, polling và job quét là lưới an toàn; cả hai đi qua cùng một hàm cập nhật idempotent.
  • Webhook: kiểm chữ ký trên body thô, kiểm timestamp, dedupe theo event id, lưu rồi trả 2xx nhanh.
  • Webhook tới trùng và sai thứ tự: state machine chỉ đi tiến (UPDATE có điều kiện).
  • Anti-corruption layer: mã trạng thái của nhà cung cấp chỉ sống trong adapter; mã lạ thành Unknown và báo động.
  • Bẫy số 1: tính HMAC trên JSON đã parse rồi serialize lại, chữ ký "thỉnh thoảng sai", rồi ai đó tắt kiểm tra.

Hình dung: nhà cung cấp là người nước ngoài; adapter là phiên dịch viên duy nhất của công ty, nên đổi đối tác chỉ cần đổi phiên dịch, không phải dạy lại cả công ty.

Timeout, retry, circuit breaker và bulkhead khi gọi bên thứ ba
  • Mọi lời gọi ra ngoài cần ba timeout: connect (1–2 giây), read (theo p99 của bên kia) và deadline tổng gồm cả retry.
  • Client HTTP mặc định của Java (HttpURLConnection, RestTemplate không cấu hình) chờ vô hạn.
  • Chỉ retry lỗi thoáng qua (timeout, 429, 502–504), và chỉ retry thao tác ghi khi có idempotency key.
  • Retry dùng exponential backoff có trần cộng jitter, để client không retry cùng lúc.
  • Bẫy số 1: retry ở nhiều tầng nhân tải (3 × 3 × 3 = 27). Chỉ retry ở một tầng.
  • Circuit breaker: lỗi vượt ngưỡng thì từ chối ngay (fail fast), sau đó thử lại vài lời gọi. Bulkhead: giới hạn số lời gọi đồng thời cho từng bên thứ ba.
  • Fallback chọn theo nghiệp vụ: thanh toán thì trả lỗi, tỉ giá thì dữ liệu cũ, SMS thì nhà cung cấp dự phòng.

Hình dung: cầu dao điện trong nhà. Một thiết bị chập thì cầu dao ngắt để cả nhà không cháy, và mỗi phòng có cầu dao riêng (bulkhead) nên một phòng chập không làm cả nhà mất điện.

Rate limitingLõi

Rate limiting: năm thuật toán, token bucket trên Redis và thiết kế bộ giới hạn phân tán
  • Fixed window đơn giản nhất nhưng cho lọt gấp đôi giới hạn ở ranh giới hai cửa sổ.
  • Sliding window counter ước lượng bằng trung bình có trọng số hai cửa sổ: chính xác hơn, vẫn chỉ 2 bộ đếm.
  • Leaky bucket xếp request vào hàng đợi và xả đều: đầu ra mượt nhưng request phải chờ.
  • Token bucket chỉ lưu "còn bao nhiêu token, cập nhật lúc nào": ít bộ nhớ, độ trễ thấp, cho phép burst có kiểm soát. Thường là lựa chọn mặc định.
  • Phân tán: một Lua script trên Redis để đọc-tính-ghi atomic; lấy token theo lô để bớt một round-trip mỗi request.
  • Bẫy số 1: không quyết định trước khi Redis chết thì làm gì (fail-open hay fail-closed).

Hình dung: token bucket như vé vào cổng: máy nhả vé đều đặn, hộp chứa tối đa N vé; khách có vé thì vào ngay, hết vé thì đứng ngoài.

Microservices, resilience patternLõi

Microservices: khi nào nên tách, tìm ranh giới service và tách dần từ monolith
  • Microservices mua khả năng deploy độc lập và đội tự chủ, trả bằng vận hành, test khó, độ trễ mạng và dữ liệu không nhất quán.
  • Thành phần chính: service, service discovery, API gateway, load balancer. Mở rộng: broker, log/metric, tracing, quản lý config/secret, service mesh. Kubernetes lo phần lớn phần chính.
  • Ranh giới: event storming → subdomain → bounded context; điểm khởi đầu tốt là một bounded context = một service.
  • Tách từ thô tới mịn; giữ những gì cần chung một transaction trong cùng service.
  • Tách service ngoại vi trước (ít rủi ro), hoặc tách service gốc mà nhiều thứ phụ thuộc; chạy song song module cũ và service mới sau API v1/v2.
  • Bẫy số 1: tách theo bảng hoặc theo tầng kỹ thuật, ra "distributed monolith": deploy riêng nhưng không đổi được gì một mình.

Hình dung: monolith như một căn nhà lớn, microservices như dãy nhà phố. Mỗi nhà tự sửa được, nhưng nếu xây tường ngang qua giữa phòng khách thì ngày nào cũng phải đi ra đường để sang phòng bên.

Spring Cloud cho microservices: Config, Eureka, LoadBalancer, Gateway và circuit breaker
flowchart LR
  C[Client] --> GW[Gateway: route, filter, retry]
  GW --> LB[LoadBalancer cache]
  LB -. lấy danh sách .-> EU[Eureka registry]
  LB --> O1[order :18091]
  LB --> O2[order :18092 đã chết?]
  O1 -. heartbeat 30s .-> EU
  CFG[Config Server + Git] -. cấu hình lúc khởi động .-> O1
  GW -. cấu hình .-> CFG
  • Spring Cloud là bộ dự án trên Spring Boot cho bài toán phân tán: Config (cấu hình tập trung), Eureka (discovery), LoadBalancer (chia tải phía client), Gateway (cửa vào), CircuitBreaker (chịu lỗi). Phiên bản theo "release train": 2025.1 đi với Boot 4.0.
  • Eureka là danh bạ, không chuyển request. Nó ưu tiên sẵn sàng hơn chính xác (AP): dữ liệu có thể cũ hàng chục giây.
  • Lab: instance bị kill -9, gateway tiếp tục gửi tới nó; trong 200 giây có 98/194 request lỗi, vì Eureka vào self-preservation và không xoá instance.
  • Thêm filter Retry=2 ở gateway: 40/40 request thành công dù instance chết vẫn nằm trong registry. Discovery luôn cần retry và timeout đi kèm.
  • Gateway chỉ làm việc chung (định tuyến, xác thực, rate limit), không chứa nghiệp vụ; bản WebFlux không được gọi code chặn.
  • Trên Kubernetes, DNS + Service + ConfigMap thường thay được Eureka và Config Server; Gateway và circuit breaker vẫn hữu ích.

Hình dung: Eureka là danh bạ điện thoại in lại mỗi 30 giây; LoadBalancer là người chọn số trong danh bạ; Gateway là tổng đài lễ tân. Danh bạ in có thể còn số của người đã nghỉ việc, nên người gọi phải biết gọi số khác khi không ai nhấc máy.

Giao tiếp: REST, gRPC, WebSocket, MQTT

Giao tiếp trong system design, phần 1: đường đi của một message, Protobuf, REST hay gRPC
  • Năm điều cân nhắc: delivery guarantee, tương thích khi đổi interface, hiệu năng, xử lý lỗi, bảo mật. Trong thực tế, đừng đặt hiệu năng lên đầu.
  • Một message đi qua: logic → serialization → protocol → mô hình xử lý (threading) → network I/O, và ngược lại ở phía nhận.
  • Reactor pattern tách việc chờ I/O (event loop) khỏi việc tính toán (worker pool). Nó không phải Actor model như slide ghi.
  • JSON dễ đọc, dễ tương thích; Protobuf nhỏ và nhanh nhưng cần schema. Luật vàng của Protobuf: không bao giờ đổi số thứ tự hay kiểu của field đã có.
  • REST cho API công khai và trình duyệt; gRPC cho service nội bộ cần nhanh, cần streaming, cần hợp đồng chặt.
  • Bẫy số 1: gRPC trên Kubernetes qua Service thường không cân bằng tải theo request, vì một connection HTTP/2 sống lâu bám vào một pod.

Hình dung: gửi một kiện hàng: đóng gói (serialization), chọn hãng vận chuyển (protocol), nhân viên kho (threading), xe chở (network I/O). Mỗi khâu chậm hay hỏng đều làm kiện hàng trễ, nhưng vì những lý do khác nhau.

Giao tiếp trong system design, phần 2: Kafka hay RabbitMQ, đẩy realtime và case study phát hiện gian lận
  • Kafka là nền tảng event streaming: throughput cao, giữ message để đọc lại, scale theo partition. RabbitMQ là message broker: định tuyến linh hoạt, TTL, delay, xoá message khi đã xử lý.
  • Kafka có exactly-once trong phạm vi Kafka (idempotent producer + transaction), chỗ slide bỏ sót.
  • Server đẩy xuống client: polling < long polling < SSE (một chiều) < WebSocket (hai chiều). Chọn cái đơn giản nhất đủ dùng.
  • Phát tới hàng triệu thiết bị: MQTT broker với topic và QoS; trình duyệt dùng MQTT qua WebSocket.
  • QUIC chạy trên UDP và tự gửi lại gói của nó, nên mất một gói chỉ chặn đúng một stream.
  • Bẫy số 1: WebSocket có trạng thái, nên scale nó là bài toán phân phối message giữa các node, không phải chỉ thêm máy.

Hình dung: Kafka là cuốn sổ nhật ký ai cũng đọc lại được từ trang bất kỳ; RabbitMQ là bưu điện phân thư đúng hộp rồi bỏ phong bì đi; WebSocket là cuộc gọi điện thoại luôn mở.

Case study system designLõi

Thiết kế URL shortener: sinh mã ngắn, Base62, token range và chuyển hướng
  • Luồng chính: long URL → một số nguyên duy nhất → Base62 → mã 7 ký tự. Bài toán khó nằm ở bước sinh số.
  • Ước lượng: 10M link mới/ngày ≈ 116 ghi/giây; đọc gấp 100 ≈ 12K/giây (đỉnh ~35K); 4 năm ≈ 14,6 tỷ link.
  • 62⁷ ≈ 3,5 nghìn tỷ mã: 7 ký tự dư cho 4 năm (thậm chí 6 ký tự cũng đủ).
  • Chọn token range: mỗi instance xin một khoảng số (ZooKeeper hoặc một dòng PostgreSQL), cấp trong RAM, không trùng và không cần hỏi ai mỗi lần ghi.
  • Số tuần tự thì đoán được: phải xáo bằng một phép hoán vị có khoá (Feistel) trước khi Base62.
  • 302 nếu cần analytics (mỗi click về server); 301 nếu ưu tiên tải và SEO (trình duyệt tự nhớ).
  • Bẫy số 1: tin rằng Snowflake "dễ trùng". Snowflake không trùng; vấn đề thật là dài 11 ký tự và đoán được theo thời gian.

Hình dung: token range giống mỗi quầy vé được phát sẵn một cuộn vé đánh số riêng: bán vé không cần gọi về trung tâm, chỉ khi hết cuộn mới xin cuộn mới.

Thiết kế news feed kiểu Threads: push, pull, hybrid và người nổi tiếng
  • Quy mô: 50M DAU, 50M bài/ngày (~580/giây), đọc feed ~6K/giây trung bình, đỉnh ~30K. Slide ghi "1 QPS bình thường, 5M QPS đỉnh" là sai.
  • Push (fan-out khi ghi): chép post id vào hộp thư (inbox) của từng follower. Đọc nhanh, ghi đắt, chết với celebrity 100 triệu follower.
  • Pull (fan-out khi đọc): lúc mở feed mới gom bài từ outbox của những người mình theo dõi. Ghi rẻ, đọc chậm và phức tạp.
  • Hybrid: push cho người thường, pull cho celebrity, trộn lúc đọc. Chỉ push cho user còn hoạt động.
  • Feed chỉ lưu id; nội dung, tác giả, bộ đếm được "hydrate" (điền vào) từ cache lúc đọc.
  • Bộ đếm like đi qua Kafka và được gộp theo lô trước khi ghi Redis, để một bài viral không làm nóng một dòng.
  • Bẫy số 1: thiết kế feed như một câu SQL JOIN follows với posts ORDER BY created_at. Ở quy mô này nó không bao giờ dưới 100 ms.

Hình dung: push là bưu tá bỏ thư vào từng hộp thư nhà bạn; pull là bạn tự đi tới từng toà soạn lấy báo. Hybrid: báo địa phương thì bỏ hộp thư, còn báo lớn ai cũng đọc thì đặt ở sạp đầu ngõ cho bạn ghé lấy.

Thiết kế hệ thống chat kiểu Discord: WebSocket gateway, lưu tin nhắn và fan-out cho server lớn
  • Gửi tin qua REST (có nonce để idempotent), nhận tin qua WebSocket gateway luôn mở. Hai đường tách biệt.
  • Quy mô giả định: 10M kết nối đồng thời lúc đỉnh, 3 tỷ tin/ngày ≈ 35K/giây (đỉnh ~100K), ~1 PB/năm kể cả replica.
  • Tin nhắn lưu ở ScyllaDB, partition (channel_id, bucket) với bucket là cửa sổ thời gian, clustering theo message_id giảm dần. Đọc lịch sử là đọc liền một partition.
  • message_id là Snowflake: vừa duy nhất vừa sắp theo thời gian, nên là thứ tự của kênh và là cursor phân trang.
  • Fan-out theo gateway node, không theo user: một tin cho 100K người online chỉ thành vài trăm thông điệp nội bộ, mỗi node tự giao cho các kết nối của mình.
  • Giao tin ít nhất một lần, client khử trùng theo message_id; mất kết nối thì resume hoặc tải bù bằng ?after=<id cuối>.
  • Bẫy số 1: partition tin nhắn chỉ theo channel_id. Kênh sôi động vài năm thành partition hàng GB, đọc chậm và không xoá dọn được.

Hình dung: gateway như tổng đài giữ máy của hàng triệu người; message service như bưu cục: nhận thư, đóng dấu số thứ tự, cất vào kho, rồi gửi một bản sang mỗi tổng đài đang có người cần nhận.

Thiết kế hệ thống thông báo: push, SMS, email, hàng đợi theo kênh, chống gửi trùng và giới hạn tần suất
flowchart LR
  S[Service gọi tới / scheduler chiến dịch] --> API[Notification API]
  API --> C[(Cache: user, device, tuỳ chọn, template)]
  API --> Q1[[Queue OTP ưu tiên cao]]
  API --> Q2[[Queue push / SMS / email]]
  Q1 --> W[Worker theo kênh]
  Q2 --> W
  W --> P[APNs / FCM / SMS / Email provider]
  W --> L[(Notification log)]
  W -.->|hết lượt retry| D[[Dead letter]]
  P -.->|webhook trạng thái| L
  • Notification service chỉ làm việc nhẹ: kiểm tra, chống trùng, đọc tuỳ chọn người dùng, dựng nội dung, rồi đẩy vào hàng đợi. Gửi thật do worker làm.
  • Mỗi kênh một hàng đợi (iOS, Android, SMS, email), tách thêm theo độ ưu tiên: OTP không được đứng sau 5 triệu email khuyến mãi.
  • Nhà cung cấp (APNs, FCM, nhà mạng SMS, SendGrid/SES) chậm hay chết chỉ làm kênh đó trễ, không kéo cả hệ thống.
  • At-least-once + idempotency key để không gửi trùng; retry có backoff và jitter cho lỗi 5xx/429, không retry lỗi 4xx; quá số lần thì vào dead letter.
  • Rate limit hai chiều: theo nhà cung cấp (quota của họ) và theo người dùng (không quá N tin khuyến mãi một ngày, giờ yên lặng).
  • Push không đảm bảo tới nơi; token hết hạn (APNs 410, FCM UNREGISTERED) phải xoá ngay.
  • Bẫy số 1: gọi thẳng nhà cung cấp trong request của service gọi tới. Nhà cung cấp chậm là cả luồng đặt hàng chậm theo.

Hình dung: như bưu điện: quầy nhận thư chỉ kiểm tra địa chỉ và dán tem rồi bỏ vào đúng túi (thư nhanh, bưu phẩm, thư quảng cáo); người đưa thư của từng tuyến đi phát theo nhịp của mình.

Case study: thiết kế hệ thống liveness cho 1 triệu thiết bị IoT gửi heartbeat
  • 1M thiết bị / 3 s = ~333K heartbeat/s. Không thể UPDATE last_seen vào PostgreSQL mỗi heartbeat (một node ~1K–20K ghi/s).
  • Trạng thái nhỏ: 1M × ~100 B ≈ 100 MB, vừa RAM. Bài toán là hẹn giờ cho 1M đối tượng, không phải lưu trữ.
  • Phương án tốt: Kafka partition theo device_id, mỗi worker giữ deadline của thiết bị thuộc partition mình trong bộ nhớ (timing wheel), hết hạn thì phát DeviceOffline.
  • Phương án đơn giản hơn: Redis ZSET với score = deadline, một checker quét ZRANGEBYSCORE mỗi giây.
  • Bẫy số 1: consumer bị trễ (lag) thì heartbeat vẫn nằm trong Kafka nhưng deadline đã hết, cả triệu thiết bị bị báo offline giả. Phải ngừng phát hiện khi lag cao.
  • Báo một lần cho mỗi lần chuyển trạng thái, gom báo động khi cả vùng mất mạng cùng lúc.

Hình dung: như người gác cổng có 1 triệu đồng hồ hẹn giờ: mỗi lần thiết bị "điểm danh" thì vặn lại đồng hồ của nó; đồng hồ nào reo là thiết bị đó mất tích. Cái khó là đừng để chính người gác ngủ gật rồi tưởng tất cả đều mất tích.

Hệ thống liveness: từ Redis sorted set đến timing wheel và LMAX Disruptor
  • Phân tích cấu trúc dữ liệu theo: use case, đọc một/đọc khoảng, ghi, bộ nhớ (cỡ, liền hay rải rác) và giới hạn. Đừng chỉ nhìn big-O, hãy nhìn cả I/O.
  • Bài liveness có hai thao tác nóng: reset timer mỗi heartbeat (333K lần/giây) và lấy timer hết hạn theo chu kỳ.
  • Redis ZSET (score = thời điểm hết hạn): ZADD O(log n), lấy hết hạn O(log n + m). Đơn giản, bền, nhưng mỗi heartbeat là một lượt mạng.
  • Timing wheel: mảng vòng các bucket, reset timer O(1), mỗi tick chỉ quét một bucket. Timer dài thì dùng nhiều bánh xe xếp tầng (Kafka).
  • Bucket lớn thì chia cho nhiều worker thread; hàng đợi giữa các thread dễ thành nút cổ chai (lock, tranh chấp head/tail, GC).
  • LMAX Disruptor: ring buffer cấp sẵn, CAS thay lock, consumer đọc theo lô. Trung bình 52 ns so với 32.757 ns của ArrayBlockingQueue.
  • Bẫy số 1: chọn cấu trúc "O(1)" nhưng quên rằng nó nằm trong RAM một máy, mất khi restart và không tự chia tải.

Hình dung: timing wheel giống mặt đồng hồ có 60 ngăn thư. Kim nhích một ngăn mỗi giây, bạn chỉ mở đúng ngăn kim đang chỉ, không phải lục cả tủ.

8. Kỹ năng senior

Kiến trúc codebase, DDD

Kiến trúc codebase: layered, hexagonal, onion, clean và functional core
  • Luồng gọi (lúc chạy) và hướng phụ thuộc (ai import ai) là hai thứ khác nhau; Dependency Inversion cho phép chúng ngược chiều.
  • Layered: tầng ngang, request đi từ trên xuống, nghiệp vụ phụ thuộc persistence.
  • Hexagonal, onion, clean là một ý: domain ở trong, hạ tầng ở ngoài, interface ở trong, cài đặt ở ngoài.
  • Dữ liệu qua ranh giới bằng DTO/command/result, không bằng entity JPA.
  • Functional core: luật nghiệp vụ là hàm thuần, I/O ở lớp vỏ; unit test không cần mock.
  • Trade-off: clean/hexagonal tốn interface và mapper, chỉ đáng khi nghiệp vụ nhiều, dự án sống lâu; CRUD nhỏ dùng layered gọn.
  • Bẫy số 1: "layered" nhưng entity JPA đi xuyên mọi tầng, nên không có cô lập thật.

Hình dung: domain là thiết bị điện, port là ổ cắm do chính thiết bị quy định, adapter là phích cắm của từng nhà cung cấp. Đổi nhà cung cấp là đổi phích, không mở thiết bị ra sửa.

DDD và cấu trúc package: bounded context, aggregate và khung codebase đặt vé máy bay
  • Chia package theo tính năng (bounded context) ở cấp cao nhất, tầng bên trong: thay đổi nằm gọn một chỗ, class nội bộ để package-private.
  • Bounded context: vùng mà mỗi từ có đúng một nghĩa, có model riêng. Hai context nói chuyện qua API công khai hoặc sự kiện, kèm anti-corruption layer.
  • Entity có ID và vòng đời; value object chỉ có giá trị, bất biến (Java record).
  • Aggregate = ranh giới nhất quán: đi qua root, một transaction sửa một aggregate, thiết kế nhỏ, tham chiếu aggregate khác bằng ID.
  • Application service điều phối, không chứa luật; luật ở aggregate và domain service. Interface repository ở domain.
  • Bẫy số 1: một model Booking dùng chung cho mọi bộ phận thành God class; aggregate quá to (Flight chứa mọi ghế) gây tranh chấp khoá.

Hình dung: mỗi bounded context là một phòng ban có từ điển riêng; họ trao đổi bằng phiếu yêu cầu (API, sự kiện), không ai vào lục tủ hồ sơ của phòng khác.

Khám phá domain trước khi thiết kế: Event Storming, Domain Storytelling và pivotal event
  • Đừng tin "yêu cầu đã đủ, khỏi cần hỏi". Tự đi qua quy trình với chuyên gia nghiệp vụ: vài ngày cho doanh nghiệp nhỏ, vài tuần cho doanh nghiệp lớn.
  • Hỏi theo thứ tự Why → What → How, câu hỏi mở; dùng 5 Whys để đào tới gốc.
  • Event Storming xoay quanh event nghiệp vụ ở thì quá khứ ("Lịch hẹn đã đặt"); bỏ event kỹ thuật ("Đã bấm nút").
  • Pivotal event (khó đảo ngược, đổi người thực hiện, mở ra quy trình con) là ứng viên ranh giới module.
  • Mức Process thêm actor, command, policy, read model: gần như ánh xạ thẳng sang API, luật nghiệp vụ, listener và query.
  • Domain Storytelling kể quy trình như câu chuyện "ai làm gì với cái gì"; dễ sót vùng mà người kể coi là hiển nhiên.

Hình dung: Event Storming là dán nhật ký sự việc lên tường theo thời gian; Domain Storytelling là nghe người trong nghề kể lại một ngày làm việc và vẽ ra.

Viết design doc, RFC

Tài liệu kiến trúc phần 1: arc42, C4 model, runtime/deployment view và docs-as-code
  • Chỉ viết khi (Cx − Cy) > Cmd: chi phí tiết kiệm được lớn hơn chi phí viết và duy trì. Áp cho từng mục, không cho cả tài liệu.
  • Ghi thứ bền và không suy ra được từ code: mục tiêu, ràng buộc, context, quyết định, quality requirement, rủi ro.
  • arc42 = 12 mục để khỏi quên, không bắt buộc điền đủ. Giá trị chính: mọi tài liệu cùng cấu trúc.
  • C4 = bốn mức zoom: Context, Container, Component, Code. "C4" là bốn chữ C, không phải "mức 4".
  • Runtime view: một sequence diagram mỗi use case, vẽ cả nhánh lỗi. Deployment view: ghi rõ staging khác prod ở đâu.
  • Bẫy số 1: tài liệu sai còn tệ hơn không có, vì người đọc tin nó. Chống bằng docs-as-code.

Hình dung: C4 giống Google Maps: zoom từ quốc gia (Context) xuống thành phố (Container) rồi đường phố (Component), mỗi tấm bản đồ chỉ ở một mức.

Tài liệu kiến trúc phần 2: ADR, quality requirement, sổ rủi ro và ví dụ address component
flowchart LR
  D[Quyết định] --> ADR["ADR (Accepted)"]
  ADR --- C["Context, Decision, Alternatives, Consequences"]
  ADR -->|đổi ý| N["ADR mới: Supersedes"]
  Q[Quality requirement] --> M["Đo được: tải, p99, lỗi"]
  M --> A[Cột Actual]
  A -->|trượt mục tiêu| R[Sổ rủi ro]
  R --> O["Owner + ngày xem lại"]
  • ADR = ghi chép ngắn cho một quyết định: Context, Decision, Alternatives, Consequences (tốt lẫn xấu), Status.
  • ADR đã Accepted thì không sửa; đổi ý thì viết ADR mới Supersedes ADR cũ.
  • Quality requirement phải đo được: loại và mức tải, thời gian, latency theo percentile, tỉ lệ lỗi, môi trường đo.
  • Cột Actual biến mong muốn thành kiểm tra; dòng trượt mục tiêu thành rủi ro.
  • Sổ rủi ro: mỗi dòng có người chịu trách nhiệm và ngày xem lại; "chấp nhận" phải ghi ai chấp nhận, vì sao.
  • Address schema: cột cấp hành chính chung, request_id UNIQUE cho retry, version cho optimistic locking.
  • Bẫy số 1: "1.500 TPS" không kèm điều kiện đo thì hệ thống nào cũng "đạt".

Hình dung: ADR là biên bản họp ghi cả lý do lẫn phương án bị bác; quality requirement là đề thi có barem chấm, không phải lời dặn "làm cho tốt".

Code review

Code review: mục tiêu, checklist, quy trình và cách viết comment
  • Hai mục tiêu: kiểm soát chất lượng (sản phẩm và codebase) và phát triển con người. Kèm theo: kiến thức lan ra, tăng bus factor.
  • Đọc theo thứ tự: mô tả PR → test → file thiết kế (interface, entity, migration) → chi tiết. Đừng chỉ đọc diff.
  • PR nhỏ được review kỹ. Google: ~100 dòng là hợp lý, 1.000 là quá lớn. Con số 400 dòng đến từ nghiên cứu SmartBear tại Cisco, không phải Google.
  • Mọi comment có nhãn: TODO chặn merge; NIT, OPTIONAL, FYI không chặn.
  • Comment về code, không về người; giải thích vì sao và đưa phương án.
  • Máy kiểm tra được gì thì để CI làm (format, lint, ArchUnit, secret); người review lo thiết kế và hành vi.
  • Bẫy số 1: comment không nhãn biến mọi góp ý khẩu vị thành điều kiện merge.

Hình dung: review giống biên tập viên đọc bản thảo: máy soát chính tả, còn người đọc để hỏi "câu chuyện có đúng và dễ hiểu không".

Code review: giải quyết bất đồng và hai buổi review mẫu trên code thật
flowchart TD
  A[Nghe và tóm lại] --> B[Viết ưu nhược]
  B --> C[Xác lập bối cảnh]
  C --> D["Đo / PoC"]
  D --> E["Đưa ra nhóm, leo thang"]
  E --> F["Disagree and commit + ADR"]
  R["2 vòng comment cùng điểm"] -->|nói trực tiếp 15 phút| G[Ghi kết luận vào MR]
  L["Little: thread = tốc độ × chờ"] --> TO["Timeout nghiệp vụ theo SLA"]
  TO --> FO{"Fail-open hay fail-closed?"}
  • Bất đồng: nghe và tóm lại ý bên kia → viết ưu nhược → xác lập bối cảnh → đo/PoC → đưa ra nhóm, leo thang → disagree and commit + ADR.
  • Quy tắc thực dụng: sau hai vòng comment cùng một điểm, nói chuyện trực tiếp 15 phút rồi ghi kết luận vào MR.
  • Định luật Little: thread bận = tốc độ request × thời gian chờ. 200 thread Tomcat, chờ 5 giây → chỉ 40 request/giây là hết.
  • Timeout nghiệp vụ phải riêng, đặt theo SLA; không mượn timeout của Redis hay hạ tầng.
  • Hết giờ thì fail-open hay fail-closed phải quyết có chủ ý; tiền thường fail-closed.
  • Comment TODO tốt luôn có hậu quả cụ thể và cách sửa.
  • Bẫy số 1 trong review mẫu: field không final với @RequiredArgsConstructor → không được inject, NPE ở request đầu tiên.

Hình dung: tranh luận trong review giống hai người chỉ đường cãi nhau: thay vì cãi tiếp, mở bản đồ (đo), hỏi người dẫn đoàn (leo thang), rồi cả đoàn đi chung một đường và ghi lại vì sao chọn.

Xử lý sự cố, postmortem

Xử lý sự cố production và viết postmortem
flowchart LR
  D[Phát hiện] --> T["Phân loại SEV"]
  T --> R["Gán vai trò: IC, comms, ops"]
  R --> M["Mitigate: rollback, flag off, scale, shed load"]
  M --> S["Khắc phục gốc"]
  S --> L["Postmortem blameless"]
  L --> A["Action item: owner + hạn"]
  A -.->|"chặn lặp lại"| D
  M -.-> C["Thông báo định kỳ"]
  • Vòng đời: phát hiện → phân loại (SEV) → giảm thiệt hại → khắc phục gốc → rút kinh nghiệm.
  • Bẫy số 1: đi tìm nguyên nhân gốc trong khi người dùng vẫn đang lỗi. Mitigate trước: rollback, tắt feature flag, scale, cắt bớt tải.
  • Ba vai trò tách bạch: incident commander điều phối (không tự debug), comms lo thông báo, ops làm kỹ thuật.
  • Debug theo thứ tự: cái gì vừa thay đổi → metric (ở đâu, từ lúc nào) → log (lỗi gì) → trace (chậm ở bước nào).
  • Mỗi mẫu sự cố có "chữ ký": pool cạn thì active = max và có người chờ; OOMKilled thì exit code 137; ổ đầy mà du không thấy thì có file đã xoá còn mở.
  • Postmortem blameless hỏi "hệ thống nào cho phép lỗi này", không hỏi "ai làm". Action item có owner, hạn, và ưu tiên loại bỏ/tự động chặn hơn "cẩn thận hơn".

Hình dung: đội cứu hoả: chỉ huy đứng ngoài nhìn toàn cảnh, một người báo tin, đội còn lại dập lửa; điều tra nguyên nhân cháy làm sau khi lửa tắt.

Ước lượng, chia việc

Ước lượng và chia việc: khoảng tin cậy, PERT, spike và cách thương lượng phạm vi
flowchart LR
  R[Yêu cầu] --> S[Chia vertical slice]
  S --> U{Còn điều chưa biết?}
  U -->|có| K[Spike có timebox]
  K --> S
  U -->|không| T["Three-point: O, M, P"]
  T --> E["Khoảng + độ tin cậy"]
  E --> C[Báo con số và rủi ro]
  C --> N{Vượt deadline?}
  N -->|có| P[Cắt scope]
  N -->|không| W[Làm và theo dõi]
  W -->|lệch| E
  • Ước lượng là dự báo có độ bất định, không phải lời hứa. Luôn báo khoảng kèm độ tin cậy: "6–9 ngày, 80% xong trước ngày 9".
  • Chia theo vertical slice (mỗi việc chạy được từ API tới DB), bắt đầu bằng walking skeleton; việc nào > 3 ngày thì chia tiếp.
  • Three-point/PERT: E = (O + 4M + P) / 6, độ lệch ≈ (P − O) / 6. Tổng nhiều việc: cộng E, độ lệch cộng theo căn bậc hai, nhưng chỉ đúng nếu các rủi ro độc lập.
  • Điều chưa biết thì không ước lượng, mà timebox một spike để biến nó thành điều đã biết.
  • Ngày công lý tưởng khác ngày lịch: nhân với focus factor, cộng thời gian chờ review, chờ bên thứ ba.
  • Bẫy số 1: mặc cả con số thay vì mặc cả phạm vi. Khi deadline cố định, cắt scope chứ không "cố gắng hơn".

Hình dung: ước lượng như dự báo thời tiết: "70% có mưa chiều mai" hữu ích hơn "mai mưa lúc 15", và bản tin được cập nhật mỗi ngày.

Làm việc với AI coding agent

Làm việc với AI coding agent cho backend: quy trình, project rules và cách kiểm chứng
flowchart LR
  RU["Project rules: AGENTS.md"] --> P[Prompt]
  P --> G[Generate]
  G --> U[Understand]
  U --> V[Verify]
  G -.->|bỏ hai bước sau| VC["Vibe coding: chỉ prototype"]
  V --> T[Test là trọng tài]
  V --> D[Đọc diff như reviewer]
  S["Tự làm: học, bảo mật, nghiệp vụ lõi"]
  • AI giỏi tạo code (boilerplate, CRUD, test khung); dở ở đảm bảo code đúng trong ngữ cảnh: nghiệp vụ, bảo mật, kiến trúc, lỗi xuyên module.
  • Quy trình: Prompt → Generate → Understand → Verify. Bỏ hai bước sau là vibe coding, chỉ hợp cho prototype.
  • Tự làm khi: đang học khái niệm mới, code bảo mật, logic nghiệp vụ lõi, luyện phỏng vấn, debug sự cố phức tạp.
  • Project rules (AGENTS.md, CLAUDE.md...) là bộ nhớ dài hạn của agent: stack, cấu trúc, quy ước, điều cấm, lệnh build/test.
  • Test là trọng tài: agent phải chạy được test, và bạn đọc diff như reviewer.
  • Bẫy số 1: tin "code chạy được, test xanh" mà không đọc test xem nó kiểm cái gì.

Hình dung: agent là một thợ xây rất nhanh nhưng mới vào công trường mỗi sáng: bạn đưa bản vẽ, quy định công trường, và tự nghiệm thu từng phần.

Mentoring

Mentoring cho senior engineer: onboarding, feedback SBI, giao việc và câu hỏi hành vi
flowchart LR
  N[Dev mới] --> O["Onboarding: PR đầu trong tuần 1"]
  O --> P[Pairing]
  P --> R[Review để dạy]
  R --> F[Feedback SBI]
  F --> D["Giao việc: bớt dần hướng dẫn"]
  D --> W[Tự sở hữu một mảng]
  W --> T["Chia sẻ lại: talk, tài liệu"]
  T -->|mentor người kế tiếp| N
  • Mentoring ở mức senior = nhân năng lực team (multiplier): đo bằng việc người khác tự làm được gì, không phải bạn giải được bao nhiêu ticket.
  • Onboarding tốt: môi trường chạy được ngày 1, PR đầu tiên lên production trong tuần 1, có buddy và kế hoạch 30-60-90.
  • Feedback theo SBI: Situation (lúc nào), Behavior (làm gì, quan sát được), Impact (ảnh hưởng ra sao), rồi hỏi và thống nhất bước tiếp.
  • Giao việc theo mức hướng dẫn: người mới cần bước cụ thể, người vững chỉ cần mục tiêu và ràng buộc. Giao vấn đề, không giao lời giải.
  • Review và pairing là kênh dạy chính: hỏi trước khi chỉ, giải thích vì sao, để junior cầm bàn phím.
  • Bẫy số 1: tự làm hộ vì "nhanh hơn". Nhanh hôm nay, nhưng bạn thành nút cổ chai mãi mãi.

Hình dung: mentor như người dạy bơi: đứng gần để đỡ khi cần, nhưng mục tiêu là ngày học viên tự bơi mà không cần bạn ở hồ.

Giải quyết vấn đề

Giải quyết vấn đề như senior: định nghĩa, causal diagram, 5 Whys và checklist
  • Vấn đề = khoảng cách giữa thực tế một stakeholder cảm nhận và thực tế họ kỳ vọng.
  • Ba cách đóng khoảng cách: đổi thực tế, đổi cảm nhận, điều chỉnh kỳ vọng. Cách 1 thường đắt nhất.
  • Quá tải: san demand, đổi perception thường rẻ hơn tăng capacity (giãn giờ chấm công rẻ hơn lắp thang).
  • Problem statement = một câu, có stakeholder, có con số ("p99 4 s lúc 9–10 giờ, mục tiêu < 800 ms").
  • 5 Whys dừng ở thứ sửa được ở mức hệ thống, không dừng ở "lỗi do người"; kết hợp causal diagram để không sót nhánh.
  • Review hệ phân tán: order, duplication, relationship, direction, consistency.
  • Bẫy số 1: câu đầu tiên trong cuộc họp là tên một công nghệ ("thêm Redis") thay vì vấn đề.

Hình dung: như bác sĩ: hỏi bệnh và chẩn đoán trước, kê thuốc sau; kê thuốc theo triệu chứng thì bệnh vẫn còn.

Phân tích và nói về trade-offLõi

Phân tích trade-off như senior: ideality, sweet spot, coupling và nguyên lý tách
flowchart TD
  A["Chốt top 3 chiều với stakeholder"] --> B["Liệt kê phương án"]
  B --> C["Chấm điểm bằng Ideality"]
  C --> D{"Xử lý thế nào?"}
  D -->|"Chọn điểm"| E["Sweet spot trên đường cong"]
  D -->|"Thiết kế lại"| F["Tách coupling"]
  F --> G["Đẩy đường cong về gốc"]
  E --> H["Nói rõ đổi gì lấy gì"]
  G --> H
  • Không có phương án "tốt nhất" chung chung: chốt với stakeholder top 3 chiều và thứ tự của chúng trước khi chấm điểm.
  • Dimensional trade-off là giữa các thuộc tính chất lượng; alternative trade-off là giữa các phương án cụ thể. Chọn công nghệ = chọn một điểm trên đường cong thuộc tính.
  • Ideality = Σ lợi ích / (Σ tài nguyên + Σ tác hại). Phương án gần như không tốn gì (thêm index, giãn giờ) thường thắng.
  • Hai cách xử lý: chọn sweet spot trên đường cong, hoặc thiết kế lại để đẩy cả đường cong về gốc.
  • Nhiều trade-off sinh ra từ coupling; tách theo thời gian, không gian, phần–toàn thể, điều kiện (sidecar, functional core, CQRS) làm nó nhỏ đi, nhưng tách cũng sinh trade-off mới.
  • Mặc định dùng boring technology; công nghệ mới mang tác hại chưa ai liệt kê được.
  • Bẫy số 1: nói "phương án này không có nhược điểm".

Hình dung: như mua xe: cả nhà chốt cần gì nhất (rẻ, rộng hay tiết kiệm xăng) rồi mới so mẫu xe.