Spring ‐ 스프링 MVC 구조 이해 - thought-corner/Backend-PlayGround GitHub Wiki

// 같은 코드로 여러 구현체 사용 가능
// logback-classic.jar 있으면 LogBack 사용
// log4j.jar 있으면 Log4j 사용
// commons-logging.jar 있으면 Commons Logging 사용

logger.info("로그 메시지"); // 어떤 구현체든 동작

// Parameterized Logging - 효율적인 포맷팅
// 문자열 연결이 아니라 배열 기반 처리
logger.debug("Processing file: {} with size: {} bytes", 
    fileName, fileSize);

// 내부적으로:
// 1. 레벨 체크 (TRACE/DEBUG가 비활성화면 String.format 실행 안 함)
// 2. MessageFormatter.format()만 호출
// 3. 불필요한 객체 생성 최소화

// SLF4J는 Facade이므로 한 단계 더 거침
// LogBack 직접 사용 vs SLF4J + LogBack

// SLF4J 호출 흐름
logger.info(...) 
  → LoggerFactory.getLogger()
  → ILoggerFactory (구현체 찾음)
  → 실제 Logger (LogBack)

// SLF4J는 최소한의 기능만 제공
// 구현체의 고급 기능을 직접 사용할 수 없음

// ❌ 불가능
logger.setAdditivity(false);

// ✅ 가능 (LogBack 직접 접근)
LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
ch.qos.logback.classic.Logger logger = 
    loggerContext.getLogger("com.example");
logger.setAdditivity(false);

// SLF4J는 에러 처리를 구현체에 위임
try {
    logger.info("메시지");
} catch (Exception e) {
    // 어떤 구현체를 사용하느냐에 따라 다른 예외 발생 가능
}

// LogBack 특화 기능을 사용하면 변경 어려움
LoggerContext loggerContext = 
    (LoggerContext) LoggerFactory.getILoggerFactory();
// ↑ LogBack 인스턴스 직접 접근
// 이 코드는 다른 구현체(Log4j 등)로 변경 불가능

// MDC 정리 안 하면 메모리 누수
MDC.put("userId", user.getId());
logger.info("User action");
// MDC.clear(); 안 하면 스레드풀에서 스레드 재사용 시 데이터 유지됨

// 비동기 Appender 종료 안 하면 스레드 남음
AsyncAppender asyncAppender = new AsyncAppender();
// 애플리케이션 종료 시 명시적으로 종료해야 함

// HttpMessageConverter 인터페이스는 HTTP 요청, HTTP 응답 둘 다 사용된다.
public interface HttpMessageConverter<T> {

    /**
     * Indicates whether the given class can be read by this converter.
     * @param clazz the class to test for readability
     * @param mediaType the media type to read (can be {@code null} if not specified);
     * typically the value of a {@code Content-Type} header.
     * @return {@code true} if readable; {@code false} otherwise
     */
    boolean canRead(Class<?> clazz, @Nullable MediaType mediaType);

    /**
     * Indicates whether the given class can be written by this converter.
     * @param clazz the class to test for writability
     * @param mediaType the media type to write (can be {@code null} if not specified);
     * typically the value of an {@code Accept} header.
     * @return {@code true} if writable; {@code false} otherwise
     */
    boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);

    /**
     * Return the list of media types supported by this converter. The list may
     * not apply to every possible target element type and calls to this method
     * should typically be guarded via {@link #canWrite(Class, MediaType)
     * canWrite(clazz, null}. The list may also exclude MIME types supported
     * only for a specific class. Alternatively, use
     * {@link #getSupportedMediaTypes(Class)} for a more precise list.
     * @return the list of supported media types
     */
    List<MediaType> getSupportedMediaTypes();

    /**
     * Return the list of media types supported by this converter for the given
     * class. The list may differ from {@link #getSupportedMediaTypes()} if the
     * converter does not support the given Class or if it supports it only for
     * a subset of media types.
     * @param clazz the type of class to check
     * @return the list of media types supported for the given class
     * @since 5.3.4
     */
    default List<MediaType> getSupportedMediaTypes(Class<?> clazz) {
        return (canRead(clazz, null) || canWrite(clazz, null) ?
                getSupportedMediaTypes() : Collections.emptyList());
    }

    /**
     * Read an object of the given type from the given input message, and returns it.
     * @param clazz the type of object to return. This type must have previously been passed to the
     * {@link #canRead canRead} method of this interface, which must have returned {@code true}.
     * @param inputMessage the HTTP input message to read from
     * @return the converted object
     * @throws IOException in case of I/O errors
     * @throws HttpMessageNotReadableException in case of conversion errors
     */
    T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
            throws IOException, HttpMessageNotReadableException;

    /**
     * Write a given object to the given output message.
     * @param t the object to write to the output message. The type of this object must have previously been
     * passed to the {@link #canWrite canWrite} method of this interface, which must have returned {@code true}.
     * @param contentType the content type to use when writing. May be {@code null} to indicate that the
     * default content type of the converter must be used. If not {@code null}, this media type must have
     * previously been passed to the {@link #canWrite canWrite} method of this interface, which must have
     * returned {@code true}.
     * @param outputMessage the message to write to
     * @throws IOException in case of I/O errors
     * @throws HttpMessageNotWritableException in case of conversion errors
     */
    void write(T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage)
            throws IOException, HttpMessageNotWritableException;

}