빌드 타임 처리와 ArC — Quarkus가 빠른 진짜 이유

[애플리케이션 시작 시]
1. ClassPathBeanDefinitionScanner가 모든 클래스를 스캔
2. 각 클래스의 어노테이션을 리플렉션으로 읽기
3. BeanDefinition 생성 및 등록
4. 의존성 그래프 구성
5. CGLIB으로 프록시 바이트코드 동적 생성
6. 빈 인스턴스 생성 및 주입
→ 이 모든 과정이 매 시작마다 반복됨

// Spring에서 런타임에 일어나는 일 (의사 코드)
for (Class<?> clazz : classPathScanner.scan("com.example")) {
    // 리플렉션으로 어노테이션 확인
    if (clazz.isAnnotationPresent(Component.class)) {
        // BeanDefinition 생성
        BeanDefinition bd = new GenericBeanDefinition();
        bd.setBeanClass(clazz);

        // 의존성 분석 (생성자/필드/세터의 파라미터 타입 확인)
        for (Constructor<?> ctor : clazz.getDeclaredConstructors()) {
            // 리플렉션으로 파라미터 타입 확인
        }

        registry.registerBeanDefinition(name, bd);
    }
}

[빌드 시]
1. Jandex 인덱스로 모든 클래스 메타데이터 수집 (리플렉션 불필요)
2. 빈 디스커버리 및 의존성 그래프 구성
3. Gizmo로 바이트코드 직접 생성 (프록시, 빈 생성 코드)
4. 미사용 빈 자동 제거
5. 결과물을 바이트코드로 출력

[애플리케이션 시작 시]
1. 미리 생성된 코드 실행 → 끝

[전통 방식: java.lang.reflect]
Class.forName("com.example.UserService")  ← 클래스 로딩 필요
  → class.getAnnotations()                ← 리플렉션 호출
  → class.getDeclaredFields()             ← 리플렉션 호출
  → field.getType()                       ← 리플렉션 호출

[ArC 방식: Jandex]
jandexIndex.getClassByName("com.example.UserService")  ← 파일에서 직접 읽음
  → classInfo.annotations()                             ← 인덱스 조회
  → classInfo.fields()                                  ← 인덱스 조회

// Spring: 런타임에 CGLIB으로 프록시 생성
// → 시작할 때마다 바이트코드를 동적으로 만듦
@Service
public class UserService {
    @Transactional
    public void createUser(User user) {
        // ...
    }
}
// Spring은 이 클래스의 CGLIB 프록시를 런타임에 생성

// ArC: 빌드 타임에 Gizmo로 바이트코드 생성
// → 빌드 결과물에 이미 프록시 클래스가 포함되어 있음

// ArC가 빌드 시 생성하는 코드 (개념적 표현)
public class UserService_Bean implements InjectableBean<UserService> {

    @Override
    public UserService create(CreationalContext<UserService> ctx) {
        // 리플렉션 없이 직접 생성자 호출
        UserRepository repo = Arc.container()
            .instance(UserRepository.class).get();
        return new UserService(repo);
    }

    @Override
    public void destroy(UserService instance, CreationalContext<UserService> ctx) {
        // 정리 코드
    }
}

@ApplicationScoped
public class EmailService {
    // 어디에서도 @Inject하지 않으면 빌드 결과물에서 제거됨
}

@ApplicationScoped
public class UserService {
    @Inject
    UserRepository userRepository;  // 이것만 포함됨
}

@ApplicationScoped
@Unremovable  // ArC가 제거하지 않음
public class PluginService {
    // CDI.current().select()로 동적 룩업될 수 있음
}

// Spring에서는 애플리케이션을 시작해봐야 알 수 있는 에러들
@Service
public class OrderService {
    @Autowired
    private PaymentService paymentService;  // PaymentService 빈이 없으면?
    // → 시작할 때 NoSuchBeanDefinitionException
}

[빌드 출력]
BUILD FAILURE

Unsatisfied dependency for type PaymentService and qualifiers [@Default]
  - injection target: OrderService#paymentService
  - declared on: com.example.OrderService

Build step io.quarkus.arc.deployment.ArcProcessor#validate threw an exception

