Sentio, ergo sum

Java Annotation in Action 5

2020-05-17T01:20:55+09:00

앞서 리플렉션으로 메서드, 파라미터 정보를 읽고 메서드를 호출하면서 애너테이션을 처리하는 방법을 살펴봤습니다. 끝에서 언급했듯 아래와 같은 문제점이 있었습니다.

타입 안전성을 해칠 가능성
안전하지 않은 메서드 이름
시그니처가 다른 메서드 지원이 어려움

충분히 원하는 기능을 구현했지만 여러 변경에 대해 용이한 구현은 아닙니다. 자바에서 제공하는 동적 프록시(Proxy)를 활용하면 같은 동작을 하는 코드를 수월하게 작성할 수 있습니다. 프록시는 “대리인”이라는 뜻의 사전적 의미를 가지며, 프로그래밍에서의 프록시도 그와 유사하게 원래의 대상 메서드를 프록시를 통해 대신해서 호출할 수 있습니다.

figure 1. 일반적인 메서드 호출

figure 2. 프록시를 통한 메서드 호출

figure 1은 calculator.plus(1, 2)와 같이 일반적인 방법으로 메서드를 호출할 때의 관계를 보여주고 있습니다. figure 2 프록시를 통해 plus 메서드를 호출할 때의 관계이며, 클라이언트는 프록시의 plus 메서드를 호출하게 되고 다시 프록시 객체는 Calculator 객체의 plus 메서드를 호출하게 됩니다. 프록시를 통해 호출할 때 메서드 호출 전/후의 처리와 메서드 호출 제어를 할 수 있게 됩니다.

자바의 프록시는 표준 JDK에 내장되어 있어 별도의 라이브러리를 추가하지 않아도 되며 java.lang.reflect.Proxy 클래스를 활용해서 프록시 기능을 사용하게 됩니다.

새로운 프록시 인스턴스를 생성하기 위해서는 Proxy.newProxyInstance 정적 메서드를 호출합니다. newProxyInstance 메서드는 ClassLoader, 인터페이스의 Class 배열 그리고 InvocationHandler 객체를 필요로 합니다. 프록시 클래스는 지정된 ClassLoader에 정의되며, 두 번째 인자인 인터페이스의 Class 배열로 전달한 모든 인터페이스를 구현합니다. 이 때 배열은 인터페이스로만 구성되어야 하고 인터페이스 외의 클래스나 열거형 등의 타입은 전달할 수 없습니다.

InvocationHandler 인터페이스에는 invoke 메서드가 정의되어 있습니다. 이 invoke 메서드가 프록시 객체를 통해 호출되는 모든 메서드를 처리하게 됩니다. 이 때 클라이언트가 호출한 메서드가 Method 타입의 파라미터로 전달되고, 인자 역시 Object[] 타입으로 받게 됩니다.

아래는 java.lang.Runnable 인터페이스의 프록시 인스턴스를 생성하는 예시입니다.

// RunnableProxy.java
package io.github.nnoco.annotation_in_action.ch5;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class RunnableProxy {
    public static void main(String[] args) {
        Runnable runnable = (Runnable) Proxy.newProxyInstance(
                Runnable.class.getClassLoader(),
                new Class[] { Runnable.class },
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println(method.getName() + " 메서드 호출");
                        return null;
                    }
                });
        
        runnable.run();
    }
}

runnable 변수에는 Runnable 인터페이스를 구현한 프록시 객체가 담겨 있으며, 일반적인 Runnable 인터페이스를 구현한 객체처럼 호출 할 수 있습니다. run 메서드를 호출하면 run 메서드의 정보가 invoke 메서드에 method 파라미터로 전달됩니다. method 파라미터는 4편에서 썼던 Method와 동일하며, 메서드를 실행하기 위해서는 실제 객체가 필요합니다. (위의 예시에서는 프록시가 아닌 실제 Runnable 객체가 없으므로 실행할 수 없습니다.) 그리고 메서드를 호출하면서 전달한 인자가 있다면 args 파라미터로 받을 수 있습니다.

프록시를 활용한 @Log 애너테이션 처리

Java Annotation in Action 4편의 @Log와 @Ignore 애너테이션은 그대로 사용하고, 프록시 객체는 인터페이스에 대해서만 생성할 수 있으므로, ICalculator 인터페이스를 작성하고 Calculator 클래스에서는 해당 인터페이스를 구현하도록 수정해 보겠습니다.

// Calculator.java
package io.github.nnoco.annotation_in_action.ch5;

import io.github.nnoco.annotation_in_action.ch4.Ignore;
import io.github.nnoco.annotation_in_action.ch4.Log;

// ICalculator 인터페이스를 구현합니다.
public class Calculator implements ICaculator {
    public long plus(int operand1, int operand2) {
        return operand1 + operand2;
    }

    public long minus(int operand1, int operand2) {
        return operand1 - operand2;
    }
}

// ICalculator.java
package io.github.nnoco.annotation_in_action.ch5;

import io.github.nnoco.annotation_in_action.ch4.Log;
import io.github.nnoco.annotation_in_action.ch4.Ignore;

public interface ICaculator {
    long plus(int operand1, int operand2);

    // 애너테이션은 인터페이스의 메서드에 태그합니다.
    @Log
    long minus(int operand1, @Ignore int operand2);
}

기존의 Calculator 클래스의 메서드를 ICalculator 인터페이스로 옮긴 후 implements ICalculator를 추가해 줍니다. 이 때 태그되어 있던 애너테이션은 인터페이스 쪽으로 옮겨 줍니다. 프록시에서는 인터페이스의 메서드 정보만을 알고 있으므로, 인터페이스를 구현한 클래스의 애너테이션은 알지 못합니다. 이제 인터페이스는 준비되었으므로 InvocationHandler 구현 클래스를 작성할 차례입니다. InvocationHandler를 구현하는 클래스는 로그를 출력하고 실제 객체의 메서드를 호출해야 하므로 프록시 대상 객체를 담아둘 멤버 변수를 정의하고, 생성자를 통해 초기화하도록 합니다.

// LogProxy.java
package io.github.nnoco.annotation_in_action.ch5;

import io.github.nnoco.annotation_in_action.ch4.Ignore;
import io.github.nnoco.annotation_in_action.ch4.Log;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.lang.reflect.Proxy;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class LogProxy implements InvocationHandler {
    private Object object;

    public LogProxy(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        boolean logAnnotationPresented = method.isAnnotationPresent(Log.class);

        // Log 애너테이션이 있으면 메서드를 호출하기 전에 파라미터를 로그로 출력
        if(logAnnotationPresented) {
            String parameterLog = getParameterLog(method.getParameters(), args);

            System.out.println(method.getName() + " 메서드 시작. " + parameterLog);
        }

        // 리플렉션을 통해 메서드 실행
        Object result = method.invoke(object, args);

        // Log 애너테이션이 있으면 리턴 값을 출력
        if(logAnnotationPresented) {
            System.out.println(method.getName() + " 메서드 끝. " + result);
        }

        // 값 반환
        return result;
    }

    String getParameterLog(Parameter[] parameters, Object[] arguments) {
        return IntStream.range(0, parameters.length)
                .boxed()
                // Ignore 애너테이션이 태그되지 않은 파라미터만 필터합니다.
                .filter(i -> !parameters[i].isAnnotationPresent(Ignore.class))

                // "파라미터 이름=인자"를 반환합니다.
                // 바이트코드에 파라미터 이름이 유지되어야 파라미터 이름을 얻을 수 있고,
                // 그렇지 않은 경우 argN 형식의 이름을 반환합니다.
                .map(i -> parameters[i].getName() + "=" + arguments[i])
                .collect(Collectors.joining(", "));
    }
}

InvocationHandler 인터페이스를 구현했으므로 invoke 메서드를 구현하는 것 이외에 기존의 CalculatorReflection.calculateWithLog 메서드와 큰 차이점은 없습니다. 다만 invoke 메서드가 파라미터로 method와 인자인 args를 받게 되므로 Class 정보로부터 실행할 메서드를 찾는 과정이 없어졌습니다. 또한 Calculator 클래스에만 국한되지 않고 모든 타입에 대해 LogProxy를 적용할 수 있도록 했습니다.

작성한 LogProxy를 테스트 해 봅시다.

// LogProxyTest.java
package io.github.nnoco.annotation_in_action.ch5;

import java.lang.reflect.Proxy;

public class LogProxyTest {
    public static void main(String[] args) {
        ICalculator calculator = (ICalculator) Proxy.newProxyInstance(
                Calculator.class.getClassLoader(),
                new Class[] { ICalculator.class },
                new LogProxy(new Calculator()));

        calculator.minus(1, 2);
    }
}

Proxy.newProxyInstance 메서드를 통해 프록시 객체를 생성합니다. ICalculator 인터페이스를 전달하고, LogProxy 객체를 생성하여 InvocationHandler를 전달합니다. Proxy.newProxyInstance 메서드의 반환 타입을 ICalculator 타입으로 형변환 해 주는데, 이 때 구현 타입인 Calculator 타입으로 형변환을 하면 ClassCastException이 발생하므로 주의해야 합니다.

LogProxyTest의 main 메서드를 실행해 보면 이 전의 로그 처리와 동일하게 동작하는 것을 확인할 수 있고, 이제 Calculator가 아닌 다른 타입에 대해서도 @Log 애너테이션 처리를 할 수 있게 되었습니다.

// 실행 결과
minus 메서드 시작. operand1=1
minus 메서드 끝. -1

여기까지 Java Annotation in Action 3, 4, 5편을 통해 리플렉션과 리플렉션을 이용해 애너테이션을 읽고 처리하는 방법을 다뤄봤습니다. 클래스나 생성자 등 아직 다루지 않은 리플렉션의 영역들이 있지만 시리즈의 나머지 편에서 보다 실용적인 예제들과 함께 리플렉션의 추가적인 내용을 다뤄보도록 하겠습니다.

* 작성한 코드는 GitHub Repository에서 확인하실 수 있습니다.

References

Java Annotation in Action 4

2020-05-16T21:31:34+09:00

Java Annotation in Action 3편에서는 필드에 애너테이션을 태그하여 필드의 값을 체크해 봤습니다. 이번 편에서는 리플렉션을 통해 메서드와 파라미터의 애너테이션을 다뤄봅니다.

메서드의 경우에도 필드를 가져올 때와 유사하게 대상 클래스의 Class 객체를 얻고, Class의 getMethod(String, Class...), getMethods() 메서드나 getDeclaredMethod(String, Class...), getDeclaredMethods() 메서드를 이용해 클래스에 정의되어 있는 메서드를 가져올 수 있습니다.

먼저 간단한 계산을 할 수 있는 Calculator 클래스를 작성합니다.

// Calculator.java
package io.github.nnoco.annotation_in_action.ch4;

public class Calculator {
    public long plus(int operand1, int operand2) {
        return operand1 + operand2;
    }
}

Calculator 클래스에 정의된 plus 메서드를 리플렉션을 통해 가져오기 위해 CalculatorReflection 클래스를 작성해 봅시다.

// CalculatorReflection.java
package io.github.nnoco.annotation_in_action.ch4;

import java.lang.reflect.Method;

public class CalculatorReflection {
    void getPlusMethodBySeveralWays() throws Exception {
        Class<?> clazz = Calculator.class;

        // getMethod(이름, 파라미터 타입 가변인자)로 plus 메서드를 가져옵니다.
        // 해당 클래스에 정의된 public 메서드 또는 상속 받은 public 메서드만 가져올 수 있습니다.
        Method plus1 = clazz.getMethod("plus", int.class, int.class);

        // getMethods()로 모든 메서드 목록을 배열로 가져옵니다.
        // 해당 클래스에 정의된 public 메서드 또는 상속 받은 public 메서드만 가져올 수 있습니다.
        Method[] methods1 = clazz.getMethods();

        // getDeclaredMethod(이름, 파라미터 타입 가변인자)로 plus 메서드를 가져옵니다.
        // 상속 받은 메서드는 해당되지 않으며 해당 클래스에 정의된 메서드만 가져옵니다.
        Method plus2 = clazz.getDeclaredMethod("plus", int.class, int.class);

        // getDeclaredMethods()로 모든 메서드 목록을 배열로 가져옵니다.
        // 상속 받은 메서드는 해당되지 않으며 해당 클래스에 정의된 메서드만 가져옵니다.
        Method[] methods2 = clazz.getDeclaredMethods();
    }
}

메서드는 이름과 파라미터 타입을 지정하여 하나의 메서드를 가져오거나 클래스의 모든 메서드를 배열로 가져올 수 있습니다. getMethod()와 getMethods()의 경우 public인 메서드만 반환하며, 부모로부터 상속 받은 메서드도 포함됩니다. 반면에 getDeclaredMethod(), getDeclaredMethods()는 접근 제어 지시자와 상관없이 모든 메서드를 가져올 수 있지만 상속 받은 메서드는 포함되지 않습니다. 즉 자기 자신에게 정의된 메서드만 반환합니다. plus 메서드는 public이고 Calculator 클래스에 정의되어 있으므로 getMethod(), getDeclaredMethod() 구분없이 두 가지 방법으로 모두 가져올 수 있습니다.

특정 메서드 하나만을 반환하는 getMethod()와 getDeclaredMethod()는 메서드의 이름뿐만 아니라 메서드의 파라미터 타입을 가변인자로 전달 받습니다. 자바에서는 메서드 파라미터 타입과 개수가 다르게 하여 메서드 오버로딩을 할 수 있으므로, 오버로딩된 메서드 중 찾고자 하는 메서드를 특정하기 위해서는 메서드의 이름과 파라미터 타입이 필요하기 때문입니다.

