Syllabus học Java web

GIAI ĐOẠN 0 - Công cụ (Ngày 1-4)

Ngày 1: Git & GitHub

• Mục tiêu: Làm việc nhóm bằng Git một cách chuyên nghiệp, không sợ conflict.

• Lý thuyết: Git flow, branch, merge vs rebase, resolve conflict, pull request, code review convention.

• Thực hành: Tạo repo, làm việc với branch, giả lập 1 conflict và tự resolve, viết commit message chuẩn (Conventional Commits).

Ngày 2: Build tool - Maven & Gradle

• Mục tiêu: Hiểu bản chất build tool thay vì chỉ bấm nút "Run" trên IDE.

• Lý thuyết: Maven (pom.xml, dependency scope, plugin, multi-module, lifecycle compile→test→package); Gradle (build.gradle.kts, Groovy vs Kotlin DSL, implementation vs api, task graph, incremental build + build cache).

• Thực hành: (1) Convert project sang Maven chuẩn, thêm dependency, tạo profile dev/prod. (2) Convert cùng project sang Gradle Kotlin DSL, so sánh thời gian build lại khi sửa 1 file. (3) Thiết lập multi-module bằng cả 2 công cụ, nhận xét ưu/nhược trong team lớn.

Ngày 3: Code convention & Clean Code

• Mục tiêu: Viết code người khác đọc được mà không cần hỏi lại.

• Lý thuyết: Naming convention, Javadoc, SOLID sơ lược, code smell, refactor cơ bản (Extract Method, Rename).

• Thực hành: Refactor 1 đoạn code "spaghetti" cho sẵn theo Clean Code.

Ngày 4: IDE & Debug

• Mục tiêu: Debug bằng công cụ thay vì System.out.println.

• Lý thuyết: Breakpoint có điều kiện, watch, evaluate expression, hot reload, shortcut năng suất.

• Thực hành: Debug 1 chương trình có bug logic ẩn bằng breakpoint.

GIAI ĐOẠN 1 - Java Core (Ngày 5-14)

Ngày 5: Cú pháp cơ bản, kiểu dữ liệu, toán tử

• Mục tiêu: Nắm vững cú pháp nền tảng và hiểu đúng bản chất kiểu dữ liệu, không chỉ học thuộc cách viết.

• Lý thuyết: Kiểu dữ liệu nguyên thủy (int, long, double, boolean, char...) vs kiểu tham chiếu (wrapper class, String, object), phạm vi giá trị và ép kiểu (casting) tường minh/ngầm định, các toán tử (số học, so sánh, logic, bitwise, gán rút gọn) và độ ưu tiên; sau đó đi sâu vào pitfall thực tế: == vs .equals(), autoboxing pitfalls, integer cache (-128 → 127), overflow.

• Thực hành: Viết chương trình minh họa từng loại toán tử, sau đó viết test case chứng minh integer cache và autoboxing pitfall.

Ngày 6: Cấu trúc điều khiển

• Mục tiêu: Điều khiển luồng chương trình thành thạo và biết chọn đúng cấu trúc lặp/rẽ nhánh cho từng tình huống.

• Lý thuyết: if/else, switch (bao gồm switch biểu thức từ Java 14+), vòng lặp for/while/do-while, break/continue (kể cả dùng label), khi nào switch rõ ràng hơn chuỗi if-else.

• Thực hành: Viết chương trình phân loại điểm số bằng cả if-else và switch biểu thức, so sánh độ dễ đọc.

Ngày 7: Mảng

• Mục tiêu: Sử dụng mảng đúng cách và hiểu giới hạn của nó trước khi chuyển sang Collection.

• Lý thuyết: Khai báo/khởi tạo mảng 1 chiều và nhiều chiều, mảng là kiểu tham chiếu (truyền theo reference), các thao tác cơ bản với java.util.Arrays (sort, binarySearch, equals, Arrays.asList), giới hạn của mảng (kích thước cố định) - lý do vì sao Collection ra đời.

• Thực hành: Viết chương trình xử lý ma trận 2 chiều (mảng nhiều chiều), dùng Arrays.sort + binarySearch cho mảng 1 chiều.

Ngày 8: Chuỗi (String)

• Mục tiêu: Hiểu String không chỉ là "một kiểu dữ liệu bình thường".

• Lý thuyết: Các thao tác String cơ bản (substring, split, replace, trim, format), String pool, String immutability và lý do thiết kế, StringBuilder vs StringBuffer, độ phức tạp thời gian của thao tác chuỗi.

• Thực hành: Benchmark nối chuỗi bằng + vs StringBuilder với 100k phần tử, giải thích vì sao StringBuilder nhanh hơn dựa trên String pool.

Ngày 9: Lớp, đối tượng, constructor

• Mục tiêu: Nắm vững cú pháp OOP nền tảng và hiểu đúng thứ tự khởi tạo object trong JVM.

• Lý thuyết: Khai báo class, field, method, tạo object bằng new, các loại constructor (mặc định, có tham số, overload); sau đó đi sâu: thứ tự static block → instance block → constructor, constructor chaining, this()/super().

• Thực hành: Viết class có đủ 3 loại block, in log để chứng minh thứ tự chạy; viết constructor chaining cho 1 class có 3 constructor overload.

Ngày 10: Kế thừa, đa hình

• Mục tiêu: Nắm vững cú pháp kế thừa/đa hình và hiểu cơ chế bên dưới, không chỉ dừng ở "extends là kế thừa".

• Lý thuyết: Cú pháp extends, method overriding vs overloading, từ khóa super, upcasting/downcasting; sau đó đi sâu: cơ chế virtual method invocation (vtable) khiến overriding hoạt động runtime.

• Thực hành: Viết hệ thống Animal → Dog/Cat với override method, chứng minh polymorphism qua danh sách kiểu Animal chứa nhiều subtype.

Ngày 11: Abstract class & Interface

• Mục tiêu: Ra quyết định kiến trúc đúng giữa abstract class và interface, không chỉ theo cú pháp.

• Lý thuyết: Cú pháp abstract class vs interface, interface default/static method (Java 8+), diamond problem và cách Java giải quyết, tiêu chí chọn abstract class (chia sẻ state/code chung) vs interface (chỉ định nghĩa hợp đồng hành vi).

• Thực hành: Thiết kế 1 hệ thống hình học (Shape) minh họa đúng lúc dùng abstract class, đúng lúc dùng interface.

Ngày 12: Đóng gói, static, final

• Mục tiêu: Thiết kế immutable class đúng chuẩn, không chỉ khai báo final.

• Lý thuyết: Nguyên tắc đóng gói (encapsulation) - private field + getter/setter có kiểm soát, ý nghĩa static (thuộc class) vs instance member, final cho biến/method/class; sau đó đi sâu: static initialization order giữa các class, immutable class design đầy đủ (defensive copy, không expose mutable field).

• Thực hành: Viết 1 immutable class chứa field kiểu List/Date mà không bị leak reference.

Ngày 13: Exception Handling

• Mục tiêu: Xử lý lỗi đúng cách trong hệ thống production.

• Lý thuyết: Checked vs unchecked (tranh cãi thực tế), custom exception, exception chaining, try-with-resources, anti-pattern (nuốt exception, catch Exception chung chung).

• Thực hành: Viết custom exception hierarchy cho 1 domain nhỏ (VD: OrderService) với exception chaining.

Ngày 14: Enum

• Mục tiêu: Dùng enum như một công cụ thiết kế, không chỉ là hằng số.

• Lý thuyết: Enum với constructor/method riêng, EnumMap/EnumSet, Strategy pattern bằng enum.

• Thực hành: Implement Strategy pattern tính phí ship bằng enum thay vì if-else.

GIAI ĐOẠN 2 - OOP + SOLID + Design Patterns (Ngày 15-22)

Ngày 15: Nguyên tắc SOLID

• Mục tiêu: Nhận diện vi phạm SOLID trong code thật.

• Lý thuyết: SRP, OCP, LSP, ISP, DIP - ví dụ vi phạm và cách sửa.

• Thực hành: Review 1 class vi phạm ít nhất 3 nguyên tắc SOLID, đề xuất refactor.

Ngày 16: Creational Patterns

• Mục tiêu: Chọn đúng pattern khởi tạo object cho từng tình huống.

• Lý thuyết: Singleton (vì sao double-checked locking cần volatile), Factory Method, Builder (đặc biệt với DTO nhiều field).

• Thực hành: Viết Builder cho 1 DTO có 10+ field, một số optional.

Ngày 17: Structural Patterns

• Mục tiêu: Hiểu nền tảng để đọc hiểu Spring AOP về sau.

• Lý thuyết: Adapter, Decorator, Facade, Proxy.

• Thực hành: Viết Proxy pattern giả lập lazy-loading một service nặng.

Ngày 18: Behavioral Patterns (phần 1)

• Mục tiêu: Nắm 3 pattern xuất hiện nhiều nhất trong code Spring thực tế.

• Lý thuyết: Strategy, Observer, Template Method.

• Thực hành: Viết Observer pattern cho hệ thống gửi thông báo đa kênh (email/SMS).

Ngày 19: Behavioral Patterns (phần 2)

• Mục tiêu: Chuẩn bị tư duy hiểu Servlet Filter/Spring Interceptor.

• Lý thuyết: Command, Chain of Responsibility, State.

• Thực hành: Viết Chain of Responsibility mô phỏng pipeline validate request.

Ngày 20: Bài tập tổng hợp Design Pattern

• Mục tiêu: Áp dụng pattern để dọn code smell thật.

• Lý thuyết: Ôn lại Strategy + Factory kết hợp.

• Thực hành: Refactor 1 hệ thống có if-else lồng nhau thành Strategy + Factory.

Ngày 21: Anti-pattern & Code Smell

• Mục tiêu: Nhận diện code xấu trước khi nó lan rộng.

• Lý thuyết: God Object, Anemic Domain Model, Spaghetti Code.

• Thực hành: Chấm điểm code smell cho 1 codebase mẫu, viết checklist review.

Ngày 22: Domain-Driven Design nhập môn

• Mục tiêu: Chuẩn bị tư duy cho Hibernate/JPA và microservices sau này.

• Lý thuyết: Entity, Value Object, Aggregate, Repository pattern.

• Thực hành: Vẽ Aggregate boundary cho domain "Order" gồm Order, OrderItem, ShippingAddress.

GIAI ĐOẠN 3 - Collections, Generics, Functional Programming (Ngày 23-30)

Ngày 23: List

• Mục tiêu: Chọn đúng cấu trúc List theo tình huống, không mặc định ArrayList.

• Lý thuyết: ArrayList vs LinkedList - độ phức tạp thực từng thao tác.

• Thực hành: Benchmark insert đầu danh sách với 2 cấu trúc, 100k phần tử.

Ngày 24: Set/Map

• Mục tiêu: Hiểu cơ chế bên trong HashMap để tránh bug hash sai.

