야 진짜 자바로 코딩하다 보면 ㅋㅋㅋ 가끔 이런 생각 안 들어? "아 이 클래스가 어떤 메서드 가지고 있는지 실행 중에 알 수 있으면 좋겠다" 또는 "어노테이션 하나 붙이면 자동으로 뭔가 처리되면 개꿀인데" 같은 거 말이야 😎

그게 바로 리플렉션(Reflection)이랑 어노테이션(Annotation)을 활용한 메타프로그래밍이야! 메타프로그래밍이라는 게 뭐냐면, 프로그램이 자기 자신이나 다른 프로그램을 데이터처럼 다루는 기법이거든. 쉽게 말해서 코드가 코드를 조작하는 거지 ㅇㅇ

스프링 프레임워크 써봤으면 알겠지만, @Autowired, @Component 이런 거 붙이면 마법처럼 의존성 주입되고 빈 등록되잖아? 그게 다 리플렉션이랑 어노테이션 덕분이야. JPA에서 @Entity 붙이면 자동으로 테이블 매핑되는 것도 마찬가지고 💡

🔍 리플렉션이 뭔데? 왜 필요한데?

리플렉션은 런타임에 클래스의 구조를 분석하고 조작할 수 있는 기능이야. 보통 자바는 컴파일 타임에 타입이 결정되는 정적 언어잖아? 근데 리플렉션을 쓰면 실행 중에 "아 이 클래스 어떤 메서드 있지?" "이 필드 값 뭐지?" 이런 걸 알아낼 수 있어 ㅋㅋ

진짜 신기한 게, 클래스 이름만 문자열로 알고 있어도 그 클래스의 인스턴스를 만들 수 있고, private 필드에도 접근할 수 있거든? 물론 보안 문제 때문에 조심해야 하지만 말이야 🔐

Class 객체 얻기

리플렉션의 시작은 Class 객체를 얻는 거야. 방법이 세 가지 있어:

// 방법 1: .class 리터럴 사용
Class<String> clazz1 = String.class;

// 방법 2: 인스턴스의 getClass() 메서드
String str = "Hello";
Class<? extends String> clazz2 = str.getClass();

// 방법 3: Class.forName() - 문자열로 클래스 이름 전달
try {
    Class<?> clazz3 = Class.forName("java.lang.String");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

세 번째 방법이 진짜 메타프로그래밍스러운 거지 ㅋㅋ 클래스 이름을 문자열로 받아서 동적으로 로딩할 수 있거든. 설정 파일에서 클래스 이름 읽어와서 인스턴스 생성하는 식으로 쓸 수 있어 👍

클래스 정보 조회하기

Class 객체를 얻었으면 이제 그 클래스에 대한 온갖 정보를 뽑아낼 수 있어:

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void introduce() {
        System.out.println("이름: " + name + ", 나이: " + age);
    }
    
    private void secretMethod() {
        System.out.println("비밀 메서드!");
    }
}

// 리플렉션으로 정보 조회
Class<Person> personClass = Person.class;

// 모든 public 메서드 가져오기
Method[] methods = personClass.getMethods();
for (Method method : methods) {
    System.out.println("메서드: " + method.getName());
}

// 선언된 모든 메서드 가져오기 (private 포함)
Method[] declaredMethods = personClass.getDeclaredMethods();

// 모든 필드 가져오기
Field[] fields = personClass.getDeclaredFields();
for (Field field : fields) {
    System.out.println("필드: " + field.getName() + ", 타입: " + field.getType());
}

// 생성자 정보
Constructor<?>[] constructors = personClass.getConstructors();

동적으로 인스턴스 생성하기

이게 진짜 신기한 부분인데 ㅋㅋ 클래스 이름만 알면 인스턴스를 만들 수 있어:

try {
    // 기본 생성자로 인스턴스 생성
    Class<?> clazz = Class.forName("com.example.Person");
    Object instance = clazz.getDeclaredConstructor().newInstance();
    
    // 파라미터 있는 생성자로 생성
    Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
    Object person = constructor.newInstance("홍길동", 25);
    
} catch (Exception e) {
    e.printStackTrace();
}

스프링 같은 프레임워크가 설정 파일 읽어서 빈 객체 생성할 때 이런 방식을 쓰는 거야. XML이나 어노테이션에서 클래스 정보 읽어와서 인스턴스 만드는 거지 🏗️

메서드 동적 호출

메서드 이름을 문자열로 받아서 실행할 수도 있어. 이것도 완전 신기함 ㅋㅋㅋ

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public int multiply(int a, int b) {
        return a * b;
    }
}

// 리플렉션으로 메서드 호출
try {
    Calculator calc = new Calculator();
    Class<?> clazz = calc.getClass();
    
    // add 메서드 가져오기
    Method addMethod = clazz.getMethod("add", int.class, int.class);
    
    // 메서드 실행
    Object result = addMethod.invoke(calc, 10, 20);
    System.out.println("결과: " + result); // 30
    
    // 메서드 이름을 변수로 받아서 실행
    String methodName = "multiply"; // 설정 파일이나 사용자 입력에서 받았다고 가정
    Method method = clazz.getMethod(methodName, int.class, int.class);
    Object result2 = method.invoke(calc, 5, 6);
    System.out.println("결과: " + result2); // 30
    
} catch (Exception e) {
    e.printStackTrace();
}

invoke() 메서드의 첫 번째 파라미터는 메서드를 실행할 객체 인스턴스고, 나머지는 메서드의 파라미터들이야. static 메서드면 첫 번째 파라미터에 null 넣으면 돼 ㅇㅇ