이제 메서드와 파라미터에 애너테이션을 사용하기 위해 @Log와 @Ignore 애너테이션을 정의해 보겠습니다. 뒤에서 @Log 애너테이션이 태그된 메서드를 호출하면 메서드의 파라미터와 반환 값을 로그로 출력해볼 것입니다. @Ignore 애너테이션은 파라미터에 태그하여 로그로 출력하지 않을 때 사용합니다.

// Log.java
package io.github.nnoco.annotation_in_action.ch4;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

}

// Ignore.java
package io.github.nnoco.annotation_in_action.ch4;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface Ignore {
    
}

두 애너테이션 작성이 완료되었으면 Calculator 클래스에 minus 메서드를 추가하고 @Log와 @Ignore 애너테이션을 태그해 줍니다.

public class Calculator {
    // plus 생략

    @Log
    public long minus(int operand1, @Ignore int operand2) {
        return operand1 - operand2;
    }
}

CalculatorReflection 클래스에는 calculateWithLog 메서드를 추가해 주겠습니다. 이 메서드는 실행할 메서드의 이름과 해당 메서드를 실행할 때 전달할 인자 값을 전달받아서 메서드를 찾고 @Log 애너테이션이 있으면 메서드의 호출 전과 후에 로그를 출력합니다.

// CalculatorReflection.java
package io.github.nnoco.annotation_in_action.ch4;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class CalculatorReflection {
    // 기존 코드 생략

    public long calculateWithLog(Calculator calculator, String name, int operand1, int operand2) throws Exception {
        Class<?> clazz = Calculator.class;

        Method method = clazz.getMethod(name, int.class, int.class);

        boolean logAnnotationPresented = method.isAnnotationPresent(Log.class);

        // 처리하기 용이하도록 파라미터를 배열로 묶습니다.
        Object[] arguments = { operand1, operand2 };

        // Log 애너테이션이 있으면 메서드를 호출하기 전에 파라미터를 로그로 출력
        if(logAnnotationPresented) {
            String parameterLog = getParameterLog(method.getParameters(), arguments);

            System.out.println(name + " 메서드 시작. " + parameterLog);
        }

        // 리플렉션을 통해 메서드 실행
        long result = (long) method.invoke(calculator, arguments);

        // Log 애너테이션이 있으면 리턴 값을 출력
        if(logAnnotationPresented) {
            System.out.println(name + " 메서드 끝. " + result);
        }

        // 값 반환
        return result;
    }

    private String getParameterLog(Parameter[] parameters, Object[] arguments) {
        return IntStream.range(0, parameters.length)
                .boxed()
                // Ignore 애너테이션이 태그되지 않은 파라미터만 필터합니다.
                .filter(i -> !parameters[i].isAnnotationPresent(Ignore.class))

                // "파라미터 이름=인자"를 반환합니다.
                // 바이트코드에 파라미터 이름이 유지되어야 파라미터 이름을 얻을 수 있고,
                // 그렇지 않은 경우 argN 형식의 이름을 반환합니다.
                .map(i -> parameters[i].getName() + "=" + arguments[i])
                .collect(Collectors.joining(", "));
    }
}

한 번에 모든 코드를 작성하여 코드가 긴 느낌이 있지만 하나씩 살펴보도록 하겠습니다. 먼저 calculateWithLog 메서드는 인자로 Calculator 클래스의 인스턴스와 실행할 메서드의 이름(plus 또는 minus), 그리고 메서드에 전달할 인자인 operand1, operand2를 전달 받습니다. 이 메서드는 결과적으로 원하는 메서드를 실행하면서, 메서드에 @Log 애너테이션이 태그되어 있으면 메서드 실행 전에 파라미터를 로그로 출력하고, 실행 후에 결과를 로그로 출력합니다.

먼저 앞서 살펴본 방법으로 실행할 메서드를 Class.getMethod()를 호출하여 가져옵니다. 그리고 필드에 있는 애너테이션 태그 여부를 확인할 때와 마찬가지로 isAnnotationPresent() 메서드를 호출하여 @Log 애너테이션이 태그되어 있는지 확인합니다.

그 다음 줄에서는 인자로 전달할 operand1, operand2를 Object 배열로 묶어주는데, 이는 파라미터를 로그로 출력할 때와 메서드를 호출할 때의 편의를 위함입니다. 메서드의 파라미터는 배열로 표현되기 때문에, 동일한 인덱스로 접근할 수 있게 하기 위해 인자도 배열로 묶습니다.

@Log 애너테이션이 태그 되어 있는 경우에는 메서드를 호출하기 전에 아래에 작성한 getParameterLog 메서드를 호출하여 파라미터와 인자를 로그로 출력합니다. getParameterLog 메서드를 살펴보면 파라미터에 @Ignore 애너테이션 태그 여부를 확인하기 위해 메서드와 마찬가지로 isAnnotationPresent 메서드를 호출하여 확인합니다. 이 때 @Ignore 애너테이션이 있으면 해당 파라미터는 로그를 출력하지 않도록 하기 위해서 스트림에서 filter를 통해 걸러내 줍니다.

그리고 Parameter 클래스는 파라미터의 이름을 반환하는 getName() 메서드가 있습니다. 이 메서드는 파라미터의 이름을 반환하지만, 컴파일 시에 별다른 옵션이 없으면 소스 상의 파라미터의 이름은 제거되어 이 경우 "argN"("arg0", "arg1", …) 형식으로 반환합니다. 실제 파라미터 이름을 얻기 위해서는 자바 컴파일 시 -parameters를 추가해 주어야 합니다.

다시 calculateWithLog 메서드로 돌아와서 메서드를 실행하는 부분을 살펴봅시다. 실행할 메서드의 이름을 name 파라미터로 전달 받고 있어서 if문이나 switch 구문을 이용해 호출을 분기해 줄 수도 있지만, Method 클래스의 invoke 메서드를 이용해 리플렉션을 통해 메서드를 실행할 수도 있습니다. invoke 메서드는 해당 메서드가 실행될 실제 객체와 메서드가 실행될 때 필요한 인자를 가변인자로 전달 받습니다. 일반적인 방법으로 caculate.plus(1, 2)와 같이 메서드를 실행할 때도 Caculator 클래스의 객체가 필요하듯이 리플렉션을 통해 메서드를 실행하더라도 실제 객체가 필요합니다. method.invoke() 함수에 전달하는 객체는 해당 메서드가 있는 객체여야 합니다. 인자는 Object 타입의 가변인자를 전달받습니다. 이 때 Object 배열을 전달할 수도 있으므로 위에서 정의해 둔 arguments 변수를 사용합니다.

그리고 invoke의 반환 타입은 Object 이므로 원래의 타입인 long으로 캐스팅 하고 result 변수에 담아줍니다. 그 후 파라미터와 마찬가지로 @Log 애너테이션이 있는 경우 리턴 값을 로그로 출력해준 다음 result를 반환해 줍니다.

작성한 caculateWithLog 메서드를 테스트하기 위해 main 메서드를 아래와 같이 작성해 줍니다.

public class CalculatorReflection {
    // 기존 코드 생략

    public static void main(String[] args) throws Exception {
        Calculator calculator = new Calculator();

        CalculatorReflection calculatorReflection = new CalculatorReflection();

        // plus 메서드는 @Log가 없으므로 로그가 출력되지 않습니다.
        long plus = calculatorReflection.calculateWithLog(calculator, "plus", 1, 2);
        
        // minus 메서드는 @Log가 있으므로 로그가 출력됩니다.
        long minus = calculatorReflection.calculateWithLog(calculator, "minus", 1, 2);
    }
}

plus 메서드에는 @Log 애너테이션이 태그되어 있지 않으므로 아무런 로그도 출력되지 않습니다. @Log 애너테이션을 태그한 minus 메서드는 아래와 같이 로그가 출력되는 것을 확인할 수 있습니다.

minus 메서드 시작. arg0=1
minus 메서드 끝. -1

이번 편에서는 리플렉션을 통해 메서드와 파라미터를 읽고, 메서드를 실행해 보고 메서드와 파라미터에 태그된 애너테이션을 읽고 처리해 보았습니다. 위의 코드를 다듬어 조금 더 범용적인 calculateWithLog 메서드를 만들 수 있지만 본질적으로 아래와 같은 문제가 있습니다.

타입 안전성을 해칠 가능성
- plus, minus 메서드는 동일한 파라미터 타입과 리턴 타입을 가지고 있지만, 다른 메서드를 지원하기 위해 코드를 수정하면 안전하지 않은 타입을 갖게 될 수 있습니다.
안전하지 않은 메서드 이름
- 메서드 이름을 문자열로 전달하므로 잘못된 문자열 이름을 전달하게 될 수 있습니다.
시그니처가 다른 메서드 지원이 어려움
- 파라미터의 갯수가 한정적이고, 리턴 타입도 long으로 고정되어 있습니다. 가변인자와 제너릭을 사용해 해결할 수는 있지만 제한적입니다.

이러한 문제를 해결하기 위해서는 다음 편에서는 java.lang.reflect 패키지의 Proxy 클래스를 활용해 동일한 기능을 다이내믹 프록시로 구현해 보도록 하겠습니다.

* 작성한 코드는 GitHub Repository에서 확인하실 수 있습니다.

Java Annotation in Action 3

2020-05-06T20:11:31+09:00

Java Annotation in Action 1편과 2편에서는 애너테이션의 개념과 정의 방법을 알아보았습니다. 이번 편에서는 소스 코드에 태그된 애너테이션을 자바 리플렉션을 통해 숨을 불어 넣어줄 차례입니다. 애너테이션을 읽어 필요한 로직을 작성하는 것을 애너테이션 프로세싱(Annotation Processing)이라고 하며, 컴파일 타임과 런타임에 애너테이션 프로세싱을 할 수 있으며, 런타임에는 자바의 리플렉션을 이용합니다.

1. 리플렉션(Reflection)

위키피디아에서 리플렉션은 다음과 같이 정의하고 있습니다.

컴퓨터 프로그램에서 런타임 시점에 사용되는 자신의 구조와 행위를 관리(type introspection)하고 수정할 수 있는 프로세스를 의미한다.

자바의 리플렉션은 클래스의 상속/구현 관계, 클래스를 구성하고 있는 생성자, 멤버 변수, 멤버 메서드 등과 클래스, 멤버 등에 태그된 애너테이션을 읽어 올 수 있고, 읽는 것 뿐만 아니라 클래스의 새로운 인스턴스를 생성하거나, 멤버 변수의 값을 바꾸거나, 메서드를 실행하는 등의 기능을 수행할 수 있습니다.

이러한 정보는 java.lang.Class 클래스의 인스턴스로 표현되며, 아래의 방법으로 Class 인스턴스를 가져올 수 있습니다.

// class 키워드를 사용
Class<?> clazz = String.class;

// 객체의 getClass() 메서드를 호출
Class<?> clazz = "Hello, World!".getClass();

// Class 클래스의 forName() static 메서드를 호출
Class<?> clazz = Class.forName("java.lang.String");

상황에 맞는 방법으로 대상 클래스의 정보를 갖고 있는 Class 객체를 가져올 수 있고 Class 객체가 리플렉션의 시작점이 됩니다. 참고로 위의 코드에서 변수 이름을 clazz로 한 이유는 class가 자바의 키워드이므로 변수 이름으로 사용할 수 없기 때문입니다.

이 글에서는 리플렉션의 모든 내용을 다루지 않고 애너테이션 처리에 초점을 맞춰 필요한 기능들을 사용하며 설명을 더하도록 하겠습니다.

2. 유효성 검증 애너테이션 예제

객체의 유효성 검증을 위한 몇 가지 애너테이션을 만들고 이를 검증하는 애너테이션 처리를 개발해 보겠습니다. @NotNull 애너테이션을 정의한 후 클래스의 멤버 변수에 태그하여 해당 멤버 변수가 null이 아닌지 체크하도록 합니다.

먼저 @NotNull 애너테이션입니다.

// io.github.nnoco.annotation_in_action.ch3.validation.NotNull.java

package io.github.nnoco.annotation_in_action.ch3.validation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 멤버 변수가 null이 아님을 체크하는 애너테이션
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface NotNull {
    String message() default "";
}

런타임에도 애너테이션이 유지되도록 @Retention(RetentionPolicy.RUNTIME)을 태그하고, 멤버 변수에만 한정적으로 태그할 수 있도록 @Target(ElementType.FIELD)를 태그해 주었습니다. message 요소를 정의하여 null인 경우에 표시할 메시지를 작성할 수 있도록 하고 기본 값을 두어 꼭 전달하지 않아도 사용할 수 있게 하였습니다.

@NotNull 애너테이션을 사용하는 Book 클래스입니다.

package io.github.nnoco.annotation_in_action.ch3.validation;

/**
 * 책 정보 클래스
 */
public class Book {
    @NotNull(message = "title은 필수 항목입니다.")
    private String title;

    @NotNull(message = "author는 필수 항목입니다.")
    private String author;

    private Integer price;

