5. API 개발 고급 - 실무 필수 최적화

OSIV와 성능 최적화

• Open Session In View: 하이버네이트
• Open EntityManager In View: JPA

(관례상 OSIV라 한다.)

OSIV ON

spring.jpa.open-in-view : true 기본값

최신 스프링 부트 버전에서는 실행을 하면 아래 warn 로그가 출력된다.

WARN 72686 --- [  restartedMain] JpaBaseConfiguration$JpaWebConfiguration : spring.jpa.open-in-view is enabled by default. Therefore, database queries may be performed during view rendering. Explicitly configure spring.jpa.open-in-view to disable this warning

이 기본값을 뿌리면서 애플리케이션 시작 시점에 warn 로그를 남기는 것은 이유가 있다.

JPA의 영속성 컨텍스트와 데이터베이스 커넥션은 굉장히 밀접하게 매칭되어 있다.

JPA의 영속성 컨텍스트는 데이터베이스 커넥션을 일대일로 쓰면서 동작해야 한다.

그러면 JPA가 언제 데이터베이스 커넥션을 가지고 오고 언제 데이터베이스 커넥션을 DB에 반환할까?

기본적으로는 데이터베이스 트랜잭션을 시작 할때 JPA의 영속성 컨텍스트가 데이터베이스 커넥션을 가져온다.

그러면 이 커넥션을 언제 DB에 돌려줘야 할까?

OSIV 전략은 트랜잭션 시작처럼 최초 데이터베이스 커넥션 시작 시점부터 API 응답이 끝날 때 까지 영속성 컨텍스트 와 데이터베이스 커넥션을 유지한다. 그래서 지금까지 View Template이나 API 컨트롤러에서 지연 로딩이 가능했던 것이다.

지연 로딩은 영속성 컨텍스트가 살아있어야 가능하고, 영속성 컨텍스트는 기본적으로 데이터베이스 커넥션을 유지한다. 이것 자체가 큰 장점이다. 이렇게 LAZY 로딩 같은 기술을 컨트롤러나 뷰에서 적극 활용하면서 중복을 줄이고 투명하게 LAZY 로딩을 끝까지 사용할 수 있어 코드의 유지 보수성을 높일 수 있다.

 

그런데 이 전략은 너무 오랜 시간 동안 데이터베이스 커넥션 리소스를 사용하기 때문에, 실시간 트래픽이 중요한 애플리 케이션에서는 커넥션이 모자랄 수 있다. 이것은 결국 장애로 이어진다. 예를 들어서 컨트롤러에서 외부 API를 호출하면 외부 API 대기 시간 만큼 커넥션 리소스를 반환하지 못하고, 유지해야 한다.

OSIV OFF

spring.jpa.open-in-view: false OSIV 종료

트랜잭션을 시작하고 끝날 때까지만 데이터베이스 커넥션을 유지한다.(영속성 컨텍스트도 커넥션에 맞춰서 유지된다.) OSIV를 끄면 트랜잭션을 종료할 때 영속성 컨텍스트를 닫고, 데이터베이스 커넥션도 반환한다.

따라서 커넥션 리소스를 낭비하지 않는다.

 코드예시

@Transactional
public Long join(Member member) {
    validateDuplicateMember(member);
    memberRepository.save(member);
    return member.getId();
}

@Transactional을 사용했기에 join() 메서드 호출이 되면 영속성 컨텍스트가 만들어고 데이터베이스 커넥션을 가져온다. 근데 이 로직이 끝나면 DB에 flush, commit을 수행하고 영속성 컨텍스트가 제거되고 DB 커넥션도 반환한다.

@PostMapping("/api/v1/members")
public CreateMemberResponse saveMemberV1(@RequestBody @Valid Member member) {

    Long id = memberService.join(member);
    return new CreateMemberResponse(id);
}

그래서 join() 로직이 끝나고 반환하는 시점인 Long id = memberService.join(member) 이 부분부터는 영속성 컨텍스트도 DB 커넥션도 안 쓴다. 그래서 트래픽이 많은 서비스에서는 훨씬 더 커넥션을 유연하게 쓸 수 있다.

단점

OSIV를 끄면 모든 지연로딩을 트랜잭션 안에서 처리해야 한다.

따라서 지금까지 작성한 많은 지연 로딩 코드를 트랜잭션 안으로 넣어야 하는 단점이 있다.

그리고 view template에서 지연로딩이 동작하지 않는다. 

결론적으로 트랜잭션이 끝나기 전에 지연 로딩을 강제로 호출해 두어야 한다.

 

실제로 컨트롤러단에서 LAZY 로딩을 할 수 없는지 open-in-view: false 로 설정하고 포스트맨으로 요청을 해보자.

@GetMapping("/api/v1/orders")
public List<Order> ordersV1() {
    List<Order> all = orderRepository.findAllByString(new OrderSearch());
    for (Order order : all) {
        order.getMember().getName();
        order.getDelivery().getAddress();
        List<OrderItem> orderItems = order.getOrderItems();
        orderItems.stream().forEach(o -> o.getItem().getName());
    }
    return all;
}

