리플렉션이란?
구체적인 클래스 타입을 알지 못해도 그 클래스의 메서드, 타입, 변수들에 접근할 수 있도록 해주는 자바 API이다.
리플렉션이 어떤 경우에 사용될까?
코드를 작성할 시점에 어떤 타입의 클래스를 사용할지 모르지만, 런타임 시점에 지금 실행되고 있는 클래스를 가져와서 실행해야 하는 경우 사용된다.
프레임워크나 IDE에서 이런 동적인 바인딩을 이용한 기능을 제공합니다.
intelliJ의 자동완성 기능, 스프링의 어노테이션이 리플렉션을 이용한 기능이라 할 수 있습니다.
클래스와 메타데이터
클래스가 제공하는 다양한 정보를 동적으로 분석하고 사용하는 기능을 리플렉션 (Reflection)이라 한다.
리플렉션을 통해 프로그램 실행 중에 클래스, 메서드, 필드 등에 대한 정보를 얻거나, 새로운 객체를 생성하고 메서드를 호출하며, 필드의 값을 읽고 쓸 수 있다.
리플렉션을 통해 얻을 수 있는 정보는 다음과 같다.
- 클래스의 메타데이터 : 클래스 이름, 접근 제어자, 부모클래스, 구현된 인터페이스 등
- 필드 정보: 필드의 이름, 타입, 접근 제어자를 확인하고, 해당 필드의 값을 읽거나 수정할 수 있다.
- 메서드 정보: 메서드 이름, 반환 타입, 매개변수 정보를 확인하고, 실행 중에 동적으로 메서드를 호출할 수 있다.
- 생성자 정보: 생성자의 매개변수 타입과 개수를 확인하고, 동적으로 객체를 생성할 수 있다.
참고 - 리플렉션 용어
"리플렉션(Reflection)"이라는 용어는 영어 단어 "reflect"에서 유래된 것으로, "반사하다" 또는 "되돌아보다"라는 의미를 가지고 있다. 리플렉션은 프로그램이 실행 중에 자기 자신의 구조를 들여다보고, 그 구조를 변경하거나 조작할 수 있는 기능을 의미한다. 쉽게 말해, 리플렉션을 통해 클래스, 메서드, 필드 등의 메타데이터를 런타임에 동적으로 조사하고 사용할 수 있다. 이는 마치 거울에 비친 자신을 보는 것과 같이, 프로그램이 자기 자신의 내부를 '반사(reflect)'하여 들여다본다는 의미이다
클래스 메타데이터 조회
package reflection.data;
public class BasicData {
public String publicField;
private int pravateField;
public BasicData() {
System.out.println("BasicData.BasicData");
}
private BasicData(String data) {
System.out.println("BasicData.BasicData: " + data);
}
public void call(){
System.out.println("BasicData.call");
}
public String hello(String str){
System.out.println("BasicData.hello");
return str + " hello";
}
private void privateMehod(){
System.out.println("BasicData.privateMehod");
}
private void defaultMethod(){
System.out.println("BasicData.defaultMethod");
}
protected void protectMethod(){
System.out.println("BasicData.protectMethod");
}
}- 예제를 위한 기본 클래스이다
package reflection;
import reflection.data.BasicData;
public class BasicV1 {
public static void main(String[] args) throws ClassNotFoundException {
// 클래스 메타데이터 조회 방법 3가지
// 1.클래스에서 찾기
Class<BasicData> basicDataClass1 = BasicData.class;
System.out.println("basicDataClass1 = " + basicDataClass1);
// 2. 인스턴스에서 찾기
BasicData basicDataInstance = new BasicData();
Class<? extends BasicData> basicDataClass2 = basicDataInstance.getClass();
System.out.println("basicDataClass2 = " + basicDataClass2);
// 3. 문자로 찾기
String className = "reflection.data.BasicData";
Class<?> basicDataClass3 = Class.forName(className);
System.out.println("basicDataClass3 = " + basicDataClass3);
}
}실행 결과
클래스의 메타데이터는 Class라는 클래스로 표현된다. 그리고 Class라는 클랙스를 획득하는 3가지 방법이 있다.
클래스에서 찾기
Class<BasicData> basicDataClass1 = BasicData.class;클래스명에. class를 사용하면 획득할 수 있다.
인스턴스에서 찾기
BasicData basicDataInstance = new BasicData();
Class<? extends BasicData> basicDataClass2 = basicDataInstance.getClass();
인스턴스에. getClass() 메서드를 호출하면 획득할 수 있다.
반환타입을 보면 Class <? extends BasicData>로 표현되는데, 실제 인스턴스가 BasicData 타입일 수도 있지만, 그 자식 타입일 수 있기 때문이다.
이해를 돕기 위해 다음 예를 보자.
Parent parent = new Child();
Class<? extends Parent> parentClass = parent.getClass();
Parent 타입을 통해 getClass()를 호출했지만 실제 인스턴스는 Child이다. 따라서 제네릭에서 자식타입도 허용할 수 있도록
? extends Parent를 사용한다.
문자로 찾기
String className = "reflection.data.BasicData";
Class<?> basicDataClass3 = Class.forName(className);이 부분이 가장 흥미로운데, 단순히 문자로 클래스의 메타데이터를 조회할 수 있다. 예를 들어서 콘솔에서 사용자가 입력으로 원하는 클래스를 동적으로 찾을 수 있다는 뜻이다.
기본 정보 탐색
이렇게 찾은 클래스 메타데이터로 어떤 일들을 할 수 있는지 알아보자
package reflection;
import reflection.data.BasicData;
import java.lang.reflect.Modifier;
import java.util.Arrays;
public class BasicV2 {
public static void main(String[] args) throws ClassNotFoundException {
Class<BasicData> basicDataClass = BasicData.class;
System.out.println("basicDataClass.getName() = " + basicDataClass.getName());
System.out.println("basicDataClass.getSimpleName() = " + basicDataClass.getSimpleName());
System.out.println("basicDataClass.getPackage() = " + basicDataClass.getPackage());
System.out.println("basicDataClass.getSuperclass() = " + basicDataClass.getSuperclass());
System.out.println("basicDataClass.getInterfaces() = " + Arrays.toString(basicDataClass.getInterfaces()));
System.out.println("basicDataClass.isInterface() = " + basicDataClass.isInterface());
System.out.println("basicDataClass.isEnum() = " + basicDataClass.isEnum());
System.out.println("basicDataClass.isAnnotation() = " + basicDataClass.isAnnotation());
int modifiers = basicDataClass.getModifiers();
System.out.println("modifiers = " + modifiers);
System.out.println("isPublic = " + Modifier.isPublic(modifiers));
System.out.println("Modifier.toString(modifiers) = " + Modifier.toString(modifiers));
}
}
클래스 이름, 패키지, 부모 클래스, 구현한 인터페이스, 수정자 정보 등 다양한 정보를 획득할 수 있다.
참고로 수정자는 접근 제어자와 비 접근 제어자(기타 수정자)로 나눌 수 있다.
접근 제어자: public , protected , default ( package-private ), private
비 접근 제어자: static , final , abstract , synchronized , volatile
getModifiers()를 통해 수정자가 조합된 숫자를 얻고 Modifier를 사용해서 실제 수정자 정보를 확인할 수 있다.
메서드 탐색과 동적 호출
클래스 메타데이터를 통해 클래스가 제공하는 메서드의 정보를 확인해 보자.
메서드 메타데이터
package reflection;
import reflection.data.BasicData;
import java.lang.reflect.Method;
public class MethodV1 {
public static void main(String[] args) {
Class<BasicData> helloClass = BasicData.class;
System.out.println("==== methodes() ====");
Method[] methods = helloClass.getMethods();
for (Method method : methods) {
System.out.println("method = " + method);
}
System.out.println("==== declaredMethods() ====");
Method[] declaredMethods = helloClass.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println("declaredMethod = " + declaredMethod);
}
}
}Class.getMethods() 또는 Class.getDeclaredMethods()를 호출하면 Method라는 메서드의 메타데이터를 얻을 수 있다.
이 클래스는 메서드의 모든 정보를 가지고 있다.
getMethods() vs getDeclaredMethods()
- getMethods() : 해당 클래스와 상위 클래스에서 상속된 모든 public메서드를 반환
- getDeclaredMethods() : 해당 클래스에서 선언된 모든 메서드를 반환하며, 접근 제어자에 관계없이 반환.
- 상속된 메서드는 포함하지 않음
동적 메서드 호출
Method 객체를 사용해서 메서드를 직접 호출할 수도 있다.
package reflection;
import reflection.data.BasicData;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class MethodV2 {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
//정적 메서드 호출 - 일반적인 메서드 호출
BasicData helloInstance = new BasicData();
helloInstance.call(); // 이 부분은 코드를 변경하지 않는 이상 정적이다.
// 동적 메서드 호출 - 리플렉션 사용
Class<? extends BasicData> helloClass = helloInstance.getClass();
String methodName = "hello";
// 메서드 이름을 변수로 변경할 수 있다.
Method method1 = helloClass.getDeclaredMethod(methodName, String.class);
System.out.println("method1 = " + method1);
Object returnValue = method1.invoke(helloInstance, "hi");
System.out.println(returnValue);
}
}
- 리플렉션을 사용하면 매우 다양한 체크 예외가 발생한다
실행 결과
일반적인 메서드 호출 - 정적
인스턴스의 참조를 통해 메서드를 호출하는 방식이 일반적인 메서드 호출 방식이다.
이 방식은 코드를 변경하지 않는 이상 call() 대신 다른 메서드로 변경하는 것이 불가능하다.
helloInstance.call()
호출하는 메서드가 이미 코드로 작성되어서 정적으로 변경할 수 없는 상태이다.
동적 메서드 호출 - 리플렉션 사용
String methodName = "hello";
// 메서드 이름을 변수로 변경할 수 있다.
System.out.println("method1 = " + method1);
Object returnValue = method1.invoke(helloInstance, "hi");
System.out.println(returnValue);리플렉션을 사용하면 동적으로 호출할 수 있다.
Method method1 = helloClass.getDeclaredMethod(methodName, String.class);클래스 메타데이거 제공하는 getDeclaredMethod()에 메서드 이름, 사용하는 매개변수의 타입을 전달하면 원하는 메서드를 찾을 수 있다.
여기에는 hello라는 이름의 String 매개변수가 있는 hello(String) 메서드를 찾는다.
Object returnValue = method1.invoke(helloInstance, "hi");
Mathod.invoke() 메서드에 실행할 인스턴스와 인자를 전달하면, 해당 인스턴스에 있는 메서드를 실행할 수 있다.
여기서는 BasicData helloInstance = new BasicData() 인스턴스에 이는 hello(String) 메서드를 호출한다.
여기서 메서드를 찾을 때 helloClass.getMethod(methodName, String.class)에서 methodName 부분이 String 변수로 되어있는 것을 확인할 수 있다. methodeName 은 변수이므로 예를 들어 사용자 콘솔 입력을 통해서 얼마든지 호출할 methodName을 변경할 수 있다.
따라서 여기서 호출할 메서드 대상은 정적으로 딱 코드에 정해진 것이 아니라, 언제든지 동적으로 변경할 수 있다. 그래서 동적 메서드 호출이라 한다.
동적 메서드 호출 - 예시
동적 메서드 호출을 예시를 통해 확인해 보자
package reflection.data;
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public int sub(int a, int b) {
return a - b;
}
}
package reflection;
import reflection.data.Calculator;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Scanner;
public class MethodV3 {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
Scanner scanner = new Scanner(System.in);
System.out.println("호출 메서드: ");
String methodName = scanner.nextLine();
System.out.println("숫자1: ");
int num1 = scanner.nextInt();
System.out.println("숫자2: ");
int num2 = scanner.nextInt();
Calculator calculator = new Calculator();
// 호출할 메서드를 변수 이름으로 동적으로 선택
Class<? extends Calculator> aClass = Calculator.class;
Method method = aClass.getMethod(methodName, int.class, int.class);
Object returnValue = method.invoke(calculator, num1, num2);
System.out.println("returnValue = " + returnValue);
}
}실행 결과
필드 탐색과 값 변경
리플렉션을 활용해서 필드를 탐색하고 또 필드의 값을 변경하도록 활용해 보자
package reflection;
import reflection.data.BasicData;
import java.lang.reflect.Field;
public class FieldV1 {
public static void main(String[] args) {
Class<BasicData> helloClass = BasicData.class;
System.out.println(" ==== fields() ==== ");
Field[] fields = helloClass.getFields();
for (Field field : fields) {
System.out.println("field = " + field);
}
System.out.println(" ==== declaredFields ==== ");
Field[] declaredFields = helloClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println("declaredField = " + declaredField);
}
}
}
실행 결과
fields() vs declaredFields()
앞서 설명한 getMethods() vs getDeclaredMethods()와 같다.
- fields() : 해당 클래스와 상위 클래스에서 상속된 모든 public 필드를 반환
- declaredFields() : 해당 클래스에서 선언된 모든 필드를 반환하며, 접근제어자에 관계없이 반환, 상속된 필드는 포함하지 않음
필드 값 변경
필드 값 변경 예제를 위해 간단한 사용자 데이터를 만들어보자
package reflection.data;
public class User {
private String id;
private String name;
private Integer age;
public User() {
}
public User(String id, String name, Integer age) {
this.id = id;
this.name = name;
this.age = age;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}여기서 모든 필드가 private 접근 제어자라는 점을 주의해서 살펴보자
package reflection;
import reflection.data.User;
import java.lang.reflect.Field;
public class FieldV2 {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
User user = new User("id1", "userA", 20);
System.out.println("기존 이름 = " + user.getName());
Class<? extends User> aClass = user.getClass();
Field nameField = aClass.getDeclaredField("name");
// private 필드에 접근 허용, private 메서드도 이렇게 호출 가능
nameField.setAccessible(true);
nameField.set(user, "userB");
System.out.println("변경된 이름 = " + user.getName());
}
}사용자의 이름이 userA인데, 리플렉션을 사용해서 name 필드에 직접 접근한 다음에 userB로 이름을 변경해 보자.
Field nameField = aClass.getDeclaredField("name");name이라는 필드를 조회한다.
그런데 name 필드는 private 접근 제어자를 사용한다. 따라서 직접 접근해서 값을 변경하는 것이 불가능하다.
nameField.setAccessible(true)리플렉션은 private 필드에 접근할 수 있는 특별한 기능을 제공한다.
참고로 setAccessible(true) 기능은 Method 도 제공한다. 따라서 private 메서드를 호출할 수도 있다.
nameField.set(user, "userB");user 인스턴스에 있는 nameField의 값을 userB로 변경한다
실행 결과
리플렉션과 주의사항
리플렉션을 활용하면 private 접근제어자에도 직접 접근해서 값을 변경할 수 있다. 하지만 이는 객체 지향 프로그래밍의 원칙을 위반하는 행위로 간주될 수 있다. private 접근제어자는 클래스 내부에서만 데이터를 보호하고, 외부에서의 직접적인 접근을 방지하기 위해 사용된다. 리플렉션을 통해 이러한 접근제한을 무시하는 것은 캡슐화 및 유지보수성에 악영향을 미칠 수 있다. 예를 들어, 클래스의 내부 구조나 구현 세부사항이 변경될 경우 리플렉션을 사용한 코드는 쉽게 깨질 수 있으며, 이는 예상치 못한 버그를 초래할 수 있다.
따라서 리플렉션을 사용할 때는 반드시 신중하게 접근해야 하면, 가능한 경우 접근메서드 (예: getter, setter)를 사용하는 것이 바람직하다. 리플렉션은 주로 테스트나 라이브러리 개발 같은 특별한 상황에서 유용하게 사용되지만, 일반적인 애플리케이션 코드에서는 권장되지 않는다. 이를 무분별하게 사용하면 코드의 가독성과 안전성을 크게 저하시킬 수 있다.
그럼 어떤 경우에 사용하면 좋은지 다음 필드 활용에서 알아보자
리플렉션 - 활용 예제
여러분의 프로젝트에서 데이터를 저장해야 하는데, 저장할 때는 반드시 null을 사용하면 안 된다고 가정해 보자.
이 경우 null 값을 다른 기본 값으로 모두 변경해야 한다.
- String 이 null 이면 "" (빈 문자)로 변경한다.
- Integer 가 null 이면 0으로 변경한다.
활용 예시를 위해 Team 클래스를 만들자
package reflection.data;
public class Team {
private String id;
private String name;
public Team(){
}
public Team(String id, String name) {
this.id = id;
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Team{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
'}';
}
}
package reflection;
import reflection.data.Team;
import reflection.data.User;
public class FieldV3 {
public static void main(String[] args) {
User user = new User("id", null, null);
Team team = new Team("team1", null);
System.out.println("===== before =====");
System.out.println("user = " + user);
System.out.println("team = " + team);
if(user.getId() == null) {
user.setId("");
}
if(user.getName() == null) {
user.setName("");
}
if(user.getAge() == null) {
user.setAge(0);
}
if(team.getId() == null) {
team.setId(" ");
}
if(team.getName() == null) {
team.setName(" ");
}
System.out.println("===== after =====");
System.out.println("user = " + user);
System.out.println("team = " + team);
}
}
User , Team 객체에 입력된 정보 중에 null 데이터를 모두 기본 값으로 변경해야 한다고 가정해 보자
- String 이 null 이면 "" (빈 문자)로 변경한다.
- Integer 가 null 이면 0으로 변경한다.
이 문제를 해결하려면 각각의 객체에 들어있는 데이터를 직접 다 찾아서 값을 입력해야 한다. 만약 User , Team 뿐만 아니라 Order , Cart , Delivery 등등 수많은 객체에 해당 기능을 적용해야 한다면 매우 많은 번거로운 코드를 작 성해야 할 것이다.
이번에는 리플렉션을 활용해서 이 문제를 깔끔하게 해결해 보자
리플렉션을 활용한 필드 기본 값 도입
package reflection;
import java.lang.reflect.Field;
public class FIeldUtil {
public static void nullFieldToDefault(Object target) throws IllegalAccessException {
Class<?> aClass = target.getClass();
Field[] declaredFields = aClass.getDeclaredFields();
for (Field field : declaredFields) {
field.setAccessible(true);
if(field.get(target) != null) {
continue;
}
if(field.getType() == String.class) {
field.set(target, "");
} else if(field.getType() == Integer.class){
field.set(target, 0);
}
}
}
}
어떤 객체든 받아서 기본 값을 적용하는 유틸리티 클래스를 만들어보자.
이 유틸리티는 필드의 값을 조사한 다음에 null 이면 기본 값을 적용한다.
- String 이 null 이면 "" (빈 문자)로 변경한다.
- Integer 가 null 이면 0으로 변경한다.
package reflection;
import reflection.data.Team;
import reflection.data.User;
public class FieldV4 {
public static void main(String[] args) throws IllegalAccessException {
User user = new User("id1", null, null);
Team team = new Team("team1", null);
System.out.println("====before====");
System.out.println("user = " + user);
System.out.println("team = " + team);
FIeldUtil.nullFieldToDefault(user);
FIeldUtil.nullFieldToDefault(team);
System.out.println("====ater====");
System.out.println("user = " + user);
System.out.println("team = " + team);
}
}실행 결과
리플렉션을 사용한 덕분에 User , Team 뿐만 아니라 Order , Cart , Delivery 등등 수많은 객체에 매우 편리하게 기본값을 적용할 수 있게 되었다.
이처럼 리플렉션을 활용하면 기존 코드로 해결하기 어려운 공통 문제를 손쉽게 처리할 수도 있다.
생성자 탐색과 객체 생성
리플렉션을 활용하면 생성자를 탐색하고, 또 탐색한 생성자를 사용해서 객체를 생성할 수 있다
생성자 탐색
package reflection;
import java.lang.reflect.Constructor;
public class ConstructV1 {
public static void main(String[] args) throws ClassNotFoundException {
Class<?> aClass = Class.forName("reflection.data.BasicData");
System.out.println("====== constructors() =====");
Constructor<?>[] constructors = aClass.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor);
}
System.out.println("====== declaredConstructor() =====");
Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println(declaredConstructor);
}
}
}실행 결과
생성자 활용
package reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ConstructV2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
Class<?> aClass = Class.forName("reflection.data.BasicData");
Constructor<?> constructor = aClass.getDeclaredConstructor(String.class);
constructor.setAccessible(true);
Object instance = constructor.newInstance("hello");
System.out.println("instance = " + instance);
Method mothod1 = aClass.getDeclaredMethod("call");
mothod1.invoke(instance);
}
}실행 결과
Class.forName("reflection.data.BasicData")을 사용해서 클래스 정보를 동적으로 조회했다
getDeclaredConstructor(String.class) : 생성자를 조회한다.
- 여기서는 매개변수로 String을 사용하는 생성자를 조회한다
constructor.setAccessible(true)를 사용해서 private 생성자를 접근 가능하게 만들었다
private BasicData(String data) {
System.out.println("BasicData.BasicData: " + data);
}
Object instance = constructor.newInstance("hello");- 찾은 생성자를 사용해서 객체를 생성한다. 여기서는 "hello"라는 인자를 넘겨준다
Method mothod1 = aClass.getDeclaredMethod("call");
mothod1.invoke(instance);- 앞서 생성한 인스턴스에 call이라는 이름의 메서드를 동적으로 찾아서 호출한다.
번 예제를 잘 보면, 클래스를 동적으로 찾아서 인스턴스를 생성하고, 메서드도 동적으로 호출했다.
코드 어디에도 BasicData의 타입이나 call() 메서드를 직접 호출하는 부분을 직접 코딩하지 않았다,
클래스를 찾고 생성하는 방법도, 그리고 생성한 클래스의 메서드를 호출하는 방법도 모두 동적으로 처리한 것이다.
참고
여러분이 스프링 프레임워크나 다른 프레임워크 기술들을 사용해 보면, 내가 만든 클래스를 프레임워크가 대신 생성해 줄 때가 있다. 그때가 되면 방금 학습한 리플렉션과 동적 객체 생성 방법들이 떠오를 것이다
참고자료 : https://dev-coco.tistory.com/153
김영한의 실전 자바 - 고급 2편, I/O, 네트워크, 리플렉션
'JAVA' 카테고리의 다른 글
| 중첩 클래스, 내부 클래스 1 (0) | 2024.12.23 |
|---|---|
| 자바 정규식 Reqular Expression (0) | 2024.12.23 |
| [JAVA] 자원 정리 (try-catch , try-with-resources) 2 (1) | 2024.11.26 |
| [JAVA] 자원 정리 (try-catch , try-with-resources) (0) | 2024.11.26 |
| [JAVA] Comparable ,Comparator (0) | 2024.11.23 |