[Native Image가 싫어하는 것들]
- Class.forName("동적 클래스명")
- Constructor.newInstance()
- Field.set()
- Proxy.newProxyInstance()
- 동적 클래스 로딩

[ArC가 이것들을 빌드 타임에 제거]
- 리플렉션 → Gizmo 바이트코드로 대체
- 동적 프록시 → 빌드 시 생성된 서브클래스로 대체
- 클래스 스캐닝 → Jandex 인덱스로 대체

// Quarkus 확장의 Build Step (프레임워크 개발자가 작성)
public class MyExtensionProcessor {

    @BuildStep
    BeanDefiningAnnotationBuildItem registerBeans() {
        // 빌드 시: 어떤 어노테이션을 빈으로 인식할지 등록
        return new BeanDefiningAnnotationBuildItem(
            DotName.createSimple("com.example.MyBean"));
    }

    @BuildStep
    void configureRuntime(BuildProducer<GeneratedClassBuildItem> generatedClasses) {
        // 빌드 시: 런타임에 필요한 클래스를 Gizmo로 생성
    }

    @BuildStep
    @Record(ExecutionTime.RUNTIME_INIT)
    void setupAtRuntime(MyRecorder recorder) {
        // 빌드 시: 런타임 초기화 코드를 레코딩
        recorder.initialize();
    }
}

[Quarkus 빌드 파이프라인]

소스 코드 + 의존성
     │
     ▼
① Jandex 인덱싱 (모든 클래스 메타데이터 수집)
     │
     ▼
② Build Step 실행 (각 확장의 @BuildStep 순서대로)
     │
     ├── ArC: 빈 디스커버리, 의존성 그래프 구성, 프록시 생성
     ├── RESTEasy: 엔드포인트 스캔, 라우팅 테이블 구성
     ├── Hibernate: 엔티티 스캔, 메타모델 생성
     └── ...
     │
     ▼
③ Gizmo 바이트코드 생성 (런타임용 코드 출력)
     │
     ▼
④ 결과물: 최적화된 JAR 또는 Native 바이너리

quarkus dev
# 브라우저에서 http://localhost:8080/q/dev-ui/arc/beans 접속

# application.properties
quarkus.arc.remove-unused-beans=true
quarkus.log.category."io.quarkus.arc".level=DEBUG

// 지원하는 스코프
@ApplicationScoped  // 앱 전체에서 하나 (가장 많이 사용)
@RequestScoped      // HTTP 요청마다 하나
@SessionScoped      // HTTP 세션마다 하나
@Dependent          // 주입 지점마다 새로 생성
@Singleton          // @ApplicationScoped와 비슷하지만 프록시 없음

@ApplicationScoped
public class ServiceA {
    // 프록시 객체가 생성됨 → 지연 초기화 가능
    // 실제 인스턴스는 첫 호출 시 생성
}

@Singleton
public class ServiceB {
    // 프록시 없이 실제 인스턴스가 직접 주입됨
    // 시작 시점에 생성
}

[JVM JAR 빌드]
Spring Boot: ~10초
Quarkus:     ~15초  (빌드 스텝 처리 때문에 약간 더 김)

[Native 빌드]
Spring Boot Native: 3~8분
Quarkus Native:     2~5분  (조금 더 빠르지만 여전히 오래 걸림)

// 이런 코드는 Native 모드에서 문제가 됨
Object service = Class.forName(className).getDeclaredConstructor().newInstance();

// 해결: @RegisterForReflection 어노테이션 사용
@RegisterForReflection
public class MyDto {
    private String name;
    private int age;
}

[문제 발생 시 디버깅 흐름]
Spring: 스택 트레이스 → 소스 코드에서 직접 확인 가능
ArC:    스택 트레이스 → 생성된 바이트코드 → 원래 의도를 역추적

// Spring에서는 가능한 패턴
@ConditionalOnProperty(name = "feature.enabled", havingValue = "true")
@Service
public class FeatureService {
    // 프로퍼티 값에 따라 런타임에 빈 등록 여부 결정
}

// Quarkus에서는 빌드 시 결정됨
// 런타임에 프로퍼티를 바꿔도 빈 등록은 변하지 않음