필드 값 접근 및 수정

private 필드에도 접근할 수 있어. 물론 setAccessible(true)를 호출해야 하지만 말이야:

public class User {
    private String password = "secret123";
    
    public String getPassword() {
        return "****"; // 보안상 가려서 반환
    }
}

// 리플렉션으로 private 필드 접근
try {
    User user = new User();
    Class<?> clazz = user.getClass();
    
    // private 필드 가져오기
    Field passwordField = clazz.getDeclaredField("password");
    
    // 접근 가능하도록 설정 (중요!)
    passwordField.setAccessible(true);
    
    // 필드 값 읽기
    String password = (String) passwordField.get(user);
    System.out.println("실제 비밀번호: " + password); // secret123
    
    // 필드 값 수정
    passwordField.set(user, "newPassword456");
    System.out.println("변경된 비밀번호: " + passwordField.get(user));
    
} catch (Exception e) {
    e.printStackTrace();
}

📝 어노테이션 완전 정복

어노테이션은 코드에 메타데이터를 추가하는 방법이야. @ 기호로 시작하는 거 많이 봤을 거야. @Override, @Deprecated 같은 거 말이지 📌

어노테이션 자체는 아무 기능도 없어. 그냥 "이 코드는 이런 특성을 가지고 있어요~" 하고 표시만 하는 거지. 실제 기능은 어노테이션을 읽어서 처리하는 코드가 따로 있어야 해. 그게 바로 리플렉션이랑 만나는 지점이야 ✨

기본 어노테이션 종류

자바에서 기본으로 제공하는 어노테이션들이 있어:

커스텀 어노테이션 만들기

진짜 재미있는 건 직접 어노테이션을 만드는 거야 ㅋㅋ @interface 키워드를 사용해:

// 간단한 마커 어노테이션
public @interface MyAnnotation {
}

// 값을 가지는 어노테이션
public @interface Author {
    String name();
    String date();
    int version() default 1; // 기본값 설정 가능
}

// 사용 예시
@Author(name = "홍길동", date = "2024-01-15", version = 2)
public class MyClass {
    // ...
}

어노테이션 요소는 메서드처럼 선언하는데, 실제로는 속성처럼 동작해. 파라미터는 없고 반환 타입만 있지. 기본값은 default 키워드로 지정할 수 있어 👌

메타 어노테이션 - 어노테이션의 어노테이션

어노테이션을 정의할 때 붙이는 어노테이션이 있어. 이걸 메타 어노테이션이라고 해 ㅋㅋ 말이 좀 복잡한데 그냥 "어노테이션의 동작 방식을 설정하는 어노테이션"이라고 생각하면 돼:

import java.lang.annotation.*;

@Target(ElementType.METHOD) // 어디에 붙일 수 있는지
@Retention(RetentionPolicy.RUNTIME) // 언제까지 유지되는지
@Documented // javadoc에 포함할지
@Inherited // 상속 가능한지
public @interface MyAnnotation {
    String value();
}

리플렉션으로 어노테이션 정보를 읽으려면 반드시 @Retention(RetentionPolicy.RUNTIME)을 붙여야 해! 이거 안 붙이면 런타임에 어노테이션 정보가 없어서 읽을 수가 없거든 ㅠㅠ

실전 예제: 유효성 검사 어노테이션

진짜 실무에서 쓸 만한 예제를 만들어볼게. 필드 값 검증하는 어노테이션이야:

