0227 ~ 0305

0227 - Filter를 통한 Logging

• LoggingFilter

@Component
public class LoggingFilter extends OncePerRequestFilter {

    protected static final Logger log = LoggerFactory.getLogger(LoggingFilter.class);

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        MDC.put("traceId", UUID.randomUUID().toString());
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        if (isAsyncDispatch(request)) {
            filterChain.doFilter(request, response);
        } else {
            doFilterWrapped(new RequestWrapper(request), new ResponseWrapper(response), filterChain);
        }
        stopWatch.stop();
        log.info("Response Time : {}(ms)", stopWatch.getTotalTimeMillis());
        MDC.clear();
    }

    protected void doFilterWrapped(RequestWrapper request, ContentCachingResponseWrapper response, FilterChain filterChain) throws ServletException, IOException {
        try {
            logRequest(request);
            filterChain.doFilter(request, response);
        } finally {
            logResponse(response);
            response.copyBodyToResponse();
        }
    }

    private static void logRequest(RequestWrapper request) throws IOException {
        String queryString = request.getQueryString();
        log.info("Request : {} uri=[{}] content-type=[{}]",
                request.getMethod(),
                queryString == null ? request.getRequestURI() : request.getRequestURI() + queryString,
                request.getContentType()
        );

        logPayload("Request", request.getContentType(), request.getInputStream());
    }

    private static void logResponse(ContentCachingResponseWrapper response) throws IOException {
        logPayload("Response", response.getContentType(), response.getContentInputStream());
    }

    private static void logPayload(String prefix, String contentType, InputStream inputStream) throws IOException {
        boolean visible = isVisible(MediaType.valueOf(contentType == null ? "application/json" : contentType));
        if (visible) {
            byte[] content = StreamUtils.copyToByteArray(inputStream);
            if (content.length > 0) {
                String contentString = new String(content);
                log.info("{} Payload: {}", prefix, contentString);
            }
        } else {
            log.info("{} Payload: Binary Content", prefix);
        }
    }

    private static boolean isVisible(MediaType mediaType) {
        final List<MediaType> VISIBLE_TYPES = Arrays.asList(
                MediaType.valueOf("text/*"),
                MediaType.APPLICATION_FORM_URLENCODED,
                MediaType.APPLICATION_JSON,
                MediaType.APPLICATION_XML,
                MediaType.valueOf("application/*+json"),
                MediaType.valueOf("application/*+xml"),
                MediaType.MULTIPART_FORM_DATA
        );

        return VISIBLE_TYPES.stream()
                .anyMatch(visibleType -> visibleType.includes(mediaType));
    }
}

• RequestWrapper

public class RequestWrapper extends HttpServletRequestWrapper {

    private final byte[] cachedInputStream;

    public RequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        InputStream requestInputStream = request.getInputStream();
        this.cachedInputStream = StreamUtils.copyToByteArray(requestInputStream);
    }

    @Override
    public ServletInputStream getInputStream() {
        return new ServletInputStream() {
            private final InputStream cachedBodyInputStream = new ByteArrayInputStream(cachedInputStream);

            @Override
            public boolean isFinished() {
                try {
                    return cachedBodyInputStream.available() == 0;
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return false;
            }

            @Override
            public boolean isReady() {
                return true;
            }

            @Override
            public void setReadListener(ReadListener readListener) {
                throw new UnsupportedOperationException();
            }

            @Override
            public int read() throws IOException {
                return cachedBodyInputStream.read();
            }
        };
    }
}

• ResponseWrapper

public class ResponseWrapper extends ContentCachingResponseWrapper {
    public ResponseWrapper(HttpServletResponse response) {
        super(response);
    }
}

[ Filter에서 요청된 HTTP 정보에 접근하기 ]

• ContentCachingRequestWrapper
  ContentCachingRequestWrapper를 상속받아 Logging Filter를 만든다면 HTTP Request를 여러 번 읽어들일 수 있다. 하지만 Request PayLoad를 읽지 못하고, content-type이 'x-www-form-urlencoded'만 지원한다.

• HttpServletRequestWrapper
  HttpServletRequestWrapper를 상속받아서 HTTP Request의 요청과 Payload를 출력

0302 - 템플릿 메소드 패턴 (Template Method Pattern)

알고리즘의 일부 단계를 서브클래스에서 정의한다.

의도

[ 의도 ]

