하나의 요청에 나가는 쿼리 개수를 효율적으로 세어보자 (Hibernate StatementInspector, Spring AOP)

1. 개요

JPA를 사용할 때, 지연 로딩과 같은 기능을 무분별하게 사용하다보면 의도 하지 않은 수많은 쿼리가 나가는 경우가 많다. 흔히 이런 문제를 N+1 문제라고 한다. 

 

이렇듯 ORM을 사용하다보면 예상치 못한 개수의 쿼리가 발생하기도 하는데, 이를 한눈에 파악하기는 쉽지 않다. 로그에 쿼리가 출력되긴 하지만 하나하나 세고 있자니 생산성이 너무 떨어진다. 

 

방법이 없을까 찾아보다 쿼리 카운터에 대해 알게됐다. 

 

대표적인, 또 쉽게 구현할 수 있는 방법은 Hibernate에서 쿼리문을 가로챌 수 있는 StatementInspector를 사용하는 것이다. 다른 방법으론 Spring AOP를 활용하는 것이다. 

 

두 가지 방법을 하나하나 알아보려 한다. 결론부터 얘기하자면 나는 Spring AOP를 활용한 쿼리 카운팅 기능을 개발했다.  

 

 

 

 

 

 

2. StatementInspector

쿼리 카운터를 만들기 위해선 아래 2가지 조건을 만족해야 한다.

 

1. 쿼리가 실행되기 바로 직전 queryCount 값을 증가시키는 메소드를 실행

2. queryCount를 관리하는 객체의 생명주기는 HTTP request와 일치

 

 

2번의 조건은 @RequestScope를 활용하여 Http request 생명주기를 가지는 빈을 만들어 주면 간단히 해결할 수 있다. 1번의 경우 StatementInspector가 이 역할을 해준다.

 

 

StatementInspector는 하이버네이트가 제공하는 인터페이스이다. inspect라는 메서드를 가지고 있는데, HibernateProperty로 StatementInspector 구현체를 등록하면 쿼리 실행 시점에 실행될 쿼리문을 인자로 받는 inspect 메서드가 실행된다. 

 

따라서 StatementInspector 구현체를 커스터마이징하여 쿼리 개수를 세는데 활용하도록 할 것이다. 

 

 

먼저 HTTP request와 주기를 같이 하는 빈을 등록시켜줘야 한다. 단순히 개수만 저장해주는 객체이다.

@Component
@RequestScope
@Getter
public class ApiQueryCounter {

    private int count;

    public void increaseCount() {
        count++;
    }
}

 

 

 

이제 위에서 만든 ApiQueryCounter의 값을 증가시켜주는 로직을 가진 StatementInspector 구현체를 생성해준다. 

@Component
public class ApiQueryInspector implements StatementInspector {

    private final ApiQueryCounter apiQueryCounter;

    public ApiQueryInspector(final ApiQueryCounter apiQueryCounter) {
        this.apiQueryCounter = apiQueryCounter;
    }

    @Override
    public String inspect(final String sql) {
        if (isInRequestScope()) {
            apiQueryCounter.increaseCount();
        }
        return sql;
    }

    private boolean isInRequestScope() {
        return Objects.nonNull(RequestContextHolder.getRequestAttributes());
    }
}

 

빈으로 만들어 준 뒤, ApiQueryCounter의 의존성을 주입받아준다.

inspect 메서드가 실행되면 쿼리가 실행된다는 의미이므로 apiQueryCounter.increaseCount를 호출해주고 매개변수로 받은 쿼리를 그대로 반환하여 실행시켜주면 된다.

 

 

 

 

이제 HibernateConfig를 작성해준다.

우리가 만든 ApiQueryInspector는 커스텀 빈인 ApiQueryCounter를 주입받고 있다. 그렇기 때문에 다른 빈들이 모두 초기화되고 나서 HibernateProperty로 등록하도록 해야한다. 

@Configuration 안에서 @Bean으로 빈 등록을 해주게 되면 컴포넌트 스캔보다 나중에 빈 등록이 된다는 점을 이용하여 ApiQueryInspector를 HibernateProperties에 등록하도록 하였다.

