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

Tìm kiếm

Java CoreSenior21 phút đọc

Reflection, annotation và annotation processor: framework Java đọc code của bạn thế nào

Ôn 12 thẻ
Trong bài này

Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.

Reflection, annotation và annotation processor: framework Java đọc code của bạn thế nào

1Reflection là gì

Mọi class đã nạp có một object Class. Từ nó lấy Field, Method, Constructor rồi đọc, ghi, gọi lúc chạy mà không cần biết kiểu lúc biên dịch.

Class<?> type = Class.forName("com.acme.Booking");
Object b = type.getDeclaredConstructor(String.class)
               .newInstance("HAN-042");
Method confirm = type.getMethod("confirm", int.class);
confirm.invoke(b, 3);
Field status = type.getDeclaredField("status");
status.setAccessible(true);   // vượt private

2Chi phí của reflection

Chậm hơn gọi thẳng vì JIT khó inline, có boxing và kiểm tra mỗi lần gọi. Thứ đắt nhất là tra cứu, nên framework tra một lần rồi cache.

Cách gọi ns/lần
Gọi thẳng ~0,02
Method.invoke đã cache ~3,5
MethodHandle.invokeExact ~1,5

3Dynamic proxy và AOP

Proxy tạo lúc chạy một class implement interface, mọi lời gọi đổ về InvocationHandler. Đây là nền của transaction, cache, retry quanh method.

  • JDK proxy chỉ cho interface; class thì CGLIB sinh lớp con
  • Method final, private không bị bọc
  • Gọi this.other() nội bộ không đi qua proxy
  • Nên @Transactional trên method gọi nội bộ vô tác dụng

4Annotation và Retention

Annotation chỉ là dữ liệu, tự nó không làm gì. @Retention quyết định nó sống tới đâu, và ai đọc được.

Retention Reflection thấy? Ví dụ
SOURCE không @Override, Lombok
CLASS (mặc định) không công cụ đọc bytecode
RUNTIME có @Service, @Entity, @Test

5Annotation processor

Plugin của javac: đọc annotation lúc biên dịch, kiểm tra và sinh file mới; không sửa được class đang có. Lombok sửa được nhờ API nội bộ của javac.

flowchart TD
  S["Code + @Annotation"] --> J["javac"]
  J --> P["Processor: sinh file .java mới"]
  P --> J
  J --> C[".class: giữ CLASS, RUNTIME"]
  C --> R["Reflection lúc chạy: chỉ RUNTIME"]

💡 Ghi nhớ

  • getMethods(): public kể cả kế thừa; getDeclared...: cả private.

  • Lỗi thật nằm trong InvocationTargetException.getCause().

  • Từ JDK 17, setAccessible không mở được bên trong JDK.

  • Từ JDK 23, processor trên classpath không tự chạy.

⭐ Điểm phỏng vấn

Tự trả lời trước, rồi bấm từng câu để xem đáp án.

  • Spring đọc @Service thế nào?

    Reflection trên annotation có @Retention(RUNTIME).

  • Vì sao @Transactional gọi nội bộ không chạy?

    this.method() không đi qua proxy.

  • Reflection hay sinh code?

    Sinh code: lỗi lúc build, khởi động nhanh.

⚠️ Lỗi thường gặp

  • Quên @Retention(RUNTIME): reflection trả null, không lỗi nào báo.

  • Tin @Inherited cho method, field hoặc interface.

  • Dùng getDeclaredField trong business code thay vì cách tĩnh.

Spring tìm @Service, Hibernate đọc @Entity, JUnit chạy @Test, Lombok sinh getter: tất cả dựa trên hai cơ chế, đọc code lúc chạy (reflection) và đọc code lúc biên dịch (annotation processing). Bài này cho bạn tự viết được cả hai, hiểu cái giá của chúng, và trả lời được “vì sao annotation của tôi không có tác dụng”. Nên biết trước class được nạp thế nào.

Sơ đồ tóm tắt:

