리플렉션

참고자료

김영한의 실전 자바 - 고급 2편, I/O, 네트워크, 리플렉션 강의 | 김영한 - 인프런

 

리플렉션이 필요한 이유

이전 포스팅에서 배운 HTTP 서버를 만들면서, 커맨드 패턴을 도입하고 사용해봤던 서블릿은 아주 유용하지만, 몇가지 단점이 있다.

• 하나의 클래스에 하나의 기능만 만들 수 있다.
• 새로 만든 클래스를 URL 경로와 항상 매핑해야 한다.

 

단점1 - 하나의 클래스에 하나의 기능만 만들 수 있다.

기능 하나를 만들때마다 각각 별도의 클래스를 만들고, 구현해야 한다. 이것은 복잡한 기능에서는 효과적이지만, 간단한 기능을 만들 때는 클래스가 너무 많이 만들어지기 때문에 부담스럽다.

 

HomeServlet

package cwchoiit.was.v5.servlet;

import cwchoiit.was.httpserver.HttpRequest;
import cwchoiit.was.httpserver.HttpResponse;
import cwchoiit.was.httpserver.HttpServlet;

import java.io.IOException;

public class HomeServlet implements HttpServlet {
    @Override
    public void service(HttpRequest request, HttpResponse response) throws IOException {
        response.writeBody("<h1>Home</h1>");
        response.writeBody("<ul>");
        response.writeBody("<li><a href='/site1'>site1</a></li>");
        response.writeBody("<li><a href='/site2'>site2</a></li>");
        response.writeBody("<li><a href='/search?q=hello'>search</a></li>");
        response.writeBody("</ul>");
    }
}

 

Site1Servlet

package cwchoiit.was.v5.servlet;

import cwchoiit.was.httpserver.HttpRequest;
import cwchoiit.was.httpserver.HttpResponse;
import cwchoiit.was.httpserver.HttpServlet;

import java.io.IOException;

public class Site1Servlet implements HttpServlet {
    @Override
    public void service(HttpRequest request, HttpResponse response) throws IOException {
        response.writeBody("<h1>Site1</h1>");
    }
}

 

Site2Servlet

package cwchoiit.was.v5.servlet;

import cwchoiit.was.httpserver.HttpRequest;
import cwchoiit.was.httpserver.HttpResponse;
import cwchoiit.was.httpserver.HttpServlet;

import java.io.IOException;

public class Site2Servlet implements HttpServlet {
    @Override
    public void service(HttpRequest request, HttpResponse response) throws IOException {
        response.writeBody("<h1>Site2</h1>");
    }
}

 

이런식으로 거의 같은 기능을 하는데도 클래스를 하나씩 만들어줘야 한다. 이런 문제를 해결할 방법이 없을까?

바로 아래 코드처럼 하나의 클래스 안에서 다양한 기능을 처리하는 것이다.

public class ReflectController {
      
      public void site1(HttpRequest request, HttpResponse response) {
          response.writeBody("<h1>site1</h1>");
      }
      
      public void site2(HttpRequest request, HttpResponse response) {
          response.writeBody("<h1>site2</h1>");
      }
      
      public void search(HttpRequest request, HttpResponse response) {
          String query = request.getParameter("q");
          response.writeBody("<h1>Search</h1>");
          response.writeBody("<ul>");
          response.writeBody("<li>query: " + query + "</li>");
          response.writeBody("</ul>");
      } 
}

 

물론, 필요하면 클래스를 나눌 수 있게 해도 된다. 예를 들어, 이렇게 말이다.

• SiteController
• SearchController

이렇게 하면 비슷한 기능을 한 곳에 모을 수 있는 장점도 있고, 작은 기능 하나를 추가할 때마다 클래스를 계속 만들지 않아도 된다.

 

단점2 - 새로 만든 클래스를 URL 경로와 항상 매핑해야 한다.

  servletManager.add("/site1", new Site1Servlet());
  servletManager.add("/site2", new Site2Servlet());
  servletManager.add("/search", new SearchServlet());

• 새로운 기능을 하나 추가할 때마다 이런 매핑 작업도 함께 추가해야 한다.

그런데 여기서 앞서 본 ReflectController 예시를 보자. URL 경로의 이름과 메서드 이름이 같다.

• `/site1` → site1()
• `/site2` → site2()
• `/search` → search()

만약, URL 경로의 이름과 같은 이름의 메서드를 찾아서 호출할 수 있다면? 예를 들어, `/site1`이 입력되면 site1()이라는 메서드를 이름으로 찾아서 호출하는 것이다. 클래스에 있는 메서드의 이름을 찾아서 이렇게 호출할 수 있다면, 번거로운 매핑 작업을 제거할 수 있을 것이다. 자바 프로그램 실행 중에 이름으로 메서드를 찾고, 또 찾은 메서드를 호출하려면 자바의 리플렉션 기능을 먼저 알아야 한다. 리플렉션 기능을 먼저 학슴하고, 또 학습한 내용을 기반으로 ReflectController 같은 기능을 만들어서 적용해보자.

 

클래스와 메타데이터