// 1. 어노테이션 정의
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NotNull {
    String message() default "값이 null일 수 없습니다";
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MinLength {
    int value();
    String message() default "최소 길이를 만족하지 않습니다";
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Email {
    String message() default "올바른 이메일 형식이 아닙니다";
}

// 2. 사용할 클래스
public class UserDto {
    @NotNull(message = "이름은 필수입니다")
    @MinLength(value = 2, message = "이름은 최소 2글자 이상이어야 합니다")
    private String name;
    
    @NotNull
    @Email
    private String email;
    
    @NotNull
    @MinLength(8)
    private String password;
    
    // 생성자, getter, setter
    public UserDto(String name, String email, String password) {
        this.name = name;
        this.email = email;
        this.password = password;
    }
    
    public String getName() { return name; }
    public String getEmail() { return email; }
    public String getPassword() { return password; }
}

// 3. 검증 로직 (리플렉션 활용)
public class Validator {
    
    public static void validate(Object obj) throws Exception {
        Class<?> clazz = obj.getClass();
        Field[] fields = clazz.getDeclaredFields();
        
        for (Field field : fields) {
            field.setAccessible(true);
            Object value = field.get(obj);
            
            // @NotNull 검증
            if (field.isAnnotationPresent(NotNull.class)) {
                if (value == null) {
                    NotNull annotation = field.getAnnotation(NotNull.class);
                    throw new Exception(field.getName() + ": " + annotation.message());
                }
            }
            
            // @MinLength 검증
            if (field.isAnnotationPresent(MinLength.class)) {
                MinLength annotation = field.getAnnotation(MinLength.class);
                if (value != null && value instanceof String) {
                    String strValue = (String) value;
                    if (strValue.length() < annotation.value()) {
                        throw new Exception(field.getName() + ": " + annotation.message());
                    }
                }
            }
            
            // @Email 검증
            if (field.isAnnotationPresent(Email.class)) {
                Email annotation = field.getAnnotation(Email.class);
                if (value != null && value instanceof String) {
                    String strValue = (String) value;
                    if (!strValue.matches("^[A-Za-z0-9+_.-]+@(.+)$")) {
                        throw new Exception(field.getName() + ": " + annotation.message());
                    }
                }
            }
        }
    }
}

// 4. 사용 예시
public class Main {
    public static void main(String[] args) {
        // 정상 케이스
        UserDto user1 = new UserDto("홍길동", "hong@example.com", "password123");
        try {
            Validator.validate(user1);
            System.out.println("검증 성공!");
        } catch (Exception e) {
            System.out.println("검증 실패: " + e.getMessage());
        }
        
        // 실패 케이스 1: 이름이 너무 짧음
        UserDto user2 = new UserDto("홍", "hong@example.com", "password123");
        try {
            Validator.validate(user2);
        } catch (Exception e) {
            System.out.println("검증 실패: " + e.getMessage());
            // 출력: 검증 실패: name: 이름은 최소 2글자 이상이어야 합니다
        }
        
        // 실패 케이스 2: 잘못된 이메일
        UserDto user3 = new UserDto("홍길동", "잘못된이메일", "password123");
        try {
            Validator.validate(user3);
        } catch (Exception e) {
            System.out.println("검증 실패: " + e.getMessage());
            // 출력: 검증 실패: email: 올바른 이메일 형식이 아닙니다
        }
    }
}

이렇게 하면 어노테이션만 붙이면 자동으로 검증이 되는 거지 ㅋㅋ 스프링의 @Valid나 하이버네이트 Validator가 이런 방식으로 동작해. 코드 중복도 줄이고 가독성도 좋아지고 일석이조야 🎯

🚀 실전 프로젝트: 간단한 DI 컨테이너 만들기

이제 진짜 실전이야 ㅋㅋ 스프링처럼 의존성 주입을 자동으로 해주는 미니 프레임워크를 만들어볼 거야. 리플렉션이랑 어노테이션을 둘 다 활용하는 프로젝트지 💪

목표는 @Component 어노테이션이 붙은 클래스를 자동으로 찾아서 인스턴스를 만들고, @Autowired가 붙은 필드에 자동으로 주입하는 거야. 완전 간단 버전이지만 원리는 똑같아!

1단계: 어노테이션 정의

import java.lang.annotation.*;

// 컴포넌트로 등록할 클래스에 붙이는 어노테이션
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
    String value() default ""; // 빈 이름 (선택)
}

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

2단계: 사용할 클래스들 작성

// 서비스 인터페이스
public interface UserService {
    void printUser();
}

// 서비스 구현체
@Component
public class UserServiceImpl implements UserService {
    @Override
    public void printUser() {
        System.out.println("사용자 정보 출력!");
    }
}

// 리포지토리
@Component
public class UserRepository {
    public void save() {
        System.out.println("사용자 저장 완료!");
    }
}

// 컨트롤러
@Component
public class UserController {
    @Autowired
    private UserService userService;
    
    @Autowired
    private UserRepository userRepository;
    
    public void handleRequest() {
        System.out.println("=== 요청 처리 시작 ===");
        userService.printUser();
        userRepository.save();
        System.out.println("=== 요청 처리 완료 ===");
    }
}

3단계: DI 컨테이너 구현

import java.io.File;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.*;

public class SimpleContainer {
    // 빈 저장소 (싱글톤 패턴)
    private Map<Class<?>, Object> beans = new HashMap<>();
    
    // 컨테이너 초기화
    public void initialize(String basePackage) throws Exception {
        // 1. 패키지 스캔해서 @Component 붙은 클래스 찾기
        List<Class<?>> componentClasses = scanComponents(basePackage);
        
        // 2. 찾은 클래스들의 인스턴스 생성
        for (Class<?> clazz : componentClasses) {
            Object instance = clazz.getDeclaredConstructor().newInstance();
            beans.put(clazz, instance);
            
            // 인터페이스도 등록 (인터페이스로 주입받을 수 있게)
            Class<?>[] interfaces = clazz.getInterfaces();
            for (Class<?> interfaceClass : interfaces) {
                beans.put(interfaceClass, instance);
            }
            
            System.out.println("빈 등록: " + clazz.getSimpleName());
        }
        
        // 3. 의존성 주입 (@Autowired 처리)
        for (Object bean : beans.values()) {
            injectDependencies(bean);
        }
    }
    
    // 패키지 스캔
    private List<Class<?>> scanComponents(String basePackage) throws Exception {
        List<Class<?>> components = new ArrayList<>();
        
        // 패키지 경로를 파일 경로로 변환
        String path = basePackage.replace('.', '/');
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        URL resource = classLoader.getResource(path);
        
        if (resource == null) {
            return components;
        }
        
        File directory = new File(resource.getFile());
        
        // 디렉토리 내 모든 .class 파일 찾기
        if (directory.exists()) {
            findClasses(directory, basePackage, components);
        }
        
        return components;
    }
    
    // 재귀적으로 클래스 파일 찾기
    private void findClasses(File directory, String packageName, 
                            List<Class<?>> components) throws Exception {
        File[] files = directory.listFiles();
        
        if (files == null) {
            return;
        }
        
        for (File file : files) {
            if (file.isDirectory()) {
                findClasses(file, packageName + "." + file.getName(), components);
            } else if (file.getName().endsWith(".class")) {
                String className = packageName + "." + 
                                  file.getName().substring(0, file.getName().length() - 6);
                Class<?> clazz = Class.forName(className);
                
                // @Component 어노테이션이 있는지 확인
                if (clazz.isAnnotationPresent(Component.class)) {
                    components.add(clazz);
                }
            }
        }
    }
    
    // 의존성 주입
    private void injectDependencies(Object bean) throws Exception {
        Class<?> clazz = bean.getClass();
        Field[] fields = clazz.getDeclaredFields();
        
        for (Field field : fields) {
            // @Autowired가 붙은 필드 찾기
            if (field.isAnnotationPresent(Autowired.class)) {
                Class<?> fieldType = field.getType();
                Object dependency = beans.get(fieldType);
                
                if (dependency != null) {
                    field.setAccessible(true);
                    field.set(bean, dependency);
                    System.out.println("의존성 주입: " + clazz.getSimpleName() + 
                                     "." + field.getName());
                } else {
                    throw new Exception("의존성을 찾을 수 없음: " + fieldType.getName());
                }
            }
        }
    }
    
    // 빈 가져오기
    public <T> T getBean(Class<T> clazz) {
        return clazz.cast(beans.get(clazz));
    }
}

4단계: 실행 및 테스트

public class Main {
    public static void main(String[] args) {
        try {
            // 컨테이너 생성 및 초기화
            SimpleContainer container = new SimpleContainer();
            container.initialize("com.example"); // 패키지 경로는 실제 경로로 변경
            
            System.out.println("\n=== 컨테이너 초기화 완료 ===\n");
            
            // 빈 가져와서 사용
            UserController controller = container.getBean(UserController.class);
            controller.handleRequest();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/* 출력 결과:
빈 등록: UserServiceImpl
빈 등록: UserRepository
빈 등록: UserController
의존성 주입: UserController.userService
의존성 주입: UserController.userRepository

=== 컨테이너 초기화 완료 ===

=== 요청 처리 시작 ===
사용자 정보 출력!
사용자 저장 완료!
=== 요청 처리 완료 ===
*/

와 진짜 신기하지 않아? ㅋㅋㅋ 우리가 직접 new 키워드로 객체 생성하지 않았는데도 자동으로 인스턴스가 만들어지고 주입됐어! 이게 바로 메타프로그래밍의 힘이야 🔥

물론 실제 스프링은 이것보다 훨씬 복잡하고 기능도 많지만, 핵심 원리는 똑같아. 리플렉션으로 클래스 정보 읽고, 어노테이션으로 메타데이터 확인하고, 동적으로 인스턴스 생성하고 주입하는 거지!

⚡ 성능 최적화와 베스트 프랙티스

리플렉션은 강력하지만 느려. 진짜 많이 느려 ㅠㅠ 일반 메서드 호출보다 수십 배에서 수백 배까지 느릴 수 있거든. 그래서 성능이 중요한 곳에서는 조심해서 써야 해 ⚠️

성능 비교 테스트

public class PerformanceTest {
    
    static class TestClass {
        private int value = 0;
        
        public void increment() {
            value++;
        }
        
        public int getValue() {
            return value;
        }
    }
    
    public static void main(String[] args) throws Exception {
        TestClass obj = new TestClass();
        int iterations = 10_000_000;
        
        // 1. 일반 메서드 호출
        long start1 = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            obj.increment();
        }
        long end1 = System.nanoTime();
        System.out.println("일반 호출: " + (end1 - start1) / 1_000_000 + "ms");
        
        // 2. 리플렉션 메서드 호출
        Method method = TestClass.class.getMethod("increment");
        obj = new TestClass(); // 리셋
        
        long start2 = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            method.invoke(obj);
        }
        long end2 = System.nanoTime();
        System.out.println("리플렉션 호출: " + (end2 - start2) / 1_000_000 + "ms");
        
        // 3. 캐싱된 리플렉션 (setAccessible 최적화)
        method.setAccessible(true);
        obj = new TestClass(); // 리셋
        
        long start3 = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            method.invoke(obj);
        }
        long end3 = System.nanoTime();
        System.out.println("최적화된 리플렉션: " + (end3 - start3) / 1_000_000 + "ms");
    }
}

/* 실행 결과 예시:
일반 호출: 8ms
리플렉션 호출: 450ms
최적화된 리플렉션: 380ms
*/

보다시피 리플렉션이 50배 이상 느려 ㅋㅋㅋ 그래서 성능 최적화가 필수야!

최적화 기법들

// ❌ 나쁜 예: 매번 리플렉션 객체 생성
public void badExample(Object obj) throws Exception {
    for (int i = 0; i < 1000; i++) {
        Method method = obj.getClass().getMethod("someMethod");
        method.invoke(obj);
    }
}

// ✅ 좋은 예: 리플렉션 객체 캐싱
private static final Map<String, Method> methodCache = new ConcurrentHashMap<>();

public void goodExample(Object obj) throws Exception {
    String key = obj.getClass().getName() + ".someMethod";
    Method method = methodCache.computeIfAbsent(key, k -> {
        try {
            return obj.getClass().getMethod("someMethod");
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    });
    
    for (int i = 0; i < 1000; i++) {
        method.invoke(obj);
    }
}

Field field = clazz.getDeclaredField("privateField");
field.setAccessible(true); // 이거 한 번만 호출하면 됨

// 이후 반복적으로 사용
for (int i = 0; i < 1000; i++) {
    Object value = field.get(obj);
}

import java.lang.invoke.*;

public class MethodHandleExample {
    
    static class Calculator {
        public int add(int a, int b) {
            return a + b;
        }
    }
    
    public static void main(String[] args) throws Throwable {
        Calculator calc = new Calculator();
        
        // MethodHandle 생성
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodType methodType = MethodType.methodType(int.class, int.class, int.class);
        MethodHandle addHandle = lookup.findVirtual(Calculator.class, "add", methodType);
        
        // 호출 (리플렉션보다 빠름)
        int result = (int) addHandle.invoke(calc, 10, 20);
        System.out.println("결과: " + result); // 30
        
        // invokeExact는 더 빠르지만 타입이 정확히 일치해야 함
        int result2 = (int) addHandle.invokeExact(calc, 5, 15);
        System.out.println("결과: " + result2); // 20
    }
}

// 초기화 단계 (애플리케이션 시작 시 한 번만)
public class BeanFactory {
    private Map<Class<?>, Object> beans = new HashMap<>();
    
    public void initialize() throws Exception {
        // 리플렉션으로 빈 생성 (느림, 하지만 한 번만)
        Class<?> clazz = Class.forName("com.example.MyService");
        Object bean = clazz.getDeclaredConstructor().newInstance();
        beans.put(clazz, bean);
    }
    
    // 런타임 단계 (빠름)
    public <T> T getBean(Class<T> clazz) {
        return clazz.cast(beans.get(clazz)); // 단순 맵 조회, 리플렉션 없음
    }
}

베스트 프랙티스 정리

🎨 실무 활용 사례와 패턴

이론은 이제 충분하고 ㅋㅋ 실제로 어디서 어떻게 쓰이는지 보자! 진짜 프로젝트에서 쓸 만한 패턴들이야 🚀

1. 플러그인 시스템

사용자가 만든 플러그인을 동적으로 로딩하는 시스템이야. IDE나 게임 같은 데서 많이 써:

// 플러그인 인터페이스
public interface Plugin {
    String getName();
    void execute();
}

// 플러그인 로더
public class PluginLoader {
    
    public List<Plugin> loadPlugins(String pluginDirectory) throws Exception {
        List<Plugin> plugins = new ArrayList<>();
        File dir = new File(pluginDirectory);
        
        // JAR 파일들 찾기
        File[] jarFiles = dir.listFiles((d, name) -> name.endsWith(".jar"));
        
        if (jarFiles != null) {
            for (File jarFile : jarFiles) {
                // JAR 파일에서 클래스 로딩
                URLClassLoader classLoader = new URLClassLoader(
                    new URL[]{jarFile.toURI().toURL()},
                    this.getClass().getClassLoader()
                );
                
                // JAR 내부의 모든 클래스 검사
                JarFile jar = new JarFile(jarFile);
                Enumeration<JarEntry> entries = jar.entries();
                
                while (entries.hasMoreElements()) {
                    JarEntry entry = entries.nextElement();
                    String name = entry.getName();
                    
                    if (name.endsWith(".class")) {
                        String className = name.replace("/", ".")
                                              .substring(0, name.length() - 6);
                        
                        try {
                            Class<?> clazz = classLoader.loadClass(className);
                            
                            // Plugin 인터페이스 구현 여부 확인
                            if (Plugin.class.isAssignableFrom(clazz) && 
                                !clazz.isInterface()) {
                                Plugin plugin = (Plugin) clazz.getDeclaredConstructor()
                                                              .newInstance();
                                plugins.add(plugin);
                                System.out.println("플러그인 로드: " + plugin.getName());
                            }
                        } catch (Exception e) {
                            // 로딩 실패한 클래스는 무시
                        }
                    }
                }
                jar.close();
            }
        }
        
        return plugins;
    }
}

// 사용 예시
public class Application {
    public static void main(String[] args) throws Exception {
        PluginLoader loader = new PluginLoader();
        List<Plugin> plugins = loader.loadPlugins("./plugins");
        
        System.out.println("\n=== 로드된 플러그인 실행 ===");
        for (Plugin plugin : plugins) {
            plugin.execute();
        }
    }
}

2. ORM (Object-Relational Mapping)

JPA나 하이버네이트처럼 객체를 DB 테이블에 자동으로 매핑하는 거야. 간단한 버전을 만들어보자:

// 어노테이션 정의
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {
    String name();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
    String name();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Id {
}

// 엔티티 클래스
@Table(name = "users")
public class User {
    @Id
    @Column(name = "id")
    private Long id;
    
    @Column(name = "username")
    private String username;
    
    @Column(name = "email")
    private String email;
    
    // 생성자, getter, setter
    public User() {}
    
    public User(Long id, String username, String email) {
        this.id = id;
        this.username = username;
        this.email = email;
    }
    
    // getter/setter 생략
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

// 간단한 ORM 구현
public class SimpleORM {
    
    // INSERT 쿼리 생성
    public String generateInsertQuery(Object entity) throws Exception {
        Class<?> clazz = entity.getClass();
        
        // 테이블 이름 가져오기
        if (!clazz.isAnnotationPresent(Table.class)) {
            throw new Exception("@Table 어노테이션이 없습니다");
        }
        Table table = clazz.getAnnotation(Table.class);
        String tableName = table.name();
        
        // 컬럼과 값 수집
        List<String> columns = new ArrayList<>();
        List<String> values = new ArrayList<>();
        
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(Column.class)) {
                Column column = field.getAnnotation(Column.class);
                String columnName = column.name();
                
                field.setAccessible(true);
                Object value = field.get(entity);
                
                columns.add(columnName);
                
                // 값 포맷팅 (문자열은 따옴표로 감싸기)
                if (value instanceof String) {
                    values.add("'" + value + "'");
                } else {
                    values.add(String.valueOf(value));
                }
            }
        }
        
        // 쿼리 조립
        String query = String.format("INSERT INTO %s (%s) VALUES (%s)",
                                    tableName,
                                    String.join(", ", columns),
                                    String.join(", ", values));
        
        return query;
    }
    
    // SELECT 쿼리 생성
    public String generateSelectQuery(Class<?> entityClass, Object id) throws Exception {
        if (!entityClass.isAnnotationPresent(Table.class)) {
            throw new Exception("@Table 어노테이션이 없습니다");
        }
        
        Table table = entityClass.getAnnotation(Table.class);
        String tableName = table.name();
        
        // ID 필드 찾기
        Field idField = null;
        for (Field field : entityClass.getDeclaredFields()) {
            if (field.isAnnotationPresent(Id.class)) {
                idField = field;
                break;
            }
        }
        
        if (idField == null) {
            throw new Exception("@Id 어노테이션이 없습니다");
        }
        
        Column idColumn = idField.getAnnotation(Column.class);
        String idColumnName = idColumn.name();
        
        String query = String.format("SELECT * FROM %s WHERE %s = %s",
                                    tableName, idColumnName, id);
        
        return query;
    }
    
    // ResultSet을 엔티티로 변환 (실제로는 JDBC ResultSet 사용)
    public <T> T mapToEntity(Class<T> entityClass, Map<String, Object> resultMap) 
            throws Exception {
        T entity = entityClass.getDeclaredConstructor().newInstance();
        
        Field[] fields = entityClass.getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(Column.class)) {
                Column column = field.getAnnotation(Column.class);
                String columnName = column.name();
                
                if (resultMap.containsKey(columnName)) {
                    field.setAccessible(true);
                    field.set(entity, resultMap.get(columnName));
                }
            }
        }
        
        return entity;
    }
}