flowchart LR
  SRC["Code + @Annotation"] --> JAVAC["javac"]
  JAVAC --> APT["Annotation processor: đọc SOURCE/CLASS, sinh file .java mới"]
  APT --> JAVAC
  JAVAC --> CLS[".class: giữ CLASS, RUNTIME"]
  CLS --> RUN["JVM chạy"]
  RUN --> REFL["Reflection: chỉ thấy RUNTIME"]
  REFL --> FW["Spring, JPA, Jackson, JUnit"]
  REFL --> PROXY["Dynamic proxy / CGLIB: AOP"]

1. Reflection: đọc và gọi code lúc chạy

Ý chính: mọi class đã nạp có một object Class; từ nó bạn lấy Field, Method, Constructor, Annotation rồi đọc, ghi, gọi mà không cần biết kiểu lúc biên dịch. Đây là cách framework làm việc với class bạn viết sau khi framework đã được biên dịch từ lâu.

Class<?> type = Class.forName("com.acme.booking.Booking");    // hoặc Booking.class, obj.getClass()
Object booking = type.getDeclaredConstructor(String.class).newInstance("HAN-042");

Method confirm = type.getMethod("confirm", int.class);       // chỉ method public, kể cả kế thừa
Object result = confirm.invoke(booking, 3);

Field status = type.getDeclaredField("status");              // mọi field khai báo trong class này
status.setAccessible(true);                                  // vượt private
status.set(booking, "CANCELLED");
  • getMethods()/getFields(): thành viên public, kể cả kế thừa từ lớp cha và Object. getDeclaredMethods()/getDeclaredFields(): mọi thành viên khai báo trong chính class đó, kể cả private, không lấy của lớp cha. Một class chỉ có field private cho ra 9 method public (của Object) và 0 declared method.
  • getDeclaredMethods() không đảm bảo thứ tự; đừng dựa vào thứ tự khai báo.
  • Exception do method được gọi ném ra bị bọc trong InvocationTargetException; nguyên nhân thật ở getCause().
  • Class.newInstance() deprecated từ JDK 9 (nó ném lén checked exception của constructor); dùng getDeclaredConstructor().newInstance().

Chi phí của reflection

Ý chính: chậm hơn gọi thẳng ở hot path, nhưng đủ nhanh cho việc framework làm: tra cứu metadata một lần lúc khởi động, cache lại, rồi gọi nhiều lần.

Đo thô trên JDK 21 (50 triệu lần gọi, vòng thứ ba, chỉ để thấy bậc độ lớn; số liệu nghiêm túc phải dùng JMH):

Cách gọi ns/lần
Gọi thẳng acc.withdraw(1) ~0,02 (JIT gần như xoá hẳn)
Method.invoke (đã cache Method) ~3,5
MethodHandle.invokeExact ~1,5

Vì sao chậm: JIT khó inline qua invoke, tham số đi qua mảng Object[] và bị boxing, có kiểm tra quyền và kiểu ở mỗi lần gọi. Thứ đắt nhất thường không phải invoke mà là tra cứu (getMethod, quét annotation trên hàng nghìn class), nên Spring quét lúc khởi động và cache kết quả. Từ JDK 18 (JEP 416), reflection lõi được viết lại trên method handle.

2. Dynamic proxy: object giả đứng trước object thật

Ý chính: java.lang.reflect.Proxy tạo lúc chạy một class implement các interface bạn đưa, mọi lời gọi đổ về một InvocationHandler. Đây là nền của AOP: transaction, cache, retry, logging bọc quanh method mà không sửa method.

interface Payment { String pay(int amount); }

Payment real = amount -> "paid " + amount;
Payment logged = (Payment) Proxy.newProxyInstance(
        Payment.class.getClassLoader(),
        new Class<?>[]{Payment.class},
        (proxy, method, args) -> {
            System.out.println("  before " + method.getName() + Arrays.toString(args));
            return method.invoke(real, args);                 // gọi object thật
        });

System.out.println(logged.pay(50) + " / class " + logged.getClass().getName());
  before pay[50]