클래스가 제공하는 다양한 정보를 동적으로 분석하고 사용하는 기능을 리플렉션(Reflection)이라고 한다. 리플렉션을 통해 프로그램 실행 중에 클래스, 메서드, 필드 등에 대한 정보를 얻거나, 새로운 객체를 생성하고 메서드를 호출하며, 필드의 값을 읽고 쓸 수 있다. 

 

리플렉션을 통해 얻을 수 있는 정보는 다음과 같다.

• 클래스의 메타데이터: 클래스 이름, 접근 제어자, 부모 클래스, 구현된 인터페이스 등
• 필드 정보: 필드의 이름, 타입, 접근 제어자를 확인하고, 해당 필드의 값을 읽거나 수정할 수 있다.
• 메서드 정보: 메서드 이름, 반환 타입, 매개변수 정보를 확인하고, 실행 중에 동적으로 메서드를 호출할 수 있다.
• 생성자 정보: 생성자의 매개변수 타입과 개수를 확인하고, 동적으로 객체를 생성할 수 있다.

참고로, 리플렉션(Reflection)이라는 용어는 영어 단어 'reflect'에서 유래된 것으로, "반사하다" 또는 "되돌아보다"라는 의미를 가지고 있다. 리플렉션은 프로그램이 실행 중에 자기 자신의 구조를 들여다보고, 그 구조를 변경하거나 조작할 수 있는 기능을 의미한다. 쉽게 말해, 리플렉션을 통해 클래스, 메서드, 필드 등의 메타데이터를 런타임에 동적으로 조사하고 사용할 수 있다. 이는 마치 거울에 비친 자신을 보는 것과 같이, 프로그램이 자기 자신의 내부를 반사(reflect)하여 들여다본다는 의미이다.

 

 

리플렉션으로 클래스 메타데이터 조회 

package cwchoiit.reflection.data;

public class BasicData {

    public String publicField;
    private int privateField;

    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 string) {
        System.out.println("BasicData.hello");
        return string + " hello";
    }

    private void privateMethod() {
        System.out.println("BasicData.privateMethod");
    }

    void defaultMethod() {
        System.out.println("BasicData.defaultMethod");
    }

    protected void protectedMethod() {
        System.out.println("BasicData.protectedMethod");
    }
}

• 예제를 위한 기본 클래스이다.

BasicV1

package cwchoiit.reflection;

import cwchoiit.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 basicInstance = new BasicData();
        Class<? extends BasicData> basicDataClass2 = basicInstance.getClass();
        System.out.println("basicDataClass2 = " + basicDataClass2);

        // 3. 문자로 찾기
        String className = "cwchoiit.reflection.data.BasicData"; // 패키지 명 주의
        Class<?> basicDataClass3 = Class.forName(className);
        System.out.println("basicDataClass3 = " + basicDataClass3);
    }
}

• 클래스의 메타데이터는 Class라는 클래스로 표현된다.
• 그리고 이 Class라는 클래스를 획득하는 방법에는 3가지가 있다. 
  • 클래스에서 찾기
  • 인스턴스에서 찾기
  • 문자로 찾기

클래스에서 찾기

Class<BasicData> basicDataClass1 = BasicData.class

클래스명에 .class를 사용하면 획득할 수 있다.

 

 

인스턴스에서 찾기

  BasicData helloInstance = new BasicData();
  Class<? extends BasicData> basicDataClass2 = helloInstance.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<?> basicData3 = Class.forName(className);

이 부분이 가장 흥미로운데, 단순히 문자로 클래스의 메타데이터를 조회할 수 있다. 예를 들어서 콘솔에서 사용자 입력으로 원하는 클래스를 동적으로 찾을 수 있다는 뜻이다. 

 

기본 정보 탐색

이렇게 찾은 클래스 메타데이터로 어떤 일들을 할 수 있는지 알아보자.

BasicV2

package cwchoiit.reflection;

import cwchoiit.reflection.data.BasicData;

import java.lang.reflect.Modifier;
import java.util.Arrays;

public class BasicV2 {

    public static void main(String[] args) {
        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("basicData.getModifiers() = " + modifiers);
        System.out.println("isPublic = " + Modifier.isPublic(modifiers));
        System.out.println("Modifier.toString() = " + Modifier.toString(modifiers));
    }
}

실행 결과

basicDataClass.getName() = cwchoiit.reflection.data.BasicData
basicDataClass.getSimpleName() = BasicData
basicDataClass.getPackage() = package cwchoiit.reflection.data
basicDataClass.getSuperclass() = class java.lang.Object
basicDataClass.getInterfaces() = []
basicDataClass.isInterface() = false
basicDataClass.isEnum() = false
basicDataClass.isAnnotation() = false
basicData.getModifiers() = 1
isPublic = true
Modifier.toString() = public

• 클래스 이름, 패키지, 부모 클래스, 구현한 인터페이스, 수정자 정보 등 다양한 정보를 획득할 수 있다.

참고로 수정자는 접근 제어자와 비 접근 제어자(기타 수정자)로 나눌 수 있다.

• 접근 제어자: public, protected, default, private
• 비 접근 제어자: static, final, abstract, synchronized, volatile 등