실행 시 아래와 같은 예외가 발생한다.

org.hibernate.LazyInitializationException: could not initialize proxy [jpabook.jpashop.domain.Member#1] - no Session
	at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:165) ~[hibernate-core-6.5.2.Final.jar:6.5.2.Final]
	at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:314) ~[hibernate-core-6.5.2.Final.jar:6.5.2.Final]
	at org.hibernate.proxy.pojo.bytebuddy.ByteBuddyInterceptor.intercept(ByteBuddyInterceptor.java:44) ~[hibernate-core-6.5.2.Final.jar:6.5.2.Final]
	at org.hibernate.proxy.ProxyConfiguration$InterceptorDispatcher.intercept(ProxyConfiguration.java:102) ~[hibernate-core-6.5.2.Final.jar:6.5.2.Final]
	at jpabook.jpashop.domain.Member$HibernateProxy$PMnyq52W.getName(Unknown Source) ~[main/:na]
	at jpabook.jpashop.api.OrderApiController.ordersV1(OrderApiController.java:36) ~[main/:na]
	...

컨트롤러에서 order.getMember().getName(); 이 부분에서 예외가 발생했다.

order.getMember()를 통해 member를 가지고 왔는데 그 member는 프록시다.

이때 getName() 호출되는 순간 영속성 컨텍스트를 통해서 프록시를 초기화해야 한다.

근데 open-in-view: false 옵션으로 컨트롤러에서 영속성 컨텍스트가 없는 상황이다.

그래서 이런 LazyInitializationException: could not initialize proxy 예외가 발생한 거다.

이런 부분을 해결하기 위해 open-in-view를 true로 설정해야 한다.

아니면 트랜잭션 안에서 프록시를 다 초기화하거나 fetch join을 사용해서 트랜잭션 안에서 로딩을 끝내고 Order 엔티티를 반환해야 한다.

커멘드와 쿼리 분리

실무에서 OSIV를 끈 상태로 복잡성을 관리하는 좋은 방법이 있다. 바로 Command와 Query를 분리하는 것이다.

참고: https://en.wikipedia.org/wiki/Command%E2%80%93query_separation

 

보통 비즈니스 로직은 특정 엔티티 몇 개를 등록하거나 수정하는 것이므로 성능이 크게 문제가 되지 않는다.

보통 성능 이슈는 조회에서 발생한다. 그래서 복잡한 화면을 출력하기 위한 쿼리들이 성능 문제를 일으킨다.

그리고 복잡한 화면을 출력하기 위한 쿼리는 보통 화면에 맞춰서 개발한다.

그래서 복잡한 화면을 출력하기 위한 쿼리는 화면에 맞추어 성능을 최적화하는 것이 중요하다.

하지만 그 복잡성에 비해 핵심 비즈니스에 큰 영향을 주는 것은 아니다.

두 쿼리의 라이프 사이클 관점에서 보면 커멘드성 쿼리와 조회 쿼리는 라이프 사이클이 다르다.

대부분 화면에 맞추는 API나 화면용 기능들은 자주 바뀐다. 즉 라이프 사이클이 빠르다.

그런데 핵심 비즈니스 로직이나 정책들이 있는 서비스 클래스는 잘 변경되지 않는다.

그래서 크고 복잡한 애플리케이션을 개발한다면, 이 둘의 관심사를 명확하게 분리하는 선택은 유지보수 관점에서 충분히 의미 있다.

단순하게 설명해서 다음처럼 분리하는 것이다.

OrderService

• OrderService: 핵심 비즈니스 로직
• OrderQueryService: 화면이나 API에 맞춘 서비스 (주로 읽기 전용 트랜잭션 사용)

보통 서비스 계층에서 트랜잭션을 유지한다. 두 서비스 모두 트랜잭션을 유지하면서 지연 로딩을 사용할 수 있다.

코드 예시

OrderApiController

@RestController
@RequiredArgsConstructor
public class OrderApiController {

    private final OrderQueryService orderQueryService;
    
    ...

    @GetMapping("/api/v3/orders")
    public List<OrderDto> ordersV3() {
        return orderQueryService.ordersV3();
    }
    
    ...
}

OrderQueryService

@Service
@Transactional(readOnly = true)
@RequiredArgsConstructor
public class OrderQueryService {

    private final OrderRepository orderRepository;

    public List<OrderDto> ordersV3() {
        List<Order> orders = orderRepository.findAllWithItem();
        List<OrderDto> collect = orders.stream()
                .map(o -> new OrderDto(o))
                .collect(toList());
        return collect;
    }
}

정리하면 트랜잭션을 컨트롤러에서 보통 안 쓰기 때문에 서비스 계층을 쿼리 전용 서비스를 만든다.

참고

유지보수성만 생각하면 OSIV를 켜는 게 장점이 많다. 그런데 성능을 생각하면 꺼야 한다.

그래서 보통 고객 서비스의 실시간 API는 OSIV를 끄고, ADMIN처럼 커넥션을 많이 사용하지 않는 곳에서는 OSIV를 켠다.