• GoF는 다음과 같이 이패턴의 의도를 설명한다.

객체의 연산에는 알고리즘의 뼈대만을 정의하고 각 단계에서 수행할 구체적 처리는 서브클래스 쪽으로 미룹니다. 알고리즘의 구조 자체는 그대로 놔둔 채 알고리즘 각 단계 처리를 서브클래스에서 재정의할 수 있게합니다.

• 실용주의 디자인 패턴에서는 이 패턴이 상속 기반의 프레임워크에서 사용된다고 설명한다.

Template Method는 보통 상속 기반의 프레임워크에서 사용된다. 프레임워크는 작업의 90% 정도를 기반 클래스를 통해 제공하며, 애플리케이션에 용도에 맞게 맞춤화할 필요가 있는 부분은 추상 메소드로 남겨놓는다. 이 말은 곧 기반 클래스가 추상 템플릿 메소드를 호출한다는 의미이다. 사용자는 클래스를 상속하고 추상 메소드를 필요에 맞게 구현함으로써 프레임워크를 사용하게 된다.

• 패턴을 활용한 리팩터링에서는 다음과 같이 설명한다.

템플릿 메서드는 '알고리즘에서 불변적인 부분은 한 번만 구현하고 가변적인 동작은 서브클래스에서 구현할 수 있도록 남겨둔 것'을 말한다. 서브클래스에 불변적인 부분과 가변적인 부분이 뒤섞여 있다면, 불변적인 부분이 여러 서브클래스에서 중복될 것이다. 이런 코드를 Template Method 패턴으로 리팩터링하면, 불변적인 부분에 대한 구현은 한 곳에만, 즉 수퍼클래스 메서드 내의 일반화된 알고리즘에만 존재하게 되므로 코드 중복이 사라진다.

템플릿 메서드의 불변적 동작은 다음을 포함한다.

• 알고리즘을 구성하는 메서드 목록과 그 호출 순서
• 서브클래스가 꼭 오버라이드해야 할 추상 메서드
• 서브클래스가 오버라이드해도 되는 훅 메서드 hook method, 즉 구체 메서드

[ 용어 ]

• 템플릿 메소드
  • 필수 처리 절차를 정의한 메소드
  • 서브클래스가 오버라이드하는 추상 메소드들을 사용하여 알고리즘을 정의하는 메소드
• 훅 연산(hook operation)
  • 필요하다면 서브클래스에서 확장할 수 있는 기본적인 행동을 제공하는 연산(메소드)
  • 기본적으로는 아무 내용도 정의하지 않는다

[ 구현 팁 ]

• 템플릿 메소드가 호출하는 메소드들을 템플릿 메소드만 호ㅜㄹ할 수 있게 하는 것을 고려한다.
  • protected 접근 제한을 사용하면 된다
• 템플릿 메소드는 오버라이드할 수 없도록 구현하는 것을 고려한다.
  • Java라면 템플릿 메소드에 final을 달아주면 된다.
• 구현해야 하는 abstract 메소드의 수가 너무 많아지니 않도록 주의한다.
• 재정의할 abstract 메소드는 식별하기 쉽도록 접두사를 붙여주자
  • 예를 들어 메소드 이름이 Do로 시작하도록 한다.

헤드 퍼스트 디자인 패턴의 예제

public class Coffee {
    // 커피 만드는 방법
    void prepareRecipe() {
        boilWater();
        brewCoffeeGrinds();
        pourInCup();
        addSugarAndMilk();
    }
    public void boilWater() {
        System.out.println("물 끓이는 중");
    }
    public void brewCoffeeGrinds() {
        System.out.println("필터를 통해서 커피를 우려내는 중");
    }
    public void pourInCup() {
        System.out.println("컵에 따르는 중");
    }
    public void addSugarAndMilk() {
        System.out.println("설탕과 우유를 추가하는 중");
    }
}

public class Tea {
    // 홍차 만드는 방법
    void prepareRecipe() {
        boilWater();
        steepTeaBag();
        pourInCup();
        addLemon();
    }
    public void boilWater() {
        System.out.println("물 끓이는 중");
    }
    public void steepTeaBag() {
        System.out.println("차를 우려내는 중");
    }
    public void pourInCup() {
        System.out.println("컵에 따르는 중");
    }
    public void addLemon() {
        System.out.println("레몬을 추가하는 중");
    }
}