getModifiers()를 통해 수정자가 조합된 숫자를 얻고, Modifier를 사용해서 실제 수정자 정보를 확인할 수 있다.

조금만 더 자세히 얘기를 해보자면, 다음 코드를 보자.

int modifiers = basicDataClass.getModifiers();
System.out.println("basicData.getModifiers() = " + modifiers);

이것의 결과로 1이 찍힌것이다. 1은 Modifier.PUBLIC을 의미하고 이 상수값이 1로 정의되어 있다. 그리고 해당 클래스의 수정자가 1이라는 것은 이 클래스는 public으로 선언된 클래스라는 것을 말하는 것이다. 

 

그럼, 메서드들의 수정자도 한번 찍어보자.

Method[] methods = basicDataClass.getDeclaredMethods();
for (Method method : methods) {
    System.out.println(method.getModifiers());
}

실행 결과

1
1
2
0
4

 

이 클래스가 가지고 있는 모든 declaredMethod를 순회하면서 수정자를 찍어보니 이렇게 나왔다. 이후에 메서드에 대한 얘기도 할테니 가볍게만 이야기 하자면, declaredMethods는 해당 클래스에서 선언된 모든 메서드들을 가져온다.

 

1은 public, 2는 private, 0은 default, 4는 protected이다. 그리고 실제로 그런지 보자.

public void call() {
    System.out.println("BasicData.call");
}

public String hello(String string) {
    System.out.println("BasicData.hello");
    return string + " hello";
}

private void privateMethod() {
    System.out.println("BasicData.privateMethod");
}

void defaultMethod() {
    System.out.println("BasicData.defaultMethod");
}

protected void protectedMethod() {
    System.out.println("BasicData.protectedMethod");
}

 

이렇게 수정자는 이런 내용을 알려주는 것이다. 그리고 수정자는 접근 제어자와 비 접근 제어자 둘 다 다룬다고 했는데 만약, final 키워드를 public 메서드에 붙이면 어떻게 나올까?

public final void call() {
    System.out.println("BasicData.call");
}

 

이렇게 하고 다시 돌려보면 17이라는 숫자가 나온다. 1(public) + 16(final) = 17이 나온것이다. 이런것이 getModifiers()다.

 

 

메서드 탐색과 동적 호출

클래스 메타데이터를 통해 클래스가 제공하는 메서드의 정보를 확인해보자.

MethodV1

package cwchoiit.reflection;

import cwchoiit.reflection.data.BasicData;

import java.lang.reflect.Method;

public class MethodV1 {
    public static void main(String[] args) {
        Class<BasicData> basicDataClass = BasicData.class;

        // 해당 클래스와 상위 클래스에 있는 public 메서드들
        System.out.println("======= methods() ========");
        Method[] methods = basicDataClass.getMethods();
        for (Method method : methods) {
            System.out.println("method = " + method);
        }

        // 해당 클래스에서 선언한 모든 메서드들
        System.out.println("======= declaredMethods() ========");
        Method[] declaredMethods = basicDataClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("declaredMethod = " + declaredMethod);
        }
    }
}

• Class.getMethods() 또는 Class.getDeclaredMethods()를 호출하면, Method라는 타입으로 메서드의 메타데이터를 얻을 수 있다. 이 클래스는 메서드의 모든 정보를 가지고 있다.

getMethods() vs getDeclaredMethods()

• getMethods(): 해당 클래스와 상위 클래스에서 상속된 모든 public 메서드를 반환
• getDeclaredMethods(): 해당 클래스에서 선언된 모든 메서드를 반환하며, 접근 제어자에 관계없이 반환. 상속된 메서드는 포함되지 않음.

실행 결과

======= methods() ========
method = public void cwchoiit.reflection.data.BasicData.call()
method = public final native java.lang.Class java.lang.Object.getClass()
method = public final void java.lang.Object.wait() throws java.lang.InterruptedException
method = public final void java.lang.Object.wait(long) throws java.lang.InterruptedException
method = public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
method = public int java.lang.Object.hashCode()
method = public boolean java.lang.Object.equals(java.lang.Object)
method = public final native void java.lang.Object.notifyAll()
method = public java.lang.String java.lang.Object.toString()
method = public java.lang.String cwchoiit.reflection.data.BasicData.hello(java.lang.String)
method = public final native void java.lang.Object.notify()
======= declaredMethods() ========
declaredMethod = public void cwchoiit.reflection.data.BasicData.call()
declaredMethod = public java.lang.String cwchoiit.reflection.data.BasicData.hello(java.lang.String)
declaredMethod = private void cwchoiit.reflection.data.BasicData.privateMethod()
declaredMethod = void cwchoiit.reflection.data.BasicData.defaultMethod()
declaredMethod = protected void cwchoiit.reflection.data.BasicData.protectedMethod()

 

 

메서드 동적 호출

Method 객체를 사용하면 메서드를 직접 호출할 수도 있다.

MethodV2

package cwchoiit.reflection;

import cwchoiit.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 basicData = new BasicData();
        basicData.call();

        // 동적 메서드 호출 - 리플렉션 사용
        Class<? extends BasicData> basicDataClass = basicData.getClass();
        String methodName = "hello";

        // 메서드 이름을 변수로 변경할 수 있다.
        Method method1 = basicDataClass.getDeclaredMethod(methodName, String.class);
        Object returnValue = method1.invoke(basicData, "hi");
        System.out.println("returnValue = " + returnValue);
    }
}