• Lý thuyết: Cơ chế hash (bucket, treeify từ Java 8), hashCode()/equals() contract, hậu quả override sai, ConcurrentModificationException và nguyên nhân gốc rễ.

• Thực hành: Viết class có equals()/hashCode() sai, chứng minh nó "biến mất" khỏi HashSet sau khi mutate.

Ngày 25: Queue/Deque/PriorityQueue

• Mục tiêu: Áp dụng đúng cấu trúc hàng đợi vào bài toán thực tế.

• Lý thuyết: Ứng dụng task scheduling, BFS.

• Thực hành: Implement task scheduler ưu tiên bằng PriorityQueue.

Ngày 26: Generics

• Mục tiêu: Viết generic code an toàn kiểu, hiểu giới hạn của type erasure.

• Lý thuyết: Bounded types, wildcard (PECS principle), type erasure và hệ quả.

• Thực hành: Viết 1 generic Repository interface áp dụng PECS đúng chuẩn.

Ngày 27: Comparable vs Comparator

• Mục tiêu: Sắp xếp đa tiêu chí thành thạo.

• Lý thuyết: Comparator.comparing().thenComparing().

• Thực hành: Sắp xếp danh sách nhân viên theo phòng ban → lương giảm dần → tên.

Ngày 28: Lambda & Functional Interfaces

• Mục tiêu: Viết code functional style gọn và đúng.

• Lý thuyết: Function, Supplier, Consumer, Predicate, BiFunction, method reference, closure và effectively final.

• Thực hành: Viết validation pipeline dùng Predicate kết hợp and()/or().

Ngày 29: Stream API

• Mục tiêu: Dùng Stream đúng cách, tránh pitfall parallel stream.

• Lý thuyết: Intermediate vs terminal operation, lazy evaluation, Collectors (groupingBy, partitioningBy, toMap), parallel stream - khi nào dùng và khi nào không.

• Thực hành: Group danh sách đơn hàng theo trạng thái + tính tổng tiền từng nhóm bằng Collectors.groupingBy.

Ngày 30: Optional

• Mục tiêu: Dùng Optional đúng ngữ nghĩa, tránh lạm dụng.

• Lý thuyết: Tránh Optional.get() bừa bãi, Optional trong return type vs field.

• Thực hành: Refactor 1 method trả null sang trả Optional đúng convention.

GIAI ĐOẠN 4 - Concurrency & Multithreading (Ngày 31-40)

Ngày 31: Thread cơ bản

• Mục tiêu: Hiểu vòng đời thread trước khi học các công cụ cao cấp.

• Lý thuyết: Tạo Thread bằng Thread/Runnable, thread lifecycle, join(), sleep(), daemon thread.

• Thực hành: Viết 2 thread in xen kẽ số chẵn/lẻ có đồng bộ.

Ngày 32: Race Condition & Critical Section

• Mục tiêu: Thấy tận mắt lỗi race condition trước khi học cách fix.

• Lý thuyết: Minh họa 2 thread cùng tăng 1 biến counter, synchronized (method vs block), intrinsic lock.

• Thực hành: Viết counter bị race condition, sau đó fix bằng synchronized.

Ngày 33: Java Memory Model (JMM)

• Mục tiêu: Hiểu vì sao thiếu volatile có thể khiến thread "không bao giờ" thấy giá trị mới.

• Lý thuyết: volatile keyword, happens-before relationship, visibility problem.

• Thực hành: Viết demo thread bị "kẹt" vô hạn do thiếu volatile, rồi fix.

Ngày 34: Deadlock, Livelock, Starvation

• Mục tiêu: Biết cách gây deadlock có chủ đích để hiểu cách phòng tránh.

• Lý thuyết: Cách gây deadlock, cách phát hiện (thread dump), phòng tránh (lock ordering).

• Thực hành: Viết 2 thread gây deadlock, dùng thread dump để chẩn đoán, rồi fix bằng lock ordering.

Ngày 35: java.util.concurrent.locks

• Mục tiêu: Dùng lock linh hoạt hơn synchronized.

• Lý thuyết: ReentrantLock, ReadWriteLock, so sánh với synchronized.

• Thực hành: Viết cache đơn giản dùng ReadWriteLock cho nhiều reader/1 writer.

Ngày 36: Atomic classes

• Mục tiêu: Hiểu vì sao CAS nhanh hơn lock trong nhiều tình huống.

• Lý thuyết: AtomicInteger, AtomicReference, Compare-And-Swap (CAS) và lý do hiệu năng cao.

• Thực hành: Viết lại counter ở Ngày 32 bằng AtomicInteger, benchmark so với synchronized.

Ngày 37: Executor Framework

• Mục tiêu: Quản lý thread pool đúng cách thay vì tự tạo Thread bừa bãi.

• Lý thuyết: ExecutorService, các loại thread pool, cách tính pool size hợp lý.

• Thực hành: Viết thread pool xử lý 1000 task, đo thời gian với các loại pool khác nhau.

Ngày 38: Future & CompletableFuture

• Mục tiêu: Compose async pipeline có xử lý lỗi đúng chuẩn.

• Lý thuyết: thenApply, thenCompose, thenCombine, xử lý exception trong async pipeline.

• Thực hành: Viết pipeline gọi 3 "API" giả lập song song rồi gộp kết quả bằng CompletableFuture.

Ngày 39: Concurrent Collections

• Mục tiêu: Chọn đúng collection an toàn cho môi trường đa luồng.

• Lý thuyết: ConcurrentHashMap (cơ chế segment lock), CopyOnWriteArrayList, BlockingQueue (Producer-Consumer).

• Thực hành: Viết Producer-Consumer bằng BlockingQueue.

Ngày 40: Bài tập tổng hợp Concurrency

• Mục tiêu: Tổng hợp toàn bộ kiến thức concurrency vào 1 bài toán thật.

• Lý thuyết: Ôn lại lock/atomic/executor.

• Thực hành: Xây hệ thống mô phỏng đặt vé (nhiều thread cùng đặt 1 chỗ), viết test chứng minh không còn race condition.

GIAI ĐOẠN 5 - JVM, Memory & Performance (Ngày 41-46)

Ngày 41: JVM Architecture

• Mục tiêu: Hiểu Java chạy như thế nào "dưới nắp capo".

• Lý thuyết: ClassLoader, Runtime Data Area (Heap, Stack, Method Area, PC Register), bytecode là gì.

• Thực hành: Dùng javap -c để đọc bytecode của 1 method đơn giản.

Ngày 42: Memory Management

• Mục tiêu: Hiểu object sống ở đâu trong bộ nhớ và di chuyển thế nào.

• Lý thuyết: Stack vs Heap, Young/Old Generation, cách object được promote.

• Thực hành: Vẽ sơ đồ vòng đời 1 object từ Eden → Survivor → Old Gen.

Ngày 43: Garbage Collection

• Mục tiêu: Chọn đúng GC theo đặc thù ứng dụng.

• Lý thuyết: Thuật toán GC (Serial, Parallel, G1, ZGC), cách chọn GC phù hợp, đọc GC log cơ bản.

• Thực hành: Chạy 1 chương trình cấp phát object liên tục với G1 và ZGC, so sánh GC log.

Ngày 44: Memory Leak trong Java

• Mục tiêu: Chẩn đoán memory leak bằng công cụ, không đoán mò.

• Lý thuyết: Nguyên nhân thường gặp (static collection giữ reference, listener không unregister, ThreadLocal không clear), dùng heap dump để phát hiện.

• Thực hành: Viết 1 chương trình leak memory có chủ đích, dùng heap dump tìm nguyên nhân.

Ngày 45: Profiling & Performance Tuning

• Mục tiêu: Tìm bottleneck bằng số liệu, không phải cảm giác.

• Lý thuyết: Dùng VisualVM/JFR đo CPU, memory, thread bottleneck.

• Thực hành: Profile 1 ứng dụng chậm, xác định function tốn CPU nhất.

Ngày 46: JIT Compiler

• Mục tiêu: Hiểu vì sao cần "warm up" trước khi benchmark.

• Lý thuyết: JIT Compiler cơ bản, tại sao code chạy nhanh hơn sau lần đầu.

• Thực hành: Benchmark 1 hàm trước và sau warm-up, so sánh kết quả.

GIAI ĐOẠN 5B - JVM (Ngày 47-51)

Ngày 47: Bytecode & Class Loading

• Mục tiêu: Hiểu class được nạp vào JVM theo cơ chế nào.

• Lý thuyết: Bootstrap/Platform/Application ClassLoader, delegation model, dùng javap/ASM để đọc và sinh bytecode.

• Thực hành: Viết 1 custom ClassLoader đơn giản load class từ file ngoài classpath.

Ngày 48: Metaspace

• Mục tiêu: Hiểu vì sao "PermGen leak" thời xưa vẫn có thể xảy ra dưới dạng khác ở Metaspace.

• Lý thuyết: Class metadata lưu ở đâu, class unloading xảy ra khi nào, nguyên nhân Metaspace OOM.

• Thực hành: Viết chương trình sinh class động (proxy/CGLIB) liên tục để tái hiện Metaspace tăng dần, quan sát qua JFR.

Ngày 49: JIT - C1/C2, Inlining, Escape Analysis

• Mục tiêu: Hiểu tại sao 1 số method "tự nhiên chạy nhanh hơn" theo thời gian.

• Lý thuyết: Tier compilation C1 vs C2, method inlining, Escape Analysis (stack allocation cho object không thoát scope).

• Thực hành: Viết method nhỏ gọi hàng triệu lần, quan sát compilation log (-XX:+PrintCompilation).

Ngày 50: Safepoint & Stop-The-World

• Mục tiêu: Hiểu vì sao ứng dụng đôi khi "đứng hình" dù không phải do GC.

• Lý thuyết: Safepoint là gì, các sự kiện gây Stop-The-World ngoài GC (biased locking revoke, deoptimization).

• Thực hành: Dùng -XX:+PrintSafepointStatistics phân tích 1 lần safepoint bất thường.

Ngày 51: Bài tập tổng hợp JVM

• Mục tiêu: Kết nối toàn bộ kiến thức JVM vào 1 case chẩn đoán thật.

• Lý thuyết: Ôn GC + Memory leak + JIT + Safepoint.

• Thực hành: Cho 1 ứng dụng "thỉnh thoảng bị đứng hình vài giây" - yêu cầu dùng JFR/GC log/safepoint log để xác định nguyên nhân gốc rễ.

GIAI ĐOẠN 6 - I/O, NIO cơ bản (Ngày 52-56)

Ngày 52: File I/O & Date/Time API

• Mục tiêu: Xử lý ngày giờ đúng chuẩn, tránh bug timezone.

• Lý thuyết: LocalDate, LocalDateTime, ZonedDateTime, Duration, Period.