paid 50 / class $Proxy7
  • JDK proxy chỉ làm được với interface. Để proxy một class, Spring dùng CGLIB (sinh lớp con lúc chạy); Spring Boot mặc định proxy theo class. Hệ quả: method final hay private không bị bọc.
  • Lời gọi từ bên trong object (this.other()) không đi qua proxy, nên @Transactional trên method gọi nội bộ không có tác dụng. Chi tiết proxy trong Spring ở IoC và DI.

3. Annotation: dữ liệu gắn vào code

Ý chính: annotation tự nó không làm gì; nó chỉ là dữ liệu mà compiler, công cụ hoặc framework đọc rồi quyết định hành động. Hai meta-annotation quan trọng nhất: @Target (đặt được ở đâu) và @Retention (sống tới giai đoạn nào).

@Retention(RetentionPolicy.RUNTIME)       // reflection đọc được lúc chạy
@Target(ElementType.METHOD)               // chỉ đặt trên method; đặt chỗ khác là lỗi biên dịch
public @interface Audit {
    String value() default "INFO";        // phần tử: primitive, String, Class, enum, annotation, hoặc mảng của chúng
    String[] tags() default {};
}
@Retention Có trong .class? Reflection thấy? Dùng cho
SOURCE không không chỉ compiler và annotation processor: @Override, @SuppressWarnings, Lombok
CLASS (mặc định khi không ghi) có không công cụ đọc bytecode (một số annotation null-check, công cụ instrument)
RUNTIME có có framework: @Service, @Entity, @Test, @Transactional

Các meta-annotation khác:

  • @Inherited: lớp con “thấy” annotation đặt trên lớp cha khi tra bằng isAnnotationPresent.
  • @Repeatable(Container.class): cho đặt cùng annotation nhiều lần; đọc bằng getAnnotationsByType. Ví dụ thật trong Spring: @PropertySource, @ComponentScan, @Sql.
  • @Documented: annotation hiện trong Javadoc của phần tử được đánh dấu.

Chạy thử trên JDK 21:

@Audit       -> @Refl.Audit("WARN")
@ClassOnly   -> null                     // retention CLASS: reflection không thấy
Child@Tagged -> true                     // @Inherited qua lớp cha
Impl@Tagged  -> false                    // @Inherited KHÔNG đi qua interface
roles        -> [@Refl.Role("ADMIN"), @Refl.Role("OPS")]

4. Annotation processor: sinh code lúc biên dịch

Ý chính: annotation processor là plugin của javac. Nó nhận các phần tử (class, method, field) mang annotation nó đăng ký, kiểm tra, và sinh file mới (.java hoặc resource) qua Filer; javac biên dịch luôn các file sinh ra trong vòng (round) kế tiếp. Nó không sửa được class đã có.

@SupportedAnnotationTypes("demo.apt.GenerateToString")
public class ToStringProcessor extends AbstractProcessor {
    @Override public SourceVersion getSupportedSourceVersion() { return SourceVersion.latestSupported(); }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment env) {
        for (Element e : env.getElementsAnnotatedWith(GenerateToString.class)) {
            if (e.getKind() != ElementKind.CLASS) {
                processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
                        "@GenerateToString chỉ dùng cho class", e);    // lỗi biên dịch chỉ đúng dòng
                continue;
            }
            writeHelper((TypeElement) e);                              // tạo file mới bằng processingEnv.getFiler()
        }
        return true;
    }
}
  • Đăng ký: file META-INF/services/javax.annotation.processing.Processor chứa tên class processor (cơ chế ServiceLoader), hoặc chỉ rõ bằng -processor.
  • Đầu ra: Maven để file sinh ra ở target/generated-sources/annotations và tự thêm thư mục này vào source path; IDE đánh dấu nó là generated sources. Đừng commit code sinh ra.
  • Báo lỗi bằng Messager gắn vào đúng phần tử, không ném exception (exception làm javac in stack trace khó đọc).
  • Rounds: processor có thể được gọi nhiều lần; code sinh ở vòng trước có thể mang annotation cần xử lý ở vòng sau. Không giả định class khác đã tồn tại ở vòng đầu.
