아이템 39. 명명 패턴보다 애너테이션을 사용하라

[chikeem90]

명명 패턴?

• 변수나 함수의 이름을 일관된 방식으로 작성하는 패턴

명명 패턴의 단점

1. 오타를 막기 위한 방법이 없음
   • JUnit 3에서 메서드명을 tsetSafetyOverride 라고 짓더라도 단순히 무시될 뿐 오타가 발생했다는 것을 인지하기 어려움
2. 어떤 레벨 (메서드 레벨, 클래스 레벨,, 등) 에서 적용되어야할지 제한이 어려움
   • JUnit 3에서 메서드명이 아닌 클래스명을 TestSafetyMechanisms로 지어 테스트를 수행하려고 해도 JUnit은 테스트를 무시할 뿐 어느 경고 메시지도 출력하지 않음
3. 프로그램 요소를 매개변수로 전달할 방법이 없음
   • 특정 예외를 던져야만 성공하는 테스트의 경우,, 명명 패턴으로는 처리하기가 까다로움.
     => 애너테이션을 사용하면 위 3가지 문제점을 해결할 수 있음

간단한 테스트 프레임워크 만들기

1. 애너테이션 정의 및 사용

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

• 애너태이션 타입에 선언하는 또 다른 애너테이션 => 메타애너테이션
• @Retention은 언제까지 해당 애너테이션이 유지되어야할 지 정의하는 애너테이션 (https://jeong-pro.tistory.com/234#comment14510614)
• @Target은 어느 레벨에 해당 애너테이션이 사용되어야할 지 정의하는 애너테이션

public class Sample {
    // 성공
    @Test
    public static void m1() {}

    // 무시
    public static void m2() {}

    // 실패
    @Test
    public static void m3() {
        throw new RuntimeException("실패");
    }

    // 무시
    public static void m4() {}

    // 실패
    @Test
    public void m5() {}

    // 무시
    public static void m6() {}

    // 실패
    @Test
    public static void m7() {
        throw new RuntimeException("실패");
    }

    // 무시
    public static void m8() {}
}

public class RunTests {
    public static void main(String[] args) throws Exception {
        int tests = 0;
        int passed = 0;
        Class<?> testClass = Class.forName("mainpackage.Sample");
        // 클래스에 선언된 메서드 정보 순회
        for (Method m : testClass.getDeclaredMethods()) {
            // Test 애너테이션이 있는 경우
            if (m.isAnnotationPresent(Test.class)) {
                tests++;
                try {
                    // 정적 메서드이므로 instance null로,,
                    m.invoke(null);
                    passed++;
                } catch (InvocationTargetException wrappedExc) {
                    Throwable exc = wrappedExc.getCause();
                    System.out.println(m + " 실패 : " + exc);
                } catch (Exception exc) {
                    System.out.println("잘못 사용한 @Test : " + m);
                }
            }
        }
        System.out.printf("성공: %d, 실패: %d%n", passed, tests - passed);
    }
}

2. 특정 예외 발생 테스트

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExceptionTest {
    // Throwable을 확장한 클래스를 모두 수용하도록,,
    Class<? extends Throwable> value();
}

public class Sample2 {
    // 성공
    // value는 생략 가능
    @ExceptionTest(value = ArithmeticException.class)
    public static void m1() {
        int i = 0;
        i = i / i;
    }

    // 무시
    @ExceptionTest(ArithmeticException.class)
    public static void m2() {
        int[] a = new int[0];
        int i = a[1];
    }

    // 실패
    @ExceptionTest(ArithmeticException.class)
    public static void m3() {}
}

public class RunTests2 {
    public static void main(String[] args) throws Exception {
        int tests = 0;
        int passed = 0;
        Class<?> testClass = Class.forName("mainpackage.Sample2");
        // 클래스에 선언된 메서드 정보 순회
        for (Method m : testClass.getDeclaredMethods()) {
            // Test 애너테이션이 있는 경우
            if (m.isAnnotationPresent(ExceptionTest.class)) {
                tests++;
                try {
                    // 정적 메서드이므로 instance null로,,
                    m.invoke(null);
                    System.out.printf("테스트 %s 실패: 예외를 던지지 않음%n", m);
                } catch (InvocationTargetException wrappedExc) {
                    Throwable exc = wrappedExc.getCause();
                    Class<? extends Throwable> excType = m.getAnnotation(ExceptionTest.class).value();
                    if (excType.isInstance(exc)) {
                        passed++;
                    } else {
                        System.out.printf("테스트 %s 실패: 기대한 예외 %s, 발생한 예외 %s%n", m, excType.getName(), exc);
                    }
                } catch (Exception exc) {
                    System.out.println("잘못 사용한 @ExceptionTest : " + m);
                }
            }
        }
        System.out.printf("성공: %d, 실패: %d%n", passed, tests - passed);
    }
}

3. 여러 에러 타입을 value 인자로 넘길 수 있는 애너테이션

• value를 배열로 선언하면 됨

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExceptionTest {
    Class<? extends Throwable>[] value();
}

public class Sample2 {
    @ExceptionTest(value = { IndexOutOfBoundsException.class, NullPointerException.class })
    public static void m4() {
        List<String> list = new ArrayList<>();
        list.addAll(5, null);
    }
}

public class RunTests2 {
    public static void main(String[] args) throws Exception {
        int tests = 0;
        int passed = 0;
        Class<?> testClass = Class.forName("mainpackage.Sample2");
        // 클래스에 선언된 메서드 정보 순회
        for (Method m : testClass.getDeclaredMethods()) {
            // Test 애너테이션이 있는 경우
            if (m.isAnnotationPresent(ExceptionTest.class)) {
                tests++;
                try {
                    // 정적 메서드이므로 instance null로,,
                    m.invoke(null);
                    System.out.printf("테스트 %s 실패: 예외를 던지지 않음%n", m);
                } catch (Throwable wrappedExc) {
                    Throwable exc = wrappedExc.getCause();
                    int oldPassed = passed;
                    // 배열 형태로 받아서
                    Class<? extends Throwable>[] excTypes = m.getAnnotation(ExceptionTest.class).value();
                    // 순회하면서 체크
                    for (Class<? extends Throwable> excType : excTypes) {
                        if (excType.isInstance(exc)) {
                            passed++;
                            break;
                        }
                    }
                    if (passed == oldPassed) {
                        System.out.printf("테스트 %s 실패: %s %n", m, exc);
                    }
                }
            }
        }
        System.out.printf("성공: %d, 실패: %d%n", passed, tests - passed);
    }
}

4. 여러 번 사용할 수 있는 애너테이션

• 애너테이션에 @Repeatable 메타애너테이션을 달면 한 요소에 여러 번 사용할 수 있음.
• @Repeatable 애너테이션을 사용하기 위해서는
  • @Repeatable 을 단 애너테이션을 반환하는 컨테이너 애너테이션을 정의해야 함
  • @Repeatable 에 컨테이너 애너테이션의 class 객체를 매개변수로 전달해야 함
  • 컨테이너 애너테이션은 내부 애너테이션 타입의 배열을 반환하는 value 메서드를 정의해야 함
• 주의해야할 점
  • 반복 가능 애너테이션을 여러 개 달면 하나만 달았을 때와 구분하기 위해 컨테이너 애너테이션 타입이 적용됨.
  • getAnnotationsByType 메서드는 애너테이션과 컨테이너 애너테이션을 구분하지 않지만, isAnnotationPresent 메서드는 그 둘을 구분하기 때문에 두 타입 모두 수용하도록 조건을 걸어야 함.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Repeatable(ExceptionTestContainer.class)
public @interface ExceptionTest {
    Class<? extends Throwable> value();
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExceptionTestContainer {
    ExceptionTest[] value();
}

public class Sample3 {
    @ExceptionTest(IndexOutOfBoundsException.class)
    @ExceptionTest(NullPointerException.class)
    public static void m4() {
        List<String> list = new ArrayList<>();
        list.addAll(5, null);
    }

    @ExceptionTest(IndexOutOfBoundsException.class)
    public static void m5() {
        int[] a = new int[0];
        int i = a[1];
    }
}

public class RunTests {
    public static void main(String[] args) throws Exception {
        int tests = 0;
        int passed = 0;
        Class testClass = Class.forName("mainpackage.Sample3");
        for (Method m : testClass.getDeclaredMethods()) {
            // 컨테이너 애너테이션과 애너테이션을 구분함
            // 두 타입 다 수용하도록,, 아니면 무시됨
            if (m.isAnnotationPresent(ExceptionTest.class) || m.isAnnotationPresent(ExceptionTestContainer.class)) {
                tests++;
                try {
                    m.invoke(null);
                    System.out.printf("테스트 %s 실패: 예외를 던지지 않음%n", m);
                } catch (Throwable wrappedExc) {
                    Throwable exc = wrappedExc.getCause();
                    int oldPassed = passed;
                    // 컨테이너 애너테이션과 애너테이션을 구분 안함
                    ExceptionTest[] excTests = m.getAnnotationsByType(ExceptionTest.class);
                    for (ExceptionTest excTest : excTests) {
                        if (excTest.value().isInstance(exc)) {
                            passed++;
                            break;
                        }
                    }
                    if (passed == oldPassed) {
                        System.out.printf("테스트 %s 실패: %s %n", m, exc);
                    }
                }
            }
        }
        System.out.printf("성공: %d, 실패: %d%n", passed, tests - passed);
    }
}

결론

• 애너테이션으로 할 수 있는 일을 명명 패턴으로 처리할 이유는 없음.
• 자바 프로그래머라면 자바가 제공하는 pre-defined된 애너테이션 타입들을 사용하는 것이 좋음.

참고 : instanceof vs isInstance()

• https://livenow14.tistory.com/36

[JoisFe]

Junit4 혹은 5만 사용해봐서 Junit3 경우 테스트 메서드 이름을 test로 시작하는 것을 타겟으로 테스트 한다는 것을 처음 알았습니다.
Junit3를 사용해 보았더라면 @Test 어노테이션의 감사함을 느꼈을텐데 이번 기회를 통해 감사함을 느낍니다 ㅎㅎ

저는 이미 만들어진 어노테이션을 아닌 제가 직접 어노테이션을 사용해본 경험을 되돌려 보니
validation 처리에 있었습니다.

자바와 스프링에서 제공한 @Valid, @Validated를 이용해 @NotNull과 같은 검증처리가 아닌 특별한 검증 처리를 해야하는 경우 커스텀을 해야하는 경우 어노테이션을 이용하면 매우 편리했습니다.

특정 상황을 예로 든다면
dto객체에 넘어온 회원정보와(게시글 작성자가 되겠지..) 세션에(그냥 curl로 쏠 경우 세션이 없겠지) 존재하는 회원정보가 다른 경우 에러를 발생하면 되지 않을까??

@PostMapping("/update")
@ResponseBody
public String updateBoard(@RequestBody BoardDto boardDto, HttpSession session) {

		String username =(String)session.getAttribute("id");

    boardService.updateBoard(boardDto);

    return "success";
}

@PostMapping("/update")
    @ResponseBody
    public String updateBoard(@RequestBody BoardDto boardDto, HttpSession session) {
        String username = (String) session.getAttribute("id");
        if (username == null || !username.equals(boardDto.getAuthor().getUsername())) {
            throw new RuntimeException();
        }

        boardService.updateBoard(boardDto);

        return "success";
    }

• 위 방식의 validation 처리 뭔가 중복이 많습니다.

모든 dto값이 이동하는 부분에서 세션의 정보와 dto 값을 비교하는 코드를 사용한다면 중복이 발생할 것이고..

이전 어노테이션 방식처럼 간단한 방법이 존재하지 않을까?

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = MemberValidation.class)
public @interface MemberCheck{
	String message()default "현재 로그인한 아이디와 작성자가 다릅니다.";
}

public class MemberValidation implements ConstraintValidator<MemberCheck, Member> {

@Override
    public boolean isValid(Member member, ConstraintValidatorContext context) {
HttpServletRequest req =((ServletRequestAttributes)Objects.requireNonNull(
RequestContextHolder.getRequestAttributes())).getRequest();

        String sessionId =(String)req.getSession().getAttribute("id");

        if(sessionId == null) {
					return false;
					}

	return member.getUsername().equals(sessionId);
	}
}

@PostMapping("/update")
@ResponseBody
public String updateBoard(@Validated @RequestBody BoardDto boardDto) {

boardService.updateBoard(boardDto);

    return "success";
}

• 위 예시는 급하게 짜낸 코드로 코드의 품질보다는 어노테이션을 이용하여 코드의 중복을 줄인 것으로 관점을 봐주시면 감사하겠습니다.
• 에러 핸들링 또한 안된 코드입니다.

이번 주제에 맞게 어노테이션을 이용한다면

1. 실수로 인한 문제를 차단
2. 중복을 제거

정리 감사합니다.!!