    public Book(String title, String author, Integer price) {
        this.title = title;
        this.author = author;
        this.price = price;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    // 이하 Getter, Setter 생략
}

책 정보를 관리하는 Book 클래스는 제목(title), 저자(author), 가격(price)을 가지고 있으며, title, author 필드를 필수 값으로 지정하였습니다. @NotNull애너테이션의 message에 적절한 메시지를 입력하여, 어느 필드에서 유효성 검증을 통과하지 못했는지 알 수 있도록 합니다.

이제 NotNullValidator 클래스를 작성하고 리플렉션으로 @NotNull 애너테이션이 태그된 필드의 null 여부를 체크해 봅시다.

// io.github.nnoco.annotation_in_action.ch3.validation.NotNullValidator.java
package io.github.nnoco.annotation_in_action.ch3.validation;

import java.lang.reflect.Field;
import java.util.Objects;

/**
 * {@link NotNull}이 태그된 필드의 null 여부를 체크하는 유효성 검사기
 */
public class NotNullValidator {
    /**
     * 전달된 객체의 NotNull 유효성을 검증합니다.
     * @param object 유효성을 검사할 객체
     * @throws IllegalArgumentException @NotNull을 태그한 필드의 값이 null인 경우
     * @throws NullPointerException {@code object}가 null인 경우
     */
    public void validate(Object object) {
        if(Objects.isNull(object)) {
            throw new NullPointerException("object는 null일 수 없습니다.");
        }

        // 전달된 객체의 Class 객체 가져오기
        Class<?> clazz = object.getClass();

        // 해당 클래스에 정의된 모든 필드 가져오기
        Field[] fields = clazz.getDeclaredFields();

        for(Field field: fields) {
            // 필드에 태그된 NotNull 애너테이션 가져오기(없으면 null)
            NotNull notNull = field.getAnnotation(NotNull.class);

            // @NotNull 애너테이션이 태그되어 있는 경우
            if(Objects.nonNull(notNull)) {
                validateField(object, field, notNull);
            }
        }
    }

    private void validateField(Object object, Field field, NotNull notNull) {
        // 필드의 값 가져오기
        Object value = getFieldValue(object, field);

        if(Objects.isNull(value)) {
            // 필드의 값이 null이라면 예외 발생
            throw new IllegalArgumentException(notNull.message());
        }
    }

    private Object getFieldValue(Object object, Field field) {
        // private 접근 제어 지시자를 무시하도록 accessible을 true로 설정
        boolean accessible = field.isAccessible();
        field.setAccessible(true);

        // 필드의 값 가져오기
        Object value = null;
        try {
            // object 객체의 field 필드의 값 조회
            value = field.get(object);
        } catch(IllegalAccessException e) {
            // 필드에 접근할 수 없는 경우 발생 - accessible을 변경하여 발생하지 않음
            e.printStackTrace();
        }

        // 원래의 accessible로 설정
        field.setAccessible(accessible);

        return value;
    }
}

유효성 검증이 필요한 객체에 대해 NotNullValidator의 validate 메서드를 호출하여 유효성을 검증하고 유효성 검증에 실패한 경우 즉, @NotNull이 태그 되어 있는 필드의 값이 null인 경우 IllegalArgumentException을 발생시킵니다. NotNullValidator 클래스를 자세히 살펴보겠습니다.

1. Class<?> clazz = object.getClass();
validate 메서드에 전달된 object 객체의 getClass() 메서드를 호출하여 Class 객체를 가져옵니다. 이 때 object가 null이면 NullPointerException이 발생하므로 앞에서 먼저 object에 대한 null 체크를 먼저 수행해 줍니다.

2. Field[] fields = clazz.getDeclaredFields();
Field 클래스는 필드의 이름, 값 등을 가져올 수 있는 정보를 가지고 있습니다. 이러한 필드를 가져오기 위해 Class 클래스에는 getDeclaredFields() 메서드가 정의되어 있습니다. 이 메서드는 접근 플래그(private, protected, default)에 상관없이 클래스에 정의된 모든 필드를 배열로 반환합니다. 이 때 상속된 필드는 해당되지 않으므로 상속된 필드를 가져오기 위해서는 부모 클래스의 Class 객체를 가져와 getDeclaredFields() 메서드를 호출해야 합니다. getFields() 메서드는 상속받은 필드를 가져올 수 있지만 public 필드에만 해당됩니다. 이 예제에서는 상속받은 필드는 제외하도록 하겠습니다.

3. NotNull notNull = field.getAnnotation(NotNull.class); 필드에 태그된 @NotNull 애너테이션을 가져오는 부분입니다. 보이는 것처럼 리플렉션을 통해 가져온 애너테이션은 객체로 표현되고, 애너테이션에 정의된 요소에 전달한 값은 메서드를 호출하여 얻을 수 있습니다. getAnnotation() 메서드는 Java 5에 추가된 메서드로 Java 8에 추가된 @Repeatable을 지원하지 않습니다. 이를 위해 Java 8에서는 getAnnotationsByType() 메서드가 추가되었습니다. getAnnotation() 메서드는 애너테이션이 태그되어 있으면 해당 애너테이션의 객체를 반환하고 없으면 null을 반환합니다. Book 클래스의 경우 title, author에 @NotNull이 태그되어 있으므로 해당 애너테이션을 가져올 수 있습니다.

4. field.setAccessible(true);
필드의 accessible은 필드에 접근할 수 있는지 여부를 나타냅니다. private 필드의 경우 기본적으로 접근할 수 없습니다. 따라서 setAccessible(true)를 호출해 주어 접근 가능하도록 만들고, 뒤에서 필드의 값을 가져올 수 있도록 합니다. 만약 이런 식으로 객체의 캡슐화를 깨고 싶지 않다면 해당 필드의 값을 반환하는 Getter 메서드를 호출하여 값을 가져오도록 할 수도 있습니다.

5. value = field.get(object);
get() 메서드를 이용해 특정 객체의 필드에 담긴 값을 가져올 수 있습니다. 이 때 실제 객체를 인자로 넘겨줄 수 있으며, 해당 field가 정의된 객체여야 합니다. 만약 field와 object가 올바르지 않다면 IllegalArgumentException이 발생하며, field에 접근 할 수 없는 경우에는 IllegalAccessException이 발생합니다. 4번의 과정에서 accessible을 ture로 설정했으므로 IllegalAccessException은 발생하지 않고 정상적으로 값을 가져올 수 있습니다.

끝으로 validateField 메서드에서 필드의 값이 null인지 체크하고 null이라면 IllegalArgumentException을 발생시킵니다. 이 때 IllegalArgumentException의 인자로 @NotNull 애너테이션의 인스턴스인 notNull의 message()를 호출하여 애너테이션을 태그할 때 message 요소에 전달한 메시지를 전달합니다.

3. `NotNullValidator`의 동작 확인

간단히 테스트할 수 있도록 NotNullValidatorTest 클래스를 작성하여 NotNullValidator 클래스가 정상적으로 동작하는지 확인해 보겠습니다.

// io.github.nnoco.annotation_in_action.ch3.validation.NotNullValidatorTest.java
package io.github.nnoco.annotation_in_action.ch3.validation;

/**
 * NotNullValidator 동작 확인
 */
public class NotNullValidatorTest {
    public static void main(String[] args) throws IllegalAccessException {
        NotNullValidator validator = new NotNullValidator();

        Book book = new Book("Java Annotation in Action", "nnoco", 0);

        // 유효한 객체이므로 통과
        validator.validate(book);

        book.setTitle(null);
        // title이 null이므로 예외 발생
        validator.validate(book);
    }
}

첫 번째 validate() 메서드를 호출했을 때는 title과 author의 값이 있으므로 예외가 발생하지 않고 정상적으로 유효성 검증이 통과됩니다. title의 값을 바꿔주고 validate() 메서드를 호출하면 구현한 대로 IllegalArgumentException이 발생합니다.

Exception in thread "main" java.lang.IllegalArgumentException: title은 필수 항목입니다.
	at io.github.nnoco.annotation_in_action.ch3.validation.NotNullValidator.validateField(NotNullValidator.java:45)
	at io.github.nnoco.annotation_in_action.ch3.validation.NotNullValidator.validate(NotNullValidator.java:34)
	at io.github.nnoco.annotation_in_action.ch3.validation.NotNullValidatorTest.main(NotNullValidatorTest.java:18)

NotNullValidator에서는 예외를 던지는 방식으로 구현했지만 입맛에 따라 올바르지 않은 필드의 목록을 반환하도록 할 수도 있을 것입니다. 또한 accessible을 강제로 true로 설정하여 필드의 값을 가져오도록 구현했는데, @NotNull 애너테이션에 해당 필드의 값을 반환하는 Getter의 이름을 전달하도록 하여 해당 Getter를 호출하도록 하거나, 필드의 이름으로 Getter이름을 만들어(title 필드의 경우 getTitle) Getter를 가져온 후 호출하는 방법 등이 있을 것입니다.

이번 예제에서는 클래스의 필드에 태그된 애너테이션을 리플렉션을 통해 읽고 처리해보았습니다. 유사한 방법으로 클래스, 메서드, 파라미터 등에 태그된 애너테이션을 처리할 수 있으며 뒤에서 다양한 실습 예제를 통해 함께 다뤄보도록 하겠습니다.

위 코드는 GitHub Repository에서 확인하실 수 있습니다.

Jekyll 타임존 이슈

2020-05-02T00:07:51+09:00

Jekyll은 포스트의 날짜 정보를 이용해 페이지 Path를 구성하는데, 이 때 URL의 날짜가 타임존에 따라서 포스트의 날짜보다 하루가 더 큰 경우가 있다. Front Matter에 Date가 없는 경우에는 파일 이름의 날짜를 이용하고 파일 이름의 날짜에는 시간 정보가 없으므로 차이가 없다.

Front Matter에 date 속성으로 일시를 직접 작성하는 경우에 나타나는데, 이 때 타임존 오프셋까지 설정해주면 해결된다.

date: 2020-05-02 00:07:51+0900

원인을 파악하기 위해 검색하다가 보니 2013년에 작성된 Jekyll GitHub의 Issues에 있었는데, 작년 2월의 이슈로도 등록되어 있고, Jekyll 3.8.5를 사용하는 나도 그런 걸 보면 해결하기 어려운 이슈인걸까.

포스트에 Series 적용하기

2020-05-01T22:08:01+09:00

대개의 경우 글을 쓸 때 단편적인 글을 쓰지만 하나의 주제를 연재식으로 쓸 때가 있다. 이러한 시리즈글은 태그나 카테고리로는 표현이 어려우므로 커스터마이징이 필요했다. 시리즈를 구현하기 위한 방법으로 커스텀 플러그인을 개발하거나 컬렉션 등을 활용할 수 있겠지만, 현재 블로그에서는 Jekyll의 데이터 파일을 활용해 구현하였다.

데이터 파일

데이터 파일은 말그대로 사이트에서 사용할 데이터 파일로써 YAML, JSON, CSV, TSV 파일을 _data 디렉토리에 위치 시켜 Liquid에서 사용할 수 있다. _data 하위의 디렉토리를 구성하여 데이터의 네임스페이스를 적용할 수 있어서, 시리즈를 위한 데이터 파일은 _data/series 디렉토리에 위치 시켰다.

아래는 “Java Annotation in Action” 시리즈의 데이터를 저장하기 위한 java_annotation_in_action.yaml 파일이다.

name: Java Annotation in Action
posts:
  - title: '애너테이션 소개'
    path: /dev/java/2020/05/02/Java-Annotation-in-Action-1.html

  - title: '애너테이션 작성'
    path: /dev/java/2020/05/02/Java-Annotation-in-Action-2.html

  - title: '리플렉션을 이용한 런타임 애너테이션 처리'
    path: /dev/java/2020/05/02/Java-Annotation-in-Action-3.html
    published: false
# 이하 생략

시리즈의 이름으로 name 속성과 시리즈에 포함되는 posts 속성을 정의하고, posts 하위에는 title, path, published(Optional)로 구성되는 배열을 정의했고, 이 구조를 post.html 레이아웃에서 사용하게 된다.

title: 시리즈에 포함된 글의 제목
path: 해당 포스트의 상대 경로, 링크와 현재 페이지 비교 시 사용
published: 포스트의 발행 여부, 그 때 그 때 글을 작성하고 시리즈 파일에 추가할 수도 있겠지만 미리 목록으로 보여주고 싶은 경우를 위해 추가했다. false인 경우 링크는 걸지 않고 제목 뒤에 (예정) 텍스트를 보여준다.

Jekyll은 _post 디렉토리에 작성하더라도 published의 값을 false로 주면 글을 노출시키지 않기 때문에 미리 파일을 생성해둘 수 있다.

포스트 헤더(Front Matter)에 series 속성 추가

데이터 파일을 이용해 시리즈 목록을 표시하는 방법은 포스트의 series 속성에 정의한 이름으로 데이터 파일을 찾아 시리즈를 찾도록 한다. 이 때 데이터 파일의 경로, 확장자를 제외한 파일 이름을 series 속성으로 설정한다. Java Annotation in Action 시리즈의 데이터 파일 이름은 java_annotation_in_action.yml이므로 작성하는 포스트의 헤더를 아래와 같이 작성한다.

---
title: 포스트 제목
#...기타 속성 작성
series: java_annotation_in_action
---

Post 레이아웃 수정

Post 레이아웃에서 시리즈 목록을 보여줄 위치에 아래 코드를 추가해준다. 참고로 page 변수가 렌더링 될 글의 참조 변수이고 post는 시리즈의 포스트 데이터이다.

<!-- 페이지에 series 속성이 있는 경우에만 처리 -->
{% if page.series != nil %}

<!-- data.series에서 페이지의 시리즈 이름으로 데이터를 가져옴 -->
{% assign series = site.data.series[page.series] %}
<div class="post-series">
    <header>{{ series.name }} 시리즈</header>
    <ol>
    {% for post in series.posts %}
    <li>
        <div>
        {% if post.published == false %}
        <!-- 시리즈 포스트의 published가 false인 경우에는 제목만 노출 -->
        <span class="series-not-published">{{ post.title }}</span>