Lombok khác annotation processor thông thường ở đâu
  • Processor chuẩn (MapStruct, AutoValue, Immutables) chỉ thêm file mới: BookingMapperImpl.java nằm trong generated-sources, mở ra đọc được, đặt breakpoint được.
  • Lombok sửa cây cú pháp (AST) của chính class bạn đang biên dịch để chèn getter, builder, constructor. Đặc tả annotation processing không cho làm vậy; Lombok làm được bằng cách dùng API nội bộ của javac (và của trình biên dịch Eclipse). Hệ quả: mỗi lần JDK đổi nội bộ, Lombok phải ra bản mới; IDE cần plugin để “giả lập” những method không có trong source (IntelliJ đóng gói sẵn plugin Lombok từ 2020.3).
  • delombok chuyển code Lombok thành code Java thường khi muốn bỏ Lombok hoặc cần đọc chính xác code được sinh.
  • Với record (Java 16+), nhu cầu dùng Lombok cho DTO bất biến giảm nhiều; Lombok vẫn tiện cho entity JPA (cần class mutable có constructor rỗng) và builder.

Bài tập

Bài 1: test runner tí hon

Đề: viết MiniRunner.run(Class<?>) tìm các method có @Test và @BeforeEach (annotation tự định nghĩa), tạo instance mới cho mỗi test, chạy @BeforeEach rồi test, hỗ trợ @Test(expected = X.class), in PASS/FAIL và tổng kết. Thử với một class test có một test đúng, một test kỳ vọng exception và một test sai.

Lời giải Bài 1
import java.lang.annotation.*;
import java.lang.reflect.*;
import java.util.*;

public class MiniRunner {
    @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD)
    @interface Test { Class<? extends Throwable> expected() default None.class; }
    @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD)
    @interface BeforeEach {}
    static final class None extends Throwable {}        // giá trị mặc định không được là null

    public static void run(Class<?> testClass) throws Exception {
        List<Method> befores = new ArrayList<>(), tests = new ArrayList<>();
        for (Method m : testClass.getDeclaredMethods()) {
            if (m.isAnnotationPresent(BeforeEach.class)) befores.add(m);
            if (m.isAnnotationPresent(Test.class)) tests.add(m);
        }
        tests.sort(Comparator.comparing(Method::getName));     // thứ tự của getDeclaredMethods không cố định
        int passed = 0;
        for (Method t : tests) {
            Object instance = testClass.getDeclaredConstructor().newInstance();   // cô lập trạng thái giữa các test
            Class<? extends Throwable> expected = t.getAnnotation(Test.class).expected();
            try {
                for (Method b : befores) { b.setAccessible(true); b.invoke(instance); }
                t.setAccessible(true);
                t.invoke(instance);
                if (expected != None.class) throw new AssertionError("expected " + expected.getSimpleName());
                System.out.println("PASS " + t.getName()); passed++;
            } catch (InvocationTargetException e) {             // exception thật nằm trong getCause()
                Throwable cause = e.getCause();
                if (expected.isInstance(cause)) { System.out.println("PASS " + t.getName()); passed++; }
                else System.out.println("FAIL " + t.getName() + ": " + cause);
            } catch (AssertionError e) {
                System.out.println("FAIL " + t.getName() + ": " + e.getMessage());
            }
        }
        System.out.printf("%d/%d passed%n", passed, tests.size());
    }

    static class WalletTest {
        private long balance;
        @BeforeEach void setUp() { balance = 100; }
        @Test void withdrawReducesBalance() {
            balance -= 30;
            if (balance != 70) throw new AssertionError("balance=" + balance);
        }
        @Test(expected = IllegalStateException.class) void overdraftIsRejected() {
            if (balance - 200 < 0) throw new IllegalStateException("overdraft");
        }
        @Test void brokenTest() { if (balance != 0) throw new AssertionError("balance=" + balance); }
        void helper() {}                                     // không có @Test: bị bỏ qua
    }

    public static void main(String[] args) throws Exception { run(WalletTest.class); }
}
FAIL brokenTest: java.lang.AssertionError: balance=100
PASS overdraftIsRejected
PASS withdrawReducesBalance
2/3 passed