• 리플렉션을 사용하면 매우 다양한 체크 예외가 발생한다.

실행 결과

BasicData.BasicData
BasicData.call
BasicData.hello
returnValue = hi hello

 

일반적인 메서드 호출 - 정적

인스턴스 참조를 통해 메서드를 호출하는 방식이 일반적인 메서드 호출 방식이다. 이 방식은 코드를 변경하지 않는 이상 다른 메서드로 변경하는 것이 불가능하다.

// 정적 메서드 호출 - 일반적인 메서드 호출
BasicData basicData = new BasicData();
basicData.call();

이렇게 되어 있는 코드에서 call() 메서드를 바꾸지 않는 이상 call()가 호출되는것을 바꾸는 것은 불가능하다는 말이다.

 

메서드 동적 호출 - 리플렉션 사용

// 동적 메서드 호출 - 리플렉션 사용
Class<? extends BasicData> basicDataClass = basicData.getClass();
String methodName = "hello";

// 메서드 이름을 변수로 변경할 수 있다.
Method method1 = basicDataClass.getDeclaredMethod(methodName, String.class);
Object returnValue = method1.invoke(basicData, "hi");
System.out.println("returnValue = " + returnValue);

위 코드처럼, 리플렉션을 사용하면 동적으로 메서드를 호출할 수 있다.

• 클래스 메타데이터가 제공하는 getMethod() 또는 getDeclaredMethod()에 메서드 이름과, 사용하는 매개변수의 타입을 전달하면 원하는 메서드를 찾을 수 있다. 
• 이 예제에선 'hello' 라는 메서드 이름에, String 매개변수가 있는 메서드를 찾는다.

Object returnValue = method1.invoke(basicData, "hi");

• Method.invoke() 메서드에 실행할 인스턴스와 인자를 전달하면, 해당 인스턴스에 있는 메서드를 전달받은 인자를 사용해 실행할 수 있다.
• 여기서는 BasicData basicData = new BasicData() 인스턴스에 있는 hello(String) 메서드를 호출한다. 그러니까 아래 메서드.

public String hello(String string) {
    System.out.println("BasicData.hello");
    return string + " hello";
}

 

여기서 메서드를 찾을 때, basicDataClass.getDeclaredMethod(methodName, String.class) 에서 methodName 부분이 String 변수로 되어 있는 것을 확인할 수 있다. methodName은 변수이므로 예를 들어, 사용자 콘솔 입력을 통해서 얼마든지 호출할 methodName을 변경할 수 있다. 따라서, 여기서 호출할 메서드 대상은 정적으로 딱 코드에 의해 정해진 것이 아니라, 언제든지 동적으로 변경할 수 있다. 그래서 동적 메서드 호출이라 한다. 

 

메서드 동적 호출 - 예시

package cwchoiit.reflection.data;

public class Calculator {

    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }
}

 

MethodV3

package cwchoiit.reflection;

import cwchoiit.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> calculatorClass = calculator.getClass();

        Method method = calculatorClass.getMethod(methodName, int.class, int.class);

        Object returnValue = method.invoke(calculator, num1, num2);
        System.out.println("returnValue = " + returnValue);

    }
}

실행 결과 1

호출 메서드: 
add
숫자1: 
3
숫자2: 
2
returnValue = 5

 

실행 결과 2

호출 메서드: 
subtract
숫자1: 
2
숫자2: 
4
returnValue = -2

 

물론, 시그니쳐가 잘못된 경우 에러가 발생하는건 당연하다.

실행 결과 3 - 잘못된 메서드명을 입력

 

필드 탐색과 값 변경

리플렉션을 활용해서, 필드를 탐색하고 또 필드의 값을 변경하도록 활용해보자.

FieldV1

package cwchoiit.reflection;

import cwchoiit.reflection.data.BasicData;

import java.lang.reflect.Field;

public class FieldV1 {
    public static void main(String[] args) {
        Class<BasicData> basicDataClass = BasicData.class;

        System.out.println("========= fields() =========");
        Field[] fields = basicDataClass.getFields();
        for (Field field : fields) {
            System.out.println("field = " + field);
        }

        System.out.println("========= declaredFields() =========");
        Field[] declaredFields = basicDataClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("declaredField = " + declaredField);
        }
    }
}

실행 결과

========= fields() =========
field = public java.lang.String cwchoiit.reflection.data.BasicData.publicField
========= declaredFields() =========
declaredField = public java.lang.String cwchoiit.reflection.data.BasicData.publicField
declaredField = private int cwchoiit.reflection.data.BasicData.privateField

 

fields() vs declaredFields()

앞서 설명한 getMethods() vs getDeclaredMethods()와 같다. 

• fields(): 해당 클래스와 상위 클래스에서 상속된 모든 public 필드를 반환
• declaredFields(): 해당 클래스에서 선언된 모든 필드를 반환하며, 접근 제어자에 관계없이 반환. 상속된 필드는 포함하지 않음.

 