• Thực hành: Viết hàm tính số ngày làm việc giữa 2 mốc thời gian ở 2 timezone khác nhau.

Ngày 53: Regular Expressions

• Mục tiêu: Validate dữ liệu bằng regex đúng và hiệu quả.

• Lý thuyết: Group, lookahead/lookbehind, ứng dụng validate dữ liệu thực tế.

• Thực hành: Viết regex validate email/số điện thoại/mật khẩu mạnh.

Ngày 54: NIO.2

• Mục tiêu: Hiểu khi nào NIO thắng I/O truyền thống.

• Lý thuyết: Path, Files, non-blocking I/O khái niệm, so sánh IO vs NIO.

• Thực hành: Viết chương trình đọc 1 file lớn bằng cả IO truyền thống và NIO, so sánh hiệu năng.

Ngày 55: Serialization

• Mục tiêu: Serialize dữ liệu an toàn, tránh lỗ hổng bảo mật kinh điển.

• Lý thuyết: Serializable, transient, rủi ro bảo mật khi deserialize dữ liệu không tin cậy, JSON serialization với Jackson (@JsonIgnore, custom serializer, xử lý vòng lặp entity).

• Thực hành: Xử lý lỗi vòng lặp vô hạn khi serialize entity có quan hệ 2 chiều bằng Jackson.

Ngày 56: Socket Programming cơ bản

• Mục tiêu: Hiểu bản chất giao tiếp mạng trước khi trừu tượng hóa qua Spring.

• Lý thuyết: TCP client-server đơn giản.

• Thực hành: Viết 1 TCP echo server/client bằng Java Socket thuần.

GIAI ĐOẠN 6B - Backend Networking (Ngày 57-61)

Ngày 57: DNS

• Mục tiêu: Hiểu vì sao "domain không resolve được" đôi khi không phải lỗi code.

• Lý thuyết: Recursive resolver, authoritative DNS, TTL, DNS cache, vì sao đổi DNS record cần thời gian propagate.

• Thực hành: Dùng dig/nslookup trace toàn bộ chuỗi resolve của 1 domain thật.

Ngày 58: TCP

• Mục tiêu: Đọc hiểu trạng thái kết nối khi debug production.

• Lý thuyết: 3-way handshake, 4-way close, trạng thái TIME_WAIT, keepalive, vì sao nhiều TIME_WAIT có thể làm cạn port.

• Thực hành: Dùng netstat/ss quan sát trạng thái kết nối của 1 server Java đang chạy dưới tải.

Ngày 59: TLS

• Mục tiêu: Hiểu handshake TLS để debug lỗi SSL đúng tầng.

• Lý thuyết: Certificate, CA, TLS handshake, mTLS là gì và khi nào cần.

• Thực hành: Tự tạo self-signed certificate, cấu hình HTTPS cho 1 Spring Boot app.

Ngày 60: HTTP/1.1, HTTP/2, HTTP/3

• Mục tiêu: Biết lý do nâng cấp giao thức HTTP qua từng thế hệ.

• Lý thuyết: Head-of-line blocking ở HTTP/1.1, multiplexing ở HTTP/2, HTTP/3 chạy trên QUIC (UDP) giải quyết gì.

• Thực hành: So sánh thời gian tải 1 trang có nhiều asset nhỏ qua HTTP/1.1 vs HTTP/2.

Ngày 61: Load Balancer & Reverse Proxy

• Mục tiêu: Hiểu tầng đứng trước ứng dụng của bạn trong production.

• Lý thuyết: L4 vs L7 load balancing, thuật toán cân bằng tải (round-robin, least-connection), Nginx làm reverse proxy.

• Thực hành: Cấu hình Nginx làm reverse proxy + load balancer cho 2 instance Spring Boot.

GIAI ĐOẠN 7 - Testing (Ngày 62-67)

Ngày 62: Testing Pyramid & triết lý test

• Mục tiêu: Xây chiến lược test hợp lý, không chạy theo % coverage.

• Lý thuyết: Unit vs integration vs e2e, test coverage là công cụ chứ không phải mục tiêu.

• Thực hành: Vẽ testing pyramid cho 1 hệ thống cụ thể, phân bổ tỉ lệ test hợp lý.

Ngày 63: JUnit 5

• Mục tiêu: Viết unit test rõ ràng, dễ maintain.

• Lý thuyết: @ParameterizedTest, @Nested, @BeforeEach, assertion với AssertJ.

• Thực hành: Viết bộ test có tổ chức bằng @Nested cho 1 service nhiều nhánh logic.

Ngày 64: Mockito

• Mục tiêu: Mock đúng mức, không over-mock làm test vô nghĩa.

• Lý thuyết: mock() vs spy(), when-thenReturn, verify(), ArgumentCaptor, tránh over-mocking.

• Thực hành: Viết unit test cho 1 service phụ thuộc 2 repository, dùng ArgumentCaptor kiểm tra tham số truyền vào.

Ngày 65: Test-Driven Development (TDD)

• Mục tiêu: Trải nghiệm quy trình Red-Green-Refactor thật sự.

• Lý thuyết: Chu trình Red-Green-Refactor.

• Thực hành: Viết 1 tính năng nhỏ hoàn toàn bằng TDD.

Ngày 66: Integration Testing với Spring Boot Test

• Mục tiêu: Test gần với môi trường thật hơn unit test.

• Lý thuyết: @SpringBootTest, @DataJpaTest, @WebMvcTest, Testcontainers (test với DB thật trong Docker thay vì H2 giả lập).

• Thực hành: Viết integration test cho 1 Repository dùng Testcontainers với Postgres thật.

Ngày 67: Contract Testing & Mutation Testing

• Mục tiêu: Đánh giá chất lượng test, không chỉ số lượng.

• Lý thuyết: Contract Testing khái niệm, Mutation Testing khái niệm, code review checklist cho test chất lượng.

• Thực hành: Chạy mutation testing (PIT) trên 1 module, xem test nào "vô dụng" (không bắt được mutant).

GIAI ĐOẠN 8 - JDBC, Transaction, Connection Pool (Ngày 68-73)

Ngày 68: JDBC

• Mục tiêu: Hiểu tầng thấp nhất trước khi dùng ORM.

• Lý thuyết: PreparedStatement, CallableStatement, phòng chống SQL Injection.

• Thực hành: Viết CRUD thuần bằng JDBC, không dùng framework.

Ngày 69: Transaction & Isolation Level

• Mục tiêu: Chọn đúng isolation level theo yêu cầu nghiệp vụ.

• Lý thuyết: ACID chi tiết, 4 mức Isolation Level và minh họa từng loại anomaly (dirty read, non-repeatable read, phantom read).

• Thực hành: Tái hiện dirty read và phantom read bằng 2 transaction chạy song song trên Postgres.

Ngày 70: Connection Pool

• Mục tiêu: Cấu hình connection pool đúng cho production, không dùng default mù quáng.

• Lý thuyết: Tại sao cần pool, cấu hình HikariCP (max pool size, connection timeout, idle timeout, connection leak detection), connection drain khi rolling deploy, ảnh hưởng của bảng dữ liệu lớn tới index/partitioning.

• Thực hành: Cấu hình HikariCP, viết test giả lập connection leak, dùng leak detection để phát hiện.

Ngày 71: Spring @Transactional

• Mục tiêu: Tránh bug @Transactional phổ biến nhất trong thực tế.

• Lý thuyết: Propagation (REQUIRED, REQUIRES_NEW, NESTED...), pitfall self-invocation, rollback rule.

• Thực hành: Tái hiện bug self-invocation (gọi method @Transactional từ trong cùng class không hoạt động), rồi fix bằng cách tách bean.

Ngày 72: Database Migration

• Mục tiêu: Quản lý schema version như quản lý code.

• Lý thuyết: Flyway/Liquibase - quản lý schema versioning.

• Thực hành: Viết 3 migration script tuần tự bằng Flyway, thử rollback.

Ngày 73: Bài tập tổng hợp JDBC/Transaction

• Mục tiêu: Kết hợp connection pool + transaction + migration vào 1 module thật.

• Lý thuyết: Ôn lại toàn bộ giai đoạn.

• Thực hành: Xây module thanh toán đơn giản đảm bảo transaction đúng propagation, có migration versioning.

GIAI ĐOẠN 8B - Database (Ngày 74-79)

Ngày 74: Storage Engine - InnoDB Page & Extent

• Mục tiêu: Hiểu dữ liệu được lưu vật lý như thế nào trên đĩa.

• Lý thuyết: Page, Extent, cấu trúc B+Tree, Clustered Index vs Secondary Index.

• Thực hành: Dùng EXPLAIN so sánh query dùng clustered index vs secondary index trên cùng 1 bảng lớn.

Ngày 75: MVCC

• Mục tiêu: Hiểu vì sao đọc dữ liệu trong transaction không bị block bởi ghi.

• Lý thuyết: Undo log, read view, snapshot isolation.

• Thực hành: Tái hiện 1 kịch bản MVCC - transaction A đọc dữ liệu trong khi B đang update cùng dòng, quan sát kết quả A thấy.

Ngày 76: Lock ở tầng row

• Mục tiêu: Debug được deadlock ở tầng database, không chỉ tầng code.

• Lý thuyết: Row lock, gap lock, next-key lock.

• Thực hành: Tái hiện gap lock gây deadlock giữa 2 transaction insert cùng khoảng giá trị.

Ngày 77: WAL

• Mục tiêu: Hiểu cơ chế đảm bảo durability của database.

• Lý thuyết: Redo log, binlog, checkpoint.

• Thực hành: Đọc binlog của 1 giao dịch UPDATE để hiểu dữ liệu được ghi lại thế nào.

Ngày 78: Query Optimizer

• Mục tiêu: Đọc execution plan để tối ưu query thật, không đoán mò.

• Lý thuyết: EXPLAIN, ANALYZE, cách optimizer chọn index.

• Thực hành: Tối ưu 1 query chậm bằng cách đọc execution plan và thêm index phù hợp.

Ngày 79: Bài tập tổng hợp Database

• Mục tiêu: Chẩn đoán 1 vấn đề hiệu năng database thật từ đầu đến cuối.

• Lý thuyết: Ôn lại Storage Engine + MVCC + Lock + Optimizer.

• Thực hành: Cho 1 bảng giao dịch hàng triệu dòng chạy chậm, yêu cầu dùng EXPLAIN + index + partitioning để tối ưu.

GIAI ĐOẠN 9 - Hibernate/JPA (Ngày 80-87)

Ngày 80-81: ORM & Hibernate cơ bản

• Mục tiêu: Hiểu ORM giải quyết vấn đề gì và đánh đổi gì.

• Lý thuyết: ORM là gì, Hibernate cơ bản, CRUD, entity lifecycle.

• Thực hành: Viết CRUD hoàn chỉnh bằng Hibernate thuần (không qua Spring Data).

