스프링 핵심 원리 - 고급편 4

인프런 강의 63일차.

 - 스프링 핵심 원리 - 고급편 (김영한 강사님)

 - 반드시 한번은 정복해야할 쉽지 않은 내용들

 - 크게 3가지 고급 개념을 학습

  1. 스프링 핵심 디자인 패턴

     > 템플릿 메소드 패턴

     > 전략 패턴

     > 템플릿 콜백 패턴

     > 프록시 패턴

     > 데코레이터 패턴

  2. 동시성 문제와 쓰레드 로컬

     > 웹 애플리케이션

     > 멀티쓰레드

     > 동시성 문제

  3. 스프링 AOP

     > 개념, 용어정리

     > 프록시 - JDK 동적 프록시, CGLIB

     > 동작 원리

     > 실전 예제

     > 실무 주의 사항

 - 기타

     > 스프링 컨테이너의 확장 포인트 - 빈 후처리기

     > 스프링 애플리케이션을 개발하는 다양한 실무 팁

 - 타입 컨버터, 파일 업로드, 활용, 쿠키, 세션, 필터, 인터셉터, 예외 처리, 타임리프, 메시지, 국제화, 검증 등등

 

3. 템플릿 메서드 패턴과 콜백 패턴

 3.1. 템플릿 메서드 패턴 - 시작

  - 로그 추적기를 막상 프로젝트에 도입하려고 하니 개발자들의 반대의 목소리가 높다.

  - 로그 추적기 도입 전과 도입 후의 코드를 비교해보자.

 

//OrderController
@GetMapping("/v0/request")
public String request(String itemId){
    orderService.orderItem(itemId)
    return "ok";
}

//OrderService
public void OrderItem(String itemId){
    orderRepository.save(itemId);
}

  - 로그추적기 도입 전 v0 소스

 

//OrderControllerV3
@GetMapping("/v3/request")
public String request(String itemId) {
    TraceStatus status = null;
    try {
        status = trace.begin("OrderController.request()");
        orderService.orderItem(itemId); //핵심 기능
 		trace.end(status);
        return "ok";
    }catch (Exception e){
        trace.exception(status, e);
        throw e;    //예외를 꼭 다시 던져줘야 한다. (trace.exception에서 예외처리를 해두었기 때문)
    }
}


//OrderServiceV3
public void OrderItem(TraceId traceId, String itemId){
    TraceStatus status = null;
    try {
        status = trace.beginSync(traceId, "OrderService.OrderItem()");
        orderRepository.save(itemId); //핵심 기능
        trace.end(status);
    }catch (Exception e){
        trace.exception(status, e);
        throw e;    //예외를 꼭 다시 던져줘야 한다. (trace.exception에서 예외처리를 해두었기 때문)
    }
}

  - 로그추적기 도입 후 v3 소스

  - V0는 해당 메서드가 실제 처리해야 하는 핵심 기능만 깔끔하게 남아있다.

  - 반면에 V3에는 핵심 기능보다 로그를 출력해야 하는 부가 기능 코드가 훨씬 더 많고 복잡하다.

  - 앞으로 코드를 설명할 때 핵심 기능과 부가 기능으로 구분해서 설명하겠다.

 

 * 핵심 기능 vs 부가 기능

  - 핵심 기능은 해당 객체가 제공하는 고유의 기능이다. 예를 들어서 orderService 의 핵심 기능은 주문 로직이다. 메서드 단위로 보면 orderService.orderItem() 의 핵심 기능은 주문 데이터를 저장하기 위해 리포지토리를 호출하는 orderRepository.save(itemId) 코드가 핵심 기능이다

  - 부가 기능은 핵심 기능을 보조하기 위해 제공되는 기능이다. 예를 들어서 로그 추적 로직, 트랜잭션 기능이 있다. 이러한 부가 기능은 단독으로 사용되지는 않고, 핵심 기능과 함께 사용된다. 예를 들어서 로그 추적 기능은 어떤 핵심 기능이 호출되었는지 로그를 남기기 위해 사용한다. 그러니까 핵심 기능을 보조하기 위해 존재한다

  - V0는 핵심 기능만 있지만, 로그 추적기를 추가한 V3코드는 핵심 기능과 부가 기능이 함께 섞여있다. V3를 보면 로그 추적기의 도입으로 핵심 기능 코드보다 부가 기능을 처리하기 위한 코드가 더 많아졌다. 소위 배보다 배꼽이 큰 상황이다. 만약 클래스가 수백 개라면 어떻게 하겠는가?

 