필드 값 변경

필드 값 변경 예제를 위해 간단한 사용자 데이터를 만들어보자.

User

package cwchoiit.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 접근 제어자라는 점을 주의해서 살펴보자.

FieldV2

package cwchoiit.reflection;

import cwchoiit.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");

        nameField.set(user, "userB");
        System.out.println("변경된 이름 = " + user.getName());
    }
}

• 사용자의 이름이 userA인데, 리플렉션을 사용해서 name 필드에 직접 접근한 다음에 userB로 이름을 변경해보자.

Field nameField = aClass.getDeclaredField("name");

• name 이라는 필드를 조회한다.
• 그런데, name 필드는 private 접근 제어자를 사용한다. 따라서 직접 접근해서 값을 변경하는 것이 불가능하다.

 

그런데, 리플렉션은 private 필드에 접근할 수 있는 특별한 기능을 제공한다. 

nameField.setAccessible(true);

• 이렇게 setAccessible(true) 설정해버리면, private 필드에 그냥 접근이 가능해진다. 
• 참고로, 이 setAccessible(true)는, Method도 제공한다. 따라서 private 메서드를 호출할 수도 있다.

// private 필드에 접근 허용, 메서드도 또한 마찬가지
nameField.setAccessible(true);
nameField.set(user, "userB");
System.out.println("변경된 이름 = " + user.getName());

그래서 이렇게 해서 실행해버리면 변경이 가능해진다.

 

실행 결과

기존 이름 = userA
변경된 이름 = userB

 

 

리플렉션과 주의사항

본 것처럼, 리플렉션을 활용하면 private 접근 제어자에도 직접 접근해서 값을 변경할 수 있다. 하지만, 이는 객체 지향 프로그래밍의 원칙을 위반하는 행위로 간주될 수 있다. private 접근 제어자는 클래스 내부에서만 데이터를 보호하고,  외부에서의 직접적인 접근을 방지하기 위해 사용된다. 리플렉션을 통해 이러한 접근 제한을 무시하는 것은 캡슐화 및 유지보수성에 악영향을 미칠 수 있다. 예를 들어, 클래스의 내부 구조나 구현 세부 사항이 변경될 경우 리플렉션을 사용한 코드는 쉽게 깨질수 있으며, 이는 예상치 못한 버그를 초래할 수 있다. 따라서, 리플렉션을 사용할 때는 반드시 신중하게 접근해야 하며, 가능한 경우 접근 메서드(예: Getter, Setter)를 사용하는 것이 바람직하다. 리플렉션은 주로 테스트나 라이브러리 개발 같은 특별한 상황에서 유용하게 사용되지만, 일반적인 애플리케이션 코드에서는 권장되지 않는다. 이를 무분별하게 사용하면 코드의 가독성과 안정성을 크게 저하시킬 수 있다. 

 

그럼 어떤 경우에 사용하면 좋은걸까?

 

리플렉션 - 활용 예제

프로젝트에서 데이터를 저장해야 하는데, 저장할 때는 반드시 null을 사용하면 안된다고 가정해보자. 이 경우, null 값을 다른 기본 값으로 모두 변경해야 한다. 

• String이 null이면 ""(빈 문자)로 변경한다.
• Integer가 null이면 0으로 변경한다.

활용 예시를 위해 Team 클래스를 하나 만들자.

Team

package cwchoiit.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 + '\'' +
                '}';
    }
}

 

FieldV3

package cwchoiit.reflection;

import cwchoiit.reflection.data.Team;
import cwchoiit.reflection.data.User;

public class FieldV3 {
    public static void main(String[] args) {
        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);

        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);
    }
}

 

실행 결과

==== before ====
user = User{id='id1', name='null', age=null}
team = Team{id='team1', name='null'}
==== after ====
user = User{id='id1', name='', age=0}
team = Team{id='team1', name=''}

• User, Team 객체에 입력된 정보 중에 null 데이터를 모두 기본 값으로 변경해야 한다고 가정해보자.
• String이 null이면 ""(빈 문자)로 변경한다.
• Integer가 null이면 0으로 변경한다. 

이 문제를 해결하려면 위 코드처럼 각각의 객체에 들어있는 데이터를 직접 다 찾아서 값을 입력해야 한다. 만약, User, Team 뿐만 아니라 Order, Cart, Delivery 등등 수 많은 객체에 해당 기능을 적용해야 한다면 매우 많은 번거로운 코드를 작성해야 할 것이다.

 

이번에는 이 무식한 코드를 리플렉션을 활용해서 깔끔하게 해결해보자.

FieldUtil

package cwchoiit.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 declaredField : declaredFields) {
            declaredField.setAccessible(true);
            if (declaredField.get(target) != null) {
                continue;
            }

            if (declaredField.getType() == String.class) {
                declaredField.set(target, "");
            } else if (declaredField.getType() == Integer.class) {
                declaredField.set(target, 0);
            }
        }
    }
}

• 어떤 객체든 받아서 기본 값을 적용하는 유틸리티 클래스를 만들어보자.

이 유틸리티 필드의 값을 조사한 다음에 null이면 기본 값을 적용한다.