Ngày 82: HQL, Criteria API, Specification API

• Mục tiêu: Viết query động chuẩn Spring Data JPA.

• Lý thuyết: HQL, Criteria API, Specification API.

• Thực hành: Viết bộ lọc sản phẩm động (nhiều điều kiện optional) bằng Specification API.

Ngày 83: Associations & N+1 query

• Mục tiêu: Phát hiện và fix N+1 - bug hiệu năng phổ biến nhất của JPA.

• Lý thuyết: One-to-Many, Many-to-Many, nguyên nhân N+1, cách phát hiện bằng SQL log, cách fix bằng JOIN FETCH/@EntityGraph.

• Thực hành: Tái hiện N+1 trên 1 API load danh sách Order kèm OrderItem, đo số query trước/sau khi fix.

Ngày 84: Lazy vs Eager Loading

• Mục tiêu: Fix LazyInitializationException đúng gốc rễ, không patch tạm.

• Lý thuyết: Nguyên nhân gốc rễ và các cách fix đúng.

• Thực hành: Tái hiện lỗi khi truy cập lazy collection ngoài transaction, fix bằng DTO projection thay vì OpenSessionInView.

Ngày 85: Entity State & Dirty Checking

• Mục tiêu: Hiểu Hibernate tự động phát hiện thay đổi thế nào.

• Lý thuyết: Cơ chế dirty checking, merge() vs persist(), vấn đề entity bị detached ngoài transaction.

• Thực hành: Chứng minh dirty checking hoạt động - update entity mà không gọi save() tường minh.

Ngày 86: Caching & Locking

• Mục tiêu: Xử lý concurrent update đúng cách trên cùng 1 row.

• Lý thuyết: First-level/Second-level Cache, Query Cache, Optimistic vs Pessimistic Locking (@Version).

• Thực hành: Tái hiện lost update khi 2 request cùng sửa 1 record, fix bằng @Version.

Ngày 87: Bài tập tổng hợp Hibernate/JPA

• Mục tiêu: Chẩn đoán và fix 1 API chậm do lỗi JPA thật.

• Lý thuyết: Ôn lại N+1 + lazy loading + locking.

• Thực hành: Cho 1 API bị chậm do N+1 + lazy loading sai cách, yêu cầu profile và fix.

GIAI ĐOẠN 10 - Spring Core & AOP (Ngày 88-92)

Ngày 88: IoC/DI

• Mục tiêu: Hiểu vòng đời bean để debug lỗi khởi tạo Spring.

• Lý thuyết: Bean lifecycle đầy đủ (@PostConstruct, @PreDestroy, BeanPostProcessor), Bean scope (singleton, prototype, request, session) và hệ quả với mutable state.

• Thực hành: Viết 1 bean scope prototype bên trong bean singleton, chứng minh vấn đề và cách fix bằng ObjectFactory.

Ngày 89: Constructor Injection vs Field Injection

• Mục tiêu: Hiểu vì sao Constructor Injection là best practice.

• Lý thuyết: Testability, immutability, phát hiện circular dependency sớm.

• Thực hành: Tái hiện circular dependency, quan sát Field Injection "che giấu" lỗi này còn Constructor Injection thì không.

Ngày 90: Spring Configuration

• Mục tiêu: Cấu hình ứng dụng linh hoạt theo môi trường.

• Lý thuyết: Java Config vs XML vs annotation, @Profile, @ConditionalOnProperty, Externalized Configuration (application.yml, @ConfigurationProperties).

• Thực hành: Cấu hình 2 profile dev/prod với @ConfigurationProperties type-safe.

Ngày 91: Spring AOP

• Mục tiêu: Hiểu cơ chế proxy đứng sau @Transactional/@Cacheable.

• Lý thuyết: Proxy-based AOP (JDK dynamic proxy vs CGLIB), pitfall self-invocation trong AOP (liên hệ trực tiếp bug @Transactional ở Ngày 71).

• Thực hành: Viết 1 aspect log thời gian chạy method, quan sát nó không hoạt động khi self-invocation.

Ngày 92: Custom Annotation + AOP

• Mục tiêu: Tự viết công cụ AOP áp dụng thực tế.

• Lý thuyết: Kết hợp custom annotation với AOP.

• Thực hành: Viết annotation @LogExecutionTime áp dụng cho bất kỳ method nào.

GIAI ĐOẠN 11 - Spring MVC & REST API (Ngày 93-101)

Ngày 93-94: Spring MVC cơ bản

• Mục tiêu: Nắm luồng xử lý request trong Spring MVC.

• Lý thuyết: Controller, DispatcherServlet, Thymeleaf.

• Thực hành: Viết 1 ứng dụng CRUD render bằng Thymeleaf.

Ngày 95: Thiết kế REST API chuẩn

• Mục tiêu: Thiết kế API mà team khác đọc là hiểu ngay.

• Lý thuyết: Resource naming, HTTP status code đúng ngữ nghĩa, versioning strategy (URL vs Header).

• Thực hành: Thiết kế lại 1 bộ API "xấu" (verb trong URL, status code sai) theo chuẩn REST.

Ngày 96: Validation

• Mục tiêu: Validate input đúng chuẩn, trả lỗi rõ ràng cho client.

• Lý thuyết: Bean Validation (@Valid, custom validator), xử lý lỗi validate trả về response chuẩn.

• Thực hành: Viết custom validator kiểm tra business rule (VD: ngày bắt đầu phải trước ngày kết thúc).

Ngày 97: Global Exception Handling

• Mục tiêu: Thống nhất format lỗi toàn hệ thống.

• Lý thuyết: @ControllerAdvice/@ExceptionHandler, thiết kế error response format thống nhất.

• Thực hành: Viết GlobalExceptionHandler xử lý ít nhất 4 loại exception khác nhau về cùng 1 format response.

Ngày 98: API Documentation

• Mục tiêu: Tự động sinh docs thay vì viết tay dễ lỗi thời.

• Lý thuyết: OpenAPI/Swagger tự động sinh docs từ code.

• Thực hành: Tích hợp Swagger UI cho bộ API đã xây, thêm mô tả và ví dụ request/response.

Ngày 99: DTO Pattern & Mapping

• Mục tiêu: Tách biệt Entity và dữ liệu trả ra ngoài API.

• Lý thuyết: Tại sao không expose Entity trực tiếp ra API, MapStruct để mapping tự động.

• Thực hành: Dùng MapStruct map Entity → DTO cho 1 module có quan hệ lồng nhau.

Ngày 100: API Design

• Mục tiêu: Nắm trọn bộ nguyên tắc thiết kế API cho hệ thống chịu tải cao, thay vì học rải rác.

• Lý thuyết: Idempotency key, Pagination (offset vs cursor-based), Versioning strategy, Rate limiting, ETag/Optimistic Concurrency Control qua HTTP header.

• Thực hành: Thiết kế 1 API tạo đơn hàng có idempotency key + pagination cursor-based cho API danh sách.

Ngày 101: GraphQL như lựa chọn thay thế REST

• Mục tiêu: Biết khi nào GraphQL phù hợp hơn REST.

• Lý thuyết: Schema, Query/Mutation, vấn đề over-fetching/under-fetching mà GraphQL giải quyết, đánh đổi (caching khó hơn, N+1 ở tầng resolver).

• Thực hành: Viết 1 GraphQL endpoint đơn giản song song với REST endpoint đã có, so sánh trải nghiệm client.

GIAI ĐOẠN 12 - Spring Data JPA (Ngày 102-105)

Ngày 102: Repository & custom query method

• Mục tiêu: Tận dụng Spring Data JPA đúng mức, biết khi nào cần viết query tay.

• Lý thuyết: Repository, custom query method, derived query.

• Thực hành: Viết 5 custom query method với các mức độ phức tạp tăng dần.

Ngày 103: Pagination, Sorting, Projection

• Mục tiêu: Trả dữ liệu hiệu quả cho API danh sách lớn.

• Lý thuyết: Pageable, Page<T>, Projection (chỉ lấy field cần thiết, tối ưu query).

• Thực hành: Viết API phân trang có projection, so sánh query SQL sinh ra trước/sau khi dùng projection.

Ngày 104: Auditing & Soft Delete

• Mục tiêu: Tự động hóa audit trail và xóa mềm.

• Lý thuyết: @CreatedDate, @LastModifiedBy, Soft Delete pattern.

• Thực hành: Thêm auditing tự động và soft delete cho 1 entity, viết filter loại bỏ record đã xóa mềm khỏi query mặc định.

Ngày 105: Multi-tenancy & Transaction across repository

• Mục tiêu: Hiểu vấn đề khi nhiều repository tham gia cùng 1 transaction.

• Lý thuyết: Multi-tenancy khái niệm, xử lý transaction across multiple repository.

• Thực hành: Viết 1 service dùng 2 repository trong cùng transaction, kiểm chứng rollback đồng bộ khi có lỗi.

GIAI ĐOẠN 13 - Spring Security (Ngày 106-111)

Ngày 106: Security Filter Chain

• Mục tiêu: Hiểu request đi qua các filter bảo mật như thế nào, không chỉ config theo mẫu.

• Lý thuyết: Cơ chế hoạt động thật sự của Security Filter Chain, Authentication vs Authorization.

• Thực hành: Vẽ sơ đồ 1 request đi qua Filter Chain của ứng dụng đang xây.

Ngày 107: Password encoding & Form login

• Mục tiêu: Lưu trữ mật khẩu an toàn đúng chuẩn ngành.

• Lý thuyết: Password encoding (BCrypt), UserDetailsService, form login.

• Thực hành: Implement đăng ký/đăng nhập với BCrypt.

Ngày 108: JWT

• Mục tiêu: Thiết kế cơ chế xác thực stateless an toàn.

• Lý thuyết: Cấu trúc token, access token vs refresh token, cách lưu trữ an toàn ở client (pitfall XSS nếu lưu localStorage).

• Thực hành: Implement luồng access token + refresh token hoàn chỉnh.

Ngày 109: Method-level Security

• Mục tiêu: Phân quyền chi tiết đến từng method.

• Lý thuyết: @PreAuthorize, @PostAuthorize, phân quyền theo role/permission.

• Thực hành: Thiết kế hệ thống phân quyền role + permission cho module quản trị.

Ngày 110: OAuth2/OpenID Connect

• Mục tiêu: Tích hợp đăng nhập bên thứ ba đúng chuẩn.

• Lý thuyết: Authorization Code Flow, tích hợp Google/Facebook login thực tế.

• Thực hành: Tích hợp Google Login vào ứng dụng đã xây.

Ngày 111: Security best practices

• Mục tiêu: Vá các lỗ hổng bảo mật phổ biến nhất trước khi lên production.

• Lý thuyết: CORS đúng cách, CSRF, rate limiting cơ bản, OWASP Top 10 áp dụng trực tiếp vào code Spring.