TraceStatus status = null;
try {
    status = trace.begin("message");
    //핵심 기능 호출
    trace.end(status);
} catch (Exception e) {
    trace.exception(status, e);
    throw e;
}

  - V3 코드를 유심히 잘 살펴보면 다음과 같이 동일한 패턴이 있다.

  - Controller , Service , Repository 의 코드를 잘 보면, 로그 추적기를 사용하는 구조는 모두 동일하다.
  - 중간에 핵심 기능을 사용하는 코드만 다를 뿐이다.

  - 부가 기능과 관련된 코드가 중복이니 중복을 별도의 메서드로 뽑아내면 될 것 같다.

  - 그런데, try ~ catch 는 물론이고, 핵심 기능 부분이 중간에 있어서 단순하게 메서드로 추출하는 것은 어렵다.

 

 * 변하는 것과 변하지 않는 것을 분리

  - 좋은 설계는 변하는 것과 변하지 않는 것을 분리하는 것이다.

  - 여기서 핵심 기능 부분은 변하고, 로그 추적기를 사용하는 부분은 변하지 않는 부분이다.

  - 이 둘을 분리해서 모듈화해야 한다.

    > 템플릿 메서드 패턴(Template Method Pattern)은 이런 문제를 해결하는 디자인 패턴이다

 

 3.2. 템플릿 메서드 패턴 - 예제1

  - 템플릿 메서드 패턴을 쉽게 이해하기 위해 단순한 예제 코드를 만들어보자

package hello.advanced.trace.template;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

@Slf4j
public class TemplateMethodTest {

    @Test
    void templateMethodV0() {
        logic1();
        logic2();
    }

    private void logic1(){
        long startTime = System.currentTimeMillis();
        //비즈니스 로직 실행
        log.info("비즈니스 로직1 실행");
        long endTime = System.currentTimeMillis();
        long resultTime = endTime - startTime;
        log.info("resultTime={}", resultTime);
    }

    private void logic2(){
        long startTime = System.currentTimeMillis();
        //비즈니스 로직 실행
        log.info("비즈니스 로직2 실행");
        long endTime = System.currentTimeMillis();
        long resultTime = endTime - startTime;
        log.info("resultTime={}", resultTime);
    }
}

  - hello/advanced/trace/template/TemplateMethodTest.java 

  - 변하는 부분: 비즈니스 로직

  - 변하지 않는 부분: 시간 측정

 

 3.3. 템플릿 메서드 패턴 - 예제2

템플릿 메서드 패턴 구조 그림

 

package hello.advanced.trace.template.code;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public abstract class AbstractTemplate {

    public void execute() {
        long startTime = System.currentTimeMillis();
        //비즈니스 로직 실행
        call(); //상속
        //비즈니스 로직 종료
        long endTime = System.currentTimeMillis();
        long resultTime = endTime - startTime;
        log.info("resultTime={}", resultTime);
    }

    protected abstract void call();
}

 

  - hello/advanced/trace/template/code/AbstractTemplate.java

  - 템플릿 메서드 패턴은 이름 그대로 템플릿을 사용하는 방식이다. 템플릿이라는 틀에 변하지 않는 부분을 몰아둔다.

  - 그리고 일부 변하는 부분을 별도로 호출해서 해결한다

 

package hello.advanced.trace.template.code;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class SubClassLogic1 extends AbstractTemplate {

    @Override
    protected void call() {
        log.info("비즈니스 로직1 실행");
    }
}

  - hello/advanced/trace/template/code/SubClassLogic1.java

  - 템플릿 call 메소드를 오버라이딩해서 비즈니스 로직1 구현. (SubClassLogic2 도 동일)

 

...
/**
 * 템플릿메서드 패턴 적용
 */
@Test
void templateMethodV1() {
    AbstractTemplate template1 = new SubClassLogic1();
    template1.execute();

    AbstractTemplate template2 = new SubClassLogic2();
    template2.execute();
}
...

  - hello/advanced/trace/template/TemplateMethodTest.java

  - 템플릿메서드 패턴 적용 메소드 호출

  - 템플릿메서드 패턴은 다형성을 사용해서 비즈니스 로직과 공통 로직을 분리하는 방법이다.

 

 3.4. 템플릿 메서드 패턴 - 예제3

  - 익명 내부 클래스 사용하기 (예제2는 비즈니스 로직 변경 시 항상 메소드를 생성해야하는 이슈가 있다)

  - 익명 내부 클래스를 사용하면 객체 인스턴스를 생성하면서 동시에 생성할 클래스를 상속 받은 자식 클래스를 정의한다.