• String이 null이면 ""(빈 문자)로 변경한다.
• Integer가 null이면 0으로 변경한다. 

FieldV4

package cwchoiit.reflection;

import cwchoiit.reflection.data.Team;
import cwchoiit.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("==== after ====");
        System.out.println("user = " + user);
        System.out.println("team = " + team);
    }
}

실행 결과

==== before ====
user = User{id='id1', name='null', age=null}
team = Team{id='team1', name='null'}
==== after ====
user = User{id='id1', name='', age=0}
team = Team{id='team1', name=''}

리플렉션을 사용한 덕분에 User, Team 뿐만 아니라 Order, Cart, Delivery 등등 수 많은 객체에 매우 편리하게 기본 값을 적용할 수 있게 되었다. 이처럼 리플렉션을 활용하면 기존 코드로 해결하기 어려운 공통 문제를 손쉽게 처리할 수도 있다. 

 

생성자 탐색과 객체 생성

리플렉션을 활용하면 생성자를 탐색하고, 또 탐색한 생성자를 사용해서 객체를 생성할 수 있다.

 

생성자 탐색

 

ConstructV1

package cwchoiit.reflection;

import java.lang.reflect.Constructor;

public class ConstructV1 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> aClass = Class.forName("cwchoiit.reflection.data.BasicData");

        System.out.println("==== constructors() ====");
        Constructor<?>[] constructors = aClass.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("constructor = " + constructor);
        }

        System.out.println("==== declaredConstructors() ====");
        Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("declaredConstructor = " + declaredConstructor);
        }
    }
}

실행 결과

==== constructors() ====
constructor = public cwchoiit.reflection.data.BasicData()
==== declaredConstructors() ====
declaredConstructor = public cwchoiit.reflection.data.BasicData()
declaredConstructor = private cwchoiit.reflection.data.BasicData(java.lang.String)

 

 

생성자 활용

 

ConstructV2

package cwchoiit.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("cwchoiit.reflection.data.BasicData");

        Constructor<?> declaredConstructors = aClass.getDeclaredConstructor(String.class);
        declaredConstructors.setAccessible(true);
        Object instance = declaredConstructors.newInstance("hello");
        System.out.println("instance = " + instance);

        Method method = aClass.getDeclaredMethod("call");
        method.invoke(instance);
    }
}

실행 결과

BasicData.BasicData:hello
instance = cwchoiit.reflection.data.BasicData@b360e9ca
BasicData.call

 

Class.forName("cwchoiit.reflection.data.BasicData")를 사용해서 클래스 정보를 동적으로 조회했다.

 

getDeclaredConstructor(String.class): 생성자를 조회한다.

• 여기서는 매개변수로 String을 사용하는 생성자를 조회한다.
• 근데 그 생성자는 private 접근 제어자다! 그럼에도 불구하고 사용할 수가 있다.

declaredConstructors.setAccessible(true)를 사용해서 private 생성자를 접근 가능하게 만들었다.

다시봐도 이 String 매개변수를 가지는 생성자는 private이다.

private BasicData(String data) {
    System.out.println("BasicData.BasicData:" + data);
}

 

Object instance = declaredConstructors.newInstance("hello");

찾은 생성자를 사용해서 객체를 생성까지 한다. 여기서는 "hello"라는 인자를 넘겨준다.

 

Method method = aClass.getDeclaredMethod("call");
method.invoke(instance);

앞서 생성한 인스턴스에 call 이라는 이름의 메서드를 동적으로 찾아서 호출한다.

 

이번 예제를 잘 보면, 클래스를 동적으로 찾아서 인스턴스를 생성하고, 메서드도 동적으로 호출했다. 코드 어디에도 BasicData의 타입이나 call() 메서드를 직접 호출하는 부분을 코딩하지 않았다. 클래스를 찾고 생성하는 방법도, 그리고 생성한 클래스의 메서드를 호출하는 방법도 모두 동적으로 처리한 것이다. 

 

참고로, 스프링 프레임워크나 다른 프레임워크 기술들을 사용해보면, 내가 만든 클래스를 프레임워크가 대신 생성해줄 때가 있다. 그때가 되면 방금 학습한 리플렉션과 동적 객체 생성 방법들이 떠오를 것이다.

 

 

HTTP 서버6 - 리플렉션 서블릿

이전 포스팅에서 커맨드 패턴으로 만든 서블릿은 아주 유용하지만, 몇가지 단점이 있다.

• 하나의 클래스에 하나의 기능만 만들 수 있다.
• 새로 만든 클래스를 URL 경로와 항상 매핑해야 한다.

이제 리플렉션의 기본 기능을 학습했으니, 처음에 설명한 리플렉션을 활용한 서블릿 기능을 만들어보자. 개발자는 다음과 같이 간단한 기능만 만들면 된다.

  public class ReflectController {
      public void site1(HttpRequest request, HttpResponse response) {
          response.writeBody("<h1>site1</h1>");
      }
      public void site2(HttpRequest request, HttpResponse response) {
          response.writeBody("<h1>site2</h1>");
      }
      public void search(HttpRequest request, HttpResponse response) {
          String query = request.getParameter("q");
          response.writeBody("<h1>Search</h1>");
          response.writeBody("<ul>");
          response.writeBody("<li>query: " + query + "</li>");
          response.writeBody("</ul>");
      } 
}

