리플렉션 — Class 객체와 동적 프록시 이해하기

컴파일 타임                    런타임
┌─────────────┐          ┌──────────────────────┐
│ new Foo()   │          │ Class.forName("Foo") │
│ foo.bar()   │          │ method.invoke(obj)   │
│ → 타입 확정  │          │ → 문자열로 타입 결정    │
└─────────────┘          └──────────────────────┘

// 1. Class.forName() — 문자열로 클래스 로드 (JDBC 드라이버 로딩에서 많이 봤을 것)
Class<?> clazz1 = Class.forName("java.util.ArrayList");

// 2. .class 리터럴 — 컴파일 타임에 타입을 알 때
Class<ArrayList> clazz2 = ArrayList.class;

// 3. getClass() — 이미 인스턴스가 있을 때
ArrayList<String> list = new ArrayList<>();
Class<?> clazz3 = list.getClass();

Class<?> clazz = Class.forName("com.example.User");

// 기본 생성자로 인스턴스 생성
Constructor<?> constructor = clazz.getDeclaredConstructor();
Object user = constructor.newInstance();

// 매개변수 있는 생성자
Constructor<?> paramCtor = clazz.getDeclaredConstructor(String.class, int.class);
Object user2 = paramCtor.newInstance("홍길동", 25);

// public 메서드 (상속 포함)
Method getName = clazz.getMethod("getName");
Object result = getName.invoke(user); // user.getName() 호출과 동일

// private 메서드 포함 (해당 클래스에 선언된 것만)
Method secret = clazz.getDeclaredMethod("secretMethod");
secret.setAccessible(true); // private 접근 허용
secret.invoke(user);

// private 필드 접근
Field nameField = clazz.getDeclaredField("name");
nameField.setAccessible(true); // 접근 제어자 무시

// 값 읽기
String name = (String) nameField.get(user);

// 값 쓰기
nameField.set(user, "이순신");

public class Secret {
    private String password = "1234"; // 외부에서 접근 불가... 라고 생각했지만
}

// 리플렉션으로 뚫기
Secret secret = new Secret();
Field pwField = Secret.class.getDeclaredField("password");
pwField.setAccessible(true);
String pw = (String) pwField.get(secret); // "1234" 가져올 수 있다

# 모듈 시스템에서 리플렉션 접근을 열어주는 옵션
java --add-opens java.base/java.lang=ALL-UNNAMED -jar app.jar

// 대상 인터페이스
public interface UserService {
    String findUser(Long id);
    void deleteUser(Long id);
}

// 실제 구현체
public class UserServiceImpl implements UserService {
    @Override
    public String findUser(Long id) {
        return "User-" + id;
    }

    @Override
    public void deleteUser(Long id) {
        System.out.println(id + "번 유저 삭제");
    }
}

// InvocationHandler — 모든 메서드 호출을 가로채서 로깅 추가
public class LoggingHandler implements InvocationHandler {
    private final Object target; // 실제 객체

    public LoggingHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 메서드 실행 전 로깅
        System.out.println("[LOG] " + method.getName() + " 호출, 인자: " + Arrays.toString(args));

        long start = System.nanoTime();
        Object result = method.invoke(target, args); // 실제 메서드 실행
        long elapsed = System.nanoTime() - start;

        // 메서드 실행 후 로깅
        System.out.println("[LOG] " + method.getName() + " 완료, 소요: " + elapsed + "ns");
        return result;
    }
}

// 프록시 생성 및 사용
UserService real = new UserServiceImpl();
UserService proxy = (UserService) Proxy.newProxyInstance(
    UserService.class.getClassLoader(),   // 클래스 로더
    new Class[]{UserService.class},        // 구현할 인터페이스 배열
    new LoggingHandler(real)               // 호출 핸들러
);

proxy.findUser(1L);
// [LOG] findUser 호출, 인자: [1]
// [LOG] findUser 완료, 소요: 12345ns