@Configuration
@RequiredArgsConstructor
public class HibernateConfig {

    private final ApiQueryInspector apiQueryInspector;

    @Bean
    public HibernatePropertiesCustomizer hibernatePropertyConfig() {
        return hibernateProperties ->
                hibernateProperties.put(AvailableSettings.STATEMENT_INSPECTOR, apiQueryInspector);
    }
}

 

이렇게 설정을 끝마치면 쿼리가 실행될 때마다 inspect 메소드가 호출되게 된다. 

 

 

 

 

이제 마지막으로 인터셉터에서 센 쿼리 개수를 로그로 남길 것이다. HandlerInterceptor를 implements해 LoggingInterceptor를 만들어주었다. 

@Slf4j
@Component
@RequiredArgsConstructor
public class LoggingInterceptor implements HandlerInterceptor {

    private static final String QUERY_COUNT_LOG_FORMAT = "STATUS_CODE: {}, METHOD: {}, URL: {}, QUERY_COUNT: {}";
    private static final String QUERY_COUNT_WARNING_LOG_FORMAT = "쿼리가 {}번 이상 실행되었습니다.";

    private static final int QUERY_COUNT_WARNING_STANDARD = 10;

    private final ApiQueryCounter apiQueryCounter;
    

    @Override
    public void afterCompletion(final HttpServletRequest request, final HttpServletResponse response,
                                final Object handler, final Exception ex) {
        final int queryCount = apiQueryCounter.getCount();

        log.info(QUERY_COUNT_LOG_FORMAT, response.getStatus(), request.getMethod(), request.getRequestURI(), queryCount);
        
        // 10개 이상의 쿼리가 나갈 시 warn
        if (queryCount >= QUERY_COUNT_WARNING_STANDARD) {
            log.warn(QUERY_COUNT_WARNING_LOG_FORMAT, QUERY_COUNT_WARNING_STANDARD);
        }
    }
}

 

 

 

 

이제 WebConfig에 등록해주면 모든 설정은 끝이난다. 

@Configuration
public class WebConfig implements WebMvcConfigurer {

    private final LoggingInterceptor loggingInterceptor;

    public WebConfig(LoggingInterceptor loggingInterceptor) {
        this.loggingInterceptor = loggingInterceptor;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loggingInterceptor);
    }
}

 

아래와 같이 어떤 URL에 Query가 몇 번 나가는 지 확인할 수 있다. 

 

 

 

 

 

 

 

 

 

3. Spring AOP 

StatementInspector의 가장 큰 단점은 Hibernate에 종속적이라는 것이다. 

개발하다보면 네이티브 쿼리를 날리는 경우도 있을 수 있기 때문에 자바의 표준 데이터 접근 기술인 JDBC 단에서 카운트를 세는 게 더 나은 방법인 것 같다. 

 

 

먼저 Jdbc에 쿼리가 날아가는 과정을 알아야한다. 

 

Datasource에서 connection을 얻고, 이를 이용하여 쿼리 실행한다. 

 

 

 

이 과정에서 prepareStatement가 실행되는 걸 확인할 수 있다. 

Connection에 AOP를 적용해 prepareStatement가 실행될 때 잡아서 카운트를 하면 된다. 

 

하지만 한가지 문제점이 있다. 

AOP는 스프링 빈에만 적용할 수 있기 때문에 Connection에 직접적으로 적용하진 못한다. 따라서 스프링 빈으로 등록된 DataSource에 AOP를 적용하고 쿼리 카운트 기능을 가진 Connection을 프록시 객체로 만들어야한다. 

 

 

프록시는 타겟의 기능을 확장하거나 타겟에 대한 접근을 제어하기 위한 목적으로 사용하는 클래스를 말한다. 근데 Connection을 프록시로 구현을 하려면 Connection의 모든 메서드를 구현해 줘야 되는데 이걸 전부 구현하는 건..

다이나믹 프록시를 이용하여 간단하게 프록시를 생성해 주자.

 

다이나믹 프록시란?
동적인 시점에 프록시를 자동으로 만들어 적용하는 기술을 말함

 

 

QueryCounter 생성

@Getter
@Component
@RequestScope
public class QueryCounter {