        {% elsif page.url == post.path %}
        <!-- 렌더링 포스트와 시리즈 포스트의 경로가 같은 경우 제목만 노출 -->
        <span class="series-current">{{ post.title }}</span>

        {% else %}
        <!-- 그 외의 경우에는 링크 설정 -->
        <a href="{{ post.path }}">{{ post.title }}</a>
        {% endif %}
        </div>
    </li>
    {% endfor %}
    </ol>
</div>
{% endif %}

적용 결과

적당히 CSS까지 적용한 후에 series 속성이 있는 글에 표시되는 시리즈 목록은 아래와 같이 나타난다.

Java Annotation in Action 시리즈

Post 레이아웃에 적용한대로 현재 글, 다른 글, 발행되지 않은 글에 따라 다르게 적용이 되었고, 글 내용 자체에 포함이 되지 않으므로 발췌(excerpt)에도 포함되지 않는다.

아쉬운 부분

데이터 파일을 이용해 간단하고 빠르게 시리즈를 적용할 수 있었지만, 어쨌든 글과 시리즈 데이터 파일을 따로 관리해야 한다는 불편함이 있다. GitHub에서 Jekyll을 호스팅 할 때 커스텀 플러그인 적용이 어렵지만 회피할 수 있는 방법이 있으므로 Jekyll Hook을 활용해서 자동으로 시리즈를 적용할 수 있는 방법을 고려해 보아야 겠다.

Java Annotation in Action 2

2020-05-01T20:43:29+09:00

1편에서 소개한 애너테이션은 필요에 따라 직접 정의하여 활용할 수 있습니다. 이러한 애너테이션을 사용자 정의(User Defined) 또는 커스텀(Custom) 애너테이션이라고 합니다. 애너테이션도 인터페이스, 클래스와 같은 하나의 타입이며, 인터페이스의 특성을 갖습니다. 이번 글에서는 애너테이션을 작성하기 위한 문법과 애너테이션의 특성을 부여하기 위한 자바 내장 애너테이션에 대해 다뤄보겠습니다.

1. 애너테이션 타입 문법

애너테이션은 @interface 키워드를 사용하여 정의합니다. 애너테이션 정의 내에 어떠한 요소도 포함하지 않는 가장 단순한 모습의 애너테이션은 아래와 같습니다.

public @interface FirstAnnotation {
}

그리고 작성한 FirstAnnotation은 아래와 같이 태그할 수 있습니다.

@FirstAnnotation
public class FirstAnnotationTest {
	@FirstAnnotation
	private String value;
    
    @FirstAnnotation
    FirstAnnotationTest() {
    
    }
    
    @FirstAnnotation
    public static void main(@FirstAnnotation String[] args) {
    	@FirstAnnotation
        String greeting = "Hello, Annotation!";
    }
}

@FirstAnnotation 애너테이션은 위 코드에서와 같이 클래스, 멤버 변수, 메서드, 생성자, 파라미터, 로컬 변수와 패키지 정보 파일인 package-info.java 파일의 패키지 선언에도 태그할 수 있습니다.

// package-info.java 파일
@FirstAnnotation
package com.nnoco.annotation;

2. 애너테이션 타입의 요소(Element) 추가

애너테이션 타입의 본문에는 메서드 선언을 포함할 수 있으며, 이러한 메서드 선언을 애너테이션의 요소라고 합니다. 애너테이션의 요소는 제한된 반환 타입을 가지며, 일반 파라미터, 타입 파라미터, throws 절을 포함할 수 없습니다. 의사 코드로 표현한 문법은 아래와 같습니다.

[modifier] @interface <type_identifier> {
    [public abstract] <type> <element_identifier>() [default <elementValue>]; 
}

대괄호로 감싼 부분은 생략 가능하고, 꺽쇠 괄호로 감싼 부분은 필수로 입력해야 하는 부분입니다.

modifier: 인터페이스의 지시자와 동일합니다.
type_identifier: 애너테이션 타입의 이름입니다.
요소의 지시자는 생략 가능하며, public, abstract, public abstract만 가능합니다.
type: 요소의 반환 타입입니다.
element_identifier: 애너테이션 타입 요소의 이름입니다.
default: 요소의 기본 값을 설정할 수 있으며 default 값의 형식으로 사용합니다.

이 중 요소가 반환하는 타입은 자바의 원시(Primitive) 타입, String, Class, Enum, Annotation 타입 및 그들의 1차원 배열만 가능하고 자기 자신을 반환 타입으로 갖거나 애너테이션 간 타입 참조 사이클을 가질 수 없습니다.

// 애너테이션 타입 자신을 요소의 반환 타입으로 사용하는 경우 - 컴파일 오류
@interface Foo {
    Foo value();
}

// 타입 참조 사이클(상호 참조)이 발생하는 경우 - 컴파일 오류
@interface Foo {
    Bar value();
}

@interface Bar {
    Foo value();
}

애너테이션 타입의 요소의 개수에 따라 아래와 같이 명칭을 구분합니다.

마커 애너테이션(Marker Annotation): 요소가 없는 경우
단일 요소 애너테이션(Single-Element Annotation): 요소가 하나만 정의된 경우
일반 애너테이션: 2개 이상의 요소가 정의된 경우

위의 내용을 참고하여 javax.validation 패키지의 @Max 애너테이션처럼 최대 값을 제한하는 @IntMax 애너테이션을 정의해 보겠습니다.

// Log.java
public @interface Log {
    // 로그 레벨(0: Debug, 1: Info, 2: Warn, 3: Error
    int level() default 1;
    
    // 로그 앞에 붙일 접두어
    String prefix() default "";
    
    // 반환 값도 로그로 출력할지 여부
    boolean logReturn();
}

@Log 애너테이션 타입에는 로그 레벨을 설정하기 위한 level, 로그 출력 시 메시지 앞에 붙일 접두어 prefix, 반환 값을 출력하기 위한 logReturn 요소가 선언되어 있으며, level과 prefix에는 기본 값이 있어 생략할 수 있습니다. @Log 애너테이션은 아래와 같이 사용합니다.

// LogTest.java
public class LogTest {

    // level, prefix는 기본 값이 있으므로 생략 가능
    // logReturn은 기본 값이 없으므로 생략 불가
    @Log(level = 0, logReturn = false)
    public void hello() {
        System.out.println("안녕하세요.");
    }
}

애너테이션은 @애너테이션(요소 = 값)의 형태로 사용할 수 있으며, 요소가 기본 값을 가지고 있는 경우에는 생략할 수 있습니다.

이번에는 javax.validation 패키지의 @Max와 같이 값의 최대 크기를 제한하는 @IntMax 애너테이션을 정의해 보겠습니다.

// IntMax.java
public @interface IntMax {
    int value() default Integer.MAX_VALUE;
}

value라는 이름의 하나의 요소를 가지고 있는 @IntMax 애너테이션입니다. 요소 이름 중 특별히 value의 경우에는 애너테이션을 사용할 때 요소 이름을 생략할 수 있습니다.

// Point.java
public class Point {
    // 생략하지 않고 표기
    @IntMax(value = 10)
    private int x;
    
    // "value =" 부분을 생략할 수 있습니다.
    @IntMax(20)
    private int y;
}

하지만 애너테이션을 사용할 때 여러 개의 요소 값을 설정하는 경우에는 value를 생략할 수 없습니다.

요소의 반환 타입이 배열인 경우는 요소에 값을 전달할 때 배열 리터럴을 사용하여 값을 전달할 수 있으며 예시는 아래와 같습니다.

// AllowedValue.java
public @interface AllowedValue {
    String[] value();
}

// AllowedValue 사용
public class Radio {

    @AllowedValue({ "AM", "FM" })
    // 또는
    // @AllowedValue(value = { "AM", "FM" })
    private String frequencyType;
}

요소의 반환 타입이 애너테이션인 경우는 아래와 같습니다.

// Book.java
public @interface Book {
    Author author();
}

// Author.java
public @interface Author {
    String value();
}

// AnnotationInAction.java
@Book(author = @Author("nnoco"))
public class AnnotationInAction {
    // ...
}

애너테이션 타입의 요소에 값을 전달할 때는 애너테이션 표현식 그대로 @애너테이션(요소=값) 형태로 전달합니다.

3. 애너테이션 타입에 중첩 타입 정의

애너테이션 타입의 본문에는 해당 애너테이션 타입의 요소 외에도 중첩 타입(클래스, 인터페이스, 애너테이션, Enum 클래스)을 정의할 수 있습니다. 앞에서 다뤘던 @Log 애너테이션의 level 요소는 반환 타입이 int이고, level 요소의 값을 제한할 수 있는 방법이 없습니다. 이런 경우 level 요소의 반환 타입은 int 보다 enum을 사용하는 것이 적절해 보입니다.

별도의 파일에 level을 표현하기 위한 enum을 정의해도 되지만 해당 enum은 @Log 내에서만 사용되므로 @Log 애너테이션 내에 Level enum을 정의해 보겠습니다.

// Log.java
public @interface Log {
    // 로그 레벨 - 기존 int 타입에서 Level 타입으로 변경
    Level level() default Level.Info;
    
    // 로그 앞에 붙일 접두어
    String prefix() default "";
    
    // 반환 값도 로그로 출력할지 여부
    boolean logReturn();
    
    /* public 생략 */ enum Level {
        DEBUG, INFO, WARN, ERROR
    }
}

// LogTest.java
public class LogTest {

    @Log(level = Log.Level.DEBUG, logReturn = true)
    String getMessage() {
        return "Hello, Annotation!";
    }
}

애너테이션 타입인 Log 내에 중첩된 Level을 참고할 때는 @Log.Level이 아닌 Log.Level의 형식입니다. 애너테이션으로써 Log를 참조하는 것이 아니라 타입으로써 Log를 참조하기 때문입니다.

enum 클래스 외에도 일반 클래스, 인터페이스, 애너테이션 역시 애너테이션 본문 내에 중첩해서 정의할 수 있으므로 상황에 맞게 정의하여 사용할 수 있습니다.

4. 메타 애너테이션(Meta Annotation)

애너테이션 타입의 속성을 설명하기 위한 애너테이션으로 메타 애너테이션이 있습니다. 이러한 메타 애너테이션으로 @Target, @Retention, @Inherited, @Documented 그리고 @Repeatable이 있습니다.

`@Target` 애너테이션

앞서 작성했던 애너테이션들은 소스 코드의 대부분에 태그하여 사용할 수 있었습니다. @Target 애너테이션은 @Target 애너테이션이 태그된 애너테이션을 어디에 태그할 것인지 제한할 수 있습니다.

// java.lang.annotation.Target
public @interface Target {
    ElementType[] value();
}​

@Target 애너테이션은 ElementType enum 배열 타입의 value 요소가 있습니다. ElementType에는 아래와 같은 값이 정의되어 있습니다.

TYPE: 타입(클래스, 인터페이스, 애너테이션, 열거형)
FIELD: 필드(멤버 변수) 선언, 열거형 선언도 포함됩니다.
METHOD: 메서드
PARAMETER: 메서드의 파라미터
CONSTRUCTOR: 생성자
LOCAL_VARIABLE: 지역 변수
PACKAGE: package-info.java 파일의 패키지 선언
TYPE_PARAMETER: 타입 파라미터(Java 8 이상)
TYPE_USE: 타입 파라미터를 포함한 타입 식별자(Java 8 이상)
MODULE: 모듈(Java 9 이상)

예를 들어 생성자와 메서드에만 태그할 수 있는 애너테이션은 아래 코드와 같습니다.

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD})
public @interface OnlyConstructorAndMethod {
}

`@Retention` 애너테이션

애너테이션의 관점에서 애너테이션의 정보가 유지되는 단계를 나눠보면 소스 코드, .class 파일(컴파일 타입), 런타임으로 나눠 볼 수 있습니다. @Retention 애너테이션은 RetentionPolicy 열거형을 value 요소로 전달 받아 태그한 애너테이션의 정보를 어느 단계까지 유지할 지 설정할 수 있습니다.

RetentionPolicy 열거형에 정의된 상수는 아래와 같습니다.

SOURCE: 소스 코드에서만 존재하며 컴파일 타임 및 런타임에는 애너테이션 정보가 유지되지 않습니다.
CLASS: 소스 코드를 컴파일한 .class 파일까지만 유지됩니다. 런타임에는 애너테이션 정보가 유지되지 않습니다. 컴파일 타임에 애너테이션을 처리하는 경우 CLASS 상수를 사용합니다. @Retention 애너테이션을 태그하지 않는 경우 기본 값입니다.
RUNTIME: 프로그램이 실행 중인 런타임에도 애너테이션 정보가 유지됩니다.

애너테이션의 용도와 처리 시점에 따라 @Retention을 적용할 수 있습니다. 예를 들어 소스 코드의 최초 작성자를 @Author 애너테이션을 정의해 기록하기로 했다면, @Author 애너테이션은 프로그램의 기능상으로 사용하지 않으므로 소스 코드에만 존재하면 됩니다. 이런 경우 @Author 애너테이션에 @Retention(RetentionPolicy.SOURCE)을 태그하여 컴파일 타임이나 런타임에 불필요한 메모리를 차지하지 않도록 할 수 있습니다.

// Author.java

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.SOURCE)
public @interface Author {
    // 최초 작성자 이름
    String value();
}
// SourceExample.java
@Author("nnoco")
public class SourceExample {
}