• Thực hành: Rà soát 1 API theo checklist OWASP Top 10, vá ít nhất 3 lỗ hổng tìm được.

GIAI ĐOẠN 14 - Caching phân tán: Redis/Valkey (Ngày 112-116)

Ngày 112: Redis cơ bản & Redis vs Valkey

• Mục tiêu: Chọn đúng công cụ cache và hiểu bối cảnh license hiện tại.

• Lý thuyết: Data structure của Redis, cache-aside pattern; Redis vs Valkey - sau khi Redis đổi license (2024), Linux Foundation fork ra Valkey, nhiều cloud provider (AWS, GCP) đã migrate; API tương thích nên không ảnh hưởng code.

• Thực hành: Cài Redis và Valkey local, chạy cùng 1 đoạn code client, xác nhận tương thích.

Ngày 113: Spring Cache Abstraction

• Mục tiêu: Tích hợp cache vào Spring bằng annotation thay vì code tay.

• Lý thuyết: @Cacheable, @CacheEvict, @CachePut.

• Thực hành: Thêm cache cho API lấy chi tiết sản phẩm, đo số lần hit DB trước/sau.

Ngày 114: 3 vấn đề kinh điển của hệ thống cache

• Mục tiêu: Phòng tránh 3 sự cố cache phổ biến nhất trong production.

• Lý thuyết: Cache Penetration (query key không tồn tại → luôn miss → đánh thẳng DB; fix: cache null có TTL ngắn, Bloom filter); Cache Avalanche (hàng loạt key hết hạn cùng lúc; fix: TTL + random jitter, warm-up); Cache Stampede (nhiều request cùng miss 1 key nóng; fix: mutex lock khi rebuild, request coalescing).

• Thực hành: Viết demo tái hiện Cache Stampede với 100 request đồng thời, fix bằng mutex lock.

Ngày 115: Redis ACL & bảo mật

• Mục tiêu: Vận hành cache an toàn trong môi trường nhiều team dùng chung.

• Lý thuyết: Cấu hình user/permission thay vì dùng chung 1 password, network isolation.

• Thực hành: Cấu hình 2 Redis user với quyền khác nhau (1 chỉ đọc, 1 đọc-ghi).

Ngày 116: Session Store & Distributed Lock

• Mục tiêu: Giải quyết race condition ở tầng nhiều instance.

• Lý thuyết: Redis cho Session Store, Distributed Lock với Redisson.

• Thực hành: Viết distributed lock bằng Redisson cho thao tác trừ tồn kho chạy trên 2 instance app.

GIAI ĐOẠN 15 - Message Queue & Streaming (Ngày 117-125)

Ngày 117: Vì sao cần message queue

• Mục tiêu: Hiểu bài toán decoupling trước khi học công cụ cụ thể.

• Lý thuyết: Decoupling, async processing, so sánh Kafka vs RabbitMQ.

• Thực hành: Vẽ sơ đồ trước/sau khi thêm message queue cho 1 luồng nghiệp vụ.

Ngày 118: RabbitMQ cơ bản

• Mục tiêu: Nắm mô hình Exchange/Queue/Binding.

• Lý thuyết: Exchange, Queue, Binding, tích hợp Spring AMQP.

• Thực hành: Viết producer/consumer đơn giản bằng Spring AMQP.

Ngày 119: Kafka cơ bản

• Mục tiêu: Nắm mô hình Topic/Partition/Consumer Group.

• Lý thuyết: Topic, Partition, Producer/Consumer, Consumer Group.

• Thực hành: Viết producer/consumer Kafka, thử scale consumer group để thấy phân chia partition.

Ngày 120: Xử lý message thất bại

• Mục tiêu: Đảm bảo hệ thống không mất và không xử lý trùng message.

• Lý thuyết: Retry, Dead Letter Queue, idempotency (tránh xử lý trùng message).

• Thực hành: Viết consumer có retry + DLQ khi xử lý message lỗi liên tục.

Ngày 121: Database làm Queue

• Mục tiêu: Biết khi nào không cần Kafka/RabbitMQ mà DB là đủ.

• Lý thuyết: Dùng Postgres/MySQL xây job queue, không cần thêm hạ tầng.

• Thực hành: Implement job queue bằng bảng Postgres với SELECT ... FOR UPDATE SKIP LOCKED.

Ngày 122: Diskless Kafka

• Mục tiêu: Cập nhật xu hướng kiến trúc Kafka-compatible hiện đại.

• Lý thuyết: Các hệ Kafka-compatible lưu log trực tiếp trên object storage (S3) thay vì đĩa cục bộ (AutoMQ, WarpStream, Redpanda Cloud); lợi ích giảm chi phí lưu trữ/cross-AZ traffic, autoscale nhanh vì broker gần như stateless; đánh đổi latency ghi cao hơn, hệ sinh thái vận hành chưa trưởng thành.

• Thực hành: Đọc kiến trúc 1 hệ diskless Kafka (VD: WarpStream), so sánh với Kafka truyền thống về chi phí ước tính.

Ngày 123: Real-time OLAP làm sink cho pipeline streaming

• Mục tiêu: Hiểu đúng vị trí OLAP trong kiến trúc streaming, không nhầm lẫn nó thay thế queue.

• Lý thuyết: Kiến trúc chuẩn App → Kafka → StarRocks/ClickHouse (Routine Load/Kafka Connector) → dashboard; queue vẫn đảm bảo delivery/ordering, OLAP làm tốt việc aggregate/join khối lượng lớn dữ liệu lịch sử.

• Thực hành: Cấu hình ClickHouse/StarRocks ingest liên tục từ 1 Kafka topic, dựng dashboard truy vấn real-time đơn giản.

Ngày 124: Bài tập - luồng đặt hàng bất đồng bộ

• Mục tiêu: Áp dụng message queue vào 1 luồng nghiệp vụ thật.

• Lý thuyết: Ôn lại producer/consumer + idempotency.

• Thực hành: Xây luồng "đặt hàng → gửi email xác nhận" bất đồng bộ qua message queue.

Ngày 125: Bài tập tổng hợp - Kafka vs Postgres SKIP LOCKED

• Mục tiêu: Tự rút ra tiêu chí chọn công nghệ dựa trên số liệu, không dựa cảm tính.

• Lý thuyết: Ôn lại toàn bộ giai đoạn.

• Thực hành: Implement lại luồng job queue nội bộ (VD: resize ảnh) bằng cả Kafka và Postgres SKIP LOCKED, đo throughput/độ phức tạp vận hành, rút ra khi nào chọn cách nào.

GIAI ĐOẠN 16 - Reactive Programming: Spring WebFlux (Ngày 126-130)

Ngày 126: Reactive Programming là gì

• Mục tiêu: Biết khi nào reactive thực sự có lợi.

• Lý thuyết: Reactive Streams spec, khi nào nên/không nên dùng (I/O-bound vs CPU-bound).

• Thực hành: Liệt kê 3 tình huống nên dùng reactive và 3 tình huống không nên, giải thích lý do.

Ngày 127: Project Reactor

• Mục tiêu: Thao tác thành thạo với Mono/Flux.

• Lý thuyết: Mono, Flux, operator cơ bản (map, flatMap, zip...).

• Thực hành: Viết pipeline xử lý dữ liệu bằng Reactor operator, không dùng blocking call.

Ngày 128: WebFlux Controller

• Mục tiêu: So sánh trực tiếp WebFlux với Spring MVC.

• Lý thuyết: WebFlux Controller, so sánh với Spring MVC truyền thống (thread-per-request vs event-loop).

• Thực hành: Viết lại 1 API MVC đã có sang WebFlux, benchmark dưới tải cao với nhiều I/O chậm.

Ngày 129: R2DBC

• Mục tiêu: Truy vấn database theo hướng reactive thật sự (không blocking JDBC ẩn bên trong).

• Lý thuyết: R2DBC driver, khác biệt với JPA/JDBC.

• Thực hành: Viết Repository R2DBC cho 1 entity đơn giản.

Ngày 130: Backpressure & Error handling

• Mục tiêu: Xử lý luồng dữ liệu lớn mà không làm sập consumer.

• Lý thuyết: Backpressure, error handling trong reactive pipeline.

• Thực hành: Viết Flux phát dữ liệu nhanh hơn tốc độ consumer xử lý, áp dụng chiến lược backpressure phù hợp.

GIAI ĐOẠN 17 - Microservices (Ngày 131-140)

Ngày 131: Kiến trúc Microservices & DDD

• Mục tiêu: Chia service theo ranh giới nghiệp vụ đúng, không chia theo cảm tính.

• Lý thuyết: Kiến trúc Microservices, áp dụng DDD để chia service (Bounded Context).

• Thực hành: Vẽ Bounded Context cho hệ thống E-commerce đã xây ở các giai đoạn trước.

Ngày 132: Service Discovery

• Mục tiêu: Các service tìm nhau động, không hardcode địa chỉ.

• Lý thuyết: Service Discovery với Eureka/Consul.

• Thực hành: Đăng ký 2 service vào Eureka, gọi nhau qua tên service thay vì IP cứng.

Ngày 133: API Gateway

• Mục tiêu: Có 1 cửa ngõ duy nhất cho toàn hệ thống microservices.

• Lý thuyết: API Gateway (Spring Cloud Gateway thay Zuul đã deprecated).

• Thực hành: Cấu hình Gateway route request tới đúng service, thêm rate limiting ở tầng gateway.

Ngày 134: Config Server

• Mục tiêu: Quản lý config tập trung, không sửa file trên từng service.

• Lý thuyết: Config Server quản lý config tập trung cho nhiều service.

• Thực hành: Tách config ra Config Server, thử đổi config runtime bằng /actuator/refresh.

Ngày 135: Circuit Breaker

• Mục tiêu: Ngăn 1 service lỗi kéo sập cả hệ thống.

• Lý thuyết: Resilience4j (thay Hystrix đã deprecated) - retry, fallback, bulkhead.

• Thực hành: Cấu hình circuit breaker cho 1 lời gọi service phụ thuộc, giả lập service đó down và quan sát fallback.

Ngày 136: Distributed Transaction - Saga & Outbox

• Mục tiêu: Đảm bảo tính nhất quán dữ liệu across service mà không cần 2PC.

• Lý thuyết: Saga Pattern (Choreography vs Orchestration - ưu tiên Orchestration khi cần audit trail rõ ràng, VD hệ thống ví điện tử), Outbox Pattern đảm bảo publish event không mất khi transaction fail.

• Thực hành: Implement Outbox Pattern cho luồng tạo đơn hàng + publish event.

Ngày 137: Two-Phase Commit (2PC)

• Mục tiêu: Hiểu trade-off để giải thích được vì sao ngành đã bỏ 2PC.

• Lý thuyết: Cơ chế coordinator + participant, vì sao 2PC gần như không dùng trong microservices hiện đại (blocking, coordinator là single point of failure, khóa tài nguyên xuyên service gây nghẽn).