// 사용 예시
public class ORMTest {
    public static void main(String[] args) throws Exception {
        SimpleORM orm = new SimpleORM();
        
        // INSERT 쿼리 생성
        User user = new User(1L, "홍길동", "hong@example.com");
        String insertQuery = orm.generateInsertQuery(user);
        System.out.println(insertQuery);
        // 출력: INSERT INTO users (id, username, email) VALUES (1, '홍길동', 'hong@example.com')
        
        // SELECT 쿼리 생성
        String selectQuery = orm.generateSelectQuery(User.class, 1L);
        System.out.println(selectQuery);
        // 출력: SELECT * FROM users WHERE id = 1
        
        // ResultSet 매핑 (DB에서 가져온 데이터라고 가정)
        Map<String, Object> resultMap = new HashMap<>();
        resultMap.put("id", 1L);
        resultMap.put("username", "홍길동");
        resultMap.put("email", "hong@example.com");
        
        User mappedUser = orm.mapToEntity(User.class, resultMap);
        System.out.println("매핑된 사용자: " + mappedUser.getUsername());
    }
}

이게 JPA의 핵심 원리야 ㅋㅋ 어노테이션으로 메타데이터 정의하고, 리플렉션으로 읽어서 SQL 쿼리 자동 생성하는 거지! 실제 JPA는 이것보다 훨씬 복잡하지만 기본 아이디어는 같아 💡

