어노테이션 프로세싱 — Lombok은 어떻게 동작하는가

소스코드(.java) → [어노테이션 프로세싱] → 추가 소스 생성 → [컴파일] → 바이트코드(.class)

// SOURCE: 컴파일러만 보고 버린다
@Retention(RetentionPolicy.SOURCE)
public @interface MySourceAnnotation {}

// RUNTIME: 런타임에 리플렉션으로 읽을 수 있다
@Retention(RetentionPolicy.RUNTIME)
public @interface MyRuntimeAnnotation {}

@Target({ElementType.TYPE, ElementType.METHOD})
public @interface MyAnnotation {}

// @Repeatable 예시
@Repeatable(Schedules.class)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Schedule {
    String cron();
}

// 컨테이너 어노테이션
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Schedules {
    Schedule[] value();
}

// 사용
@Schedule(cron = "0 0 * * *")
@Schedule(cron = "0 12 * * *")
public void doWork() {}

@SupportedAnnotationTypes("com.example.MyAnnotation")
@SupportedSourceVersion(SourceVersion.RELEASE_17)
public class MyProcessor extends AbstractProcessor {

    @Override
    public boolean process(Set<? extends TypeElement> annotations,
                           RoundEnvironment roundEnv) {
        // 어노테이션이 붙은 요소들을 순회
        for (Element element : roundEnv.getElementsAnnotatedWith(MyAnnotation.class)) {
            // element의 정보를 읽어서 새 소스 파일 생성
            String className = element.getSimpleName().toString();
            processingEnv.getMessager()
                .printMessage(Diagnostic.Kind.NOTE,
                    "처리 중: " + className);
        }
        return true; // true: 이 어노테이션을 다음 프로세서에 넘기지 않음
    }
}

@Override
public boolean process(Set<? extends TypeElement> annotations,
                       RoundEnvironment roundEnv) {
    for (Element element : roundEnv.getElementsAnnotatedWith(MyAnnotation.class)) {
        String packageName = processingEnv.getElementUtils()
            .getPackageOf(element).getQualifiedName().toString();
        String className = element.getSimpleName() + "Generated";

        try {
            // Filer를 통해 새 소스 파일 생성
            JavaFileObject file = processingEnv.getFiler()
                .createSourceFile(packageName + "." + className);

            try (Writer writer = file.openWriter()) {
                writer.write("package " + packageName + ";\n\n");
                writer.write("// 자동 생성된 클래스\n");
                writer.write("public class " + className + " {\n");
                writer.write("    public String info() {\n");
                writer.write("        return \"" + element.getSimpleName()
                    + "에서 생성됨\";\n");
                writer.write("    }\n");
                writer.write("}\n");
            }
        } catch (IOException e) {
            processingEnv.getMessager()
                .printMessage(Diagnostic.Kind.ERROR,
                    "파일 생성 실패: " + e.getMessage());
        }
    }
    return true;
}

src/main/resources/
└── META-INF/
    └── services/
        └── javax.annotation.processing.Processor

com.example.MyProcessor

// auto-service 사용 시
@AutoService(Processor.class)
public class MyProcessor extends AbstractProcessor {
    // ...
}

[일반 프로세서]
소스코드 → 파싱 → AST → 프로세서(새 파일 생성) → 컴파일

[Lombok]
소스코드 → 파싱 → AST → Lombok(AST 직접 수정!) → 컴파일

// 우리가 작성하는 코드
@Getter
public class User {
    private String name;
    private int age;
}

// Lombok이 AST 조작 후 컴파일되는 결과 (실제로 소스 파일이 변하진 않음)
public class User {
    private String name;
    private int age;

    public String getName() { return this.name; }
    public int getAge() { return this.age; }
}

// 매퍼 인터페이스 정의
@Mapper
public interface UserMapper {
    UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);

    // User → UserDto 변환
    @Mapping(source = "name", target = "userName")
    UserDto toDto(User user);
}

// MapStruct가 자동 생성하는 구현체
@Generated
public class UserMapperImpl implements UserMapper {
    @Override
    public UserDto toDto(User user) {
        if (user == null) {
            return null;
        }
        UserDto userDto = new UserDto();
        userDto.setUserName(user.getName()); // 매핑 규칙 적용
        userDto.setAge(user.getAge());
        return userDto;
    }
}

@Retention(RetentionPolicy.RUNTIME)  // 런타임에 리플렉션으로 읽어야 함
@Target(ElementType.METHOD)          // 메서드에만 사용
@Documented
public @interface MeasureTime {
    String value() default "";  // 선택적으로 설명 추가
}

@Aspect
@Component
public class MeasureTimeAspect {

    private static final Logger log = LoggerFactory.getLogger(MeasureTimeAspect.class);

    @Around("@annotation(measureTime)")
    public Object measure(ProceedingJoinPoint joinPoint,
                          MeasureTime measureTime) throws Throwable {
        long start = System.nanoTime();

        try {
            return joinPoint.proceed();
        } finally {
            long elapsed = System.nanoTime() - start;
            String label = measureTime.value().isEmpty()
                ? joinPoint.getSignature().getName()
                : measureTime.value();
            // 실행 시간 로그 출력
            log.info("[{}] 실행 시간: {}ms", label, elapsed / 1_000_000.0);
        }
    }
}

@Service
public class UserService {

    @MeasureTime("사용자 조회")
    public User findById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException(id));
    }
}

// 리플렉션: 런타임에 매번 메타데이터 조회
Method method = clazz.getMethod("getName");
Object result = method.invoke(instance); // 매 호출마다 비용

// 어노테이션 프로세싱: 컴파일 타임에 코드 생성, 런타임엔 일반 메서드 호출
String result = instance.getName(); // 직접 호출, 오버헤드 없음

// JPA 엔티티에서 @Data 대신 필요한 것만 사용
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
public class User {
    @Id @GeneratedValue
    private Long id;
    private String name;

    @Builder
    public User(String name) {
        this.name = name;
    }
    // @Data는 피한다 — equals/hashCode 자동 생성이 JPA와 충돌 가능
}

1. javac 시작
2. 소스 코드 파싱 → AST 생성
3. 어노테이션 프로세싱 라운드 시작
   ├─ [표준 프로세서] 새 소스 파일 생성 (Filer API)
   └─ [Lombok] AST 직접 수정 (내부 API)
4. 새 소스가 생성됐으면 → 다시 3번으로 (다음 라운드)
5. 더 이상 새 소스 없으면 → 최종 컴파일
6. 바이트코드(.class) 생성 완료