questions.json

[
  {
    "num": 1,
    "numStr": "01",
    "question": "JDK, JRE, JVM khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th>Thành phần</th><th>Là gì</th><th>Dùng khi nào</th></tr>\n        <tr><td><strong>JVM</strong></td><td>Máy ảo Java, thực thi bytecode (.class)</td><td>Runtime</td></tr>\n        <tr><td><strong>JRE</strong></td><td>JVM + thư viện runtime chuẩn (rt.jar...)</td><td>Chỉ cần chạy app</td></tr>\n        <tr><td><strong>JDK</strong></td><td>JRE + compiler (javac), debugger, tools</td><td>Phát triển ứng dụng</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 Quy tắc nhớ: <strong>JDK ⊃ JRE ⊃ JVM</strong>. Trên máy dev cài JDK; server production chỉ cần JRE là đủ.</div>",
    "tags": "java oop basics",
    "level": "intern",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "OOP & Basics"
  },
  {
    "num": 2,
    "numStr": "02",
    "question": "Java là pass-by-value hay pass-by-reference?",
    "answerHtml": "<p>Java <span class=\"highlight\">luôn luôn là pass-by-value</span>. Tuy nhiên với object, giá trị được pass là <strong>bản sao của reference</strong> (địa chỉ), không phải object gốc.</p>\n      <div class=\"code-block\"><span class=\"kw\">void</span> <span class=\"fn\">change</span>(StringBuilder sb) {\n    sb.append(<span class=\"st\">\" World\"</span>);   <span class=\"cm\">// OK - thay đổi object gốc qua reference</span>\n    sb = <span class=\"kw\">new</span> StringBuilder(); <span class=\"cm\">// KHÔNG ảnh hưởng caller - reassign local copy</span>\n}\n\nStringBuilder s = <span class=\"kw\">new</span> StringBuilder(<span class=\"st\">\"Hello\"</span>);\nchange(s);\nSystem.out.println(s); <span class=\"cm\">// \"Hello World\" - append có, nhưng reassign không</span></div>\n      <div class=\"tip-box\">💡 Cách nhớ: bạn truyền vào địa chỉ nhà (copy), người nhận có thể vào nhà sửa đồ đạc, nhưng không thể thay đổi địa chỉ trong danh bạ của bạn.</div>",
    "tags": "java basics",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "OOP & Basics"
  },
  {
    "num": 3,
    "numStr": "03",
    "question": "4 tính chất OOP trong Java?",
    "answerHtml": "<ul>\n        <li><strong>Encapsulation (Đóng gói):</strong> Che giấu data bên trong class, chỉ expose qua getter/setter. Tăng bảo mật, kiểm soát truy cập.</li>\n        <li><strong>Inheritance (Kế thừa):</strong> Class con kế thừa field/method của class cha. Tái sử dụng code. Java chỉ hỗ trợ đơn kế thừa (<code>extends</code>).</li>\n        <li><strong>Polymorphism (Đa hình):</strong> Cùng một method nhưng hành vi khác nhau tuỳ object. Có 2 loại: compile-time (overloading) và runtime (overriding).</li>\n        <li><strong>Abstraction (Trừu tượng):</strong> Ẩn chi tiết implement, chỉ show interface. Dùng abstract class hoặc interface.</li>\n      </ul>",
    "tags": "java oop",
    "level": "intern",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "OOP & Basics"
  },
  {
    "num": 4,
    "numStr": "04",
    "question": "Abstract class vs Interface khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Abstract Class</th><th>Interface</th></tr>\n        <tr><td>Constructor</td><td>✅ Có</td><td>❌ Không</td></tr>\n        <tr><td>Field</td><td>Mọi loại</td><td>Chỉ public static final</td></tr>\n        <tr><td>Method</td><td>Abstract + concrete</td><td>Abstract + default + static (Java 8+)</td></tr>\n        <tr><td>Kế thừa</td><td>Chỉ extend 1</td><td>Implement nhiều</td></tr>\n        <tr><td>Dùng khi</td><td>Chia sẻ code chung, có quan hệ \"is-a\"</td><td>Định nghĩa contract, \"can-do\"</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 Ví dụ: <code>Animal</code> (abstract class có method <code>sleep()</code>) vs <code>Flyable</code> (interface - Bird, Plane đều implement được).</div>",
    "tags": "java oop",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "OOP & Basics"
  },
  {
    "num": 5,
    "numStr": "05",
    "question": "== vs .equals() khác nhau thế nào?",
    "answerHtml": "<p><code>==</code> so sánh <strong>địa chỉ bộ nhớ</strong> (reference). <code>.equals()</code> so sánh <strong>nội dung giá trị</strong> (nếu được override).</p>\n      <div class=\"code-block\">String a = <span class=\"kw\">new</span> String(<span class=\"st\">\"hello\"</span>);\nString b = <span class=\"kw\">new</span> String(<span class=\"st\">\"hello\"</span>);\n\nSystem.out.println(a == b);        <span class=\"cm\">// false - khác địa chỉ</span>\nSystem.out.println(a.equals(b));   <span class=\"cm\">// true  - cùng nội dung</span>\n\nString c = <span class=\"st\">\"hello\"</span>;\nString d = <span class=\"st\">\"hello\"</span>;\nSystem.out.println(c == d);        <span class=\"cm\">// true  - cùng String Pool</span></div>\n      <div class=\"warn-box\">⚠️ Với Integer: <code>Integer a = 127; Integer b = 127; a == b</code> là <strong>true</strong> (Integer cache -128 đến 127). Nhưng <code>Integer a = 200; Integer b = 200; a == b</code> là <strong>false</strong>!</div>",
    "tags": "java basics",
    "level": "intern",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "OOP & Basics"
  },
  {
    "num": 6,
    "numStr": "06",
    "question": "String, StringBuilder, StringBuffer khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>String</th><th>StringBuilder</th><th>StringBuffer</th></tr>\n        <tr><td>Mutable</td><td>❌ Immutable</td><td>✅</td><td>✅</td></tr>\n        <tr><td>Thread-safe</td><td>✅ (immutable)</td><td>❌</td><td>✅ (synchronized)</td></tr>\n        <tr><td>Hiệu năng</td><td>Chậm khi nối nhiều</td><td>Nhanh nhất</td><td>Chậm hơn Builder</td></tr>\n      </table>\n      <p><strong>Khi nào dùng:</strong></p>\n      <ul>\n        <li>String: giá trị không đổi, key trong HashMap</li>\n        <li>StringBuilder: nối chuỗi trong loop, single-thread</li>\n        <li>StringBuffer: multi-thread (hiếm dùng, thường dùng StringBuilder + sync riêng)</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"cm\">// BAD - tạo nhiều String object</span>\nString s = <span class=\"st\">\"\"</span>;\n<span class=\"kw\">for</span> (<span class=\"kw\">int</span> i = <span class=\"num\">0</span>; i < <span class=\"num\">1000</span>; i++) s += i;\n\n<span class=\"cm\">// GOOD</span>\nStringBuilder sb = <span class=\"kw\">new</span> StringBuilder();\n<span class=\"kw\">for</span> (<span class=\"kw\">int</span> i = <span class=\"num\">0</span>; i < <span class=\"num\">1000</span>; i++) sb.append(i);</div>",
    "tags": "java basics",
    "level": "intern",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "OOP & Basics"
  },
  {
    "num": 7,
    "numStr": "07",
    "question": "final, finally, finalize khác nhau thế nào?",
    "answerHtml": "<ul>\n        <li><code>final</code> — <strong>keyword</strong>: biến không thể gán lại, method không thể override, class không thể extend.</li>\n        <li><code>finally</code> — <strong>block</strong>: luôn chạy sau try-catch, dùng để giải phóng resource (đóng connection, file...).</li>\n        <li><code>finalize()</code> — <strong>method</strong>: GC gọi trước khi thu hồi object. <span class=\"warn\">Deprecated Java 9+</span>, không nên dùng — không đảm bảo khi nào được gọi.</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"kw\">final int</span> MAX = <span class=\"num\">100</span>;   <span class=\"cm\">// không thể thay đổi</span>\n\n<span class=\"kw\">try</span> {\n    connection.execute();\n} <span class=\"kw\">catch</span> (Exception e) {\n    log.error(e);\n} <span class=\"kw\">finally</span> {\n    connection.close();  <span class=\"cm\">// luôn chạy dù có exception hay không</span>\n}</div>",
    "tags": "java basics",
    "level": "intern",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "OOP & Basics"
  },
  {
    "num": 8,
    "numStr": "08",
    "question": "static keyword dùng để làm gì?",
    "answerHtml": "<p><code>static</code> nghĩa là thuộc về <strong>class</strong>, không phải instance cụ thể. Dùng chung cho tất cả object.</p>\n      <ul>\n        <li><strong>Static field:</strong> Biến chia sẻ giữa tất cả instance (đếm số lượng object)</li>\n        <li><strong>Static method:</strong> Gọi qua tên class, không cần tạo object (<code>Math.abs()</code>)</li>\n        <li><strong>Static block:</strong> Chạy một lần khi class được load — dùng để init</li>\n        <li><strong>Static nested class:</strong> Inner class không cần instance của outer class</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"kw\">class</span> <span class=\"cl\">Counter</span> {\n    <span class=\"kw\">static int</span> count = <span class=\"num\">0</span>;         <span class=\"cm\">// chia sẻ cho tất cả object</span>\n    <span class=\"cl\">Counter</span>() { count++; }\n\n    <span class=\"kw\">static int</span> <span class=\"fn\">getCount</span>() {      <span class=\"cm\">// gọi qua Counter.getCount()</span>\n        <span class=\"kw\">return</span> count;\n    }\n}</div>",
    "tags": "java basics",
    "level": "intern",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "OOP & Basics"
  },
  {
    "num": 9,
    "numStr": "09",
    "question": "Overloading vs Overriding khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Overloading</th><th>Overriding</th></tr>\n        <tr><td>Xảy ra ở đâu</td><td>Cùng một class</td><td>Subclass với superclass</td></tr>\n        <tr><td>Tham số</td><td>Khác nhau (số lượng/kiểu)</td><td>Phải giống hệt</td></tr>\n        <tr><td>Return type</td><td>Có thể khác</td><td>Phải giống (hoặc covariant)</td></tr>\n        <tr><td>Quyết định lúc nào</td><td>Compile-time</td><td>Runtime</td></tr>\n        <tr><td>Gọi là</td><td>Static polymorphism</td><td>Dynamic polymorphism</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// Overloading</span>\n<span class=\"kw\">int</span> <span class=\"fn\">add</span>(<span class=\"kw\">int</span> a, <span class=\"kw\">int</span> b) { <span class=\"kw\">return</span> a+b; }\n<span class=\"kw\">double</span> <span class=\"fn\">add</span>(<span class=\"kw\">double</span> a, <span class=\"kw\">double</span> b) { <span class=\"kw\">return</span> a+b; }\n\n<span class=\"cm\">// Overriding</span>\n<span class=\"kw\">class</span> <span class=\"cl\">Animal</span> { String <span class=\"fn\">sound</span>() { <span class=\"kw\">return</span> <span class=\"st\">\"...\"</span>; } }\n<span class=\"kw\">class</span> <span class=\"cl\">Dog</span> <span class=\"kw\">extends</span> <span class=\"cl\">Animal</span> {\n    <span class=\"an\">@Override</span>\n    String <span class=\"fn\">sound</span>() { <span class=\"kw\">return</span> <span class=\"st\">\"Woof\"</span>; }  <span class=\"cm\">// quyết định lúc runtime</span>\n}</div>",
    "tags": "java oop",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "OOP & Basics"
  },
  {
    "num": 10,
    "numStr": "10",
    "question": "Constructor có thể được override không?",
    "answerHtml": "<p><span class=\"highlight\">Không thể override constructor</span>. Constructor không được kế thừa — subclass không kế thừa constructor của superclass, nên không có gì để override.</p>\n      <p>Tuy nhiên, constructor <strong>có thể overload</strong> (nhiều constructor khác tham số trong cùng 1 class).</p>\n      <p>Subclass có thể <strong>gọi constructor cha</strong> bằng <code>super()</code> — nhưng đó là gọi, không phải override.</p>\n      <div class=\"code-block\"><span class=\"kw\">class</span> <span class=\"cl\">Animal</span> {\n    <span class=\"cl\">Animal</span>(String name) { ... }\n}\n<span class=\"kw\">class</span> <span class=\"cl\">Dog</span> <span class=\"kw\">extends</span> <span class=\"cl\">Animal</span> {\n    <span class=\"cl\">Dog</span>(String name) {\n        <span class=\"kw\">super</span>(name);  <span class=\"cm\">// gọi constructor cha, không phải override</span>\n    }\n}</div>",
    "tags": "java oop",
    "level": "intern",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "OOP & Basics"
  },
  {
    "num": 11,
    "numStr": "11",
    "question": "ArrayList vs LinkedList khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th>Thao tác</th><th>ArrayList</th><th>LinkedList</th></tr>\n        <tr><td>Truy cập theo index (get)</td><td>O(1) ⚡</td><td>O(n) 🐢</td></tr>\n        <tr><td>Thêm/xóa ở đầu/giữa</td><td>O(n) 🐢</td><td>O(1) ⚡</td></tr>\n        <tr><td>Thêm ở cuối</td><td>O(1) amortized</td><td>O(1)</td></tr>\n        <tr><td>Bộ nhớ</td><td>Ít hơn</td><td>Nhiều hơn (lưu node + 2 pointer)</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 <strong>Thực tế:</strong> Hầu hết dùng ArrayList vì access theo index nhiều hơn insert/delete. Dùng LinkedList khi cần Queue/Deque hoặc insert/delete đầu list thường xuyên.</div>",
    "tags": "java collections",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Collections & Generics"
  },
  {
    "num": 12,
    "numStr": "12",
    "question": "HashMap hoạt động như thế nào?",
    "answerHtml": "<p>HashMap dùng <strong>hashing</strong>: khi put(key, value), Java tính <code>hash(key)</code> → xác định vị trí (bucket index) trong mảng nội bộ.</p>\n      <ul>\n        <li><strong>Collision:</strong> Nếu 2 key có cùng bucket → lưu thành chain (LinkedList). Từ Java 8, nếu chain dài ≥ 8 → chuyển sang TreeNode (O(log n)).</li>\n        <li><strong>Load factor:</strong> Mặc định 0.75. Khi fill > 75% capacity → resize (double size, rehash tất cả).</li>\n        <li><strong>Độ phức tạp:</strong> get/put trung bình O(1), tệ nhất O(log n).</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"cm\">// Khi put(\"name\", \"John\"):</span>\n<span class=\"num\">1</span>. hash = <span class=\"st\">\"name\"</span>.hashCode()  <span class=\"cm\">// → tính hash</span>\n<span class=\"num\">2</span>. index = hash & (capacity - <span class=\"num\">1</span>)  <span class=\"cm\">// → tìm bucket</span>\n<span class=\"num\">3</span>. Nếu bucket trống → lưu vào\n<span class=\"num\">4</span>. Nếu đã có key giống → update value\n<span class=\"num\">5</span>. Nếu collision → thêm vào chain</div>\n      <div class=\"warn-box\">⚠️ HashMap không đảm bảo thứ tự. Dùng <strong>LinkedHashMap</strong> nếu cần giữ insertion order, <strong>TreeMap</strong> nếu cần sorted order.</div>",
    "tags": "java collections",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Collections & Generics"
  },
  {
    "num": 13,
    "numStr": "13",
    "question": "HashMap vs HashTable khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>HashMap</th><th>HashTable</th></tr>\n        <tr><td>Thread-safe</td><td>❌</td><td>✅ (synchronized toàn bộ method)</td></tr>\n        <tr><td>Null key/value</td><td>✅ 1 null key, nhiều null value</td><td>❌</td></tr>\n        <tr><td>Hiệu năng</td><td>Nhanh hơn</td><td>Chậm hơn (lock toàn bộ)</td></tr>\n        <tr><td>Iterator</td><td>fail-fast</td><td>Enumerator (cũ hơn)</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 Trong thực tế: <strong>không dùng HashTable nữa</strong>. Cần thread-safe thì dùng <code>ConcurrentHashMap</code> — hiệu năng tốt hơn nhiều.</div>",
    "tags": "java collections",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Collections & Generics"
  },
  {
    "num": 14,
    "numStr": "14",
    "question": "HashMap vs ConcurrentHashMap khác nhau thế nào?",
    "answerHtml": "<p><strong>ConcurrentHashMap</strong> thread-safe nhưng <span class=\"green\">hiệu năng tốt hơn HashTable</span> vì không lock toàn bộ map.</p>\n      <ul>\n        <li>Java 7: chia thành nhiều <strong>Segment</strong>, mỗi segment có lock riêng → nhiều thread read/write song song trên segment khác nhau.</li>\n        <li>Java 8+: dùng <strong>CAS (Compare-And-Swap)</strong> + synchronized chỉ trên từng bucket khi cần — ít blocking hơn nhiều.</li>\n        <li>Không cho phép <strong>null key/value</strong> (HashMap cho phép 1 null key).</li>\n      </ul>\n      <div class=\"tip-box\">💡 Rule of thumb: single-thread → HashMap; multi-thread → ConcurrentHashMap.</div>",
    "tags": "java collections thread",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Collections & Generics"
  },
  {
    "num": 15,
    "numStr": "15",
    "question": "HashSet hoạt động như thế nào?",
    "answerHtml": "<p>HashSet thực chất là <strong>HashMap bên trong</strong>: element được lưu làm <em>key</em>, value là một dummy object <code>PRESENT</code>.</p>\n      <p>Tính duy nhất đảm bảo bởi: <code>hashCode()</code> + <code>equals()</code>. Nếu 2 object có cùng hashCode VÀ equals trả về true → được coi là trùng → không thêm vào.</p>\n      <div class=\"code-block\"><span class=\"cm\">// Khi add(\"hello\"):</span>\nmap.put(<span class=\"st\">\"hello\"</span>, PRESENT);  <span class=\"cm\">// PRESENT = new Object()</span>\n\n<span class=\"cm\">// Nếu \"hello\" đã tồn tại → put chỉ update value (PRESENT lại)</span>\n<span class=\"cm\">// → HashSet báo là đã có, không thêm</span></div>\n      <div class=\"warn-box\">⚠️ Phải override cả <strong>hashCode()</strong> và <strong>equals()</strong> nếu dùng custom object trong HashSet/HashMap!</div>",
    "tags": "java collections",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Collections & Generics"
  },
  {
    "num": 16,
    "numStr": "16",
    "question": "equals() và hashCode() contract là gì?",
    "answerHtml": "<p>Java quy định <strong>contract bắt buộc</strong>:</p>\n      <ul>\n        <li>Nếu <code>a.equals(b) == true</code> → <code>a.hashCode() == b.hashCode()</code> <span class=\"highlight\">BẮT BUỘC</span></li>\n        <li>Nếu <code>a.hashCode() == b.hashCode()</code> → chưa chắc <code>a.equals(b)</code> (collision bình thường)</li>\n      </ul>\n      <div class=\"warn-box\">⚠️ Vi phạm contract này khiến HashMap/HashSet hoạt động sai: 2 object \"bằng nhau\" nhưng lại nằm ở 2 bucket khác nhau → tìm không ra.</div>\n      <div class=\"code-block\"><span class=\"cm\">// Ví dụ SAI - chỉ override equals, quên hashCode</span>\n<span class=\"kw\">class</span> <span class=\"cl\">User</span> {\n    String name;\n    <span class=\"an\">@Override</span>\n    <span class=\"kw\">boolean</span> <span class=\"fn\">equals</span>(Object o) { <span class=\"kw\">return</span> name.equals(((User)o).name); }\n    <span class=\"cm\">// ❌ không override hashCode → HashMap hoạt động sai!</span>\n}</div>",
    "tags": "java collections",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Collections & Generics"
  },
  {
    "num": 17,
    "numStr": "17",
    "question": "Comparable vs Comparator khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Comparable</th><th>Comparator</th></tr>\n        <tr><td>Package</td><td>java.lang</td><td>java.util</td></tr>\n        <tr><td>Method</td><td>compareTo(T o)</td><td>compare(T o1, T o2)</td></tr>\n        <tr><td>Định nghĩa ở đâu</td><td>Trong class cần so sánh</td><td>Bên ngoài class</td></tr>\n        <tr><td>Số cách sắp xếp</td><td>1 (natural order)</td><td>Nhiều (linh hoạt)</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// Comparable - class tự định nghĩa cách sort</span>\n<span class=\"kw\">class</span> <span class=\"cl\">Student</span> <span class=\"kw\">implements</span> <span class=\"cl\">Comparable</span>&lt;<span class=\"cl\">Student</span>&gt; {\n    <span class=\"kw\">public int</span> <span class=\"fn\">compareTo</span>(<span class=\"cl\">Student</span> o) { <span class=\"kw\">return</span> <span class=\"kw\">this</span>.gpa - o.gpa; }\n}\n\n<span class=\"cm\">// Comparator - định nghĩa ngoài, linh hoạt</span>\nstudents.sort(Comparator.comparing(<span class=\"cl\">Student</span>::getName));\nstudents.sort(Comparator.comparingDouble(<span class=\"cl\">Student</span>::getGpa).reversed());</div>",
    "tags": "java collections",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Collections & Generics"
  },
  {
    "num": 18,
    "numStr": "18",
    "question": "List, Set, Map khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th>Interface</th><th>Thứ tự</th><th>Duplicate</th><th>Ví dụ</th></tr>\n        <tr><td><strong>List</strong></td><td>✅ Có (insertion order)</td><td>✅ Cho phép</td><td>ArrayList, LinkedList</td></tr>\n        <tr><td><strong>Set</strong></td><td>❌ (trừ Linked/Tree)</td><td>❌ Không cho phép</td><td>HashSet, TreeSet</td></tr>\n        <tr><td><strong>Map</strong></td><td>Tuỳ impl</td><td>Key không, Value có</td><td>HashMap, TreeMap</td></tr>\n      </table>",
    "tags": "java collections",
    "level": "intern",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Collections & Generics"
  },
  {
    "num": 19,
    "numStr": "19",
    "question": "Iterator vs ListIterator khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Iterator</th><th>ListIterator</th></tr>\n        <tr><td>Dùng cho</td><td>Mọi Collection</td><td>Chỉ List</td></tr>\n        <tr><td>Hướng duyệt</td><td>Một chiều (forward)</td><td>Hai chiều (forward + backward)</td></tr>\n        <tr><td>Thêm element</td><td>❌</td><td>✅ (add())</td></tr>\n        <tr><td>Lấy index</td><td>❌</td><td>✅ (nextIndex(), previousIndex())</td></tr>\n      </table>",
    "tags": "java collections",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Collections & Generics"
  },
  {
    "num": 20,
    "numStr": "20",
    "question": "fail-fast vs fail-safe iterator là gì?",
    "answerHtml": "<ul>\n        <li><span class=\"highlight\">fail-fast:</span> Ném <code>ConcurrentModificationException</code> ngay lập tức nếu collection bị sửa đổi trong khi đang duyệt. Dùng biến <code>modCount</code> để phát hiện. Ví dụ: ArrayList, HashMap iterator.</li>\n        <li><span class=\"green\">fail-safe:</span> Duyệt trên <strong>bản sao (snapshot)</strong> của collection → không ảnh hưởng bởi thay đổi. Không throw exception nhưng có thể không phản ánh thay đổi mới nhất. Ví dụ: CopyOnWriteArrayList, ConcurrentHashMap.</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"cm\">// fail-fast - sẽ throw ConcurrentModificationException</span>\nList&lt;String&gt; list = <span class=\"kw\">new</span> ArrayList&lt;&gt;(Arrays.asList(<span class=\"st\">\"a\"</span>,<span class=\"st\">\"b\"</span>,<span class=\"st\">\"c\"</span>));\n<span class=\"kw\">for</span> (String s : list) {\n    <span class=\"kw\">if</span> (s.equals(<span class=\"st\">\"b\"</span>)) list.remove(s); <span class=\"cm\">// ❌ Exception!</span>\n}\n\n<span class=\"cm\">// Cách đúng: dùng iterator.remove()</span>\nIterator&lt;String&gt; it = list.iterator();\n<span class=\"kw\">while</span> (it.hasNext()) {\n    <span class=\"kw\">if</span> (it.next().equals(<span class=\"st\">\"b\"</span>)) it.remove(); <span class=\"cm\">// ✅ OK</span>\n}</div>",
    "tags": "java collections thread",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Collections & Generics"
  },
  {
    "num": 21,
    "numStr": "21",
    "question": "Checked vs Unchecked Exception khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Checked Exception</th><th>Unchecked Exception</th></tr>\n        <tr><td>Extends</td><td>Exception (trừ RuntimeException)</td><td>RuntimeException</td></tr>\n        <tr><td>Bắt buộc xử lý</td><td>✅ (try-catch hoặc throws)</td><td>❌</td></tr>\n        <tr><td>Xảy ra khi</td><td>Lỗi ngoài tầm kiểm soát (IO, network, DB)</td><td>Lỗi lập trình (null, out of bounds)</td></tr>\n        <tr><td>Ví dụ</td><td>IOException, SQLException</td><td>NullPointerException, IllegalArgumentException</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 Triết lý: Checked = <em>\"Tôi biết điều này có thể xảy ra, hãy xử lý\"</em>. Unchecked = <em>\"Code bạn có bug\"</em>. Spring khuyến khích dùng Unchecked (RuntimeException) để tránh boilerplate.</div>",
    "tags": "java exception",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Exception Handling"
  },
  {
    "num": 22,
    "numStr": "22",
    "question": "Error vs Exception khác nhau thế nào?",
    "answerHtml": "<p>Cả hai đều extends <code>Throwable</code>, nhưng:</p>\n      <ul>\n        <li><strong>Error:</strong> Lỗi <span class=\"highlight\">nghiêm trọng từ JVM/system</span>, thường không thể recover. Ví dụ: <code>OutOfMemoryError</code>, <code>StackOverflowError</code>. Không nên catch (và thường không thể handle được).</li>\n        <li><strong>Exception:</strong> Lỗi <span class=\"green\">có thể dự đoán và xử lý</span> được trong ứng dụng. Nên catch và handle phù hợp.</li>\n      </ul>\n      <div class=\"code-block\">Throwable\n├── Error (không nên catch)\n│   ├── OutOfMemoryError\n│   └── StackOverflowError\n└── Exception (nên handle)\n    ├── IOException (checked)\n    └── RuntimeException (unchecked)\n        ├── NullPointerException\n        └── IllegalArgumentException</div>",
    "tags": "java exception",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Exception Handling"
  },
  {
    "num": 23,
    "numStr": "23",
    "question": "try-with-resources là gì?",
    "answerHtml": "<p>Cú pháp Java 7+ tự động gọi <code>close()</code> trên resource sau khi dùng xong, dù có exception hay không. Resource phải implement <code>AutoCloseable</code>.</p>\n      <div class=\"code-block\"><span class=\"cm\">// Cách cũ - dễ quên close(), rò rỉ resource</span>\nBufferedReader br = <span class=\"kw\">null</span>;\n<span class=\"kw\">try</span> {\n    br = <span class=\"kw\">new</span> BufferedReader(<span class=\"kw\">new</span> FileReader(<span class=\"st\">\"file.txt\"</span>));\n    <span class=\"kw\">return</span> br.readLine();\n} <span class=\"kw\">finally</span> {\n    <span class=\"kw\">if</span> (br != <span class=\"kw\">null</span>) br.close();\n}\n\n<span class=\"cm\">// try-with-resources - gọn hơn, an toàn hơn</span>\n<span class=\"kw\">try</span> (BufferedReader br = <span class=\"kw\">new</span> BufferedReader(<span class=\"kw\">new</span> FileReader(<span class=\"st\">\"file.txt\"</span>))) {\n    <span class=\"kw\">return</span> br.readLine();\n} <span class=\"cm\">// br.close() tự động gọi ở đây</span></div>",
    "tags": "java exception",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Exception Handling"
  },
  {
    "num": 24,
    "numStr": "24",
    "question": "finally block có luôn chạy không?",
    "answerHtml": "<p><strong>Gần như luôn luôn</strong>. Nhưng có 3 trường hợp ngoại lệ mà finally KHÔNG chạy:</p>\n      <ul>\n        <li><code>System.exit()</code> được gọi trong try/catch</li>\n        <li>JVM crash (OutOfMemoryError, kill process)</li>\n        <li>Thread bị kill đột ngột (<code>Thread.stop()</code> - deprecated)</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"kw\">try</span> {\n    <span class=\"kw\">return</span> <span class=\"num\">1</span>;         <span class=\"cm\">// return trong try vẫn chạy finally trước</span>\n} <span class=\"kw\">finally</span> {\n    System.out.println(<span class=\"st\">\"Luôn chạy!\"</span>); <span class=\"cm\">// Chạy trước khi return</span>\n    <span class=\"cm\">// Nếu return ở đây → override giá trị return từ try!</span>\n}</div>",
    "tags": "java exception",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Exception Handling"
  },
  {
    "num": 25,
    "numStr": "25",
    "question": "Custom Exception tạo như thế nào?",
    "answerHtml": "<div class=\"code-block\"><span class=\"cm\">// Checked Exception</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">InsufficientFundsException</span> <span class=\"kw\">extends</span> <span class=\"cl\">Exception</span> {\n    <span class=\"kw\">private final double</span> amount;\n    \n    <span class=\"kw\">public</span> <span class=\"fn\">InsufficientFundsException</span>(<span class=\"kw\">double</span> amount) {\n        <span class=\"kw\">super</span>(<span class=\"st\">\"Insufficient funds: \"</span> + amount);\n        <span class=\"kw\">this</span>.amount = amount;\n    }\n    \n    <span class=\"kw\">public double</span> <span class=\"fn\">getAmount</span>() { <span class=\"kw\">return</span> amount; }\n}\n\n<span class=\"cm\">// Unchecked Exception (phổ biến hơn trong Spring)</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">UserNotFoundException</span> <span class=\"kw\">extends</span> <span class=\"cl\">RuntimeException</span> {\n    <span class=\"kw\">public</span> <span class=\"fn\">UserNotFoundException</span>(Long id) {\n        <span class=\"kw\">super</span>(<span class=\"st\">\"User not found with id: \"</span> + id);\n    }\n}</div>",
    "tags": "java exception",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Exception Handling"
  },
  {
    "num": 26,
    "numStr": "26",
    "question": "Thread vs Runnable khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>extends Thread</th><th>implements Runnable</th></tr>\n        <tr><td>Kế thừa class khác</td><td>❌ (đã dùng 1 slot extend)</td><td>✅ Tự do</td></tr>\n        <tr><td>Tách logic/thread</td><td>❌ Gộp chung</td><td>✅ Tách biệt rõ ràng</td></tr>\n        <tr><td>Tái sử dụng task</td><td>❌</td><td>✅ Dùng với ThreadPool</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// Cách khuyến khích - implements Runnable</span>\n<span class=\"cl\">Runnable</span> task = () -> System.out.println(<span class=\"st\">\"Running in: \"</span> + Thread.currentThread().getName());\n<span class=\"kw\">new</span> Thread(task).start();\n\n<span class=\"cm\">// Dùng với ThreadPool</span>\nExecutorService pool = Executors.newFixedThreadPool(<span class=\"num\">4</span>);\npool.submit(task);</div>",
    "tags": "java thread",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 27,
    "numStr": "27",
    "question": "synchronized keyword dùng để làm gì?",
    "answerHtml": "<p><code>synchronized</code> đảm bảo <strong>chỉ 1 thread</strong> được vào block/method tại một thời điểm, tránh race condition. Thread khác phải chờ (blocked).</p>\n      <ul>\n        <li><strong>synchronized method:</strong> Lock trên <code>this</code> (instance)</li>\n        <li><strong>static synchronized method:</strong> Lock trên <code>Class</code> object</li>\n        <li><strong>synchronized block:</strong> Lock trên object chỉ định, phạm vi hẹp hơn → ít blocking hơn</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"cm\">// synchronized method</span>\n<span class=\"kw\">public synchronized void</span> <span class=\"fn\">increment</span>() { count++; }\n\n<span class=\"cm\">// synchronized block - tốt hơn vì chỉ lock khi cần</span>\n<span class=\"kw\">public void</span> <span class=\"fn\">increment</span>() {\n    doSomethingWithoutLock();    <span class=\"cm\">// Không cần lock - chạy song song</span>\n    <span class=\"kw\">synchronized</span> (<span class=\"kw\">this</span>) {\n        count++;                 <span class=\"cm\">// Chỉ lock phần cần thiết</span>\n    }\n}</div>",
    "tags": "java thread",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 28,
    "numStr": "28",
    "question": "volatile keyword dùng để làm gì?",
    "answerHtml": "<p><code>volatile</code> đảm bảo biến được đọc/ghi trực tiếp từ <strong>main memory</strong>, không bị cache trong CPU register của từng thread.</p>\n      <p>Giải quyết <strong>visibility problem</strong>: Thread A thay đổi biến nhưng Thread B vẫn thấy giá trị cũ từ cache.</p>\n      <div class=\"code-block\"><span class=\"kw\">class</span> <span class=\"cl\">StopThread</span> {\n    <span class=\"kw\">private volatile boolean</span> running = <span class=\"kw\">true</span>;  <span class=\"cm\">// không có volatile, thread có thể không thấy thay đổi</span>\n    \n    <span class=\"kw\">void</span> <span class=\"fn\">run</span>() {\n        <span class=\"kw\">while</span> (running) { doWork(); }  <span class=\"cm\">// đọc từ main memory mỗi lần</span>\n    }\n    \n    <span class=\"kw\">void</span> <span class=\"fn\">stop</span>() { running = <span class=\"kw\">false</span>; }  <span class=\"cm\">// ghi vào main memory ngay</span>\n}</div>\n      <div class=\"warn-box\">⚠️ volatile <strong>KHÔNG</strong> đảm bảo atomicity! <code>count++</code> gồm 3 bước (read, increment, write) — vẫn cần synchronized hoặc AtomicInteger.</div>",
    "tags": "java thread",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 29,
    "numStr": "29",
    "question": "wait(), notify(), notifyAll() dùng để làm gì?",
    "answerHtml": "<p>Dùng trong <code>synchronized</code> block để điều phối các thread chờ nhau (Producer-Consumer pattern):</p>\n      <ul>\n        <li><code>wait()</code>: Thread <strong>giải phóng lock</strong> và đi ngủ, chờ được đánh thức</li>\n        <li><code>notify()</code>: Đánh thức <strong>1 thread ngẫu nhiên</strong> đang wait trên cùng object</li>\n        <li><code>notifyAll()</code>: Đánh thức <strong>tất cả</strong> thread đang wait → các thread cạnh tranh lại lock</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"cm\">// Producer-Consumer đơn giản</span>\n<span class=\"kw\">synchronized</span> (queue) {\n    <span class=\"kw\">while</span> (queue.isEmpty()) {\n        queue.wait();  <span class=\"cm\">// giải phóng lock, chờ có data</span>\n    }\n    process(queue.poll());\n}\n\n<span class=\"cm\">// Khi Producer thêm data:</span>\n<span class=\"kw\">synchronized</span> (queue) {\n    queue.add(item);\n    queue.notifyAll();  <span class=\"cm\">// đánh thức consumer</span>\n}</div>\n      <div class=\"tip-box\">💡 Thực tế dùng <code>BlockingQueue</code> (LinkedBlockingQueue, ArrayBlockingQueue) thay vì tự implement — đơn giản và an toàn hơn.</div>",
    "tags": "java thread",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 30,
    "numStr": "30",
    "question": "Deadlock là gì? Cách tránh?",
    "answerHtml": "<p>Deadlock xảy ra khi 2+ thread <strong>chờ nhau giải phóng lock</strong> vô thời hạn.</p>\n      <div class=\"code-block\"><span class=\"cm\">// Thread 1: lock A → chờ B</span>\n<span class=\"cm\">// Thread 2: lock B → chờ A  → DEADLOCK!</span></div>\n      <p><strong>Cách tránh Deadlock:</strong></p>\n      <ul>\n        <li>✅ <strong>Thứ tự lock nhất quán:</strong> Luôn lock A trước B, không bao giờ ngược lại</li>\n        <li>✅ <strong>tryLock với timeout:</strong> <code>lock.tryLock(1, TimeUnit.SECONDS)</code> — nếu không được thì bỏ qua</li>\n        <li>✅ <strong>Giảm phạm vi lock:</strong> Chỉ lock khi thực sự cần, release sớm nhất có thể</li>\n        <li>✅ <strong>Dùng concurrent collections:</strong> ConcurrentHashMap, BlockingQueue... thay vì tự lock</li>\n      </ul>",
    "tags": "java thread",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 31,
    "numStr": "31",
    "question": "ThreadPool và ExecutorService là gì?",
    "answerHtml": "<p><strong>ThreadPool</strong> là nhóm thread được tạo sẵn và tái sử dụng — tránh chi phí tạo/hủy thread liên tục.</p>\n      <p><strong>ExecutorService</strong> là interface quản lý ThreadPool: submit task, lấy kết quả, shutdown.</p>\n      <div class=\"code-block\">ExecutorService pool = Executors.newFixedThreadPool(<span class=\"num\">4</span>);\n\n<span class=\"cm\">// Submit Runnable (không cần kết quả)</span>\npool.execute(() -> processTask());\n\n<span class=\"cm\">// Submit Callable (cần kết quả)</span>\nFuture&lt;String&gt; future = pool.submit(() -> fetchData());\nString result = future.get(); <span class=\"cm\">// block cho đến khi có kết quả</span>\n\npool.shutdown(); <span class=\"cm\">// dừng nhận task mới, chờ task hiện tại xong</span></div>\n      <table class=\"compare-table\">\n        <tr><th>Factory method</th><th>Dùng khi</th></tr>\n        <tr><td>newFixedThreadPool(n)</td><td>Số lượng task nhiều, giới hạn tài nguyên</td></tr>\n        <tr><td>newCachedThreadPool()</td><td>Nhiều task ngắn, số lượng thay đổi</td></tr>\n        <tr><td>newSingleThreadExecutor()</td><td>Task cần chạy tuần tự</td></tr>\n        <tr><td>newScheduledThreadPool(n)</td><td>Task định kỳ</td></tr>\n      </table>",
    "tags": "java thread",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 32,
    "numStr": "32",
    "question": "Callable vs Runnable khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Runnable</th><th>Callable&lt;V&gt;</th></tr>\n        <tr><td>Return value</td><td>void</td><td>V (generic type)</td></tr>\n        <tr><td>Checked Exception</td><td>❌ Không throw được</td><td>✅ Có thể throw</td></tr>\n        <tr><td>Dùng với</td><td>execute(), Thread</td><td>submit() → Future&lt;V&gt;</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cl\">Callable</span>&lt;Integer&gt; task = () -> {\n    <span class=\"cm\">// có thể throw checked exception</span>\n    <span class=\"kw\">return</span> computeHeavyTask(); <span class=\"cm\">// trả về kết quả</span>\n};\n\nFuture&lt;Integer&gt; future = pool.submit(task);\nInteger result = future.get();          <span class=\"cm\">// block đợi kết quả</span>\nInteger result2 = future.get(<span class=\"num\">5</span>, TimeUnit.SECONDS); <span class=\"cm\">// timeout</span></div>",
    "tags": "java thread",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 33,
    "numStr": "33",
    "question": "synchronized vs ReentrantLock khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>synchronized</th><th>ReentrantLock</th></tr>\n        <tr><td>Tự động release</td><td>✅</td><td>❌ (phải gọi unlock())</td></tr>\n        <tr><td>tryLock(timeout)</td><td>❌</td><td>✅</td></tr>\n        <tr><td>Interruptible lock</td><td>❌</td><td>✅ lockInterruptibly()</td></tr>\n        <tr><td>Fairness</td><td>❌</td><td>✅ new ReentrantLock(true)</td></tr>\n        <tr><td>Nhiều Condition</td><td>❌</td><td>✅ newCondition()</td></tr>\n      </table>\n      <div class=\"code-block\">ReentrantLock lock = <span class=\"kw\">new</span> ReentrantLock();\n<span class=\"kw\">try</span> {\n    <span class=\"kw\">if</span> (lock.tryLock(<span class=\"num\">1</span>, TimeUnit.SECONDS)) {\n        <span class=\"kw\">try</span> { doWork(); }\n        <span class=\"kw\">finally</span> { lock.unlock(); } <span class=\"cm\">// PHẢI gọi trong finally!</span>\n    }\n} <span class=\"kw\">catch</span> (InterruptedException e) { ... }</div>\n      <div class=\"tip-box\">💡 Dùng synchronized khi đủ đơn giản. Dùng ReentrantLock khi cần timeout, interruptible, fairness hoặc multiple conditions.</div>",
    "tags": "java thread",
    "level": "senior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 34,
    "numStr": "34",
    "question": "Atomic classes là gì?",
    "answerHtml": "<p>Các class trong <code>java.util.concurrent.atomic</code> thực hiện thao tác <strong>thread-safe không cần synchronized</strong>, dùng <strong>CAS (Compare-And-Swap)</strong> ở CPU level — nhanh hơn synchronized.</p>\n      <div class=\"code-block\"><span class=\"cm\">// Không thread-safe</span>\n<span class=\"kw\">int</span> count = <span class=\"num\">0</span>;\ncount++;  <span class=\"cm\">// 3 bước: read, increment, write → race condition</span>\n\n<span class=\"cm\">// Thread-safe với AtomicInteger</span>\nAtomicInteger count = <span class=\"kw\">new</span> AtomicInteger(<span class=\"num\">0</span>);\ncount.incrementAndGet();           <span class=\"cm\">// atomic, không cần synchronized</span>\ncount.compareAndSet(<span class=\"num\">5</span>, <span class=\"num\">10</span>);       <span class=\"cm\">// chỉ set 10 nếu hiện tại là 5</span></div>\n      <p><strong>Các class phổ biến:</strong> AtomicInteger, AtomicLong, AtomicBoolean, AtomicReference, LongAdder (hiệu năng cao hơn trong high-contention).</p>",
    "tags": "java thread",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 136,
    "numStr": "136",
    "question": "CompletableFuture là gì? Dùng thế nào?",
    "answerHtml": "<p><code>CompletableFuture</code> (Java 8+) cho phép lập trình <strong>bất đồng bộ (async)</strong> và <strong>kết hợp nhiều task</strong> dễ dàng hơn <code>Future</code>. Không cần block thread để đợi kết quả.</p>\n      <table class=\"compare-table\">\n        <tr><th>Method</th><th>Dùng để</th></tr>\n        <tr><td>thenApply(fn)</td><td>Transform kết quả (giống map trong Stream)</td></tr>\n        <tr><td>thenAccept(fn)</td><td>Consume kết quả, không trả về</td></tr>\n        <tr><td>thenCompose(fn)</td><td>Chain 2 CompletableFuture (giống flatMap)</td></tr>\n        <tr><td>thenCombine(cf, fn)</td><td>Kết hợp 2 future song song</td></tr>\n        <tr><td>allOf(...)</td><td>Chờ tất cả future hoàn thành</td></tr>\n        <tr><td>exceptionally(fn)</td><td>Xử lý exception (như catch)</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// Async gọi 2 API song song, combine kết quả</span>\nCompletableFuture&lt;User&gt; userFuture = CompletableFuture\n    .supplyAsync(() -&gt; userService.findById(<span class=\"num\">1L</span>));\n\nCompletableFuture&lt;List&lt;Order&gt;&gt; orderFuture = CompletableFuture\n    .supplyAsync(() -&gt; orderService.findByUser(<span class=\"num\">1L</span>));\n\nCompletableFuture&lt;UserProfile&gt; profile = userFuture\n    .thenCombine(orderFuture, (user, orders) -&gt; <span class=\"kw\">new</span> UserProfile(user, orders));\n\n<span class=\"cm\">// Chain + error handling</span>\nCompletableFuture.supplyAsync(() -&gt; fetchData())\n    .thenApply(data -&gt; process(data))\n    .thenApply(result -&gt; save(result))\n    .exceptionally(ex -&gt; handleError(ex))\n    .thenAccept(System.out::println);</div>\n      <div class=\"tip-box\">💡 Mặc định dùng ForkJoinPool.commonPool(). Production nên truyền Executor riêng để kiểm soát số thread và tránh starvation.</div>",
    "tags": "java thread java8",
    "level": "senior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 137,
    "numStr": "137",
    "question": "Thread vs Process khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Process</th><th>Thread</th></tr>\n        <tr><td>Bộ nhớ</td><td>Không gian địa chỉ riêng biệt</td><td>Chia sẻ heap với các thread cùng process</td></tr>\n        <tr><td>Tạo</td><td>Nặng (fork OS)</td><td>Nhẹ hơn nhiều</td></tr>\n        <tr><td>Giao tiếp</td><td>IPC (pipe, socket, shared mem)</td><td>Trực tiếp qua shared memory</td></tr>\n        <tr><td>Fault isolation</td><td>✅ Process crash không ảnh hưởng nhau</td><td>❌ Thread crash có thể crash cả process</td></tr>\n        <tr><td>Ví dụ</td><td>JVM chạy = 1 process</td><td>Các thread trong ThreadPool</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 JVM (1 process) có thể chạy nhiều thread. Các microservice khác nhau là các process riêng biệt — lý do chúng fault-isolate nhau.</div>",
    "tags": "java thread",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 138,
    "numStr": "138",
    "question": "Livelock là gì? Khác Deadlock thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Deadlock</th><th>Livelock</th></tr>\n        <tr><td>Thread state</td><td>BLOCKED (dừng chờ)</td><td>RUNNING (đang chạy, nhưng vô ích)</td></tr>\n        <tr><td>Tiến triển</td><td>Không có</td><td>Không có (dù thread vẫn active)</td></tr>\n        <tr><td>CPU</td><td>Thấp (không làm gì)</td><td>Cao (busy loop)</td></tr>\n        <tr><td>Phát hiện</td><td>Thread dump: BLOCKED state</td><td>Khó hơn, CPU cao nhưng không progress</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// Livelock: 2 người nhường nhau mãi (đi lại không thoát)</span>\n<span class=\"kw\">while</span> (!done) {\n    <span class=\"kw\">if</span> (other.isMovingLeft()) {\n        moveRight(); <span class=\"cm\">// tránh bên phải</span>\n    } <span class=\"kw\">else</span> {\n        moveLeft();  <span class=\"cm\">// nhưng other cũng tránh → lặp mãi</span>\n    }\n}</div>\n      <div class=\"tip-box\">💡 Cách fix Livelock: thêm randomized backoff (chờ ngẫu nhiên trước khi retry) để phá vỡ sự đồng bộ giữa các thread.</div>",
    "tags": "java thread",
    "level": "senior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 139,
    "numStr": "139",
    "question": "Race Condition là gì? Cách phòng tránh?",
    "answerHtml": "<p>Race Condition xảy ra khi 2+ thread cùng truy cập <strong>shared resource</strong> mà không có đồng bộ hoá → kết quả phụ thuộc vào thứ tự thực hiện (không đoán trước được).</p>\n      <div class=\"code-block\"><span class=\"cm\">// ❌ Race condition: 2 thread cùng đọc-ghi count</span>\n<span class=\"kw\">int</span> count = <span class=\"num\">0</span>;\n<span class=\"cm\">// Thread A: read count=5, Thread B: read count=5</span>\n<span class=\"cm\">// Thread A: write count=6, Thread B: write count=6  ← mất 1 lần increment!</span>\n\n<span class=\"cm\">// ✅ Fix 1: synchronized</span>\n<span class=\"kw\">synchronized void</span> increment() { count++; }\n\n<span class=\"cm\">// ✅ Fix 2: AtomicInteger (tốt hơn - dùng CAS)</span>\nAtomicInteger count = <span class=\"kw\">new</span> AtomicInteger(<span class=\"num\">0</span>);\ncount.incrementAndGet();\n\n<span class=\"cm\">// ✅ Fix 3: dùng concurrent collection</span>\nConcurrentHashMap, CopyOnWriteArrayList...</div>\n      <div class=\"warn-box\">⚠️ Race condition rất khó reproduce (chỉ xuất hiện trong điều kiện specific). Luôn design thread-safe từ đầu thay vì debug sau.</div>",
    "tags": "java thread",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 140,
    "numStr": "140",
    "question": "Debug Deadlock trong production bằng cách nào?",
    "answerHtml": "<p><strong>Khi app bị \"treo\" hoặc response time tăng đột biến</strong>, có thể là deadlock. Quy trình xử lý:</p>\n      <div class=\"code-block\"><span class=\"cm\"># Bước 1: Lấy thread dump - tìm BLOCKED threads</span>\njstack &lt;PID&gt;                   <span class=\"cm\"># lấy thread dump từ process</span>\nkill -3 &lt;PID&gt;                  <span class=\"cm\"># hoặc signal SIGQUIT</span>\n\n<span class=\"cm\"># Bước 2: Tìm trong output</span>\n\"Found one Java-level deadlock:\"   <span class=\"cm\">← JVM tự detect!</span>\n\n<span class=\"cm\">  Thread-1: waiting to lock &lt;0x1234&gt; (held by Thread-2)</span>\n<span class=\"cm\">  Thread-2: waiting to lock &lt;0x5678&gt; (held by Thread-1)</span>\n\n<span class=\"cm\"># Bước 3: Với Spring Boot Actuator</span>\nGET /actuator/threaddump           <span class=\"cm\"># xem thread state qua HTTP</span></div>\n      <p><strong>Công cụ khác:</strong></p>\n      <ul>\n        <li><strong>VisualVM / JConsole:</strong> GUI để xem thread state và detect deadlock</li>\n        <li><strong>Async Profiler:</strong> Low-overhead profiling trong production</li>\n        <li><strong>APM tools:</strong> Datadog, New Relic tự alert khi phát hiện deadlock</li>\n      </ul>\n      <div class=\"tip-box\">💡 Prevention > Debug: dùng timeout lock (<code>tryLock(1s)</code>), nhất quán thứ tự acquire lock, tránh nested locks.</div>",
    "tags": "java thread",
    "level": "senior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 35,
    "numStr": "35",
    "question": "Lambda Expression là gì?",
    "answerHtml": "<p>Lambda là cú pháp ngắn gọn để implement <strong>Functional Interface</strong> (interface có đúng 1 abstract method), thay thế anonymous class dài dòng.</p>\n      <p><strong>Cú pháp:</strong> <code>(params) -&gt; { body }</code></p>\n      <div class=\"code-block\"><span class=\"cm\">// Trước Java 8 - dài dòng</span>\nRunnable r = <span class=\"kw\">new</span> Runnable() {\n    <span class=\"an\">@Override</span>\n    <span class=\"kw\">public void</span> <span class=\"fn\">run</span>() { System.out.println(<span class=\"st\">\"Hello\"</span>); }\n};\n\n<span class=\"cm\">// Lambda - gọn hơn rất nhiều</span>\nRunnable r = () -> System.out.println(<span class=\"st\">\"Hello\"</span>);\n\n<span class=\"cm\">// Với tham số</span>\nComparator&lt;String&gt; c = (a, b) -> a.compareTo(b);\nlist.sort((a, b) -> a.length() - b.length());</div>",
    "tags": "java java8",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Java 8+ Features"
  },
  {
    "num": 36,
    "numStr": "36",
    "question": "Functional Interface là gì?",
    "answerHtml": "<p>Interface có <strong>đúng 1 abstract method</strong>. Dùng <code>@FunctionalInterface</code> để compiler kiểm tra. Là nền tảng cho Lambda và Stream API.</p>\n      <table class=\"compare-table\">\n        <tr><th>Interface</th><th>Method</th><th>Dùng cho</th></tr>\n        <tr><td>Predicate&lt;T&gt;</td><td>test(T) → boolean</td><td>Điều kiện lọc</td></tr>\n        <tr><td>Function&lt;T,R&gt;</td><td>apply(T) → R</td><td>Chuyển đổi kiểu</td></tr>\n        <tr><td>Consumer&lt;T&gt;</td><td>accept(T) → void</td><td>Xử lý không trả về</td></tr>\n        <tr><td>Supplier&lt;T&gt;</td><td>get() → T</td><td>Tạo/cung cấp giá trị</td></tr>\n        <tr><td>BiFunction&lt;T,U,R&gt;</td><td>apply(T,U) → R</td><td>Function 2 input</td></tr>\n      </table>",
    "tags": "java java8",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Java 8+ Features"
  },
  {
    "num": 37,
    "numStr": "37",
    "question": "Stream API là gì?",
    "answerHtml": "<p>API xử lý collection theo phong cách <strong>functional/declarative</strong>: filter, transform, aggregate... Lazy evaluation (chỉ tính khi có terminal operation), hỗ trợ parallel.</p>\n      <p><strong>2 loại operation:</strong></p>\n      <ul>\n        <li><strong>Intermediate</strong> (lazy, trả về Stream): filter, map, sorted, distinct, limit, skip</li>\n        <li><strong>Terminal</strong> (trigger execution, trả về kết quả): collect, forEach, count, reduce, findFirst</li>\n      </ul>\n      <div class=\"code-block\">List&lt;String&gt; names = employees.stream()\n    .filter(e -> e.getSalary() > <span class=\"num\">5000</span>)       <span class=\"cm\">// intermediate</span>\n    .map(Employee::getName)                   <span class=\"cm\">// intermediate</span>\n    .sorted()                                 <span class=\"cm\">// intermediate</span>\n    .collect(Collectors.toList());            <span class=\"cm\">// terminal - pipeline chạy ở đây</span>\n\n<span class=\"cm\">// Parallel stream - xử lý song song</span>\n<span class=\"kw\">long</span> count = list.parallelStream()\n    .filter(s -> s.startsWith(<span class=\"st\">\"A\"</span>))\n    .count();</div>",
    "tags": "java java8",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Java 8+ Features"
  },
  {
    "num": 38,
    "numStr": "38",
    "question": "Optional là gì? Tại sao dùng?",
    "answerHtml": "<p>Optional là <strong>container có thể chứa hoặc không chứa giá trị</strong>, thay thế <code>null</code>. Buộc lập trình viên xử lý trường hợp không có giá trị một cách rõ ràng → tránh NullPointerException.</p>\n      <div class=\"code-block\"><span class=\"cm\">// Trước Optional - dễ quên check null</span>\nUser user = userRepo.findById(id);\nSystem.out.println(user.getName()); <span class=\"cm\">// NPE nếu user = null!</span>\n\n<span class=\"cm\">// Với Optional</span>\nOptional&lt;User&gt; optional = userRepo.findById(id);\n\noptional.isPresent();                           <span class=\"cm\">// check có value không</span>\noptional.get();                                 <span class=\"cm\">// lấy value (throws nếu empty)</span>\noptional.orElse(<span class=\"kw\">new</span> User(<span class=\"st\">\"default\"</span>));         <span class=\"cm\">// default nếu empty</span>\noptional.orElseThrow(() -> <span class=\"kw\">new</span> RuntimeException()); \noptional.map(User::getName).orElse(<span class=\"st\">\"Unknown\"</span>); <span class=\"cm\">// chain an toàn</span></div>\n      <div class=\"warn-box\">⚠️ Không dùng Optional làm field trong Entity hoặc method parameter. Chỉ dùng làm return type.</div>",
    "tags": "java java8",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Java 8+ Features"
  },
  {
    "num": 39,
    "numStr": "39",
    "question": "Method Reference là gì?",
    "answerHtml": "<p>Cú pháp ngắn hơn lambda khi lambda chỉ gọi một method có sẵn: <code>ClassName::methodName</code></p>\n      <table class=\"compare-table\">\n        <tr><th>Loại</th><th>Cú pháp</th><th>Tương đương lambda</th></tr>\n        <tr><td>Static method</td><td>Integer::parseInt</td><td>s -> Integer.parseInt(s)</td></tr>\n        <tr><td>Instance method (object)</td><td>str::toUpperCase</td><td>() -> str.toUpperCase()</td></tr>\n        <tr><td>Instance method (class)</td><td>String::toLowerCase</td><td>s -> s.toLowerCase()</td></tr>\n        <tr><td>Constructor</td><td>User::new</td><td>() -> new User()</td></tr>\n      </table>\n      <div class=\"code-block\">list.stream().map(String::toUpperCase).forEach(System.out::println);\n<span class=\"cm\">// thay vì: .map(s -> s.toUpperCase()).forEach(s -> System.out.println(s))</span></div>",
    "tags": "java java8",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Java 8+ Features"
  },
  {
    "num": 40,
    "numStr": "40",
    "question": "default method trong Interface là gì?",
    "answerHtml": "<p>Java 8 cho phép interface có method với <strong>implementation sẵn</strong> (default method). Mục đích chính: thêm tính năng mới vào interface mà không break các class đã implement.</p>\n      <div class=\"code-block\"><span class=\"kw\">interface</span> <span class=\"cl\">Collection</span>&lt;E&gt; {\n    <span class=\"cm\">// Trước Java 8: thêm method mới → tất cả impl phải update!</span>\n    \n    <span class=\"cm\">// Java 8: default method - có implementation sẵn</span>\n    <span class=\"kw\">default void</span> <span class=\"fn\">forEach</span>(Consumer&lt;E&gt; action) {\n        <span class=\"kw\">for</span> (E e : <span class=\"kw\">this</span>) action.accept(e);\n    }\n}\n<span class=\"cm\">// ArrayList, LinkedList... không cần thay đổi gì → backward compatible</span></div>\n      <div class=\"warn-box\">⚠️ Nếu class implement 2 interface có cùng default method → compile error! Phải override để resolve.</div>",
    "tags": "java java8",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Java 8+ Features"
  },
  {
    "num": 41,
    "numStr": "41",
    "question": "Heap vs Stack trong JVM?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Stack</th><th>Heap</th></tr>\n        <tr><td>Lưu gì</td><td>Stack frame, local variables, references</td><td>Objects, arrays</td></tr>\n        <tr><td>Per thread</td><td>✅ Mỗi thread 1 stack riêng</td><td>❌ Chia sẻ tất cả thread</td></tr>\n        <tr><td>Kích thước</td><td>Nhỏ (~512KB-1MB)</td><td>Lớn (theo -Xmx config)</td></tr>\n        <tr><td>Tốc độ</td><td>Rất nhanh (LIFO)</td><td>Chậm hơn</td></tr>\n        <tr><td>Quản lý</td><td>Tự động (pop khi method return)</td><td>GC thu hồi</td></tr>\n        <tr><td>Lỗi</td><td>StackOverflowError</td><td>OutOfMemoryError</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"kw\">void</span> <span class=\"fn\">method</span>() {\n    <span class=\"kw\">int</span> x = <span class=\"num\">5</span>;             <span class=\"cm\">// x lưu trong Stack</span>\n    String s = <span class=\"st\">\"hi\"</span>;      <span class=\"cm\">// reference s trong Stack, object \"hi\" trong Heap</span>\n    User u = <span class=\"kw\">new</span> User();  <span class=\"cm\">// reference u trong Stack, User object trong Heap</span>\n}</div>",
    "tags": "java jvm",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Memory & JVM"
  },
  {
    "num": 42,
    "numStr": "42",
    "question": "Garbage Collection hoạt động như thế nào?",
    "answerHtml": "<p>GC tự động thu hồi object trong Heap không còn được tham chiếu, dùng <strong>Generational GC</strong>:</p>\n      <div class=\"code-block\">Heap\n├── Young Generation\n│   ├── Eden Space     ← object mới tạo tại đây\n│   ├── Survivor S0    ← sống sót sau Minor GC\n│   └── Survivor S1\n├── Old Generation     ← object sống lâu được promote\n└── Metaspace          ← class metadata (Java 8+)</div>\n      <ul>\n        <li><strong>Minor GC:</strong> Dọn Young Generation, nhanh (~ms). Object sống sót được chuyển sang Survivor.</li>\n        <li><strong>Major/Full GC:</strong> Dọn Old Generation, chậm hơn → Stop-The-World pause.</li>\n        <li><strong>Thuật toán:</strong> G1GC (default Java 9+), ZGC (Java 15+, pause &lt;1ms), Shenandoah.</li>\n      </ul>",
    "tags": "java jvm",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Memory & JVM"
  },
  {
    "num": 43,
    "numStr": "43",
    "question": "String Pool là gì?",
    "answerHtml": "<p>Vùng nhớ đặc biệt trong Heap (Metaspace Java 7+) lưu <strong>String literals</strong>. Các String có cùng nội dung sẽ dùng chung 1 reference → tiết kiệm bộ nhớ.</p>\n      <div class=\"code-block\">String a = <span class=\"st\">\"hello\"</span>;       <span class=\"cm\">// Tạo trong String Pool</span>\nString b = <span class=\"st\">\"hello\"</span>;       <span class=\"cm\">// Trỏ đến cùng object trong Pool</span>\nSystem.out.println(a == b); <span class=\"cm\">// true - cùng reference từ pool</span>\n\nString c = <span class=\"kw\">new</span> String(<span class=\"st\">\"hello\"</span>); <span class=\"cm\">// Tạo mới trong Heap, ngoài pool</span>\nSystem.out.println(a == c);    <span class=\"cm\">// false</span>\nSystem.out.println(a == c.intern()); <span class=\"cm\">// true - intern() lấy từ pool</span></div>",
    "tags": "java jvm basics",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Memory & JVM"
  },
  {
    "num": 44,
    "numStr": "44",
    "question": "Strong, Weak, Soft, Phantom Reference khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th>Loại</th><th>GC thu hồi khi nào</th><th>Use case</th></tr>\n        <tr><td>Strong</td><td>Khi không còn reference</td><td>Mặc định mọi object</td></tr>\n        <tr><td>Soft</td><td>Chỉ khi sắp OutOfMemory</td><td>Memory-sensitive cache</td></tr>\n        <tr><td>Weak</td><td>Ngay khi GC chạy, dù còn memory</td><td>WeakHashMap, canonical mapping</td></tr>\n        <tr><td>Phantom</td><td>Sau khi finalize, trước khi thu hồi</td><td>Cleanup action, off-heap resources</td></tr>\n      </table>",
    "tags": "java jvm",
    "level": "senior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Memory & JVM"
  },
  {
    "num": 45,
    "numStr": "45",
    "question": "ClassLoader là gì?",
    "answerHtml": "<p>ClassLoader load file <code>.class</code> vào JVM. Dùng mô hình <strong>delegation</strong>: trước khi tự load, uỷ thác cho parent.</p>\n      <div class=\"code-block\">Bootstrap ClassLoader     <span class=\"cm\">← load java.lang, java.util...</span>\n    ↑ delegate\nExtension ClassLoader     <span class=\"cm\">← load thư viện trong ext/</span>\n    ↑ delegate\nApplication ClassLoader   <span class=\"cm\">← load classpath app</span>\n    ↑ delegate\nCustom ClassLoader        <span class=\"cm\">← load từ DB, network, encrypted jar...</span></div>\n      <div class=\"tip-box\">💡 Trong Spring Boot: có thêm ClassLoader riêng để load nested JARs trong fat JAR. Đây là lý do cần <code>spring-boot-loader</code>.</div>",
    "tags": "java jvm",
    "level": "senior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Memory & JVM"
  },
  {
    "num": 141,
    "numStr": "141",
    "question": "JIT Compiler là gì? Tại sao JVM khởi động chậm nhưng sau đó nhanh?",
    "answerHtml": "<p><strong>JIT (Just-In-Time) Compiler</strong> biên dịch bytecode thành <strong>native machine code</strong> tại runtime — chỉ với những method được gọi nhiều lần (<em>hot spots</em>). Đây là lý do Java nhanh sau khi \"warm up\".</p>\n      <div class=\"code-block\">JVM lifecycle:\n1. Load .class → bytecode (interpreted mode) ← CHẬM ban đầu\n2. JIT phát hiện \"hot method\" (gọi nhiều lần)\n3. JIT compile hot method → native code + cache\n4. Lần sau gọi → chạy native code trực tiếp ← NHANH\n\nThreshold mặc định: ~10,000 lần gọi = hot method</div>\n      <ul>\n        <li><strong>C1 Compiler (Client):</strong> Compile nhanh, ít optimize — cho startup nhanh</li>\n        <li><strong>C2 Compiler (Server):</strong> Compile chậm hơn nhưng optimize sâu hơn — performance đỉnh</li>\n        <li><strong>Tiered Compilation (default Java 8+):</strong> Dùng C1 trước → sau đó C2 cho hot spots</li>\n      </ul>\n      <div class=\"tip-box\">💡 Đây là lý do khi load test Spring Boot app: 5 phút đầu chậm hơn, sau đó \"warm up\" xong và throughput tăng đáng kể.</div>",
    "tags": "java jvm",
    "level": "senior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Memory & JVM"
  },
  {
    "num": 142,
    "numStr": "142",
    "question": "JVM Tuning — các JVM flags quan trọng là gì?",
    "answerHtml": "<div class=\"code-block\"><span class=\"cm\"># Memory sizing</span>\n-Xms512m          <span class=\"cm\"># Initial heap size (tránh resize liên tục)</span>\n-Xmx2g            <span class=\"cm\"># Max heap size</span>\n-Xss512k          <span class=\"cm\"># Stack size mỗi thread</span>\n-XX:MetaspaceSize=256m   <span class=\"cm\"># Initial Metaspace</span>\n\n<span class=\"cm\"># GC Collector</span>\n-XX:+UseG1GC      <span class=\"cm\"># G1GC (default Java 9+) - balanced</span>\n-XX:+UseZGC       <span class=\"cm\"># ZGC (Java 15+) - ultra-low pause (&lt;1ms)</span>\n-XX:MaxGCPauseMillis=200  <span class=\"cm\"># G1: target pause time</span>\n\n<span class=\"cm\"># GC Logging (để debug GC issues)</span>\n-Xlog:gc*:file=/logs/gc.log:time,uptime:filecount=5,filesize=20m\n\n<span class=\"cm\"># Heap dump khi OOM</span>\n-XX:+HeapDumpOnOutOfMemoryError\n-XX:HeapDumpPath=/dumps/heap.hprof\n\n<span class=\"cm\"># Spring Boot production recommended</span>\njava -Xms512m -Xmx1g -XX:+UseG1GC -XX:+HeapDumpOnOutOfMemoryError \\\n     -jar app.jar</div>\n      <table class=\"compare-table\">\n        <tr><th>Vấn đề</th><th>Dấu hiệu</th><th>Tuning</th></tr>\n        <tr><td>High GC time</td><td>CPU spike định kỳ</td><td>Tăng heap, dùng G1GC</td></tr>\n        <tr><td>OOM Heap</td><td>OutOfMemoryError</td><td>Tăng -Xmx, tìm memory leak</td></tr>\n        <tr><td>High latency</td><td>GC pause lớn</td><td>Dùng ZGC/Shenandoah</td></tr>\n        <tr><td>Slow startup</td><td>Khởi động lâu</td><td>CDS, GraalVM native image</td></tr>\n      </table>",
    "tags": "java jvm",
    "level": "senior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Memory & JVM"
  },
  {
    "num": 46,
    "numStr": "46",
    "question": "Singleton Pattern là gì? Implement thread-safe?",
    "answerHtml": "<p>Đảm bảo một class <strong>chỉ có duy nhất 1 instance</strong> trong toàn bộ ứng dụng.</p>\n      <div class=\"code-block\"><span class=\"cm\">// Cách 1: Eager initialization - đơn giản, thread-safe</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">Config</span> {\n    <span class=\"kw\">private static final</span> <span class=\"cl\">Config</span> INSTANCE = <span class=\"kw\">new</span> <span class=\"cl\">Config</span>();\n    <span class=\"kw\">private</span> <span class=\"fn\">Config</span>() {}\n    <span class=\"kw\">public static</span> <span class=\"cl\">Config</span> <span class=\"fn\">getInstance</span>() { <span class=\"kw\">return</span> INSTANCE; }\n}\n\n<span class=\"cm\">// Cách 2: Enum Singleton - best practice, safe với serialization</span>\n<span class=\"kw\">public enum</span> <span class=\"cl\">Database</span> {\n    INSTANCE;\n    <span class=\"kw\">public void</span> <span class=\"fn\">connect</span>() { ... }\n}\n\n<span class=\"cm\">// Cách 3: Double-checked locking (Lazy + thread-safe)</span>\n<span class=\"kw\">private static volatile</span> <span class=\"cl\">Config</span> instance;\n<span class=\"kw\">public static</span> <span class=\"cl\">Config</span> <span class=\"fn\">getInstance</span>() {\n    <span class=\"kw\">if</span> (instance == <span class=\"kw\">null</span>) {\n        <span class=\"kw\">synchronized</span> (<span class=\"cl\">Config</span>.<span class=\"kw\">class</span>) {\n            <span class=\"kw\">if</span> (instance == <span class=\"kw\">null</span>) instance = <span class=\"kw\">new</span> <span class=\"cl\">Config</span>();\n        }\n    }\n    <span class=\"kw\">return</span> instance;\n}</div>",
    "tags": "java pattern",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Design Patterns & Misc"
  },
  {
    "num": 47,
    "numStr": "47",
    "question": "Immutable class là gì? Tạo như thế nào?",
    "answerHtml": "<p>Immutable class là class mà <strong>state không thể thay đổi</strong> sau khi tạo. Ví dụ có sẵn: String, Integer, LocalDate.</p>\n      <p><strong>5 quy tắc tạo Immutable class:</strong></p>\n      <ul>\n        <li>Khai báo class là <code>final</code></li>\n        <li>Tất cả field là <code>private final</code></li>\n        <li>Không có setter</li>\n        <li>Khởi tạo qua constructor</li>\n        <li>Nếu field là mutable object (List, Date) → trả về <strong>defensive copy</strong></li>\n      </ul>\n      <div class=\"code-block\"><span class=\"kw\">public final class</span> <span class=\"cl\">Money</span> {\n    <span class=\"kw\">private final double</span> amount;\n    <span class=\"kw\">private final</span> String currency;\n    <span class=\"kw\">private final</span> List&lt;String&gt; tags;\n\n    <span class=\"kw\">public</span> <span class=\"fn\">Money</span>(<span class=\"kw\">double</span> amount, String currency, List&lt;String&gt; tags) {\n        <span class=\"kw\">this</span>.amount = amount;\n        <span class=\"kw\">this</span>.currency = currency;\n        <span class=\"kw\">this</span>.tags = <span class=\"kw\">new</span> ArrayList&lt;&gt;(tags); <span class=\"cm\">// defensive copy!</span>\n    }\n    \n    <span class=\"kw\">public</span> List&lt;String&gt; <span class=\"fn\">getTags</span>() {\n        <span class=\"kw\">return</span> Collections.unmodifiableList(tags); <span class=\"cm\">// trả về view chỉ đọc</span>\n    }\n}</div>",
    "tags": "java pattern",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Design Patterns & Misc"
  },
  {
    "num": 48,
    "numStr": "48",
    "question": "Serialization là gì?",
    "answerHtml": "<p>Serialization là quá trình <strong>chuyển object thành byte stream</strong> để lưu vào file/DB hoặc truyền qua network. Deserialization là chiều ngược lại.</p>\n      <div class=\"code-block\"><span class=\"kw\">class</span> <span class=\"cl\">User</span> <span class=\"kw\">implements</span> Serializable {\n    <span class=\"kw\">private static final long</span> serialVersionUID = <span class=\"num\">1L</span>; <span class=\"cm\">// version control</span>\n    String name;\n    <span class=\"kw\">transient</span> String password; <span class=\"cm\">// transient = không serialize field này</span>\n}\n\n<span class=\"cm\">// Serialize</span>\nObjectOutputStream oos = <span class=\"kw\">new</span> ObjectOutputStream(<span class=\"kw\">new</span> FileOutputStream(<span class=\"st\">\"user.dat\"</span>));\noos.writeObject(user);\n\n<span class=\"cm\">// Deserialize</span>\nObjectInputStream ois = <span class=\"kw\">new</span> ObjectInputStream(<span class=\"kw\">new</span> FileInputStream(<span class=\"st\">\"user.dat\"</span>));\nUser loaded = (User) ois.readObject();</div>\n      <div class=\"tip-box\">💡 Trong web API, Jackson serialize object thành JSON, không cần implement Serializable.</div>",
    "tags": "java basics",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Design Patterns & Misc"
  },
  {
    "num": 49,
    "numStr": "49",
    "question": "Java Reflection là gì?",
    "answerHtml": "<p>Reflection API cho phép <strong>inspect và thay đổi class/method/field tại runtime</strong> mà không cần biết tên ở compile time. Là nền tảng của Spring, Hibernate, Jackson.</p>\n      <div class=\"code-block\">Class&lt;?&gt; clazz = Class.forName(<span class=\"st\">\"com.example.User\"</span>);\n\n<span class=\"cm\">// Xem tất cả method</span>\nMethod[] methods = clazz.getDeclaredMethods();\n\n<span class=\"cm\">// Gọi method private</span>\nMethod m = clazz.getDeclaredMethod(<span class=\"st\">\"getName\"</span>);\nm.setAccessible(<span class=\"kw\">true</span>);   <span class=\"cm\">// bypass access control</span>\nString name = (String) m.invoke(userObject);\n\n<span class=\"cm\">// Đọc/ghi field</span>\nField f = clazz.getDeclaredField(<span class=\"st\">\"age\"</span>);\nf.setAccessible(<span class=\"kw\">true</span>);\nf.set(userObject, <span class=\"num\">25</span>);</div>\n      <div class=\"warn-box\">⚠️ Reflection chậm hơn (~10x), bỏ qua access control, khó debug. Chỉ dùng trong framework/library, không dùng trong business code thường ngày.</div>",
    "tags": "java basics",
    "level": "senior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Design Patterns & Misc"
  },
  {
    "num": 50,
    "numStr": "50",
    "question": "try-catch có ảnh hưởng hiệu năng không?",
    "answerHtml": "<p><strong>try block bình thường: gần như không có overhead</strong> (JVM tối ưu rất tốt).</p>\n      <p>Overhead xảy ra khi <strong>exception thực sự được throw</strong>:</p>\n      <ul>\n        <li>JVM tạo stack trace → tốn kém O(depth of call stack)</li>\n        <li>Tạo Exception object, fill stack frames</li>\n      </ul>\n      <div class=\"warn-box\">⚠️ Anti-pattern: dùng exception để kiểm soát luồng bình thường (if/else) → rất chậm! Exception nên chỉ dùng cho trường hợp <em>bất thường</em>, không phải flow thông thường.</div>\n      <div class=\"code-block\"><span class=\"cm\">// BAD - dùng exception thay if</span>\n<span class=\"kw\">try</span> {\n    <span class=\"kw\">int</span> value = Integer.parseInt(str);\n} <span class=\"kw\">catch</span> (NumberFormatException e) {\n    value = <span class=\"num\">0</span>; <span class=\"cm\">// chậm nếu str thường xuyên không phải số</span>\n}\n\n<span class=\"cm\">// GOOD</span>\n<span class=\"kw\">int</span> value = str.matches(<span class=\"st\">\"-?\\\\d+\"</span>) ? Integer.parseInt(str) : <span class=\"num\">0</span>;</div>",
    "tags": "java basics",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Design Patterns & Misc"
  },
  {
    "num": 51,
    "numStr": "51",
    "question": "Spring Boot là gì? Khác gì với Spring Framework?",
    "answerHtml": "<p><strong>Spring Framework</strong> là framework nền tảng: mạnh mẽ nhưng cần nhiều config XML/Java phức tạp.</p>\n      <p><strong>Spring Boot</strong> = Spring Framework + <em>\"convention over configuration\"</em>:</p>\n      <ul>\n        <li>✅ <strong>Auto-configuration:</strong> Tự detect classpath và cấu hình bean phù hợp</li>\n        <li>✅ <strong>Starter dependencies:</strong> Bundle thư viện liên quan vào 1 dependency</li>\n        <li>✅ <strong>Embedded server:</strong> Tomcat/Jetty tích hợp sẵn — chạy <code>java -jar</code> là xong</li>\n        <li>✅ <strong>Actuator:</strong> Monitoring endpoints sẵn có</li>\n        <li>✅ Không cần XML config, không cần deploy WAR</li>\n      </ul>",
    "tags": "spring core",
    "level": "junior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 52,
    "numStr": "52",
    "question": "@SpringBootApplication gồm những annotation nào?",
    "answerHtml": "<p><code>@SpringBootApplication</code> là meta-annotation gộp 3 annotation:</p>\n      <ul>\n        <li><code>@Configuration</code>: Đánh dấu class là nguồn bean config</li>\n        <li><code>@EnableAutoConfiguration</code>: Kích hoạt auto-configuration</li>\n        <li><code>@ComponentScan</code>: Tự động scan tìm component trong package hiện tại và sub-package</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"an\">@SpringBootApplication</span>  <span class=\"cm\">// = 3 annotation dưới đây</span>\n<span class=\"cm\">// @Configuration</span>\n<span class=\"cm\">// @EnableAutoConfiguration</span>\n<span class=\"cm\">// @ComponentScan(basePackages = \"com.example\")</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">Application</span> {\n    <span class=\"kw\">public static void</span> <span class=\"fn\">main</span>(String[] args) {\n        SpringApplication.run(<span class=\"cl\">Application</span>.<span class=\"kw\">class</span>, args);\n    }\n}</div>",
    "tags": "spring core",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 53,
    "numStr": "53",
    "question": "Auto-configuration hoạt động như thế nào?",
    "answerHtml": "<p>Khi Spring Boot khởi động, <code>@EnableAutoConfiguration</code> kích hoạt cơ chế scan file cấu hình auto-config, sau đó dùng <code>@Conditional</code> để quyết định có tạo bean hay không.</p>\n      <div class=\"code-block\"><span class=\"cm\">// Spring Boot đọc file này (Boot 3.x):</span>\nMETA-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports\n\n<span class=\"cm\">// Mỗi auto-config class có điều kiện:</span>\n<span class=\"an\">@ConditionalOnClass</span>(DataSource.<span class=\"kw\">class</span>)    <span class=\"cm\">// có class này trong classpath?</span>\n<span class=\"an\">@ConditionalOnMissingBean</span>(DataSource.<span class=\"kw\">class</span>) <span class=\"cm\">// chưa có bean nào tự định nghĩa?</span>\n<span class=\"an\">@ConditionalOnProperty</span>(name = <span class=\"st\">\"spring.datasource.url\"</span>)</div>\n      <div class=\"tip-box\">💡 Debug auto-config: chạy với flag <code>--debug</code> hoặc thêm <code>logging.level.org.springframework.boot.autoconfigure=DEBUG</code> để thấy bean nào được/không được tạo.</div>",
    "tags": "spring core",
    "level": "senior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 54,
    "numStr": "54",
    "question": "Dependency Injection là gì?",
    "answerHtml": "<p>DI là pattern trong đó object <strong>không tự tạo dependency</strong> — thay vào đó, container (Spring) cung cấp (inject) từ bên ngoài. Đảo ngược quyền kiểm soát (IoC).</p>\n      <table class=\"compare-table\">\n        <tr><th>Cách inject</th><th>Ưu điểm</th><th>Nhược điểm</th></tr>\n        <tr><td>Constructor injection ✅</td><td>Immutable, dễ test, phát hiện circular dep sớm</td><td>Nhiều dependency → constructor dài</td></tr>\n        <tr><td>Setter injection</td><td>Optional dependency</td><td>Mutable, dễ quên inject</td></tr>\n        <tr><td>Field injection ❌</td><td>Ngắn gọn</td><td>Khó test, không rõ dependency, dùng reflection</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// ✅ Constructor injection - khuyến khích</span>\n<span class=\"an\">@Service</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">OrderService</span> {\n    <span class=\"kw\">private final</span> <span class=\"cl\">OrderRepository</span> orderRepo;\n    <span class=\"kw\">private final</span> <span class=\"cl\">PaymentService</span> paymentService;\n\n    <span class=\"cm\">// Spring tự inject khi có 1 constructor (không cần @Autowired)</span>\n    <span class=\"kw\">public</span> <span class=\"fn\">OrderService</span>(<span class=\"cl\">OrderRepository</span> orderRepo, <span class=\"cl\">PaymentService</span> paymentService) {\n        <span class=\"kw\">this</span>.orderRepo = orderRepo;\n        <span class=\"kw\">this</span>.paymentService = paymentService;\n    }\n}</div>",
    "tags": "spring core",
    "level": "junior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 55,
    "numStr": "55",
    "question": "IoC Container là gì?",
    "answerHtml": "<p><strong>IoC (Inversion of Control):</strong> Đảo ngược quyền kiểm soát — thay vì code tự tạo object, container đảm nhận việc tạo, quản lý vòng đời, inject dependency.</p>\n      <p>Spring IoC Container có 2 loại:</p>\n      <ul>\n        <li><code>BeanFactory</code>: Lazy, cơ bản, ít dùng trực tiếp</li>\n        <li><code>ApplicationContext</code>: Extends BeanFactory, thêm i18n, events, AOP, eager init. <strong>Đây là loại chính dùng trong Spring Boot.</strong></li>\n      </ul>\n      <div class=\"tip-box\">💡 Ví dụ thực tế: Bạn không viết <code>new UserService(new UserRepository(dataSource))</code> nữa — Spring tự làm điều đó, bạn chỉ cần khai báo.</div>",
    "tags": "spring core",
    "level": "junior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 56,
    "numStr": "56",
    "question": "Bean là gì?",
    "answerHtml": "<p>Bean là <strong>object được Spring IoC Container quản lý</strong> (tạo, khởi tạo, inject dependency, destroy). Không phải mọi object Java đều là bean — chỉ những object được register với container.</p>\n      <p><strong>Cách khai báo bean:</strong></p>\n      <ul>\n        <li><code>@Component</code>, <code>@Service</code>, <code>@Repository</code>, <code>@Controller</code> → Spring tự scan</li>\n        <li><code>@Bean</code> trong <code>@Configuration</code> class → Manual config, dùng cho third-party class</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"cm\">// Cách 1: @Component (Spring scan tự động)</span>\n<span class=\"an\">@Service</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">UserService</span> { ... }\n\n<span class=\"cm\">// Cách 2: @Bean (khi không thể sửa source class)</span>\n<span class=\"an\">@Configuration</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">AppConfig</span> {\n    <span class=\"an\">@Bean</span>\n    <span class=\"kw\">public</span> ObjectMapper <span class=\"fn\">objectMapper</span>() {\n        <span class=\"kw\">return new</span> ObjectMapper()\n            .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, <span class=\"kw\">false</span>);\n    }\n}</div>",
    "tags": "spring core",
    "level": "intern",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 57,
    "numStr": "57",
    "question": "@Component vs @Service vs @Repository vs @Controller khác nhau thế nào?",
    "answerHtml": "<p>Về chức năng DI cơ bản: <strong>giống nhau</strong> (đều là Component). Khác nhau về semantic và tính năng bổ sung:</p>\n      <table class=\"compare-table\">\n        <tr><th>Annotation</th><th>Layer</th><th>Tính năng đặc biệt</th></tr>\n        <tr><td>@Component</td><td>Generic</td><td>Không có gì đặc biệt thêm</td></tr>\n        <tr><td>@Service</td><td>Business Logic</td><td>Semantic rõ ràng, không có thêm tính năng kỹ thuật</td></tr>\n        <tr><td>@Repository</td><td>Data Access</td><td>✅ Tự động translate SQL Exception → DataAccessException</td></tr>\n        <tr><td>@Controller</td><td>Web Layer</td><td>✅ Hỗ trợ @RequestMapping, trả về view name</td></tr>\n        <tr><td>@RestController</td><td>Web Layer</td><td>✅ = @Controller + @ResponseBody</td></tr>\n      </table>",
    "tags": "spring core",
    "level": "intern",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 58,
    "numStr": "58",
    "question": "Bean Scope là gì? Các loại scope?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th>Scope</th><th>Số instance</th><th>Khi nào dùng</th></tr>\n        <tr><td><strong>Singleton</strong> (default)</td><td>1 cho toàn container</td><td>Service, Repository, thường dùng nhất</td></tr>\n        <tr><td><strong>Prototype</strong></td><td>Mới mỗi lần inject/getBean</td><td>Object có state, không thread-safe</td></tr>\n        <tr><td><strong>Request</strong></td><td>1 cho mỗi HTTP request</td><td>Web app - lưu request context</td></tr>\n        <tr><td><strong>Session</strong></td><td>1 cho mỗi HTTP session</td><td>Web app - user session data</td></tr>\n        <tr><td><strong>Application</strong></td><td>1 cho mỗi ServletContext</td><td>Shared giữa sessions</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"an\">@Service</span>\n<span class=\"an\">@Scope</span>(<span class=\"st\">\"prototype\"</span>)  <span class=\"cm\">// hoặc @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">TaskProcessor</span> { ... }</div>\n      <div class=\"warn-box\">⚠️ Inject Prototype bean vào Singleton bean → vẫn chỉ lấy 1 instance (vì Singleton chỉ inject 1 lần). Dùng <code>@Lookup</code> hoặc <code>ApplicationContext.getBean()</code> để giải quyết.</div>",
    "tags": "spring core",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 59,
    "numStr": "59",
    "question": "@Autowired hoạt động như thế nào?",
    "answerHtml": "<p>Spring inject dependency <strong>theo type</strong>. Nếu tìm thấy đúng 1 bean → inject. Nhiều bean cùng type → cần <code>@Qualifier</code>. Không tìm thấy → Exception (trừ <code>@Autowired(required = false)</code>).</p>\n      <div class=\"code-block\"><span class=\"cm\">// Field injection (không khuyến khích)</span>\n<span class=\"an\">@Autowired</span>\n<span class=\"kw\">private</span> UserRepository userRepo;\n\n<span class=\"cm\">// Constructor injection (khuyến khích - không cần @Autowired nếu 1 constructor)</span>\n<span class=\"kw\">public</span> <span class=\"fn\">UserService</span>(UserRepository userRepo) {\n    <span class=\"kw\">this</span>.userRepo = userRepo;\n}\n\n<span class=\"cm\">// Optional dependency</span>\n<span class=\"an\">@Autowired</span>(required = <span class=\"kw\">false</span>)\n<span class=\"kw\">private</span> CacheService cacheService; <span class=\"cm\">// null nếu không có bean</span></div>",
    "tags": "spring core",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 60,
    "numStr": "60",
    "question": "@Qualifier dùng để làm gì?",
    "answerHtml": "<p>Khi có <strong>nhiều bean cùng type</strong>, Spring không biết inject cái nào → Exception. <code>@Qualifier</code> chỉ định tên bean cụ thể cần dùng.</p>\n      <div class=\"code-block\"><span class=\"an\">@Service</span>(<span class=\"st\">\"emailNotifier\"</span>)\n<span class=\"kw\">class</span> <span class=\"cl\">EmailNotificationService</span> <span class=\"kw\">implements</span> <span class=\"cl\">NotificationService</span> { ... }\n\n<span class=\"an\">@Service</span>(<span class=\"st\">\"smsNotifier\"</span>)\n<span class=\"kw\">class</span> <span class=\"cl\">SmsNotificationService</span> <span class=\"kw\">implements</span> <span class=\"cl\">NotificationService</span> { ... }\n\n<span class=\"cm\">// Inject bean cụ thể</span>\n<span class=\"kw\">public</span> <span class=\"fn\">OrderService</span>(<span class=\"an\">@Qualifier</span>(<span class=\"st\">\"emailNotifier\"</span>) NotificationService notifier) {\n    <span class=\"kw\">this</span>.notifier = notifier;\n}</div>",
    "tags": "spring core",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 61,
    "numStr": "61",
    "question": "@Primary dùng để làm gì?",
    "answerHtml": "<p>Khi có nhiều bean cùng type, đánh dấu 1 bean là <strong>ưu tiên mặc định</strong> — Spring inject bean này nếu không có <code>@Qualifier</code> cụ thể.</p>\n      <div class=\"code-block\"><span class=\"an\">@Service</span>\n<span class=\"an\">@Primary</span>  <span class=\"cm\">// bean này được inject mặc định</span>\n<span class=\"kw\">class</span> <span class=\"cl\">EmailNotificationService</span> <span class=\"kw\">implements</span> <span class=\"cl\">NotificationService</span> { ... }\n\n<span class=\"an\">@Service</span>\n<span class=\"kw\">class</span> <span class=\"cl\">SmsNotificationService</span> <span class=\"kw\">implements</span> <span class=\"cl\">NotificationService</span> { ... }\n\n<span class=\"cm\">// Không cần @Qualifier → nhận EmailNotificationService</span>\n<span class=\"kw\">public</span> <span class=\"fn\">OrderService</span>(NotificationService notifier) { ... }</div>",
    "tags": "spring core",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 62,
    "numStr": "62",
    "question": "Constructor injection vs Field injection — cái nào tốt hơn?",
    "answerHtml": "<p><strong>Constructor injection được khuyến khích</strong> bởi cả Spring team và Baeldung:</p>\n      <table class=\"compare-table\">\n        <tr><th>Tiêu chí</th><th>Constructor ✅</th><th>Field ❌</th></tr>\n        <tr><td>Immutable</td><td>✅ final field</td><td>❌</td></tr>\n        <tr><td>Dễ Unit Test</td><td>✅ Tự tạo object thường</td><td>❌ Phải dùng reflection/Mockito</td></tr>\n        <tr><td>Circular Dependency</td><td>✅ Phát hiện khi start</td><td>❌ Khó phát hiện</td></tr>\n        <tr><td>Rõ dependency</td><td>✅ Thấy ngay ở constructor</td><td>❌ Ẩn trong field</td></tr>\n        <tr><td>Không cần Spring context khi test</td><td>✅</td><td>❌</td></tr>\n      </table>",
    "tags": "spring core",
    "level": "senior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 63,
    "numStr": "63",
    "question": "Circular Dependency là gì? Cách xử lý?",
    "answerHtml": "<p>Circular Dependency: A cần B để khởi tạo, B cần A để khởi tạo → Spring không biết tạo cái nào trước → Exception.</p>\n      <div class=\"code-block\"><span class=\"cm\">// Circular: A → B → A</span>\n<span class=\"kw\">class</span> <span class=\"cl\">A</span> { <span class=\"kw\">public</span> <span class=\"fn\">A</span>(<span class=\"cl\">B</span> b) { ... } }\n<span class=\"kw\">class</span> <span class=\"cl\">B</span> { <span class=\"kw\">public</span> <span class=\"fn\">B</span>(<span class=\"cl\">A</span> a) { ... } } <span class=\"cm\">// ❌ BeanCurrentlyInCreationException</span></div>\n      <p><strong>Cách giải quyết (theo thứ tự ưu tiên):</strong></p>\n      <ul>\n        <li>✅ <strong>Tái cấu trúc code</strong>: Tách ra class C chứa logic dùng chung → loại bỏ vòng lặp</li>\n        <li>✅ <strong>@Lazy</strong>: Một trong 2 bean lazy init → inject proxy trước, tạo thật khi dùng</li>\n        <li>⚠️ <strong>Setter injection</strong>: Spring tạo object trước, inject sau → phá vòng nhưng mutable</li>\n      </ul>",
    "tags": "spring core",
    "level": "senior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 64,
    "numStr": "64",
    "question": "DispatcherServlet là gì?",
    "answerHtml": "<p>DispatcherServlet là <strong>Front Controller</strong> trong Spring MVC. Mọi HTTP request đều đi qua đây trước khi được điều phối đến handler phù hợp.</p>\n      <div class=\"code-block\">HTTP Request\n    ↓\nDispatcherServlet\n    ↓\nHandlerMapping       <span class=\"cm\">← tìm controller phù hợp cho URL</span>\n    ↓\nHandlerAdapter       <span class=\"cm\">← gọi method của controller</span>\n    ↓\nController Method    <span class=\"cm\">← business logic, trả về data/view</span>\n    ↓\nViewResolver         <span class=\"cm\">← (nếu MVC) resolve tên view → template</span>\n    ↓\nHTTP Response</div>",
    "tags": "spring web",
    "level": "senior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring MVC & Web"
  },
  {
    "num": 65,
    "numStr": "65",
    "question": "@RestController vs @Controller khác nhau thế nào?",
    "answerHtml": "<p><code>@RestController</code> = <code>@Controller</code> + <code>@ResponseBody</code></p>\n      <table class=\"compare-table\">\n        <tr><th></th><th>@Controller</th><th>@RestController</th></tr>\n        <tr><td>Return giá trị</td><td>Tên view (String) → resolve thành HTML</td><td>Object → serialize thành JSON/XML</td></tr>\n        <tr><td>Cần @ResponseBody?</td><td>Có nếu muốn trả data</td><td>Mặc định có rồi</td></tr>\n        <tr><td>Dùng cho</td><td>Web MVC (Thymeleaf, JSP)</td><td>REST API</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"an\">@Controller</span>\n<span class=\"kw\">class</span> <span class=\"cl\">PageController</span> {\n    <span class=\"an\">@GetMapping</span>(<span class=\"st\">\"/home\"</span>)\n    String <span class=\"fn\">home</span>() { <span class=\"kw\">return</span> <span class=\"st\">\"home\"</span>; }  <span class=\"cm\">// → resolve \"home.html\"</span>\n}\n\n<span class=\"an\">@RestController</span>\n<span class=\"kw\">class</span> <span class=\"cl\">UserController</span> {\n    <span class=\"an\">@GetMapping</span>(<span class=\"st\">\"/api/users\"</span>)\n    List&lt;User&gt; <span class=\"fn\">getUsers</span>() { <span class=\"kw\">return</span> users; }  <span class=\"cm\">// → serialize thành JSON</span>\n}</div>",
    "tags": "spring web",
    "level": "junior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring MVC & Web"
  },
  {
    "num": 66,
    "numStr": "66",
    "question": "@PathVariable vs @RequestParam khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>@PathVariable</th><th>@RequestParam</th></tr>\n        <tr><td>Lấy từ đâu</td><td>URL path: /users/{id}</td><td>Query string: ?name=abc</td></tr>\n        <tr><td>Bắt buộc</td><td>Mặc định có</td><td>Tuỳ (required = false)</td></tr>\n        <tr><td>Default value</td><td>❌</td><td>✅ defaultValue = \"...\"</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// GET /users/42</span>\n<span class=\"an\">@GetMapping</span>(<span class=\"st\">\"/users/{id}\"</span>)\nUser <span class=\"fn\">getById</span>(<span class=\"an\">@PathVariable</span> Long id) { ... }\n\n<span class=\"cm\">// GET /users?page=1&size=10&sort=name</span>\n<span class=\"an\">@GetMapping</span>(<span class=\"st\">\"/users\"</span>)\nPage&lt;User&gt; <span class=\"fn\">getAll</span>(\n    <span class=\"an\">@RequestParam</span>(defaultValue = <span class=\"st\">\"0\"</span>) <span class=\"kw\">int</span> page,\n    <span class=\"an\">@RequestParam</span>(defaultValue = <span class=\"st\">\"10\"</span>) <span class=\"kw\">int</span> size,\n    <span class=\"an\">@RequestParam</span>(required = <span class=\"kw\">false</span>) String sort\n) { ... }</div>",
    "tags": "spring web",
    "level": "intern",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring MVC & Web"
  },
  {
    "num": 67,
    "numStr": "67",
    "question": "@RequestBody vs @ResponseBody?",
    "answerHtml": "<ul>\n        <li><code>@RequestBody</code>: Đọc HTTP request body → deserialize (thường từ JSON) thành Java object. Dùng <strong>HttpMessageConverter</strong> (Jackson mặc định).</li>\n        <li><code>@ResponseBody</code>: Serialize Java object → ghi vào HTTP response body (thường thành JSON). <code>@RestController</code> đã bao gồm sẵn.</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"an\">@PostMapping</span>(<span class=\"st\">\"/users\"</span>)\n<span class=\"an\">@ResponseBody</span>  <span class=\"cm\">// không cần nếu đã có @RestController</span>\nUser <span class=\"fn\">create</span>(<span class=\"an\">@RequestBody</span> <span class=\"an\">@Valid</span> CreateUserRequest request) {\n    <span class=\"cm\">// request tự động parse từ JSON body: {\"name\":\"John\",\"email\":\"...\"}</span>\n    <span class=\"kw\">return</span> userService.create(request);\n    <span class=\"cm\">// return value tự serialize thành JSON response</span>\n}</div>",
    "tags": "spring web",
    "level": "intern",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring MVC & Web"
  },
  {
    "num": 68,
    "numStr": "68",
    "question": "ResponseEntity là gì?",
    "answerHtml": "<p>ResponseEntity cho phép kiểm soát <strong>toàn bộ HTTP response</strong>: status code, headers, body. Hữu ích khi cần trả về HTTP status khác 200.</p>\n      <div class=\"code-block\"><span class=\"an\">@PostMapping</span>(<span class=\"st\">\"/users\"</span>)\nResponseEntity&lt;User&gt; <span class=\"fn\">create</span>(<span class=\"an\">@RequestBody</span> CreateUserRequest req) {\n    User user = userService.create(req);\n    <span class=\"kw\">return</span> ResponseEntity\n        .status(HttpStatus.CREATED)        <span class=\"cm\">// 201</span>\n        .header(<span class=\"st\">\"Location\"</span>, <span class=\"st\">\"/users/\"</span> + user.getId())\n        .body(user);\n}\n\n<span class=\"cm\">// Các shorthand phổ biến</span>\nResponseEntity.ok(data);                   <span class=\"cm\">// 200 + body</span>\nResponseEntity.created(uri).body(user);    <span class=\"cm\">// 201 + Location header</span>\nResponseEntity.noContent().build();        <span class=\"cm\">// 204</span>\nResponseEntity.notFound().build();         <span class=\"cm\">// 404</span></div>",
    "tags": "spring web",
    "level": "junior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring MVC & Web"
  },
  {
    "num": 69,
    "numStr": "69",
    "question": "Exception handling trong Spring Boot thế nào?",
    "answerHtml": "<p><strong>Cách 1: @ExceptionHandler trong Controller</strong> — chỉ áp dụng cho controller đó.</p>\n      <p><strong>Cách 2: @ControllerAdvice + @ExceptionHandler</strong> — global, áp dụng cho tất cả controller.</p>\n      <div class=\"code-block\"><span class=\"an\">@RestControllerAdvice</span>  <span class=\"cm\">// = @ControllerAdvice + @ResponseBody</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">GlobalExceptionHandler</span> {\n\n    <span class=\"an\">@ExceptionHandler</span>(UserNotFoundException.<span class=\"kw\">class</span>)\n    <span class=\"an\">@ResponseStatus</span>(HttpStatus.NOT_FOUND)\n    ErrorResponse <span class=\"fn\">handleNotFound</span>(UserNotFoundException ex) {\n        <span class=\"kw\">return new</span> ErrorResponse(<span class=\"st\">\"USER_NOT_FOUND\"</span>, ex.getMessage());\n    }\n\n    <span class=\"an\">@ExceptionHandler</span>(MethodArgumentNotValidException.<span class=\"kw\">class</span>)\n    <span class=\"an\">@ResponseStatus</span>(HttpStatus.BAD_REQUEST)\n    ErrorResponse <span class=\"fn\">handleValidation</span>(MethodArgumentNotValidException ex) {\n        <span class=\"kw\">var</span> errors = ex.getBindingResult().getFieldErrors()\n            .stream().map(e -> e.getField() + <span class=\"st\">\": \"</span> + e.getDefaultMessage())\n            .toList();\n        <span class=\"kw\">return new</span> ErrorResponse(<span class=\"st\">\"VALIDATION_FAILED\"</span>, errors.toString());\n    }\n}</div>",
    "tags": "spring web",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring MVC & Web"
  },
  {
    "num": 70,
    "numStr": "70",
    "question": "Filter vs Interceptor khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Filter (Servlet)</th><th>Interceptor (Spring MVC)</th></tr>\n        <tr><td>Level</td><td>Servlet container</td><td>Spring DispatcherServlet</td></tr>\n        <tr><td>Chạy khi nào</td><td>Trước cả DispatcherServlet</td><td>Sau DispatcherServlet, trước Controller</td></tr>\n        <tr><td>Truy cập Spring bean</td><td>Khó hơn</td><td>✅ Dễ dàng</td></tr>\n        <tr><td>Truy cập HandlerMethod</td><td>❌</td><td>✅</td></tr>\n        <tr><td>Dùng cho</td><td>CORS, encoding, security (Spring Security)</td><td>Auth check, logging, audit</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// Interceptor</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">AuthInterceptor</span> <span class=\"kw\">implements</span> HandlerInterceptor {\n    <span class=\"kw\">public boolean</span> <span class=\"fn\">preHandle</span>(HttpServletRequest req, HttpServletResponse res, Object handler) {\n        <span class=\"cm\">// Chạy TRƯỚC controller method</span>\n        <span class=\"cm\">// return false → dừng, không vào controller</span>\n        <span class=\"kw\">return</span> validateToken(req);\n    }\n    <span class=\"kw\">public void</span> <span class=\"fn\">postHandle</span>(...) { <span class=\"cm\">/* Sau controller, trước render view */</span> }\n    <span class=\"kw\">public void</span> <span class=\"fn\">afterCompletion</span>(...) { <span class=\"cm\">/* Sau tất cả, dọn dẹp */</span> }\n}</div>",
    "tags": "spring web",
    "level": "senior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring MVC & Web"
  },
  {
    "num": 71,
    "numStr": "71",
    "question": "JPA là gì? Hibernate liên quan thế nào?",
    "answerHtml": "<p><strong>JPA (Jakarta Persistence API)</strong> là <em>specification</em> — tập hợp interface và annotation chuẩn cho ORM (Object-Relational Mapping) trong Java.</p>\n      <p><strong>Hibernate</strong> là <em>implementation</em> phổ biến nhất của JPA — là thư viện thật sự làm việc với DB.</p>\n      <div class=\"code-block\">JPA (Specification / Interface)\n    ↑ implements\nHibernate (Implementation - default trong Spring Boot)\n    ↑ on top of\nJDBC (Low-level DB access)\n    ↑ connects to\nDatabase (MySQL, PostgreSQL...)</div>\n      <div class=\"tip-box\">💡 Bạn code theo JPA standard (annotation, EntityManager) → có thể đổi Hibernate sang EclipseLink mà không cần đổi code business.</div>",
    "tags": "spring jpa",
    "level": "junior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Data JPA"
  },
  {
    "num": 72,
    "numStr": "72",
    "question": "@Entity, @Table, @Column dùng để làm gì?",
    "answerHtml": "<div class=\"code-block\"><span class=\"an\">@Entity</span>                           <span class=\"cm\">// đánh dấu class là JPA entity → map với table</span>\n<span class=\"an\">@Table</span>(name = <span class=\"st\">\"users\"</span>,             <span class=\"cm\">// tên table (mặc định = tên class lowercase)</span>\n       uniqueConstraints = <span class=\"an\">@UniqueConstraint</span>(columnNames = <span class=\"st\">\"email\"</span>))\n<span class=\"kw\">public class</span> <span class=\"cl\">User</span> {\n\n    <span class=\"an\">@Id</span>\n    <span class=\"an\">@GeneratedValue</span>(strategy = GenerationType.IDENTITY)\n    <span class=\"kw\">private</span> Long id;\n\n    <span class=\"an\">@Column</span>(name = <span class=\"st\">\"full_name\"</span>,       <span class=\"cm\">// tên column</span>\n            nullable = <span class=\"kw\">false</span>,\n            length = <span class=\"num\">100</span>)\n    <span class=\"kw\">private</span> String name;\n\n    <span class=\"an\">@Column</span>(unique = <span class=\"kw\">true</span>)\n    <span class=\"kw\">private</span> String email;\n\n    <span class=\"an\">@CreatedDate</span>\n    <span class=\"kw\">private</span> LocalDateTime createdAt;\n}</div>",
    "tags": "spring jpa",
    "level": "intern",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Data JPA"
  },
  {
    "num": 73,
    "numStr": "73",
    "question": "Các loại GenerationType trong @GeneratedValue?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th>Strategy</th><th>Cách hoạt động</th><th>Dùng với</th></tr>\n        <tr><td>IDENTITY</td><td>DB tự tăng (AUTO_INCREMENT)</td><td>MySQL, PostgreSQL SERIAL</td></tr>\n        <tr><td>SEQUENCE</td><td>Dùng DB sequence object</td><td>PostgreSQL, Oracle (hiệu năng tốt hơn)</td></tr>\n        <tr><td>TABLE</td><td>Dùng table riêng lưu counter</td><td>Portable nhưng chậm</td></tr>\n        <tr><td>AUTO</td><td>JPA tự chọn phù hợp với DB</td><td>Không khuyến khích (không predictable)</td></tr>\n        <tr><td>UUID</td><td>Tự generate UUID</td><td>Distributed systems</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 PostgreSQL: dùng SEQUENCE (batch insert tốt hơn). MySQL: dùng IDENTITY. Distributed system: UUID hoặc Snowflake ID.</div>",
    "tags": "spring jpa",
    "level": "intern",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Data JPA"
  },
  {
    "num": 74,
    "numStr": "74",
    "question": "JpaRepository cung cấp gì?",
    "answerHtml": "<p>Không cần viết SQL cơ bản — Spring Data tự generate implementation lúc runtime.</p>\n      <div class=\"code-block\"><span class=\"kw\">public interface</span> <span class=\"cl\">UserRepository</span> <span class=\"kw\">extends</span> JpaRepository&lt;User, Long&gt; {\n    <span class=\"cm\">// JpaRepository cho sẵn:</span>\n    <span class=\"cm\">// save(entity), saveAll(), findById(id), findAll(),</span>\n    <span class=\"cm\">// deleteById(id), delete(entity), count(), existsById(id)</span>\n    <span class=\"cm\">// findAll(Pageable), findAll(Sort), saveAndFlush()...</span>\n}</div>\n      <div class=\"code-block\">userRepo.save(user);                       <span class=\"cm\">// INSERT hoặc UPDATE</span>\nuserRepo.findById(<span class=\"num\">1L</span>);                    <span class=\"cm\">// Optional&lt;User&gt;</span>\nuserRepo.findAll(PageRequest.of(<span class=\"num\">0</span>, <span class=\"num\">10</span>));  <span class=\"cm\">// paginated</span>\nuserRepo.deleteById(<span class=\"num\">1L</span>);</div>",
    "tags": "spring jpa",
    "level": "junior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Data JPA"
  },
  {
    "num": 75,
    "numStr": "75",
    "question": "Derived Query Method là gì?",
    "answerHtml": "<p>Spring Data <strong>tự generate SQL</strong> từ tên method theo convention. Không cần viết query!</p>\n      <div class=\"code-block\"><span class=\"kw\">interface</span> <span class=\"cl\">UserRepository</span> <span class=\"kw\">extends</span> JpaRepository&lt;User, Long&gt; {\n    \n    <span class=\"cm\">// SELECT * FROM users WHERE email = ?</span>\n    Optional&lt;User&gt; <span class=\"fn\">findByEmail</span>(String email);\n\n    <span class=\"cm\">// SELECT * FROM users WHERE active = ? AND role = ?</span>\n    List&lt;User&gt; <span class=\"fn\">findByActiveAndRole</span>(<span class=\"kw\">boolean</span> active, String role);\n\n    <span class=\"cm\">// SELECT * FROM users WHERE name LIKE '%?%'</span>\n    List&lt;User&gt; <span class=\"fn\">findByNameContainingIgnoreCase</span>(String name);\n\n    <span class=\"cm\">// SELECT * FROM users WHERE age >= ? ORDER BY name ASC</span>\n    List&lt;User&gt; <span class=\"fn\">findByAgeGreaterThanEqualOrderByNameAsc</span>(<span class=\"kw\">int</span> age);\n\n    <span class=\"cm\">// SELECT COUNT(*) FROM users WHERE active = ?</span>\n    <span class=\"kw\">long</span> <span class=\"fn\">countByActive</span>(<span class=\"kw\">boolean</span> active);\n}</div>",
    "tags": "spring jpa",
    "level": "junior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Data JPA"
  },
  {
    "num": 76,
    "numStr": "76",
    "question": "@Query dùng để làm gì?",
    "answerHtml": "<p>Khi derived method không đủ (query phức tạp), dùng <code>@Query</code> để viết JPQL hoặc native SQL tùy chỉnh.</p>\n      <div class=\"code-block\"><span class=\"cm\">// JPQL - dùng tên class/field Java, không phải tên table/column</span>\n<span class=\"an\">@Query</span>(<span class=\"st\">\"SELECT u FROM User u WHERE u.email = :email AND u.active = true\"</span>)\nOptional&lt;User&gt; <span class=\"fn\">findActiveByEmail</span>(<span class=\"an\">@Param</span>(<span class=\"st\">\"email\"</span>) String email);\n\n<span class=\"cm\">// Native SQL - dùng tên table/column trong DB</span>\n<span class=\"an\">@Query</span>(value = <span class=\"st\">\"SELECT * FROM users WHERE created_at > :date LIMIT :limit\"</span>,\n       nativeQuery = <span class=\"kw\">true</span>)\nList&lt;User&gt; <span class=\"fn\">findRecentUsers</span>(<span class=\"an\">@Param</span>(<span class=\"st\">\"date\"</span>) LocalDateTime date, <span class=\"an\">@Param</span>(<span class=\"st\">\"limit\"</span>) <span class=\"kw\">int</span> limit);\n\n<span class=\"cm\">// Update/Delete query cần @Modifying + @Transactional</span>\n<span class=\"an\">@Modifying</span>\n<span class=\"an\">@Transactional</span>\n<span class=\"an\">@Query</span>(<span class=\"st\">\"UPDATE User u SET u.active = false WHERE u.id = :id\"</span>)\n<span class=\"kw\">int</span> <span class=\"fn\">deactivateUser</span>(<span class=\"an\">@Param</span>(<span class=\"st\">\"id\"</span>) Long id);</div>",
    "tags": "spring jpa",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Data JPA"
  },
  {
    "num": 77,
    "numStr": "77",
    "question": "N+1 Problem là gì? Cách tránh?",
    "answerHtml": "<p>N+1 Problem: query 1 lần để lấy danh sách (1 query), sau đó lặp qua từng phần tử và query thêm (N queries) → tổng N+1 queries → rất chậm.</p>\n      <div class=\"code-block\"><span class=\"cm\">// N+1 Problem</span>\nList&lt;Order&gt; orders = orderRepo.findAll();      <span class=\"cm\">// 1 query</span>\n<span class=\"kw\">for</span> (Order o : orders) {\n    String name = o.getUser().getName();        <span class=\"cm\">// N query (mỗi order 1 query cho user)</span>\n}\n<span class=\"cm\">// Tổng: 1 + N queries! 100 orders = 101 queries</span></div>\n      <p><strong>Cách fix:</strong></p>\n      <div class=\"code-block\"><span class=\"cm\">// Cách 1: JOIN FETCH trong JPQL</span>\n<span class=\"an\">@Query</span>(<span class=\"st\">\"SELECT o FROM Order o JOIN FETCH o.user\"</span>)\nList&lt;Order&gt; <span class=\"fn\">findAllWithUser</span>();  <span class=\"cm\">// 1 query duy nhất với JOIN</span>\n\n<span class=\"cm\">// Cách 2: @EntityGraph</span>\n<span class=\"an\">@EntityGraph</span>(attributePaths = {<span class=\"st\">\"user\"</span>, <span class=\"st\">\"items\"</span>})\nList&lt;Order&gt; <span class=\"fn\">findAll</span>();\n\n<span class=\"cm\">// Cách 3: spring.jpa.properties.hibernate.default_batch_fetch_size=20</span></div>",
    "tags": "spring jpa",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Data JPA"
  },
  {
    "num": 78,
    "numStr": "78",
    "question": "FetchType LAZY vs EAGER khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>EAGER</th><th>LAZY</th></tr>\n        <tr><td>Load khi nào</td><td>Ngay khi load entity cha</td><td>Chỉ khi truy cập field đó</td></tr>\n        <tr><td>Số query</td><td>Nhiều hơn (JOIN hoặc extra query)</td><td>Ít hơn nếu không dùng</td></tr>\n        <tr><td>Nguy cơ</td><td>Load dữ liệu không cần thiết</td><td>LazyInitializationException nếu ngoài session</td></tr>\n        <tr><td>Default</td><td>@ManyToOne, @OneToOne</td><td>@OneToMany, @ManyToMany</td></tr>\n      </table>\n      <div class=\"warn-box\">⚠️ LazyInitializationException: truy cập lazy field sau khi JPA session đã đóng (ngoài @Transactional). Fix: dùng JOIN FETCH, @EntityGraph, hoặc mở transaction đúng chỗ.</div>\n      <div class=\"tip-box\">💡 Best practice: giữ LAZY cho tất cả, dùng JOIN FETCH khi cần. Tránh đổi sang EAGER toàn bộ — dễ dẫn đến performance vấn đề.</div>",
    "tags": "spring jpa",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Data JPA"
  },
  {
    "num": 79,
    "numStr": "79",
    "question": "@Transactional dùng để làm gì?",
    "answerHtml": "<p>Đánh dấu method/class chạy trong <strong>một transaction database</strong>. Nếu method thành công → commit. Nếu exception xảy ra → tự động rollback.</p>\n      <p>Spring implement bằng <strong>AOP proxy</strong>: tạo proxy bao bọc method, quản lý transaction xung quanh lời gọi thật.</p>\n      <div class=\"code-block\"><span class=\"an\">@Transactional</span>\n<span class=\"kw\">public void</span> <span class=\"fn\">transfer</span>(Long fromId, Long toId, <span class=\"kw\">double</span> amount) {\n    Account from = accountRepo.findById(fromId).orElseThrow();\n    Account to = accountRepo.findById(toId).orElseThrow();\n    \n    from.deduct(amount);   <span class=\"cm\">// nếu exception ở đây</span>\n    to.deposit(amount);    <span class=\"cm\">// cả 2 đều rollback → tài khoản không mất tiền</span>\n}</div>\n      <div class=\"warn-box\">⚠️ Gọi @Transactional method từ <strong>cùng class</strong> (self-invocation) không hoạt động vì Spring AOP dùng proxy — lời gọi nội bộ bypass proxy. Fix: inject bean vào chính nó hoặc dùng AspectJ weaving.</div>",
    "tags": "spring jpa",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Data JPA"
  },
  {
    "num": 80,
    "numStr": "80",
    "question": "@Transactional propagation là gì?",
    "answerHtml": "<p>Xác định <strong>behavior khi method có @Transactional gọi method khác cũng có @Transactional</strong>.</p>\n      <table class=\"compare-table\">\n        <tr><th>Propagation</th><th>Hành vi</th></tr>\n        <tr><td>REQUIRED (default)</td><td>Tham gia transaction hiện tại nếu có, nếu không tạo mới</td></tr>\n        <tr><td>REQUIRES_NEW</td><td>Luôn tạo transaction mới, suspend transaction hiện tại</td></tr>\n        <tr><td>NESTED</td><td>Tạo savepoint trong transaction hiện tại (rollback nested không ảnh hưởng outer)</td></tr>\n        <tr><td>SUPPORTS</td><td>Dùng transaction nếu có, không tạo mới nếu không có</td></tr>\n        <tr><td>NOT_SUPPORTED</td><td>Suspend transaction hiện tại, chạy không có transaction</td></tr>\n        <tr><td>NEVER</td><td>Throw exception nếu đang có transaction</td></tr>\n        <tr><td>MANDATORY</td><td>Throw exception nếu KHÔNG có transaction</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 Use case REQUIRES_NEW: ghi audit log — dù business logic rollback, audit log vẫn phải được lưu.</div>",
    "tags": "spring jpa",
    "level": "senior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Data JPA"
  },
  {
    "num": 81,
    "numStr": "81",
    "question": "@Transactional rollbackFor dùng để làm gì?",
    "answerHtml": "<p>Mặc định, Spring <strong>chỉ rollback với RuntimeException và Error</strong>. Checked Exception <em>không</em> tự rollback!</p>\n      <div class=\"code-block\"><span class=\"cm\">// ❌ IOException là checked exception - KHÔNG rollback mặc định</span>\n<span class=\"an\">@Transactional</span>\n<span class=\"kw\">public void</span> <span class=\"fn\">process</span>() <span class=\"kw\">throws</span> IOException {\n    userRepo.save(user);  <span class=\"cm\">// sẽ COMMIT dù IOException xảy ra sau!</span>\n    sendEmail();          <span class=\"cm\">// throw IOException</span>\n}\n\n<span class=\"cm\">// ✅ Chỉ định rollback cho mọi exception</span>\n<span class=\"an\">@Transactional</span>(rollbackFor = Exception.<span class=\"kw\">class</span>)\n<span class=\"kw\">public void</span> <span class=\"fn\">process</span>() <span class=\"kw\">throws</span> IOException { ... }\n\n<span class=\"cm\">// Không rollback với exception cụ thể</span>\n<span class=\"an\">@Transactional</span>(noRollbackFor = OptimisticLockException.<span class=\"kw\">class</span>)</div>",
    "tags": "spring jpa",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Data JPA"
  },
  {
    "num": 82,
    "numStr": "82",
    "question": "Pagination trong Spring Data JPA thế nào?",
    "answerHtml": "<div class=\"code-block\"><span class=\"cm\">// Repository</span>\n<span class=\"kw\">interface</span> <span class=\"cl\">UserRepository</span> <span class=\"kw\">extends</span> JpaRepository&lt;User, Long&gt; {\n    Page&lt;User&gt; <span class=\"fn\">findByActive</span>(<span class=\"kw\">boolean</span> active, Pageable pageable);\n}\n\n<span class=\"cm\">// Service / Controller</span>\nPageable pageable = PageRequest.of(\n    <span class=\"num\">0</span>,                        <span class=\"cm\">// page number (0-based)</span>\n    <span class=\"num\">10</span>,                       <span class=\"cm\">// page size</span>\n    Sort.by(<span class=\"st\">\"createdAt\"</span>).descending()\n);\n\nPage&lt;User&gt; page = userRepo.findByActive(<span class=\"kw\">true</span>, pageable);\n\npage.getContent();         <span class=\"cm\">// List data trong page này</span>\npage.getTotalElements();   <span class=\"cm\">// tổng số record</span>\npage.getTotalPages();      <span class=\"cm\">// tổng số trang</span>\npage.getNumber();          <span class=\"cm\">// page hiện tại</span>\npage.isLast();             <span class=\"cm\">// trang cuối chưa?</span></div>",
    "tags": "spring jpa",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Data JPA"
  },
  {
    "num": 83,
    "numStr": "83",
    "question": "Spring Security hoạt động như thế nào?",
    "answerHtml": "<p>Spring Security dùng <strong>chuỗi Filter (SecurityFilterChain)</strong> xử lý mọi request trước khi vào Controller.</p>\n      <div class=\"code-block\">HTTP Request\n    ↓\nSecurityFilterChain\n    ├── CorsFilter\n    ├── CsrfFilter\n    ├── UsernamePasswordAuthenticationFilter  ← login\n    ├── JwtAuthenticationFilter              ← check JWT token\n    ├── ExceptionTranslationFilter           ← handle 401/403\n    └── FilterSecurityInterceptor            ← authorization\n    ↓\nController</div>\n      <div class=\"code-block\"><span class=\"cm\">// Config Spring Security (Spring Boot 3+)</span>\n<span class=\"an\">@Bean</span>\nSecurityFilterChain <span class=\"fn\">securityFilterChain</span>(HttpSecurity http) <span class=\"kw\">throws</span> Exception {\n    <span class=\"kw\">return</span> http\n        .csrf(csrf -> csrf.disable())\n        .authorizeHttpRequests(auth -> auth\n            .requestMatchers(<span class=\"st\">\"/api/auth/**\"</span>).permitAll()\n            .requestMatchers(<span class=\"st\">\"/api/admin/**\"</span>).hasRole(<span class=\"st\">\"ADMIN\"</span>)\n            .anyRequest().authenticated()\n        )\n        .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.<span class=\"kw\">class</span>)\n        .build();\n}</div>",
    "tags": "spring security",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Security"
  },
  {
    "num": 84,
    "numStr": "84",
    "question": "Authentication vs Authorization khác nhau thế nào?",
    "answerHtml": "<ul>\n        <li><span class=\"highlight\">Authentication (Xác thực)</span>: <strong>\"Bạn là ai?\"</strong> — Xác minh danh tính. Ví dụ: kiểm tra username/password, validate JWT token.</li>\n        <li><span class=\"green\">Authorization (Phân quyền)</span>: <strong>\"Bạn được làm gì?\"</strong> — Kiểm tra quyền truy cập sau khi đã xác thực. Ví dụ: chỉ ADMIN mới xoá được user.</li>\n      </ul>\n      <p>Trong Spring Security: Authentication xảy ra trước, sau đó Authorization quyết định có cho phép thực hiện request không.</p>\n      <div class=\"code-block\">Authentication: user gửi JWT token → Spring verify chữ ký → tạo Authentication object\n                    → lưu vào SecurityContextHolder\n\nAuthorization:  request đến /admin/users → Spring kiểm tra authentication có role ADMIN không\n                → có → tiếp tục | không → 403 Forbidden</div>",
    "tags": "spring security",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Security"
  },
  {
    "num": 85,
    "numStr": "85",
    "question": "JWT là gì? Dùng trong Spring Security thế nào?",
    "answerHtml": "<p><strong>JWT (JSON Web Token)</strong> là token tự chứa thông tin, gồm 3 phần phân cách bằng dấu chấm: <code>header.payload.signature</code></p>\n      <div class=\"code-block\">eyJhbGciOiJIUzI1NiJ9      <span class=\"cm\">← header (algorithm)</span>\n.eyJ1c2VySWQiOjEsInJvbGUiOiJVU0VSIn0  <span class=\"cm\">← payload (claims: userId, role...)</span>\n.HMACSHA256(...)            <span class=\"cm\">← signature (verify không bị tampered)</span></div>\n      <p><strong>Luồng JWT trong Spring Security:</strong></p>\n      <ul>\n        <li>Login → server tạo JWT, ký bằng secret key → trả về client</li>\n        <li>Client gửi request kèm <code>Authorization: Bearer &lt;token&gt;</code></li>\n        <li>JwtFilter intercept → verify chữ ký → extract user info → set vào SecurityContext</li>\n        <li>Controller nhận request đã được authenticate</li>\n      </ul>\n      <div class=\"tip-box\">💡 Ưu điểm JWT: Stateless — server không cần lưu session. Nhược điểm: không thể revoke ngay lập tức. Solution: dùng short expiry + refresh token, hoặc lưu blacklist Redis.</div>",
    "tags": "spring security",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Security"
  },
  {
    "num": 86,
    "numStr": "86",
    "question": "@PreAuthorize vs @Secured khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>@Secured</th><th>@PreAuthorize</th></tr>\n        <tr><td>SpEL support</td><td>❌</td><td>✅</td></tr>\n        <tr><td>Prefix cần thiết</td><td>Cần \"ROLE_\"</td><td>Không cần</td></tr>\n        <tr><td>Expression phức tạp</td><td>❌</td><td>✅</td></tr>\n        <tr><td>Khi nào check</td><td>Trước method</td><td>Trước method (+ @PostAuthorize sau)</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// @Secured - đơn giản</span>\n<span class=\"an\">@Secured</span>({<span class=\"st\">\"ROLE_ADMIN\"</span>, <span class=\"st\">\"ROLE_MANAGER\"</span>})\n<span class=\"kw\">void</span> <span class=\"fn\">deleteUser</span>(Long id) { ... }\n\n<span class=\"cm\">// @PreAuthorize - linh hoạt hơn, hỗ trợ SpEL</span>\n<span class=\"an\">@PreAuthorize</span>(<span class=\"st\">\"hasRole('ADMIN')\"</span>)\n<span class=\"an\">@PreAuthorize</span>(<span class=\"st\">\"hasAnyRole('ADMIN', 'MANAGER')\"</span>)\n<span class=\"an\">@PreAuthorize</span>(<span class=\"st\">\"#userId == authentication.principal.id\"</span>)  <span class=\"cm\">// user chỉ xoá chính mình</span>\n<span class=\"an\">@PreAuthorize</span>(<span class=\"st\">\"isAuthenticated() and @userService.isOwner(#id)\"</span>) <span class=\"cm\">// gọi Spring bean</span></div>",
    "tags": "spring security",
    "level": "senior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Security"
  },
  {
    "num": 87,
    "numStr": "87",
    "question": "CSRF là gì? Spring Security xử lý thế nào?",
    "answerHtml": "<p><strong>CSRF (Cross-Site Request Forgery)</strong>: Kẻ tấn công lừa browser của user gửi request đến server mà user đã đăng nhập, server tưởng là request hợp lệ.</p>\n      <p><strong>Spring Security mặc định bật CSRF protection</strong> bằng cách yêu cầu CSRF token trong mỗi request thay đổi state (POST, PUT, DELETE).</p>\n      <div class=\"code-block\"><span class=\"cm\">// REST API stateless với JWT → thường disable CSRF</span>\n<span class=\"cm\">// Vì JWT không bị tự động gửi bởi browser như cookie</span>\nhttp.csrf(csrf -> csrf.disable());\n\n<span class=\"cm\">// Web MVC với session/cookie → nên enable CSRF</span>\n<span class=\"cm\">// Thymeleaf tự inject CSRF token vào form</span></div>\n      <div class=\"tip-box\">💡 CSRF chủ yếu là mối đe dọa với cookie-based authentication. JWT trong header (Authorization: Bearer) không bị ảnh hưởng bởi CSRF vì browser không tự gửi header custom.</div>",
    "tags": "spring security",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Security"
  },
  {
    "num": 88,
    "numStr": "88",
    "question": "PasswordEncoder là gì?",
    "answerHtml": "<p>Interface để <strong>hash password một chiều</strong> trước khi lưu vào DB. <strong>BCryptPasswordEncoder</strong> là phổ biến nhất.</p>\n      <p><strong>Tại sao BCrypt?</strong></p>\n      <ul>\n        <li>Tự động thêm <strong>random salt</strong> → cùng password hash ra kết quả khác nhau → chống rainbow table</li>\n        <li>Có <strong>cost factor</strong> (rounds, mặc định 10) → điều chỉnh độ chậm theo sức mạnh phần cứng → chống brute force</li>\n        <li>Chậm có chủ đích: 100ms/hash là tốt cho user, nhưng tốn kém với attacker</li>\n      </ul>\n      <div class=\"code-block\">PasswordEncoder encoder = <span class=\"kw\">new</span> BCryptPasswordEncoder(<span class=\"num\">12</span>); <span class=\"cm\">// cost = 12</span>\n\n<span class=\"cm\">// Lưu user: hash password trước</span>\nuser.setPassword(encoder.encode(<span class=\"st\">\"rawPassword\"</span>));\n\n<span class=\"cm\">// Login: so sánh</span>\n<span class=\"kw\">boolean</span> match = encoder.matches(<span class=\"st\">\"rawPassword\"</span>, user.getPassword()); <span class=\"cm\">// true</span></div>",
    "tags": "spring security",
    "level": "junior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Security"
  },
  {
    "num": 147,
    "numStr": "147",
    "question": "OAuth2 flow hoạt động thế nào?",
    "answerHtml": "<p>OAuth2 là <strong>authorization framework</strong> — cho phép ứng dụng third-party truy cập tài nguyên thay mặt user mà <strong>không cần biết password</strong>.</p>\n      <p><strong>Authorization Code Flow (phổ biến nhất — web app):</strong></p>\n      <div class=\"code-block\">1. User click \"Login with Google\"\n2. App redirect → Google Authorization Server (kèm client_id, scope, redirect_uri)\n3. User login + consent tại Google\n4. Google redirect về app kèm: ?code=AUTH_CODE\n5. App gửi AUTH_CODE → Google để đổi lấy Access Token (server-to-server, an toàn)\n6. App dùng Access Token để gọi Google APIs\n\n<span class=\"cm\">// Các Grant Type khác:</span>\nClient Credentials: M2M (machine-to-machine), không có user\nImplicit:           Deprecated (không an toàn, token trong URL)\nPKCE:               Mobile/SPA app (thay Implicit)</div>\n      <p><strong>Phân biệt OAuth2 vs OIDC vs JWT:</strong></p>\n      <ul>\n        <li><strong>OAuth2:</strong> Framework cấp phép (Authorization)</li>\n        <li><strong>OIDC (OpenID Connect):</strong> Layer trên OAuth2, thêm Authentication (ai đang login?)</li>\n        <li><strong>JWT:</strong> Format của token (có thể dùng trong OAuth2/OIDC)</li>\n      </ul>",
    "tags": "spring security",
    "level": "senior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Security"
  },
  {
    "num": 148,
    "numStr": "148",
    "question": "Refresh Token là gì? Cách revoke JWT?",
    "answerHtml": "<ul>\n        <li><strong>Access Token:</strong> Ngắn hạn (5-15 phút), dùng để gọi API</li>\n        <li><strong>Refresh Token:</strong> Dài hạn (7-30 ngày), dùng để lấy Access Token mới khi hết hạn — không gửi kèm mỗi request</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"cm\">// Flow Refresh Token</span>\n1. Login → nhận {access_token (15min), refresh_token (7days)}\n2. Gọi API với access_token\n3. access_token hết hạn → 401 Unauthorized\n4. Client gửi refresh_token → server cấp access_token mới\n5. Nếu refresh_token hết hạn → bắt đăng nhập lại\n\n<span class=\"cm\">// Cách revoke JWT (JWT vốn không thể revoke vì stateless)</span>\n<span class=\"cm\">// Giải pháp 1: Blacklist (lưu token đã revoke vào Redis với TTL)</span>\nredis.set(<span class=\"st\">\"blacklist:\"</span> + jti, <span class=\"st\">\"revoked\"</span>, tokenTTL);\n\n<span class=\"cm\">// Giải pháp 2: Dùng short-lived access token + refresh token rotation</span>\n<span class=\"cm\">// Giải pháp 3: Reference token — token chỉ là ID, server lookup DB</span></div>\n      <div class=\"warn-box\">⚠️ Refresh Token phải lưu ở httpOnly cookie (không JS access được) để tránh XSS. Access Token lưu trong memory (không phải localStorage).</div>",
    "tags": "spring security",
    "level": "senior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Security"
  },
  {
    "num": 149,
    "numStr": "149",
    "question": "Rate Limiting implement thế nào? Token Bucket vs Sliding Window?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th>Thuật toán</th><th>Cơ chế</th><th>Ưu điểm</th></tr>\n        <tr><td><strong>Token Bucket</strong></td><td>Bucket có N token, refill đều. Request lấy 1 token, hết thì reject</td><td>Cho phép burst ngắn</td></tr>\n        <tr><td><strong>Fixed Window</strong></td><td>Đếm request trong window cố định (1 phút). Reset khi hết window</td><td>Đơn giản, nhưng có boundary spike</td></tr>\n        <tr><td><strong>Sliding Window</strong></td><td>Window trượt theo thời gian thực. Chính xác hơn Fixed Window</td><td>Phân phối đều, chính xác</td></tr>\n        <tr><td><strong>Leaky Bucket</strong></td><td>Request xếp hàng, xử lý đều đặn</td><td>Smooth traffic</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// Implement với Redis (Sliding Window + Sorted Set)</span>\n<span class=\"kw\">public boolean</span> <span class=\"fn\">isAllowed</span>(String userId, <span class=\"kw\">int</span> limit, <span class=\"kw\">int</span> windowSeconds) {\n    String key = <span class=\"st\">\"rate:\"</span> + userId;\n    <span class=\"kw\">long</span> now = System.currentTimeMillis();\n    <span class=\"kw\">long</span> windowStart = now - windowSeconds * <span class=\"num\">1000L</span>;\n\n    redis.zremrangeByScore(key, <span class=\"num\">0</span>, windowStart); <span class=\"cm\">// xóa request cũ</span>\n    <span class=\"kw\">long</span> count = redis.zcard(key);\n\n    <span class=\"kw\">if</span> (count &lt; limit) {\n        redis.zadd(key, now, UUID.randomUUID().toString());\n        redis.expire(key, windowSeconds);\n        <span class=\"kw\">return true</span>;\n    }\n    <span class=\"kw\">return false</span>; <span class=\"cm\">// 429 Too Many Requests</span>\n}\n\n<span class=\"cm\">// Hoặc dùng Bucket4j library (Token Bucket, thread-safe)</span>\n<span class=\"cm\">// Hoặc Spring Cloud Gateway built-in rate limiter</span></div>",
    "tags": "spring security redis",
    "level": "senior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Security"
  },
  {
    "num": 150,
    "numStr": "150",
    "question": "Brute Force Protection — các kỹ thuật phòng chống?",
    "answerHtml": "<ul>\n        <li>🔒 <strong>Account Lockout:</strong> Khóa tài khoản sau N lần sai (VD: 5 lần → lock 15 phút)</li>\n        <li>⏳ <strong>Progressive Delay:</strong> Mỗi lần sai → chờ lâu hơn (1s, 2s, 4s, 8s...)</li>\n        <li>🤖 <strong>CAPTCHA:</strong> Sau 3 lần sai → hiện captcha</li>\n        <li>🌐 <strong>IP Rate Limiting:</strong> Giới hạn login attempt từ cùng IP</li>\n        <li>🔑 <strong>MFA:</strong> Multi-factor auth — ngăn brute force hoàn toàn</li>\n        <li>📧 <strong>Login notification:</strong> Email/SMS khi login từ device/location mới</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"cm\">// Track failed attempts trong Redis</span>\nString key = <span class=\"st\">\"login:fail:\"</span> + username;\n<span class=\"kw\">int</span> failures = redis.incr(key);\nredis.expire(key, <span class=\"num\">900</span>); <span class=\"cm\">// reset sau 15 phút</span>\n\n<span class=\"kw\">if</span> (failures &gt;= <span class=\"num\">5</span>) {\n    <span class=\"kw\">throw new</span> AccountLockedException(<span class=\"st\">\"Too many attempts\"</span>);\n}\n<span class=\"cm\">// Login thành công → xóa counter</span>\nredis.delete(key);</div>\n      <div class=\"tip-box\">💡 Spring Security có <code>AccountStatusUserDetailsChecker</code> check <code>isAccountNonLocked()</code>. Dùng kết hợp với Redis counter để implement đầy đủ.</div>",
    "tags": "spring security",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Security"
  },
  {
    "num": 89,
    "numStr": "89",
    "question": "application.properties vs application.yml?",
    "answerHtml": "<p>Hai format tương đương về chức năng. YAML cấu trúc hơn, tránh lặp prefix.</p>\n      <div class=\"code-block\"><span class=\"cm\"># application.properties</span>\nspring.datasource.url=jdbc:mysql://localhost:3306/mydb\nspring.datasource.username=root\nspring.datasource.password=secret\nspring.jpa.hibernate.ddl-auto=update</div>\n      <div class=\"code-block\"><span class=\"cm\"># application.yml - cùng nội dung, gọn hơn</span>\nspring:\n  datasource:\n    url: jdbc:mysql://localhost:3306/mydb\n    username: root\n    password: secret\n  jpa:\n    hibernate:\n      ddl-auto: update</div>\n      <div class=\"warn-box\">⚠️ YAML nhạy cảm với indentation (dùng spaces, không dùng tab). Không trộn lẫn 2 file (nếu có cả 2, properties được load trước).</div>",
    "tags": "spring config",
    "level": "intern",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 90,
    "numStr": "90",
    "question": "@Value vs @ConfigurationProperties khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>@Value</th><th>@ConfigurationProperties</th></tr>\n        <tr><td>Inject</td><td>Từng giá trị đơn lẻ</td><td>Cả nhóm vào POJO</td></tr>\n        <tr><td>Type-safe</td><td>❌ (dạng String)</td><td>✅</td></tr>\n        <tr><td>Validation</td><td>❌</td><td>✅ Kết hợp @Validated</td></tr>\n        <tr><td>IDE support</td><td>Ít hơn</td><td>✅ Auto-complete</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// @Value - đơn giản, ít config</span>\n<span class=\"an\">@Value</span>(<span class=\"st\">\"${app.jwt.secret}\"</span>)\n<span class=\"kw\">private</span> String jwtSecret;\n\n<span class=\"cm\">// @ConfigurationProperties - nhóm config, type-safe</span>\n<span class=\"an\">@ConfigurationProperties</span>(prefix = <span class=\"st\">\"app.jwt\"</span>)\n<span class=\"an\">@Validated</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">JwtProperties</span> {\n    <span class=\"an\">@NotBlank</span>\n    <span class=\"kw\">private</span> String secret;\n    <span class=\"an\">@Min</span>(<span class=\"num\">60</span>)\n    <span class=\"kw\">private int</span> expirationMinutes = <span class=\"num\">60</span>;\n}</div>",
    "tags": "spring config",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 91,
    "numStr": "91",
    "question": "Profile trong Spring Boot là gì?",
    "answerHtml": "<p>Profile cho phép <strong>tách config theo môi trường</strong> (dev, staging, production) trong cùng codebase.</p>\n      <div class=\"code-block\"><span class=\"cm\"># File cấu hình theo profile</span>\napplication.yml           <span class=\"cm\">← config chung, luôn load</span>\napplication-dev.yml       <span class=\"cm\">← override khi profile=dev</span>\napplication-prod.yml      <span class=\"cm\">← override khi profile=prod</span>\n\n<span class=\"cm\"># Kích hoạt profile</span>\n<span class=\"cm\"># application.yml</span>\nspring.profiles.active=dev\n\n<span class=\"cm\"># Command line (override tất cả)</span>\njava -jar app.jar --spring.profiles.active=prod\n\n<span class=\"cm\"># Environment variable</span>\nSPRING_PROFILES_ACTIVE=prod</div>\n      <div class=\"code-block\"><span class=\"cm\">// Bean chỉ active với profile cụ thể</span>\n<span class=\"an\">@Profile</span>(<span class=\"st\">\"dev\"</span>)\n<span class=\"an\">@Bean</span>\nMockEmailService <span class=\"fn\">emailService</span>() { <span class=\"kw\">return new</span> MockEmailService(); }\n\n<span class=\"an\">@Profile</span>(<span class=\"st\">\"prod\"</span>)\n<span class=\"an\">@Bean</span>\nRealEmailService <span class=\"fn\">emailService</span>() { <span class=\"kw\">return new</span> RealEmailService(); }</div>",
    "tags": "spring config",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 92,
    "numStr": "92",
    "question": "Spring Boot Actuator là gì?",
    "answerHtml": "<p>Actuator cung cấp <strong>production-ready endpoints</strong> để monitoring và quản lý ứng dụng mà không cần code thêm.</p>\n      <table class=\"compare-table\">\n        <tr><th>Endpoint</th><th>Thông tin cung cấp</th></tr>\n        <tr><td>/actuator/health</td><td>Trạng thái UP/DOWN của app, DB, cache...</td></tr>\n        <tr><td>/actuator/metrics</td><td>JVM memory, CPU, request count, latency...</td></tr>\n        <tr><td>/actuator/info</td><td>App info (version, build time...)</td></tr>\n        <tr><td>/actuator/env</td><td>Environment properties (cẩn thận expose)</td></tr>\n        <tr><td>/actuator/loggers</td><td>Xem/thay đổi log level lúc runtime</td></tr>\n        <tr><td>/actuator/threaddump</td><td>Thread dump để debug deadlock</td></tr>\n      </table>\n      <div class=\"warn-box\">⚠️ Bảo mật actuator endpoints trong production! Chỉ expose /health và /info ra ngoài, các endpoint khác cần authentication.</div>",
    "tags": "spring config",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 93,
    "numStr": "93",
    "question": "@Scheduled dùng để làm gì?",
    "answerHtml": "<p>Chạy method theo lịch định kỳ. Cần enable bằng <code>@EnableScheduling</code> trên config class.</p>\n      <div class=\"code-block\"><span class=\"an\">@Scheduled</span>(fixedRate = <span class=\"num\">5000</span>)          <span class=\"cm\">// mỗi 5 giây (kể từ lần chạy trước BẮT ĐẦU)</span>\n<span class=\"an\">@Scheduled</span>(fixedDelay = <span class=\"num\">5000</span>)         <span class=\"cm\">// 5 giây sau khi lần trước KẾT THÚC</span>\n<span class=\"an\">@Scheduled</span>(initialDelay = <span class=\"num\">10000</span>, fixedRate = <span class=\"num\">5000</span>) <span class=\"cm\">// chờ 10s rồi mới bắt đầu</span>\n\n<span class=\"cm\">// Cron expression: giây phút giờ ngày tháng thứ</span>\n<span class=\"an\">@Scheduled</span>(cron = <span class=\"st\">\"0 0 2 * * ?\"</span>)      <span class=\"cm\">// 2:00 AM mỗi ngày</span>\n<span class=\"an\">@Scheduled</span>(cron = <span class=\"st\">\"0 0 9 ? * MON-FRI\"</span>) <span class=\"cm\">// 9AM các ngày trong tuần</span>\n<span class=\"kw\">public void</span> <span class=\"fn\">sendDailyReport</span>() { ... }</div>\n      <div class=\"tip-box\">💡 Mặc định scheduled task chạy single-threaded — một task chậm có thể block task khác. Configure ThreadPoolTaskScheduler nếu cần chạy song song.</div>",
    "tags": "spring config",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 94,
    "numStr": "94",
    "question": "@Async dùng để làm gì?",
    "answerHtml": "<p>Chạy method trong <strong>thread riêng biệt</strong> (bất đồng bộ), không block thread hiện tại. Cần <code>@EnableAsync</code>.</p>\n      <div class=\"code-block\"><span class=\"an\">@Async</span>\n<span class=\"kw\">public void</span> <span class=\"fn\">sendEmail</span>(String to) {\n    <span class=\"cm\">// Chạy trong thread pool riêng, không block caller</span>\n    emailClient.send(to, message);\n}\n\n<span class=\"cm\">// Trả về kết quả bất đồng bộ</span>\n<span class=\"an\">@Async</span>\n<span class=\"kw\">public</span> CompletableFuture&lt;String&gt; <span class=\"fn\">fetchData</span>() {\n    String result = externalApi.call();\n    <span class=\"kw\">return</span> CompletableFuture.completedFuture(result);\n}\n\n<span class=\"cm\">// Caller có thể chờ hoặc không:</span>\nCompletableFuture&lt;String&gt; future = service.fetchData();\nString result = future.get();  <span class=\"cm\">// block đợi</span>\n<span class=\"cm\">// hoặc future.thenAccept(r -> process(r)); // non-blocking</span></div>\n      <div class=\"warn-box\">⚠️ Giống @Transactional, @Async dùng AOP proxy — self-invocation không hoạt động!</div>",
    "tags": "spring config",
    "level": "senior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 95,
    "numStr": "95",
    "question": "@SpringBootTest vs @WebMvcTest khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>@SpringBootTest</th><th>@WebMvcTest</th></tr>\n        <tr><td>Context</td><td>Load FULL application context</td><td>Chỉ Web layer (Controller, Filter...)</td></tr>\n        <tr><td>Tốc độ</td><td>Chậm</td><td>Nhanh hơn nhiều</td></tr>\n        <tr><td>DB thật</td><td>Có thể</td><td>❌ (Service, Repo phải mock)</td></tr>\n        <tr><td>Dùng cho</td><td>Integration test</td><td>Unit test Controller</td></tr>\n        <tr><td>Server</td><td>Embedded server (tuỳ config)</td><td>Mock MVC, không cần server thật</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"an\">@WebMvcTest</span>(<span class=\"cl\">UserController</span>.<span class=\"kw\">class</span>)\n<span class=\"kw\">class</span> <span class=\"cl\">UserControllerTest</span> {\n    <span class=\"an\">@Autowired</span> MockMvc mockMvc;\n    <span class=\"an\">@MockBean</span> UserService userService; <span class=\"cm\">// Service phải mock</span>\n    \n    <span class=\"an\">@Test</span>\n    <span class=\"kw\">void</span> <span class=\"fn\">getUser_ReturnsUser</span>() <span class=\"kw\">throws</span> Exception {\n        when(userService.findById(<span class=\"num\">1L</span>)).thenReturn(<span class=\"kw\">new</span> User(<span class=\"st\">\"John\"</span>));\n        \n        mockMvc.perform(get(<span class=\"st\">\"/api/users/1\"</span>))\n            .andExpect(status().isOk())\n            .andExpect(jsonPath(<span class=\"st\">\"$.name\"</span>).value(<span class=\"st\">\"John\"</span>));\n    }\n}</div>",
    "tags": "spring test",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 96,
    "numStr": "96",
    "question": "MockMvc là gì?",
    "answerHtml": "<p>MockMvc cho phép <strong>test Spring MVC controller không cần start server thật</strong>. Simulate toàn bộ HTTP request/response stack trong memory.</p>\n      <div class=\"code-block\">mockMvc.perform(\n        post(<span class=\"st\">\"/api/users\"</span>)\n            .contentType(MediaType.APPLICATION_JSON)\n            .content(<span class=\"st\">\"\"\"{\"name\":\"John\",\"email\":\"john@example.com\"}\"\"\"</span>)\n            .header(<span class=\"st\">\"Authorization\"</span>, <span class=\"st\">\"Bearer \"</span> + token)\n    )\n    .andExpect(status().isCreated())\n    .andExpect(header().string(<span class=\"st\">\"Location\"</span>, Matchers.containsString(<span class=\"st\">\"/users/\"</span>)))\n    .andExpect(jsonPath(<span class=\"st\">\"$.id\"</span>).isNumber())\n    .andExpect(jsonPath(<span class=\"st\">\"$.name\"</span>).value(<span class=\"st\">\"John\"</span>))\n    .andDo(print()); <span class=\"cm\">// in request/response ra console</span></div>",
    "tags": "spring test",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 97,
    "numStr": "97",
    "question": "@MockBean vs @Mock khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>@Mock (Mockito)</th><th>@MockBean (Spring)</th></tr>\n        <tr><td>Đăng ký vào Spring context</td><td>❌</td><td>✅ Thay thế bean thật</td></tr>\n        <tr><td>Dùng khi</td><td>Unit test thuần (không có Spring context)</td><td>Integration test với @SpringBootTest/@WebMvcTest</td></tr>\n        <tr><td>Runner cần</td><td>@ExtendWith(MockitoExtension.class)</td><td>@SpringBootTest hoặc @WebMvcTest</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// Unit test với @Mock - không cần Spring</span>\n<span class=\"an\">@ExtendWith</span>(MockitoExtension.<span class=\"kw\">class</span>)\n<span class=\"kw\">class</span> <span class=\"cl\">UserServiceTest</span> {\n    <span class=\"an\">@Mock</span> UserRepository userRepo;\n    <span class=\"an\">@InjectMocks</span> UserService userService;\n}\n\n<span class=\"cm\">// Integration test với @MockBean</span>\n<span class=\"an\">@SpringBootTest</span>\n<span class=\"kw\">class</span> <span class=\"cl\">UserIntegrationTest</span> {\n    <span class=\"an\">@MockBean</span> EmailService emailService; <span class=\"cm\">// thay thế real bean trong context</span>\n    <span class=\"an\">@Autowired</span> UserService userService;\n}</div>",
    "tags": "spring test",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 98,
    "numStr": "98",
    "question": "Caching trong Spring Boot thế nào?",
    "answerHtml": "<p>Spring Cache Abstraction cho phép cache result của method với annotation đơn giản. Cần <code>@EnableCaching</code>.</p>\n      <div class=\"code-block\"><span class=\"cm\">// @Cacheable - cache kết quả, lần sau gọi cùng key → trả từ cache</span>\n<span class=\"an\">@Cacheable</span>(value = <span class=\"st\">\"users\"</span>, key = <span class=\"st\">\"#id\"</span>)\n<span class=\"kw\">public</span> User <span class=\"fn\">findById</span>(Long id) {\n    <span class=\"kw\">return</span> userRepo.findById(id).orElseThrow(); <span class=\"cm\">// không gọi nếu cache hit</span>\n}\n\n<span class=\"cm\">// @CachePut - luôn gọi method VÀ update cache</span>\n<span class=\"an\">@CachePut</span>(value = <span class=\"st\">\"users\"</span>, key = <span class=\"st\">\"#user.id\"</span>)\n<span class=\"kw\">public</span> User <span class=\"fn\">update</span>(User user) { <span class=\"kw\">return</span> userRepo.save(user); }\n\n<span class=\"cm\">// @CacheEvict - xoá khỏi cache</span>\n<span class=\"an\">@CacheEvict</span>(value = <span class=\"st\">\"users\"</span>, key = <span class=\"st\">\"#id\"</span>)\n<span class=\"kw\">public void</span> <span class=\"fn\">delete</span>(Long id) { userRepo.deleteById(id); }\n\n<span class=\"cm\">// @CacheEvict - xoá toàn bộ cache users</span>\n<span class=\"an\">@CacheEvict</span>(value = <span class=\"st\">\"users\"</span>, allEntries = <span class=\"kw\">true</span>)</div>\n      <div class=\"tip-box\">💡 Cache providers: Simple (default, in-memory Map), Ehcache (local, phức tạp hơn), Redis (distributed, phổ biến nhất cho production).</div>",
    "tags": "spring config",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 99,
    "numStr": "99",
    "question": "Spring Boot Starter là gì?",
    "answerHtml": "<p>Starter là <strong>dependency bundle</strong> — tập hợp thư viện liên quan vào 1 dependency, đúng phiên bản tương thích nhau. Không cần tự quản lý từng thư viện và version conflict.</p>\n      <table class=\"compare-table\">\n        <tr><th>Starter</th><th>Bao gồm</th></tr>\n        <tr><td>spring-boot-starter-web</td><td>Spring MVC + Tomcat + Jackson</td></tr>\n        <tr><td>spring-boot-starter-data-jpa</td><td>Spring Data + Hibernate + JDBC</td></tr>\n        <tr><td>spring-boot-starter-security</td><td>Spring Security</td></tr>\n        <tr><td>spring-boot-starter-test</td><td>JUnit 5 + Mockito + MockMvc</td></tr>\n        <tr><td>spring-boot-starter-cache</td><td>Spring Cache + Caffeine</td></tr>\n      </table>",
    "tags": "spring core",
    "level": "junior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 100,
    "numStr": "100",
    "question": "Embedded Server trong Spring Boot là gì? Cách đổi sang Jetty?",
    "answerHtml": "<p>Spring Boot tích hợp sẵn server (Tomcat mặc định). Không cần deploy WAR, chạy trực tiếp: <code>java -jar app.jar</code></p>\n      <div class=\"code-block\"><span class=\"cm\">&lt;!-- Đổi từ Tomcat sang Jetty --&gt;</span>\n&lt;dependency&gt;\n    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;\n    &lt;artifactId&gt;spring-boot-starter-web&lt;/artifactId&gt;\n    &lt;exclusions&gt;\n        &lt;exclusion&gt;\n            &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;\n            &lt;artifactId&gt;spring-boot-starter-tomcat&lt;/artifactId&gt;\n        &lt;/exclusion&gt;\n    &lt;/exclusions&gt;\n&lt;/dependency&gt;\n&lt;dependency&gt;\n    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;\n    &lt;artifactId&gt;spring-boot-starter-jetty&lt;/artifactId&gt;\n&lt;/dependency&gt;</div>",
    "tags": "spring core",
    "level": "junior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 101,
    "numStr": "101",
    "question": "@Bean vs @Component khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>@Component</th><th>@Bean</th></tr>\n        <tr><td>Đặt ở đâu</td><td>Trên class definition</td><td>Trong @Configuration class, trên method</td></tr>\n        <tr><td>Scan</td><td>Spring component scan tự động</td><td>Phải định nghĩa thủ công</td></tr>\n        <tr><td>Dùng với class bên ngoài?</td><td>❌ (phải có source code)</td><td>✅ (third-party library)</td></tr>\n        <tr><td>Config chi tiết</td><td>Ít hơn</td><td>✅ Full control</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// @Component - annotate class của bạn</span>\n<span class=\"an\">@Component</span>\n<span class=\"kw\">class</span> <span class=\"cl\">MyService</span> { ... }\n\n<span class=\"cm\">// @Bean - cần thiết với thư viện ngoài (không có source)</span>\n<span class=\"an\">@Bean</span>\nRestTemplate <span class=\"fn\">restTemplate</span>() {\n    RestTemplate rt = <span class=\"kw\">new</span> RestTemplate();\n    rt.setInterceptors(List.of(<span class=\"kw\">new</span> LoggingInterceptor()));\n    <span class=\"kw\">return</span> rt;\n}</div>",
    "tags": "spring core",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 102,
    "numStr": "102",
    "question": "Lazy initialization là gì?",
    "answerHtml": "<p>Mặc định, Spring tạo tất cả singleton bean khi application start (<strong>Eager</strong>). Lazy initialization: bean chỉ tạo khi lần đầu được request.</p>\n      <p><strong>Ưu điểm Lazy:</strong> Startup nhanh hơn, ít memory hơn lúc đầu.</p>\n      <p><strong>Nhược điểm:</strong> Lỗi config chỉ được phát hiện khi bean được dùng (không fail-fast khi start).</p>\n      <div class=\"code-block\"><span class=\"cm\"># Bật global lazy initialization</span>\nspring.main.lazy-initialization=true\n\n<span class=\"cm\">// Chỉ bean cụ thể</span>\n<span class=\"an\">@Lazy</span>\n<span class=\"an\">@Service</span>\n<span class=\"kw\">class</span> <span class=\"cl\">HeavyService</span> { ... }\n\n<span class=\"cm\">// Inject lazy</span>\n<span class=\"kw\">public</span> <span class=\"fn\">OrderService</span>(<span class=\"an\">@Lazy</span> HeavyService heavy) { ... }</div>",
    "tags": "spring core",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 103,
    "numStr": "103",
    "question": "Spring AOP là gì? Các khái niệm cơ bản?",
    "answerHtml": "<p><strong>AOP (Aspect-Oriented Programming)</strong>: Tách <strong>cross-cutting concern</strong> (logging, security, transaction, audit...) ra khỏi business logic.</p>\n      <p><strong>Các khái niệm:</strong></p>\n      <ul>\n        <li><strong>Aspect</strong>: Class chứa cross-cutting logic (annotated <code>@Aspect</code>)</li>\n        <li><strong>Advice</strong>: Hành động thực hiện — @Before, @After, @AfterReturning, @AfterThrowing, @Around</li>\n        <li><strong>Pointcut</strong>: Biểu thức xác định <em>where</em> advice áp dụng (method nào, class nào)</li>\n        <li><strong>Join Point</strong>: Điểm cụ thể trong execution (method call)</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"an\">@Aspect</span>\n<span class=\"an\">@Component</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">LoggingAspect</span> {\n\n    <span class=\"an\">@Around</span>(<span class=\"st\">\"execution(* com.example.service.*.*(..))\"</span>)\n    <span class=\"kw\">public</span> Object <span class=\"fn\">logExecutionTime</span>(ProceedingJoinPoint pjp) <span class=\"kw\">throws</span> Throwable {\n        <span class=\"kw\">long</span> start = System.currentTimeMillis();\n        Object result = pjp.proceed(); <span class=\"cm\">// gọi method gốc</span>\n        <span class=\"kw\">long</span> time = System.currentTimeMillis() - start;\n        log.info(<span class=\"st\">\"{} executed in {}ms\"</span>, pjp.getSignature(), time);\n        <span class=\"kw\">return</span> result;\n    }\n}</div>",
    "tags": "spring core",
    "level": "senior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Boot Config & Misc"
  },
  {
    "num": 151,
    "numStr": "151",
    "question": "Unit test vs Integration test vs E2E test khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Unit Test</th><th>Integration Test</th><th>E2E Test</th></tr>\n        <tr><td>Test gì</td><td>1 class/method độc lập</td><td>Nhiều layer kết hợp (DB, API)</td><td>Toàn bộ flow user</td></tr>\n        <tr><td>Dependency</td><td>Mock hết</td><td>Dùng real DB, real Spring context</td><td>Dùng real system</td></tr>\n        <tr><td>Tốc độ</td><td>Rất nhanh (ms)</td><td>Chậm hơn (giây)</td><td>Chậm nhất (phút)</td></tr>\n        <tr><td>Annotation</td><td>@ExtendWith(Mockito)</td><td>@SpringBootTest</td><td>Selenium, Playwright</td></tr>\n        <tr><td>Tỷ lệ đề xuất</td><td>70%</td><td>20%</td><td>10%</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// Unit test - nhanh, isolate</span>\n<span class=\"an\">@ExtendWith</span>(MockitoExtension.class)\n<span class=\"kw\">class</span> <span class=\"cl\">OrderServiceTest</span> {\n    <span class=\"an\">@Mock</span> OrderRepository repo;          <span class=\"cm\">// mock dependency</span>\n    <span class=\"an\">@InjectMocks</span> OrderService service;   <span class=\"cm\">// inject mock vào class cần test</span>\n\n    <span class=\"an\">@Test</span>\n    <span class=\"kw\">void</span> <span class=\"fn\">shouldCreateOrder</span>() { ... }\n}\n\n<span class=\"cm\">// Integration test - dùng @SpringBootTest + DB thật</span>\n<span class=\"an\">@SpringBootTest</span>\n<span class=\"an\">@Transactional</span>  <span class=\"cm\">// rollback sau mỗi test</span>\n<span class=\"kw\">class</span> <span class=\"cl\">OrderServiceIntegrationTest</span> { ... }</div>\n      <div class=\"tip-box\">💡 Test Pyramid: nhiều unit test (nhanh, rẻ) → ít integration test → ít E2E test. Đừng chỉ viết integration test vì chúng chậm và fragile.</div>",
    "tags": "spring test",
    "level": "middle",
    "section": "Testing",
    "sectionIcon": "🧪",
    "sectionColor": "#fbbf24",
    "sectionColorClass": "",
    "subsection": "Unit Test, Integration Test & TDD"
  },
  {
    "num": 152,
    "numStr": "152",
    "question": "Mockito — @Mock, @InjectMocks, verify(), ArgumentCaptor dùng thế nào?",
    "answerHtml": "<div class=\"code-block\"><span class=\"an\">@ExtendWith</span>(MockitoExtension.class)\n<span class=\"kw\">class</span> <span class=\"cl\">UserServiceTest</span> {\n    <span class=\"an\">@Mock</span>\n    <span class=\"kw\">private</span> UserRepository userRepo;   <span class=\"cm\">// tạo mock object</span>\n    <span class=\"an\">@Mock</span>\n    <span class=\"kw\">private</span> EmailService emailService;\n\n    <span class=\"an\">@InjectMocks</span>\n    <span class=\"kw\">private</span> UserService userService;    <span class=\"cm\">// inject các mock vào đây</span>\n\n    <span class=\"an\">@Test</span>\n    <span class=\"kw\">void</span> <span class=\"fn\">shouldSendWelcomeEmail</span>() {\n        <span class=\"cm\">// Arrange: mock behavior</span>\n        User user = <span class=\"kw\">new</span> User(<span class=\"num\">1L</span>, <span class=\"st\">\"alice@email.com\"</span>);\n        when(userRepo.save(any())).thenReturn(user);\n\n        <span class=\"cm\">// Act</span>\n        userService.register(<span class=\"kw\">new</span> RegisterRequest(<span class=\"st\">\"alice@email.com\"</span>));\n\n        <span class=\"cm\">// Assert: verify method được gọi đúng</span>\n        verify(emailService, times(<span class=\"num\">1</span>)).sendWelcome(user.getEmail());\n        verify(userRepo).save(any(User.class));\n\n        <span class=\"cm\">// ArgumentCaptor: kiểm tra argument được truyền vào</span>\n        ArgumentCaptor&lt;User&gt; captor = ArgumentCaptor.forClass(User.class);\n        verify(userRepo).save(captor.capture());\n        assertEquals(<span class=\"st\">\"alice@email.com\"</span>, captor.getValue().getEmail());\n    }\n\n    <span class=\"an\">@Test</span>\n    <span class=\"kw\">void</span> <span class=\"fn\">shouldThrowWhenEmailExists</span>() {\n        when(userRepo.existsByEmail(any())).thenReturn(<span class=\"kw\">true</span>);\n        assertThrows(EmailAlreadyExistsException.class,\n            () -&gt; userService.register(<span class=\"kw\">new</span> RegisterRequest(<span class=\"st\">\"alice@email.com\"</span>)));\n    }\n}</div>",
    "tags": "spring test",
    "level": "middle",
    "section": "Testing",
    "sectionIcon": "🧪",
    "sectionColor": "#fbbf24",
    "sectionColorClass": "",
    "subsection": "Unit Test, Integration Test & TDD"
  },
  {
    "num": 153,
    "numStr": "153",
    "question": "Testcontainers là gì? Tại sao tốt hơn H2 in-memory?",
    "answerHtml": "<p>Testcontainers spin up <strong>Docker container thật</strong> (PostgreSQL, Redis, Kafka…) cho integration test — thay vì dùng H2 in-memory fake database.</p>\n      <table class=\"compare-table\">\n        <tr><th></th><th>H2 in-memory</th><th>Testcontainers</th></tr>\n        <tr><td>DB</td><td>Fake (H2 dialect)</td><td>DB thật (PostgreSQL, MySQL)</td></tr>\n        <tr><td>Behavior</td><td>Khác production (SQL dialect)</td><td>Giống hệt production</td></tr>\n        <tr><td>Setup</td><td>Đơn giản</td><td>Cần Docker</td></tr>\n        <tr><td>Test độ tin cậy</td><td>Thấp hơn</td><td>Cao — không có surprises ở prod</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"an\">@SpringBootTest</span>\n<span class=\"an\">@Testcontainers</span>\n<span class=\"kw\">class</span> <span class=\"cl\">OrderRepositoryTest</span> {\n\n    <span class=\"an\">@Container</span>\n    <span class=\"kw\">static</span> PostgreSQLContainer&lt;?&gt; postgres =\n        <span class=\"kw\">new</span> PostgreSQLContainer&lt;&gt;(<span class=\"st\">\"postgres:15\"</span>)\n            .withDatabaseName(<span class=\"st\">\"testdb\"</span>);\n\n    <span class=\"an\">@DynamicPropertySource</span>\n    <span class=\"kw\">static void</span> <span class=\"fn\">props</span>(DynamicPropertyRegistry r) {\n        r.add(<span class=\"st\">\"spring.datasource.url\"</span>, postgres::getJdbcUrl);\n        r.add(<span class=\"st\">\"spring.datasource.username\"</span>, postgres::getUsername);\n        r.add(<span class=\"st\">\"spring.datasource.password\"</span>, postgres::getPassword);\n    }\n\n    <span class=\"an\">@Test</span>\n    <span class=\"kw\">void</span> <span class=\"fn\">testSaveAndFind</span>() { <span class=\"cm\">// test với PostgreSQL thật!</span> }\n}</div>\n      <div class=\"tip-box\">💡 Testcontainers dùng shared container (reuse=true) để không phải restart Docker giữa các test — tối ưu tốc độ.</div>",
    "tags": "spring test",
    "level": "senior",
    "section": "Testing",
    "sectionIcon": "🧪",
    "sectionColor": "#fbbf24",
    "sectionColorClass": "",
    "subsection": "Unit Test, Integration Test & TDD"
  },
  {
    "num": 154,
    "numStr": "154",
    "question": "TDD là gì? Red-Green-Refactor cycle hoạt động thế nào?",
    "answerHtml": "<p><strong>TDD (Test-Driven Development):</strong> Viết test TRƯỚC khi viết code. Nghe lạ nhưng giúp design API tốt hơn và đảm bảo coverage tự nhiên.</p>\n      <div class=\"code-block\">🔴 RED:     Viết test mới → test fail (vì chưa có code)\n🟢 GREEN:   Viết code tối thiểu để test pass (không hơn không kém)\n🔵 REFACTOR: Cải thiện code mà không break test\n\n→ Lặp lại cho feature tiếp theo</div>\n      <div class=\"code-block\"><span class=\"cm\">// Bước 1: RED - viết test trước</span>\n<span class=\"an\">@Test</span>\n<span class=\"kw\">void</span> <span class=\"fn\">shouldRejectNegativeAmount</span>() {\n    assertThrows(IllegalArgumentException.class,\n        () -&gt; <span class=\"kw\">new</span> Transfer(-<span class=\"num\">100</span>, <span class=\"st\">\"USD\"</span>));  <span class=\"cm\">// compile error → class chưa tồn tại</span>\n}\n\n<span class=\"cm\">// Bước 2: GREEN - viết code đủ để pass</span>\n<span class=\"kw\">class</span> <span class=\"cl\">Transfer</span> {\n    Transfer(<span class=\"kw\">double</span> amount, String currency) {\n        <span class=\"kw\">if</span> (amount &lt; <span class=\"num\">0</span>) <span class=\"kw\">throw new</span> IllegalArgumentException(<span class=\"st\">\"Negative\"</span>);\n    }\n}\n\n<span class=\"cm\">// Bước 3: REFACTOR - clean up</span></div>\n      <p><strong>Lợi ích TDD:</strong></p>\n      <ul>\n        <li>✅ Coverage tự nhiên ~100% cho code logic</li>\n        <li>✅ API được design từ góc nhìn consumer (dễ dùng hơn)</li>\n        <li>✅ Refactor an toàn — test là safety net</li>\n        <li>❌ Cần discipline, cần team quen — không phù hợp prototype nhanh</li>\n      </ul>",
    "tags": "spring test",
    "level": "senior",
    "section": "Testing",
    "sectionIcon": "🧪",
    "sectionColor": "#fbbf24",
    "sectionColorClass": "",
    "subsection": "Unit Test, Integration Test & TDD"
  },
  {
    "num": 104,
    "numStr": "104",
    "question": "Spring Boot Externalized Configuration thứ tự ưu tiên?",
    "answerHtml": "<p>Config sau trong danh sách <strong>override config trước</strong> (số lớn = ưu tiên cao hơn):</p>\n      <div class=\"code-block\"><span class=\"num\">1</span>. Default properties (@SpringBootApplication)\n<span class=\"num\">2</span>. @PropertySource trong @Configuration\n<span class=\"num\">3</span>. application.yml / application.properties\n<span class=\"num\">4</span>. application-{profile}.yml\n<span class=\"num\">5</span>. OS Environment variables      ← thường dùng trong Docker/K8s\n<span class=\"num\">6</span>. Java System properties (-Dkey=value)\n<span class=\"num\">7</span>. Command-line arguments (--key=value)  ← ưu tiên cao nhất</div>\n      <div class=\"tip-box\">💡 Thực tế: Base config trong application.yml, sensitive config (DB password, JWT secret) qua Environment variable hoặc secrets manager (Vault, AWS Secrets Manager).</div>",
    "tags": "spring config",
    "level": "senior",
    "section": "Testing",
    "sectionIcon": "🧪",
    "sectionColor": "#fbbf24",
    "sectionColorClass": "",
    "subsection": "Unit Test, Integration Test & TDD"
  },
  {
    "num": 105,
    "numStr": "105",
    "question": "Cách tối ưu startup time Spring Boot?",
    "answerHtml": "<ul>\n        <li><strong>Lazy initialization:</strong> <code>spring.main.lazy-initialization=true</code> — bean tạo khi cần</li>\n        <li><strong>Giảm component scan:</strong> Chỉ scan package cần thiết thay vì toàn bộ classpath</li>\n        <li><strong>Loại bỏ starter không dùng:</strong> Không add dependency thừa (mỗi auto-config thêm overhead)</li>\n        <li><strong>spring-context-indexer:</strong> Tạo index của component scan lúc build, không scan lúc runtime</li>\n        <li><strong>Spring Native (GraalVM):</strong> Compile thành native executable → startup &lt;100ms, nhưng build lâu hơn nhiều</li>\n        <li><strong>Class Data Sharing (CDS):</strong> JVM feature share class metadata giữa các lần run</li>\n      </ul>",
    "tags": "spring config",
    "level": "senior",
    "section": "Testing",
    "sectionIcon": "🧪",
    "sectionColor": "#fbbf24",
    "sectionColorClass": "",
    "subsection": "Unit Test, Integration Test & TDD"
  },
  {
    "num": 106,
    "numStr": "106",
    "question": "Validation trong Spring Boot thế nào?",
    "answerHtml": "<p>Spring Boot dùng <strong>Jakarta Bean Validation (Hibernate Validator)</strong> qua annotation.</p>\n      <div class=\"code-block\"><span class=\"cm\">// DTO với validation annotation</span>\n<span class=\"kw\">public record</span> <span class=\"cl\">CreateUserRequest</span>(\n    <span class=\"an\">@NotBlank</span>(message = <span class=\"st\">\"Name is required\"</span>)\n    <span class=\"an\">@Size</span>(min = <span class=\"num\">2</span>, max = <span class=\"num\">50</span>)\n    String name,\n\n    <span class=\"an\">@Email</span>(message = <span class=\"st\">\"Invalid email\"</span>)\n    <span class=\"an\">@NotNull</span>\n    String email,\n\n    <span class=\"an\">@Min</span>(<span class=\"num\">18</span>) <span class=\"an\">@Max</span>(<span class=\"num\">120</span>)\n    <span class=\"kw\">int</span> age,\n\n    <span class=\"an\">@Pattern</span>(regexp = <span class=\"st\">\"^\\\\+?[0-9]{10,15}$\"</span>)\n    String phone\n) {}\n\n<span class=\"cm\">// Controller - thêm @Valid để trigger validation</span>\n<span class=\"an\">@PostMapping</span>(<span class=\"st\">\"/users\"</span>)\nUser <span class=\"fn\">create</span>(<span class=\"an\">@Valid</span> <span class=\"an\">@RequestBody</span> CreateUserRequest request) { ... }\n<span class=\"cm\">// Nếu không valid → MethodArgumentNotValidException → 400 Bad Request</span></div>",
    "tags": "spring web",
    "level": "middle",
    "section": "Testing",
    "sectionIcon": "🧪",
    "sectionColor": "#fbbf24",
    "sectionColorClass": "",
    "subsection": "Unit Test, Integration Test & TDD"
  },
  {
    "num": 107,
    "numStr": "107",
    "question": "Optimistic vs Pessimistic Locking là gì?",
    "answerHtml": "<p>Cơ chế xử lý concurrent update trên cùng record trong DB.</p>\n      <table class=\"compare-table\">\n        <tr><th></th><th>Optimistic Locking</th><th>Pessimistic Locking</th></tr>\n        <tr><td>Giả định</td><td>Conflict hiếm → kiểm tra sau</td><td>Conflict thường → lock trước</td></tr>\n        <tr><td>Cơ chế</td><td>Version number, conflict → throw Exception</td><td>DB-level lock (SELECT FOR UPDATE)</td></tr>\n        <tr><td>Hiệu năng</td><td>Tốt hơn (không block)</td><td>Kém hơn (blocking)</td></tr>\n        <tr><td>Dùng khi</td><td>Read nhiều, write ít, conflict hiếm</td><td>Write nhiều, conflict thường xuyên</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// Optimistic Locking - dùng @Version</span>\n<span class=\"an\">@Entity</span>\n<span class=\"kw\">class</span> <span class=\"cl\">Product</span> {\n    <span class=\"an\">@Version</span>\n    <span class=\"kw\">private int</span> version; <span class=\"cm\">// tự increment mỗi update</span>\n    <span class=\"cm\">// Nếu 2 user đọc version=1, update cùng lúc → người sau throw OptimisticLockException</span>\n}\n\n<span class=\"cm\">// Pessimistic Locking</span>\n<span class=\"an\">@Lock</span>(LockModeType.PESSIMISTIC_WRITE)\n<span class=\"an\">@Query</span>(<span class=\"st\">\"SELECT p FROM Product p WHERE p.id = :id\"</span>)\nOptional&lt;Product&gt; <span class=\"fn\">findByIdWithLock</span>(<span class=\"an\">@Param</span>(<span class=\"st\">\"id\"</span>) Long id);</div>",
    "tags": "spring jpa",
    "level": "middle",
    "section": "Testing",
    "sectionIcon": "🧪",
    "sectionColor": "#fbbf24",
    "sectionColorClass": "",
    "subsection": "Unit Test, Integration Test & TDD"
  },
  {
    "num": 108,
    "numStr": "108",
    "question": "CORS là gì? Cấu hình trong Spring Boot thế nào?",
    "answerHtml": "<p><strong>CORS (Cross-Origin Resource Sharing)</strong>: Browser chặn request từ origin khác (domain, port, protocol khác) vì Same-Origin Policy. CORS là cơ chế server cho phép browser gửi cross-origin request.</p>\n      <div class=\"code-block\"><span class=\"cm\">// Cách 1: @CrossOrigin trên Controller/Method</span>\n<span class=\"an\">@CrossOrigin</span>(origins = <span class=\"st\">\"http://localhost:3000\"</span>)\n<span class=\"an\">@RestController</span>\n<span class=\"kw\">class</span> <span class=\"cl\">UserController</span> { ... }\n\n<span class=\"cm\">// Cách 2: Global config (khuyến khích)</span>\n<span class=\"an\">@Bean</span>\nWebMvcConfigurer <span class=\"fn\">corsConfigurer</span>() {\n    <span class=\"kw\">return new</span> WebMvcConfigurer() {\n        <span class=\"an\">@Override</span>\n        <span class=\"kw\">public void</span> <span class=\"fn\">addCorsMappings</span>(CorsRegistry registry) {\n            registry.addMapping(<span class=\"st\">\"/api/**\"</span>)\n                .allowedOrigins(<span class=\"st\">\"https://myapp.com\"</span>, <span class=\"st\">\"http://localhost:3000\"</span>)\n                .allowedMethods(<span class=\"st\">\"GET\"</span>, <span class=\"st\">\"POST\"</span>, <span class=\"st\">\"PUT\"</span>, <span class=\"st\">\"DELETE\"</span>)\n                .allowedHeaders(<span class=\"st\">\"*\"</span>)\n                .allowCredentials(<span class=\"kw\">true</span>);\n        }\n    };\n}</div>",
    "tags": "spring web",
    "level": "middle",
    "section": "Testing",
    "sectionIcon": "🧪",
    "sectionColor": "#fbbf24",
    "sectionColorClass": "",
    "subsection": "Unit Test, Integration Test & TDD"
  },
  {
    "num": 109,
    "numStr": "109",
    "question": "Spring Boot DevTools là gì?",
    "answerHtml": "<p>Module hỗ trợ development, <strong>tự loại khỏi production build</strong> (fat jar):</p>\n      <ul>\n        <li><strong>Automatic restart:</strong> Detect classpath thay đổi → tự restart (nhanh hơn cold restart vì dùng 2 ClassLoader)</li>\n        <li><strong>LiveReload:</strong> Browser tự reload khi static resource thay đổi</li>\n        <li><strong>Disable cache:</strong> Tắt cache của template engine (Thymeleaf, FreeMarker) để thấy thay đổi ngay</li>\n        <li><strong>H2 console:</strong> Tự bật H2 console khi dùng H2</li>\n      </ul>\n      <div class=\"code-block\">&lt;dependency&gt;\n    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;\n    &lt;artifactId&gt;spring-boot-devtools&lt;/artifactId&gt;\n    &lt;optional&gt;true&lt;/optional&gt;  <span class=\"cm\">&lt;!-- không include trong production --&gt;</span>\n&lt;/dependency&gt;</div>",
    "tags": "spring core",
    "level": "junior",
    "section": "Testing",
    "sectionIcon": "🧪",
    "sectionColor": "#fbbf24",
    "sectionColorClass": "",
    "subsection": "Unit Test, Integration Test & TDD"
  },
  {
    "num": 110,
    "numStr": "110",
    "question": "@PostConstruct và @PreDestroy là gì?",
    "answerHtml": "<p>Annotation để hook vào <strong>vòng đời của bean</strong>:</p>\n      <ul>\n        <li><code>@PostConstruct</code>: Chạy <strong>sau khi bean tạo xong và inject đầy đủ dependency</strong> — dùng để khởi tạo (load cache, connect, validate config)</li>\n        <li><code>@PreDestroy</code>: Chạy <strong>trước khi bean bị destroy</strong> (app shutdown) — dùng để cleanup (đóng connection, flush data)</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"an\">@Service</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">CacheService</span> {\n    <span class=\"kw\">private</span> Map&lt;String, Object&gt; cache;\n\n    <span class=\"an\">@PostConstruct</span>\n    <span class=\"kw\">void</span> <span class=\"fn\">init</span>() {\n        cache = <span class=\"kw\">new</span> ConcurrentHashMap&lt;&gt;();\n        loadInitialData();  <span class=\"cm\">// gọi sau khi inject xong</span>\n        log.info(<span class=\"st\">\"Cache initialized\"</span>);\n    }\n\n    <span class=\"an\">@PreDestroy</span>\n    <span class=\"kw\">void</span> <span class=\"fn\">cleanup</span>() {\n        cache.clear();\n        log.info(<span class=\"st\">\"Cache cleared\"</span>);\n    }\n}</div>\n      <div class=\"tip-box\">💡 Thứ tự vòng đời bean: Constructor → @Autowired inject → @PostConstruct → Sử dụng → @PreDestroy → Destroy</div>",
    "tags": "spring core",
    "level": "middle",
    "section": "Testing",
    "sectionIcon": "🧪",
    "sectionColor": "#fbbf24",
    "sectionColorClass": "",
    "subsection": "Unit Test, Integration Test & TDD"
  },
  {
    "num": 111,
    "numStr": "111",
    "question": "Kafka là gì? Tại sao dùng Kafka?",
    "answerHtml": "<p>Apache Kafka là <strong>distributed event streaming platform</strong> — hệ thống message broker phân tán, hiệu năng cao, dùng để truyền dữ liệu giữa các service theo mô hình <strong>publish/subscribe</strong>.</p>\n      <p><strong>Tại sao dùng Kafka?</strong></p>\n      <ul>\n        <li><strong>Tách coupling:</strong> Producer không cần biết Consumer — service A gửi event, service B/C/D xử lý độc lập</li>\n        <li><strong>Throughput cao:</strong> Ghi hàng triệu message/giây nhờ sequential disk I/O (append-only log)</li>\n        <li><strong>Replay được:</strong> Message lưu trên disk (mặc định 7 ngày), Consumer có thể đọc lại từ đầu</li>\n        <li><strong>Fault-tolerant:</strong> Replication — dữ liệu được sao chép sang nhiều broker</li>\n        <li><strong>Scalable:</strong> Thêm partition, thêm consumer dễ dàng</li>\n      </ul>\n      <div class=\"tip-box\">💡 Ví dụ thực tế: Đặt hàng → Kafka → Order Service, Inventory Service, Notification Service xử lý song song — không cần gọi trực tiếp nhau.</div>",
    "tags": "kafka",
    "level": "junior",
    "section": "Kafka",
    "sectionIcon": "🟠",
    "sectionColor": "#f97316",
    "sectionColorClass": "",
    "subsection": "Kafka Cơ Bản"
  },
  {
    "num": 112,
    "numStr": "112",
    "question": "Topic, Partition, Offset, Consumer Group trong Kafka là gì?",
    "answerHtml": "<ul>\n        <li><strong>Topic:</strong> Kênh dữ liệu — giống như một \"hàng đợi có tên\". VD: <code>order-created</code>, <code>payment-processed</code></li>\n        <li><strong>Partition:</strong> Topic được chia thành nhiều partition — đơn vị song song hóa. Mỗi partition là một append-only log, được ghi tuần tự.</li>\n        <li><strong>Offset:</strong> Số thứ tự của message trong partition (bắt đầu từ 0). Consumer lưu offset để biết đã đọc đến đâu.</li>\n        <li><strong>Consumer Group:</strong> Nhóm consumer cùng nhau xử lý một topic. Mỗi partition chỉ được đọc bởi <strong>1 consumer trong group</strong> tại một thời điểm → load balancing tự động.</li>\n      </ul>\n      <div class=\"code-block\">Topic: order-created (3 partitions)\n├── Partition 0: [msg0, msg1, msg4, ...]  ← Consumer 1 đọc\n├── Partition 1: [msg2, msg5, ...]        ← Consumer 2 đọc\n└── Partition 2: [msg3, msg6, ...]        ← Consumer 3 đọc\n\nConsumer Group A: 3 consumers → mỗi consumer 1 partition\nConsumer Group B: 1 consumer  → consumer đó đọc cả 3 partition</div>\n      <div class=\"warn-box\">⚠️ Số consumer trong group > số partition → consumer thừa sẽ idle (không nhận message).</div>",
    "tags": "kafka",
    "level": "middle",
    "section": "Kafka",
    "sectionIcon": "🟠",
    "sectionColor": "#f97316",
    "sectionColorClass": "",
    "subsection": "Kafka Cơ Bản"
  },
  {
    "num": 113,
    "numStr": "113",
    "question": "Kafka đảm bảo thứ tự message như thế nào?",
    "answerHtml": "<p>Kafka <strong>đảm bảo thứ tự trong cùng một partition</strong>, nhưng <span class=\"warn\">không đảm bảo thứ tự giữa các partition khác nhau</span>.</p>\n      <ul>\n        <li>Message trong cùng partition được append tuần tự → consumer đọc theo đúng thứ tự</li>\n        <li>Dùng <strong>Partition Key</strong> để đảm bảo các message liên quan đến cùng entity đi vào cùng partition</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"cm\">// Tất cả order của user \"123\" vào cùng partition</span>\nproducer.send(<span class=\"kw\">new</span> ProducerRecord&lt;&gt;(\n    <span class=\"st\">\"order-events\"</span>,\n    <span class=\"st\">\"user-123\"</span>,  <span class=\"cm\">// partition key</span>\n    orderJson\n));</div>\n      <div class=\"tip-box\">💡 Ví dụ: Event \"order created\" và \"order cancelled\" của cùng 1 đơn hàng phải dùng orderId làm key → đảm bảo xử lý đúng thứ tự.</div>",
    "tags": "kafka",
    "level": "middle",
    "section": "Kafka",
    "sectionIcon": "🟠",
    "sectionColor": "#f97316",
    "sectionColorClass": "",
    "subsection": "Kafka Cơ Bản"
  },
  {
    "num": 114,
    "numStr": "114",
    "question": "At-most-once, At-least-once, Exactly-once trong Kafka là gì?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th>Delivery Semantics</th><th>Ý nghĩa</th><th>Rủi ro</th><th>Config</th></tr>\n        <tr><td><strong>At-most-once</strong></td><td>Gửi tối đa 1 lần, có thể mất message</td><td>Mất dữ liệu</td><td>acks=0</td></tr>\n        <tr><td><strong>At-least-once</strong></td><td>Đảm bảo gửi được, có thể duplicate</td><td>Duplicate</td><td>acks=all + retry</td></tr>\n        <tr><td><strong>Exactly-once</strong></td><td>Đúng 1 lần, không mất, không dup</td><td>Phức tạp hơn</td><td>enable.idempotence=true + Transactions</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// At-least-once (phổ biến nhất)</span>\nprops.put(<span class=\"st\">\"acks\"</span>, <span class=\"st\">\"all\"</span>);\nprops.put(<span class=\"st\">\"retries\"</span>, <span class=\"num\">3</span>);\n\n<span class=\"cm\">// Exactly-once (Kafka 0.11+)</span>\nprops.put(<span class=\"st\">\"enable.idempotence\"</span>, <span class=\"st\">\"true\"</span>);\nprops.put(<span class=\"st\">\"transactional.id\"</span>, <span class=\"st\">\"my-producer-1\"</span>);</div>\n      <div class=\"tip-box\">💡 Thực tế: Dùng at-least-once + consumer idempotent (xử lý duplicate message an toàn). Exactly-once có overhead, chỉ dùng khi thực sự cần.</div>",
    "tags": "kafka",
    "level": "senior",
    "section": "Kafka",
    "sectionIcon": "🟠",
    "sectionColor": "#f97316",
    "sectionColorClass": "",
    "subsection": "Kafka Cơ Bản"
  },
  {
    "num": 115,
    "numStr": "115",
    "question": "Kafka Replication và Leader/Follower hoạt động thế nào?",
    "answerHtml": "<p>Mỗi partition được replicate sang nhiều broker để fault-tolerance:</p>\n      <ul>\n        <li><strong>Leader:</strong> Broker chịu trách nhiệm đọc/ghi cho partition đó</li>\n        <li><strong>Follower (ISR):</strong> Sao chép data từ leader — In-Sync Replicas</li>\n        <li>Khi leader chết → ISR bầu chọn leader mới tự động → <strong>tự heal</strong></li>\n      </ul>\n      <div class=\"code-block\">Topic: payments, replication-factor=3\nPartition 0: Leader=Broker1, Follower=Broker2, Follower=Broker3\nPartition 1: Leader=Broker2, Follower=Broker1, Follower=Broker3\n\n<span class=\"cm\">// Config producer ghi vào tất cả ISR mới confirm</span>\nacks=all  <span class=\"cm\">// đảm bảo không mất data khi leader chết</span></div>\n      <div class=\"warn-box\">⚠️ <code>replication.factor=3</code> là best practice cho production. Đảm bảo chịu được 2 broker chết.</div>",
    "tags": "kafka",
    "level": "senior",
    "section": "Kafka",
    "sectionIcon": "🟠",
    "sectionColor": "#f97316",
    "sectionColorClass": "",
    "subsection": "Kafka Cơ Bản"
  },
  {
    "num": 116,
    "numStr": "116",
    "question": "Kafka vs RabbitMQ khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Kafka</th><th>RabbitMQ</th></tr>\n        <tr><td>Mô hình</td><td>Pub/Sub + Log-based</td><td>Message Queue (Push)</td></tr>\n        <tr><td>Lưu message</td><td>✅ Disk (replay được)</td><td>❌ Xóa sau khi consumer ACK</td></tr>\n        <tr><td>Throughput</td><td>Triệu msg/s</td><td>Hàng chục nghìn msg/s</td></tr>\n        <tr><td>Ordering</td><td>Trong partition</td><td>Trong queue</td></tr>\n        <tr><td>Consumer</td><td>Pull (consumer tự kéo)</td><td>Push (broker đẩy)</td></tr>\n        <tr><td>Use case</td><td>Event streaming, log, audit</td><td>Task queue, RPC</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 Kafka: dùng khi cần replay, nhiều consumer đọc cùng data, throughput lớn. RabbitMQ: dùng khi cần routing phức tạp, task queue đơn giản.</div>",
    "tags": "kafka",
    "level": "middle",
    "section": "Kafka",
    "sectionIcon": "🟠",
    "sectionColor": "#f97316",
    "sectionColorClass": "",
    "subsection": "Kafka Cơ Bản"
  },
  {
    "num": 117,
    "numStr": "117",
    "question": "Dùng Kafka trong Spring Boot như thế nào?",
    "answerHtml": "<div class=\"code-block\"><span class=\"cm\">// Producer</span>\n<span class=\"an\">@Service</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">OrderProducer</span> {\n    <span class=\"an\">@Autowired</span>\n    <span class=\"kw\">private</span> KafkaTemplate&lt;String, String&gt; kafkaTemplate;\n\n    <span class=\"kw\">public void</span> <span class=\"fn\">sendOrder</span>(Order order) {\n        kafkaTemplate.send(<span class=\"st\">\"order-events\"</span>, order.getId(), toJson(order));\n    }\n}\n\n<span class=\"cm\">// Consumer</span>\n<span class=\"an\">@Service</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">OrderConsumer</span> {\n    <span class=\"an\">@KafkaListener</span>(topics = <span class=\"st\">\"order-events\"</span>, groupId = <span class=\"st\">\"inventory-group\"</span>)\n    <span class=\"kw\">public void</span> <span class=\"fn\">consume</span>(String message, <span class=\"an\">@Header</span>(KafkaHeaders.RECEIVED_PARTITION) <span class=\"kw\">int</span> partition) {\n        log.info(<span class=\"st\">\"Received from partition {}: {}\"</span>, partition, message);\n        processOrder(message);\n    }\n}</div>\n      <div class=\"code-block\"><span class=\"cm\"># application.yml</span>\nspring.kafka:\n  bootstrap-servers: localhost:9092\n  consumer:\n    group-id: my-group\n    auto-offset-reset: earliest\n    key-deserializer: org.apache.kafka.common.serialization.StringDeserializer\n    value-deserializer: org.apache.kafka.common.serialization.StringDeserializer</div>",
    "tags": "kafka spring",
    "level": "middle",
    "section": "Kafka",
    "sectionIcon": "🟠",
    "sectionColor": "#f97316",
    "sectionColorClass": "",
    "subsection": "Kafka Cơ Bản"
  },
  {
    "num": 118,
    "numStr": "118",
    "question": "Redis là gì? Tại sao dùng Redis?",
    "answerHtml": "<p>Redis (Remote Dictionary Server) là <strong>in-memory data store</strong> — lưu dữ liệu trong RAM. Tốc độ đọc/ghi cực nhanh (~100,000 ops/s).</p>\n      <p><strong>Dùng Redis khi nào?</strong></p>\n      <ul>\n        <li>🗂️ <strong>Caching:</strong> Cache kết quả DB query, API response tốn kém → giảm tải DB</li>\n        <li>🔐 <strong>Session store:</strong> Lưu session/JWT token với TTL</li>\n        <li>🚦 <strong>Rate limiting:</strong> Đếm số request trong thời gian ngắn</li>\n        <li>📊 <strong>Leaderboard:</strong> Xếp hạng real-time bằng Sorted Set</li>\n        <li>📨 <strong>Message queue:</strong> Pub/Sub, Stream</li>\n        <li>🔒 <strong>Distributed lock:</strong> Lock giữa nhiều instance</li>\n      </ul>\n      <div class=\"tip-box\">💡 Ví dụ: Query danh sách sản phẩm từ DB mất 200ms. Cache vào Redis → lần sau chỉ mất 1ms. Giảm 200x!</div>",
    "tags": "redis",
    "level": "junior",
    "section": "Redis",
    "sectionIcon": "🔴",
    "sectionColor": "#ef4444",
    "sectionColorClass": "",
    "subsection": "Redis Cơ Bản"
  },
  {
    "num": 119,
    "numStr": "119",
    "question": "Các kiểu dữ liệu trong Redis là gì?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th>Type</th><th>Dùng cho</th><th>Ví dụ lệnh</th></tr>\n        <tr><td><strong>String</strong></td><td>Cache value đơn giản, counter</td><td>SET, GET, INCR</td></tr>\n        <tr><td><strong>Hash</strong></td><td>Object (user profile, config)</td><td>HSET, HGET, HGETALL</td></tr>\n        <tr><td><strong>List</strong></td><td>Queue, recent items, timeline</td><td>LPUSH, RPOP, LRANGE</td></tr>\n        <tr><td><strong>Set</strong></td><td>Unique members, tags</td><td>SADD, SMEMBERS, SINTER</td></tr>\n        <tr><td><strong>Sorted Set</strong></td><td>Leaderboard, priority queue</td><td>ZADD, ZRANGE, ZRANK</td></tr>\n        <tr><td><strong>Stream</strong></td><td>Event log (giống mini-Kafka)</td><td>XADD, XREAD</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\"># String - cache user session</span>\nSET session:abc123 \"{userId:1, role:admin}\" EX 3600\n\n<span class=\"cm\"># Hash - user profile</span>\nHSET user:1 name \"Alice\" email \"alice@example.com\"\nHGET user:1 name  <span class=\"cm\"># → \"Alice\"</span>\n\n<span class=\"cm\"># Sorted Set - leaderboard điểm game</span>\nZADD leaderboard 9500 \"Alice\"\nZADD leaderboard 8200 \"Bob\"\nZRANGE leaderboard 0 9 REV WITHSCORES  <span class=\"cm\"># top 10</span></div>",
    "tags": "redis",
    "level": "middle",
    "section": "Redis",
    "sectionIcon": "🔴",
    "sectionColor": "#ef4444",
    "sectionColorClass": "",
    "subsection": "Redis Cơ Bản"
  },
  {
    "num": 120,
    "numStr": "120",
    "question": "Cache Aside Pattern và Write-Through là gì?",
    "answerHtml": "<p><strong>Cache Aside (Lazy Loading) — phổ biến nhất:</strong></p>\n      <div class=\"code-block\"><span class=\"cm\">// 1. Kiểm tra cache trước</span>\nUser user = redis.get(<span class=\"st\">\"user:\"</span> + id);\n<span class=\"kw\">if</span> (user == <span class=\"kw\">null</span>) {\n    <span class=\"cm\">// 2. Cache miss → query DB</span>\n    user = db.findById(id);\n    <span class=\"cm\">// 3. Lưu vào cache với TTL</span>\n    redis.set(<span class=\"st\">\"user:\"</span> + id, user, Duration.ofMinutes(<span class=\"num\">10</span>));\n}\n<span class=\"kw\">return</span> user;</div>\n      <table class=\"compare-table\">\n        <tr><th>Pattern</th><th>Cách hoạt động</th><th>Ưu điểm</th><th>Nhược điểm</th></tr>\n        <tr><td><strong>Cache Aside</strong></td><td>App tự quản lý cache</td><td>Chỉ cache data được dùng</td><td>Cache miss lần đầu chậm</td></tr>\n        <tr><td><strong>Write-Through</strong></td><td>Ghi DB + cache đồng thời</td><td>Cache luôn fresh</td><td>Ghi chậm hơn, cache thừa</td></tr>\n        <tr><td><strong>Write-Behind</strong></td><td>Ghi cache trước, DB sau async</td><td>Ghi rất nhanh</td><td>Có thể mất data nếu crash</td></tr>\n      </table>",
    "tags": "redis",
    "level": "middle",
    "section": "Redis",
    "sectionIcon": "🔴",
    "sectionColor": "#ef4444",
    "sectionColorClass": "",
    "subsection": "Redis Cơ Bản"
  },
  {
    "num": 121,
    "numStr": "121",
    "question": "Cache Stampede / Thundering Herd là gì? Cách xử lý?",
    "answerHtml": "<p><strong>Cache Stampede:</strong> Khi cache expire, hàng nghìn request cùng lúc thấy cache miss → tất cả cùng query DB → DB quá tải.</p>\n      <p><strong>Giải pháp:</strong></p>\n      <ul>\n        <li>✅ <strong>Mutex/Lock:</strong> Chỉ 1 request được query DB, các request khác chờ cache</li>\n        <li>✅ <strong>Probabilistic Early Expiration:</strong> Refresh cache trước khi hết hạn một cách ngẫu nhiên</li>\n        <li>✅ <strong>TTL jitter:</strong> Thêm random offset vào TTL để các key không expire cùng lúc</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"cm\">// TTL jitter - tránh expire đồng loạt</span>\n<span class=\"kw\">int</span> baseTTL = <span class=\"num\">3600</span>;\n<span class=\"kw\">int</span> jitter = <span class=\"kw\">new</span> Random().nextInt(<span class=\"num\">300</span>); <span class=\"cm\">// ±5 phút random</span>\nredis.set(key, value, Duration.ofSeconds(baseTTL + jitter));\n\n<span class=\"cm\">// Distributed lock với Redisson</span>\nRLock lock = redisson.getLock(<span class=\"st\">\"lock:product:list\"</span>);\n<span class=\"kw\">if</span> (lock.tryLock(<span class=\"num\">100</span>, <span class=\"num\">5000</span>, TimeUnit.MILLISECONDS)) {\n    <span class=\"kw\">try</span> {\n        <span class=\"cm\">// chỉ 1 thread vào đây query DB</span>\n        data = db.findAll();\n        redis.set(<span class=\"st\">\"product:list\"</span>, data);\n    } <span class=\"kw\">finally</span> { lock.unlock(); }\n}</div>",
    "tags": "redis",
    "level": "senior",
    "section": "Redis",
    "sectionIcon": "🔴",
    "sectionColor": "#ef4444",
    "sectionColorClass": "",
    "subsection": "Redis Cơ Bản"
  },
  {
    "num": 122,
    "numStr": "122",
    "question": "Redis Persistence: RDB vs AOF là gì?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>RDB (Snapshot)</th><th>AOF (Append Only File)</th></tr>\n        <tr><td>Cơ chế</td><td>Chụp snapshot định kỳ ra file .rdb</td><td>Log từng write command vào file</td></tr>\n        <tr><td>Mất data tối đa</td><td>Vài phút (interval giữa 2 snapshot)</td><td>1 giây (nếu fsync=everysec)</td></tr>\n        <tr><td>Tốc độ restart</td><td>Nhanh hơn</td><td>Chậm hơn (replay toàn bộ log)</td></tr>\n        <tr><td>File size</td><td>Nhỏ hơn</td><td>Lớn hơn (có thể rewrite)</td></tr>\n        <tr><td>Dùng cho</td><td>Backup, cache có thể mất</td><td>Dữ liệu quan trọng</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 Best practice: Bật cả hai (RDB + AOF). RDB để backup nhanh, AOF để tránh mất data. Redis 7+ có RDB+AOF kết hợp.</div>",
    "tags": "redis",
    "level": "senior",
    "section": "Redis",
    "sectionIcon": "🔴",
    "sectionColor": "#ef4444",
    "sectionColorClass": "",
    "subsection": "Redis Cơ Bản"
  },
  {
    "num": 123,
    "numStr": "123",
    "question": "Dùng Redis Cache trong Spring Boot như thế nào?",
    "answerHtml": "<div class=\"code-block\"><span class=\"cm\">// 1. Enable caching</span>\n<span class=\"an\">@SpringBootApplication</span>\n<span class=\"an\">@EnableCaching</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">App</span> {}\n\n<span class=\"cm\">// 2. Dùng annotation</span>\n<span class=\"an\">@Service</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">ProductService</span> {\n    <span class=\"an\">@Cacheable</span>(value = <span class=\"st\">\"products\"</span>, key = <span class=\"st\">\"#id\"</span>)\n    <span class=\"kw\">public</span> Product <span class=\"fn\">findById</span>(Long id) {\n        <span class=\"kw\">return</span> db.findById(id); <span class=\"cm\">// chỉ gọi khi cache miss</span>\n    }\n\n    <span class=\"an\">@CachePut</span>(value = <span class=\"st\">\"products\"</span>, key = <span class=\"st\">\"#product.id\"</span>)\n    <span class=\"kw\">public</span> Product <span class=\"fn\">save</span>(Product product) {\n        <span class=\"kw\">return</span> db.save(product); <span class=\"cm\">// ghi DB + update cache</span>\n    }\n\n    <span class=\"an\">@CacheEvict</span>(value = <span class=\"st\">\"products\"</span>, key = <span class=\"st\">\"#id\"</span>)\n    <span class=\"kw\">public void</span> <span class=\"fn\">delete</span>(Long id) {\n        db.deleteById(id); <span class=\"cm\">// xóa DB + xóa cache</span>\n    }\n}</div>\n      <div class=\"code-block\"><span class=\"cm\"># application.yml</span>\nspring.data.redis:\n  host: localhost\n  port: 6379\nspring.cache:\n  type: redis\n  redis:\n    time-to-live: 600000  <span class=\"cm\"># 10 phút (milliseconds)</span></div>",
    "tags": "redis spring",
    "level": "middle",
    "section": "Redis",
    "sectionIcon": "🔴",
    "sectionColor": "#ef4444",
    "sectionColorClass": "",
    "subsection": "Redis Cơ Bản"
  },
  {
    "num": 124,
    "numStr": "124",
    "question": "Microservice vs Monolith khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Monolith</th><th>Microservice</th></tr>\n        <tr><td>Deploy</td><td>Deploy toàn bộ app</td><td>Deploy từng service độc lập</td></tr>\n        <tr><td>Scale</td><td>Scale toàn bộ app</td><td>Scale riêng từng service</td></tr>\n        <tr><td>Technology</td><td>1 tech stack</td><td>Mỗi service chọn tech riêng</td></tr>\n        <tr><td>Fault isolation</td><td>1 bug crash cả app</td><td>1 service chết, app vẫn sống</td></tr>\n        <tr><td>Complexity</td><td>Đơn giản ban đầu</td><td>Phức tạp hơn (network, distributed)</td></tr>\n        <tr><td>Phù hợp</td><td>Startup, team nhỏ</td><td>Scale lớn, nhiều team</td></tr>\n      </table>\n      <div class=\"warn-box\">⚠️ Đừng vội microservice! Bắt đầu bằng monolith. Chỉ chuyển sang microservice khi có vấn đề scale thực sự, team đủ lớn, và DevOps mature.</div>",
    "tags": "microservice",
    "level": "junior",
    "section": "Microservice",
    "sectionIcon": "🔷",
    "sectionColor": "#38bdf8",
    "sectionColorClass": "",
    "subsection": "Microservice Architecture"
  },
  {
    "num": 125,
    "numStr": "125",
    "question": "API Gateway là gì? Tại sao cần?",
    "answerHtml": "<p>API Gateway là <strong>single entry point</strong> — cổng vào duy nhất cho mọi request từ client. Thay vì client gọi trực tiếp từng service.</p>\n      <ul>\n        <li>🔑 <strong>Authentication/Authorization:</strong> Kiểm tra JWT một chỗ, không cần mỗi service tự check</li>\n        <li>🚦 <strong>Rate Limiting:</strong> Giới hạn request/user</li>\n        <li>🔀 <strong>Routing:</strong> /users → User Service, /orders → Order Service</li>\n        <li>⚖️ <strong>Load Balancing:</strong> Phân tải giữa các instance</li>\n        <li>📊 <strong>Logging/Monitoring:</strong> Centralized logging</li>\n        <li>🔄 <strong>Protocol translation:</strong> REST → gRPC</li>\n      </ul>\n      <div class=\"code-block\">Client → API Gateway → /users/**  → User Service (port 8081)\n                        → /orders/** → Order Service (port 8082)\n                        → /products/**→ Product Service (port 8083)</div>\n      <div class=\"tip-box\">💡 Spring Cloud Gateway, Kong, AWS API Gateway là các lựa chọn phổ biến.</div>",
    "tags": "microservice",
    "level": "middle",
    "section": "Microservice",
    "sectionIcon": "🔷",
    "sectionColor": "#38bdf8",
    "sectionColorClass": "",
    "subsection": "Microservice Architecture"
  },
  {
    "num": 126,
    "numStr": "126",
    "question": "Circuit Breaker Pattern là gì? Tại sao cần?",
    "answerHtml": "<p>Khi service B chậm/chết, Service A gọi sang B sẽ bị timeout → thread pool A bị chiếm hết → A cũng chết → <strong>cascading failure</strong>.</p>\n      <p>Circuit Breaker ngăn điều này bằng cách <strong>ngắt kết nối tạm thời</strong> khi detect failure:</p>\n      <div class=\"code-block\">CLOSED → (nhiều lỗi) → OPEN → (sau timeout) → HALF-OPEN\n   ↑                                                     |\n   └─────────── (thành công) ───────────────────────────┘\n\nCLOSED:    Gọi bình thường\nOPEN:      Fail fast ngay (không gọi service B), trả fallback\nHALF-OPEN: Thử vài request xem B đã recover chưa</div>\n      <div class=\"code-block\"><span class=\"cm\">// Resilience4j trong Spring Boot</span>\n<span class=\"an\">@CircuitBreaker</span>(name = <span class=\"st\">\"paymentService\"</span>, fallbackMethod = <span class=\"st\">\"fallback\"</span>)\n<span class=\"kw\">public</span> PaymentResult <span class=\"fn\">processPayment</span>(Order order) {\n    <span class=\"kw\">return</span> paymentServiceClient.process(order);\n}\n\n<span class=\"kw\">public</span> PaymentResult <span class=\"fn\">fallback</span>(Order order, Exception e) {\n    <span class=\"kw\">return</span> PaymentResult.pending(<span class=\"st\">\"Payment service unavailable, retry later\"</span>);\n}</div>",
    "tags": "microservice",
    "level": "senior",
    "section": "Microservice",
    "sectionIcon": "🔷",
    "sectionColor": "#38bdf8",
    "sectionColorClass": "",
    "subsection": "Microservice Architecture"
  },
  {
    "num": 127,
    "numStr": "127",
    "question": "Service Discovery là gì? Eureka hoạt động thế nào?",
    "answerHtml": "<p>Trong microservice, các service scale up/down liên tục → IP thay đổi → không hard-code được địa chỉ. <strong>Service Discovery</strong> giải quyết bằng cách đăng ký/tìm kiếm service theo tên.</p>\n      <div class=\"code-block\">Order Service muốn gọi Payment Service:\n1. Payment Service đăng ký với Eureka: \"Tôi là 'payment-service' tại 192.168.1.5:8082\"\n2. Order Service hỏi Eureka: \"Cho tôi địa chỉ 'payment-service'\"\n3. Eureka trả về: \"192.168.1.5:8082\"\n4. Order Service gọi Payment Service trực tiếp</div>\n      <div class=\"code-block\"><span class=\"cm\">// Eureka Server</span>\n<span class=\"an\">@EnableEurekaServer</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">DiscoveryServer</span> {}\n\n<span class=\"cm\">// Eureka Client (service đăng ký)</span>\n<span class=\"an\">@EnableDiscoveryClient</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">PaymentApp</span> {}\n\n<span class=\"cm\">// Gọi service theo tên, không cần IP</span>\n<span class=\"an\">@FeignClient</span>(name = <span class=\"st\">\"payment-service\"</span>)\n<span class=\"kw\">public interface</span> <span class=\"cl\">PaymentClient</span> {\n    <span class=\"an\">@PostMapping</span>(<span class=\"st\">\"/payments\"</span>)\n    PaymentResult <span class=\"fn\">pay</span>(PaymentRequest req);\n}</div>",
    "tags": "microservice",
    "level": "middle",
    "section": "Microservice",
    "sectionIcon": "🔷",
    "sectionColor": "#38bdf8",
    "sectionColorClass": "",
    "subsection": "Microservice Architecture"
  },
  {
    "num": 128,
    "numStr": "128",
    "question": "Saga Pattern là gì? Choreography vs Orchestration?",
    "answerHtml": "<p>Trong microservice, mỗi service có DB riêng → không thể dùng 1 transaction chung. <strong>Saga Pattern</strong> quản lý distributed transaction bằng chuỗi transaction cục bộ + <strong>compensating transaction</strong> khi có lỗi.</p>\n      <table class=\"compare-table\">\n        <tr><th></th><th>Choreography</th><th>Orchestration</th></tr>\n        <tr><td>Điều phối</td><td>Service tự phát event, tự react</td><td>Orchestrator trung tâm điều khiển</td></tr>\n        <tr><td>Coupling</td><td>Loose (không biết nhau)</td><td>Tighter (biết các service)</td></tr>\n        <tr><td>Dễ debug</td><td>Khó (flow phân tán)</td><td>Dễ (flow tập trung)</td></tr>\n        <tr><td>Tool</td><td>Kafka events</td><td>Temporal, Conductor, Camunda</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// Choreography - Đặt hàng:</span>\nOrder Service → phát event \"OrderCreated\"\n  → Payment Service lắng nghe → charge → phát \"PaymentSuccess\"\n    → Inventory Service lắng nghe → reserve → phát \"InventoryReserved\"\n      → Shipping Service lắng nghe → ship\n\n<span class=\"cm\">// Nếu Payment fail → phát \"PaymentFailed\"\n//   → Order Service rollback (compensate)</span></div>",
    "tags": "microservice",
    "level": "senior",
    "section": "Microservice",
    "sectionIcon": "🔷",
    "sectionColor": "#38bdf8",
    "sectionColorClass": "",
    "subsection": "Microservice Architecture"
  },
  {
    "num": 129,
    "numStr": "129",
    "question": "ACID là gì? Giải thích từng thuộc tính?",
    "answerHtml": "<p>ACID là 4 thuộc tính đảm bảo độ tin cậy của database transaction:</p>\n      <ul>\n        <li>🔵 <strong>Atomicity (Nguyên tử):</strong> Toàn bộ transaction thành công hoặc toàn bộ thất bại — không có \"nửa vời\". VD: chuyển tiền phải trừ A VÀ cộng B, không được chỉ trừ A.</li>\n        <li>🟢 <strong>Consistency (Nhất quán):</strong> DB luôn ở trạng thái hợp lệ trước và sau transaction. VD: tổng tiền trong hệ thống phải không đổi sau khi chuyển.</li>\n        <li>🟡 <strong>Isolation (Cô lập):</strong> Transaction đang chạy không bị ảnh hưởng bởi transaction khác chạy song song.</li>\n        <li>🔴 <strong>Durability (Bền vững):</strong> Sau khi commit thành công, data được persist dù server crash. DB ghi vào disk/WAL log.</li>\n      </ul>\n      <div class=\"tip-box\">💡 NoSQL thường trade-off ACID lấy performance/scalability. Theo CAP theorem: không thể có cả Consistency, Availability, Partition tolerance — phải chọn 2.</div>",
    "tags": "database",
    "level": "middle",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 130,
    "numStr": "130",
    "question": "Transaction Isolation Levels là gì?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th>Isolation Level</th><th>Dirty Read</th><th>Non-repeatable Read</th><th>Phantom Read</th></tr>\n        <tr><td>READ UNCOMMITTED</td><td>✅ Có thể</td><td>✅ Có thể</td><td>✅ Có thể</td></tr>\n        <tr><td>READ COMMITTED</td><td>❌ Không</td><td>✅ Có thể</td><td>✅ Có thể</td></tr>\n        <tr><td>REPEATABLE READ</td><td>❌ Không</td><td>❌ Không</td><td>✅ Có thể</td></tr>\n        <tr><td>SERIALIZABLE</td><td>❌ Không</td><td>❌ Không</td><td>❌ Không</td></tr>\n      </table>\n      <ul>\n        <li><strong>Dirty Read:</strong> Đọc data của transaction khác chưa commit</li>\n        <li><strong>Non-repeatable Read:</strong> Đọc cùng row 2 lần → kết quả khác (bị update)</li>\n        <li><strong>Phantom Read:</strong> Query cùng điều kiện 2 lần → số row khác (bị insert)</li>\n      </ul>\n      <div class=\"tip-box\">💡 MySQL InnoDB default: REPEATABLE READ. PostgreSQL default: READ COMMITTED. Spring @Transactional default dùng DB default.</div>",
    "tags": "database",
    "level": "senior",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 131,
    "numStr": "131",
    "question": "Index trong database là gì? Khi nào nên/không nên dùng?",
    "answerHtml": "<p>Index là cấu trúc dữ liệu phụ (thường là B-Tree) giúp DB tìm kiếm nhanh hơn — như mục lục sách. Thay vì scan toàn bộ bảng (O(n)) → tìm trong index (O(log n)).</p>\n      <p><strong>Nên tạo index:</strong></p>\n      <ul>\n        <li>Column thường dùng trong WHERE, JOIN, ORDER BY</li>\n        <li>Foreign key columns</li>\n        <li>Column có cardinality cao (nhiều giá trị khác nhau)</li>\n      </ul>\n      <p><strong>Không nên index:</strong></p>\n      <ul>\n        <li>Bảng nhỏ (full scan nhanh hơn)</li>\n        <li>Column ít distinct values (VD: gender — chỉ 2 giá trị)</li>\n        <li>Column thường xuyên bị UPDATE (index phải rebuild sau mỗi write)</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"cm\">-- Composite index: thứ tự quan trọng!</span>\nCREATE INDEX idx_order ON orders(user_id, created_at, status);\n<span class=\"cm\">-- Dùng được: WHERE user_id=1</span>\n<span class=\"cm\">-- Dùng được: WHERE user_id=1 AND created_at>'2024'</span>\n<span class=\"cm\">-- KHÔNG dùng được: WHERE created_at>'2024' (bỏ qua user_id)</span></div>",
    "tags": "database",
    "level": "middle",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 132,
    "numStr": "132",
    "question": "N+1 Query Problem là gì? Cách fix?",
    "answerHtml": "<p>N+1 Problem: Query 1 lần lấy N record, rồi query thêm N lần cho từng record → tổng N+1 query → rất chậm.</p>\n      <div class=\"code-block\"><span class=\"cm\">// ❌ N+1: lấy 100 order → query thêm 100 lần tên user</span>\nList&lt;Order&gt; orders = orderRepo.findAll();   <span class=\"cm\">// 1 query</span>\n<span class=\"kw\">for</span> (Order o : orders) {\n    System.out.println(o.getUser().getName()); <span class=\"cm\">// 100 queries!</span>\n}\n\n<span class=\"cm\">// ✅ Fix bằng JOIN FETCH (load cùng lúc)</span>\n<span class=\"an\">@Query</span>(<span class=\"st\">\"SELECT o FROM Order o JOIN FETCH o.user\"</span>)\nList&lt;Order&gt; <span class=\"fn\">findAllWithUser</span>();\n\n<span class=\"cm\">// ✅ Fix bằng @EntityGraph</span>\n<span class=\"an\">@EntityGraph</span>(attributePaths = <span class=\"st\">\"user\"</span>)\nList&lt;Order&gt; <span class=\"fn\">findAll</span>();\n\n<span class=\"cm\">// ✅ Fix bằng @BatchSize (load batch)</span>\n<span class=\"an\">@BatchSize</span>(size = <span class=\"num\">100</span>)\n<span class=\"kw\">private</span> List&lt;OrderItem&gt; items;</div>\n      <div class=\"tip-box\">💡 Luôn bật Hibernate SQL logging trong dev để detect N+1: <code>spring.jpa.show-sql=true</code></div>",
    "tags": "database",
    "level": "middle",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 133,
    "numStr": "133",
    "question": "Optimistic vs Pessimistic Locking là gì?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Optimistic Lock</th><th>Pessimistic Lock</th></tr>\n        <tr><td>Cơ chế</td><td>Không lock, kiểm tra version khi update</td><td>Lock record ngay khi đọc</td></tr>\n        <tr><td>Xảy ra conflict</td><td>Ném exception, retry</td><td>Thread khác phải chờ</td></tr>\n        <tr><td>Phù hợp</td><td>Ít conflict, read nhiều</td><td>Nhiều conflict, critical section</td></tr>\n        <tr><td>Hiệu năng</td><td>Cao (không block)</td><td>Thấp hơn (block)</td></tr>\n        <tr><td>JPA</td><td>@Version</td><td>@Lock(PESSIMISTIC_WRITE)</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// Optimistic - dùng @Version</span>\n<span class=\"an\">@Entity</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">Product</span> {\n    <span class=\"an\">@Version</span>\n    <span class=\"kw\">private</span> Long version; <span class=\"cm\">// tự động increment, JPA check khi update</span>\n}\n<span class=\"cm\">// Nếu 2 user cùng update → người sau nhận OptimisticLockException</span>\n\n<span class=\"cm\">// Pessimistic - SELECT FOR UPDATE</span>\n<span class=\"an\">@Lock</span>(LockModeType.PESSIMISTIC_WRITE)\n<span class=\"an\">@Query</span>(<span class=\"st\">\"SELECT p FROM Product p WHERE p.id = :id\"</span>)\nProduct <span class=\"fn\">findByIdForUpdate</span>(<span class=\"an\">@Param</span>(<span class=\"st\">\"id\"</span>) Long id);</div>",
    "tags": "database",
    "level": "senior",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 134,
    "numStr": "134",
    "question": "SQL vs NoSQL: Khi nào dùng cái nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>SQL (Relational)</th><th>NoSQL</th></tr>\n        <tr><td>Schema</td><td>Cố định, strict</td><td>Linh hoạt, schema-less</td></tr>\n        <tr><td>ACID</td><td>✅ Đầy đủ</td><td>Thường chỉ eventual consistency</td></tr>\n        <tr><td>Scale</td><td>Vertical (scale up)</td><td>Horizontal (scale out)</td></tr>\n        <tr><td>Query</td><td>SQL mạnh, JOIN phức tạp</td><td>Simple queries, no JOIN</td></tr>\n        <tr><td>Ví dụ</td><td>MySQL, PostgreSQL</td><td>MongoDB, Cassandra, DynamoDB</td></tr>\n      </table>\n      <p><strong>Dùng SQL khi:</strong> Cần ACID, data có quan hệ phức tạp, report, financial</p>\n      <p><strong>Dùng NoSQL khi:</strong> Schema thay đổi thường xuyên, cần scale horizontal lớn, dữ liệu dạng document/time-series/graph</p>\n      <div class=\"tip-box\">💡 Thực tế: Dùng kết hợp cả hai — PostgreSQL cho user/order, Redis cho cache, Elasticsearch cho search, MongoDB cho log/analytics.</div>",
    "tags": "database",
    "level": "middle",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 135,
    "numStr": "135",
    "question": "Database Sharding là gì? Khi nào cần?",
    "answerHtml": "<p>Sharding là kỹ thuật <strong>chia data nằm ngang (horizontal partitioning)</strong> ra nhiều DB server độc lập, mỗi server giữ một phần data.</p>\n      <div class=\"code-block\">VD: Bảng users 100 triệu record chia thành 4 shard:\nShard 1: user_id % 4 == 0  → DB Server 1 (0-25M)\nShard 2: user_id % 4 == 1  → DB Server 2\nShard 3: user_id % 4 == 2  → DB Server 3\nShard 4: user_id % 4 == 3  → DB Server 4</div>\n      <p><strong>Vấn đề khi Sharding:</strong></p>\n      <ul>\n        <li>❌ JOIN giữa các shard rất phức tạp</li>\n        <li>❌ Transaction cross-shard khó đảm bảo ACID</li>\n        <li>❌ Rebalancing khi thêm shard tốn kém</li>\n      </ul>\n      <div class=\"warn-box\">⚠️ Chỉ dùng sharding khi thực sự cần (hàng chục triệu record, single DB không đủ). Trước tiên thử: indexing, caching, read replica, connection pooling.</div>",
    "tags": "database",
    "level": "senior",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 143,
    "numStr": "143",
    "question": "Idempotency là gì? Tại sao quan trọng trong microservice?",
    "answerHtml": "<p>Idempotency = <strong>gọi cùng 1 request nhiều lần → kết quả giống nhau</strong>. Quan trọng vì trong distributed system, network có thể retry → cùng request gửi nhiều lần.</p>\n      <div class=\"code-block\"><span class=\"cm\">// VD: thanh toán bị timeout → client retry → tránh charge 2 lần</span>\n<span class=\"cm\">// Implement: dùng Idempotency-Key trong header</span>\n\nPOST /payments\nHeaders:\n  Idempotency-Key: uuid-abc-123   <span class=\"cm\">// client tạo unique key mỗi request</span>\n\n<span class=\"cm\">// Server logic:</span>\n<span class=\"kw\">if</span> (redis.exists(<span class=\"st\">\"idempotent:\"</span> + key)) {\n    <span class=\"kw\">return</span> redis.get(<span class=\"st\">\"idempotent:\"</span> + key); <span class=\"cm\">// trả cached result</span>\n}\nresult = processPayment(request);\nredis.set(<span class=\"st\">\"idempotent:\"</span> + key, result, Duration.ofHours(<span class=\"num\">24</span>));\n<span class=\"kw\">return</span> result;</div>\n      <p><strong>HTTP Methods và Idempotency:</strong> <span class=\"green\">GET, PUT, DELETE = idempotent</span> — <span class=\"highlight\">POST = NOT idempotent</span> (mỗi lần tạo mới)</p>\n      <div class=\"tip-box\">💡 Stripe, PayPal đều implement idempotency key. Kafka consumer cũng phải idempotent vì at-least-once delivery có thể duplicate message.</div>",
    "tags": "microservice kafka",
    "level": "senior",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 144,
    "numStr": "144",
    "question": "Event-Driven Architecture là gì? Khác REST thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>REST (Synchronous)</th><th>Event-Driven (Async)</th></tr>\n        <tr><td>Giao tiếp</td><td>Request/Response trực tiếp</td><td>Qua event broker (Kafka, RabbitMQ)</td></tr>\n        <tr><td>Coupling</td><td>Tight (A biết B)</td><td>Loose (A không biết ai lắng nghe)</td></tr>\n        <tr><td>Availability</td><td>B chết → A fail</td><td>B chết → event chờ trong queue</td></tr>\n        <tr><td>Latency</td><td>Thấp (sync)</td><td>Cao hơn (async)</td></tr>\n        <tr><td>Phức tạp</td><td>Đơn giản</td><td>Khó debug, trace</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// REST: Order service gọi trực tiếp Payment, Inventory, Notification</span>\norderService.create(order);\npaymentService.charge(order);      <span class=\"cm\">// nếu fail → rollback phức tạp</span>\ninventoryService.reserve(order);\nnotificationService.notify(order);\n\n<span class=\"cm\">// Event-Driven: Order service chỉ phát event</span>\norderService.create(order);\neventBus.publish(<span class=\"st\">\"order.created\"</span>, order);  <span class=\"cm\">// done!</span>\n<span class=\"cm\">// Payment, Inventory, Notification tự lắng nghe và xử lý độc lập</span></div>",
    "tags": "microservice kafka",
    "level": "senior",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 145,
    "numStr": "145",
    "question": "CAP Theorem là gì? Tại sao không thể có cả 3?",
    "answerHtml": "<p>Trong distributed system, <strong>không thể đảm bảo cả 3 thuộc tính cùng lúc</strong> — phải đánh đổi 1:</p>\n      <ul>\n        <li>🔵 <strong>Consistency (C):</strong> Mọi node đều trả về data mới nhất</li>\n        <li>🟢 <strong>Availability (A):</strong> Mọi request đều nhận được response (không có error)</li>\n        <li>🟡 <strong>Partition Tolerance (P):</strong> Hệ thống tiếp tục hoạt động dù mạng bị chia cắt</li>\n      </ul>\n      <table class=\"compare-table\">\n        <tr><th>Lựa chọn</th><th>Đánh đổi</th><th>Ví dụ</th></tr>\n        <tr><td><strong>CP</strong> (C + P)</td><td>Availability — có thể trả error</td><td>HBase, Zookeeper, MongoDB (strong)</td></tr>\n        <tr><td><strong>AP</strong> (A + P)</td><td>Consistency — trả data cũ (eventual)</td><td>Cassandra, DynamoDB, CouchDB</td></tr>\n        <tr><td><strong>CA</strong> (C + A)</td><td>Partition — không distribute được</td><td>MySQL, PostgreSQL (single node)</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 Thực tế: Partition Tolerance là bắt buộc trong distributed system (mạng luôn có thể fail). Nên lựa chọn thực sự là CP vs AP — tùy use case.</div>",
    "tags": "microservice database",
    "level": "senior",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 146,
    "numStr": "146",
    "question": "Two-Phase Commit (2PC) là gì? Tại sao ít dùng trong microservice?",
    "answerHtml": "<p>2PC là giao thức đảm bảo distributed transaction — tất cả participants commit hoặc tất cả rollback:</p>\n      <div class=\"code-block\">Phase 1 - Prepare:\n  Coordinator → tất cả participants: \"Bạn có sẵn sàng commit không?\"\n  Participants ghi redo log, trả lời \"YES\" hoặc \"NO\"\n\nPhase 2 - Commit/Abort:\n  Nếu TẤT CẢ trả YES → Coordinator gửi COMMIT\n  Nếu BẤT KỲ trả NO  → Coordinator gửi ROLLBACK</div>\n      <p><strong>Vấn đề của 2PC trong Microservice:</strong></p>\n      <ul>\n        <li>❌ <strong>Blocking:</strong> Participants lock resource trong suốt quá trình → giảm throughput</li>\n        <li>❌ <strong>Single point of failure:</strong> Coordinator chết → participants bị block mãi</li>\n        <li>❌ <strong>Latency cao:</strong> Nhiều round-trip network</li>\n        <li>❌ <strong>Tight coupling:</strong> Tất cả services phải support 2PC protocol</li>\n      </ul>\n      <div class=\"tip-box\">💡 Thay bằng Saga Pattern (eventual consistency) — chấp nhận eventual consistency thay vì strong consistency. Phù hợp hơn với microservice.</div>",
    "tags": "microservice database",
    "level": "expert",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 160,
    "numStr": "160",
    "question": "EXPLAIN ANALYZE — đọc query execution plan thế nào?",
    "answerHtml": "<p><code>EXPLAIN ANALYZE</code> cho thấy PostgreSQL/MySQL <strong>thực sự thực thi query như thế nào</strong> — không chỉ plan mà còn actual time, rows scanned.</p>\n      <div class=\"code-block\"><span class=\"cm\">-- Chạy EXPLAIN ANALYZE trước query chậm</span>\nEXPLAIN ANALYZE\nSELECT * FROM orders o\nJOIN users u ON o.user_id = u.id\nWHERE o.status = 'PENDING'\n  AND o.created_at > '2024-01-01';\n\n<span class=\"cm\">-- Output key terms:</span>\nSeq Scan on orders        <span class=\"cm\">← ❌ Quét toàn bảng — cần index!</span>\nIndex Scan on users       <span class=\"cm\">← ✅ Dùng index tốt</span>\ncost=0.00..1234.56        <span class=\"cm\">← Ước tính cost (nhỏ hơn = tốt hơn)</span>\nrows=5000                 <span class=\"cm\">← Số rows ước tính</span>\nactual time=123.456ms     <span class=\"cm\">← Thời gian thực tế</span>\nBuffers: hit=100 read=500 <span class=\"cm\">← read nhiều = cache miss, chậm</span></div>\n      <p><strong>Các dấu hiệu cần fix:</strong></p>\n      <ul>\n        <li><code>Seq Scan</code> trên bảng lớn → thiếu index</li>\n        <li><code>Hash Join</code> với rows lớn → cân nhắc index trên JOIN column</li>\n        <li><code>actual rows</code> >> <code>estimated rows</code> → statistics cũ, cần <code>ANALYZE</code></li>\n      </ul>\n      <div class=\"tip-box\">💡 Dùng <a href=\"https://explain.dalibo.com\" style=\"color:var(--accent2)\">explain.dalibo.com</a> để visualize EXPLAIN output dạng đồ thị — dễ đọc hơn nhiều.</div>",
    "tags": "database",
    "level": "senior",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 161,
    "numStr": "161",
    "question": "HikariCP là gì? Cấu hình Connection Pool như thế nào?",
    "answerHtml": "<p>HikariCP là <strong>connection pool nhanh nhất</strong> cho Java (default trong Spring Boot). Thay vì mở/đóng DB connection mỗi request (tốn ~100ms) → giữ sẵn pool connection để tái sử dụng.</p>\n      <div class=\"code-block\"><span class=\"cm\"># application.yml</span>\nspring.datasource.hikari:\n  maximum-pool-size: 10      <span class=\"cm\"># Max connections (default: 10)</span>\n  minimum-idle: 5            <span class=\"cm\"># Min idle connections giữ sẵn</span>\n  connection-timeout: 30000  <span class=\"cm\"># Chờ tối đa 30s để lấy connection</span>\n  idle-timeout: 600000       <span class=\"cm\"># Connection idle 10 phút → đóng</span>\n  max-lifetime: 1800000      <span class=\"cm\"># Connection tối đa 30 phút → recreate</span>\n  pool-name: HikariPool-Orders</div>\n      <p><strong>Tính maximumPoolSize:</strong></p>\n      <div class=\"code-block\"><span class=\"cm\"># Formula của HikariCP team:</span>\npool_size = (core_count * 2) + effective_spindle_count\n\n<span class=\"cm\"># Ví dụ: server 4 CPU, SSD (spindle=0):</span>\npool_size = (4 * 2) + 1 = 9 → ~10</div>\n      <div class=\"warn-box\">⚠️ Pool size quá lớn thực ra làm chậm hơn! DB cũng có giới hạn connection. Nhiều connection → nhiều context switching → overhead. Đừng set 100+.</div>",
    "tags": "database spring",
    "level": "senior",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 162,
    "numStr": "162",
    "question": "Query Optimization — các kỹ thuật thực tế thường dùng?",
    "answerHtml": "<div class=\"code-block\"><span class=\"cm\">-- ❌ SELECT * (fetch dữ liệu không cần thiết)</span>\nSELECT * FROM orders WHERE status = 'PENDING';\n<span class=\"cm\">-- ✅ Chỉ lấy column cần</span>\nSELECT id, user_id, total FROM orders WHERE status = 'PENDING';\n\n<span class=\"cm\">-- ❌ LIKE với wildcard đầu (không dùng được index)</span>\nWHERE name LIKE '%Alice%'\n<span class=\"cm\">-- ✅ LIKE cuối dùng được index</span>\nWHERE name LIKE 'Alice%'\n<span class=\"cm\">-- ✅ Full-text search → dùng Elasticsearch</span>\n\n<span class=\"cm\">-- ❌ Function trên column trong WHERE (bypass index)</span>\nWHERE YEAR(created_at) = 2024\n<span class=\"cm\">-- ✅ Range condition (dùng được index)</span>\nWHERE created_at BETWEEN '2024-01-01' AND '2024-12-31'\n\n<span class=\"cm\">-- ❌ IN với subquery (có thể chậm)</span>\nWHERE id IN (SELECT user_id FROM premium_users)\n<span class=\"cm\">-- ✅ JOIN thường nhanh hơn</span>\nJOIN premium_users pu ON orders.user_id = pu.user_id\n\n<span class=\"cm\">-- ✅ Covering index: index chứa tất cả column cần query</span>\nCREATE INDEX idx_cover ON orders(status, created_at, user_id, total);\n<span class=\"cm\">-- Query chỉ cần đọc index, không cần đọc table (index-only scan)</span></div>\n      <div class=\"tip-box\">💡 Quy trình debug query chậm: EXPLAIN ANALYZE → tìm Seq Scan → thêm index → kiểm tra lại. Measure trước, optimize sau.</div>",
    "tags": "database",
    "level": "senior",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 155,
    "numStr": "155",
    "question": "Docker là gì? Image vs Container khác nhau thế nào?",
    "answerHtml": "<p>Docker cho phép đóng gói ứng dụng + dependencies vào <strong>container</strong> — chạy giống nhau trên mọi môi trường (dev/staging/prod).</p>\n      <table class=\"compare-table\">\n        <tr><th></th><th>Image</th><th>Container</th></tr>\n        <tr><td>Là gì</td><td>Blueprint (read-only template)</td><td>Instance đang chạy của Image</td></tr>\n        <tr><td>Tương tự</td><td>Class (Java)</td><td>Object (instance của class)</td></tr>\n        <tr><td>Lưu trữ</td><td>Docker Hub, Registry</td><td>RAM + writable layer</td></tr>\n        <tr><td>Tạo</td><td>docker build -t app .</td><td>docker run app</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\"># Dockerfile tối ưu cho Spring Boot (multi-stage)</span>\n<span class=\"cm\"># Stage 1: Build</span>\nFROM eclipse-temurin:21-jdk AS builder\nWORKDIR /app\nCOPY pom.xml .\nRUN mvn dependency:go-offline   <span class=\"cm\"># cache dependencies</span>\nCOPY src ./src\nRUN mvn package -DskipTests\n\n<span class=\"cm\"># Stage 2: Runtime (image nhỏ hơn nhiều)</span>\nFROM eclipse-temurin:21-jre-alpine\nWORKDIR /app\nCOPY --from=builder /app/target/app.jar app.jar\nEXPOSE 8080\nENTRYPOINT [\"java\", \"-jar\", \"app.jar\"]</div>\n      <div class=\"tip-box\">💡 Multi-stage build giúp image production nhỏ hơn — không chứa JDK, Maven, source code. JRE-alpine thường ~200MB thay vì JDK ~600MB.</div>",
    "tags": "devops",
    "level": "middle",
    "section": "DevOps & Production",
    "sectionIcon": "🚀",
    "sectionColor": "#34d399",
    "sectionColorClass": "",
    "subsection": "Docker & CI/CD"
  },
  {
    "num": 156,
    "numStr": "156",
    "question": "Docker Compose — chạy multi-service local thế nào?",
    "answerHtml": "<p>Docker Compose định nghĩa và chạy <strong>nhiều container cùng lúc</strong> — thay vì chạy từng lệnh <code>docker run</code> riêng.</p>\n      <div class=\"code-block\"><span class=\"cm\"># docker-compose.yml cho Spring Boot app</span>\nversion: '3.8'\nservices:\n  app:\n    build: .\n    ports:\n      - \"8080:8080\"\n    environment:\n      SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/mydb\n      SPRING_KAFKA_BOOTSTRAP_SERVERS: kafka:9092\n      SPRING_REDIS_HOST: redis\n    depends_on:\n      - postgres\n      - redis\n      - kafka\n\n  postgres:\n    image: postgres:15\n    environment:\n      POSTGRES_DB: mydb\n      POSTGRES_PASSWORD: secret\n    volumes:\n      - pgdata:/var/lib/postgresql/data\n\n  redis:\n    image: redis:7-alpine\n\n  kafka:\n    image: confluentinc/cp-kafka:7.5.0\n    environment:\n      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181\n\nvolumes:\n  pgdata:</div>\n      <div class=\"code-block\"><span class=\"cm\"># Lệnh thường dùng</span>\ndocker-compose up -d          <span class=\"cm\"># Chạy background</span>\ndocker-compose logs -f app    <span class=\"cm\"># Xem logs real-time</span>\ndocker-compose down -v        <span class=\"cm\"># Dừng + xóa volumes</span></div>",
    "tags": "devops",
    "level": "middle",
    "section": "DevOps & Production",
    "sectionIcon": "🚀",
    "sectionColor": "#34d399",
    "sectionColorClass": "",
    "subsection": "Docker & CI/CD"
  },
  {
    "num": 157,
    "numStr": "157",
    "question": "CI/CD là gì? Viết GitHub Actions pipeline cho Spring Boot?",
    "answerHtml": "<ul>\n        <li><strong>CI (Continuous Integration):</strong> Tự động build + test mỗi khi push code</li>\n        <li><strong>CD (Continuous Delivery/Deployment):</strong> Tự động deploy sau khi CI pass</li>\n      </ul>\n      <div class=\"code-block\"><span class=\"cm\"># .github/workflows/ci-cd.yml</span>\nname: CI/CD Pipeline\non:\n  push:\n    branches: [main, develop]\n  pull_request:\n    branches: [main]\n\njobs:\n  build-and-test:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-java@v4\n        with:\n          java-version: '21'\n          distribution: 'temurin'\n          cache: 'maven'        <span class=\"cm\"># cache Maven deps</span>\n\n      - name: Run Tests\n        run: mvn test\n\n      - name: Build Docker Image\n        run: docker build -t myapp:${{ github.sha }} .\n\n      - name: Push to Registry\n        run: |\n          docker login ghcr.io -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }}\n          docker push ghcr.io/myorg/myapp:${{ github.sha }}\n\n  deploy:\n    needs: build-and-test\n    if: github.ref == 'refs/heads/main'\n    runs-on: ubuntu-latest\n    steps:\n      - name: Deploy to Production\n        run: ssh user@server \"docker pull ... && docker-compose up -d\"</div>",
    "tags": "devops",
    "level": "senior",
    "section": "DevOps & Production",
    "sectionIcon": "🚀",
    "sectionColor": "#34d399",
    "sectionColorClass": "",
    "subsection": "Docker & CI/CD"
  },
  {
    "num": 158,
    "numStr": "158",
    "question": "Monitoring với Prometheus + Grafana + Spring Actuator hoạt động thế nào?",
    "answerHtml": "<div class=\"code-block\"><span class=\"cm\"># 1. Spring Boot expose metrics qua Actuator</span>\n<span class=\"cm\"># pom.xml: thêm micrometer-registry-prometheus</span>\n\n<span class=\"cm\"># application.yml</span>\nmanagement.endpoints.web.exposure.include: health,metrics,prometheus\nmanagement.metrics.export.prometheus.enabled: true\n\n<span class=\"cm\"># 2. Prometheus scrape metrics mỗi 15s</span>\n<span class=\"cm\"># prometheus.yml</span>\nscrape_configs:\n  - job_name: 'spring-boot-app'\n    static_configs:\n      - targets: ['app:8080']\n    metrics_path: '/actuator/prometheus'\n\n<span class=\"cm\"># 3. Grafana visualize từ Prometheus data source</span>\n<span class=\"cm\"># Import dashboard ID: 12900 (Spring Boot Statistics)</span></div>\n      <p><strong>Metrics quan trọng cần monitor:</strong></p>\n      <ul>\n        <li><code>http_server_requests_seconds</code> — latency, error rate</li>\n        <li><code>hikaricp_connections_active</code> — DB connection pool</li>\n        <li><code>jvm_memory_used_bytes</code> — heap usage</li>\n        <li><code>jvm_gc_pause_seconds</code> — GC pause time</li>\n        <li><code>kafka_consumer_lag</code> — Kafka consumer backlog</li>\n      </ul>\n      <div class=\"tip-box\">💡 Alert rule quan trọng: error rate &gt; 1%, latency p99 &gt; 1s, heap &gt; 80%, consumer lag tăng liên tục.</div>",
    "tags": "devops spring",
    "level": "senior",
    "section": "DevOps & Production",
    "sectionIcon": "🚀",
    "sectionColor": "#34d399",
    "sectionColorClass": "",
    "subsection": "Docker & CI/CD"
  },
  {
    "num": 159,
    "numStr": "159",
    "question": "ELK Stack là gì? Centralized Logging hoạt động thế nào?",
    "answerHtml": "<p><strong>ELK = Elasticsearch + Logstash + Kibana</strong> — stack để thu thập, lưu trữ, và visualize logs từ nhiều service.</p>\n      <div class=\"code-block\">App Logs → Logstash (parse, filter) → Elasticsearch (store, index) → Kibana (visualize)\n\n<span class=\"cm\"># Hiện đại hơn: EFK Stack</span>\nApp Logs → Fluentd/Fluent Bit (gọn nhẹ hơn Logstash) → Elasticsearch → Kibana</div>\n      <div class=\"code-block\"><span class=\"cm\"># Spring Boot - gửi log dạng JSON đến ELK</span>\n<span class=\"cm\"># pom.xml: logstash-logback-encoder</span>\n\n<span class=\"cm\"># logback-spring.xml</span>\n&lt;appender name=\"LOGSTASH\" class=\"net.logstash.logback.appender.LogstashTcpSocketAppender\"&gt;\n    &lt;destination&gt;logstash:5000&lt;/destination&gt;\n    &lt;encoder class=\"net.logstash.logback.encoder.LogstashEncoder\"/&gt;\n&lt;/appender&gt;\n\n<span class=\"cm\"># Luôn log với structured fields (dễ search)</span>\nMDC.put(<span class=\"st\">\"traceId\"</span>, UUID.randomUUID().toString());\nMDC.put(<span class=\"st\">\"userId\"</span>, userId.toString());\nlog.info(<span class=\"st\">\"Order created\"</span>, kv(<span class=\"st\">\"orderId\"</span>, orderId), kv(<span class=\"st\">\"amount\"</span>, amount));</div>\n      <div class=\"tip-box\">💡 Luôn thêm <strong>correlation ID / trace ID</strong> vào mọi log để trace request across multiple services. Spring Cloud Sleuth / Micrometer Tracing tự động làm điều này.</div>",
    "tags": "devops",
    "level": "senior",
    "section": "DevOps & Production",
    "sectionIcon": "🚀",
    "sectionColor": "#34d399",
    "sectionColorClass": "",
    "subsection": "Docker & CI/CD"
  },
  {
    "num": 163,
    "numStr": "163",
    "question": "Clean Architecture là gì? Tại sao business logic không nên phụ thuộc framework?",
    "answerHtml": "<p>Clean Architecture (Uncle Bob) tổ chức code theo <strong>vòng tròn đồng tâm</strong> — dependency chỉ hướng vào trong, core business không biết gì về framework/DB/UI.</p>\n      <div class=\"code-block\">Ngoài → Trong (dependency direction):\n\n┌──────────────────────────────────┐\n│  Frameworks &amp; Drivers             │  Spring, Hibernate, REST\n│  ┌────────────────────────────┐  │\n│  │  Interface Adapters        │  │  Controller, Repository impl\n│  │  ┌──────────────────────┐  │  │\n│  │  │  Application Layer   │  │  │  Use Cases / Services\n│  │  │  ┌────────────────┐  │  │  │\n│  │  │  │  Domain Layer  │  │  │  │  Entities, Business Rules\n│  │  │  │  (Không phụ   │  │  │  │  ← KHÔNG import Spring!\n│  │  │  │   thuộc gì)   │  │  │  │\n│  │  │  └────────────────┘  │  │  │\n│  │  └──────────────────────┘  │  │\n│  └────────────────────────────┘  │\n└──────────────────────────────────┘</div>\n      <p><strong>Lợi ích:</strong></p>\n      <ul>\n        <li>✅ Đổi từ REST sang GraphQL → chỉ thay Controller, không động đến business logic</li>\n        <li>✅ Đổi từ MySQL sang MongoDB → chỉ thay Repository impl</li>\n        <li>✅ Test business logic thuần Java — không cần Spring context, test siêu nhanh</li>\n      </ul>\n      <div class=\"tip-box\">💡 Dùng Port (interface) và Adapter (implementation) để tách biệt. VD: <code>OrderRepository</code> là port (interface), <code>JpaOrderRepository</code> là adapter.</div>",
    "tags": "architecture",
    "level": "expert",
    "section": "Architecture Patterns",
    "sectionIcon": "🧱",
    "sectionColor": "#c084fc",
    "sectionColorClass": "",
    "subsection": "Software Architecture"
  },
  {
    "num": 164,
    "numStr": "164",
    "question": "Hexagonal Architecture (Ports & Adapters) là gì?",
    "answerHtml": "<p>Tương tự Clean Architecture, tổ chức theo <strong>Hexagon</strong>: core ở giữa, I/O (REST, DB, Kafka, Email) kết nối qua Ports và Adapters.</p>\n      <div class=\"code-block\">Inbound Adapters          Core Domain         Outbound Adapters\n(Driving side)                                (Driven side)\n\nREST Controller  →→→  Port: UseCase  →→→  Port: Repository\nGraphQL          →→→  (Interface)    →→→       (Interface)\nKafka Consumer   →→→                →→→  Port: EmailGateway\ngRPC             →→→                →→→  Port: PaymentGateway\n                                          ↓\n                                    Adapter implements:\n                                    - JpaOrderRepository\n                                    - SmtpEmailAdapter\n                                    - StripePaymentAdapter</div>\n      <div class=\"code-block\"><span class=\"cm\">// Port (Interface in domain)</span>\n<span class=\"kw\">public interface</span> <span class=\"cl\">OrderRepository</span> {          <span class=\"cm\">// domain không biết JPA</span>\n    Order <span class=\"fn\">save</span>(Order order);\n    Optional&lt;Order&gt; <span class=\"fn\">findById</span>(OrderId id);\n}\n\n<span class=\"cm\">// Adapter (Infrastructure layer)</span>\n<span class=\"an\">@Repository</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">JpaOrderRepository</span> <span class=\"kw\">implements</span> <span class=\"cl\">OrderRepository</span> {\n    <span class=\"an\">@Autowired</span> <span class=\"kw\">private</span> JpaOrderEntityRepository jpaRepo;\n    <span class=\"cm\">// map giữa Domain Object ↔ JPA Entity</span>\n}</div>",
    "tags": "architecture",
    "level": "expert",
    "section": "Architecture Patterns",
    "sectionIcon": "🧱",
    "sectionColor": "#c084fc",
    "sectionColorClass": "",
    "subsection": "Software Architecture"
  },
  {
    "num": 165,
    "numStr": "165",
    "question": "DDD — Domain Driven Design các khái niệm cơ bản?",
    "answerHtml": "<p>DDD là cách thiết kế phần mềm <strong>tập trung vào business domain</strong> — tổ chức code phản ánh thực tế business, không phải cấu trúc kỹ thuật.</p>\n      <table class=\"compare-table\">\n        <tr><th>Khái niệm</th><th>Giải thích</th><th>Ví dụ</th></tr>\n        <tr><td><strong>Entity</strong></td><td>Object có identity (ID) — mutable</td><td>Order, User (thay đổi trạng thái)</td></tr>\n        <tr><td><strong>Value Object</strong></td><td>Không có ID — immutable, so sánh theo giá trị</td><td>Money(100, \"USD\"), Address</td></tr>\n        <tr><td><strong>Aggregate</strong></td><td>Nhóm Entities/VOs có ranh giới nhất quán</td><td>Order + OrderItems (1 transaction)</td></tr>\n        <tr><td><strong>Aggregate Root</strong></td><td>Entity trung tâm của Aggregate</td><td>Order (chỉ thao tác Order qua đây)</td></tr>\n        <tr><td><strong>Domain Event</strong></td><td>Sự kiện có ý nghĩa trong domain</td><td>OrderPlaced, PaymentFailed</td></tr>\n        <tr><td><strong>Bounded Context</strong></td><td>Ranh giới context của một subdomain</td><td>Order Context, Inventory Context</td></tr>\n        <tr><td><strong>Ubiquitous Language</strong></td><td>Ngôn ngữ chung giữa dev và domain expert</td><td>Dùng \"Place Order\" không phải \"Create Record\"</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 Mỗi Microservice thường tương ứng 1 Bounded Context trong DDD. DDD giúp tìm ra ranh giới service hợp lý thay vì tách service theo kỹ thuật.</div>",
    "tags": "architecture microservice",
    "level": "expert",
    "section": "Architecture Patterns",
    "sectionIcon": "🧱",
    "sectionColor": "#c084fc",
    "sectionColorClass": "",
    "subsection": "Software Architecture"
  },
  {
    "num": 166,
    "numStr": "166",
    "question": "Design Rate Limiter — các thuật toán và implement ở scale?",
    "answerHtml": "<p><strong>Yêu cầu:</strong> Giới hạn mỗi user tối đa 100 request/phút. Scale: 100M users, 10M req/s.</p>\n      <p><strong>Thuật toán — Sliding Window Log (Redis Sorted Set):</strong></p>\n      <div class=\"code-block\">Key: \"rate:{userId}\"   Type: Sorted Set   Score: timestamp\n\nMULTI                                    <span class=\"cm\"># atomic transaction</span>\n  ZREMRANGEBYSCORE rate:user1 0 (now-60s) <span class=\"cm\"># xóa request cũ</span>\n  ZADD rate:user1 now {uuid}              <span class=\"cm\"># thêm request hiện tại</span>\n  ZCARD rate:user1                        <span class=\"cm\"># đếm trong 60s</span>\nEXEC\n\nif count &gt; 100: return 429 Too Many Requests</div>\n      <p><strong>Scale lên 10M req/s:</strong></p>\n      <ul>\n        <li>🔴 <strong>Redis Cluster:</strong> Shard theo userId để phân tải</li>\n        <li>🌐 <strong>API Gateway level:</strong> Implement tại gateway (Kong, AWS API GW) — không cần đến service</li>\n        <li>💾 <strong>Local cache:</strong> Mỗi instance cache quota ngắn hạn, sync với Redis định kỳ (token bucket)</li>\n        <li>⚡ <strong>Lua script:</strong> Atomic operation trong Redis để tránh race condition</li>\n      </ul>\n      <div class=\"tip-box\">💡 Response headers chuẩn: <code>X-RateLimit-Limit: 100</code>, <code>X-RateLimit-Remaining: 42</code>, <code>X-RateLimit-Reset: 1720000000</code>, <code>Retry-After: 30</code></div>",
    "tags": "systemdesign redis",
    "level": "expert",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 167,
    "numStr": "167",
    "question": "Design URL Shortener (bit.ly) — xử lý 100M URLs, 10B redirects/ngày?",
    "answerHtml": "<p><strong>Core requirements:</strong> <code>POST /shorten</code> → short URL. <code>GET /{code}</code> → redirect 301.</p>\n      <div class=\"code-block\">1. HASH GENERATION\n   shortCode = base62(incrementalId)\n   <span class=\"cm\">// base62: a-z + A-Z + 0-9 = 62 chars</span>\n   <span class=\"cm\">// 6 chars = 62^6 = 56 tỷ URLs — đủ dùng</span>\n   <span class=\"cm\">// Dùng auto-increment DB ID để đảm bảo unique</span>\n\n2. STORAGE\n   CREATE TABLE urls (\n     id BIGINT PRIMARY KEY AUTO_INCREMENT,\n     short_code VARCHAR(8) UNIQUE INDEX,\n     long_url TEXT,\n     created_at TIMESTAMP,\n     expires_at TIMESTAMP,\n     user_id BIGINT INDEX\n   );\n\n3. REDIRECT (read-heavy: 10B/day = 116K req/s)\n   <span class=\"cm\">// Cache hot URLs trong Redis (90% redirect là top 10% URL)</span>\n   Redis.get(shortCode) → 301 redirect (cache hit, ~1ms)\n   miss → DB → Redis.set(shortCode, longUrl, 1h) → redirect\n\n4. SCALE\n   CDN edge node cache popular redirects\n   Read replicas cho DB reads\n   301 (Permanent) vs 302 (Temporary) redirect strategy</div>\n      <div class=\"tip-box\">💡 301 = browser cache → giảm tải server nhưng khó track analytics. 302 = mỗi lần đều hit server → track được nhưng chậm hơn. bitly dùng 301 cho user experience.</div>",
    "tags": "systemdesign database redis",
    "level": "expert",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 168,
    "numStr": "168",
    "question": "Design Notification System — gửi 1 tỷ notifications/ngày?",
    "answerHtml": "<p><strong>Channels:</strong> Push (FCM/APNs), Email (SendGrid), SMS (Twilio), In-app.</p>\n      <div class=\"code-block\">Architecture:\n\nAPI Layer         Queue Layer          Worker Layer\n    ↓                  ↓                    ↓\nPOST /notify  →  Kafka Topics:    →  Push Workers (scale independently)\n               - push-notifications     Email Workers\n               - email-queue            SMS Workers\n               - sms-queue\n\nKey Design Decisions:\n\n1. DEDUPLICATION\n   Redis SET \"notif:{userId}:{eventType}:{date}\" với TTL\n   → Không gửi 2 lần cùng notification\n\n2. USER PREFERENCES\n   DB: notification_settings (userId, channel, enabled, quiet_hours)\n   Check trước khi enqueue → tránh gửi cho user đã opt-out\n\n3. TEMPLATE ENGINE\n   Lưu template trong DB, fill variable lúc send\n   I18n: chọn template theo user.language\n\n4. RATE LIMITING PER USER\n   Max 10 push/hour, 5 email/day per user\n\n5. RETRY &amp; DEAD LETTER\n   Kafka consumer retry 3 lần với exponential backoff\n   Fail → Dead Letter Queue → alert team</div>\n      <div class=\"tip-box\">💡 1 tỷ / ngày = 11,574 notifications/giây. Push notification (FCM batch API) có thể gửi 500 devices/request → chỉ cần ~23 req/s. Không quá scary khi dùng batch!</div>",
    "tags": "systemdesign microservice kafka",
    "level": "expert",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 169,
    "numStr": "169",
    "question": "Java Record là gì? Dùng khi nào?",
    "answerHtml": "<p><code>record</code> (Java 14+ preview, Java 16 stable) là cú pháp ngắn gọn để tạo <strong>immutable data class</strong>. Tự động sinh constructor, getter, equals(), hashCode(), toString().</p>\n      <div class=\"code-block\"><span class=\"cm\">// Trước record - boilerplate nhiều</span>\n<span class=\"kw\">class</span> <span class=\"cl\">Point</span> {\n    <span class=\"kw\">private final int</span> x, y;\n    Point(<span class=\"kw\">int</span> x, <span class=\"kw\">int</span> y) { <span class=\"kw\">this</span>.x = x; <span class=\"kw\">this</span>.y = y; }\n    <span class=\"kw\">public int</span> <span class=\"fn\">x</span>() { <span class=\"kw\">return</span> x; }\n    <span class=\"cm\">// + equals, hashCode, toString...</span>\n}\n\n<span class=\"cm\">// Với record - gọn hơn rất nhiều</span>\n<span class=\"kw\">record</span> <span class=\"cl\">Point</span>(<span class=\"kw\">int</span> x, <span class=\"kw\">int</span> y) {}\n\nPoint p = <span class=\"kw\">new</span> Point(<span class=\"num\">3</span>, <span class=\"num\">4</span>);\np.x();          <span class=\"cm\">// getter tự sinh</span>\np.equals(<span class=\"kw\">new</span> Point(<span class=\"num\">3</span>, <span class=\"num\">4</span>)); <span class=\"cm\">// true - tự sinh</span>\n\n<span class=\"cm\">// Record trong Spring Boot - DTO/Request body</span>\n<span class=\"kw\">record</span> <span class=\"cl\">CreateUserRequest</span>(String name, String email, String role) {}\n\n<span class=\"an\">@PostMapping</span>(<span class=\"st\">\"/users\"</span>)\n<span class=\"kw\">public</span> UserResponse <span class=\"fn\">create</span>(<span class=\"an\">@RequestBody</span> <span class=\"cl\">CreateUserRequest</span> req) { ... }</div>\n      <div class=\"tip-box\">💡 Dùng record cho: DTO, Value Objects, API request/response. Không phù hợp cho JPA Entity (cần no-arg constructor và mutable fields).</div>",
    "tags": "java java8",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Java 8+ Features"
  },
  {
    "num": 170,
    "numStr": "170",
    "question": "Sealed Class trong Java là gì?",
    "answerHtml": "<p><code>sealed</code> class (Java 17) cho phép <strong>kiểm soát class nào được phép extend/implement</strong>. Kết hợp với <code>pattern matching</code> rất mạnh.</p>\n      <div class=\"code-block\"><span class=\"cm\">// Không khai báo sealed: ai cũng có thể extend</span>\n<span class=\"cm\">// Với sealed: chỉ các class được listed mới được phép</span>\n<span class=\"kw\">public sealed class</span> <span class=\"cl\">Shape</span>\n    <span class=\"kw\">permits</span> <span class=\"cl\">Circle</span>, <span class=\"cl\">Rectangle</span>, <span class=\"cl\">Triangle</span> {}\n\n<span class=\"kw\">public final class</span> <span class=\"cl\">Circle</span> <span class=\"kw\">extends</span> <span class=\"cl\">Shape</span> {\n    <span class=\"kw\">double</span> radius;\n}\n\n<span class=\"kw\">public non-sealed class</span> <span class=\"cl\">Rectangle</span> <span class=\"kw\">extends</span> <span class=\"cl\">Shape</span> {\n    <span class=\"cm\">// non-sealed: ai cũng extend được Rectangle</span>\n}\n\n<span class=\"cm\">// Pattern matching với sealed class (switch expression)</span>\n<span class=\"kw\">double</span> area = <span class=\"kw\">switch</span> (shape) {\n    <span class=\"kw\">case</span> <span class=\"cl\">Circle</span> c    -> Math.PI * c.radius * c.radius;\n    <span class=\"kw\">case</span> <span class=\"cl\">Rectangle</span> r -> r.width * r.height;\n    <span class=\"kw\">case</span> <span class=\"cl\">Triangle</span> t  -> <span class=\"num\">0.5</span> * t.base * t.height;\n    <span class=\"cm\">// Compiler biết đã cover hết cases! Không cần default</span>\n};</div>\n      <div class=\"tip-box\">💡 Sealed class + record + pattern matching = algebraic data types trong Java. Rất hữu ích để model domain entities rõ ràng hơn.</div>",
    "tags": "java java8",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Java 8+ Features"
  },
  {
    "num": 171,
    "numStr": "171",
    "question": "Stream API: map() vs flatMap() khác nhau thế nào?",
    "answerHtml": "<p><code>map()</code> chuyển đổi mỗi element thành 1 element mới (1-to-1). <code>flatMap()</code> chuyển đổi mỗi element thành một Stream rồi <strong>flatten</strong> tất cả thành 1 Stream (1-to-many).</p>\n      <div class=\"code-block\"><span class=\"cm\">// map: 1-to-1 transformation</span>\nList&lt;String&gt; names = List.of(<span class=\"st\">\"Alice\"</span>, <span class=\"st\">\"Bob\"</span>);\nList&lt;Integer&gt; lengths = names.stream()\n    .map(String::length)           <span class=\"cm\">// [5, 3]</span>\n    .toList();\n\n<span class=\"cm\">// flatMap: 1-to-many → flatten</span>\nList&lt;List&lt;Integer&gt;&gt; nested = List.of(\n    List.of(<span class=\"num\">1</span>, <span class=\"num\">2</span>),\n    List.of(<span class=\"num\">3</span>, <span class=\"num\">4</span>)\n);\nList&lt;Integer&gt; flat = nested.stream()\n    .flatMap(Collection::stream)   <span class=\"cm\">// [1, 2, 3, 4]</span>\n    .toList();\n\n<span class=\"cm\">// Ví dụ thực tế: lấy tất cả tag của nhiều bài viết</span>\nList&lt;String&gt; allTags = posts.stream()\n    .flatMap(post -> post.getTags().stream())\n    .distinct()\n    .toList();</div>\n      <div class=\"warn-box\">⚠️ Dùng map() khi result là 1 element. Dùng flatMap() khi result là Collection/Optional/Stream. Nhầm lẫn sẽ tạo Stream&lt;Stream&lt;T&gt;&gt; thay vì Stream&lt;T&gt;.</div>",
    "tags": "java java8",
    "level": "junior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Java 8+ Features"
  },
  {
    "num": 172,
    "numStr": "172",
    "question": "Virtual Thread (Project Loom) trong Java 21 là gì?",
    "answerHtml": "<p><strong>Virtual Thread</strong> (Java 21 GA) là thread cực nhẹ được JVM quản lý, không 1-1 với OS thread. Giải quyết vấn đề <strong>thread-per-request model</strong> trong high-concurrency.</p>\n      <table class=\"compare-table\">\n        <tr><th></th><th>Platform Thread</th><th>Virtual Thread</th></tr>\n        <tr><td>Tạo bởi</td><td>OS</td><td>JVM</td></tr>\n        <tr><td>Stack size</td><td>~1MB</td><td>~KB (elastic, grow/shrink)</td></tr>\n        <tr><td>Số lượng</td><td>Vài nghìn</td><td>Hàng triệu</td></tr>\n        <tr><td>Blocking I/O</td><td>Block OS thread</td><td>Unmount, OS thread tự do</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// Tạo virtual thread</span>\nThread.ofVirtual().start(() -> handleRequest());\n\n<span class=\"cm\">// Dùng với ExecutorService</span>\n<span class=\"kw\">try</span> (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {\n    <span class=\"kw\">for</span> (<span class=\"kw\">int</span> i = <span class=\"num\">0</span>; i &lt; <span class=\"num\">1_000_000</span>; i++) {\n        executor.submit(() -> handleRequest());\n    }\n}\n\n<span class=\"cm\"># Spring Boot 3.2+ - enable virtual threads</span>\nspring.threads.virtual.enabled=<span class=\"kw\">true</span></div>\n      <div class=\"tip-box\">💡 Virtual thread phù hợp I/O-bound workload (DB, HTTP call). Không có lợi cho CPU-bound tasks. Spring Boot 3.2+ support native virtual thread.</div>",
    "tags": "java thread",
    "level": "senior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Multithreading & Concurrency"
  },
  {
    "num": 173,
    "numStr": "173",
    "question": "Spring Boot Actuator là gì? Các endpoint quan trọng?",
    "answerHtml": "<p>Spring Boot Actuator cung cấp <strong>production-ready monitoring endpoints</strong> sẵn có — không cần code thêm.</p>\n      <table class=\"compare-table\">\n        <tr><th>Endpoint</th><th>Mô tả</th><th>Dùng khi</th></tr>\n        <tr><td>/actuator/health</td><td>Health check (UP/DOWN)</td><td>K8s readiness/liveness probe</td></tr>\n        <tr><td>/actuator/metrics</td><td>JVM, HTTP, custom metrics</td><td>Prometheus scraping</td></tr>\n        <tr><td>/actuator/info</td><td>App version, build info</td><td>Biết version đang chạy</td></tr>\n        <tr><td>/actuator/env</td><td>ConfigEnv properties</td><td>Debug config</td></tr>\n        <tr><td>/actuator/loggers</td><td>Thay đổi log level runtime</td><td>Debug production không restart</td></tr>\n        <tr><td>/actuator/threaddump</td><td>Thread dump</td><td>Debug deadlock</td></tr>\n        <tr><td>/actuator/heapdump</td><td>Heap dump file</td><td>Debug memory leak</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\"># application.yml - expose endpoints</span>\nmanagement:\n  endpoints:\n    web:\n      exposure:\n        include: health,info,metrics,loggers\n  endpoint:\n    health:\n      show-details: always\n  health:\n    db:\n      enabled: true\n    redis:\n      enabled: true</div>\n      <div class=\"warn-box\">⚠️ Không expose /actuator/* public ra internet! Dùng Spring Security để bảo vệ, hoặc tạo management port riêng (<code>management.server.port=8081</code>).</div>",
    "tags": "spring core",
    "level": "junior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 174,
    "numStr": "174",
    "question": "Spring Transaction: @Transactional hoạt động như thế nào? Propagation là gì?",
    "answerHtml": "<p><code>@Transactional</code> dùng <strong>AOP proxy</strong>: Spring tạo proxy bao quanh bean, tự động <code>begin transaction</code> trước method và <code>commit/rollback</code> sau khi method kết thúc.</p>\n      <table class=\"compare-table\">\n        <tr><th>Propagation</th><th>Hành vi</th></tr>\n        <tr><td>REQUIRED (default)</td><td>Dùng transaction hiện có; nếu không có → tạo mới</td></tr>\n        <tr><td>REQUIRES_NEW</td><td>Luôn tạo transaction mới; suspend transaction cũ</td></tr>\n        <tr><td>NESTED</td><td>Tạo savepoint trong transaction hiện có</td></tr>\n        <tr><td>NOT_SUPPORTED</td><td>Suspend transaction hiện có, chạy không có transaction</td></tr>\n        <tr><td>NEVER</td><td>Throw exception nếu đang có transaction</td></tr>\n        <tr><td>MANDATORY</td><td>Throw exception nếu không có transaction</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"an\">@Transactional</span>   <span class=\"cm\">// rollback chỉ với RuntimeException mặc định!</span>\n<span class=\"kw\">public void</span> <span class=\"fn\">transfer</span>(<span class=\"kw\">long</span> from, <span class=\"kw\">long</span> to, <span class=\"kw\">double</span> amount) {\n    accountRepo.debit(from, amount);\n    accountRepo.credit(to, amount);  <span class=\"cm\">// nếu throw → cả 2 rollback</span>\n}\n\n<span class=\"cm\">// Rollback checked exception</span>\n<span class=\"an\">@Transactional</span>(rollbackFor = Exception.<span class=\"kw\">class</span>)\n\n<span class=\"cm\">// Gọi @Transactional method trong cùng class → KHÔNG có transaction!</span>\n<span class=\"cm\">// Vì Spring proxy không intercept self-invocation</span>\n<span class=\"kw\">public void</span> <span class=\"fn\">outer</span>() {\n    <span class=\"kw\">this</span>.inner();  <span class=\"cm\">// ❌ Proxy bị bypass!</span>\n}</div>\n      <div class=\"warn-box\">⚠️ Self-invocation pitfall: Gọi @Transactional method từ trong cùng class sẽ bypass proxy → không có transaction! Inject self bean hoặc chuyển method sang class khác.</div>",
    "tags": "spring jpa",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Data JPA"
  },
  {
    "num": 175,
    "numStr": "175",
    "question": "Spring Security: JWT Authentication flow hoạt động như thế nào?",
    "answerHtml": "<p>JWT Authentication trong Spring Boot dùng <strong>Filter Chain</strong>: custom filter intercept mọi request, extract và validate JWT trước khi vào controller.</p>\n      <div class=\"code-block\">Request → JwtAuthFilter → SecurityContextHolder → Controller\n\n<span class=\"cm\">// JwtAuthFilter - check mọi request</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">JwtAuthFilter</span> <span class=\"kw\">extends</span> OncePerRequestFilter {\n    <span class=\"an\">@Override</span>\n    <span class=\"kw\">protected void</span> <span class=\"fn\">doFilterInternal</span>(HttpServletRequest req, ...) {\n        String token = extractBearerToken(req);\n        <span class=\"kw\">if</span> (token != <span class=\"kw\">null</span> && jwtService.isValid(token)) {\n            UserDetails user = userDetailsService.loadUserByUsername(\n                jwtService.extractUsername(token));\n            UsernamePasswordAuthenticationToken auth =\n                <span class=\"kw\">new</span> UsernamePasswordAuthenticationToken(\n                    user, <span class=\"kw\">null</span>, user.getAuthorities());\n            SecurityContextHolder.getContext().setAuthentication(auth);\n        }\n        filterChain.doFilter(req, res);\n    }\n}\n\n<span class=\"cm\">// Security Config</span>\n<span class=\"an\">@Bean</span>\nSecurityFilterChain <span class=\"fn\">securityFilterChain</span>(HttpSecurity http) <span class=\"kw\">throws</span> Exception {\n    <span class=\"kw\">return</span> http\n        .csrf(AbstractHttpConfigurer::disable)\n        .sessionManagement(s -> s.sessionCreationPolicy(STATELESS))\n        .authorizeHttpRequests(a -> a\n            .requestMatchers(<span class=\"st\">\"/auth/**\"</span>).permitAll()\n            .anyRequest().authenticated())\n        .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.<span class=\"kw\">class</span>)\n        .build();\n}</div>\n      <div class=\"tip-box\">💡 JWT payload: { sub: userId, roles: [\"ROLE_USER\"], iat: timestamp, exp: timestamp }. Không lưu sensitive data trong JWT vì ai cũng decode được (chỉ không giả mạo được).</div>",
    "tags": "spring security",
    "level": "middle",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Spring Security"
  },
  {
    "num": 176,
    "numStr": "176",
    "question": "Spring AOP là gì? Proxy hoạt động như thế nào?",
    "answerHtml": "<p><strong>AOP (Aspect-Oriented Programming)</strong> cho phép tách cross-cutting concerns (logging, security, transaction) ra khỏi business logic. Spring AOP dùng <strong>proxy pattern</strong>.</p>\n      <table class=\"compare-table\">\n        <tr><th>Khái niệm</th><th>Giải thích</th></tr>\n        <tr><td>Aspect</td><td>Module chứa cross-cutting concern (ví dụ: LoggingAspect)</td></tr>\n        <tr><td>Advice</td><td>Code thực thi: @Before, @After, @Around, @AfterReturning, @AfterThrowing</td></tr>\n        <tr><td>Pointcut</td><td>Expression xác định method nào bị intercept</td></tr>\n        <tr><td>Join point</td><td>Điểm trong execution flow (method call, exception)</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"an\">@Aspect</span>\n<span class=\"an\">@Component</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">LoggingAspect</span> {\n\n    <span class=\"cm\">// @Around intercept mọi method trong service package</span>\n    <span class=\"an\">@Around</span>(<span class=\"st\">\"execution(* com.example.service.*.*(.))\"</span>)\n    <span class=\"kw\">public</span> Object <span class=\"fn\">logTime</span>(ProceedingJoinPoint pjp) <span class=\"kw\">throws</span> Throwable {\n        <span class=\"kw\">long</span> start = System.currentTimeMillis();\n        <span class=\"kw\">try</span> {\n            <span class=\"kw\">return</span> pjp.proceed();  <span class=\"cm\">// gọi method gốc</span>\n        } <span class=\"kw\">finally</span> {\n            <span class=\"kw\">long</span> elapsed = System.currentTimeMillis() - start;\n            log.info(<span class=\"st\">\"{} took {}ms\"</span>, pjp.getSignature(), elapsed);\n        }\n    }\n}</div>\n      <div class=\"warn-box\">⚠️ Spring AOP chỉ intercept Spring-managed bean được gọi từ bên ngoài class (qua proxy). Self-invocation không bị intercept. Dùng AspectJ weaving nếu cần intercept mọi call.</div>",
    "tags": "spring core",
    "level": "senior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 177,
    "numStr": "177",
    "question": "Kafka Consumer Group và Rebalancing hoạt động như thế nào?",
    "answerHtml": "<p><strong>Rebalancing</strong> xảy ra khi consumer group thay đổi (thêm/bớt consumer, consumer chết). Kafka tự động phân phối lại partition.</p>\n      <div class=\"code-block\">Trước rebalance: 3 partitions, 3 consumers\n  P0 → C1 | P1 → C2 | P2 → C3\n\nC3 chết → rebalance:\n  P0 → C1 | P1 → C2 | P2 → C1 (hoặc C2)\n\nThêm C4 → rebalance lại</div>\n      <div class=\"code-block\"><span class=\"cm\">// Spring Kafka listener</span>\n<span class=\"an\">@KafkaListener</span>(\n    topics = <span class=\"st\">\"order-created\"</span>,\n    groupId = <span class=\"st\">\"order-processing-group\"</span>,\n    concurrency = <span class=\"st\">\"3\"</span>  <span class=\"cm\">// 3 threads, mỗi thread 1 partition</span>\n)\n<span class=\"kw\">public void</span> <span class=\"fn\">handleOrder</span>(ConsumerRecord&lt;String, OrderEvent&gt; record) {\n    log.info(<span class=\"st\">\"Partition: {}, Offset: {}\"</span>,\n        record.partition(), record.offset());\n    processOrder(record.value());\n}\n\n<span class=\"cm\"># Tránh rebalance quá thường: tăng session timeout</span>\nspring.kafka.consumer.session-timeout-ms=45000\nspring.kafka.consumer.heartbeat-interval-ms=15000</div>\n      <div class=\"tip-box\">💡 Rebalancing gây \"stop the world\" — consumer dừng consume trong thời gian rebalance. Dùng <code>partition.assignment.strategy=CooperativeStickyAssignor</code> để incremental rebalance, giảm thời gian dừng.</div>",
    "tags": "kafka",
    "level": "middle",
    "section": "Kafka",
    "sectionIcon": "🟠",
    "sectionColor": "#f97316",
    "sectionColorClass": "",
    "subsection": "Kafka Cơ Bản"
  },
  {
    "num": 178,
    "numStr": "178",
    "question": "Kafka Exactly-Once Semantics (EOS) là gì? Implement thế nào?",
    "answerHtml": "<p>Kafka hỗ trợ 3 mức delivery:</p>\n      <table class=\"compare-table\">\n        <tr><th>Mức</th><th>Ý nghĩa</th><th>Rủi ro</th></tr>\n        <tr><td>At-most-once</td><td>Gửi 1 lần, không retry</td><td>Có thể mất message</td></tr>\n        <tr><td>At-least-once</td><td>Retry cho đến khi ack</td><td>Có thể duplicate</td></tr>\n        <tr><td>Exactly-once</td><td>Đúng 1 lần, không mất, không duplicate</td><td>Overhead performance</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\"># Producer config - Idempotent producer</span>\nspring.kafka.producer.properties.enable.idempotence=true\nspring.kafka.producer.acks=all\nspring.kafka.producer.retries=Integer.MAX_VALUE\n\n<span class=\"cm\"># Transaction (đảm bảo atomic read-process-write)</span>\nspring.kafka.producer.transaction-id-prefix=tx-\n\n<span class=\"cm\">// Java code</span>\n<span class=\"an\">@Transactional</span>(<span class=\"st\">\"kafkaTransactionManager\"</span>)\n<span class=\"kw\">public void</span> <span class=\"fn\">processAndPublish</span>(String inputTopic, String outputTopic) {\n    ConsumerRecord&lt;?,?&gt; record = consumer.poll(...);\n    String result = process(record.value());\n    producer.send(<span class=\"kw\">new</span> ProducerRecord&lt;&gt;(outputTopic, result));\n    consumer.commitSync();  <span class=\"cm\">// atomic: publish + commit trong 1 transaction</span>\n}</div>\n      <div class=\"warn-box\">⚠️ Exactly-once có throughput thấp hơn ~20-30% do overhead transaction. Chỉ dùng khi thực sự cần (tài chính, billing). Thường At-least-once + idempotent consumer là đủ.</div>",
    "tags": "kafka",
    "level": "senior",
    "section": "Kafka",
    "sectionIcon": "🟠",
    "sectionColor": "#f97316",
    "sectionColorClass": "",
    "subsection": "Kafka Cơ Bản"
  },
  {
    "num": 179,
    "numStr": "179",
    "question": "Kafka Dead Letter Queue (DLQ) — xử lý message lỗi thế nào?",
    "answerHtml": "<p>Khi consumer không xử lý được message (business error, data invalid), không nên retry mãi mãi. <strong>DLQ</strong> là topic đặc biệt lưu các message fail để xử lý sau.</p>\n      <div class=\"code-block\"><span class=\"cm\">// Spring Kafka - cấu hình DLQ tự động</span>\n<span class=\"an\">@Bean</span>\n<span class=\"kw\">public</span> DefaultErrorHandler <span class=\"fn\">errorHandler</span>(KafkaTemplate&lt;?, ?&gt; kafkaTemplate) {\n    DeadLetterPublishingRecoverer recoverer =\n        <span class=\"kw\">new</span> DeadLetterPublishingRecoverer(kafkaTemplate,\n            (record, ex) -> <span class=\"kw\">new</span> TopicPartition(\n                record.topic() + <span class=\"st\">\".DLT\"</span>,  <span class=\"cm\">// → order-events.DLT</span>\n                record.partition()));\n\n    ExponentialBackOffWithMaxRetries backoff =\n        <span class=\"kw\">new</span> ExponentialBackOffWithMaxRetries(<span class=\"num\">3</span>);\n    backoff.setInitialInterval(<span class=\"num\">1000L</span>);\n    backoff.setMultiplier(<span class=\"num\">2.0</span>);   <span class=\"cm\">// retry: 1s, 2s, 4s → DLQ</span>\n\n    <span class=\"kw\">return new</span> DefaultErrorHandler(recoverer, backoff);\n}\n\n<span class=\"cm\">// Monitor DLQ consumer riêng</span>\n<span class=\"an\">@KafkaListener</span>(topics = <span class=\"st\">\"order-events.DLT\"</span>)\n<span class=\"kw\">public void</span> <span class=\"fn\">handleDLQ</span>(ConsumerRecord&lt;?,?&gt; record, <span class=\"an\">@Header</span> Map&lt;String,?&gt; headers) {\n    <span class=\"cm\">// headers chứa: original topic, exception, stack trace</span>\n    alertOpsTeam(record);  <span class=\"cm\">// alert khi có message vào DLQ</span>\n    dlqRepository.save(record);\n}</div>\n      <div class=\"tip-box\">💡 DLQ best practice: Phân biệt retriable error (network, DB timeout → retry) vs non-retriable error (invalid data, business rule → DLQ ngay). Dùng <code>addNotRetryableExceptions()</code> để skip retry cho lỗi rõ ràng.</div>",
    "tags": "kafka spring",
    "level": "senior",
    "section": "Kafka",
    "sectionIcon": "🟠",
    "sectionColor": "#f97316",
    "sectionColorClass": "",
    "subsection": "Kafka Cơ Bản"
  },
  {
    "num": 180,
    "numStr": "180",
    "question": "Elasticsearch Inverted Index là gì? Tại sao tìm kiếm nhanh?",
    "answerHtml": "<p><strong>Inverted Index</strong> là cấu trúc dữ liệu cốt lõi của Elasticsearch: thay vì lưu document → words, Elasticsearch lưu word → danh sách document chứa word đó.</p>\n      <div class=\"code-block\">Documents:\n  Doc1: \"Spring Boot là framework Java\"\n  Doc2: \"Java là ngôn ngữ mạnh mẽ\"\n\nInverted Index:\n  \"spring\"    → [Doc1]\n  \"boot\"      → [Doc1]\n  \"framework\" → [Doc1]\n  \"java\"      → [Doc1, Doc2]\n  \"là\"        → [Doc1, Doc2]\n  \"ngôn\"      → [Doc2]\n\nQuery \"java framework\":\n  \"java\"      → [Doc1, Doc2]\n  \"framework\" → [Doc1]\n  Intersection → [Doc1] với score cao hơn</div>\n      <div class=\"code-block\"><span class=\"cm\">// Elasticsearch query DSL</span>\nGET /posts/_search\n{\n  \"query\": {\n    \"multi_match\": {\n      \"query\": \"java framework\",\n      \"fields\": [\"title^2\", \"content\"],  // title boost x2\n      \"type\": \"best_fields\"\n    }\n  },\n  \"highlight\": {\n    \"fields\": { \"content\": {} }  // highlight từ khớp\n  }\n}</div>\n      <div class=\"tip-box\">💡 So sánh với SQL LIKE '%java%': phải scan toàn bộ table. ES inverted index lookup O(1) → nhanh hơn nhiều bậc cho full-text search với data lớn.</div>",
    "tags": "elk elasticsearch",
    "level": "junior",
    "section": "ELK Stack",
    "sectionIcon": "📊",
    "sectionColor": "#c084fc",
    "sectionColorClass": "",
    "subsection": "ELK Stack"
  },
  {
    "num": 181,
    "numStr": "181",
    "question": "Elasticsearch: Sharding và Replication hoạt động thế nào?",
    "answerHtml": "<p><strong>Shard</strong> là đơn vị phân tán: mỗi index được chia thành nhiều shard để phân tải và scale. <strong>Replica</strong> là bản sao của shard để tăng availability và read throughput.</p>\n      <div class=\"code-block\">Index: \"products\" - 3 primary shards, 1 replica\n\nNode 1: [P0] [R1] [R2]\nNode 2: [P1] [R0] [R2]\nNode 3: [P2] [R0] [R1]\n\n→ Node 2 chết: Node 1 & 3 vẫn có đủ data (replica)\n→ Read có thể từ P hoặc R → tăng throughput</div>\n      <div class=\"code-block\"><span class=\"cm\">// Tạo index với config</span>\nPUT /products\n{\n  \"settings\": {\n    \"number_of_shards\": 3,      // primary shards\n    \"number_of_replicas\": 1    // replica per shard\n  }\n}\n\n<span class=\"cm\">// Xem shard health</span>\nGET /_cat/shards?v\nGET /_cluster/health</div>\n      <div class=\"warn-box\">⚠️ Số primary shard KHÔNG thể thay đổi sau khi tạo index (phải reindex). Tính toán kỹ từ đầu: rule of thumb là 10-50GB per shard. Quá nhiều shard nhỏ gây overhead.</div>",
    "tags": "elk elasticsearch",
    "level": "middle",
    "section": "ELK Stack",
    "sectionIcon": "📊",
    "sectionColor": "#c084fc",
    "sectionColorClass": "",
    "subsection": "ELK Stack"
  },
  {
    "num": 182,
    "numStr": "182",
    "question": "Centralized Logging với ELK Stack trong Spring Boot — setup thế nào?",
    "answerHtml": "<p>Setup pipeline: <strong>Spring Boot → Logstash → Elasticsearch → Kibana</strong></p>\n      <div class=\"code-block\"><span class=\"cm\"># 1. Spring Boot: log ra file hoặc gửi qua TCP</span>\n<span class=\"cm\"># pom.xml - thêm logstash encoder</span>\n&lt;dependency&gt;\n    &lt;groupId&gt;net.logstash.logback&lt;/groupId&gt;\n    &lt;artifactId&gt;logstash-logback-encoder&lt;/artifactId&gt;\n&lt;/dependency&gt;\n\n// logback-spring.xml\n&lt;appender name=\"LOGSTASH\" class=\"net.logstash.logback.appender.LogstashTcpSocketAppender\"&gt;\n    &lt;destination&gt;logstash:5044&lt;/destination&gt;\n    &lt;encoder class=\"net.logstash.logback.encoder.LogstashEncoder\"/&gt;\n&lt;/appender&gt;</div>\n      <div class=\"code-block\"><span class=\"cm\"># 2. Logstash pipeline config</span>\ninput {\n  beats { port => 5044 }\n}\nfilter {\n  json { source => \"message\" }  # parse JSON log\n  mutate {\n    add_field => { \"[@metadata][target_index]\"\n                   => \"app-logs-%{+YYYY.MM.dd}\" }\n  }\n}\noutput {\n  elasticsearch {\n    hosts => [\"elasticsearch:9200\"]\n    index => \"%{[@metadata][target_index]}\"\n  }\n}</div>\n      <div class=\"code-block\"><span class=\"cm\">// 3. Log Correlation - MDC để track trace ID qua các service</span>\n<span class=\"an\">@Component</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">RequestIdFilter</span> <span class=\"kw\">implements</span> Filter {\n    <span class=\"kw\">public void</span> <span class=\"fn\">doFilter</span>(ServletRequest req, ...) {\n        String traceId = UUID.randomUUID().toString();\n        MDC.put(<span class=\"st\">\"traceId\"</span>, traceId);\n        <span class=\"kw\">try</span> { chain.doFilter(req, res); }\n        <span class=\"kw\">finally</span> { MDC.clear(); }\n    }\n}</div>\n      <div class=\"tip-box\">💡 Kibana query để tìm log theo trace ID: <code>traceId: \"abc-123\"</code>. Set up index pattern <code>app-logs-*</code> trong Kibana để tìm kiếm tất cả ngày.</div>",
    "tags": "elk spring",
    "level": "middle",
    "section": "ELK Stack",
    "sectionIcon": "📊",
    "sectionColor": "#c084fc",
    "sectionColorClass": "",
    "subsection": "ELK Stack"
  },
  {
    "num": 183,
    "numStr": "183",
    "question": "Elasticsearch Aggregation là gì? Query DSL vs Aggregation khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Query DSL</th><th>Aggregation</th></tr>\n        <tr><td>Mục đích</td><td>Tìm kiếm documents phù hợp</td><td>Phân tích/tổng hợp dữ liệu</td></tr>\n        <tr><td>Output</td><td>List of documents (hits)</td><td>Metrics, buckets, statistics</td></tr>\n        <tr><td>Tương đương SQL</td><td>WHERE clause</td><td>GROUP BY + COUNT/SUM/AVG</td></tr>\n      </table>\n      <div class=\"code-block\">GET /orders/_search\n{\n  \"query\": {\n    \"range\": { \"createdAt\": { \"gte\": \"2024-01-01\" } }\n  },\n  \"aggs\": {\n    \"revenue_by_status\": {\n      \"terms\": { \"field\": \"status.keyword\" },  // GROUP BY status\n      \"aggs\": {\n        \"total_revenue\": {\n          \"sum\": { \"field\": \"amount\" }           // SUM(amount)\n        },\n        \"avg_order_value\": {\n          \"avg\": { \"field\": \"amount\" }           // AVG(amount)\n        }\n      }\n    },\n    \"daily_orders\": {\n      \"date_histogram\": {\n        \"field\": \"createdAt\",\n        \"calendar_interval\": \"day\"              // GROUP BY day\n      }\n    }\n  },\n  \"size\": 0  // không cần hits, chỉ cần agg result\n}</div>\n      <div class=\"tip-box\">💡 Aggregation chạy trên tất cả shard song song → rất nhanh cho analytics. Kibana Dashboards thực chất là visualization của ES Aggregation queries.</div>",
    "tags": "elk elasticsearch",
    "level": "senior",
    "section": "ELK Stack",
    "sectionIcon": "📊",
    "sectionColor": "#c084fc",
    "sectionColorClass": "",
    "subsection": "ELK Stack"
  },
  {
    "num": 184,
    "numStr": "184",
    "question": "Database Index: B-Tree Index hoạt động như thế nào? Khi nào nên tạo index?",
    "answerHtml": "<p><strong>B-Tree Index</strong> là loại index phổ biến nhất. Cấu trúc cây cân bằng: giúp tìm kiếm, range query, sort trong O(log n) thay vì O(n) scan toàn bộ.</p>\n      <div class=\"code-block\">B-Tree (bậc 3) cho column age:\n              [20, 35]\n             /    |    \\\n         [10,15] [25,30] [40,50]\n\nQuery: age = 28\n → So sánh 28 với 20 (>), 35 (<)\n → Vào nhánh giữa [25,30]\n → Tìm 28: O(log n) thay vì scan toàn bộ</div>\n      <div class=\"code-block\"><span class=\"cm\">-- Khi nào TẠO index</span>\nCREATE INDEX idx_orders_user_id ON orders(user_id);\n<span class=\"cm\">-- ✅ Column trong WHERE clause thường xuyên</span>\n<span class=\"cm\">-- ✅ Column trong JOIN condition</span>\n<span class=\"cm\">-- ✅ Column trong ORDER BY</span>\n<span class=\"cm\">-- ✅ Foreign key columns</span>\n\n<span class=\"cm\">-- Khi nào KHÔNG tạo index</span>\n<span class=\"cm\">-- ❌ Column ít unique values (gender: M/F → chỉ 2 giá trị)</span>\n<span class=\"cm\">-- ❌ Table nhỏ (&lt;1000 rows → seq scan nhanh hơn)</span>\n<span class=\"cm\">-- ❌ Column thay đổi thường xuyên → index update overhead</span>\n\n<span class=\"cm\">-- Composite index: thứ tự quan trọng!</span>\nCREATE INDEX idx_user_status ON orders(user_id, status);\n<span class=\"cm\">-- Có thể dùng cho: WHERE user_id=1 AND status='PAID'</span>\n<span class=\"cm\">-- Có thể dùng cho: WHERE user_id=1</span>\n<span class=\"cm\">-- KHÔNG dùng được: WHERE status='PAID' (không có user_id)</span></div>\n      <div class=\"tip-box\">💡 Rule of thumb: Dùng EXPLAIN/EXPLAIN ANALYZE để kiểm tra query plan. Nếu thấy \"Seq Scan\" trên table lớn → xem xét thêm index.</div>",
    "tags": "database",
    "level": "junior",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 185,
    "numStr": "185",
    "question": "Database Transaction Isolation Levels: 4 mức là gì? Các vấn đề liên quan?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th>Level</th><th>Dirty Read</th><th>Non-Repeatable Read</th><th>Phantom Read</th></tr>\n        <tr><td>READ UNCOMMITTED</td><td>✅ Có thể</td><td>✅ Có thể</td><td>✅ Có thể</td></tr>\n        <tr><td>READ COMMITTED (default PG)</td><td>❌ Không</td><td>✅ Có thể</td><td>✅ Có thể</td></tr>\n        <tr><td>REPEATABLE READ (default MySQL)</td><td>❌ Không</td><td>❌ Không</td><td>✅ Có thể</td></tr>\n        <tr><td>SERIALIZABLE</td><td>❌ Không</td><td>❌ Không</td><td>❌ Không</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">-- Dirty Read: đọc uncommitted data của transaction khác</span>\n<span class=\"cm\">-- T1: UPDATE balance=500 (chưa commit)</span>\n<span class=\"cm\">-- T2: SELECT balance → 500 (dirty!)</span>\n<span class=\"cm\">-- T1: ROLLBACK → T2 đã dùng data sai</span>\n\n<span class=\"cm\">-- Non-Repeatable Read: query 2 lần trong transaction cho kết quả khác</span>\n<span class=\"cm\">-- T1: SELECT price → 100</span>\n<span class=\"cm\">-- T2: UPDATE price=120, COMMIT</span>\n<span class=\"cm\">-- T1: SELECT price → 120 (khác lần trước!)</span>\n\n<span class=\"cm\">-- Phantom Read: query 2 lần cho số hàng khác</span>\n<span class=\"cm\">-- T1: SELECT COUNT(*) WHERE age>18 → 10</span>\n<span class=\"cm\">-- T2: INSERT user(age=20), COMMIT</span>\n<span class=\"cm\">-- T1: SELECT COUNT(*) WHERE age>18 → 11 (phantom row!)</span>\n\n<span class=\"cm\">-- Spring set isolation level</span>\n<span class=\"an\">@Transactional</span>(isolation = Isolation.READ_COMMITTED)</div>\n      <div class=\"tip-box\">💡 Thực tế: READ COMMITTED đủ dùng cho 90% use case. REPEATABLE READ cho inventory/banking. SERIALIZABLE hiếm dùng vì ảnh hưởng throughput.</div>",
    "tags": "database",
    "level": "middle",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 186,
    "numStr": "186",
    "question": "PostgreSQL vs MySQL: khác nhau thế nào? Chọn cái nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>PostgreSQL</th><th>MySQL</th></tr>\n        <tr><td>ACID</td><td>✅ Đầy đủ, MVCC native</td><td>✅ InnoDB engine</td></tr>\n        <tr><td>JSON</td><td>✅ JSONB (binary, indexed)</td><td>JSON (text-based, ít tính năng hơn)</td></tr>\n        <tr><td>Full-text search</td><td>✅ Tốt hơn</td><td>Cơ bản</td></tr>\n        <tr><td>Complex queries</td><td>✅ Window functions, CTEs, lateral joins</td><td>Hỗ trợ từ MySQL 8</td></tr>\n        <tr><td>Concurrency</td><td>✅ MVCC tốt hơn (không lock read)</td><td>Có locking issues hơn</td></tr>\n        <tr><td>Replication</td><td>Logical/Physical, streaming</td><td>Binlog replication, mature</td></tr>\n        <tr><td>Phổ biến tại</td><td>Fintech, complex apps</td><td>Web apps, WordPress, e-commerce</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">-- PostgreSQL-specific features</span>\nSELECT user_id,\n       SUM(amount) OVER (PARTITION BY user_id ORDER BY created_at)\n         AS running_total        -- Window function\nFROM orders;\n\n<span class=\"cm\">-- JSONB query (PostgreSQL)</span>\nSELECT * FROM products\nWHERE metadata->>'color' = 'red'\n  AND (metadata->>'price')::numeric > 100;</div>\n      <div class=\"tip-box\">💡 2024: Dùng PostgreSQL cho new projects — feature-rich hơn, active community, native cloud support (RDS, Cloud SQL). MySQL nếu team đã quen hoặc project legacy.</div>",
    "tags": "database",
    "level": "middle",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 187,
    "numStr": "187",
    "question": "HikariCP Connection Pool — cấu hình tối ưu thế nào?",
    "answerHtml": "<p>HikariCP là default connection pool của Spring Boot — fastest Java connection pool. Config sai gây performance bottleneck nghiêm trọng.</p>\n      <div class=\"code-block\"><span class=\"cm\"># application.yml</span>\nspring.datasource.hikari:\n  maximum-pool-size: 10        # Số connection tối đa\n  minimum-idle: 5              # Số connection duy trì idle\n  connection-timeout: 30000    # Chờ tối đa lấy connection (30s)\n  idle-timeout: 600000         # Connection idle > 10 phút → close\n  max-lifetime: 1800000        # Lifetime tối đa connection (30 phút)\n  leak-detection-threshold: 2000  # Alert nếu connection bị giữ > 2s</div>\n      <div class=\"code-block\"><span class=\"cm\">// Công thức tính pool size (Hikari formula)</span>\npool_size = Tn * (Cm - 1) + 1\n<span class=\"cm\">// Tn = số thread tối đa</span>\n<span class=\"cm\">// Cm = số connection tối đa per transaction</span>\n\n<span class=\"cm\">// Ví dụ thực tế với IO-bound Spring Boot:</span>\n<span class=\"cm\">// CPU cores: 4, thread pool: 20, simple queries</span>\n<span class=\"cm\">// pool_size = 20 * (1-1) + 1 = 1 (quá nhỏ)</span>\n<span class=\"cm\">// → Thực tế: 10-20 thường đủ, đo bằng load test!</span>\n\n<span class=\"cm\">// Monitor với Actuator + Micrometer</span>\nGET /actuator/metrics/hikaricp.connections.active\nGET /actuator/metrics/hikaricp.connections.pending</div>\n      <div class=\"warn-box\">⚠️ Maximum pool size không phải cứ nhiều là tốt! Database server có giới hạn connections. PostgreSQL default max_connections=100. Dùng PgBouncer pooler ở DB side để scale.</div>",
    "tags": "database spring",
    "level": "senior",
    "section": "Database",
    "sectionIcon": "🗄️",
    "sectionColor": "#a78bfa",
    "sectionColorClass": "",
    "subsection": "SQL & Database Design"
  },
  {
    "num": 188,
    "numStr": "188",
    "question": "Saga Pattern là gì? Choreography vs Orchestration khác nhau thế nào?",
    "answerHtml": "<p><strong>Saga Pattern</strong> giải quyết vấn đề distributed transaction trong microservices: không có 2PC, mỗi service có transaction local và publish event để compensate khi fail.</p>\n      <table class=\"compare-table\">\n        <tr><th></th><th>Choreography</th><th>Orchestration</th></tr>\n        <tr><td>Kiểm soát</td><td>Phân tán — mỗi service tự lắng nghe event</td><td>Tập trung — Saga Orchestrator điều phối</td></tr>\n        <tr><td>Coupling</td><td>Thấp (loose coupling)</td><td>Orchestrator biết tất cả services</td></tr>\n        <tr><td>Tracking</td><td>Khó theo dõi flow</td><td>Dễ visualize và debug</td></tr>\n        <tr><td>Phù hợp</td><td>Simple flow, ít step</td><td>Complex flow, nhiều step</td></tr>\n        <tr><td>Tools</td><td>Kafka events</td><td>Temporal, Camunda, AWS Step Functions</td></tr>\n      </table>\n      <div class=\"code-block\">Choreography Saga — Đặt hàng:\n1. Order Service: tạo order → publish OrderCreated\n2. Inventory Service: giữ hàng → publish InventoryReserved\n3. Payment Service: charge → publish PaymentProcessed\n4. Order Service: cập nhật CONFIRMED\n\nNếu Payment fail:\n4b. Payment Service → publish PaymentFailed\n3b. Inventory Service lắng nghe → release hàng (compensate)\n2b. Order Service lắng nghe → set status CANCELLED</div>\n      <div class=\"tip-box\">💡 Mỗi bước trong Saga phải có <strong>compensating transaction</strong>. Saga không phải ACID — đây là eventual consistency. Thiết kế cẩn thận để idempotent.</div>",
    "tags": "microservice",
    "level": "senior",
    "section": "Microservice",
    "sectionIcon": "🔷",
    "sectionColor": "#38bdf8",
    "sectionColorClass": "",
    "subsection": "Microservice Architecture"
  },
  {
    "num": 189,
    "numStr": "189",
    "question": "Service Discovery là gì? Eureka vs Consul khác nhau thế nào?",
    "answerHtml": "<p><strong>Service Discovery</strong> giải quyết vấn đề: trong microservices, service instances lên/xuống liên tục và IP thay đổi. Service Discovery cho phép service tìm nhau theo tên thay vì IP cứng.</p>\n      <div class=\"code-block\">// Spring Boot với Eureka\n// 1. Eureka Server\n@SpringBootApplication\n@EnableEurekaServer\npublic class DiscoveryServer {}\n\n// 2. Service đăng ký\n# application.yml của Order Service\neureka:\n  client:\n    service-url.defaultZone: http://eureka:8761/eureka\nspring.application.name: order-service\n\n// 3. Gọi service theo tên\n@FeignClient(name = \"payment-service\")\npublic interface PaymentClient {\n    @PostMapping(\"/payments\")\n    PaymentResult processPayment(@RequestBody PaymentRequest req);\n}</div>\n      <table class=\"compare-table\">\n        <tr><th></th><th>Eureka</th><th>Consul</th></tr>\n        <tr><td>Consistency</td><td>AP (Available, Partition tolerant)</td><td>CP (Consistent, Partition tolerant)</td></tr>\n        <tr><td>Health check</td><td>Heartbeat-based</td><td>HTTP/TCP/Script check</td></tr>\n        <tr><td>Multi-DC</td><td>Cơ bản</td><td>✅ Native multi-datacenter</td></tr>\n        <tr><td>KV Store</td><td>❌</td><td>✅ Built-in KV store</td></tr>\n        <tr><td>Kubernetes</td><td>Ít dùng (K8s có DNS sẵn)</td><td>Native integration</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 Trong Kubernetes, không cần Eureka/Consul vì K8s Service + CoreDNS đã là service discovery. Chỉ cần thêm khi microservices chạy ngoài K8s.</div>",
    "tags": "microservice",
    "level": "middle",
    "section": "Microservice",
    "sectionIcon": "🔷",
    "sectionColor": "#38bdf8",
    "sectionColorClass": "",
    "subsection": "Microservice Architecture"
  },
  {
    "num": 190,
    "numStr": "190",
    "question": "Distributed Tracing là gì? Cách implement với Spring Boot?",
    "answerHtml": "<p><strong>Distributed Tracing</strong> theo dõi một request qua nhiều service: gắn <code>traceId</code> xuyên suốt, biết service nào chậm và tại sao.</p>\n      <div class=\"code-block\">Request → Order Service → Payment Service → Notification Service\n    traceId: abc-123                  ↑                ↑\n    spanId: 001       spanId: 002    spanId: 003\n\nTimeline:\n  Order Svc:    |----100ms----|  (gọi Payment)\n  Payment Svc:        |--80ms--|  (gọi Notification)\n  Notif Svc:               |--20ms--|</div>\n      <div class=\"code-block\"><span class=\"cm\"># pom.xml - Spring Boot 3.x dùng Micrometer Tracing</span>\n&lt;dependency&gt;\n    &lt;groupId&gt;io.micrometer&lt;/groupId&gt;\n    &lt;artifactId&gt;micrometer-tracing-bridge-brave&lt;/artifactId&gt;\n&lt;/dependency&gt;\n&lt;dependency&gt;\n    &lt;groupId&gt;io.zipkin.reporter2&lt;/groupId&gt;\n    &lt;artifactId&gt;zipkin-reporter-brave&lt;/artifactId&gt;\n&lt;/dependency&gt;\n\n<span class=\"cm\"># application.yml</span>\nmanagement.tracing.sampling.probability: 1.0  # sample 100%\nspring.zipkin.base-url: http://zipkin:9411\n\n<span class=\"cm\">// traceId tự động propagate qua HTTP headers (B3 format)</span>\n<span class=\"cm\">// X-B3-TraceId, X-B3-SpanId, X-B3-ParentSpanId</span>\n<span class=\"cm\">// Qua Feign Client, RestTemplate, WebClient tự động</span>\n\n<span class=\"cm\">// Custom span</span>\n<span class=\"an\">@Autowired</span> Tracer tracer;\n<span class=\"kw\">void</span> <span class=\"fn\">processPayment</span>() {\n    Span span = tracer.nextSpan().name(<span class=\"st\">\"process-payment\"</span>).start();\n    <span class=\"kw\">try</span> (Tracer.SpanInScope ws = tracer.withSpan(span)) {\n        doWork();\n    } <span class=\"kw\">finally</span> { span.end(); }\n}</div>\n      <div class=\"tip-box\">💡 Tools phổ biến: Zipkin (open source, đơn giản), Jaeger (CNCF, scalable hơn), Tempo + Grafana (stack hiện đại). Kết hợp với ELK để search log theo traceId.</div>",
    "tags": "microservice spring",
    "level": "senior",
    "section": "Microservice",
    "sectionIcon": "🔷",
    "sectionColor": "#38bdf8",
    "sectionColorClass": "",
    "subsection": "Microservice Architecture"
  },
  {
    "num": 191,
    "numStr": "191",
    "question": "CQRS Pattern là gì? Khi nào dùng?",
    "answerHtml": "<p><strong>CQRS (Command Query Responsibility Segregation)</strong>: Tách riêng model Write (Command) và Read (Query). Write model đảm bảo business rules và consistency; Read model tối ưu cho display.</p>\n      <div class=\"code-block\">Command Side (Write):              Query Side (Read):\n  POST /orders → OrderCommand   →  GET /orders/{id} → OrderSummaryDTO\n  PUT /orders/{id}/cancel           GET /orders?userId=1 → List&lt;OrderDTO&gt;\n  ↓                                  ↑\n  OrderAggregate (domain logic)    OrderReadRepository\n  OrderRepository (DB write)       (Elasticsearch / Read DB)\n  ↓\n  DomainEvent published → Kafka → sync sang Read side</div>\n      <div class=\"code-block\"><span class=\"cm\">// Command side - focus on business rules</span>\n<span class=\"kw\">record</span> <span class=\"cl\">PlaceOrderCommand</span>(String userId, List&lt;OrderItem&gt; items) {}\n\n<span class=\"an\">@CommandHandler</span>\n<span class=\"kw\">public</span> String <span class=\"fn\">handle</span>(PlaceOrderCommand cmd) {\n    Order order = Order.place(cmd.userId(), cmd.items());\n    orderRepository.save(order);\n    eventBus.publish(new OrderPlacedEvent(order.getId()));\n    <span class=\"kw\">return</span> order.getId();\n}\n\n<span class=\"cm\">// Query side - denormalized, fast read</span>\n<span class=\"an\">@QueryHandler</span>\n<span class=\"kw\">public</span> OrderSummaryDTO <span class=\"fn\">handle</span>(GetOrderQuery query) {\n    <span class=\"kw\">return</span> orderReadRepo.findById(query.orderId());  <span class=\"cm\">// flat, join-free</span>\n}</div>\n      <div class=\"warn-box\">⚠️ CQRS tăng độ phức tạp đáng kể — eventual consistency, sync lag giữa write và read. Chỉ dùng khi: read/write ratio rất khác nhau, cần optimize riêng, hoặc kết hợp Event Sourcing.</div>",
    "tags": "microservice",
    "level": "senior",
    "section": "Microservice",
    "sectionIcon": "🔷",
    "sectionColor": "#38bdf8",
    "sectionColorClass": "",
    "subsection": "Microservice Architecture"
  },
  {
    "num": 192,
    "numStr": "192",
    "question": "Design Real-Time Leaderboard — xử lý 100M users, cập nhật real-time?",
    "answerHtml": "<p><strong>Requirements:</strong> Score cập nhật real-time, lấy top 100, lấy ranking của 1 user.</p>\n      <div class=\"code-block\">Core Data Structure: Redis Sorted Set\nKey: \"leaderboard:global\"  Type: Sorted Set  Score: user's score\n\nOperations:\n  ZADD leaderboard:global 1500 \"user:123\"  → O(log N)\n  ZINCRBY leaderboard:global 50 \"user:123\" → O(log N)\n  ZREVRANK leaderboard:global \"user:123\"   → O(log N) - rank của user\n  ZREVRANGE leaderboard:global 0 99        → O(log N + 100) - top 100\n  ZSCORE leaderboard:global \"user:123\"     → O(1) - score của user</div>\n      <div class=\"code-block\">Scale 100M users:\n\n1. SHARDING: Không thể 1 Sorted Set 100M entries\n   → Shard theo user_id: leaderboard:shard-0, shard-1, ..., shard-N\n   → Top global = merge top-K từ mỗi shard (external sort)\n\n2. HIERARCHICAL LEADERBOARD:\n   → leaderboard:global (top 10,000 only)\n   → leaderboard:weekly (reset mỗi tuần)\n   → leaderboard:friends:user:123 (friend group)\n\n3. WRITE OPTIMIZATION:\n   → Batch updates: collect scores 5s → ZADD in pipeline\n   → Async update: Kafka → Leaderboard Consumer → Redis\n\n4. REAL-TIME PUSH:\n   → WebSocket: push top 100 mỗi 5 giây\n   → SSE: stream rank changes cho user</div>\n      <div class=\"tip-box\">💡 Thực tế tại game companies: Không lưu ALL 100M users trong sorted set. Chỉ giữ qualified users (score > threshold). Archive phần còn lại vào DB.</div>",
    "tags": "systemdesign redis",
    "level": "expert",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 193,
    "numStr": "193",
    "question": "Design File Upload Service (S3-style) — upload large files, multi-tenant?",
    "answerHtml": "<p><strong>Requirements:</strong> Upload file lớn (up to 5GB), multi-tenant, secure, CDN delivery.</p>\n      <div class=\"code-block\">Architecture:\n\n1. PRESIGNED URL FLOW (tránh file đi qua server)\n   Client → POST /files/presign {fileName, size, contentType}\n   Server → validate quota, tạo presigned S3 URL (expire 15 phút)\n   Client → PUT {presignedUrl} (upload trực tiếp lên S3)\n   Client → POST /files/confirm {fileId} khi upload xong\n   Server → trigger virus scan, generate metadata\n\n2. MULTIPART UPLOAD (file > 100MB)\n   POST /files/multipart/initiate → uploadId\n   PUT each part (5MB-5GB/part) → etag per part\n   POST /files/multipart/complete → {uploadId, parts[]} → S3 combines\n\n3. STORAGE STRUCTURE\n   s3://bucket/{tenantId}/{year}/{month}/{fileId}/{filename}\n   → Isolate per tenant, lifecycle policy per prefix\n\n4. METADATA (PostgreSQL)\n   file_id, tenant_id, original_name, s3_key,\n   size, content_type, checksum (MD5/SHA256),\n   status (PENDING|SCANNING|READY|INFECTED),\n   uploaded_by, created_at, expires_at\n\n5. CDN DELIVERY\n   CloudFront signed URL → time-limited access\n   Short-lived URL → prevent hotlinking</div>\n      <div class=\"code-block\"><span class=\"cm\">// Spring Boot - Presigned URL generation</span>\nS3Presigner presigner = S3Presigner.create();\nPutObjectRequest objectRequest = PutObjectRequest.builder()\n    .bucket(<span class=\"st\">\"my-bucket\"</span>)\n    .key(tenantId + <span class=\"st\">\"/\"</span> + fileId)\n    .contentType(contentType)\n    .build();\nPresignedPutObjectRequest presigned = presigner.presignPutObject(\n    r -> r.signatureDuration(Duration.ofMinutes(<span class=\"num\">15</span>))\n           .putObjectRequest(objectRequest));\n<span class=\"kw\">return</span> presigned.url().toString();</div>\n      <div class=\"tip-box\">💡 Virus scanning: ClamAV (open source) hoặc AWS Macie, scan async sau khi upload xong. Status SCANNING → READY hoặc INFECTED. Notify user qua WebSocket/email.</div>",
    "tags": "systemdesign",
    "level": "expert",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 194,
    "numStr": "194",
    "question": "Design Distributed Cache — tại sao cần và implement ở scale thế nào?",
    "answerHtml": "<p><strong>Requirements:</strong> Cache 100M keys, sub-millisecond read, high availability, cache eviction.</p>\n      <div class=\"code-block\">Vấn đề với đơn giản:\n  Single Redis → SPOF (Single Point of Failure)\n  Data > RAM → không lưu được hết\n  High write rate → single instance bottleneck\n\nSolution: Redis Cluster + Consistent Hashing\n\n  16384 hash slots chia cho N master nodes\n  Key → CRC16(key) % 16384 → slot → node\n  Mỗi master có 1+ replica\n\n  Node 1 (master): slot 0-5460\n  Node 2 (master): slot 5461-10922\n  Node 3 (master): slot 10923-16383\n\n→ Tăng/giảm node: chỉ di chuyển subset slots → zero downtime</div>\n      <div class=\"code-block\">Cache Strategy:\n\n1. CACHE-ASIDE (lazy loading) - phổ biến nhất\n   Read: check cache → miss → DB → set cache → return\n   Write: write DB → invalidate cache\n   Pros: chỉ cache data thực sự cần\n   Cons: cache miss first time, stale data\n\n2. WRITE-THROUGH\n   Write: DB + cache đồng thời\n   Pros: không stale\n   Cons: write latency tăng, cache nhiều cold data\n\n3. WRITE-BEHIND (async)\n   Write: cache ngay → async write DB\n   Pros: write rất nhanh\n   Cons: mất data nếu cache crash trước khi sync\n\nEviction policies:\n  LRU (Least Recently Used) - mặc định Redis\n  LFU (Least Frequently Used) - Redis 4+\n  TTL-based: allkeys-lru, volatile-lru</div>\n      <div class=\"tip-box\">💡 Netflix dùng EVCache (Memcached-based) để cache hàng tỷ keys. Rule of thumb: 20% data được truy cập 80% thời gian → cache 20% đó là đủ.</div>",
    "tags": "systemdesign redis",
    "level": "expert",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 195,
    "numStr": "195",
    "question": "Spring Boot @Async hoạt động như thế nào? Tránh các pitfalls nào?",
    "answerHtml": "<p><code>@Async</code> cho phép method chạy bất đồng bộ trên thread pool riêng. Spring tạo proxy và submit task vào <code>ThreadPoolTaskExecutor</code>.</p>\n      <div class=\"code-block\"><span class=\"cm\">// 1. Enable async</span>\n<span class=\"an\">@SpringBootApplication</span>\n<span class=\"an\">@EnableAsync</span>\n<span class=\"kw\">public class</span> <span class=\"cl\">App</span> {}\n\n<span class=\"cm\">// 2. Config executor (QUAN TRỌNG - đừng dùng default!)</span>\n<span class=\"an\">@Bean</span>\n<span class=\"kw\">public</span> TaskExecutor <span class=\"fn\">asyncExecutor</span>() {\n    ThreadPoolTaskExecutor executor = <span class=\"kw\">new</span> ThreadPoolTaskExecutor();\n    executor.setCorePoolSize(<span class=\"num\">5</span>);\n    executor.setMaxPoolSize(<span class=\"num\">20</span>);\n    executor.setQueueCapacity(<span class=\"num\">100</span>);\n    executor.setThreadNamePrefix(<span class=\"st\">\"async-\"</span>);\n    executor.setRejectedExecutionHandler(<span class=\"kw\">new</span> ThreadPoolExecutor.CallerRunsPolicy());\n    executor.initialize();\n    <span class=\"kw\">return</span> executor;\n}\n\n<span class=\"cm\">// 3. Dùng @Async</span>\n<span class=\"an\">@Async</span>(<span class=\"st\">\"asyncExecutor\"</span>)\n<span class=\"kw\">public</span> CompletableFuture&lt;String&gt; <span class=\"fn\">sendEmail</span>(String to) {\n    emailProvider.send(to);  <span class=\"cm\">// chạy trên thread riêng</span>\n    <span class=\"kw\">return</span> CompletableFuture.completedFuture(<span class=\"st\">\"sent\"</span>);\n}</div>\n      <div class=\"warn-box\">⚠️ Pitfalls: (1) @Async trên private method → không hoạt động do proxy. (2) Self-invocation bypass proxy. (3) Default SimpleAsyncTaskExecutor tạo thread mới mỗi lần (không pool). (4) Exception trong @Async bị nuốt — phải dùng AsyncUncaughtExceptionHandler.</div>",
    "tags": "spring core",
    "level": "senior",
    "section": "Spring Boot",
    "sectionIcon": "🌱",
    "sectionColor": "#34d399",
    "sectionColorClass": "spring-color",
    "subsection": "Core Concepts"
  },
  {
    "num": 196,
    "numStr": "196",
    "question": "Kafka Streams vs Consumer API — khi nào dùng cái nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Kafka Consumer API</th><th>Kafka Streams</th></tr>\n        <tr><td>Tính năng</td><td>Consume và xử lý thủ công</td><td>Stream processing framework đầy đủ</td></tr>\n        <tr><td>State</td><td>Stateless (thường)</td><td>✅ Stateful (local RocksDB store)</td></tr>\n        <tr><td>Join</td><td>Tự implement</td><td>✅ Stream-stream, stream-table join</td></tr>\n        <tr><td>Windowing</td><td>Tự implement</td><td>✅ Tumbling, hopping, session window</td></tr>\n        <tr><td>Fault tolerance</td><td>Tự handle</td><td>✅ Built-in với changelog topic</td></tr>\n        <tr><td>Dùng khi</td><td>Simple event processing, transform, route</td><td>Aggregation, join, real-time analytics</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\">// Kafka Streams - count orders per user (1 phút sliding window)</span>\nKStreamBuilder builder = <span class=\"kw\">new</span> StreamsBuilder();\n\nKStream&lt;String, OrderEvent&gt; orders =\n    builder.stream(<span class=\"st\">\"order-events\"</span>);\n\norders\n    .groupBy((key, order) -> order.getUserId())\n    .windowedBy(TimeWindows.ofSizeWithNoGrace(Duration.ofMinutes(<span class=\"num\">1</span>)))\n    .count()\n    .toStream()\n    .map((windowedKey, count) ->\n        KeyValue.pair(windowedKey.key(), count))\n    .to(<span class=\"st\">\"user-order-counts\"</span>);\n\nKafkaStreams streams = <span class=\"kw\">new</span> KafkaStreams(builder.build(), config);\nstreams.start();</div>\n      <div class=\"tip-box\">💡 Kafka Streams chạy như embedded library trong Java app — không cần separate cluster. Dùng khi cần: aggregation, join 2 streams, tumbling window analytics. Simple fan-out/routing → dùng Consumer API là đủ.</div>",
    "tags": "kafka",
    "level": "senior",
    "section": "Kafka",
    "sectionIcon": "🟠",
    "sectionColor": "#f97316",
    "sectionColorClass": "",
    "subsection": "Kafka Cơ Bản"
  },
  {
    "num": 197,
    "numStr": "197",
    "question": "Elasticsearch Performance Tuning — các vấn đề phổ biến là gì?",
    "answerHtml": "<p>Các vấn đề thường gặp trong production ES và cách xử lý:</p>\n      <table class=\"compare-table\">\n        <tr><th>Vấn đề</th><th>Nguyên nhân</th><th>Fix</th></tr>\n        <tr><td>High heap usage</td><td>Field data cache, aggregation lớn</td><td>Tăng heap, dùng doc_values, giới hạn aggregation size</td></tr>\n        <tr><td>Slow indexing</td><td>Too many shards, refresh too often</td><td>Giảm shard số, tăng refresh_interval</td></tr>\n        <tr><td>Slow search</td><td>Wildcard query, heavy aggregation</td><td>Tránh leading wildcard, dùng filter context</td></tr>\n        <tr><td>OOM</td><td>Heap < 50% RAM, GC pressure</td><td>Set heap = min(50%RAM, 32GB)</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\"># Bulk indexing - tăng throughput</span>\n<span class=\"cm\"># Dùng Bulk API thay vì index từng document</span>\nPOST /_bulk\n{ \"index\": { \"_index\": \"logs\" } }\n{ \"timestamp\": \"2024-01-01\", \"message\": \"...\", \"level\": \"INFO\" }\n{ \"index\": { \"_index\": \"logs\" } }\n{ \"timestamp\": \"2024-01-01\", \"message\": \"...\", \"level\": \"ERROR\" }\n\n<span class=\"cm\"># Tăng indexing performance</span>\nPUT /logs/_settings\n{\n  \"refresh_interval\": \"30s\",     // default 1s → ít refresh hơn\n  \"number_of_replicas\": 0        // giảm replica khi bulk load\n}\n\n<span class=\"cm\"># Query optimization: Filter context (không tính score = cache)</span>\nGET /logs/_search\n{\n  \"query\": {\n    \"bool\": {\n      \"filter\": [                          // filter context - cacheable\n        { \"term\": { \"level\": \"ERROR\" } },\n        { \"range\": { \"timestamp\": { \"gte\": \"now-1h\" } } }\n      ]\n    }\n  }\n}</div>\n      <div class=\"tip-box\">💡 ES heap rule: Không vượt 32GB (JVM compressed oops limit). 50% RAM cho heap, 50% cho OS file cache (Lucene dùng nhiều). Minimum 1GB memory per shard.</div>",
    "tags": "elk elasticsearch",
    "level": "senior",
    "section": "ELK Stack",
    "sectionIcon": "📊",
    "sectionColor": "#c084fc",
    "sectionColorClass": "",
    "subsection": "ELK Stack"
  },
  {
    "num": 198,
    "numStr": "198",
    "question": "Design E-Commerce Order System — xử lý 100K orders/giây?",
    "answerHtml": "<p><strong>Core challenge:</strong> Inventory consistency (không oversell), payment reliability, và scale.</p>\n      <div class=\"code-block\">High-Level Architecture:\n\nClient → API Gateway → Order Service\n            ↓                ↓\n       Auth/Ratelimit    Kafka: order-created\n                             ↓           ↓           ↓\n                        Inventory   Payment     Notification\n                          Service    Service      Service\n                             ↓\n                      PostgreSQL (inventory)\n                      Redis (stock cache)</div>\n      <div class=\"code-block\">Inventory Anti-Oversell:\n\n// Option 1: Optimistic Lock\n@Transactional\nvoid reserveStock(Long productId, int qty) {\n    Product p = repo.findById(productId);\n    if (p.getStock() &lt; qty) throw new InsufficientStockException();\n    p.setStock(p.getStock() - qty);  // @Version auto-check\n    repo.save(p);\n}\n\n// Option 2: Redis atomic DECRBY\nLong remaining = redisTemplate.opsForValue()\n    .decrement(\"stock:\" + productId, qty);\nif (remaining &lt; 0) {\n    redisTemplate.opsForValue().increment(\"stock:\" + productId, qty);\n    throw new InsufficientStockException();\n}\n// → Async sync Redis → DB</div>\n      <div class=\"code-block\">Scale 100K orders/s:\n  Write path: API Gateway → Kafka (buffer) → async DB write\n  Kafka cluster 50 partitions → 50 concurrent consumers\n  Order Service: 20 instances × 5K req/s = 100K req/s\n\n  DB: PostgreSQL (write) + Read Replicas (query orders)\n  Sharding by user_id % N for horizontal scale\n  Payment: idempotency key → prevent duplicate charge</div>\n      <div class=\"tip-box\">💡 Bài toán then chốt là inventory reservation: 2 phase commit quá chậm, Saga đơn giản hơn nhưng cần compensating transaction. Redis DECRBY là giải pháp phổ biến nhất cho high-throughput inventory.</div>",
    "tags": "systemdesign kafka database",
    "level": "expert",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 199,
    "numStr": "199",
    "question": "Horizontal Scaling vs Vertical Scaling — khi nào dùng cái nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Vertical Scaling (Scale Up)</th><th>Horizontal Scaling (Scale Out)</th></tr>\n        <tr><td>Cách làm</td><td>Nâng cấp máy mạnh hơn (CPU, RAM)</td><td>Thêm nhiều máy/instance</td></tr>\n        <tr><td>Giới hạn</td><td>Có giới hạn phần cứng tối đa</td><td>Gần như không giới hạn</td></tr>\n        <tr><td>Downtime</td><td>Thường cần restart</td><td>Zero downtime (rolling deploy)</td></tr>\n        <tr><td>Cost</td><td>Exponential (máy xịn rất đắt)</td><td>Linear (thêm máy bình thường)</td></tr>\n        <tr><td>Session</td><td>Không cần lo (1 máy)</td><td>Cần sticky session hoặc distributed session</td></tr>\n        <tr><td>Phù hợp</td><td>DB (RDBMS khó horizontal scale), rapid fix</td><td>Stateless services, microservices</td></tr>\n      </table>\n      <div class=\"code-block\">Thực tế kiến trúc điển hình:\n\nDatabase:      Vertical scale (PostgreSQL master) + Read Replicas\nApp Server:    Horizontal scale (10 Spring Boot instances behind LB)\nCache:         Redis Cluster (horizontal)\n\nDấu hiệu cần Scale Out:\n  CPU > 80% liên tục → thêm instance\n  Latency tăng theo traffic → thêm instance\n  Single point of failure → thêm replica</div>\n      <div class=\"tip-box\">💡 Stateless là chìa khóa scale horizontally: không lưu session trong app, không local file storage, config qua environment variable. Spring Boot stateless by design → scale out dễ dàng.</div>",
    "tags": "systemdesign performance",
    "level": "junior",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 200,
    "numStr": "200",
    "question": "Load Balancing — các thuật toán Round Robin, Least Connection, IP Hash khác nhau thế nào?",
    "answerHtml": "<p><strong>Load Balancer</strong> phân phối traffic đến các backend instances. Chọn sai thuật toán gây uneven load.</p>\n      <table class=\"compare-table\">\n        <tr><th>Thuật toán</th><th>Cách hoạt động</th><th>Dùng khi</th><th>Nhược điểm</th></tr>\n        <tr><td>Round Robin</td><td>Xoay vòng lần lượt: 1→2→3→1→2→3</td><td>Servers đồng đều, requests tương tự nhau</td><td>Không tính đến server load hiện tại</td></tr>\n        <tr><td>Weighted Round Robin</td><td>Server mạnh hơn nhận nhiều request hơn</td><td>Servers có capacity khác nhau</td><td>Cần biết trước capacity</td></tr>\n        <tr><td>Least Connection</td><td>Gửi đến server ít active connections nhất</td><td>Requests có duration khác nhau (long-polling)</td><td>Cần theo dõi connection count</td></tr>\n        <tr><td>IP Hash</td><td>CRC(client IP) % N → cùng IP luôn đến cùng server</td><td>Cần sticky session mà không dùng shared session</td><td>Uneven nếu IP distribution lệch</td></tr>\n        <tr><td>Random</td><td>Ngẫu nhiên</td><td>Simple, stateless</td><td>Không đảm bảo đều</td></tr>\n      </table>\n      <div class=\"code-block\"># Nginx load balancing config\nupstream backend {\n    # Round Robin (default)\n    server app1:8080;\n    server app2:8080;\n    server app3:8080;\n\n    # Weighted\n    # server app1:8080 weight=3;\n    # server app2:8080 weight=1;\n\n    # Least Connection\n    # least_conn;\n\n    # IP Hash (sticky)\n    # ip_hash;\n\n    keepalive 32;  # connection pool to upstream\n}\n\nserver {\n    location /api/ {\n        proxy_pass http://backend;\n        proxy_next_upstream error timeout; # retry on fail\n    }\n}</div>\n      <div class=\"tip-box\">💡 Layer 4 LB (TCP level) vs Layer 7 LB (HTTP level): L7 đắt hơn nhưng có thể route dựa trên URL path, headers, cookie. AWS ALB = L7, AWS NLB = L4.</div>",
    "tags": "systemdesign performance",
    "level": "middle",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 201,
    "numStr": "201",
    "question": "CDN là gì? Khi nào cần dùng? Cách tích hợp với Spring Boot?",
    "answerHtml": "<p><strong>CDN (Content Delivery Network)</strong>: Mạng lưới server phân tán trên toàn cầu, cache content gần người dùng → giảm latency, giảm tải origin server.</p>\n      <div class=\"code-block\">Không có CDN:\n  User Hà Nội → Server Singapore → 80ms round trip\n\nCó CDN:\n  User Hà Nội → CDN Edge Hà Nội (cache) → 5ms ✅\n  Cache miss → CDN Edge → Origin Singapore → cache → next request: 5ms</div>\n      <table class=\"compare-table\">\n        <tr><th>Loại content</th><th>CDN có giúp?</th><th>Cache strategy</th></tr>\n        <tr><td>Static files (JS, CSS, images)</td><td>✅ Rất tốt</td><td>Cache-Control: max-age=31536000 (1 năm + versioned filename)</td></tr>\n        <tr><td>API response</td><td>✅ Nếu cacheable (GET, public)</td><td>Cache-Control: max-age=60, s-maxage=300</td></tr>\n        <tr><td>User-specific data</td><td>❌ Không nên</td><td>Cache-Control: private, no-store</td></tr>\n        <tr><td>Realtime data</td><td>❌</td><td>no-cache</td></tr>\n      </table>\n      <div class=\"code-block\">// Spring Boot - set Cache-Control headers\n@GetMapping(\"/products\")\n@ResponseBody\npublic ResponseEntity&lt;List&lt;Product&gt;&gt; getProducts() {\n    return ResponseEntity.ok()\n        .cacheControl(CacheControl.maxAge(5, TimeUnit.MINUTES)\n            .cachePublic())\n        .body(productService.findAll());\n}\n\n// Static resources - long cache với content hash\n@Configuration\npublic class WebConfig implements WebMvcConfigurer {\n    @Override\n    public void addResourceHandlers(ResourceHandlerRegistry r) {\n        r.addResourceHandler(\"/static/**\")\n         .addResourceLocations(\"classpath:/static/\")\n         .setCacheControl(CacheControl.maxAge(365, TimeUnit.DAYS));\n    }\n}</div>\n      <div class=\"tip-box\">💡 CDN Invalidation: Khi push code mới, static files có content hash mới (main.a3f4b.js) → URL khác → CDN tự cache version mới, không cần purge. API response dùng Surrogate-Key để selective purge.</div>",
    "tags": "systemdesign performance",
    "level": "middle",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 202,
    "numStr": "202",
    "question": "Database Read Replica — khi nào cần? Setup và xử lý với Spring Boot thế nào?",
    "answerHtml": "<p>Read Replica là bản sao của DB master, chỉ để <strong>xử lý READ queries</strong>. Giải quyết bottleneck khi read nhiều hơn write (tỷ lệ thường 80:20).</p>\n      <div class=\"code-block\">Architecture:\n  Write operations → Master DB (primary)\n  Read operations  → Replica 1, Replica 2, ... (load balanced)\n\nLag: Replica sync với master qua replication log (~ms)\n→ Eventual consistency: read ngay sau write có thể trả data cũ!</div>\n      <div class=\"code-block\">// Spring Boot - Routing đến Master/Replica\n// 1. Config 2 DataSource\n@Bean\n@ConfigurationProperties(\"spring.datasource.master\")\npublic DataSource masterDataSource() { return ... }\n\n@Bean\n@ConfigurationProperties(\"spring.datasource.replica\")\npublic DataSource replicaDataSource() { return ... }\n\n// 2. AbstractRoutingDataSource - chọn DS theo transaction type\npublic class RoutingDataSource extends AbstractRoutingDataSource {\n    @Override\n    protected Object determineCurrentLookupKey() {\n        return TransactionSynchronizationManager.isCurrentTransactionReadOnly()\n            ? \"replica\" : \"master\";\n    }\n}\n\n// 3. @Transactional(readOnly = true) → tự routing sang replica\n@Transactional(readOnly = true)\npublic List&lt;Product&gt; findAll() {\n    return productRepo.findAll();  // → replica\n}\n\n@Transactional  // readOnly = false → master\npublic Product save(Product p) {\n    return productRepo.save(p);   // → master\n}</div>\n      <div class=\"warn-box\">⚠️ Replication lag pitfall: User tạo đơn hàng → redirect sang trang order detail → read từ replica → order chưa xuất hiện (lag ~100ms). Fix: sau write operation, force read từ master trong cùng request hoặc dùng read-your-writes session.</div>",
    "tags": "database performance systemdesign",
    "level": "senior",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 203,
    "numStr": "203",
    "question": "Performance Testing — Load Test, Stress Test, Spike Test, Soak Test khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th>Loại</th><th>Mục đích</th><th>Pattern</th><th>Câu hỏi trả lời</th></tr>\n        <tr><td>Load Test</td><td>Đo performance ở expected load</td><td>Tăng dần đến expected traffic</td><td>App có đáp ứng SLA ở load bình thường?</td></tr>\n        <tr><td>Stress Test</td><td>Tìm điểm gãy (breaking point)</td><td>Tăng mãi đến khi hệ thống fail</td><td>Hệ thống gãy ở đâu? Recover thế nào?</td></tr>\n        <tr><td>Spike Test</td><td>Test đột biến traffic</td><td>0 → Peak đột ngột → 0</td><td>App có chịu được flash sale / viral post?</td></tr>\n        <tr><td>Soak Test</td><td>Test memory leak, resource drain</td><td>Load bình thường trong 24h+</td><td>App có ổn định trong thời gian dài?</td></tr>\n      </table>\n      <div class=\"code-block\"># k6 load test script\nimport http from 'k6/http';\nimport { check, sleep } from 'k6';\n\nexport const options = {\n  stages: [\n    { duration: '2m', target: 100 },  // ramp up\n    { duration: '5m', target: 100 },  // stay at 100 users\n    { duration: '2m', target: 0 },    // ramp down\n  ],\n  thresholds: {\n    'http_req_duration': ['p95&lt;500'],  // 95% requests &lt; 500ms\n    'http_req_failed': ['rate&lt;0.01'],  // &lt; 1% error rate\n  },\n};\n\nexport default function() {\n  const res = http.get('http://api.example.com/products');\n  check(res, {\n    'status 200': (r) =&gt; r.status === 200,\n    'response &lt; 200ms': (r) =&gt; r.timings.duration &lt; 200,\n  });\n  sleep(1);\n}</div>\n      <div class=\"tip-box\">💡 Tools phổ biến: k6 (modern, JS-based), JMeter (Java, GUI), Gatling (Scala, CI-friendly), Locust (Python). Metrics cần theo dõi: Throughput (RPS), Latency (p50/p95/p99), Error rate, Saturation (CPU, memory, connections).</div>",
    "tags": "performance systemdesign",
    "level": "middle",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 204,
    "numStr": "204",
    "question": "Java Performance Profiling — công cụ và cách tìm bottleneck trong production?",
    "answerHtml": "<p>Profiling phân loại 2 dạng: <strong>CPU profiling</strong> (method nào tốn nhiều CPU) và <strong>Memory profiling</strong> (object nào chiếm nhiều heap).</p>\n      <table class=\"compare-table\">\n        <tr><th>Vấn đề</th><th>Triệu chứng</th><th>Tool/Lệnh</th></tr>\n        <tr><td>High CPU</td><td>CPU spike, latency tăng</td><td>async-profiler, jstack, Flight Recorder</td></tr>\n        <tr><td>Memory leak</td><td>Heap tăng dần, Full GC thường xuyên</td><td>jmap, VisualVM, Eclipse MAT</td></tr>\n        <tr><td>Thread contention</td><td>Thread BLOCKED, throughput thấp</td><td>jstack, thread dump analysis</td></tr>\n        <tr><td>Slow DB queries</td><td>Response time cao, DB CPU cao</td><td>Spring Boot Actuator, p6spy, EXPLAIN</td></tr>\n        <tr><td>GC pressure</td><td>GC pause spikes, latency jitter</td><td>GC logs, GCViewer, GCEasy</td></tr>\n      </table>\n      <div class=\"code-block\"># async-profiler - low overhead CPU profiling (production safe)\n./profiler.sh -d 30 -f /tmp/profile.html &lt;PID&gt;  # 30 giây\n\n# Phân tích heap dump - tìm memory leak\njmap -dump:format=b,file=/tmp/heap.hprof &lt;PID&gt;\n# Mở bằng Eclipse MAT → Leak Suspects report\n\n# Thread dump - tìm deadlock/contention\njstack &lt;PID&gt; &gt; /tmp/thread_dump.txt\n# Tìm: BLOCKED, WAITING, \"Found Java-level deadlock\"\n\n# Spring Boot + Micrometer metrics cho production monitoring\nmanagement.metrics.enable.jvm: true\n# JVM GC, heap, threads metrics → Prometheus → Grafana dashboard</div>\n      <div class=\"code-block\">// p6spy - log slow SQL queries\n# application.yml\nspring.datasource.driver-class-name: com.p6spy.engine.spy.P6SpyDriver\nspring.datasource.url: jdbc:p6spy:postgresql://localhost/mydb\n\n# spy.properties\nappend=true\nlogfile=slow-queries.log\nexecutionThreshold=100  # log query > 100ms</div>\n      <div class=\"tip-box\">💡 Quy trình: Monitor → Alert → Identify (APM/Profiler) → Diagnose (traces/logs) → Fix → Verify. Đừng optimize premature — đo trước, optimize sau.</div>",
    "tags": "java performance jvm",
    "level": "senior",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 205,
    "numStr": "205",
    "question": "Back-pressure và Flow Control là gì? Xử lý trong Spring Boot thế nào?",
    "answerHtml": "<p><strong>Back-pressure</strong>: Cơ chế consumer thông báo cho producer <em>\"chậm thôi, tôi xử lý không kịp\"</em> — thay vì bị overwhelm và crash.</p>\n      <div class=\"code-block\">Không có back-pressure:\n  Producer → 100K msg/s → Consumer (10K/s) → Queue overflow → OOM/crash\n\nCó back-pressure:\n  Producer → 10K msg/s ← signal \"slow down\" ← Consumer (10K/s) → stable ✅</div>\n      <table class=\"compare-table\">\n        <tr><th>Cách implement</th><th>Cơ chế</th><th>Dùng khi</th></tr>\n        <tr><td>Bounded Queue</td><td>Queue đầy → producer block hoặc reject</td><td>Thread pool, Kafka consumer lag</td></tr>\n        <tr><td>Rate Limiting</td><td>Giới hạn request/s tại API Gateway</td><td>Public API, protection</td></tr>\n        <tr><td>Reactive Streams</td><td>Publisher/Subscriber với demand signal</td><td>WebFlux, streaming data</td></tr>\n        <tr><td>Circuit Breaker</td><td>Fail fast khi downstream quá tải</td><td>Microservice calls</td></tr>\n      </table>\n      <div class=\"code-block\">// Spring WebFlux - Reactive back-pressure\n@GetMapping(value = \"/stream\", produces = MediaType.TEXT_EVENT_STREAM_VALUE)\npublic Flux&lt;Product&gt; streamProducts() {\n    return productRepository.findAll()\n        .delayElements(Duration.ofMillis(100))  // tự động back-pressure\n        .onBackpressureBuffer(1000)             // buffer 1000 items\n        .onBackpressureDrop(dropped -&gt;          // drop nếu buffer đầy\n            log.warn(\"Dropped: {}\", dropped));\n}\n\n// Kafka - bounded consumer để tránh overwhelm downstream\n@KafkaListener(topics = \"orders\")\npublic void consume(ConsumerRecord&lt;?,?&gt; record) {\n    // Nếu downstream DB chậm → consumer tự động slow down\n    // Kafka lag tăng → OK, đây là natural back-pressure\n    processSlowly(record);\n    // commit offset sau khi xử lý xong = back-pressure tự nhiên\n}</div>\n      <div class=\"tip-box\">💡 Kafka consumer lag là back-pressure tự nhiên: nếu consumer không kịp, lag tăng, producer không bị ảnh hưởng. Monitor lag bằng Kafka Consumer Group Lag metrics → alert nếu lag > threshold.</div>",
    "tags": "performance systemdesign spring",
    "level": "senior",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 206,
    "numStr": "206",
    "question": "Design Audit Logging System — ghi lại mọi hành động user ở scale lớn?",
    "answerHtml": "<p><strong>Requirements:</strong> Ghi lại mọi thao tác (ai làm gì, khi nào, với data nào), không được mất, query được, không ảnh hưởng performance app chính.</p>\n      <div class=\"code-block\">Architecture (Async, non-blocking):\n\nAPI Request → Controller → Service (business logic)\n                               ↓ async publish\n                           Kafka Topic: audit-events\n                               ↓\n                       Audit Consumer Service\n                           ↓         ↓\n                    Elasticsearch   PostgreSQL (archive)\n                    (search/query)  (compliance, immutable)</div>\n      <div class=\"code-block\">// Audit Event schema\nrecord AuditEvent(\n    String eventId,        // UUID\n    String userId,         // ai làm\n    String action,         // CREATE/UPDATE/DELETE/VIEW\n    String resourceType,   // Order/User/Product\n    String resourceId,     // ID của resource\n    Map&lt;String,Object&gt; before,  // state trước\n    Map&lt;String,Object&gt; after,   // state sau\n    String ipAddress,\n    Instant timestamp,\n    String requestId       // correlation với request log\n) {}\n\n// Spring AOP - tự động capture audit events\n@Aspect @Component\npublic class AuditAspect {\n    @Around(\"@annotation(Auditable)\")\n    public Object audit(ProceedingJoinPoint pjp) throws Throwable {\n        Object before = captureState(pjp.getArgs());\n        Object result = pjp.proceed();\n        Object after = captureState(result);\n        // Async publish - không block main thread\n        eventPublisher.publishAsync(AuditEvent.of(\n            getCurrentUser(), pjp.getSignature().getName(),\n            before, after, requestContext.getTraceId()));\n        return result;\n    }\n}\n\n@Service public class OrderService {\n    @Auditable  // trigger auto-audit\n    public Order cancelOrder(Long orderId, String reason) { ... }\n}</div>\n      <div class=\"tip-box\">💡 Immutability là yêu cầu compliance: audit log không được sửa/xóa. Dùng append-only Kafka topic + WORM (Write Once Read Many) storage. Elasticsearch ILM policy: hot (7d) → warm (30d) → cold (1yr) → delete.</div>",
    "tags": "systemdesign performance",
    "level": "expert",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 207,
    "numStr": "207",
    "question": "Design Search Autocomplete System — gợi ý tìm kiếm real-time cho 10M users?",
    "answerHtml": "<p><strong>Requirements:</strong> Gợi ý từ khoá khi user gõ, latency &lt;100ms, 10M users, top-K results theo popularity.</p>\n      <div class=\"code-block\">Data Structure — Trie + Ranking:\n\nTrie lưu tất cả search terms:\n  \"j\" → \"just\", \"java\", \"javascript\", ...\n  \"ja\" → \"java\", \"javascript\", \"james\", ...\n  \"jav\" → \"java\", \"javascript\"\n\nMỗi node lưu: count (số lần search) → rank top-K\n\nVấn đề với pure Trie:\n  - Trie 10M terms → tốn RAM nhiều\n  - Không fit in memory của 1 server → distribute</div>\n      <div class=\"code-block\">Architecture:\n\n1. OFFLINE: Tính top-K suggestions mỗi prefix\n   Batch job (hourly): aggregate search logs → top-20 per prefix\n   Lưu vào Redis: SET \"suggest:jav\" [\"java\",\"javascript\",\"javalin\"]\n\n2. ONLINE: Real-time lookup\n   User gõ \"jav\" → GET suggest:jav → [\"java\", \"javascript\", ...]\n   Latency: ~1ms (Redis lookup)\n\n3. PERSONALIZATION (optional):\n   Merge global top-K với user search history\n   Boost terms user đã search trước đây\n\n4. SCALE:\n   Input: \"j\" → 100K distinct prefixes với 1 letter\n   Redis memory: 1M prefixes × 20 suggestions × ~50 bytes = ~1GB\n   → Fit in Redis easily!\n\n   Read: 10M users × 5 keystrokes/search × 10 searches/day\n       = 500M lookups/day = ~5800 req/s → Redis handles easily</div>\n      <div class=\"code-block\">// Spring Boot Redis autocomplete\n@GetMapping(\"/suggest\")\npublic List&lt;String&gt; suggest(@RequestParam String prefix) {\n    String key = \"suggest:\" + prefix.toLowerCase();\n    List&lt;String&gt; suggestions = redisTemplate.opsForList()\n        .range(key, 0, 9);  // top 10\n    if (suggestions == null || suggestions.isEmpty()) {\n        // fallback to Elasticsearch prefix query\n        suggestions = esService.prefixSearch(prefix, 10);\n    }\n    return suggestions;\n}</div>\n      <div class=\"tip-box\">💡 Debounce quan trọng phía client: chỉ gửi request khi user dừng gõ 200-300ms, không gửi mỗi keystroke. Giảm request ~70%. Cache phía client browser thêm 30s cũng hiệu quả.</div>",
    "tags": "systemdesign performance redis",
    "level": "expert",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 208,
    "numStr": "208",
    "question": "Design Flash Sale System — xử lý 1 triệu users cùng mua 1 sản phẩm lúc 12:00?",
    "answerHtml": "<p><strong>Core challenges:</strong> Traffic spike đột ngột, inventory không oversell, user experience tốt, prevention của bot/abuse.</p>\n      <div class=\"code-block\">Timeline of chaos (12:00:00):\n  12:00:00 → 1M users hit \"Buy Now\" cùng lúc\n  12:00:01 → DB bị query 1M lần UPDATE inventory\n  12:00:02 → DB lock contention → timeout cascade\n  12:00:03 → App servers OOM → 💀\n\n→ Cần pre-computation và caching ở mọi layer</div>\n      <div class=\"code-block\">Solution Architecture:\n\n1. PRE-SALE SETUP (11:59:50)\n   Redis: SET flash:product:123:stock 1000  # pre-load stock\n   Redis: SET flash:product:123:active true\n\n2. TRAFFIC FILTERING (tại API Gateway / CDN)\n   Rate limit: 10 req/s per IP\n   Bot detection: CAPTCHA, JS challenge\n   Virtual queue: nếu > capacity → show \"waiting room\" page\n\n3. INVENTORY RESERVATION (Redis atomic)\n   DECRBY flash:product:123:stock 1\n   if result &lt; 0:\n       INCRBY flash:product:123:stock 1  # rollback\n       return \"Sold Out\"\n   else:\n       create_reservation(userId, productId, token, 10min_expiry)\n       async_publish(\"flash-purchase-reserved\", {...})\n\n4. ORDER CONFIRMATION (async queue)\n   User có 10 phút để complete payment\n   Kafka consumer → create actual order → charge payment\n   On timeout/fail → release reservation (INCRBY stock 1)\n\n5. DB WRITE (batch, async)\n   Không write DB đồng bộ lúc 12:00!\n   Batch tất cả reservations → write DB mỗi 1 giây\n   DB chỉ xử lý ~1K writes/giây thay vì 1M</div>\n      <div class=\"code-block\">// Redis Lua script - atomic check-and-decrement\nString luaScript = \"\"\"\n    local stock = tonumber(redis.call('GET', KEYS[1]))\n    if stock &gt; 0 then\n        redis.call('DECR', KEYS[1])\n        return 1  -- success\n    else\n        return 0  -- sold out\n    end\n\"\"\";\nLong result = redisTemplate.execute(\n    RedisScript.of(luaScript, Long.class),\n    List.of(\"flash:product:123:stock\"));</div>\n      <div class=\"tip-box\">💡 Virtual Queue (Waiting Room) là giải pháp cực kỳ hiệu quả: CloudFlare Waiting Room, AWS WAF, hoặc self-built. User vào queue → được phát token theo thứ tự → vào mua khi đến lượt. Giảm spike 1M → sustained 10K/min.</div>",
    "tags": "systemdesign performance redis kafka",
    "level": "expert",
    "section": "System Design",
    "sectionIcon": "🔥",
    "sectionColor": "#fb923c",
    "sectionColorClass": "",
    "subsection": "Design Interviews"
  },
  {
    "num": 209,
    "numStr": "209",
    "question": "OutOfMemoryError — các loại, nguyên nhân và cách xử lý trong production?",
    "answerHtml": "<p><code>OutOfMemoryError</code> (OOM) xảy ra khi JVM không thể cấp phát bộ nhớ. Có <strong>nhiều loại OOM khác nhau</strong>, mỗi loại chỉ ra vùng nhớ bị cạn kiệt.</p>\n      <table class=\"compare-table\">\n        <tr><th>Loại OOM</th><th>Message</th><th>Nguyên nhân phổ biến</th></tr>\n        <tr><td>Heap OOM</td><td>Java heap space</td><td>Memory leak, object quá lớn, heap quá nhỏ</td></tr>\n        <tr><td>Metaspace OOM</td><td>Metaspace</td><td>Load quá nhiều class (dynamic proxy, reflection), ClassLoader leak</td></tr>\n        <tr><td>GC Overhead</td><td>GC overhead limit exceeded</td><td>98% thời gian chạy GC nhưng chỉ free &lt;2% heap</td></tr>\n        <tr><td>Direct Buffer</td><td>Direct buffer memory</td><td>Dùng NIO trực tiếp, Netty, không release ByteBuffer</td></tr>\n        <tr><td>Unable to create native thread</td><td>unable to create new native thread</td><td>Quá nhiều thread, OS limit ulimit</td></tr>\n      </table>\n      <div class=\"code-block\"><span class=\"cm\"># Bước 1: Cấu hình JVM để tự dump khi OOM (LUÔN BẬT trong production)</span>\njava -Xmx2g \\\n     -XX:+HeapDumpOnOutOfMemoryError \\\n     -XX:HeapDumpPath=/var/log/app/heapdump.hprof \\\n     -XX:+PrintGCDetails \\\n     -Xlog:gc*:file=/var/log/app/gc.log \\\n     -jar app.jar\n\n<span class=\"cm\"># Bước 2: Khi OOM xảy ra → xem GC log để hiểu pattern</span>\n<span class=\"cm\"># Heap tăng liên tục dù GC chạy → Memory leak</span>\n<span class=\"cm\"># Heap tăng nhanh → Object allocation quá lớn</span>\n\n<span class=\"cm\"># Bước 3: Phân tích heap dump với Eclipse MAT</span>\n<span class=\"cm\"># Open heapdump.hprof → Leak Suspects → tìm object chiếm nhiều nhất</span></div>\n      <div class=\"code-block\"><span class=\"cm\">// Các lỗi memory leak phổ biến trong Spring Boot:</span>\n\n<span class=\"cm\">// 1. Cache không có eviction → tăng mãi</span>\n<span class=\"kw\">private</span> Map&lt;String, Object&gt; cache = <span class=\"kw\">new</span> HashMap&lt;&gt;();  <span class=\"cm\">// ❌ unbounded</span>\n<span class=\"cm\">// Fix: dùng Caffeine/Guava Cache với maximumSize + expireAfterWrite</span>\n\n<span class=\"cm\">// 2. Static field giữ reference → GC không thu hồi được</span>\n<span class=\"kw\">static</span> List&lt;User&gt; activeUsers = <span class=\"kw\">new</span> ArrayList&lt;&gt;();  <span class=\"cm\">// ❌ grows forever</span>\n\n<span class=\"cm\">// 3. Listener/Observer không được deregister</span>\neventBus.register(listener);   <span class=\"cm\">// ❌ register</span>\n<span class=\"cm\">// Fix: eventBus.unregister(listener) trong @PreDestroy</span>\n\n<span class=\"cm\">// 4. ThreadLocal không clear sau khi dùng</span>\nThreadLocal&lt;Context&gt; ctx = ThreadLocal.withInitial(Context::new);\n<span class=\"cm\">// Fix: ctx.remove() trong finally block</span>\n\n<span class=\"cm\">// 5. Hibernate/JPA load quá nhiều entity vào memory</span>\nList&lt;Order&gt; all = orderRepo.findAll();  <span class=\"cm\">// ❌ 10M rows → OOM</span>\n<span class=\"cm\">// Fix: Pageable, Stream, hoặc batch processing</span>\norderRepo.findAll(PageRequest.of(0, 100));</div>\n      <div class=\"code-block\"><span class=\"cm\"># Monitoring để phát hiện sớm trước khi OOM</span>\n<span class=\"cm\"># Prometheus alert: heap usage > 85%</span>\nalert: HighHeapUsage\nexpr: jvm_memory_used_bytes{area=\"heap\"} / jvm_memory_max_bytes{area=\"heap\"} > 0.85\nfor: 5m\nannotations:\n  summary: \"Heap usage > 85%, OOM risk!\"\n\n<span class=\"cm\"># Spring Boot Actuator endpoint</span>\nGET /actuator/metrics/jvm.memory.used?tag=area:heap</div>\n      <div class=\"warn-box\">⚠️ <code>GC overhead limit exceeded</code> thường xuất hiện trước OOM thực sự — đây là dấu hiệu sớm nhất. Nếu thấy log này, hành động ngay: tăng heap, tìm memory leak, hoặc restart pod tạm thời để tránh system down.</div>",
    "tags": "java jvm performance",
    "level": "senior",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Memory & JVM"
  },
  {
    "num": 210,
    "numStr": "210",
    "question": "StackOverflowError — nguyên nhân, cách debug và phòng tránh?",
    "answerHtml": "<p><code>StackOverflowError</code> xảy ra khi call stack vượt quá giới hạn cho phép (mặc định ~512KB–1MB mỗi thread). Thường do <strong>đệ quy vô hạn</strong> hoặc call chain quá sâu.</p>\n      <div class=\"code-block\"><span class=\"cm\">// Nguyên nhân 1: Đệ quy không có base case</span>\n<span class=\"kw\">int</span> <span class=\"fn\">factorial</span>(<span class=\"kw\">int</span> n) {\n    <span class=\"kw\">return</span> n * factorial(n - <span class=\"num\">1</span>);  <span class=\"cm\">// ❌ Không có điều kiện dừng!</span>\n}\n\n<span class=\"cm\">// Fix: thêm base case</span>\n<span class=\"kw\">int</span> <span class=\"fn\">factorial</span>(<span class=\"kw\">int</span> n) {\n    <span class=\"kw\">if</span> (n &lt;= <span class=\"num\">1</span>) <span class=\"kw\">return</span> <span class=\"num\">1</span>;  <span class=\"cm\">// ✅ base case</span>\n    <span class=\"kw\">return</span> n * factorial(n - <span class=\"num\">1</span>);\n}\n\n<span class=\"cm\">// Nguyên nhân 2: Hai method gọi nhau vòng lặp</span>\n<span class=\"kw\">void</span> <span class=\"fn\">methodA</span>() { methodB(); }   <span class=\"cm\">// ❌ A → B → A → B → ... StackOverflow!</span>\n<span class=\"kw\">void</span> <span class=\"fn\">methodB</span>() { methodA(); }\n\n<span class=\"cm\">// Nguyên nhân 3: Spring/JPA proxy circular call</span>\n<span class=\"cm\">// @Transactional self-invocation → proxy gọi chính nó vô hạn</span>\n\n<span class=\"cm\">// Nguyên nhân 4: Jackson infinite serialization loop</span>\n<span class=\"cm\">// @Entity A có @OneToMany B, @Entity B có @ManyToOne A</span>\n<span class=\"cm\">// Jackson serialize A → serialize B.a → serialize B.a.b → ...</span></div>\n      <div class=\"code-block\"><span class=\"cm\">// Debug: đọc stack trace để tìm pattern lặp lại</span>\njava.lang.StackOverflowError\n    at com.example.OrderService.processOrder(OrderService.java:42)\n    at com.example.OrderService.validateOrder(OrderService.java:78)\n    at com.example.OrderService.processOrder(OrderService.java:42)  ← lặp lại!\n    at com.example.OrderService.validateOrder(OrderService.java:78)\n    ...\n<span class=\"cm\">// → Ngay lập tức thấy processOrder ↔ validateOrder gọi nhau vòng lặp</span></div>\n      <div class=\"code-block\"><span class=\"cm\">// Fix 1: Với đệ quy sâu hợp lệ → dùng iteration (stack thay recursion)</span>\n<span class=\"cm\">// Ví dụ: duyệt cây số tầng rất sâu</span>\n<span class=\"kw\">void</span> <span class=\"fn\">traverseIterative</span>(Node root) {\n    Deque&lt;Node&gt; stack = <span class=\"kw\">new</span> ArrayDeque&lt;&gt;();\n    stack.push(root);\n    <span class=\"kw\">while</span> (!stack.isEmpty()) {\n        Node node = stack.pop();\n        process(node);\n        node.children.forEach(stack::push);\n    }\n}\n\n<span class=\"cm\">// Fix 2: Jackson circular reference</span>\n<span class=\"an\">@JsonManagedReference</span>  <span class=\"cm\">// phía \"cha\"</span>\n<span class=\"kw\">private</span> List&lt;OrderItem&gt; items;\n\n<span class=\"an\">@JsonBackReference</span>    <span class=\"cm\">// phía \"con\" → bị bỏ qua khi serialize</span>\n<span class=\"kw\">private</span> Order order;\n\n<span class=\"cm\">// Hoặc dùng DTO để tránh serialize entity trực tiếp (best practice)</span>\n\n<span class=\"cm\">// Fix 3: Tăng stack size (workaround, không phải fix gốc)</span>\njava -Xss2m -jar app.jar  <span class=\"cm\">// tăng stack mỗi thread lên 2MB</span>\n\n<span class=\"cm\">// Fix 4: Tail recursion (Java không optimize TCO, nhưng dùng trampoline)</span>\n<span class=\"cm\">// Sử dụng Stream/loop thay thế recursion sâu</span></div>\n      <table class=\"compare-table\">\n        <tr><th>Tình huống</th><th>Giải pháp</th></tr>\n        <tr><td>Đệ quy thiếu base case</td><td>Thêm điều kiện dừng rõ ràng</td></tr>\n        <tr><td>Đệ quy sâu hợp lệ (1000+ levels)</td><td>Chuyển sang iterative với explicit Stack</td></tr>\n        <tr><td>Circular method call</td><td>Tái cấu trúc, tách responsibility</td></tr>\n        <tr><td>Jackson circular reference</td><td>@JsonManagedReference/@JsonBackReference hoặc dùng DTO</td></tr>\n        <tr><td>Hibernate lazy load loop</td><td>Dùng @JsonIgnore hoặc DTO mapping</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 Khác biệt quan trọng: <strong>StackOverflowError</strong> là <em>Error</em> (không phải Exception) — không nên catch và bỏ qua. Nó chỉ ra bug trong code. Khác với OutOfMemoryError (heap), StackOverflow chỉ liên quan đến call stack depth.</div>",
    "tags": "java jvm performance",
    "level": "middle",
    "section": "Java Core",
    "sectionIcon": "☕",
    "sectionColor": "#f97316",
    "sectionColorClass": "java-color",
    "subsection": "Memory & JVM"
  },
  {
    "num": 211,
    "numStr": "211",
    "question": "AWS IAM là gì? User, Group, Role, Policy khác nhau thế nào?",
    "answerHtml": "<p><strong>IAM (Identity and Access Management)</strong> là dịch vụ quản lý định danh và phân quyền trong AWS. IAM trả lời 2 câu hỏi: <em>ai</em> được truy cập và <em>được làm gì</em> trên resource nào.</p>\n      <table class=\"compare-table\">\n        <tr><th>Thành phần</th><th>Là gì</th><th>Dùng khi nào</th></tr>\n        <tr><td>User</td><td>Định danh dài hạn cho người/app</td><td>Human user hoặc legacy app cần access key</td></tr>\n        <tr><td>Group</td><td>Tập hợp nhiều user</td><td>Gán quyền chung cho Dev, QA, Ops</td></tr>\n        <tr><td>Role</td><td>Định danh tạm thời để assume</td><td>EC2/Lambda/ECS gọi AWS API, cross-account access</td></tr>\n        <tr><td>Policy</td><td>JSON định nghĩa Allow/Deny action/resource</td><td>Gắn vào user/group/role/resource</td></tr>\n      </table>\n      <div class=\"code-block\">IAM Policy structure:\n{\n  \"Effect\": \"Allow\",\n  \"Action\": [\"s3:GetObject\"],\n  \"Resource\": \"arn:aws:s3:::my-bucket/*\",\n  \"Condition\": {\n    \"StringEquals\": { \"aws:PrincipalTag/team\": \"backend\" }\n  }\n}\n\nEvaluation logic:\n  Explicit Deny > Explicit Allow > Default Deny</div>\n      <div class=\"warn-box\">⚠️ Best practice: Không dùng root account hằng ngày, bật MFA, không hard-code access key, ưu tiên IAM Role thay vì long-lived credentials, áp dụng least privilege.</div>",
    "tags": "cloud aws iam security",
    "level": "junior",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS IAM"
  },
  {
    "num": 212,
    "numStr": "212",
    "question": "AWS EC2 là gì? Instance, AMI, EBS, Security Group khác nhau thế nào?",
    "answerHtml": "<p><strong>EC2 (Elastic Compute Cloud)</strong> là dịch vụ máy chủ ảo. Bạn chọn cấu hình CPU/RAM/network, image hệ điều hành, storage và network policy để chạy application.</p>\n      <table class=\"compare-table\">\n        <tr><th>Khái niệm</th><th>Ý nghĩa</th><th>Lưu ý phỏng vấn</th></tr>\n        <tr><td>Instance</td><td>Máy ảo đang chạy</td><td>Instance type quyết định CPU/RAM/network</td></tr>\n        <tr><td>AMI</td><td>Template image để tạo instance</td><td>Chứa OS, package, config ban đầu</td></tr>\n        <tr><td>EBS</td><td>Block storage gắn vào instance</td><td>Persist sau stop/start, snapshot được</td></tr>\n        <tr><td>Security Group</td><td>Stateful firewall ở instance level</td><td>Chỉ allow rule, deny mặc định</td></tr>\n        <tr><td>Key Pair</td><td>SSH key để login Linux</td><td>Mất private key thì không SSH trực tiếp được</td></tr>\n      </table>\n      <div class=\"code-block\">EC2 production pattern:\n  User → ALB → Auto Scaling Group → EC2 instances\n                         ↓\n                    Launch Template\n                    AMI + User Data + SG + IAM Role\n\nScale out: CPU > 70% → thêm instance\nRolling deploy: thay AMI/launch template → instance refresh</div>\n      <div class=\"tip-box\">💡 Security Group là stateful: nếu inbound request được allow, response outbound tự được cho phép. Network ACL là stateless và ở subnet level.</div>",
    "tags": "cloud aws ec2 devops",
    "level": "junior",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS EC2"
  },
  {
    "num": 213,
    "numStr": "213",
    "question": "AWS S3 là gì? Bucket, Object, Storage Class, Versioning dùng thế nào?",
    "answerHtml": "<p><strong>S3 (Simple Storage Service)</strong> là object storage dùng để lưu file, backup, static website, data lake. S3 không phải file system và không phải block storage.</p>\n      <table class=\"compare-table\">\n        <tr><th>Khái niệm</th><th>Mô tả</th><th>Ví dụ</th></tr>\n        <tr><td>Bucket</td><td>Container cấp cao nhất, tên global unique</td><td>company-prod-assets</td></tr>\n        <tr><td>Object</td><td>File + metadata + key</td><td>users/123/avatar.png</td></tr>\n        <tr><td>Storage Class</td><td>Mức lưu trữ theo cost/access pattern</td><td>Standard, IA, Glacier</td></tr>\n        <tr><td>Versioning</td><td>Lưu nhiều version của object</td><td>Recover khi overwrite/delete nhầm</td></tr>\n        <tr><td>Lifecycle Policy</td><td>Tự chuyển/xóa object theo thời gian</td><td>Log sau 30 ngày → Glacier</td></tr>\n      </table>\n      <div class=\"code-block\">Common upload flow:\n  Client → API: xin presigned URL\n  API → validate auth/quota → tạo presigned PUT URL\n  Client → upload trực tiếp lên S3\n  S3 Event → Lambda/SQS → resize image, scan virus, update metadata\n\nBenefits:\n  App server không phải stream file lớn\n  Giảm bandwidth và memory pressure\n  URL hết hạn giúp kiểm soát quyền upload/download</div>\n      <div class=\"warn-box\">⚠️ Không public bucket nếu không cần. Dùng Block Public Access, bucket policy chặt chẽ, SSE-S3/SSE-KMS encryption và presigned URL hoặc CloudFront signed URL cho private content.</div>",
    "tags": "cloud aws s3 storage systemdesign",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS S3"
  },
  {
    "num": 214,
    "numStr": "214",
    "question": "AWS RDS là gì? Multi-AZ, Read Replica, Backup khác nhau thế nào?",
    "answerHtml": "<p><strong>RDS (Relational Database Service)</strong> là managed relational database cho MySQL, PostgreSQL, MariaDB, Oracle, SQL Server và Aurora. AWS lo provisioning, patching, backup, failover; bạn vẫn phải thiết kế schema/query/index tốt.</p>\n      <table class=\"compare-table\">\n        <tr><th>Tính năng</th><th>Mục đích</th><th>Lưu ý</th></tr>\n        <tr><td>Multi-AZ</td><td>High availability</td><td>Standby khác AZ, failover tự động, không dùng để scale read chính</td></tr>\n        <tr><td>Read Replica</td><td>Scale read traffic</td><td>Async replication, có replication lag</td></tr>\n        <tr><td>Automated Backup</td><td>Point-in-time recovery</td><td>Restore ra instance mới</td></tr>\n        <tr><td>Snapshot</td><td>Backup thủ công</td><td>Dùng cho migration/backup trước release lớn</td></tr>\n        <tr><td>Parameter Group</td><td>DB engine config</td><td>Một số thay đổi cần reboot</td></tr>\n      </table>\n      <div class=\"code-block\">Typical Spring Boot setup:\n  Write API → RDS Primary\n  Read API  → RDS Read Replica\n\nPitfall:\n  User tạo order → redirect detail page → đọc replica\n  Replica lag 200ms → không thấy order\n\nFix:\n  Read-your-writes: request ngay sau write đọc primary\n  Hoặc delay/retry, hoặc session flag forcePrimary=true</div>\n      <div class=\"tip-box\">💡 Multi-AZ là HA, Read Replica là read scaling. Hai khái niệm này hay bị nhầm trong phỏng vấn.</div>",
    "tags": "cloud aws rds database",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS RDS"
  },
  {
    "num": 215,
    "numStr": "215",
    "question": "AWS SQS là gì? Standard Queue vs FIFO Queue khác nhau thế nào?",
    "answerHtml": "<p><strong>SQS (Simple Queue Service)</strong> là managed message queue giúp decouple producer và consumer. Producer gửi message vào queue, consumer poll và xử lý bất đồng bộ.</p>\n      <table class=\"compare-table\">\n        <tr><th></th><th>Standard Queue</th><th>FIFO Queue</th></tr>\n        <tr><td>Throughput</td><td>Gần như không giới hạn</td><td>Thấp hơn, có quota theo message group</td></tr>\n        <tr><td>Ordering</td><td>Best effort, không đảm bảo tuyệt đối</td><td>Đảm bảo thứ tự trong cùng MessageGroupId</td></tr>\n        <tr><td>Delivery</td><td>At-least-once, có thể duplicate</td><td>Exactly-once processing theo dedup window</td></tr>\n        <tr><td>Dùng khi</td><td>Background jobs, async processing</td><td>Order/payment cần thứ tự</td></tr>\n      </table>\n      <div class=\"code-block\">Important concepts:\n  Visibility Timeout:\n    Consumer nhận message → message bị ẩn tạm thời\n    Xử lý xong → DeleteMessage\n    Không delete kịp → message hiện lại để retry\n\n  Dead Letter Queue (DLQ):\n    Message fail quá maxReceiveCount → chuyển DLQ\n    Dùng để debug poison message\n\n  Long Polling:\n    WaitTimeSeconds up to 20s → giảm empty response và cost</div>\n      <div class=\"warn-box\">⚠️ Consumer phải idempotent vì SQS Standard là at-least-once. Luôn thiết kế xử lý duplicate bằng idempotency key hoặc unique constraint.</div>",
    "tags": "cloud aws sqs queue messaging microservice",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS SQS"
  },
  {
    "num": 216,
    "numStr": "216",
    "question": "AWS CloudWatch dùng để làm gì? Logs, Metrics, Alarms khác nhau thế nào?",
    "answerHtml": "<p><strong>CloudWatch</strong> là dịch vụ observability của AWS: thu thập log, metric, alarm và event để monitor hệ thống.</p>\n      <table class=\"compare-table\">\n        <tr><th>Thành phần</th><th>Vai trò</th><th>Ví dụ</th></tr>\n        <tr><td>CloudWatch Logs</td><td>Lưu và search log</td><td>Application log từ ECS/Lambda/EC2</td></tr>\n        <tr><td>Metrics</td><td>Time-series số liệu</td><td>CPUUtilization, 5xx count, latency</td></tr>\n        <tr><td>Alarms</td><td>Cảnh báo theo threshold/anomaly</td><td>CPU > 80% trong 5 phút</td></tr>\n        <tr><td>Dashboard</td><td>Hiển thị chart tổng hợp</td><td>RPS, p95 latency, error rate</td></tr>\n        <tr><td>EventBridge</td><td>Route event theo rule</td><td>Schedule job, react to AWS events</td></tr>\n      </table>\n      <div class=\"code-block\">Production alarm examples:\n  ALB 5XX > 1% trong 5 phút → PagerDuty/SNS\n  ECS CPU > 75% → scale out service\n  RDS FreeStorageSpace < 10GB → cảnh báo sớm\n  Lambda Errors > 0 và IteratorAge tăng → consumer bị lag\n\nLog query mindset:\n  Filter theo requestId/correlationId\n  Count ERROR theo service/version\n  Tìm p95 latency endpoint trong 15 phút gần nhất</div>\n      <div class=\"tip-box\">💡 Monitor theo golden signals: latency, traffic, errors, saturation. Đừng chỉ monitor CPU/RAM; với API cần p95/p99 latency và error rate.</div>",
    "tags": "cloud aws cloudwatch monitoring observability devops",
    "level": "junior",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS CloudWatch"
  },
  {
    "num": 217,
    "numStr": "217",
    "question": "AWS ECS là gì? ECS Cluster, Task Definition, Service, Fargate hoạt động thế nào?",
    "answerHtml": "<p><strong>ECS (Elastic Container Service)</strong> là dịch vụ orchestration để chạy Docker containers trên AWS. ECS đơn giản hơn Kubernetes nếu workload chủ yếu nằm trong AWS ecosystem.</p>\n      <table class=\"compare-table\">\n        <tr><th>Khái niệm</th><th>Ý nghĩa</th><th>Ví dụ</th></tr>\n        <tr><td>Cluster</td><td>Nhóm capacity để chạy tasks</td><td>prod-cluster</td></tr>\n        <tr><td>Task Definition</td><td>Blueprint container</td><td>image, CPU, memory, env, port, log config</td></tr>\n        <tr><td>Task</td><td>Instance chạy từ task definition</td><td>1 task chứa 1 hoặc nhiều container</td></tr>\n        <tr><td>Service</td><td>Duy trì desired count và rolling deploy</td><td>Luôn chạy 6 tasks backend-api</td></tr>\n        <tr><td>Fargate</td><td>Serverless compute cho containers</td><td>Không quản lý EC2 worker nodes</td></tr>\n      </table>\n      <div class=\"code-block\">Common ECS architecture:\n  Route53 → ALB → ECS Service (Fargate)\n                    desiredCount=6\n                    tasks spread across 2-3 AZs\n                    CloudWatch Logs\n                    IAM Task Role\n                    Secrets Manager env injection\n\nDeploy:\n  Build Docker image → push ECR\n  Update task definition image tag\n  ECS rolling update replaces old tasks</div>\n      <div class=\"warn-box\">⚠️ Phân biệt Task Role và Execution Role: Execution Role để ECS pull image/logs/secrets; Task Role là quyền AWS API mà application bên trong container được dùng.</div>",
    "tags": "cloud aws ecs docker container devops",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS ECS"
  },
  {
    "num": 218,
    "numStr": "218",
    "question": "AWS Lambda là gì? Cold Start, Timeout, Concurrency cần hiểu thế nào?",
    "answerHtml": "<p><strong>Lambda</strong> là serverless compute: bạn upload function, AWS tự chạy theo event và scale theo số request. Phù hợp cho event-driven jobs, API nhẹ, file processing, scheduled tasks.</p>\n      <table class=\"compare-table\">\n        <tr><th>Khái niệm</th><th>Ý nghĩa</th><th>Lưu ý</th></tr>\n        <tr><td>Trigger</td><td>Nguồn gọi Lambda</td><td>API Gateway, S3 Event, SQS, EventBridge</td></tr>\n        <tr><td>Cold Start</td><td>Khởi tạo runtime/container mới</td><td>Ảnh hưởng latency request đầu</td></tr>\n        <tr><td>Timeout</td><td>Thời gian chạy tối đa</td><td>Không hợp task quá dài</td></tr>\n        <tr><td>Concurrency</td><td>Số executions song song</td><td>Cần limit để bảo vệ downstream</td></tr>\n        <tr><td>DLQ/Destination</td><td>Nơi nhận event fail</td><td>Quan trọng với async invoke</td></tr>\n      </table>\n      <div class=\"code-block\">Good Lambda use cases:\n  S3 upload → Lambda resize image/create thumbnail\n  EventBridge schedule → cleanup expired sessions\n  SQS → Lambda consume background jobs\n  API Gateway → Lambda for lightweight APIs\n\nBad fit:\n  Long-running batch > timeout\n  Heavy JVM app cần latency cực thấp\n  Stateful workload hoặc cần local persistent disk\n  High-throughput DB writes không có connection pooling strategy</div>\n      <div class=\"tip-box\">💡 Java Lambda có thể cold start cao hơn Node/Python/Go. Giảm cold start bằng package nhỏ, lazy init hợp lý, Provisioned Concurrency hoặc dùng SnapStart cho Java runtime được hỗ trợ.</div>",
    "tags": "cloud aws lambda serverless",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS Lambda"
  },
  {
    "num": 219,
    "numStr": "219",
    "question": "IAM Role khác IAM User ở điểm nào? Khi nào nên dùng Role thay vì access key?",
    "answerHtml": "<p><strong>IAM User</strong> thường đại diện cho identity dài hạn; <strong>IAM Role</strong> là quyền tạm thời được assume bởi user, service hoặc account khác.</p>\n      <table class=\"compare-table\">\n        <tr><th></th><th>IAM User</th><th>IAM Role</th></tr>\n        <tr><td>Credential</td><td>Long-lived password/access key</td><td>Temporary credentials qua STS</td></tr>\n        <tr><td>Gắn với</td><td>Một người/app cụ thể</td><td>EC2, Lambda, ECS task, cross-account</td></tr>\n        <tr><td>Rotation</td><td>Phải tự rotate key</td><td>AWS tự cấp credential ngắn hạn</td></tr>\n        <tr><td>Best practice</td><td>Hạn chế dùng access key</td><td>Ưu tiên cho workload trên AWS</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 Nếu app chạy trên EC2/ECS/Lambda và cần gọi S3/RDS/SQS, hãy dùng IAM Role. Không hard-code <code>AWS_ACCESS_KEY_ID</code>/<code>AWS_SECRET_ACCESS_KEY</code> trong source code hoặc image.</div>",
    "tags": "cloud aws iam security",
    "level": "junior",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS IAM"
  },
  {
    "num": 220,
    "numStr": "220",
    "question": "Principle of Least Privilege trong IAM là gì? Thiết kế policy an toàn thế nào?",
    "answerHtml": "<p><strong>Least Privilege</strong> nghĩa là cấp đúng quyền tối thiểu cần thiết, đúng resource, đúng điều kiện, đúng thời gian.</p>\n      <ul>\n        <li>Tránh policy quá rộng như <code>Action: *</code> hoặc <code>Resource: *</code>.</li>\n        <li>Tách quyền theo môi trường: dev/staging/prod dùng role và account khác nhau.</li>\n        <li>Dùng condition như source VPC, MFA, principal tag, resource tag.</li>\n        <li>Dùng IAM Access Analyzer/CloudTrail để rà soát quyền không dùng.</li>\n      </ul>\n      <div class=\"code-block\">Bad:\n  s3:* trên *\n\nBetter:\n  s3:GetObject trên arn:aws:s3:::company-prod-assets/public/*\n  Condition: chỉ cho role backend-prod đọc prefix cần thiết</div>\n      <div class=\"warn-box\">⚠️ Explicit Deny luôn thắng Allow. Dùng Deny ở SCP hoặc permission boundary để chặn hành vi nguy hiểm ở cấp organization/account.</div>",
    "tags": "cloud aws iam security",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS IAM"
  },
  {
    "num": 221,
    "numStr": "221",
    "question": "EC2 Auto Scaling Group hoạt động thế nào? Scale theo metric nào?",
    "answerHtml": "<p><strong>Auto Scaling Group (ASG)</strong> duy trì số lượng EC2 instances theo desired/min/max capacity và tự scale theo policy.</p>\n      <div class=\"code-block\">ASG components:\n  Launch Template: AMI, instance type, SG, IAM role, user data\n  Desired capacity: số instance mong muốn\n  Health check: EC2 hoặc ALB health check\n  Scaling policy: target tracking / step scaling / scheduled scaling</div>\n      <table class=\"compare-table\">\n        <tr><th>Metric</th><th>Dùng khi</th><th>Lưu ý</th></tr>\n        <tr><td>CPUUtilization</td><td>App CPU-bound</td><td>Dễ dùng nhưng không đủ cho mọi app</td></tr>\n        <tr><td>RequestCountPerTarget</td><td>Web/API sau ALB</td><td>Phản ánh load tốt hơn CPU</td></tr>\n        <tr><td>SQS Queue Depth</td><td>Worker xử lý queue</td><td>Scale theo backlog per instance</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 ASG thường đi cùng ALB và stateless app. Nếu app lưu session local, scale out sẽ gây lỗi trải nghiệm; dùng Redis/session store hoặc JWT.</div>",
    "tags": "cloud aws ec2 autoscaling devops",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS EC2"
  },
  {
    "num": 222,
    "numStr": "222",
    "question": "EC2 Security Group vs NACL khác nhau thế nào?",
    "answerHtml": "<table class=\"compare-table\">\n        <tr><th></th><th>Security Group</th><th>Network ACL</th></tr>\n        <tr><td>Scope</td><td>ENI/instance level</td><td>Subnet level</td></tr>\n        <tr><td>State</td><td>Stateful</td><td>Stateless</td></tr>\n        <tr><td>Rule</td><td>Chỉ Allow</td><td>Allow và Deny</td></tr>\n        <tr><td>Evaluate</td><td>Tất cả rule cùng lúc</td><td>Theo rule number từ thấp đến cao</td></tr>\n        <tr><td>Dùng khi</td><td>Firewall chính cho workload</td><td>Guardrail ở subnet, chặn IP range</td></tr>\n      </table>\n      <div class=\"code-block\">Ví dụ:\n  ALB SG: allow inbound 443 từ Internet\n  App SG: allow inbound 8080 chỉ từ ALB SG\n  DB SG: allow inbound 5432 chỉ từ App SG\n\n→ Không mở DB ra Internet.</div>\n      <div class=\"tip-box\">💡 Trong phỏng vấn, câu trả lời quan trọng nhất: Security Group stateful, NACL stateless.</div>",
    "tags": "cloud aws ec2 networking security",
    "level": "junior",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS EC2"
  },
  {
    "num": 223,
    "numStr": "223",
    "question": "S3 consistency model hiện nay như thế nào? Có cần lo eventual consistency không?",
    "answerHtml": "<p>S3 hiện cung cấp <strong>strong read-after-write consistency</strong> cho PUT, GET, LIST và DELETE object trong mọi region.</p>\n      <ul>\n        <li>PUT object xong → GET ngay sẽ thấy object mới.</li>\n        <li>Overwrite object xong → GET/LIST thấy version mới.</li>\n        <li>DELETE object xong → LIST/GET phản ánh trạng thái mới.</li>\n      </ul>\n      <div class=\"warn-box\">⚠️ Strong consistency không thay thế thiết kế distributed system tốt. Nếu app cache qua CloudFront/CDN/browser, bạn vẫn có thể thấy dữ liệu cũ do cache TTL/invalidation.</div>\n      <div class=\"tip-box\">💡 Câu hỏi cũ hay nói S3 eventual consistency, nhưng đó là kiến thức trước đây. Khi trả lời phỏng vấn nên nói rõ hiện tại S3 strong consistency.</div>",
    "tags": "cloud aws s3 storage",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS S3"
  },
  {
    "num": 224,
    "numStr": "224",
    "question": "S3 Presigned URL là gì? Dùng để upload/download private file thế nào?",
    "answerHtml": "<p><strong>Presigned URL</strong> là URL tạm thời được ký bằng credential của IAM principal, cho phép client upload/download object mà không cần AWS credentials.</p>\n      <div class=\"code-block\">Upload flow:\n  1. Client gọi API /files/presign\n  2. Backend check auth, quota, content-type, file size\n  3. Backend tạo presigned PUT URL expire 5-15 phút\n  4. Client PUT trực tiếp lên S3\n  5. Client confirm hoặc S3 Event báo backend xử lý tiếp</div>\n      <ul>\n        <li>Giảm tải app server vì file không đi qua backend.</li>\n        <li>Giới hạn thời gian truy cập bằng expiration.</li>\n        <li>Có thể ràng buộc content-type, key prefix, metadata.</li>\n      </ul>\n      <div class=\"warn-box\">⚠️ Presigned URL là bearer token: ai có URL thì dùng được đến khi hết hạn. Không log URL nhạy cảm, expire ngắn, key path khó đoán.</div>",
    "tags": "cloud aws s3 storage security",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS S3"
  },
  {
    "num": 225,
    "numStr": "225",
    "question": "RDS Multi-AZ failover diễn ra thế nào? App cần chuẩn bị gì?",
    "answerHtml": "<p>Với <strong>Multi-AZ</strong>, RDS duy trì standby database ở Availability Zone khác. Khi primary lỗi, RDS tự promote standby và endpoint DNS trỏ sang primary mới.</p>\n      <div class=\"code-block\">Failover events:\n  Primary instance crash\n  AZ/network issue\n  Maintenance/reboot with failover\n\nApp impact:\n  Connection hiện tại bị drop\n  DNS endpoint đổi target\n  Có downtime ngắn trong lúc promote</div>\n      <ul>\n        <li>Connection pool phải retry được khi connection stale.</li>\n        <li>Timeout nên hợp lý, không treo request quá lâu.</li>\n        <li>Transaction đang chạy có thể rollback và cần idempotency/retry an toàn.</li>\n      </ul>\n      <div class=\"tip-box\">💡 Multi-AZ tăng availability, không làm query nhanh hơn. Muốn scale read thì dùng Read Replica hoặc Aurora reader endpoint.</div>",
    "tags": "cloud aws rds database availability",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS RDS"
  },
  {
    "num": 226,
    "numStr": "226",
    "question": "RDS Performance Insights và slow query tuning dùng thế nào?",
    "answerHtml": "<p><strong>Performance Insights</strong> giúp quan sát database load, wait events và top SQL để tìm bottleneck trong RDS.</p>\n      <table class=\"compare-table\">\n        <tr><th>Dấu hiệu</th><th>Nguyên nhân thường gặp</th><th>Cách xử lý</th></tr>\n        <tr><td>CPU cao</td><td>Query scan nhiều row</td><td>Thêm index, rewrite query</td></tr>\n        <tr><td>Lock wait</td><td>Transaction giữ lock lâu</td><td>Rút ngắn transaction, đúng isolation</td></tr>\n        <tr><td>I/O wait</td><td>Disk throughput thiếu</td><td>Tối ưu query, tăng storage IOPS</td></tr>\n        <tr><td>Connection spike</td><td>Pool config sai</td><td>Giới hạn pool, dùng RDS Proxy</td></tr>\n      </table>\n      <div class=\"code-block\">Tuning workflow:\n  1. Xác định time window latency tăng\n  2. Xem DB load và top SQL\n  3. EXPLAIN ANALYZE query chậm\n  4. Thêm index/rewrite query\n  5. Verify p95 latency và CPU sau fix</div>\n      <div class=\"tip-box\">💡 Đừng chỉ tăng instance size. Scale up che triệu chứng tạm thời; query/index sai vẫn quay lại khi traffic tăng.</div>",
    "tags": "cloud aws rds database performance",
    "level": "senior",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS RDS"
  },
  {
    "num": 227,
    "numStr": "227",
    "question": "SQS Visibility Timeout là gì? Nếu xử lý message lâu hơn timeout thì sao?",
    "answerHtml": "<p><strong>Visibility Timeout</strong> là khoảng thời gian message bị ẩn sau khi consumer nhận nó. Nếu consumer không delete message trước khi timeout hết, message sẽ hiện lại và có thể được consumer khác xử lý lại.</p>\n      <div class=\"code-block\">Timeline:\n  t=0: Consumer A nhận message, visibility timeout = 30s\n  t=25: xử lý chưa xong\n  t=30: message visible lại\n  t=31: Consumer B nhận cùng message\n\nResult: duplicate processing nếu app không idempotent.</div>\n      <ul>\n        <li>Set timeout lớn hơn thời gian xử lý p99.</li>\n        <li>Với job dài, gọi ChangeMessageVisibility để extend.</li>\n        <li>DeleteMessage chỉ sau khi xử lý thành công.</li>\n      </ul>\n      <div class=\"warn-box\">⚠️ Luôn thiết kế consumer idempotent. SQS Standard không đảm bảo exactly-once.</div>",
    "tags": "cloud aws sqs queue messaging",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS SQS"
  },
  {
    "num": 228,
    "numStr": "228",
    "question": "SQS Dead Letter Queue là gì? Khi nào message bị đưa vào DLQ?",
    "answerHtml": "<p><strong>Dead Letter Queue (DLQ)</strong> là queue phụ chứa các message xử lý thất bại nhiều lần, giúp tránh poison message làm kẹt consumer chính.</p>\n      <div class=\"code-block\">Redrive policy:\n  source queue: orders\n  deadLetterTargetArn: orders-dlq\n  maxReceiveCount: 5\n\nNếu message được receive 5 lần nhưng không delete thành công\n→ SQS chuyển message sang orders-dlq</div>\n      <ul>\n        <li>DLQ dùng để debug payload lỗi, dependency lỗi, bug logic.</li>\n        <li>Không nên để DLQ tồn đọng lâu mà không alert.</li>\n        <li>Sau khi fix bug, có thể redrive message về source queue.</li>\n      </ul>\n      <div class=\"tip-box\">💡 Alert quan trọng: ApproximateNumberOfMessagesVisible của DLQ > 0. DLQ có message nghĩa là hệ thống đang mất event cần xử lý.</div>",
    "tags": "cloud aws sqs queue messaging",
    "level": "junior",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS SQS"
  },
  {
    "num": 229,
    "numStr": "229",
    "question": "CloudWatch Logs Insights dùng để query log như thế nào?",
    "answerHtml": "<p><strong>CloudWatch Logs Insights</strong> cho phép query log bằng ngôn ngữ query riêng để điều tra lỗi, latency, requestId và pattern bất thường.</p>\n      <div class=\"code-block\">Ví dụ query error theo service:\nfields @timestamp, @message, level, service, requestId\n| filter level = \"ERROR\"\n| sort @timestamp desc\n| limit 50\n\nĐếm lỗi theo endpoint:\nfields endpoint, status\n| filter status >= 500\n| stats count(*) as errors by endpoint\n| sort errors desc</div>\n      <ul>\n        <li>Log nên có JSON format để filter field dễ hơn.</li>\n        <li>Luôn log correlationId/requestId để trace một request qua nhiều service.</li>\n        <li>Đặt retention hợp lý để kiểm soát cost.</li>\n      </ul>\n      <div class=\"tip-box\">💡 Logs Insights rất hữu ích khi chưa có ELK/Datadog. Nhưng query log nhiều và retention dài có thể tốn cost.</div>",
    "tags": "cloud aws cloudwatch logs observability",
    "level": "junior",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS CloudWatch"
  },
  {
    "num": 230,
    "numStr": "230",
    "question": "CloudWatch Alarm nên thiết kế thế nào để không bị alert noise?",
    "answerHtml": "<p>Alert tốt phải <strong>actionable</strong>: khi báo thì người trực biết cần làm gì. Alert quá nhiều và không quan trọng sẽ gây alert fatigue.</p>\n      <ul>\n        <li>Dùng threshold theo SLA/SLO: error rate, p95 latency, availability.</li>\n        <li>Đặt evaluation period để tránh spike ngắn gây báo giả.</li>\n        <li>Phân cấp severity: warning vs critical.</li>\n        <li>Alarm trên symptom trước, cause sau: 5xx/latency quan trọng hơn CPU đơn thuần.</li>\n      </ul>\n      <div class=\"code-block\">Good critical alarms:\n  ALB 5xx rate > 2% trong 5 phút\n  API p95 latency > 1s trong 10 phút\n  SQS oldest message age > SLA\n  RDS free storage < 10%\n\nNoisy alarm:\n  CPU > 70% trong 1 phút nhưng app vẫn healthy</div>\n      <div class=\"tip-box\">💡 Một alarm tốt nên có runbook link: nguyên nhân thường gặp, dashboard liên quan, bước rollback/restart/scale.</div>",
    "tags": "cloud aws cloudwatch monitoring observability",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS CloudWatch"
  },
  {
    "num": 231,
    "numStr": "231",
    "question": "ECS rolling deployment hoạt động thế nào? minimumHealthyPercent và maximumPercent là gì?",
    "answerHtml": "<p>Khi update ECS Service, scheduler thay task cũ bằng task mới theo deployment configuration để tránh downtime.</p>\n      <table class=\"compare-table\">\n        <tr><th>Config</th><th>Ý nghĩa</th><th>Ví dụ desired=10</th></tr>\n        <tr><td>minimumHealthyPercent</td><td>Số task healthy tối thiểu khi deploy</td><td>100% → luôn giữ ít nhất 10 task</td></tr>\n        <tr><td>maximumPercent</td><td>Số task tối đa tạm thời khi deploy</td><td>200% → có thể chạy tối đa 20 task</td></tr>\n      </table>\n      <div class=\"code-block\">Deployment desired=4, min=100%, max=200%:\n  Start 4 new tasks song song với 4 old tasks\n  New tasks pass health check\n  Stop old tasks dần\n  Kết thúc còn 4 new tasks</div>\n      <div class=\"warn-box\">⚠️ Nếu cluster/capacity không đủ để chạy thêm task mới, deployment có thể bị kẹt. Với Fargate ít gặp hơn EC2 launch type.</div>",
    "tags": "cloud aws ecs docker container deployment",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS ECS"
  },
  {
    "num": 232,
    "numStr": "232",
    "question": "ECS Service Auto Scaling khác EC2 Auto Scaling thế nào?",
    "answerHtml": "<p><strong>ECS Service Auto Scaling</strong> tăng/giảm số task của service. <strong>EC2 Auto Scaling</strong> tăng/giảm số EC2 instances cung cấp capacity cho cluster.</p>\n      <table class=\"compare-table\">\n        <tr><th></th><th>ECS Service Scaling</th><th>EC2 Auto Scaling</th></tr>\n        <tr><td>Scale cái gì</td><td>Task count</td><td>EC2 instance count</td></tr>\n        <tr><td>Dùng với Fargate</td><td>Rất phổ biến</td><td>Không cần quản lý EC2</td></tr>\n        <tr><td>Dùng với EC2 launch type</td><td>Cần capacity sẵn</td><td>Cần để thêm worker node</td></tr>\n        <tr><td>Metric</td><td>CPU/memory/RPS per task</td><td>CPU cluster, capacity provider</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 Với ECS trên EC2, phải scale cả 2 lớp: task count và EC2 capacity. Với Fargate, bạn chỉ cần quan tâm task count.</div>",
    "tags": "cloud aws ecs autoscaling container",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS ECS"
  },
  {
    "num": 233,
    "numStr": "233",
    "question": "Lambda xử lý event từ SQS như thế nào? Batch size và retry cần lưu ý gì?",
    "answerHtml": "<p>Khi SQS trigger Lambda, Lambda service poll queue, lấy một batch messages và invoke function. Nếu function thành công, messages được delete; nếu fail, messages quay lại queue sau visibility timeout.</p>\n      <ul>\n        <li><strong>Batch size:</strong> nhiều message/invoke giúp throughput tốt hơn nhưng lỗi một batch ảnh hưởng nhiều message.</li>\n        <li><strong>Partial batch response:</strong> cho phép báo message nào fail để chỉ retry message đó.</li>\n        <li><strong>Visibility timeout:</strong> nên lớn hơn Lambda timeout để tránh duplicate khi function còn chạy.</li>\n        <li><strong>DLQ:</strong> cấu hình ở SQS redrive policy cho poison message.</li>\n      </ul>\n      <div class=\"warn-box\">⚠️ Nếu Lambda ghi DB/downstream, hãy giới hạn reserved concurrency để không làm quá tải database khi queue backlog lớn.</div>",
    "tags": "cloud aws lambda sqs serverless",
    "level": "middle",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS Lambda"
  },
  {
    "num": 234,
    "numStr": "234",
    "question": "Lambda cold start là gì? Làm sao giảm cold start cho Java/Spring Boot?",
    "answerHtml": "<p><strong>Cold start</strong> xảy ra khi Lambda phải tạo execution environment mới: download code, start runtime, init dependencies rồi mới chạy handler.</p>\n      <table class=\"compare-table\">\n        <tr><th>Cách giảm</th><th>Tác dụng</th><th>Lưu ý</th></tr>\n        <tr><td>Giảm package size</td><td>Load code nhanh hơn</td><td>Loại dependency không cần</td></tr>\n        <tr><td>Init lazy/hợp lý</td><td>Giảm thời gian init</td><td>Không init heavy client nếu không dùng</td></tr>\n        <tr><td>Provisioned Concurrency</td><td>Giữ environment warm</td><td>Tốn cost cố định</td></tr>\n        <tr><td>SnapStart</td><td>Snapshot initialized runtime</td><td>Hữu ích cho Java runtime được hỗ trợ</td></tr>\n        <tr><td>Quarkus/Micronaut</td><td>Startup nhẹ hơn Spring Boot truyền thống</td><td>Cần đổi stack/framework</td></tr>\n      </table>\n      <div class=\"tip-box\">💡 Với API latency-sensitive, Lambda Java + Spring Boot full app có thể không phải lựa chọn tốt nhất. ECS/Fargate hoặc Lambda runtime nhẹ hơn có thể phù hợp hơn.</div>",
    "tags": "cloud aws lambda serverless java performance",
    "level": "senior",
    "section": "Cloud",
    "sectionIcon": "☁️",
    "sectionColor": "#60a5fa",
    "sectionColorClass": "",
    "subsection": "AWS Lambda"
  }
]