템플릿 메소드 패턴은 위의 두 클래스를 다음과 같이 리팩토링한다.

• 공통적인 부분을 뽑아 추상 클래스를 만든다.
  • 알고리즘의 세부 항목에서 차이가 있는 곳은 추상 메소드로 정의한다.

public abstract class CaffeineBeverage {
    // 알고리즘을 갖고 있는 이 메소드를 '템플릿 메소드'라 부른다
    final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }

    abstract void brew();           // 서브클래스에서 구현
    abstract void addCondiments();  // 서브클래스에서 구현

    void boilWater() {
        System.out.println("물 끓이는 중");
    }
    void pourInCup() {
        System.out.println("컵에 따르는 중");
    }
}

public class Coffee extends CaffeineBeverage {
    public void brew() {
        System.out.println("필터로 커피를 우려내는 중");
    }
    public void addCondiments() {
        System.out.println("설탕과 커피를 추가하는 중");
    }
}

public class Tea extends CaffeineBeverage {
    public void brew() {
        System.out.println("차를 우려내는 중");
    }
    public void addCondiments() {
        System.out.println("레몬을 추가하는 중");
    }
}

[ hook 메소드 ]

• 서브클래스 구현시 융통성을 발휘하기 위한 메소드
• 추상 클래스에서 선언하지만 기본적인 내용만 구현되어 있거나 내용이 비어 있는 메소드

public abstract class CaffeineBeverage {
    // 알고리즘을 갖고 있는 이 메소드를 '템플릿 메소드'라 부른다
    final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        // 고객이 원하는 경우에만 첨가물을 넣는다
        if (customerWantsCondiments()) {
            addCondiments();
        }
    }

    abstract void brew();           // 서브클래스에서 구현
    abstract void addCondiments();  // 서브클래스에서 구현

    void boilWater() {
        System.out.println("물 끓이는 중");
    }
    void pourInCup() {
        System.out.println("컵에 따르는 중");
    }

    // 이 메소드가 hook 메소드
    boolean customerWantsCondiments() {
        return true;
    }
}

람다를 사용해 서브 클래스 제거하기

1개의 추상 메소드를 사용하는 템플릿 메소드가 있다.

abstract class OnlineBanking {
    // template method
    public void processCustomer(int id) {
        Customer c = Database.getCustomerWithId(id);
        makeCustomerHappy(c);
    }
    abstract void makeCustomerHappy(Customer c);
}

이 코드를 사용하려면 서브 클래스를 작성해야 한다.

class OnlineBankingKorea extends OnlineBanking {
    @Override
    void makeCustomerHappy(Customer c) {
        System.out.println("안녕하세요 " + c.getName());
    }
}

다음과 같이 사용할 수 있다.

new OnlineBankingKorea().processCustomer(1337);

구현해야 할 추상 메소드가 하나 뿐이므로 람다의 사용을 고려해볼 수 있다.
OnlineBacking에서 abstract 키워드를 삭제하고, processCustomer 메소드가 Consumer를 받도록 수정한다.

class OnlineBanking {
    public void processCustomer(int id, Consumer<Customer> makeCustomerHappy) {
        Customer c = Database.getCustomerWithId(id);
        makeCustomerHappy.accept(c);
    }
}

이제 상속 없이 OnlineBanking 클래스를 사용할 수 있다.

new OnlineBanking()
    .processCustomer(1337,
        (Customer c) -> System.out.println("안녕하세요" + c.getName())
);

고려할 점들

• From: 실용주의 디자인 패턴

Template Method 패턴은 가능한 절제해 사용해야 한다. 클래스 자체가 전적으로 파생 클래스의 커스터마이징에 의존하는 일종의 '프레임워크가' 되면 이 역시 매우 부서지기 쉽기 때문이다. 기반 클래스는 매우 깨지기 쉽다. 나는 MFC에서 프로그래밍을 할 때, 마이크로소프트가 새로운 버전을 일ㄹ리즈할 때마다 전체 애플리케이션을 재작성해야만 했던 악몽을 떨쳐버릴 수가 없다. 종종 코드는 잘 컴파일되지만, 몇몇 기반 클래스의 메소드가 변경되어 프로그램이 제대로 실행되지 않았던 것이다.