• Thực hành: Viết so sánh bảng trade-off 2PC vs Saga cho 1 tình huống cụ thể (VD: chuyển tiền liên ngân hàng).

Ngày 138: Idempotent API Design

• Mục tiêu: Chống nhân đôi dữ liệu khi client retry.

• Lý thuyết: Idempotency key (client sinh UUID, server dedupe trong khoảng thời gian nhất định), bắt buộc cho API tạo giao dịch/thanh toán.

• Thực hành: Thêm idempotency key cho API tạo giao dịch, test bằng cách gửi trùng request nhiều lần.

Ngày 139: Inter-service Communication - REST vs gRPC

• Mục tiêu: Chọn đúng giao thức giao tiếp giữa các service.

• Lý thuyết: REST vs gRPC - khi nào dùng loại nào (latency, contract-first, streaming).

• Thực hành: Viết 1 lời gọi giữa 2 service bằng gRPC, so sánh payload size/latency với REST.

Ngày 140: Bài tập - tách monolith thành microservices

• Mục tiêu: Thực hành tách hệ thống thật, không chỉ lý thuyết.

• Lý thuyết: Ôn lại toàn bộ giai đoạn.

• Thực hành: Chia dự án monolith (Giai đoạn 22) thành 2-3 microservice giao tiếp qua REST + message queue.

GIAI ĐOẠN 17B - Distributed Systems (Ngày 141-146)

Ngày 141: Consensus - Raft/Paxos

• Mục tiêu: Hiểu cách các node đạt đồng thuận khi không có "nguồn chân lý" trung tâm.

• Lý thuyết: Vấn đề consensus trong hệ phân tán, ý tưởng cốt lõi của Raft (leader election, log replication) so với Paxos.

• Thực hành: Đọc log của 1 cluster etcd (dùng Raft), quan sát quá trình bầu leader khi kill node leader.

Ngày 142: Leader Election

• Mục tiêu: Hiểu cơ chế bầu leader dùng trong hạ tầng thực tế.

• Lý thuyết: ZooKeeper, etcd dùng để bầu leader và lưu trạng thái cluster như thế nào.

• Thực hành: Dùng etcd/ZooKeeper implement leader election đơn giản cho 3 instance của cùng 1 service.

Ngày 143: Replication

• Mục tiêu: Hiểu đánh đổi giữa các chiến lược replicate dữ liệu.

• Lý thuyết: Sync vs async replication, quorum read/write.

• Thực hành: Cấu hình Postgres streaming replication (1 primary, 1 replica), đo độ trễ dữ liệu khi replicate async.

Ngày 144: Consistency Models

• Mục tiêu: Chọn đúng mức consistency theo yêu cầu nghiệp vụ.

• Lý thuyết: Linearizable, causal, eventual consistency - ví dụ thực tế từng loại.

• Thực hành: Phân loại 5 tình huống nghiệp vụ (VD: số dư ví, like Facebook, đơn hàng) theo mức consistency phù hợp.

Ngày 145: Distributed Lock

• Mục tiêu: Hiểu rủi ro thật của distributed lock, không chỉ biết cách dùng.

• Lý thuyết: Distributed lock bằng Redis (Redlock và tranh cãi xung quanh nó) vs ZooKeeper/etcd (dựa trên consensus, an toàn hơn).

• Thực hành: So sánh 1 kịch bản lock bị mất do GC pause dài - dùng Redis lock vs etcd lock, phân tích rủi ro.

Ngày 146: Failure Mode - Split Brain & Network Partition

• Mục tiêu: Thiết kế hệ thống chịu được lỗi mạng thật, không chỉ lỗi "server chết".

• Lý thuyết: Split brain là gì, network partition ảnh hưởng đến CAP theorem trong thực tế thế nào.

• Thực hành: Giả lập network partition giữa 2 node trong 1 cluster (dùng iptables/tc), quan sát hệ thống phản ứng thế nào.

GIAI ĐOẠN 17C - Architecture Patterns (Ngày 147-151)

Ngày 147: Hexagonal Architecture (Ports & Adapters)

• Mục tiêu: Tách business logic khỏi framework/infrastructure.

• Lý thuyết: Port, Adapter, vì sao domain layer không nên phụ thuộc trực tiếp vào Spring/JPA.

• Thực hành: Refactor 1 service đang phụ thuộc trực tiếp JPA Repository sang Hexagonal Architecture (domain gọi qua interface/port).

Ngày 148: Clean Architecture

• Mục tiêu: Hiểu nguyên tắc dependency rule để thiết kế layer đúng hướng.

• Lý thuyết: Entity/Use Case/Interface Adapter/Framework layer, dependency rule (phụ thuộc chỉ hướng vào trong).

• Thực hành: Vẽ sơ đồ layer Clean Architecture cho module đã refactor ở Ngày 147.

Ngày 149: CQRS

• Mục tiêu: Tách biệt luồng đọc và ghi khi chúng có yêu cầu khác nhau.

• Lý thuyết: Command Query Responsibility Segregation, khi nào cần tách read model riêng khỏi write model.

• Thực hành: Tách read model (dùng projection/view tối ưu cho query) khỏi write model cho 1 module Order.

Ngày 150: Event Sourcing

• Mục tiêu: Hiểu mô hình lưu trạng thái bằng chuỗi sự kiện thay vì snapshot.

• Lý thuyết: Lưu chuỗi event thay vì trạng thái hiện tại, tái tạo state bằng cách replay event, đánh đổi (phức tạp, cần snapshot định kỳ).

• Thực hành: Implement Event Sourcing đơn giản cho 1 tài khoản ví (nạp tiền/rút tiền là các event), tái tạo số dư bằng replay.

Ngày 151: Modular Monolith

• Mục tiêu: Biết khi nào KHÔNG cần microservices.

• Lý thuyết: Modular Monolith - giữ 1 deployable unit nhưng phân module rõ ràng bằng package/module boundary, con đường trung gian giữa monolith rối và microservices quá sớm.

• Thực hành: Tổ chức lại 1 project monolith hiện có thành các module rõ ràng (package-by-feature + kiểm soát dependency giữa module bằng ArchUnit).

GIAI ĐOẠN 18 - Observability (Ngày 152-155)

Ngày 152: Structured Logging

• Mục tiêu: Log để debug được trong hệ phân tán, không chỉ để "có log".

• Lý thuyết: SLF4J + Logback, log level đúng ngữ cảnh, correlation ID để trace request qua nhiều service.

• Thực hành: Thêm correlation ID xuyên suốt 1 request đi qua 2 service, log có thể trace theo ID đó.

Ngày 153: Metrics

• Mục tiêu: Đo hiệu năng hệ thống bằng số liệu định lượng.

• Lý thuyết: Micrometer + Prometheus, đo latency/throughput/error rate.

• Thực hành: Expose metrics của 1 API qua Micrometer, scrape bằng Prometheus.

Ngày 154: Distributed Tracing

• Mục tiêu: Trace 1 request đi qua nhiều microservice để tìm điểm chậm.

• Lý thuyết: Zipkin/Jaeger.

• Thực hành: Trace 1 request đi qua 3 service, xác định service nào gây chậm nhất.

Ngày 155: Dashboard & Alert

• Mục tiêu: Biết hệ thống có vấn đề trước khi user báo lỗi.

• Lý thuyết: Dashboard với Grafana, thiết lập alert cơ bản.

• Thực hành: Dựng dashboard Grafana hiển thị latency/error rate, cấu hình alert khi error rate vượt ngưỡng.

GIAI ĐOẠN 19 - Frontend (Ngày 156-158)

Ngày 156: SPA tiêu thụ API

• Mục tiêu: Hiểu góc nhìn frontend để thiết kế backend thân thiện hơn.

• Lý thuyết: SPA (React/Angular) gọi REST như thế nào, quản lý state cơ bản, vì sao cần CORS và cấu hình đúng ở backend.

• Thực hành: Cấu hình CORS đúng cho 1 API, test gọi từ SPA chạy ở port khác.

Ngày 157: Luồng xác thực phía client

• Mục tiêu: Lưu trữ token an toàn ở phía client.

• Lý thuyết: Lưu JWT ở đâu an toàn (httpOnly cookie vs localStorage - pitfall XSS), refresh token flow, OAuth2 Authorization Code + PKCE nhìn từ phía client.

• Thực hành: Implement lưu JWT bằng httpOnly cookie, xử lý refresh token tự động khi access token hết hạn.

Ngày 158: Thực hành nối SPA với API

• Mục tiêu: Hoàn thiện luồng end-to-end frontend-backend.

• Lý thuyết: Ôn lại CORS + auth flow.

• Thực hành: Nối 1 SPA đơn giản với API đã xây ở các giai đoạn trước, xử lý lỗi 401/403 chuẩn.

GIAI ĐOẠN 20 - Docker, Kubernetes cơ bản (Ngày 159-168)

Ngày 159: Docker multi-stage build

• Mục tiêu: Build image Java nhỏ gọn, nhanh cho production.

• Lý thuyết: Multi-stage build (giảm size image Java), layer caching để build nhanh.

• Thực hành: Viết Dockerfile multi-stage cho 1 Spring Boot app, so sánh size image trước/sau.

Ngày 160: Docker Compose

• Mục tiêu: Chạy cả stack local chỉ với 1 lệnh.

• Lý thuyết: Docker Compose - chạy app + DB + Redis + Kafka cùng lúc.

• Thực hành: Viết docker-compose.yml cho toàn bộ stack của dự án E-commerce.

Ngày 161: Kubernetes nền tảng

• Mục tiêu: Nắm các khối xây dựng cơ bản của K8s.

• Lý thuyết: Pod, Deployment, Service, ConfigMap, Secret, Ingress.

• Thực hành: Deploy 1 Spring Boot app lên Minikube với Deployment + Service + ConfigMap.

Ngày 162: Health check với Spring Boot Actuator

• Mục tiêu: Tránh pod bị restart vòng lặp do health check cấu hình sai.

• Lý thuyết: Liveness vs readiness probe, vì sao thiết lập sai khiến pod bị restart liên tục.

• Thực hành: Cấu hình liveness/readiness probe đúng cho app đã deploy, giả lập app "chưa sẵn sàng" lúc khởi động để kiểm chứng readiness probe hoạt động.

Ngày 163: Tối ưu JVM chạy trong container

• Mục tiêu: Tránh OOMKilled do JVM không nhận đúng resource limit của container.

• Lý thuyết: cgroups là gì, JVM đọc resource limit container thế nào, -XX:MaxRAMPercentage thay vì -Xmx cứng, nguyên nhân/cách chẩn đoán OOMKilled (phân biệt với OutOfMemoryError), CPU throttling khi set CPU limit quá chặt so với số thread pool.

• Thực hành: Set memory limit thấp cho container, tái hiện OOMKilled, fix bằng -XX:MaxRAMPercentage phù hợp.

