How can you implement request and response logging in a Spring Boot application?

Implementing request and response logging in Spring Boot applications is a best practice that helps developers monitor and debug application behavior in both development and production environments. Here are some steps to implement request and response logging in Spring Boot:

1. Using Spring Boot's Built-in Features

Spring Boot provides built-in features that can be activated to log HTTP requests and responses. For example, you can configure the logging level in the application.properties or application.yml file:

properties
# application.properties
logging.level.org.springframework.web=TRACE

or

yaml
# application.yml
logging:
  level:
    org.springframework.web: TRACE

This will log detailed information for all Spring MVC requests and responses, but it often includes excessive information that may not be suitable for all scenarios.

2. Using Filters

For finer-grained control over log content, you can implement a custom filter. Within this filter, you can read and log request and response content. Here is a simple example:

java
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@Component
public class LoggingFilter implements Filter {

    private static final Logger LOGGER = LoggerFactory.getLogger(LoggingFilter.class);

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) 
            throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        String uri = request.getRequestURI();

        // Log request information
        LOGGER.info("Request URI: {}", uri);
        LOGGER.info("Request Method: {}", request.getMethod());

        // Continue the filter chain
        filterChain.doFilter(servletRequest, servletResponse);

        // Add response logging
    }
}

3. Using Interceptors

Spring also offers a more powerful way to intercept requests and responses: interceptors. By implementing the HandlerInterceptor interface, you can customize processing before, after, and after view rendering.

java
@Component
public class LoggingInterceptor implements HandlerInterceptor {

    private static final Logger LOGGER = LoggerFactory.getLogger(LoggingInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        LOGGER.info("Pre Handle method is called");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        LOGGER.info("Post Handle method is called");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception exception) throws Exception {
        LOGGER.info("Request and Response are completed");
    }
}

4. Using AOP

Another powerful approach is to use Aspect-Oriented Programming (AOP) to log method invocations. This can be achieved using Spring's @Aspect annotation. This method is particularly suitable for logging business logic parts of requests, such as method calls in service or controller layers.

java
@Aspect
@Component
public class LoggingAspect {

    private static final Logger LOGGER = LoggerFactory.getLogger(LoggingAspect.class);

    @Around("execution(* com.yourcompany.yourproject.controller.*.*(..))")
    public Object aroundControllerMethods(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = pjp.proceed();
        long elapsedTime = System.currentTimeMillis() - start;
        LOGGER.info("Method {} executed in {} ms", pjp.getSignature().getName(), elapsedTime);
        return result;
    }
}

Each of these methods has its pros and cons, and the choice depends on your specific requirements. For example, AOP provides very powerful logging capabilities but may impact performance; whereas filters and interceptors offer finer-grained control but may require more configuration work.