...
@Test
void templateMethodV2() {
    AbstractTemplate template1 = new AbstractTemplate() {
        @Override
        protected void call() {
            log.info("비즈니스 로직1 실행");
        }
    };
    template1.execute();

    AbstractTemplate template2 = new AbstractTemplate() {
        @Override
        protected void call() {
            log.info("비즈니스 로직2 실행");
        }
    };
    template2.execute();
}
...

  - hello/advanced/trace/template/TemplateMethodTest.java

  - 익명 내부 클래스로 인스턴스 생성 및 실행

 

 3.5. 템플릿 메서드 패턴 - 적용1

  - 우리가 만든 애플리케이션의 로그 추적기 로직에 템플릿 메서드 패턴을 적용해보자.

package hello.advanced.trace.template;

import hello.advanced.trace.TraceStatus;
import hello.advanced.trace.logtrace.LogTrace;

public abstract class AbstractTemplate<T> {

    private final LogTrace trace;

    public AbstractTemplate(LogTrace trace) {
        this.trace = trace;
    }

    public T execute(String message) {
        TraceStatus status = null;
        try{
            status = trace.begin(message);

            //로직 호출
            T result = call();

            trace.end(status);
            return result;
        } catch (Exception e) {
            trace.exception(status, e);
            throw e;
        }
    }

    protected abstract T call();
}

  - hello/advanced/trace/template/AbstractTemplate.java

  - AbstractTemplate 은 템플릿 메서드 패턴에서 부모 클래스이고, 템플릿 역할을 한다.

  - T : 제네릭을 사용했다. 반환 타입을 정의한다.

  - 객체를 생성할 때 내부에서 사용할 LogTrace trace 를 전달 받는다.

  - 로그에 출력할 message 를 외부에서 파라미터로 전달받는다.

  - 템플릿 코드 중간에 call() 메서드를 통해서 변하는 부분을 처리한다.

  - abstract T call() 은 변하는 부분을 처리하는 메서드이다. 이 부분은 상속으로 구현해야 한다

 

 * v3 -> v4 복사

package hello.advanced.app.v4;

import hello.advanced.trace.logtrace.LogTrace;
import hello.advanced.trace.template.AbstractTemplate;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequiredArgsConstructor
public class OrderControllerV4 {

    private final OrderServiceV4 orderService;
    private final LogTrace trace;

    @GetMapping("/v4/request")
    public String request(String itemId) {

        AbstractTemplate<String> template = new AbstractTemplate<>(trace) {
            @Override
            protected String call() {
                orderService.orderItem(itemId);
                return "ok";
            }
        };

        return template.execute("OrderController.request()");   //inline variable 변경 = Ctrl + Alt + N
    }
}

 

  - hello.advanced.app.v4.OrderControllerV4.java

  - AbstractTemplate<Generic> 을 String 으로 설정했다.

  - template.execute("OrderController.request()")을 사용해 템플릿을 실행하면서 로그로 남길 message 를 전달한다.

 

package hello.advanced.app.v4;

import hello.advanced.trace.TraceId;
import hello.advanced.trace.TraceStatus;
import hello.advanced.trace.helloTrace.HelloTraceV2;
import hello.advanced.trace.logtrace.LogTrace;
import hello.advanced.trace.template.AbstractTemplate;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

@Service
@RequiredArgsConstructor
public class OrderServiceV4 {

    private final OrderRepositoryV4 orderRepository;
    private final LogTrace trace;


    public void orderItem(String itemId){

        AbstractTemplate<Void> template = new AbstractTemplate<>(trace) {
            @Override
            protected Void call() {
                orderRepository.save(itemId); //핵심 기능
                return null;
            }
        };

        template.execute("OrderService.orderItem()");
    }
}

  - hello.advanced.app.v4.OrderServiceV4.java

  - AbstractTemplate 을 Void으로 설정 후 return null 로 처리했다. (제네릭은 기본 타입인 void , int 등을 선언할 수 없다.)

 

package hello.advanced.app.v4;

import hello.advanced.trace.logtrace.LogTrace;
import hello.advanced.trace.template.AbstractTemplate;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Repository;


@Repository
@RequiredArgsConstructor
public class OrderRepositoryV4 {

    private final LogTrace trace;

    public void save(String itemId) {

        AbstractTemplate<Void> template = new AbstractTemplate<>(trace) {
            @Override
            protected Void call() {
                //저장 로직
                if (itemId.equals("ex")) {  //상품 ID 가 ex 면 예외 처리
                    throw new IllegalStateException("예외 발생!");
                }
                sleep(1000);    //상품을 저장하는데 1초가 걸린다고 가정
                return null;
            }
        };
        template.execute("OrderRepositoryV4.request()");   //inline variable 변경 = Ctrl + Alt + N
    }

    private void sleep(int miilis) {
        try {
            Thread.sleep(miilis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

  - hello.advanced.app.v4.OrderRepositoryV4.java

  - 서비스에도 템플릿메서드 패턴 적용