Ba điểm JUnit thật cũng làm: instance mới cho mỗi test (không để test này làm bẩn test kia), mở InvocationTargetException lấy nguyên nhân, và không dựa vào thứ tự method. Annotation expected dùng lớp None làm giá trị mặc định vì phần tử annotation không nhận null.

Bài 2: processor sinh toString

Đề: viết annotation @GenerateToString (SOURCE, chỉ đặt trên class) và processor sinh class XxxStrings có static String of(Xxx o) in tên class và các field không static. Đặt annotation lên interface thì phải ra lỗi biên dịch chỉ đúng dòng. Kiểm tra annotation không còn trong .class.

Lời giải Bài 2
// proc/src/demo/apt/GenerateToString.java
package demo.apt;
import java.lang.annotation.*;

@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.TYPE)
public @interface GenerateToString {}
// proc/src/demo/apt/ToStringProcessor.java
package demo.apt;

import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.*;
import javax.lang.model.util.ElementFilter;
import javax.tools.Diagnostic;
import java.io.*;
import java.util.*;

@SupportedAnnotationTypes("demo.apt.GenerateToString")
public class ToStringProcessor extends AbstractProcessor {
    @Override public SourceVersion getSupportedSourceVersion() { return SourceVersion.latestSupported(); }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment env) {
        for (Element e : env.getElementsAnnotatedWith(GenerateToString.class)) {
            if (e.getKind() != ElementKind.CLASS) {
                processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
                        "@GenerateToString chỉ dùng cho class", e);
                continue;
            }
            TypeElement type = (TypeElement) e;
            String pkg = processingEnv.getElementUtils().getPackageOf(type).getQualifiedName().toString();
            String name = type.getSimpleName() + "Strings";
            List<VariableElement> fields = ElementFilter.fieldsIn(type.getEnclosedElements()).stream()
                    .filter(f -> !f.getModifiers().contains(Modifier.STATIC)).toList();
            StringBuilder body = new StringBuilder("\"" + type.getSimpleName() + "[\"");
            for (int i = 0; i < fields.size(); i++) {
                String f = fields.get(i).getSimpleName().toString();
                body.append(" + \"").append(i == 0 ? "" : ", ").append(f).append("=\" + o.").append(f);
            }
            body.append(" + \"]\"");
            try (Writer w = processingEnv.getFiler().createSourceFile(pkg + "." + name, type).openWriter()) {
                w.write("package " + pkg + ";\n\n");
                w.write("public final class " + name + " {\n");
                w.write("    private " + name + "() {}\n");
                w.write("    public static String of(" + type.getSimpleName() + " o) {\n");
                w.write("        return " + body + ";\n    }\n}\n");
            } catch (IOException ex) {
                processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, ex.getMessage(), e);
            }
        }
        return true;
    }
}
// app/src/demo/Booking.java
package demo;
import demo.apt.GenerateToString;

