Java Annotation

어노테이션이란?

리플렉션이란?

public class Reflection {

    public static void main(String[] args) throws Exception {
        // Class for the class named "A"
        Class<?> clazz = Class.forName("A");

        for (Field field : clazz.getDeclaredFields()) {
            System.out.println(field.getName());
            Object instance = clazz.getDeclaredConstructor().newInstance();
            field.setAccessible(true);
            System.out.println(field.getName() + ": " + field.get(instance));
        }
    }
}

class A {
    // Public fields for demonstration
    public int a = 10;
    public int b = 20;
}

public class Reflection {

    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("A");

        for (Method method : clazz.getDeclaredMethods()) {
            for (Annotation annotation : method.getAnnotations()) {
                if (annotation.annotationType().equals(Deprecated.class)) {
                    System.out.println("Deprecated Method: " + method.getName());
                }
            }
        }
    }
}

class A {

    private int a = 10;
    private int b = 20;

    @Deprecated
    public void method1() {

    }
}

어노테이션 사용을 고려해볼 상황

어노테이션의 장점

• 코드 가독성 향상:
- 어노테이션은 메타데이터를 명확하고 간결하게 표현합니다.
- 코드의 의도와 기능을 직관적으로 파악할 수 있게 해줍니다.
- 예를 들어, @Override 어노테이션은 메서드가 상위 클래스의 메서드를 오버라이드한다는 것을 명확히 나타냅니다.

• 설정의 간소화:
- XML 설정 파일 대신 어노테이션을 사용하면 설정을 더 간단하고 직관적으로 할 수 있습니다.
- 코드 내에서 직접 설정을 관리할 수 있어 유지보수가 용이합니다.
- 예를 들어, Spring Framework에서 @Component, @Autowired 등의 어노테이션으로 빈 설정을 간소화할 수 있습니다.

• 컴파일 시점 검사:
- 특정 어노테이션을 사용하면 컴파일러가 코드의 정확성을 검증할 수 있습니다.
- 런타임 오류를 사전에 방지하여 프로그램의 안정성을 높입니다.
- 예를 들어, @FunctionalInterface 어노테이션은 해당 인터페이스가 함수형 인터페이스의 요구사항을 충족하는지 컴파일 시점에 확인합니다.

• 런타임 처리 지원:
- 어노테이션은 런타임에 리플렉션을 통해 처리될 수 있어, 동적인 기능 구현이 가능합니다.
- AOP(Aspect-Oriented Programming)를 구현하는 데 유용하게 사용됩니다.
- 예를 들어, Spring의 @Transactional 어노테이션은 메서드 실행 시 트랜잭션 처리를 동적으로 수행합니다.

• 코드 생성 및 자동화:
- 어노테이션 프로세서를 이용해 컴파일 시점에 코드를 자동으로 생성할 수 있습니다.
- 반복적인 작업을 줄이고 개발 생산성을 향상시킵니다.
- 예를 들어, Lombok 라이브러리의 @Getter, @Setter 어노테이션은 getter와 setter 메서드를 자동으로 생성합니다.

어노테이션 단점

어노테이션 종류

1. 표준 어노테이션

• @Override
• 이 어노테이션은 메서드가 슈퍼클래스에 있는 메서드를 오버라이드 하고 있음을 명시적으로 나타냅니다. 이 어노테이션을 사용하면 실수로 잘못된 메서드 식별자를 사용했을 때 컴파일러가 경고를 제공합니다.

• @Deprecated
• 더 이상 사용되지 않는 메서드나 클래스에 붙이며, 해당 요소가 곧 제거될 예정임을 나타냅니다. 컴파일러는 이 어노테이션이 붙은 코드를 사용할 때 경고를 발생시킵니다.

• @SuppressWarnings
• 컴파일러 경고를 무시하도록 지시하는데 사용됩니다.

• @SafeVarargs
• 가변 인수를 사용하는 메서드 또는 생성자가 타입에 안전하다는 것을 보장하기 위해 사용합니다. 주로 제네릭 가변 인수 메서드에서 경고를 억제하는데 사용합니다.

• @FuncionalInterface
• 인터페이스가 함수형 인터페이스임을 명시합니다. 함수형 인터페이스는 하나의 추상 메서드만을 가지는 인터페이스로, 람다 표현식에서 사용됩니다.

2. 메타 어노테이션

• @Retention
• 어노테이션의 유지 정책을 정의합니다.
• Option
• RetentionPolicy.SOURCE : 소스 코드에만 존재
• RetentionPolicy.CLASS : 컴파일 된 바이트코드에 존재. 런타임 시점에 소멸
• RetentionPolicy.RUNTIME : 런타임에도 유지됨

• @Target
• 어노테이션이 적용될 수 있는 위치를 정의합니다.
• Option
• ElementType.TYPE : 클래스, 인터페이스, 열거형에 어노테이션을 적용할 수 있습니다.
• ElementType.FIELD : 필드에 어노테이션을 적용할 수 있습니다.
• ElementType.METHOD : 메서드에 어노테이션을 적용할 수 있습니다.
• ElementType.PARAMETER : 메서드 매개변수에 어노테이션을 적용할 수 있습니다.
• ElementType.CONSTRUCTOR : 생성자에 어노테이션을 적용할 수 있습니다.
• ElementType.LOCAL_VARIABLE : 로컬 변수에 어노테이션을 적용할 수 있습니다.
• ElementType.ANNOTATION_TYPE : 다른 어노테이션에 적용할 수 있습니다.
• ElementType.PACKAGE : 패키지에 어노테이션을 적용할 수 있습니다.
• ElementType.TYPE_PARAMETER : 제네릭 타입 파라미터에 적용할 수 있습니다.
• ElementType.TYPE_USE : 타입 선언에 어노테이션을 적용할 수 있습니다.