만약 런타임에 애너테이션을 처리한다면 @Retention(RetentionPolicy.RUNTIME)을 태그하여 런타임에도 애너테이션이 유지되도록 하여 처리할 수 있습니다. 런타임에 처리되어야 할 애너테이션의 Retention이 RetentionPolicy.RUNTIME으로 태그되어 있지 않다면 당연하게도 애너테이션 정보를 읽을 수 없습니다.

`@Inherited` 애너테이션

애너테이션 정보는 기본적으로 하위 클래스로 상속되지 않습니다. @Inherited 애너테이션은 애너테이션이 하위 클래스로 상속되도록 합니다. 애너테이션을 처리하는 과정에서 하위 클래스에서 애너테이션을 태그하지 않았다면, 해당 요소의 상위 클래스에서 애너테이션 정보를 찾습니다. 계층 구조를 가지고 있다면 가장 상위의 클래스에 도달할 때까지 반복됩니다.

// InheritedAnnotation.java

import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface InheritedAnnotation {
}

@Inherited 애너테이션을 태그하여 하위 클래스에서도 애너테이션의 정보를 얻을 수 있도록 했고, 런타임에 처리하기 위해 @Retention(RetentionPolicy.RUNTIME)을 태그해 주었습니다.

// SuperClass.java
@InheritedAnnotation
public class SuperClass {
}

// SubClass.java
public class SubClass extends SuperClass {
    public void printInheritedAnnotation() {
        InheritedAnnotation annotation = getClass().getAnnotation(InheritedAnnotation.class);
        System.out.println(annotation);
    }
}

@InheritedAnnotation 애너테이션을 SuperClass에 태그해주면 SuperClass를 상속한 SubClass도 @InheritedAnnotation 정보를 갖고 있습니다. SubClass의 인스턴스를 생성하여 printInheritedAnnotation() 메서드를 호출하면 “@com.nnoco.aia.ch2.InheritedAnnotation()”이 출력됩니다. (패키지 위치에 따라 달라질 수 있습니다.)

만약 @Inherited 애너테이션이 없다면, 하위 클래스에서도 동일한 애너테이션을 태그해 주어야 합니다.

`@Documented` 애너테이션

@Documented 애너테이션을 태그하면 태그된 요소의 정보(public contract)에 태그된 애너테이션 정보가 포함됩니다. @Documented가 태그된 애너테이션을 태그하는 요소는 Javadoc이나 IDE에서 확인할 수 있게 됩니다.

@InheritedAnnotation에 @Documented 애너테이션을 태그하고 이를 확인해 보겠습니다.

// InheritedAnnotation.java
import java.lang.annotation.Documented;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface InheritedAnnotation {
}

IntelliJ IDEA 기준 SuperClass에 커서를 두고 F1 키를 누르면 Javadoc 주석을 확인할 수 있는데, 여기에 @InheritedAnnotation이 표시됩니다.

@Documented가 태그된 @InheritedAnnotation이 Javadoc에 표시

@InheritedAnnotation의 @Documented 부분을 주석처리하면 아래와 같이 @InheritedAnnotation이 표시되지 않습니다.

@Documented가 태그되지 않은 경우 미표시

@InheritedAnnotation의 @Inherited와 상관없이 하위 클래스에서의 Javadoc에서는 표시되지 않습니다.

SubClass에는 @InheritedAnnotation 미표시

`@Repeatable` 애너테이션

Java 8 이전에는 같은 애너테이션을 같은 요소에 여러 개 태그할 수 없었습니다. 아래 예시를 살펴보겠습니다.

먼저 멤버 변수의 별칭을 애너테이션으로 정의하기 위해 @Alias 애너테이션을 정의합니다.

// Alias.java
@Retention(RetentionPolicy.RUNTIME)
public @interface Alias {
    String value();
}

그리고 아래 Person 클래스에서 name 멤버 변수에 두 개의 별칭을 지정하기 위해 @Alias 애너테이션을 태그합니다.

// Person.java
public class Person {
    @Alias("이름")
    @Alias("성함")
    private String name;
}

Person 클래스를 컴파일 하면 컴파일 오류가 발생합니다.

Person.java:6: error: Alias is not a repeatable annotation type
    @Alias("성함")
    ^
1 error

이를 해결하기 위해 여러 개의 @Alias 애너테이션을 담을 @Aliases 애너테이션을 정의해 줍니다. @Aliases 애너테이션과 같이 다른 애너테이션의 배열을 담은 애너테이션을 컨테이너(Container) 애너테이션이라고 합니다.

// Aliases.java
@Retention(RetentionPolicy.RUNTIME)
public @interface Aliases {
    Alias[] value();
}

Person에 태그한 @Alias 애너테이션은 @Aliases 애너테이션으로 감싸서 아래와 같이 바꿔줄 수 있습니다.

// Person.java
public class Person {
    @Aliases({
        @Alias("이름"),
        @Alias("성함")
    })
    private String name;
}

Java 8에서는 @Repeatable 메타 애너테이션이 추가되어 애너테이션을 태그할 때는 @Aliases로 감싸지 않고 여러 개의 @Alias를 태그할 수 있습니다. @Alias 애너테이션에 @Repeatable 애너테이션을 추가해 보겠습니다.

// Alias.java
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Aliases.class)
public @interface Alias {
    String value();
}

@Repeatable은 value 요소로 컨테이너 애너테이션의 클래스를 받습니다. @Repeatable 애너테이션이 추가되었지만 컨테이너 클래스는 필요합니다. 이 때 컨테이너 클래스에는 @Repeatable 애너테이션이 태그된 애너테이션 배열 타입의 value 이름을 갖는 요소가 정의되어 있어야 합니다. 이름이 value가 아니거나, 타입이 일치하지 않는 경우 컴파일 오류가 발생합니다.

앞서 작성한 @Aliases 컨테이너 애너테이션은 이미 Alias[] 타입의 value 요소가 정의되어 있으므로 그대로 사용할 수 있습니다. @Alias 애너테이션에 @Repeatable(Aliases.class)를 태그했으므로 Person.java 파일은 다시 아래와 같이 작성할 수 있습니다.

// Person.java
public class Person {
    @Alias("이름")
    @Alias("성함")
    private String name;
}

여러 개의 동일한 애너테이션을 태그한 경우 리플렉션에서 getAnnotationsByType(Class<? extends Annotation>) 메서드에 @Repeatable이 태그된 애너테이션 클래스를 전달하여 배열로 가져오거나, getAnnotation(Class<? extends Annotation>) 메서드에 컨테이너 애너테이션의 클래스를 전달하여 컨테이너를 가져와 컨테이너에 포함된 애너테이션을 가져올 수 있습니다.

아래는 리플렉션을 통해 런타임에 Person 클래스의 멤버 변수에 태그된 Alias 애너테이션을 가져오는 예시입니다. 리플렉션을 통한 애너테이션 처리는 다음 글에서 상세히 다루도록 하고, 여기에서는 간략하게 설명하겠습니다.

public class AliasProcessor {
    // 컨테이너 애너테이션으로 가져오기
    public Aliases getByContainer(Class<?> type, String fieldName) throws NoSuchFieldException {
        Field field = type.getDeclaredField(fieldName);
        return field.getAnnotation(Aliases.class);
    }

    // @Repeatable이 적용된 애너테이션으로 가져오기
    public Alias[] getByItem(Class<?> type, String fieldName) throws NoSuchFieldException {
        Field field = type.getDeclaredField(fieldName);
        return field.getAnnotationsByType(Alias.class);
    }

    public Alias getByItem2(Class<?> type, String fieldName) throws NoSuchFieldException {
        Field field = type.getDeclaredField(fieldName);
        return field.getAnnotation(Alias.class);
    }

    public static void main(String[] args) throws NoSuchFieldException {
        AliasProcessor processor = new AliasProcessor();

        Aliases aliases = processor.getByContainer(Person.class, "name");
        for(Alias alias: aliases.value()) {
            System.out.println("Aliases: " + alias.value());
        }

        Alias[] aliasArray = processor.getByItem(Person.class, "name");
        for(Alias alias: aliasArray) {
            System.out.println("AliasArray: " + alias.value());
        }

        // 아래는 null을 반환
        Alias alias = processor.getByItem2(Person.class, "name");
        
        // NullPointerException 발생
        System.out.println(alias.value());
    }
}

Class 클래스에는 클래스의 모든 정보를 포함하고 있습니다. 클래스의 필드(멤버 변수)를 가져오기 위해서는 getDeclaredField(String)메서드에 필드의 이름을 전달하여 Field 객체를 가져옵니다. 그리고 해당 필드에 태그된 애너테이션을 가져오기 위해서 getAnnotation(Class) 또는 getAnnotationsByType(Class) 메서드를 사용합니다.

getAnnotation(Class) 메서드는 Java 5에서 추가된 메서드로 @Repeatable을 지원하지 않습니다. getAnnotation(Class) 메서드를 사용할 때는 컨테이너 클래스를 전달하여 컨테이너 클래스를 반환 받은 후 그 안의 value 요소에서 Alias 배열을 얻을 수 있습니다.

getAnnotationsByType(Class) 메서드는 Java 8에 @Repeatable과 함께 추가된 메서드로써 @Alias 애너테이션의 클래스를 전달하면 컨테이너 없이 Alias 배열을 가져올 수 있습니다.

애너테이션을 정의하고 태그하여 사용하는 것은 프로그램의 기능에 아무런 영향을 주지 않지만 리플렉션이나 애너테이션 처리 API를 활용하면 실제로 애너테이션을 이용해 동작하는 프로그램을 작성할 수 있습니다. 이 후의 글에서는 작성한 애너테이션을 어떻게 처리할 수 있는지에 대해 다뤄보도록 하겠습니다.

References

https://docs.oracle.com/javase/specs/jls/se8/html

Java Annotation in Action 1

2020-05-01T19:35:44+09:00

자바 5(J2SE 5) 버전 이상부터 애너테이션(Annotation) 기능을 사용할 수 있습니다. 자바의 애너테이션은 소스코드의 클래스, 메서드, 멤버 변수나 주석에 붙여 메타 데이터를 제공할 수 있습니다. 메타 데이터란 데이터의 데이터를 의미합니다. 조금 말장난 같지만 주 데이터에 필요하거나 설명하기 위한 부가적인 데이터로 볼 수 있습니다. 현실에서의 예를 들어보면 여러 전원 케이블을 구분하기 위해 케이블에 꼬리표를 붙여 냉장고의 전원 케이블인지 텔레비전의 케이블인지, 스탠드 조명의 케이블인지 구분할 수 있습니다. 이 경우 꼬리표가 전원 케이블의 메타 데이터입니다. 또한 도서의 저자, 출판사, ISDN 등의 데이터도 메타 데이터입니다.

1. 자바 애너테이션

자바의 애너테이션은 “@애너테이션 이름”의 형태로 소스코드에 태그하여 메타데이터를 표현할 수 있습니다. 간단한 예시로 자바에 내장되어 있는 애너테이션으로 @Override를 살펴보겠습니다.

public class Foo {
  @Override
  public String toString() {
    return "bar";
  }
}

위 예시에서 @Override 애너테이션은 toString 메서드에 태그되어 “toString 메서드는 상위 클래스의 toString 메서드를 오버라이드 했다”는 데이터를 추가할 수 있습니다. 자바의 메서드 자체는 오버라이드 여부를 표현할 수 없지만 애너테이션으로 “오버라이드 메서드”라는 데이터를 추가해 줄 수 있습니다. 이렇게 추가된 @Override 애너테이션은 컴파일러에서도 활용할 수 있고, 주석을 굳이 작성하지 않아도 애너테이션만으로 사람도 코드를 읽을 때 오버라이드 메서드인 것을 알 수 있게 됩니다.

애너테이션 자체는 데이터로써만 존재할 뿐 어떠한 기능을 갖는 것은 아닙니다. 자바의 리플렉션(Reflection) API나 PAPA(Pluggable Annotation Processing API)를 활용해서 컴파일 타임이나 런타임에 소스코드에 태그된 애너테이션 정보를 읽어 처리할 수 있게 합니다.

2. 자바 내장 애너테이션

자바 표준 API에 정의된 애너테이션으로는 @Override, @Deprecated, @SuprpressWarning, @SafeVaragrs, @FunctionalInterface 그리고 애너테이션 타입에 태그하는 애너테이션인 메타 애너테이션으로 @Target, @Retention, @Inherited, @Documented, @Repeatable이 있습니다.

@Override

@Override 애너테이션은 앞서 간단히 설명했듯 @Override 애너테이션을 태그한 메서드가 부모 클래스로부터 상속 받은 메서드를 재정의(Override) 함을 의미합니다.

@Deprecated

@Deprecated 애너테이션은 생성자, 필드, 지역변수, 메서드, 파라미터, 타입(클래스, 인터페이스 등) 등에 태그할 수 있고, 태그된 요소의 사용을 더 이상 권장하지 않는 경우에 사용합니다. 이를테면 메서드가 더 이상 유지보수 되지 않고, 다음 버전에서 제거되는 경우 상위 버전 호환을 위하여 @Deprecated 애너테이션을 태그하여 메서드를 사용하는 개발자에게 알립니다. 이런 경우 대개 Javadoc 주석으로 대체할 방법을 안내합니다. 직접 @Deprecated를 사용하는 경우에도 Deprecated의 이유와 대체 방법 등을 Javadoc 주석으로 안내하는 것이 좋습니다.

public class DeprecatedExample {
    /**
     * @deprecated 더 이상 {@link DeprecatedExample#a} 메서드는 유지보수 되지 않습니다.
     * {@link DeprecatedExample#b} 를 사용해 주십시오.
     */
    @Deprecated
    public void a() {
        
    }

    public void b() {
        
    }
}