Ngày 164: GraalVM & Spring Boot Native Image

• Mục tiêu: Đánh giá đúng lợi ích/đánh đổi của Native Image.

• Lý thuyết: AOT compilation là gì, build native image bằng Spring Boot 3 (built-in từ 3.0, không còn là project rời "Spring Native"), lợi ích (startup mili-giây, ít RAM - quan trọng với serverless/Lambda) và đánh đổi (build lâu hơn, hạn chế reflection, một số thư viện chưa hỗ trợ tốt).

• Thực hành: Build native image cho 1 app đơn giản, so sánh thời gian khởi động và RAM dùng so với JVM thường.

Ngày 165: Build image

• Mục tiêu: Giảm bề mặt tấn công của image production.

• Lý thuyết: Jib/Cloud Native Buildpacks tạo distroless image (không cần viết Dockerfile tay), quét lỗ hổng bảo mật (Trivy/Snyk) trong CI/CD trước khi push registry.

• Thực hành: Build image bằng Jib, chạy Trivy scan trong pipeline, chặn build nếu có lỗ hổng mức Critical.

Ngày 166: Helm cơ bản

• Mục tiêu: Quản lý manifest K8s phức tạp qua nhiều môi trường.

• Lý thuyết: Helm chart, values file theo môi trường.

• Thực hành: Đóng gói app thành Helm chart, deploy với values khác nhau cho dev/staging.

Ngày 167: CI/CD

• Mục tiêu: Tự động hóa toàn bộ pipeline từ commit đến production.

• Lý thuyết: Pipeline thực tế với GitHub Actions/GitLab CI - build, test, scan bảo mật, deploy tự động qua các môi trường.

• Thực hành: Viết pipeline GitHub Actions build → test → scan → deploy tự động lên môi trường dev.

Ngày 168: Blue-Green & Rolling Update

• Mục tiêu: Deploy production không downtime và rollback an toàn.

• Lý thuyết: Blue-Green Deployment & Rolling Update, chiến lược rollback khi phát hiện lỗi sau deploy.

• Thực hành: Cấu hình Rolling Update trên K8s, giả lập deploy lỗi và thực hiện rollback.

GIAI ĐOẠN 20B - Cloud Native (Ngày 169-174)

Ngày 169: Secrets Management với Vault

• Mục tiêu: Không bao giờ để secret nằm trần trong ConfigMap/repo.

• Lý thuyết: Vấn đề của K8s Secret mặc định (chỉ base64, không mã hóa thật), HashiCorp Vault quản lý secret tập trung, dynamic secret.

• Thực hành: Cài Vault, lấy secret database động cho 1 Spring Boot app thay vì hardcode trong application.yml.

Ngày 170: External Secrets Operator

• Mục tiêu: Đồng bộ secret từ nguồn bên ngoài vào K8s tự động.

• Lý thuyết: External Secrets Operator đồng bộ secret từ Vault/AWS Secrets Manager vào K8s Secret tự động, tránh secret sprawl.

• Thực hành: Cấu hình External Secrets Operator đồng bộ 1 secret từ Vault vào cluster Minikube.

Ngày 171: HPA & KEDA

• Mục tiêu: Autoscale theo tải thực tế, không chỉ theo CPU.

• Lý thuyết: Horizontal Pod Autoscaler theo CPU/memory, KEDA autoscale theo custom metric (VD: độ dài Kafka queue).

• Thực hành: Cấu hình KEDA scale consumer theo số lượng message tồn trong Kafka topic.

Ngày 172: Cluster Autoscaler

• Mục tiêu: Hiểu autoscale ở tầng node, không chỉ tầng pod.

• Lý thuyết: Cluster Autoscaler thêm/bớt node theo nhu cầu pod đang chờ được schedule.

• Thực hành: Đọc log Cluster Autoscaler trong 1 kịch bản demo (hoặc cloud sandbox) khi pod pending do thiếu node.

Ngày 173: Service Account & OIDC

• Mục tiêu: Cấp quyền cho workload đúng nguyên tắc least privilege.

• Lý thuyết: Kubernetes Service Account, liên kết với IAM Role qua OIDC (thay vì gắn credential tĩnh vào pod).

• Thực hành: Cấu hình 1 pod dùng Service Account liên kết OIDC để truy cập tài nguyên cloud (VD: S3) mà không cần access key hardcode.

Ngày 174: FinOps cơ bản

• Mục tiêu: Đọc được chi phí hạ tầng và tối ưu nó, không chỉ tối ưu hiệu năng.

• Lý thuyết: Cấu trúc chi phí K8s (compute, network egress, storage), cost allocation theo namespace/label, right-sizing request/limit.

• Thực hành: Phân tích chi phí giả lập của 1 cluster theo namespace, đề xuất 3 thay đổi giảm chi phí (VD: giảm over-provision request).

GIAI ĐOẠN 21 - System Design & Best Practices (Ngày 175-179)

Ngày 175: Scalability cơ bản

• Mục tiêu: Thiết kế service scale được ngay từ đầu.

• Lý thuyết: Vertical vs horizontal scaling, stateless service design.

• Thực hành: Refactor 1 service đang lưu state trong bộ nhớ (session local) thành stateless.

Ngày 176: Load Balancing, CDN, Replication/Sharding

• Mục tiêu: Nắm các kỹ thuật mở rộng hệ thống ở tầng hạ tầng.

• Lý thuyết: Load Balancing, CDN, Database Replication/Sharding khái niệm.

• Thực hành: Thiết kế chiến lược sharding cho bảng Order theo customer_id, phân tích ưu/nhược.

Ngày 177: CAP Theorem & Consistency models

• Mục tiêu: Áp dụng CAP vào quyết định thiết kế thực tế, không học thuộc lòng.

• Lý thuyết: CAP Theorem, Consistency models (liên hệ Ngày 144).

• Thực hành: Phân tích 1 hệ thống cụ thể (VD: giỏ hàng vs số dư tài khoản) nên ưu tiên C hay A khi có network partition.

Ngày 178: Thiết kế API cho hệ thống chịu tải cao

• Mục tiêu: Tổng hợp toàn bộ kỹ thuật API design vào 1 hệ thống thật.

• Lý thuyết: Rate limiting, idempotency key, pagination cursor-based (liên hệ Ngày 100).

• Thực hành: Thiết kế API đặt vé sự kiện chịu được spike traffic lớn (VD: mở bán vé concert).

Ngày 179: Mock system design interview

• Mục tiêu: Luyện trình bày thiết kế hệ thống mạch lạc dưới áp lực thời gian.

• Lý thuyết: Khung trình bày system design (yêu cầu → ước lượng → high-level design → deep dive → trade-off).

• Thực hành: Thiết kế 1 hệ thống (VD: URL shortener, hệ thống đặt vé) từ đầu đến cuối trong 45 phút, có người phản biện.

GIAI ĐOẠN 22 - Dự án end-to-end (Ngày 180-193)

Mỗi dự án bắt buộc có: thiết kế ERD, REST API chuẩn, test coverage, Docker hóa, CI/CD pipeline, logging/monitoring cơ bản, security (JWT).

Ngày 180-186: Dự án 1 - Hệ thống E-commerce mini

• Mục tiêu: Ráp toàn bộ kiến thức Java Core → Spring → Cache → MQ thành 1 sản phẩm hoàn chỉnh.

• Lý thuyết: Ôn tập có định hướng: Concurrency (Giai đoạn 4) cho race condition khi đặt hàng, Cache (Giai đoạn 14) cho sản phẩm hot, MQ (Giai đoạn 15) cho email bất đồng bộ.

• Thực hành: Xây service Product, Order, Payment (giả lập), Notification (qua message queue). Yêu cầu bắt buộc: cache sản phẩm hot bằng Redis, xử lý đặt hàng đồng thời không race condition, gửi email xác nhận bất đồng bộ.

Ngày 187-193: Dự án 2 - Tách Microservices

• Mục tiêu: Chuyển đổi 1 monolith thành hệ microservices có khả năng vận hành thật.

• Lý thuyết: Ôn tập Giai đoạn 17 (Microservices) + 17B (Distributed Systems) + 18 (Observability).

• Thực hành: Tách Dự án 1 thành các service độc lập, thêm API Gateway, Service Discovery, Circuit Breaker, Distributed Tracing. Deploy lên Kubernetes cục bộ (Minikube), viết CI/CD pipeline hoàn chỉnh.

GIAI ĐOẠN 23 - Chuyên đề mở rộng: Track A - Fintech Engineering (Ngày 194-199)

Ngày 194: Double-entry bookkeeping (ghi sổ kép)

• Mục tiêu: Thiết kế hệ thống ledger đúng chuẩn kế toán, không dùng 1 cột balance đơn lẻ.

• Lý thuyết: Nguyên lý mọi giao dịch phải cân bằng Nợ/Có (Debit = Credit), thiết kế LedgerEntry bất biến (append-only, không UPDATE/DELETE dòng đã ghi), bảng Account/Transaction/Entry (liên hệ Giai đoạn 4 + Ngày 86 Optimistic/Pessimistic Locking).

• Thực hành: Thiết kế schema Account/Transaction/Entry, viết hàm chuyển tiền đảm bảo tổng Nợ = tổng Có trong 1 transaction.

Ngày 195: Money & Precision

• Mục tiêu: Không bao giờ để sai số tích lũy trong tính toán tiền tệ.

• Lý thuyết: Bắt buộc dùng BigDecimal cho tiền tệ (không bao giờ double/float), RoundingMode chuẩn theo từng loại tiền tệ, xử lý tỷ giá/số lẻ multi-currency, MathContext tránh lỗi tích lũy khi tính lãi/phí qua nhiều giao dịch.

• Thực hành: Viết hàm tính lãi kép qua 12 kỳ bằng BigDecimal, chứng minh sai số nếu dùng double.

Ngày 196: Batch Reconciliation (đối soát cuối ngày)

• Mục tiêu: Phát hiện chênh lệch giữa hệ thống nội bộ và đối tác bên ngoài.

• Lý thuyết: Matching engine so khớp ledger nội bộ với nguồn bên ngoài (ngân hàng, cổng thanh toán), phân loại discrepancy (thiếu/thừa giao dịch, lệch số tiền), quy trình xử lý ngoại lệ và báo cáo.

• Thực hành: Viết matching engine đối soát file giao dịch nội bộ với file ngân hàng mẫu, báo cáo các dòng lệch.

Ngày 197: Audit Trail & Tamper-Evident Logging

• Mục tiêu: Đảm bảo log không thể bị sửa mà không bị phát hiện.

• Lý thuyết: Log bất biến phục vụ compliance/audit, kỹ thuật hash chaining (mỗi bản ghi chứa hash của bản ghi trước - ý tưởng blockchain đơn giản).