• @Inherited
• 자식 클래스가 부모 클래스에 선언된 어노테이션을 상속받도록 합니다. 클래스 레벨에서만 적용되며 메서드나 필드에는 적용되지 않습니다.

• @Documented
• 어노테이션은 특정 어노테이션이 Javadoc으로 문서화될 때 포함되도록 합니다. 이 어노테이션은 주로 API 문서를 작성할 때 유용합니다.

• @Repeatable
• 동일한 어노테이션을 같은 대상에 여러 번 적용할 수 있도록 해줍니다. Java 8부터 지원됩니다. @Repeatable 어노테이션을 사용하려면, 이 어노테이션의 인자로 컨테이너 어노테이션을 지정해야 합니다.

사용자 정의 어노테이션 도입해보기

문제 상황

 public class JokBoCalculator {
 
	 //...
	 public static JokBo calculateJokBo(List<Card> cards) {
	
	        Collections.sort(cards);
	        Collections.reverse(cards);
	        Optional<JokBo> optionalJokBo;
	        optionalJokBo = JokBoCalculator.evaluateStraightFlush(cards);
	        if (optionalJokBo.isPresent()) {
	            return optionalJokBo.get();
	        }
	
	        optionalJokBo = JokBoCalculator.evaluateFourOfAKind(cards);
	        if (optionalJokBo.isPresent()) {
	            return optionalJokBo.get();
	        }
	
	        optionalJokBo = JokBoCalculator.evaluateFullHouse(cards);
	        if (optionalJokBo.isPresent()) {
	            return optionalJokBo.get();
	        }
	
	        optionalJokBo = JokBoCalculator.evaluateFlush(cards);
	        if (optionalJokBo.isPresent()) {
	            return optionalJokBo.get();
	        }
	
	        optionalJokBo = JokBoCalculator.evaluateStraight(cards);
	        if (optionalJokBo.isPresent()) {
	            return optionalJokBo.get();
	        }
	
	        optionalJokBo = JokBoCalculator.evaluateTwoPair(cards);
	        if (optionalJokBo.isPresent()) {
	            return optionalJokBo.get();
	        }
	
	        optionalJokBo = JokBoCalculator.evaluateOnePair(cards);
	        if (optionalJokBo.isPresent()) {
	            return optionalJokBo.get();
	        }
	
	        optionalJokBo = JokBoCalculator.evaluateHighCard(cards);
	        if (optionalJokBo.isPresent()) {
	            return optionalJokBo.get();
	        }
	
	        return JokBoCalculator.evaluateHighCard(cards).get();
	    }
    }

1. 코드 반복:
사용자의 카드를 받아 알맞은 족보를 검출하여 반환하는 로직을 수행하는데 코드를 보시면 총 9개의 족보를 처리하는 로직이 순서에 따라 반복되고 있습니다.

2. 가독성 저하 :
if문의 많은 반복으로 코드의 가독성이 떨어집니다.

3. 유연성 및 확장성 부족 포커는 많은 종류가 있고, 같은 포커 게임에서도 많은 룰이 있습니다.
예를들어 함수의 input으로 전달받는 card의 개수가 달라질 수 있습니다 ( 플레이어가 소유하고 있는 카드의 숫자나 커뮤니티 카드의 유무에 따라 달라질 수 있음). 또한 많은 룰이 있는 포커의 경우를 생각해봤을 때 확장성을 생각하지 않고 작성한 코드입니다.
 

사용자 정의 어노테이션을 사용하여 문제 해결

1. 사용자 정의 어노테이션 생성

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface JokBoEvaluator {
    int order();
}

2. 함수에 어노테이션 추가

 @JokBoEvaluator(order = 1)
    private static Optional<JokBo> evaluateStraightFlush(List<Card> cards) {

        Optional<JokBo> flushJokBo = evaluateFlush(cards);
        if (flushJokBo.isPresent()) {
            Optional<JokBo> straightJokBo = evaluateStraight(cards);
            if (straightJokBo.isPresent()) {
                return Optional.of(new JokBo(JokBoTitle.STRAIGHT_FLUSH, flushJokBo.get().getStrengthContext()));
            }
        }

        return Optional.empty();
    }

3. 족보 검출 방법 설정

    public class JokBoCalculator {
		    private static final List<Method> evaluators;
		
		    static {
		        evaluators = new ArrayList<>();
		
		        for (Method method : JokBoCalculator.class.getDeclaredMethods()) {
		            if (method.isAnnotationPresent(JokBoEvaluator.class)) {
		                evaluators.add(method);
		            }
		        }
		
		        evaluators.sort(Comparator.comparingInt(m -> m.getAnnotation(JokBoEvaluator.class).order()));
		    }
    }

1. 9가지 족보를 검산하는 함수들을 찾아냅니다. (JokBoEvaluator 어노테이션)

2. order 인자에 따라 순서대로 정렬합니다.

4. 결과 (비즈니스 로직)

 public static JokBo calculateJokBo(List<Card> cards) {

        for (Method evaluator : evaluators) {
            try {
                Optional<JokBo> result = (Optional<JokBo>) evaluator.invoke(null, cards);
                if (result.isPresent()) {
                    return result.get();
                }
            } catch (Exception e) {
                throw new RuntimeException("Error while evaluating JokBo", e);
            }
        }

        return new JokBo(JokBoTitle.NONE, new ArrayList<>());
    }

Reference