• 개발자는 이런 Xxx컨트롤러라는 기능만 개발하면 된다.
• 이러한 컨트롤러의 메서드를 리플렉션으로 읽고 호출할 것이다.

참고로, 컨트롤러라는 용어는, 애플리케이션의 제어 흐름을 제어(control)한다. 요청을 받아 적절한 비즈니스 로직을 호출하고, 그 결과를 뷰에 전달하는 등의 작업을 수행한다.

 

URL 경로의 이름과 메서드의 이름이 같다.

• /site1 → site1()
• /site2 → site2()
• /search → search()

리플렉션을 활용하면 메서드 이름을 알 수 있다. 예를 들어, /site1이 입력되면, site1() 이라는 메서드를 이름으로 찾아서 호출하는 것이다. 이렇게 하면 번거로운 매핑 작업을 제거할 수 있다. 

 

물론 필요하면 서로 관련된 기능은 하나의 클래스로 모으도록, 클래스를 나눌 수 있게 해도 된다. 

• SiteController
  • site1()
  • site2()
• SearchController
  • search()

리플렉션을 처리하는 서블릿 구현

앞서 설명했듯, 서블릿은 자바 진영에서 이미 표준으로 사용하는 기술이다. 따라서 서블릿은 그대로 사용하면서 새로운 기능을 구현해보자. 앞서 만든 HTTP 서버에서 was.httpserver 패키지는 다른 곳에서 제공하는 변경할 수 없는 라이브러리라고 가정하자. 우리는 was.httpserver의 코드를 전혀 변경하지 않고 그대로 재사용하면서 기능을 추가하겠다. 

 

 

v5 코드

• HTTP 서버와 관련된 부분 - was.httpserver 패키지
  • HttpServer, HttpRequestHandler, HttpRequest, HttpResponse
  • HttpServlet, HttpServletManager
  • InternalErrorServlet, NotFoundServlet (was.httpserver.servlet 패키지)
• 서비스 개발을 위한 로직 - v5.servlet 패키지
  • HomeServlet
  • Site1Servlet
  • Site2Servlet
  • SearchServlet

 

컨트롤러

SearchControllerV6

package cwchoiit.was.v6;

import cwchoiit.was.httpserver.HttpRequest;
import cwchoiit.was.httpserver.HttpResponse;

public class SearchControllerV6 {

    public void search(HttpRequest request, HttpResponse response) {
        String query = request.getParameter("q");

        response.writeBody("<h1>Search</h1>");
        response.writeBody("<ul>");
        response.writeBody("<li>query = " + query + "</li>");
        response.writeBody("</ul>");
    }
}

• `/search`를 처리한다.

SiteControllerV6

package cwchoiit.was.v6;

import cwchoiit.was.httpserver.HttpRequest;
import cwchoiit.was.httpserver.HttpResponse;

public class SiteControllerV6 {

    public void site1(HttpRequest request, HttpResponse response) {
        response.writeBody("<h1>Site1</h1>");
    }

    public void site2(HttpRequest request, HttpResponse response) {
        response.writeBody("<h1>Site2</h1>");
    }
}

• `/site1`, `/site2`를 처리한다.

참고로, XxxController에서 호출 대상이 되는 메서드는 반드시 HttpRequest, HttpResponse를 인자로 받아야 한다. 이 부분은 뒤에서 설명한다. 기존 코드에서 이런 컨트롤러들을 어떻게 호출하도록 만들 수 있을까? 

 

리플렉션 서블릿

ReflectionServlet

package cwchoiit.was.httpserver.servlet.reflection;

import cwchoiit.was.httpserver.HttpRequest;
import cwchoiit.was.httpserver.HttpResponse;
import cwchoiit.was.httpserver.HttpServlet;
import cwchoiit.was.httpserver.PageNotFoundException;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;

public class ReflectionServlet implements HttpServlet {

    private final List<Object> controllers;

    public ReflectionServlet(List<Object> controllers) {
        this.controllers = controllers;
    }

    @Override
    public void service(HttpRequest request, HttpResponse response) throws IOException {
        String path = request.getPath();

        for (Object controller : controllers) {
            Class<?> aClass = controller.getClass();
            Method[] methods = aClass.getDeclaredMethods();

            for (Method method : methods) {
                String name = method.getName();
                if (path.equals("/" + name)) {
                    invoke(request, response, controller, method);
                    return;
                }
            }
        }
        throw new PageNotFoundException("path = " + path);
    }