3. JSON 직렬화/역직렬화

Jackson이나 Gson 같은 라이브러리도 리플렉션을 써. 객체를 JSON으로, JSON을 객체로 변환하는 거야:

public class SimpleJsonSerializer {
    
    // 객체를 JSON 문자열로 변환
    public String toJson(Object obj) throws Exception {
        if (obj == null) {
            return "null";
        }
        
        Class<?> clazz = obj.getClass();
        
        // 기본 타입 처리
        if (clazz == String.class) {
            return "\"" + obj + "\"";
        }
        if (clazz == Integer.class || clazz == Long.class || 
            clazz == Double.class || clazz == Boolean.class) {
            return obj.toString();
        }
        
        // 객체 처리
        StringBuilder json = new StringBuilder("{");
        Field[] fields = clazz.getDeclaredFields();
        boolean first = true;
        
        for (Field field : fields) {
            field.setAccessible(true);
            Object value = field.get(obj);
            
            if (!first) {
                json.append(",");
            }
            first = false;
            
            json.append("\"").append(field.getName()).append("\":");
            json.append(toJson(value)); // 재귀 호출
        }
        
        json.append("}");
        return json.toString();
    }
    
    // JSON 문자열을 객체로 변환 (간단한 버전)
    public <T> T fromJson(String json, Class<T> clazz) throws Exception {
        // 실제로는 JSON 파싱 라이브러리 필요
        // 여기서는 개념만 보여주는 예시
        
        T instance = clazz.getDeclaredConstructor().newInstance();
        
        // JSON 파싱 (실제로는 복잡함)
        json = json.trim();
        if (json.startsWith("{") && json.endsWith("}")) {
            json = json.substring(1, json.length() - 1);
            
            // 간단한 파싱 (실제로는 정규식이나 파서 사용)
            String[] pairs = json.split(",");
            
            for (String pair : pairs) {
                String[] keyValue = pair.split(":");
                String key = keyValue[0].trim().replace("\"", "");
                String value = keyValue[1].trim().replace("\"", "");
                
                Field field = clazz.getDeclaredField(key);
                field.setAccessible(true);
                
                // 타입에 맞게 변환
                Class<?> fieldType = field.getType();
                if (fieldType == String.class) {
                    field.set(instance, value);
                } else if (fieldType == int.class || fieldType == Integer.class) {
                    field.set(instance, Integer.parseInt(value));
                } else if (fieldType == long.class || fieldType == Long.class) {
                    field.set(instance, Long.parseLong(value));
                }
            }
        }
        
        return instance;
    }
}

