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.
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?".
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.
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.
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).
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.
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.
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ổ.
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.
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.
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.
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.
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: 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é.
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".
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.
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.
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ự.
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ó.
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.
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: ghiT 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.
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ì.
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.
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.
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.
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.
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".
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).
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: 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: 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.
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.
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 đồ.
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.
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).
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.
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 @Patternkhô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ờ.
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 đó.
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: timestamptzkhô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.
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.
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.
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.
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.
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.
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.
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ứ 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ự.
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.
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.
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.
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.
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.
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.
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.
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.
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ử.
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.
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.
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é.
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.
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ý.
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.
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.
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ờ.
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.
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.
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.
@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.
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.
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.
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.
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).
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".
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.
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.
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: @Transactionalvẫ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.
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.
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ĩ.
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ồ.
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.
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).
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.
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.
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.
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.
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 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é.
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.
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.
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.
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.
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.
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ộ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.
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 = 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.
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".
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ờ.
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à.
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.
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.
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 đứ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.
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).
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.
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.
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.
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.
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ẫ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.
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 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.
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.
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.
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 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ó.
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.
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.
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.
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 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ũ".
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.
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ề.
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.
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.
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.
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.
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".
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.
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.
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ê.
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.
Đá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.
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.
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.
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.
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.
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ở.
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.
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.
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.
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.
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.
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.
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.
Đừ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.
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.
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.
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.
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.
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ồ.
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.