@GenerateToString
public class Booking {
    final String code; final int nights;            // package-private để class sinh ra đọc được
    public Booking(String code, int nights) { this.code = code; this.nights = nights; }
    @Override public String toString() { return BookingStrings.of(this); }
    public static void main(String[] args) { System.out.println(new Booking("HAN-042", 3)); }
}
echo "demo.apt.ToStringProcessor" > proc/out/META-INF/services/javax.annotation.processing.Processor
javac -d proc/out proc/src/demo/apt/*.java
javac --processor-path proc/out -cp proc/out -s app/gen -d app/out app/src/demo/Booking.java
java -cp app/out demo.Booking
Booking[code=HAN-042, nights=3]

File sinh ra trong app/gen/demo/BookingStrings.java:

public final class BookingStrings {
    private BookingStrings() {}
    public static String of(Booking o) {
        return "Booking[" + "code=" + o.code + ", nights=" + o.nights + "]";
    }
}

Đặt @GenerateToString lên một interface: error: @GenerateToString chỉ dùng cho class chỉ đúng dòng khai báo. javap -v trên Booking.class không còn chữ GenerateToString nào vì retention là SOURCE. Dùng --processor-path (không chỉ -cp) để chạy được cả trên JDK 23+.

Ghi nhớ

  • Phân biệt được getMethods và getDeclaredMethods, và biết vì sao setAccessible thất bại với class của JDK.
  • Giải thích được reflection chậm ở đâu và framework giảm chi phí đó thế nào.
  • Biết JDK proxy chỉ làm với interface, CGLIB làm với class, và vì sao gọi nội bộ không đi qua proxy.
  • Chọn đúng @Retention, và biết giới hạn của @Inherited.
  • Viết được annotation processor tối thiểu và cấu hình nó chạy trên JDK 23+.

Câu hỏi phỏng vấn

Reflection là gì? Framework nào dùng nó và dùng để làm gì?

Reflection là API cho phép chương trình xem và thao tác cấu trúc của chính nó lúc chạy: liệt kê field, method, constructor, đọc annotation, tạo object, gọi method khi chỉ biết tên.

Spring dùng để quét @Component, tạo bean qua constructor, inject field/setter, tạo proxy AOP. Hibernate đọc @Entity và gán field khi nạp dòng. Jackson đọc getter/field để chuyển JSON. JUnit tìm @Test. Tất cả đều cần làm việc với class được viết sau khi framework đã biên dịch.

Reflection có nhược điểm gì? Khi nào không nên dùng?

Chậm hơn gọi thẳng ở hot path, mất kiểm tra kiểu lúc biên dịch, phá đóng gói khi dùng setAccessible, lỗi chỉ lộ ra lúc chạy, và vướng module system và native image.

Không nên dùng trong business logic hay vòng lặp nóng; dùng interface, sealed type + switch, hoặc map từ key tới lambda. Nếu buộc phải dùng, tra cứu một lần và cache Method/MethodHandle, gom vào một chỗ ở rìa hệ thống.

Vì sao setAccessible(true) trên field của String ném InaccessibleObjectException?

Vì từ JDK 16–17 các package nội bộ của JDK bị đóng chặt (strong encapsulation): module java.base không opens package java.lang cho code của bạn.

setAccessible chỉ vượt được private khi module chứa class đó mở package cho module gọi; code trên classpath (unnamed module) vẫn reflect thoải mái vào nhau. Thư viện cũ dựa vào reflect vào JDK sẽ hỏng khi nâng JDK; cách đúng là nâng thư viện, tạm thời mới thêm --add-opens.

@Retention có những giá trị nào? Annotation tự viết không được Spring nhận thì kiểm tra gì?

SOURCE (chỉ compiler thấy), CLASS (vào .class nhưng reflection không thấy, là mặc định), RUNTIME (reflection thấy).

Annotation không có tác dụng: kiểm tra có @Retention(RUNTIME) chưa; @Target có đúng chỗ đặt không; có thành phần nào đọc nó không (aspect, BeanPostProcessor, interceptor); bean có đi qua proxy không (gọi nội bộ thì aspect không chạy); annotation đặt trên interface mà code đọc bằng reflection thuần thì không thấy, phải dùng AnnotatedElementUtils.

@Inherited hoạt động thế nào? Annotation trên interface có được class implement “kế thừa” không?

@Inherited chỉ làm cho annotation đặt trên một class được thấy ở lớp con khi tra bằng getAnnotation/isAnnotationPresent; không áp dụng cho interface, method hay field.

Thử nghiệm: @Tagged (có @Inherited) trên lớp cha → lớp con true; trên interface → class implement false. Spring bù lại bằng MergedAnnotations với chiến lược tìm theo cả cây kiểu, nên @Transactional đặt trên interface vẫn được Spring thấy trong nhiều trường hợp, nhưng tài liệu Spring khuyên đặt trên class cụ thể.

JDK dynamic proxy khác CGLIB proxy thế nào? Ảnh hưởng gì tới @Transactional?

JDK proxy tạo class implement interface và chỉ bọc được method của interface; CGLIB sinh lớp con của class thật nên bọc được method public không final. Spring Boot mặc định dùng proxy theo class.

Hệ quả cho @Transactional, @Cacheable, @Async: method final, private, static không bị bọc; gọi this.method() từ trong cùng bean không đi qua proxy nên annotation bị bỏ qua; inject theo class cụ thể khi proxy là JDK proxy thì lỗi kiểu. Cách sửa: tách method sang bean khác, hoặc inject chính bean qua proxy.

Annotation processor là gì? Nó khác reflection ở đâu?

Là plugin của javac, chạy lúc biên dịch, đọc annotation (thường SOURCE) và sinh file mới mà javac biên dịch tiếp; reflection thì đọc annotation RUNTIME lúc chương trình chạy.

Processor bắt lỗi sớm (lỗi biên dịch đúng dòng), sinh code đọc được, không tốn thời gian khởi động: MapStruct, Dagger, Hibernate metamodel, Spring Boot configuration metadata. Giới hạn: không sửa được class đã có, chỉ thêm file; muốn chạy trên JDK 23+ phải khai báo processor rõ ràng (annotationProcessorPaths).

Lombok hoạt động thế nào? Vì sao nâng JDK hay làm Lombok lỗi?

Lombok là annotation processor nhưng không chỉ sinh file mới: nó sửa trực tiếp cây cú pháp của class đang biên dịch qua API nội bộ của javac, điều mà đặc tả processor không cho phép.

Vì dựa vào nội bộ của compiler, mỗi bản JDK mới có thể làm Lombok cũ hỏng (lỗi kiểu NoSuchFieldError trong com.sun.tools.javac), nên phải nâng Lombok cùng JDK và khai báo nó trong annotationProcessorPaths. IDE cần plugin để hiểu các method không có trong source. Khi muốn thoát Lombok: delombok, hoặc thay DTO bằng record.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu tiếng Anh dùng trong phỏng vấn
reflection /rɪˈflek.ʃən/ xem và gọi code lúc chạy “Frameworks use reflection once at startup and cache the results.”
strong encapsulation /strɑːŋ ɪnˌkæp.sjəˈleɪ.ʃən/ JDK đóng package nội bộ “Since JDK 17, strong encapsulation blocks deep reflection into java.base.”
dynamic proxy /daɪˈnæm.ɪk ˈprɑːk.si/ object sinh lúc chạy, chặn mọi lời gọi “A JDK dynamic proxy only works through interfaces.”
invocation handler /ˌɪn.vəˈkeɪ.ʃən ˈhænd.lɚ/ nơi xử lý lời gọi tới proxy “The invocation handler wraps every call with logging.”
retention policy /rɪˈten.ʃən ˈpɑː.lə.si/ annotation sống tới đâu “Without RUNTIME retention, reflection returns null.”
meta-annotation /ˌmet.ə æn.əˈteɪ.ʃən/ annotation đặt trên annotation “@RestController is composed from meta-annotations.”
annotation processor /ˌæn.əˈteɪ.ʃən ˈprɑː.ses.ɚ/ plugin của javac sinh code “MapStruct is an annotation processor that generates mapper classes.”
processing round /ˈprɑː.ses.ɪŋ raʊnd/ một vòng xử lý của processor “Generated sources are compiled in the next processing round.”
generated sources /ˈdʒen.ə.reɪ.t̬ɪd ˈsɔːr.sɪz/ code do máy sinh “We never commit generated sources; the build recreates them.”
self-invocation /self ˌɪn.vəˈkeɪ.ʃən/ gọi method khác trong cùng object “Self-invocation bypasses the proxy, so the advice doesn’t run.”

Ghi chép tự tổng hợp từ tài liệu chính thức và kinh nghiệm thực tế.