• Thực hành: Implement audit log dùng hash chaining, viết hàm kiểm tra tính toàn vẹn của toàn bộ chuỗi log.

Ngày 198: Exactly-once trong Batch Processing

• Mục tiêu: Xử lý batch hàng triệu giao dịch an toàn khi job crash giữa chừng.

• Lý thuyết: Checkpointing, chia batch theo watermark, tránh xử lý trùng khi resume (liên hệ Idempotent API Design Ngày 138).

• Thực hành: Viết batch job xử lý 1 triệu record giả lập, tái hiện crash giữa chừng, resume đúng bằng checkpoint không xử lý trùng.

Ngày 199: Bài tập tổng hợp Track A

• Mục tiêu: Ráp toàn bộ kiến thức fintech thành 1 mini ledger service hoàn chỉnh.

• Lý thuyết: Ôn lại double-entry + reconciliation + audit trail.

• Thực hành: Xây mini ledger service - nạp tiền, chuyển tiền giữa 2 tài khoản đảm bảo double-entry, chạy batch reconciliation giả lập với file dữ liệu ngân hàng mẫu có cố tình gây lệch để test cơ chế phát hiện.

GIAI ĐOẠN 24 - Chuyên đề mở rộng: Track B - Platform Engineering (Ngày 200-206)

Ngày 200: Service Mesh

• Mục tiêu: Hiểu vấn đề phát sinh khi số lượng microservice tăng lên.

• Lý thuyết: mTLS thủ công, retry/timeout rải rác trong từng service, sidecar proxy pattern tách network logic khỏi application code.

• Thực hành: Vẽ sơ đồ kiến trúc trước/sau khi thêm service mesh cho hệ thống ở Dự án 2.

Ngày 201: Istio

• Mục tiêu: Vận hành traffic control ở tầng mesh.

• Lý thuyết: Cài Istio trên cluster đã có (Giai đoạn 20), cấu hình traffic splitting (canary theo %), circuit breaking ở tầng mesh (so sánh với Resilience4j ở Ngày 135).

• Thực hành: Cấu hình canary release 10% traffic sang version mới của 1 service qua Istio.

Ngày 202: mTLS & Zero Trust Network

• Mục tiêu: Hiểu mô hình bảo mật không tin tưởng mặc định vào network nội bộ.

• Lý thuyết: Mesh tự động mã hóa giao tiếp giữa service không cần sửa code, Zero Trust khác gì bảo mật theo network perimeter truyền thống.

• Thực hành: Bật mTLS strict mode trong Istio, kiểm chứng traffic giữa 2 service đã được mã hóa.

Ngày 203: Observability qua Service Mesh

• Mục tiêu: Đánh giá đánh đổi giữa observability ở tầng mesh và tầng code.

• Lý thuyết: Mesh cung cấp sẵn metrics/tracing ở tầng network so với tự nhúng Micrometer/tracing vào từng service (Giai đoạn 18).

• Thực hành: So sánh dashboard mesh tự sinh (Kiali) với dashboard tự nhúng đã làm ở Ngày 153-154.

Ngày 204: GitOps & ArgoCD

• Mục tiêu: Áp dụng "Git là nguồn chân lý duy nhất" cho hạ tầng.

• Lý thuyết: Mọi thay đổi hạ tầng qua Pull Request, ArgoCD tự động sync trạng thái cluster theo Git repo, progressive delivery qua Argo Rollouts - so sánh với CI/CD truyền thống (Ngày 167): GitOps là pull-based, CI/CD truyền thống là push-based.

• Thực hành: Cài ArgoCD, để nó tự động sync 1 thay đổi Deployment từ Git repo vào cluster.

Ngày 205: Infrastructure as Code với Terraform

• Mục tiêu: Provision hạ tầng bằng code, không thao tác tay trên console.

• Lý thuyết: Terraform provision VPC/cluster/database, kết hợp Terraform + GitOps trong cùng pipeline.

• Thực hành: Viết Terraform module tạo 1 K8s cluster tối thiểu.

Ngày 206: Bài tập tổng hợp Track B

• Mục tiêu: Vận hành 1 hệ thống với đầy đủ platform engineering stack.

• Lý thuyết: Ôn lại mesh + GitOps + IaC.

• Thực hành: Đưa Dự án 2 lên vận hành với Istio + ArgoCD + Terraform, viết runbook triển khai/rollback.

GIAI ĐOẠN 25 - Capstone lớn: E-Wallet (Ví điện tử) (Ngày 207-215)

Ngày 207: Thiết kế tổng thể E-Wallet

• Mục tiêu: Vẽ kiến trúc tổng thể trước khi code dòng nào.

• Lý thuyết: Chia service: Account Service, Ledger Service, Transfer Service, Notification Service, Fraud Service - ranh giới Bounded Context giữa các service.

• Thực hành: Vẽ sơ đồ kiến trúc + ERD tổng thể cho toàn bộ hệ thống E-Wallet.

Ngày 208-209: Account Service & Ledger Service

• Mục tiêu: Xây tầng lõi tài chính chuẩn double-entry.

• Lý thuyết: Áp dụng Ngày 194-195 (double-entry, BigDecimal) vào thiết kế thật.

• Thực hành: Implement Account Service (quản lý user/account) và Ledger Service (ghi sổ kép, immutable).

Ngày 210: Transfer Service với Saga

• Mục tiêu: Đảm bảo giao dịch chuyển tiền nhất quán across service.

• Lý thuyết: Áp dụng Saga Orchestration + Outbox Pattern (Ngày 136) cho luồng chuyển tiền.

• Thực hành: Implement Transfer Service điều phối Account/Ledger Service bằng Saga, đảm bảo bù trừ (compensating transaction) khi 1 bước thất bại.

Ngày 211: Notification Service qua Kafka

• Mục tiêu: Thông báo giao dịch bất đồng bộ, không chặn luồng chính.

• Lý thuyết: Ôn lại Giai đoạn 15 (Kafka, idempotent consumer).

• Thực hành: Implement Notification Service consume event từ Kafka, gửi thông báo, đảm bảo không gửi trùng.

Ngày 212: Fraud Service cơ bản

• Mục tiêu: Thêm lớp phát hiện bất thường vào pipeline giao dịch.

• Lý thuyết: Rule-based fraud detection cơ bản (velocity check: số giao dịch/phút, ngưỡng số tiền bất thường), vị trí đặt Fraud Service trong luồng (đồng bộ chặn giao dịch hay bất đồng bộ gắn cờ sau).

• Thực hành: Implement Fraud Service chặn giao dịch vượt ngưỡng velocity check trước khi Transfer Service thực thi.

Ngày 213: Bảo mật & Idempotency toàn hệ thống

• Mục tiêu: Khép kín lớp bảo mật và chống trùng giao dịch cho toàn bộ capstone.

• Lý thuyết: Ôn lại JWT (Ngày 108), idempotency key (Ngày 138), Redis distributed lock (Ngày 116).

• Thực hành: Áp JWT cho toàn bộ API, idempotency key bắt buộc cho API chuyển tiền, distributed lock cho thao tác cùng 1 account.

Ngày 214: Vận hành - Cache, Observability, Cloud Native

• Mục tiêu: Đưa hệ thống lên trạng thái sẵn sàng vận hành production.

• Lý thuyết: Ôn lại Redis (Giai đoạn 14), Observability (Giai đoạn 18), Kubernetes + Cloud Native (Giai đoạn 20-20B).

• Thực hành: Deploy toàn bộ hệ thống lên Kubernetes, có Prometheus/Grafana dashboard, ArgoCD sync, secret quản lý qua Vault.

Ngày 215: Demo & Review toàn khóa

• Mục tiêu: Trình bày hệ thống hoàn chỉnh như 1 buổi review thật trong công ty.

• Lý thuyết: Chuẩn bị demo script, xác định các câu hỏi trade-off có thể bị hỏi (vì sao Saga không 2PC, vì sao double-entry, vì sao Kafka không RabbitMQ...).

• Thực hành: Demo end-to-end 1 giao dịch chuyển tiền đi qua toàn bộ hệ thống (Account → Fraud → Transfer/Saga → Ledger → Notification), trả lời phản biện.

GIAI ĐOẠN 26 - Engineering Practices & Career (Ngày 216-220)

Ngày 216: Code Review hiệu quả

• Mục tiêu: Review code mang tính xây dựng, không chỉ bắt lỗi cú pháp.

• Lý thuyết: Checklist review (đúng logic, đúng thiết kế, đủ test, không phá vỡ convention), cách phản hồi không gây xung đột, khi nào nên block PR vs nên góp ý sau.

• Thực hành: Review 1 PR thật (có cả lỗi thiết kế và lỗi nhỏ), viết comment review theo chuẩn xây dựng.

Ngày 217: Viết RFC/Design Doc

• Mục tiêu: Thuyết phục team bằng tài liệu thiết kế trước khi code.

• Lý thuyết: Cấu trúc 1 RFC (bối cảnh, mục tiêu, các phương án, trade-off, quyết định), vì sao RFC giúp tránh rework tốn kém.

• Thực hành: Viết 1 RFC đề xuất thay đổi kiến trúc thật (VD: chuyển từ REST sang gRPC cho 1 luồng nội bộ).

Ngày 218: Incident Management & Postmortem

• Mục tiêu: Xử lý sự cố production có quy trình, học được từ sự cố thay vì đổ lỗi.

• Lý thuyết: Các bước xử lý incident (phát hiện → giảm thiểu → khắc phục → khôi phục), viết postmortem blameless (tập trung vào hệ thống, không quy trách nhiệm cá nhân).

• Thực hành: Viết 1 postmortem giả lập cho sự cố "API thanh toán chậm do connection pool cạn kiệt" (liên hệ Ngày 70).

Ngày 219: On-call & Chaos Engineering cơ bản

• Mục tiêu: Chủ động tìm điểm yếu hệ thống trước khi nó tự bộc lộ lúc nửa đêm.

• Lý thuyết: Vai trò on-call, runbook, giới thiệu Chaos Engineering (chủ động gây lỗi có kiểm soát để kiểm chứng khả năng chịu lỗi).

• Thực hành: Viết 1 runbook xử lý sự cố "service không kết nối được database", chạy thử 1 thí nghiệm chaos đơn giản (kill 1 pod, quan sát hệ thống tự phục hồi).

Ngày 220: Kỹ năng phỏng vấn

• Mục tiêu: Tổng hợp toàn khóa thành khả năng trả lời phỏng vấn.

• Lý thuyết: Các dạng câu hỏi thường gặp (system design, trade-off kỹ thuật, xử lý sự cố thật đã gặp - theo mô hình STAR), cách trình bày kinh nghiệm từ capstone E-Wallet thành câu chuyện phỏng vấn thuyết phục.

• Thực hành: Mock phỏng vấn 60 phút: 1 câu system design + 2-3 câu trade-off kỹ thuật rút ra từ chính capstone đã làm.