Template Method 패턴은 또한 '이디엄'과 '패턴'사이가 얼마나 가까울 수 있는지를 보여주는 예이기도 하다. Template Method 패턴은 다형성을 조금 응용했을 뿐 패턴이란 영광의 타이틀을 쓰기엔 부족하다고 주장할 수도 있는 것이다.

• From: 패턴을 활용한 리팩터링

Template Method 패턴을 구현할 때에 실무적인 주의사항이 하나 있는데, 서브클래스에서 오버라이드해야하는 메서드가 너무 많으면 곤란하다는 것이다. 서브클래스를 구현하기가 어려워지기 때문이다. 그래서 [Design Patterns]에서는 서브클래스에서 오버라이드해야 하는 추상 메서드의 개수를 최소화해야 한다고 지적한다. 그러지 않으면 템플릿 메서드의 내용을 자세히 살펴보지 않고는 프로그래머가 어떤 메서드를 오버라이드해야 할지 쉽게 알 수 없을 것이다.

Java 같은 프로그래밍 언어에서는 템플릿 메서드를 final로 선언해 서브클래스가 실수로 오버라이드하는 것을 예방할 수도 있다. 단, 이런 방법은 클라이언트 코드에서 템플릿 메서드의 불변적인 부분을 전혀 변경할 필요가 없는 것이 확실할 때에만 사용해야 한다.

0304 - @Constraint, ConstraintValidator

스프링에서는 JSR 303 기반 어노테이션 기반으로 일관성 있는 Validation을 진행할 수 있다. 기본으로 제공하는 어노테이션 말고 @Cnstraint로 커스텀 Validation을 만들 수 있다.

[ 장점 ]

• 일관성있는 처리 방법 - 검증방법과 검증시점에 대해 통일성을 가질 수 있다. 해당 커스텀 Validation을 구현하면 @NotNull @Empty와 같은 단계인 interceptor에서 처리가 가능하다.
• 간결함 - 로직 흐름에 대한 컨텍스트가 응축돼 있어 적재적소에 사용된다면 불필요한 반복코드가 줄어든다.
• 일관성 있는 ErrorResponse - ConstraintViolationException 에러를 통해 응답을 일관성있게 리턴할 수 있다.

[ 구현 ]

• 어노테이션 생성(필드 예제)

@Constraint(validatedBy = GenderValidator.class)
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ValidGender {
    String message() default "올바른 성별을 입력해주세요";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

• ConstraintValidator를 구현한 Validator 생성

public class GenderValidtor implements ConstraintValidator<ValidGender, String>{

    @Override
    public boolean isValid(String gender, ConstraintValidatorContext context) {
        try {
            Gender.valueOf(gender.toUpperCase()); 
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}

• dto

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class CreateUserReqDto {
        @Email(message = "올바른 이메일을 입력해주세요")
        private String email;

        private String password;

        @ValidGender(message = "올바른 성별을 입력해주세요") <-- CustomValidator
        private Gender gender;
    }
}

• 추가예제

@Constraint(validatedBy = NotEqualValidator.class)
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface NotEqual {
    String message() default "상행 역과 하행 역은 같을 수 없습니다.";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

    String upStationId();

    String downStationId();

    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @interface List {
        NotEqual[] value();
    }
}

public class NotEqualValidator implements ConstraintValidator<NotEqual, Object> {
    private String upStationId;
    private String downStationId;

    @Override
    public void initialize(NotEqual constraintAnnotation) {
        this.upStationId = constraintAnnotation.upStationId();
        this.downStationId = constraintAnnotation.downStationId();
    }

    @Override
    public boolean isValid(Object object, ConstraintValidatorContext context) {
        Object upStationValue = new BeanWrapperImpl(object).getPropertyValue(upStationId);
        Object downStationValue = new BeanWrapperImpl(object).getPropertyValue(downStationId);
        return !upStationValue.equals(downStationValue);
    }
}

@NotEqual(upStationId = "upStationId", downStationId = "downStationId")
public class SectionRequest {
    @NotNull
    private Long upStationId;

    @NotNull
    private Long downStationId;
    
    // ...
}

[ 결론 ]

커스텀 어노테이션을 잘 이용하면 불필요한 반복코드가 줄어들고, 비지니스 로직에 더 집중 할 수 있다는 장점이 있다.
다만, 커스텀 어노테이션은 의도와 목적을 명확히 하여 구성원간 공감대를 이룬 후 추가하는 것이 좋다.