// 테스트
public class JsonTest {
    
    static class Person {
        private String name;
        private int age;
        private String email;
        
        public Person() {}
        
        public Person(String name, int age, String email) {
            this.name = name;
            this.age = age;
            this.email = email;
        }
        
        @Override
        public String toString() {
            return "Person{name='" + name + "', age=" + age + ", email='" + email + "'}";
        }
    }
    
    public static void main(String[] args) throws Exception {
        SimpleJsonSerializer serializer = new SimpleJsonSerializer();
        
        // 객체 → JSON
        Person person = new Person("홍길동", 25, "hong@example.com");
        String json = serializer.toJson(person);
        System.out.println("JSON: " + json);
        // 출력: {"name":"홍길동","age":25,"email":"hong@example.com"}
        
        // JSON → 객체
        Person deserializedPerson = serializer.fromJson(json, Person.class);
        System.out.println("객체: " + deserializedPerson);
    }
}

4. 테스트 프레임워크

JUnit 같은 테스트 프레임워크도 리플렉션을 활용해. @Test 어노테이션 붙은 메서드를 찾아서 자동으로 실행하는 거지:

// 테스트 어노테이션
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Before {
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface After {
}

// 간단한 테스트 러너
public class SimpleTestRunner {
    
    public void runTests(Class<?> testClass) throws Exception {
        Object testInstance = testClass.getDeclaredConstructor().newInstance();
        Method[] methods = testClass.getDeclaredMethods();
        
        // @Before 메서드 찾기
        List<Method> beforeMethods = new ArrayList<>();
        List<Method> testMethods = new ArrayList<>();
        List<Method> afterMethods = new ArrayList<>();
        
        for (Method method : methods) {
            if (method.isAnnotationPresent(Before.class)) {
                beforeMethods.add(method);
            } else if (method.isAnnotationPresent(Test.class)) {
                testMethods.add(method);
            } else if (method.isAnnotationPresent(After.class)) {
                afterMethods.add(method);
            }
        }
        
        int passed = 0;
        int failed = 0;
        
        // 각 테스트 메서드 실행
        for (Method testMethod : testMethods) {
            System.out.println("\n실행 중: " + testMethod.getName());
            
            try {
                // @Before 메서드 실행
                for (Method before : beforeMethods) {
                    before.invoke(testInstance);
                }
                
                // 테스트 메서드 실행
                testMethod.invoke(testInstance);
                
                // @After 메서드 실행
                for (Method after : afterMethods) {
                    after.invoke(testInstance);
                }
                
                System.out.println("✅ 통과");
                passed++;
                
            } catch (Exception e) {
                System.out.println("❌ 실패: " + e.getCause().getMessage());
                failed++;
            }
        }
        
        System.out.println("\n=== 테스트 결과 ===");
        System.out.println("통과: " + passed);
        System.out.println("실패: " + failed);
        System.out.println("전체: " + (passed + failed));
    }
}

// 테스트 클래스
public class CalculatorTest {
    private int value;
    
    @Before
    public void setUp() {
        System.out.println("  [Before] 초기화");
        value = 0;
    }
    
    @Test
    public void testAddition() {
        System.out.println("  [Test] 덧셈 테스트");
        value = 2 + 3;
        if (value != 5) {
            throw new AssertionError("2 + 3은 5여야 합니다");
        }
    }
    
    @Test
    public void testSubtraction() {
        System.out.println("  [Test] 뺄셈 테스트");
        value = 10 - 3;
        if (value != 7) {
            throw new AssertionError("10 - 3은 7이어야 합니다");
        }
    }
    
    @Test
    public void testFailure() {
        System.out.println("  [Test] 실패하는 테스트");
        throw new AssertionError("의도적인 실패");
    }
    
    @After
    public void tearDown() {
        System.out.println("  [After] 정리");
        value = 0;
    }
}

// 실행
public class TestMain {
    public static void main(String[] args) throws Exception {
        SimpleTestRunner runner = new SimpleTestRunner();
        runner.runTests(CalculatorTest.class);
    }
}

/* 출력:
실행 중: testAddition
  [Before] 초기화
  [Test] 덧셈 테스트
  [After] 정리
✅ 통과

실행 중: testSubtraction
  [Before] 초기화
  [Test] 뺄셈 테스트
  [After] 정리
✅ 통과

실행 중: testFailure
  [Before] 초기화
  [Test] 실패하는 테스트
  [After] 정리
❌ 실패: 의도적인 실패

=== 테스트 결과 ===
통과: 2
실패: 1
전체: 3
*/

이렇게 리플렉션과 어노테이션을 조합하면 진짜 강력한 프레임워크를 만들 수 있어 ㅋㅋ 코드 중복도 줄이고 생산성도 올라가고 완전 좋지 🎉

🔒 보안 고려사항

리플렉션은 강력한 만큼 위험할 수도 있어. private 멤버에 접근할 수 있다는 건 캡슐화를 깨뜨릴 수 있다는 뜻이거든 ⚠️

SecurityManager와 권한 체크

자바에는 SecurityManager라는 게 있어서 리플렉션 사용을 제한할 수 있어:

// SecurityManager 설정 (Java 17 이전)
System.setSecurityManager(new SecurityManager());

// 이제 리플렉션 사용 시 권한 체크됨
try {
    Field field = SomeClass.class.getDeclaredField("privateField");
    field.setAccessible(true); // SecurityException 발생 가능
} catch (SecurityException e) {
    System.out.println("권한 없음!");
}

모듈 시스템과 리플렉션 (Java 9+)

Java 9부터 도입된 모듈 시스템은 리플렉션 접근을 더 엄격하게 제어해:

// module-info.java
module myapp {
    // 특정 패키지만 리플렉션 허용
    opens com.example.model to com.fasterxml.jackson.databind;
    
    // 모든 모듈에 리플렉션 허용
    opens com.example.dto;
}

opens 키워드를 쓰지 않으면 리플렉션으로 접근할 수 없어. 이렇게 하면 보안이 강화되지 👍

안전한 리플렉션 사용 패턴

// 안전한 리플렉션 래퍼
public class SafeReflection {
    // 허용된 클래스 목록
    private static final Set<String> ALLOWED_CLASSES = Set.of(
        "com.example.model.User",
        "com.example.model.Product"
    );
    
    public static Object createInstance(String className) throws Exception {
        // 1. 화이트리스트 체크
        if (!ALLOWED_CLASSES.contains(className)) {
            throw new SecurityException("허용되지 않은 클래스: " + className);
        }
        
        // 2. 클래스 로딩
        Class<?> clazz = Class.forName(className);
        
        // 3. 인스턴스 생성
        Object instance = clazz.getDeclaredConstructor().newInstance();
        
        // 4. 로깅
        System.out.println("인스턴스 생성: " + className);
        
        return instance;
    }
    
    public static void invokeMethod(Object obj, String methodName, Object... args) 
            throws Exception {
        Class<?> clazz = obj.getClass();
        
        // 1. 클래스 화이트리스트 체크
        if (!ALLOWED_CLASSES.contains(clazz.getName())) {
            throw new SecurityException("허용되지 않은 클래스");
        }
        
        // 2. 위험한 메서드 블랙리스트 체크
        Set<String> dangerousMethods = Set.of("exec", "eval", "compile");
        if (dangerousMethods.contains(methodName)) {
            throw new SecurityException("위험한 메서드 호출 시도: " + methodName);
        }
        
        // 3. 메서드 실행
        Method method = findMethod(clazz, methodName, args);
        method.invoke(obj, args);
        
        // 4. 로깅
        System.out.println("메서드 호출: " + clazz.getName() + "." + methodName);
    }
    
    private static Method findMethod(Class<?> clazz, String name, Object[] args) 
            throws NoSuchMethodException {
        Class<?>[] paramTypes = new Class<?>[args.length];
        for (int i = 0; i < args.length; i++) {
            paramTypes[i] = args[i].getClass();
        }
        return clazz.getMethod(name, paramTypes);
    }
}

💼 재능넷에서 메타프로그래밍 배우기

여기까지 읽었으면 리플렉션과 어노테이션에 대해 꽤 많이 알게 됐을 거야 ㅋㅋ 근데 이론만 알아서는 부족하지. 실제 프로젝트에 적용해봐야 진짜 실력이 늘어 🚀

재능넷에는 자바 메타프로그래밍 전문가들이 많아. 실무 경험이 풍부한 개발자들한테 직접 배울 수 있거든. 1:1 코칭도 받을 수 있고, 프로젝트 리뷰도 받을 수 있어. 혼자 삽질하면서 배우는 것보다 훨씬 빠르게 성장할 수 있지 💡

특히 스프링 프레임워크 내부 동작 원리를 깊이 있게 이해하고 싶다면, 재능넷에서 전문가를 찾아보는 것도 좋은 방법이야. 실무에서 바로 써먹을 수 있는 노하우를 배울 수 있거든 👨‍💻

학습 로드맵 추천

🎓 마무리하며

와 여기까지 읽느라 고생했어 ㅋㅋㅋ 리플렉션과 어노테이션은 처음에는 좀 어렵게 느껴질 수 있는데, 막상 써보면 진짜 강력한 도구야. 특히 프레임워크나 라이브러리 개발할 때는 필수적이고 말이야 💪

핵심만 정리하면:

실무에서는 직접 리플렉션을 쓸 일이 많지는 않아. 대부분 스프링 같은 프레임워크가 알아서 해주거든. 하지만 원리를 이해하면 프레임워크를 더 잘 활용할 수 있고, 문제가 생겼을 때 디버깅도 쉬워져 🔍

그리고 가끔은 직접 메타프로그래밍 기법을 써야 할 때도 있어. 특히 사내 프레임워크 개발하거나, 반복적인 코드를 자동화하고 싶을 때 말이야. 그럴 때 이 글이 도움이 되길 바래 😊

더 깊이 공부하고 싶다면 스프링 프레임워크 소스코드를 뜯어보는 것도 추천해. 특히 BeanFactory, ApplicationContext 같은 핵심 클래스들을 보면 리플렉션이 어떻게 활용되는지 생생하게 볼 수 있거든 📖

자 이제 직접 코드 짜보면서 실습해봐! 이론만 알고 있으면 소용없어 ㅋㅋ 작은 프로젝트라도 만들어보면서 손에 익혀야 진짜 내 것이 되는 거야. 화이팅! 🚀✨