a() 메서드에 @Deprecated 애너테이션과 함께 Javadoc 주석을 활용하여 설명을 적어주면, Javadoc 문서 생성 시 해당 내용이 출력되고, 대부분의 IDE에서 a() 메서드 참조 시 Deprecated 된 것을 표시해 줍니다. 아래는 IntelliJ IDEA의 예시입니다.

IntelliJ IDEA - a() 메서드 호출 시 취소선으로 표시

a() 메서드의 Javadoc

Java 9 에는 @Deprecated 애너테이션에 since, forRemoval 요소가 추가되어 보다 @Deprecated 애너테이션에 추가적인 정보를 전달할 수 있습니다. since는 Deprecated 되는 버전 문자열, forRemoval은 Deprecated의 사유가 삭제인지 true/false로 전달합니다.

// java.lang 패키지의 Runtime 클래스 내 transactionInstructions(boolean) 메서드
/**
 * Not implemented, does nothing.
 *
 * @deprecated
 * This method was intended to control instruction tracing.
 * It has been superseded by JVM-specific tracing mechanisms.
 * This method is subject to removal in a future version of Java SE.
 *
 * @param on ignored
 */
@Deprecated(since="9", forRemoval=true)
public void traceInstructions(boolean on) { }

자바 내장 타입인 Runtime 클래스의 traceInstructions(boolean) 메서드에 태그된 @Deprecated 애너테이션입니다. since 요소에 "9", forRemoval이 true인 것으로 미루어 Java 9 버전부터 Deprecated 되었고, 이 후 삭제될 수 있음을 알 수 있습니다.

@SuppressWarnings

자바 컴파일러는 정적 분석을 통해 잘못된 코드, 비효율적인 코드, 혹은 오류가 발생할 수 있는 가능성이 있는 코드를 탐지할 수 있고, 컴파일 시 옵션으로 -Xlint를 추가하면 경고 메시지를 출력해 줍니다. IDE는 소스코드 편집기에서 같은 내용을 강조하여 보여주기도 합니다.

아래는 제너릭 리스트를 타입 파라미터 없이 사용하고 있는 코드입니다.

// SuppressWarningsExample.java 

import java.util.List;
import java.util.ArrayList;

public class SuppressWarningsExample {
    public void test() {
    	// 파라미터화된 타입을 사용하지 않고 List 사용
        List list = new ArrayList();
    }
}

위의 Test.java 파일을 javac -Xlint SuppressWarningsExample.java 명령으로 컴파일하면 아래와 같은 메시지가 출력됩니다.

$ javac -Xlint SuppressWarningsExample.java
SuppressWarningsExample.java:6: warning: [rawtypes] found raw type: List
        List list = new ArrayList();
        ^
  missing type arguments for generic class List
  where E is a type-variable:
    E extends Object declared in interface List
SuppressWarningsExample.java:6: warning: [rawtypes] found raw type: ArrayList
        List list = new ArrayList();
                        ^
  missing type arguments for generic class ArrayList
  where E is a type-variable:
    E extends Object declared in class ArrayList
2 warnings

rawtypes는 타입 파라미터가 정의되었을 때 파라미터화된 타입을 전달하지 않았을 때를 일컫습니다. 만약 이러한 코드에서 의도적으로 타입 파라미터를 전달하지 않았다면 경고 메시지는 방해가 될 수 있습니다. 이럴 때 컴파일러의 경고 메시지를 출력하지 않도록 할 때 @SuppressWarnings 애너테이션을 사용할 수 있습니다.

import java.util.List;
import java.util.ArrayList;

public class SuppressWarningsExample {
    public void test() {
    	// @SuppressWarnings 애너테이션을 태그하여 컴파일 경고 무시
        @SuppressWarnings("rawtypes")
        List list = new ArrayList();
    }
}

위와 같이 경고가 발생하는 코드에 @SuppressWarnings 애너테이션을 태그한 후 컴파일하면 경고 메시지가 출력되지 않는 것을 확인할 수 있습니다.

@SuppressWarnings 애너테이션은 어떤 타입의 경고를 무시할 지 value 요소에 단일 값 또는 배열로 전달할 수 있고, 위에서는 컴파일 시 출력된 경고 메시지의 “SuppressWarningsExample.java:6: warning: [rawtypes] found raw type: List” 에서 표시된 rawtypes를 무시하도록 했습니다.

@SuppressWarnings에 전달할 수 있는 경고 타입은 아래와 같습니다.

auxiliaryclass: Warn about an auxiliary class that is hidden in a source file, and is used from other files.
cast: 불필요한 타입 캐스팅을 하는 경우
classfile: classfile 컨텐츠에 관련된 이슈가 있는 경우
deprecation: deprecated 항목을 사용하는 경우
dep-ann: Javadoc 주석에 deprecated를 표시하고 있지만 @Deprecated 애너테이션을 태그하지 않은 경우
divzero: 0으로 나누는 경우
empty: if 구분의 내용이 비어있는 경우
exports: 모듈 Export에 대한 이슈가 있는 경우
fallthrough: switch 구문에서 break 하지 않고 다음 case로 넘어가는(Fall through) 경우
finally: 정상적으로 종료되지 않는 finally 절이 있는 경우
module: 모듈 시스템과 관련된 이슈가 있는 경우
opens: 모듈 오픈에 관련된 이슈가 있는 경우
options: 커맨드 라인 옵션 사용과 관련된 문제가 있는 경우
overloads: 잘못된 오버로드와 관련된 문제가 있는 경우
overrides: 잘못된 오버라이드와 관련된 문제가 있는 경우
path: 커맨드 라인의 잘못된 경로 요소가 있는 경우
processing: 애너테이션 프로세싱과 관련된 문제가 있는 경우
rawtypes: 타입 파라미터가 정의되어 있지만 사용하지 않는 경우
removal: 삭제될 예정인 API를 사용하는 경우
requires-automatic: requires 절에서 자동 모듈을 사용하는 경우
requires-transitive-automatic: requires transitive 에서 자동 모듈을 사용하는 경우
serial: Serializable 인터페이스를 구현한 클래스에서 Serial Version ID를 정의하지 않거나, public이 아닌 경우
static: 인터페이스에서 static 멤버를 액세스하는 경우
try: try 블록 사용과 관련된 문제가 있는 경우
unchecked: (타입 체크 등의) 체크를 수행하지 않은 연산의 경우 - 예) 타입 체크를 하지 않고 타입 캐스팅
varargs: 잠재적으로 안전하지 않은 가변 인자를 가진 메서드에 관한 문제가 있는 경우

이러한 경고들은 컴파일은 수행할 수 있지만 런타임에 잠재적으로 문제를 가진 것들입니다. 따라서 경고를 없애기 위해 @SuppressWarnings 애너테이션을 무분별하게 사용하기보다, 경고를 없앨 수 있는 방법을 찾아보고, 해당 코드가 의도적으로 경고가 발생할 수 있도록 작성되었으며, 런타임에도 오류가 발생하지 않는 것이 분명할 때만 사용하는 것이 좋을 것입니다.

@SafeVarargs

메서드나 생성자에 에 가변인자(Varargs, Vargs, Variable Arguments)를 사용하면 메서드를 유연하게 사용할 수 있지만, 제너릭 가변인자를 사용하는 경우 타입 안전성이 깨질 수 있습니다. 또한 자바 언어 명세(Java Language Specification, JLS) 4.12.2에서는 파라미터화된 타입의 변수가 다른 타입의 객체를 참조하는, 힙 오염(Heap Pollution)이 발생한다고 안내하고 있습니다. (Joshua Bloch - Effective Java 3/E, Item 32에서 제너릭 가변인자의 문제점과 안전한 제너릭 가변인자를 사용하기 위한 내용을 설명하고 있습니다.)

아래 코드는 컴파일하면 unchecked 타입의 경고를 출력합니다.

// SafeVargsExample.java

public class SafeVargsExample {
    static <T> void foo(T... args) {
        // ...
    }
}