    private void invoke(HttpRequest request, HttpResponse response, Object controller, Method method) {
        try {
            method.invoke(controller, request, response);
        } catch (IllegalAccessException | InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }
}

• was.httpserver.servlet.reflection 패키지 위치를 주의하자. 다른 프로젝트에서도 필요하면 사용할 수 있다.
• List<Object> controllers: 생성자를 통해 여러 컨트롤러들을 보관할 수 있다.

이 서블릿은 요청이 오면 모든 컨트롤러를 순회한다. 그리고 선언된 메서드 정보를 통해, URL의 요청 경로와 메서드 이름이 맞는지 확인한다. 만약, 메서드 이름이 맞다면 invoke()를 통해 해당 메서드를 동적으로 호출한다. 이때, HttpRequest, HttpResponse 정보도 함께 넘겨준다. 따라서 대상 메서드는 반드시 HttpRequest, HttpResponse를 인자로 받아야 한다. 

 

이미 앞서 리플렉션에서 학습한 내용들이라 이해하기 어렵지는 않을 것이다.

 

ServerMainV6

package cwchoiit.was.v6;

import cwchoiit.was.httpserver.HttpServer;
import cwchoiit.was.httpserver.ServletManager;
import cwchoiit.was.httpserver.servlet.DiscardServlet;
import cwchoiit.was.httpserver.servlet.reflection.ReflectionServlet;
import cwchoiit.was.v5.servlet.HomeServlet;

import java.io.IOException;
import java.util.List;

public class ServerMainV6 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        List<Object> controllers = List.of(new SiteControllerV6(), new SearchControllerV6());

        ReflectionServlet reflectionServlet = new ReflectionServlet(controllers);

        ServletManager servletManager = new ServletManager();
        servletManager.setDefaultServlet(reflectionServlet);

        servletManager.add("/", new HomeServlet());
        servletManager.add("/favicon.ico", new DiscardServlet());

        new HttpServer(PORT, servletManager).start();
    }
}

실행 결과

• 실행 결과는 기존과 같다.

 

• 만든 컨트롤러(SiteController, SearchController)들을 리스트로 담고, ReflectionServlet의 생성자로 넘겨준다.
• ServletManager의 defaultServlet을 위에서 만든 ReflectionServlet으로 지정한다. 이 부분이 중요하다. 리플렉션 서블릿을 기본 서블릿으로 등록하는 것이다. 이렇게 되면 다른 서블릿에서 경로를 찾지 못할 때 우리가 만든 리플렉션 서블릿이 항상 호출된다. 그리고 다른 서블릿은 등록하지 않는다. 따라서 항상 리플렉션 서블릿이 호출된다. 
  
  • 아쉽게도 HomeServlet을 처리하는 `/` 경로와 `/favicon.ico` 경로를 처리하는 DiscardServlet()은 등록해줘야 한다. 이 두 경로는 메서드명을 `/()`로 할 수 없고 `favicon.ico()` 이렇게 못만드니까.

기존에는 어떻게 서블릿을 URL 매핑을 했나? 바로 이렇게 했다.

servletManager.add("/", new HomeServlet());
servletManager.add("/site1", new Site1Servlet());
servletManager.add("/site2", new Site2Servlet());
servletManager.add("/search", new SearchServlet());
servletManager.add("/favicon.ico", new DiscardServlet());

 

이렇게 각 URL 별로 서블릿 하나씩을 다 만들어서 ServletManager에 등록하고 이 ServletManager가 아래 메서드를 호출하면서, 서블릿을 실행했다.

public void execute(HttpRequest request, HttpResponse response) throws IOException {
    try {

        HttpServlet servlet = servletMap.getOrDefault(request.getPath(), defaultServlet);
        if (servlet == null) {
            throw new PageNotFoundException("Page not found: " + request.getPath());
        }

        servlet.service(request, response);

    } catch (PageNotFoundException e) {
        e.printStackTrace();
        notFoundErrorServlet.service(request, response);
    } catch (Exception e) {
        e.printStackTrace();
        internalErrorServlet.service(request, response);
    }
}

그런데, 여기서 이제는 defaultServlet을 제외하고 아무런 서블릿도 등록하지 않았으니 저 ReflectionServlet만 실행되도록 한 것이다.

 

 

정리

기존 HTTP 서버의 코드를 전혀 변경하지 않고, 서블릿만 잘 구현해서 완전히 새로운 기능을 도입했다. 덕분에 앞서 커맨드 패턴으로 만든 서블릿의 단점을 해결할 수 있었다. 이렇게 리플렉션을 활용해서, 요청 URL과 동일한 메서드명을 통해 서블릿을 호출할 수 있게 된다.

 

남은 문제점

• 리플렉션 서블릿은 요청 URL과 메서드 이름이 같다면 해당 메서드를 동적으로 호출할 수 있다. 하지만 요청 이름과 메서드 이름을 다르게 하고 싶다면 어떻게 해야할까?
• 예를 들어, `/site1` 이라고 와도 page1()과 같은 다른 이름의 메서드를 호출하고 싶다면 어떻게 해야 할까? 예를 들어서 메서드 이름은 더 자세히 적고 싶을 수도 있잖아? 
• 또한, 홈 경로인 `/`와, `/favicon.ico`와 같은 아이콘 처리 경로는 자바 메서드 이름으로 처리할 수 없었다. 이건 어떻게 해결 할까?
• URL은 주로 `-`를 사용해서 문장을 이어간다. 예를 들면 `/add-member` 이렇게 말이다. 이런 URL은 어떻게 해결 할까?

 

 

이 문제들을 해결하는 방법은 애노테이션을 사용하는 것이다! 다음 포스팅은 애노테이션이다.