    private int count;

    public void increaseCount() {
        count++;
    }

}

카운트 역할을 하는 이 객체의 생명주기는 특정 스레드의 요청 동안만 사용된다. ThreadLocal을 써서 저장, 삭제해 줄 수도 있겠지만 Spring에서 RequstScope를 지원해 주기 때문에 이를 활용해 준다.

 

 

ConnectionProxyHandler 생성

Connection 다이나믹 프록시 구현을 위해 handler를 먼저 만들어야 된다. 원하는 동작(카운트)을 설정할 수 있도록 InvocationHandler를 구현해 준다.

public class ConnectionProxyHandler implements InvocationHandler {

    private static final String QUERY_PREPARE_STATEMENT = "prepareStatement";

    private final Object connection;
    private final QueryCounter queryCounter;

    public ConnectionProxyHandler(Object connection, QueryCounter queryCounter) {
        this.connection = connection;
        this.queryCounter = queryCounter;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        countQuery(method);
        return method.invoke(connection, args);
    }

    private void countQuery(Method method) {
        if (isPrepareStatement(method) && isRequest()) {
            queryCounter.increaseCount();
        }
    }

    private boolean isPrepareStatement(Method method) {
        return method.getName().equals(QUERY_PREPARE_STATEMENT);
    }

    private boolean isRequest() {
        return RequestContextHolder.getRequestAttributes() != null;
    }
}

 

invoke 메서드가 실제 target의 메서드 호출을 가로채기 때문에 이 부분에 추가적으로 적용할 기능을 추가하면 된다. 실행되는 메소드의 명이 "prepareStatement" 라면 count해주었다. 

 

현재 QueryCounter가 RequestScope를 사용하고 있기 때문에 isRequest 분기가 없으면 다음과 같은 에러가 발생하니 꼭 추가해줘야 한다.

Scope ‘request’ is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton;

 

 

AOP 적용

DataSource가 getConnection() 메소드를 호출할 때 Connection을 추가 기능이 장착된 프록시 객체로 덮어씌워줘야 된다. 방금 만든 Handler를 이용하여 Connection 다이나믹 프록시를 구현해 보자.

 

우선 자바에서 다이나믹 프록시는 Java.lang.reflect.Proxy 클래스의 newProxyInstance() 메소드를 이용하여 생성할 수 있다.

 

Proxy.newProxyInstance(
        프록시 클래스를 정의하는 클래스 로더,
        구현할 프록시 클래스의 인터페이스 목록,
        메소드 호출을 전달하는 호출 핸들러
);

 

@Aspect
@Component
@Slf4j
@RequiredArgsConstructor
public class QueryCountAspect {

    private final QueryCounter queryCounter;

    @Around("execution(* javax.sql.DataSource.getConnection(..))")
    public Object getConnection(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        Object connection = proceedingJoinPoint.proceed();
        return Proxy.newProxyInstance(
                connection.getClass().getClassLoader(),
                connection.getClass().getInterfaces(),
                new ConnectionHandler(connection, queryCounter)
        );
    }
}

 

 

쿼리 카운트 로깅 인터셉터 생성

@Slf4j
@Component
@RequiredArgsConstructor
public class LoggingInterceptor implements HandlerInterceptor {

    private static final String QUERY_COUNT_LOG = "METHOD: {}, URL: {}, STATUS_CODE: {}, QUERY_COUNT: {}";
    private static final String QUERY_COUNT_WARN_LOG = "쿼리가 {}번 이상 실행되었습니다!!!";
    private static final int WARN_QUERY_COUNT= 8;

    private final QueryCounter queryCounter;

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                Object handler, Exception ex) {
        int queryCount = queryCounter.getCount();
        log.info(QUERY_COUNT_LOG, request.getMethod(), request.getRequestURI(), response.getStatus(), queryCount);
        if (queryCount >= WARN_QUERY_COUNT) {
            log.warn(QUERY_COUNT_WARN_LOG, WARN_QUERY_COUNT);
        }
    }

}

 

 

 

AOP를 적용해도 아까와 마찬가지로 쿼리 카운팅이 잘 되는걸 확인할 수 있다. 😊