SafeVargsExample.java:2: warning: [unchecked] Possible heap pollution from parameterized vararg type T
    static  void foo(T... args) {
                             ^
  where T is a type-variable:
    T extends Object declared in method toArray(T...)
1 warning

이 경고는 마찬가지로 런타임에 오류를 발생시킬 수 있기 때문에 출력되지만, 앞서 @SuppressWarnings와 마찬가지로 코드에서 오류가 발생하지 않는 것이 분명한 경우 경고를 무시하도록 할 수 있습니다. @SuppressWarnings("unchecked") 는 위의 경고를 무시하도록 합니다. 하지만 @SuppressWarnings("unchecked")의 경우 태그한 요소의 하위 요소의 동일 타입(unchecked)의 경고를 무시하게 되므로 어떤 이유로 인해 오류를 무시하도록 한 것인지 의도를 파악하기 어렵습니다. 자바 7 버전 이 전에는 @SuppressWarnings("unchecked")를 사용했지만 자바 1.7 에는 한정적으로 제너릭 가변인자에 대한 경고를 무시하도록 하는 @SafeVarargs 애너테이션이 추가되었습니다.

// SafeVarargsExample

public class SafeVarargsExample {

    // foo 메서드에 @SafeVarargs 추가
    @SafeVarargs
    static <T> void foo(T... args) {
        // ...
    }
}

foo 메서드에 @SafeVarargs를 태그하면 컴파일 시 경고가 발생하지 않습니다.

@FunctionalInterface

Java 8에서는 함수형 프로그래밍을 위한 많은 문법과 API가 추가되었습니다. 함수형 인터페이스(Functional Interface)는 하나의 추상 메서드만을 가지는 인터페이스를 의미하며, @FunctionalInterface 애너테이션을 인터페이스에 태그하면 해당 인터페이스가 하나의 추상 메서드만 가지도록 강제합니다. @FunctionalInterface 애너테이션을 태그한 인터페이스가 2개 이상의 추상 메서드를 가진다면 컴파일 오류가 발생합니다.

// FunctionalInterfaceExample.java
@FunctionalInterface
public interface FunctionalInterfaceExample {
    public void run();

    public void execute();
}

컴파일 결과

FunctionalInterfaceExample.java:2: error: Unexpected @FunctionalInterface annotation
@FunctionalInterface
^
  FunctionalInterfaceExample is not a functional interface
    multiple non-overriding abstract methods found in interface FunctionalInterfaceExample
1 error

@FunctionalInterface 애너테이션을 태그하지 않았다면, 다른 개발자가 원래 개발자가 작성한 코드의 의도를 파악하지 못하고 실수로 메서드를 추가할 수도 있습니다. @FunctionalInterface는 이러한 일이 발생하는 것을 방지해주는 역할을 합니다.

3. 애너테이션 활용의 예시

애너테이션을 활용하면 반복되는 보일러 플레이트 코드의 작성을 줄일 수도 있고, 메서드가 호출될 때 부가적인 기능을 수행하게끔 만들 수도 있습니다. 많은 라이브러리나 프레임워크에서는 애너테이션을 활용하고 있습니다.

Lombok

Lombok은 클래스의 Getter, Setter, 생성자 등의 코드를 컴파일 타임에 자동으로 생성해 주는 라이브러리입니다.

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Getter
@NoArgsConstructor
@AllArgsConstructor
public class Book {
    private String title;
    
    @Setter
    private int price;
}

@Getter나 @Setter 메서드는 멤버 변수의 Setter와 Getter를 생성해주고, 클래스 레벨에서 태그하거나, 개별 멤버 변수에 태그할 수 있습니다. 위의 코드에서는 클래스 레벨에서 @Getter를, price 멤버 변수에 @Setter를 태그해서 title, price 멤버 변수의 Getter와 price 멤버 변수의 Setter를 자동으로 생성합니다.

@NoArgsConstructor와 @AllArgsConstructor는 생성자를 생성하도록 하는 애너테이션이며 이름대로 @NoArgsConstructor는 인자가 없는 생성자, @AllArgsConstructor는 모든 멤버 변수를 초기화하기 위한 인자를 받아 초기화하는 생성자를 생성합니다. 위 Lombok 애너테이션을 적용해서 생성된 결과는 아래와 같습니다.

public class Book {
    private String title;
    private int price;

    public Book() {
    }
    
    public Book(String title, int price) {
      this.title = title;
      this.price = price;
    }
    
    public String getTitle() {
      return this.title;
    }
    
    public int getPrice() {
      return this.price;
    }
    
    public void setPrice(int price) {
      this.price = price;
    }
}

Spring Framework

Spring Framework는 XML을 통해 할 수 있었던 애플리케이션 설정, 빈 생성 등의 작업을 애너테이션을 이용해 자바 코드에서도 할 수 있도록 지원합니다. 또한 Spring Web에서는 컨트롤러 클래스의 핸들러 메서드 매핑을 애너테이션으로 선언적으로 설정할 수 있습니다.

import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
@RequestMapping("/api/books")
public class BookApiController {
    @GetMapping
    public List<Book> getBooks() {
        // ...
    }
    
    @GetMapping("/{id}")
    public Book getBook(@PathVariable Long id) {
        // ...
    }
}

BookApiController 클래스를 @RestController 애너테이션으로 스프링의 컨트롤러 빈으로 등록하고, @XxxMapping 애너테이션들을 이용해 어떤 요청 경로에 매핑할 것인지 설정합니다. 클래스에 태그된 애너테이션들을 읽어 애플리케이션으로 들어오는 요청을 자동으로 처리할 수 있게 됩니다.

Bean Validation

Java EE(Enterprise Edition) 6 이상에서 빈의 유효성 검증을 위한 클래스들이 javax.validation 패키지에 정의되어 있으며, 폼(Form) 요청 등의 데이터를 검증하기 위해 애너테이션을 활용할 수 있습니다.

import javax.validation.constraints.Min;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Size;

public class Book {
    @Size(max = 100, message = "title은 100자를 초과할 수 없습니다.")
    @NotEmpty(message = "title은 필수 입력 항목입니다.")
    private String title;

    @Min(value = 0, message = "가격은 음수일 수 없습니다.")
    private int price;
}

길이 제한, Null 가능 여부, Empty 가능 여부, 최대/최소값, 정규표현식을 통한 패턴 체크 등의 유효성 설정을 애너테이션으로 태그하고, 유효성 검사기(Validator)로 객체에 담긴 값이 유효한지 확인할 수 있습니다.

Feign

Feign은 애너테이션 기반의 HTTP Client 라이브러리입니다.

import feign.Param;
import feign.RequestLine;
import java.util.List;

public interface BookApiClient {
    @RequestLine("GET /api/books")
    List<Book> getBooks();

    @RequestLine("Get /api/books/{id}")
    Book getBook(@Param("id") Long id);
}

HTTP 요청을 위한 정보를 담고 있는 BookApiClient 인터페이스를 작성합니다. HTTP 요청을 “어떻게” 해야하는지는 명시할 필요가 없고 “무엇을” 요청해야하는지만 애너테이션으로 정의해 주면됩니다.

import feign.Feign;
import java.util.List;

public class BookApiClientTest {
    public static void main(String[] args) {
        BookApiClient client = Feign.builder()
                .target(BookApiClient.class, "http://some.where...");

        List<Book> books = client.getBooks();
        Book book = client.getBook(1L);
    }
}

그리고 Feign 클래스를 통해 BookApiClient가 실제로 동작할 수 있도록 객체를 생성해서 별다른 HTTP 통신 관련 코드를 작성하지 않아도 인터페이스에서 정의한 메서드를 사용해서 API를 호출할 수 있습니다.

위의 예시에서 살펴본 것과 같이 애너테이션은 선언적 프로그래밍을 가능하게 해주고 반복적인 많은 코드를 작성하는 수고를 덜 수 있게 도와줄 수 있습니다. 물론 런타임에 애너테이션을 읽어 처리할 때는 그만큼 실행 속도가 느려지는 등의 단점은 있습니다.

이 후의 글에서는 직접 애너테이션을 작성하고 처리하는 방법, 속도 이슈를 해결하기 위한 방법을 다뤄보도록 하겠습니다.

문자 인코딩, 문자셋, 유니코드

2020-05-01T13:49:19+09:00

컴퓨터는 결국 0과 1로 표현됩니다. 우리가 컴퓨터를 사용하면서 보는 글자, 이미지, 파일 등도 어떤 방식으로든 0과 1로 저장이되거나 전송이 됩니다. 그래서 0과 1로 변환하는 것을 인코딩(Encoding, 부호화)이라고 하며, 이 중 글자를 0과 1로 변환하는 것을 문자 인코딩(Character Encoding)이라고 합니다.

문자 인코딩과 문자 셋

위키피디아의 부호화 문서에는 아래와 같이 정의되어 있습니다.

부호화 또는 인코딩(encoding)은 정보의 형태나 형식을 표준화, 보안, 처리 속도 향상, 저장 공간 절약 등을 위해서 다른 형태나 형식으로 변환하는 처리 혹은 그 처리 방식을 말한다.

문자 부호화에 맞게 각색해서 다시 정의해보면 “문자 부호화 또는 문자 인코딩은 문자를 저장하거나 처리하기 위한 변환 혹은 그 변환 방법을 말한다.”로 볼 수 있습니다.

컴퓨터에 맞게 한글 인코딩 방법을 아주 간단한 예를 들어보면 이와 같이 정의해볼 수 있습니다.

“2개의 byte를 사용해 자음 ㄱ은 0x0000, ㄴ은 0x0001, ㄷ은 0x0002 와 같이 변환한다.”

인코딩의 반대는 디코딩(복호화)이라고 하며, 위의 정의에서 우리는 0x0000을 디코딩하면 ㄱ이 되는 것을 알 수 있습니다.

문자 셋(문자 집합, Character set, Charset)은 문자들의 집합을 정의한 것으로 문자 셋에서 다루는 문자에 음수가 아닌 정수들을 배정한 것을 부호화된 문자 셋(coded character set, CCS)라고 합니다. ASCII, EUC-KR, UTF-8 등 대개의 문자 셋들은 부호화된 문자 셋에 해당하며, 일반적으로 문자 집합과 문자 인코딩은 어떤 문자를 사용할 수 있으며 어떤 식으로 표현되는지를 나타낸다는 점에서 동의어로 취급되기도 합니다. (위키피디아 문자 인코딩)

유니코드

컴퓨터가 개발된 초기에는 여러 나라의 문자를 다룰 필요성이 크지 않았지만(ASCII만 해도 1963년에 표준화 초판이 발간되었음) 점차 표준화된 다국어 표현을 위해 유니코드가 개발되었습니다.

유니코드(Unicode)는 전 세계의 모든 문자를 컴퓨터에서 일관되게 표현하고 다룰 수 있도록 설계된 산업 표준이며, 유니코드 협회(Unicode Consortium)가 제정한다.
(중략) 유니코드의 목적은 현존하는 문자 인코딩 방법들을 모두 유니코드로 교체하려는 것이다. 기존의 인코딩들은 그 규모나 범위 면에서 한정되어 있고, 다국어 환경에서는 서로 호환되지 않는 문제점이 있었다. 유니코드가 다양한 문자 집합들을 통합하는 데 성공하면서 유니코드는 컴퓨터 소프트웨어의 국제화와 지역화에 널리 사용되게 되었으며, …

(위키피디아 유니코드)

이러한 유니코드는 1988년에 초안이 발간되어 1991년 10월에 한글이 포함되었습니다. 이후 1996년 7월 2.0 버전에 11,172자의 새 한글 완성자 영역을 새로 지정하였습니다.

유니코드는 유니코드 평면이라는 유니코드 전체를 논리적으로 나눈 범위를 정의하고 있으며, 0번에서 16번까지 모두 17개의 유니코드 평면으로 나뉘며, 각 평면은 65536개(2의 16제곱)의 코드로 구성됩니다.

그 중 첫 번째인 0번 평면은 다국어 기본 평면(Basic multilingual plane, BMP)으로 U+0000부터 U+FFFF까지의 영역을 차지합니다. 다국어 기본 평면에는 거의 모든 근대 문자와 특수 문자가 포함되어 있으며, 그 중 대부분은 한글과 한중일 통합 한자들로 이루어져 있습니다.

<위키피디아 - 다국어 기본 평면> - 한 칸은 문자 256개를 나타냅니다.

유니코드에 할당된 문자의 값을 표현하기 위해서는 코드 포인트(code point)를 사용하고 U+를 붙여서 표시합니다. ‘가’의 유니코드 값은 U+AC00과 같이 표기합니다. 자바스크립트에서는 문자열 내에서 ‘\uAC00’과 같이 표현하기도 합니다.

이러한 코드 포인트를 인코딩하기 위한 방법으로 유니코드 변환 형식(Unicode Transformation Format, UTF) 인코딩과 국제 문자 세트(Universal Coded Character Set, UCS) 인코딩이 있습니다.

즉 UTF-8과 같은 문자셋은 유니코드 코드 포인트를 인코딩하기 위한 방법 중 하나입니다. UTF를 유니코드와 동의어로 쓰는 경우가 간혹 있는데 유의하도록 합시다.

UTF-8

UTF-8은 유니코드를 위한 가변 길이 문자 인코딩 방식 중 하나로 Universal Coded Character Set + Transformation Format - 8-bit의 약자입니다.

“가변 길이”란 한 글자를 표현하기 위해 정해진 바이트를 사용하는 것이 아니라 변할 수 있는 길이를 의미하며, UTF-8 인코딩은 유니코드 한 문자를 나타내기 위해 1바이트에서 4바이트를 사용합니다. 영문자와 같이 U+0000부터 U+007F 범위에 있는 문자들은 1바이트만 사용하며, 대부분의 문자는 2~3바이트를 사용하며, 4바이트로 표현되는 문자는 모두 다국어 기본 평면(BMP) 바깥의 유니코드 문자이며 거의 사용되지 않습니다.

UTF-8의 구조

한글 ‘가’의 경우 유니코드 코드 포인트 U+AC00이고, 이를 이진수로 표현하면 1010110000000000이 됩니다. AC00은 000800-00FFFF 범위에 들어가므로 3개의 바이트를 사용하게 되고, 1110xxxx 10xxxxxx 10xxxxxx 과 같은 형태로 인코딩되어, x부분에 이진수 값을 대체하면 됩니다. 즉 x자리에 1010-110000-000000을 채워주면 ‘가’는 UTF-8로 인코딩했을 때 11101010 10110000 10000000 이 됩니다.

UTF-16

UTF-16(16-bit Unicode Transformation Format)은 UTF-8과 마찬가지로 유니코드 문자 인코딩 방식의 하나입니다. 기본 다국어 평면(BMP)에 속하는 문자들은 그대로 16비트 값으로 인코딩이 되고, 그 이상의 문자는 특별히 정해진 방식으로 32비트로 인코딩이 됩니다.

UTF-8은 기본 다국어 평면에 속하는 글자도 1~3바이트로 길이가 달라질 수 있었지만 UTF-16은 기본 다국어 평면의 글자는 모두 2바이트로 표현됩니다. UTF-8에서 ‘가’는 11101010 10110000 10000000이었지만, UTF-16에서의 ‘가’는 10101100 00000000입니다.

UTF-16에서 유의할 점은 엔디언입니다. 엔디언이란 연속된 값을 배열하는 순서를 의미하며, 바이트의 배열 순서(Byte order)를 지칭할 때 사용하는 용어입니다. 큰 단위가 앞에 나오는 빅 엔디언(Big-endian, BE), 작은 단위가 앞에 나오는 리틀 엔디언(Little-endian, LE)으로 나눌 수 있으며 이 외에 미들 엔디언이 있습니다.

빅 엔디언은 사람이 숫자를 쓰는 것과 같이 큰 수가 앞쪽에 작은 수가 뒷쪽에 오는 방식이고 리틀 엔디안은 그 반대입니다.

예를 들어 10진수 12345는 빅 엔디언으로 쓰여있지만, 이를 리틀 엔디언으로 쓰면 54321이 됩니다. 마찬가지로 한글 ‘가’는 코드 포인트가 U+AC00으로 바이트로 나눠보면 AC와 00입니다. 이 경우 빅 엔디언으로는 AC00이 되고, 리틀 엔디언으로는 00AC가 됩니다.

이를 UTF-16에 적용해 보면 한글 ‘가’는 빅 엔디언 UTF-16(UTF-16BE)으로는 10101100 00000000 이고, 리틀 엔디언(UTF-16LE)로는 00000000 10101100이 됩니다.

빅 엔디언인지 리틀 엔디언인지 구분을 위해 BOM(Byte Order Mark, 바이트 순서 표시)를 사용하는 경우가 간혹 있습니다. BOM은 필수 사항은 아니며, BOM을 쓰려면 텍스트의 시작 부분에 나와야 합니다. (예 - 텍스트 파일의 가장 첫 부분에 BOM 코드가 들어감). BOM은 유니코드에 U+FEFF로 정의되어 있습니다.

UTF-16에서의 빅 엔디언 BOM은 FE FF이고, 리틀 엔디언은 FF FE입니다. BOM 문자는 가끔 필요할 수 있지만, 보이는 글자가 아니라서 사람이 식별할 수 없고(BOM이 있어도 텍스트 에디터 등으로 파일을 열어도 표시되지 않습니다.) 텍스트 파일을 읽거나, 네트워크로 텍스트를 전송할 때 문제가 될 수 있으므로 유의해야 합니다.

References

자바스크립트 문자열 표현하기

2020-05-01T13:47:15+09:00

문자열은 텍스트를 다루기 위한 데이터입니다. 문서의 제목, 내용, 사용자의 ID, 비밀번호, 게시글에 보이는 내용 등 글자로 된 것들 그리고 지금 쓰고 있는 이 문서도 텍스트이고 문자열로 표현될 수 있습니다. 자바스크립트에서의 문자열은 문자열 리터럴(작은 따옴표 또는 큰 따옴표로 묶인 텍스트), String 함수, 또는 다른 객체의 toString() 메서드를 호출하여 표현할 수 있습니다.

// 문자열 리터럴
let literalString = "Hello, String!"

// String 함수
let stringFunction = String("Hello, String"); // String 함수에 문자열 리터럴을 전달
let stringFunction2 = String(1); // "1"이 됩니다.

// toString() 메서드 호출
let number = 123;
let toStringResult = number.toString(); // "123"이 됩니다.

단순히 원하는 텍스트를 따옴표 안에 넣음으로써 문자열을 표현할 수도 있지만, 줄바꿈, 탭과 같은 문자는 역슬래시()기호를 붙인 문자로 표현할 수 있습니다. 이를 이스케이프(Escape)라고 합니다.

let tab = "\t"; // Tab 문자
let newLine = "\n"; // 줄바꿈 문자
let singleQuote = '\''; // 작은 따옴표(')로 둘러싼 문자열 안에서 작은 따옴표를 글자 그대로 쓰기
let noProblem = "'"; // 큰 따옴표 안의 작은 따옴표는 이스케이프 하지 않아도 됩니다.
let doubleQuote = "\""; // 큰 따움표(")로 둘러싼 문자열 안에서 큰 따옴표를 글자 그대로 쓰기

줄바꿈의 경우에는 운영체제나 환경에 따라 Carriage Return 이라는 문자를 줄바꿈에 같이 쓰기도 합니다.

타자기에서는 줄을 바꿀 때 잉크가 묻은 카트리지가 좌우로 움직이게 하는 캐리지를 줄 끝에서 다시 줄 처음으로 되돌려야 하고, 이를 캐리지 리턴이라고 합니다. 그리고 난 후 새로운 줄의 입력을 위해 종이를 밀어 올리는 Line Feed를 해줍니다. 이를 줄여서 캐리지 리턴을 CR, 라인 피드를 LF라고 하며, 이스케이프된 문자로는 각각 \r, \n 입니다. 그래서 간혹 텍스트 파일의 줄바꿈의 표현에 CR과 LF가 함께 있는 경우가 있어 파일을 읽은 후 줄 단위의 처리를 할 때 \r\n 형식으로 해줄 때도 있습니다.

이스케이프 문자 외에 한국어 키보드에 없는 다른 국가의 문자나 이모지를 입력하려면 유니코드를 활용할 수 있습니다. 유니코드를 입력하기 위해서는 \u와 함께 16진수 4자리의 유니코드 값을 적어줍니다.

// 제 성인 "이"의 한자를 유니코드 16진수로 표기하면 아래와 같습니다.
let lastName = "\u674e";
console.log(lastName); // "李" 출력

객체를 문자열로 표현하기 위해서 toString() 메서드를 호출하여 문자열을 얻을 수 있습니다. 객체 중 숫자(Number) 타입의 경우 toString() 메서드에 몇 진수로 표현할 것인지 인자로 전달할 수 있습니다.

let number = 1234;

console.log(number.toString()); // "1234" -> 10진수 그대로 문자열로 변환
console.log(number.toString(2)); // "10011010010" -> 2진수로 표현된 1234
console.log(number.toString(8)); // "2322" -> 8진수로 표현된 1234
console.log(number.toString(16)); // "4d2" -> 16진수로 표현된 1234

10진수 이상은 알파벳을 사용하여 표현하며 toString의 인자로 최대 36까지 전달할 수 있으며, 36진수의 경우에는 숫자 0~9, 알파벳 a~z(26문자)로 구성됩니다. 2보다 적은 수 또는 36보다 큰 수를 전달하면 오류가 발생합니다.

유니코드 중 이모지의 경우에는 조금 더 복잡합니다. 자바스크립트는 하나의 글자를 위해 2byte를 사용합니다. 하지만 이모지는 4byte입니다. 그러므로 이모지는 보여지는 것은 한 글자이지만, 자바스크립트 내부적으로는 두 글자입니다.

let smile = "😀";
console.log(smile.length); // 한 글자이지만 2를 출력합니다.

// charCodeAt
console.log(smile.charCodeAt(0)); // 55357 출력
console.log(smile.charCodeAt(1)); // 56832 출력

// codePointAt
console.log(smile.codePointAt(0)); // 128512 출력
console.log(smile.codePointAt(1)); // 56832 출력

문자와 문자열의 내부에서 charCodeAt은 UTF-16의 값을 반환하고, codePointAt은 유니코드 값을 반환한다고 했습니다. 스마일 이모지는 유니코드에는 하나의 글자와 값으로 정의하지만, UTF-16에는 Surrogate라는 방식으로 2byte 2개로 나누어 표현합니다.

(아래는 깊게 보지 않아도 됩니다.)

UTF-16에서 유니코드의 코드 값이 16진수 값으로 0x10000이 넘는 값은 코드 값에서 0x10000을 빼고, 뒤에서 10비트, 나머지 비트를 UTF-16의 “상위/하위 대체 영역”으로 표시된 Surrogate(상위 U+D800~U+DBFF, 하위 U+DC00~U+DFFF) 범위로 다시 대응시킵니다.

위의 스마일의 codePointAt()의 호출 결과로 128512의 값을 얻었는데, 이를 Surrogate에 대응하기 위해서는 아래와 같이 계산합니다.

유니코드 값 128512에서 0x10000(십진수로 65536) 을 뺍니다. → 62976
하위 10비트의 값을 구하기 위해 1024로 나눈 나머지를 구합니다 → 512
나머지 비트의 값을 구하기 위해 1024로 나누고 소수점은 버립니다 → 61
상위 Surrogate의 시작 값인 U+D800에 나머지 비트의 값인 61을 더합니다.
하위 Surrogate의 시작 값인 U+DC00에 하위 10비트의 값인 512를 구합니다.
이를 유니코드 이스케이프(\u16진수)로 표현해줍니다.

이를 코드로 옮기면 아래와 같습니다.

let smile = "😀";
let codePoint = smile.codePointAt(0); // 유니코드 값을 얻습니다.

let rebase = codePoint - 0x10000; // 0x10000을 빼줍니다. -> 62976

let highSurrogate = Math.floor(rebase / 1024); // 1024로 나눈 후 소수점 이하 버림
let lowSurrogate = rebase % 1024; // 1024로 나눈 나머지를 구함

highSurrogate += 0xD800; // 0xD800을 더함
lowSurrogate += 0xDC00; // 0xDC00을 더함

// 결과를 16진수로 출력
console.log(highSurrogate.toString(16)); // d83d 출력
console.log(lowSurrogate.toString(16)); // de00 출력

// 결과를 유니코드 이스케이프로 출력
console.log("\ud83d\ude00"); // 😀이 출력됩니다.

조금 복잡한 내용을 다루었는데, UTF-16와 유니코드의 관계는 아래 문서에서 별도로 다루고 있습니다.

문자 인코딩, 문자셋, 유니코드

References

https://thekevinscott.com/emojis-in-javascript/
https://unicode.org/emoji/charts/full-emoji-list.html
문자와 인코딩 개념 정리 https://devhoma.tistory.com/95
유니코드의 Surrogate Pair, Supplementary Character가 뭘까요? https://www.sysnet.pe.kr/2/0/1710
Unicode Code Point와 Surrogates Pair https://rookiecj.tistory.com/299
위키피디아 - UTF-8 https://ko.wikipedia.org/wiki/UTF-8
나무위키 - 유니코드 https://namu.wiki/w/유니코드

자바스크립트 문자열 다루기

2020-05-01T13:44:58+09:00

자바스크립트의 문자열 타입인 String의 기능과 제공하는 함수들을 다뤄봅니다.

String.fromCharCode()

UTF-16의 문자 코드들을 전달하여 해당 문자 코드에 해당되는 문자로 변환하여 문자열을 반환합니다.

console.log(String.fromCharCode(189, 43, 190, 61));
// ½+¾= 출력

String.fromCodePoint()

유니코드 코드 포인트들을 전달하여 해당 유니코드 코드 포인드에 해당하는 문자로 변환되어 반환합니다.

console.log(String.fromCodePoint(44032));
// "가" 출력

String.prototype.chartAt(index)

index에 위치한 문자를 반환합니다.

const sentence = "동해물과 백두산이 마르고 닳도록";
const index = 5;

console.log(sentence.charAt(index)); // 백

// 아래는 같은 기능을 하는 인덱스 연산자입니다.
console.log(sentence[index]); // 백

String.prototype.charCodeAt(index)

index에 위치한 문자의 UTF-16의 문자 코드를 반환합니다.

2바이트 문자의 경우 charCodeAt과 codePointAt은 글자의 반환 값이 같습니다.

console.log('안녕하세요'.charCodeAt(2)); 
// 45397 출력

String.prototype.codePointAt(index)

index에 위치한 문자의 유니코드 코드 포인트를 반환합니다.

2바이트 문자의 경우 charCodeAt과 codePointAt은 글자의 반환 값이 같습니다.

console.log('안녕하세요'.codePointAt(2)); 
// 45397 출력

String.prototype.concat(string, [, …string들])

현재 문자열에 파라미터로 전달된 문자열들을 붙입니다.

문자열에 + 연산자로 문자열을 붙이는 것과 같습니다.

console.log('Hello,' + ' World!');
console.log('Hello,'.concat(' Worl', 'd', '!'));

String.prototype.includes(포함되어 있는지 확인할 문자열)

현재 문자열에 파라미터로 전달된 문자열이 있는지 확인합니다. 있다면 true, 없으면 false입니다.

console.log('Hello'.includes('ell')); // true 출력
console.log('Hello'.includes('h')); // false 출력 - 대소문자 구분

String.prototype.endsWith(찾을 문자열)

현재 문자열이 파라미터로 전달된 찾을 문자열로 끝나는지 확인합니다.

let fileName = "profile.png";

let isPngFile = fileName.endsWith(".png");
console.log(isPngFile); // true 출력

String.prototype.indexOf(찾을 문자열)

현재 문자열에서 찾을 문자열로 시작하는 부분의 인덱스를 반환합니다. 만약 찾을 수 없다면 -1을 반환합니다.

indexOf 함수는 인덱스를 앞에서부터 찾습니다.

let message = "Hello, World!";

console.log(message.indexOf('l')); // 처음으로 l이 나오는 인덱스인 2를 출력
console.log(message.indexOf('World')); // World의 시작 인덱스인 7을 출력
console.log(message.indexOf('안녕')); // 안녕은 없으므로 -1 출력

String.prototype.lastIndexOf(찾을 문자열)

현재 문자열에서 찾을 문자열로 시작하는 부분의 인덱스를 반환합니다. 만약 찾을 수 없다면 -1을 반환합니다.

lastIndexOf 함수는 이름과 같이 뒤에서부터 찾습니다.

let message = "Hello, World!";

console.log(message.indexOf('l')); // 뒤에서부터 처음으로 l이 나오는 인덱스인 10을 출력
console.log(message.indexOf('World')); // World의 시작 인덱스인 7을 출력
console.log(message.indexOf('안녕')); // 안녕은 없으므로 -1 출력

String.prototype.match(정규표현식)

전달된 정규표현식에 일치되는 문자열이 포함된배열을 반환합니다. (정규표현식은 별도로 다루도록 하겠습니다)

let phoneNumber = '010-1234-4567';

console.log(phoneNumber.match(/\d{4}/)); // 숫자 4개가 매치된 결과를 반환
// 결과 배열
// [ "1234" ]

// 정규표현식에 global(전체 검색) 옵션 추가
console.log(phoneNumber.match(/\d{4}/)); // 숫자 4개가 매치된 결과를 반환
// 결과 배열
// [ "1234", "4567" ]

String.prototype.padEnd(맞출 문자열의 길이 n, 채울 문자열)

문자열의 길이가 파라미터로 전달된 문자열의 길이 n보다 짧으면 문자열의 뒷쪽에 채울 문자로 문자열의 길이를 맞춥니다. 채울 문자를 전달하지 않으면 공백 문자로 채워집니다.

padEnd와 padStart가 있습니다.

console.log("1".padEnd(4)); // "1    "로 공백을 채워서 글자 길이를 4글자로 맞춤
console.log("1".padEnd(4, "*")); // "1***"

console.log("1".padEnd(4, "XY")); // "1XYX"

String.prototype.padStart(맞출 문자열의 길이 n, 채울 문자열)

문자열의 길이가 파라미터로 전달된 문자열의 길이 n보다 짧으면 문자열의 앞쪽에 채울 문자로 문자열의 길이를 맞춥니다. 채울 문자를 전달하지 않으면 공백 문자로 채워집니다.

console.log("1".padStart(4)); // "   1" 출력
console.log("1".padStart(4, "0")); // "0001" 출력

// 날짜 포맷을 맞추는 예제 (yyyy-MM-dd 형식)
let now = new Date();
let year = now.getFullYear(); 

// 1~9월은 한자리이므로 0을 pad해주기
// 자바스크립트 month는 0부터 시작하므로 1을 더해줌
let month = String(now.getMonth() + 1).padStart(2, "0"); 

// 1~9일은 한자리이므로 0을 pad해주기
// day는 1부터 시작함 ;;
let day = String(now.getDate()).padStart(2, "0");

let formatted = `${year}-${month}-${day}`;

console.log(formatted); // 2020-03-21 출력

참고자료

Sentio, ergo sum

Java Annotation in Action 5

프록시를 활용한 @Log 애너테이션 처리

References

Java Annotation in Action 4

Java Annotation in Action 3

1. 리플렉션(Reflection)

2. 유효성 검증 애너테이션 예제

3. NotNullValidator의 동작 확인

Jekyll 타임존 이슈

포스트에 Series 적용하기

데이터 파일

포스트 헤더(Front Matter)에 series 속성 추가

Post 레이아웃 수정

적용 결과

아쉬운 부분

Java Annotation in Action 2

1. 애너테이션 타입 문법

2. 애너테이션 타입의 요소(Element) 추가

3. 애너테이션 타입에 중첩 타입 정의

4. 메타 애너테이션(Meta Annotation)

@Target 애너테이션

@Retention 애너테이션

@Inherited 애너테이션

@Documented 애너테이션

@Repeatable 애너테이션

References

Java Annotation in Action 1

1. 자바 애너테이션

2. 자바 내장 애너테이션

@Override

@Deprecated

@SuppressWarnings

@SafeVarargs

@FunctionalInterface

3. 애너테이션 활용의 예시

Lombok

Spring Framework

Bean Validation

Feign

문자 인코딩, 문자셋, 유니코드

문자 인코딩과 문자 셋

유니코드

UTF-8

UTF-16

References

자바스크립트 문자열 표현하기

References

자바스크립트 문자열 다루기

3. `NotNullValidator`의 동작 확인

`@Target` 애너테이션

`@Retention` 애너테이션

`@Inherited` 애너테이션

`@Documented` 애너테이션

`@Repeatable` 애너테이션