클라이언트 → proxy.findUser(1L)
                ↓
        Proxy 객체 (런타임 생성)
                ↓
        InvocationHandler.invoke()
                ↓
        ┌── 전처리 (로깅, 트랜잭션 시작 등) ──┐
        │   method.invoke(target, args)       │  ← 실제 메서드 실행
        └── 후처리 (로깅, 트랜잭션 커밋 등) ──┘
                ↓
        결과 반환

@Service
public class OrderService {
    @Autowired
    private UserRepository userRepository; // Spring이 리플렉션으로 값을 주입
}

// Spring이 내부적으로 하는 일 (단순화)
for (Field field : clazz.getDeclaredFields()) {
    if (field.isAnnotationPresent(Autowired.class)) {
        field.setAccessible(true);
        Object bean = beanFactory.getBean(field.getType()); // 컨테이너에서 빈 조회
        field.set(instance, bean); // 리플렉션으로 필드에 주입
    }
}

// 일반 호출 — JIT가 인라인 가능
user.getName();

// 리플렉션 — JIT 최적화 어려움
Method m = User.class.getMethod("getName");
m.invoke(user); // invoke 내부에서 네이티브 코드 호출

// 오타가 있어도 컴파일은 통과한다
Method m = clazz.getMethod("getNamee"); // 런타임에 NoSuchMethodException

// MethodHandle로 메서드 호출
MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodHandle handle = lookup.findVirtual(
    String.class, "substring",
    MethodType.methodType(String.class, int.class)
);
String result = (String) handle.invoke("Hello World", 6); // "World"

import java.lang.annotation.*;

// 빈으로 등록할 클래스에 붙이는 어노테이션
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyComponent {}

// 의존성 주입 대상 필드에 붙이는 어노테이션
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface MyInject {}

import java.lang.reflect.*;
import java.util.*;

public class MiniContainer {
    // 빈 저장소: 타입 → 인스턴스
    private final Map<Class<?>, Object> beans = new HashMap<>();

    // 1단계: 클래스 등록 및 인스턴스 생성
    public void register(Class<?>... classes) throws Exception {
        for (Class<?> clazz : classes) {
            if (clazz.isAnnotationPresent(MyComponent.class)) {
                // 기본 생성자로 인스턴스 생성
                Constructor<?> ctor = clazz.getDeclaredConstructor();
                ctor.setAccessible(true);
                Object instance = ctor.newInstance();
                beans.put(clazz, instance);
            }
        }
    }

    // 2단계: @MyInject 필드에 의존성 주입
    public void inject() throws Exception {
        for (Object bean : beans.values()) {
            for (Field field : bean.getClass().getDeclaredFields()) {
                if (field.isAnnotationPresent(MyInject.class)) {
                    field.setAccessible(true);
                    // 필드 타입에 맞는 빈을 찾아서 주입
                    Object dependency = findBean(field.getType());
                    if (dependency != null) {
                        field.set(bean, dependency);
                    }
                }
            }
        }
    }

    // 타입 또는 구현체 기준으로 빈 검색
    private Object findBean(Class<?> type) {
        for (Map.Entry<Class<?>, Object> entry : beans.entrySet()) {
            if (type.isAssignableFrom(entry.getKey())) {
                return entry.getValue();
            }
        }
        return null;
    }

    // 빈 조회
    @SuppressWarnings("unchecked")
    public <T> T getBean(Class<T> type) {
        return (T) findBean(type);
    }
}

@MyComponent
public class UserRepository {
    public String findById(Long id) {
        return "User-" + id;
    }
}

@MyComponent
public class UserService {
    @MyInject
    private UserRepository userRepository; // 컨테이너가 자동 주입

    public String getUser(Long id) {
        return userRepository.findById(id);
    }
}

// 컨테이너 실행
public class Main {
    public static void main(String[] args) throws Exception {
        MiniContainer container = new MiniContainer();

        // 빈 등록
        container.register(UserRepository.class, UserService.class);

        // 의존성 주입
        container.inject();

        // 사용
        UserService service = container.getBean(UserService.class);
        System.out.println(service.getUser(1L)); // "User-1"
    }
}