JavaScript에서 **클로저(Closure)**는 함수와 그 함수가 선언된 어휘적 환경(Lexical Environment)의 조합을 말합니다. 즉, 함수가 외부 스코프의 변수에 접근할 수 있는 기능을 의미합니다.

📌 기본 개념

클로저는 다음과 같은 조건에서 생성됩니다:

1. 함수 안에 함수가 정의되어 있고,
2. 내부 함수가 외부 함수의 변수에 접근할 수 있으며,
3. 외부 함수의 실행이 끝난 뒤에도 내부 함수가 여전히 그 변수에 접근할 수 있을 때 클로저가 됩니다.

function outer() {
  let count = 0;
  return function inner() {
    count++;
    console.log(count);
  }
}

const counter = outer();
counter(); // 1
counter(); // 2

위 예제에서 inner() 함수는 outer()의 지역 변수 count에 접근합니다. outer()의 실행이 끝났음에도 counter()가 count에 계속 접근할 수 있는 이유는 클로저 때문입니다.

MySQL을 비롯한 대부분의 관계형 데이터베이스에서 사용되는 JOIN은 여러 테이블의 데이터를 조합해 하나의 결과로 만드는 데 사용됩니다. 아래는 대표적인 JOIN 종류와 각각의 설명, 예제를 포함한 정리입니다.

🔗 1. INNER JOIN

✅ 정의

두 테이블에서 공통된 값이 존재하는 행만 반환합니다.

🧪 예시

SELECT a.id, a.name, b.order_date
FROM customers a
INNER JOIN orders b ON a.id = b.customer_id;

📌 특징

• 가장 일반적인 JOIN 방식
• 양쪽 모두 일치하는 값이 있어야 결과에 포함됨

🔗 2. LEFT JOIN (또는 LEFT OUTER JOIN)

✅ 정의

왼쪽 테이블의 모든 행을 반환하며, 오른쪽 테이블에 일치하는 값이 없으면 NULL로 채워집니다.

HttpApiCachingFilter 와 CachedHttpServletRequestWrapper

• json과 multipart 외 form-urlencoded의 경우도 허용하면서 logging 정보 남기는 filter 구현 예시
• request 의 inputStream을 한번 읽으면 휘발되기 때문에 이를 방지하는 로직이 중요합니다.

HttpApiCachingFilter

@Component
@Order(value = Ordered.HIGHEST_PRECEDENCE)
@WebFilter(filterName = "HttpApiCachingFilter", urlPatterns = "/*")
@Slf4j
public class HttpApiCachingFilter extends OncePerRequestFilter {

    private static String APPLICATION_NAME;

    @Value("${spring.application.name}")
    private void setApplicationName(String value) {
        APPLICATION_NAME = value;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
        throws ServletException, IOException {
        if (isAsyncDispatch(request)) {
            filterChain.doFilter(request, response);
        } else if (isMultipartRequest(request)) {
            doFilterWrapped(new StandardMultipartHttpServletRequest(request), new CachedHttpServletResponseWrapper(response), filterChain);
        } else {
            doFilterWrapped(new CachedHttpServletRequestWrapper(request), new CachedHttpServletResponseWrapper(response), filterChain);
        }
    }

    protected void doFilterWrapped(HttpServletRequestWrapper request, ContentCachingResponseWrapper response, FilterChain filterChain)
        throws ServletException, IOException {
        try {
            logRequestHeader(request);
            logRequest(request);
            filterChain.doFilter(request, response);
        } finally {
            logResponseHeader(response);
            logResponse(response);
            response.copyBodyToResponse();
        }
    }

    private static void logRequestHeader(HttpServletRequestWrapper request) {
        Enumeration<String> headerNames = request.getHeaderNames();
        if (headerNames != null) {
            Collections.list(headerNames).forEach(headersName -> {
                String headerValue = request.getHeader(headersName);
                log.info("Request Header {}: {}", headersName, headerValue);
            });
        }
    }

    private static void logRequest(HttpServletRequestWrapper request) throws IOException {
        String contentType = request.getContentType();

        log.info("Request body: {} uri=[{}] content-type=[{}]", request.getMethod(),
            request.getRequestURI(), contentType);

        if (contentType != null && contentType.startsWith(MediaType.APPLICATION_FORM_URLENCODED_VALUE)) {
            Map<String, String[]> paramMap = request.getParameterMap();
            paramMap.forEach((key, values) -> {
                for (String value : values) {
                    log.info("REQUEST Param: {} = {}", key, value);
                }
            });
        } else {
            logPayload("REQUEST", contentType, request.getInputStream(), request.getRequestURI());
        }
    }

    private static void logResponseHeader(ContentCachingResponseWrapper response) {
        Collection<String> headerNames = response.getHeaderNames();
        for (String headerName : headerNames) {
            for (String value : response.getHeaders(headerName)) {
                log.info("Response Header {}: {}", headerName, value);
            }
        }
    }

    private static void logResponse(ContentCachingResponseWrapper response) throws IOException {
        logPayload("RESPONSE", response.getContentType(), response.getContentInputStream(), null);
    }

    private static void logPayload(String direction,
                                   String contentType,
                                   InputStream inputStream,
                                   String targetUri
    ) throws IOException {
        boolean visible = isVisible(MediaType.valueOf(contentType == null ? "application/json" : contentType));
        if (visible) {
            byte[] content = StreamUtils.copyToByteArray(inputStream);
            if (content.length > 0) {
                String contentString = new String(content);
                log.info("{} Payload: {}", direction, contentString);
            }
        } else {
            log.info("{} Payload: Binary Content", direction);
        }
    }

    private static boolean isVisible(MediaType mediaType) {
        final List<MediaType> VISIBLE_TYPES = Arrays.asList(MediaType.valueOf("text/*"),
            MediaType.APPLICATION_FORM_URLENCODED,
            MediaType.APPLICATION_JSON,
            MediaType.APPLICATION_XML,
            MediaType.valueOf("application/*+json"),
            MediaType.valueOf("application/*+xml"),
            MediaType.MULTIPART_FORM_DATA);
        return VISIBLE_TYPES.stream().anyMatch(visibleType -> visibleType.includes(mediaType));
    }

    private boolean isMultipartRequest(HttpServletRequest request) {
        String contentType = request.getContentType();
        return request.getMethod().equalsIgnoreCase("POST")
            && contentType != null
            && contentType.startsWith("multipart/form-data");
    }
}

CachedHttpServletRequestWrapper.java

public class CachedHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private final byte[] cachedBody;
    private Map<String, String[]> parameterMap;

    public CachedHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        this.cachedBody = request.getInputStream().readAllBytes();

        // form-urlencoded 타입일 때만 파라미터 파싱
        String contentType = request.getContentType();
        if (contentType != null && contentType.startsWith(MediaType.APPLICATION_FORM_URLENCODED_VALUE)) {
            String encoding = request.getCharacterEncoding();
            if (encoding == null) {
                encoding = StandardCharsets.UTF_8.name();
            }
            this.parameterMap = parseFormParameters(new String(this.cachedBody, encoding));
        } else {
            // 원본 request의 파라미터 맵 사용
            this.parameterMap = super.getParameterMap();
        }
    }

    @Override
    public ServletInputStream getInputStream() {
        ByteArrayInputStream bais = new ByteArrayInputStream(cachedBody);

        return new ServletInputStream() {
            @Override
            public int read() {
                return bais.read();
            }

            @Override
            public boolean isFinished() {
                return bais.available() == 0;
            }

            @Override
            public boolean isReady() {
                return true;
            }

            @Override
            public void setReadListener(ReadListener listener) {
            }
        };
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        return this.parameterMap;
    }

    @Override
    public BufferedReader getReader() {
        String encoding = getCharacterEncoding();
        if (encoding == null) {
            encoding = StandardCharsets.UTF_8.name();
        }
        return new BufferedReader(new InputStreamReader(getInputStream(), Charset.forName(encoding)));
    }

    private Map<String, String[]> parseFormParameters(String body) throws UnsupportedEncodingException {
        Map<String, List<String>> tempMap = new LinkedHashMap<>();

        // 빈 바디 처리
        if (body == null || body.trim().isEmpty()) {
            return new LinkedHashMap<>();
        }

        for (String pair : body.split("&")) {
            if (pair.trim().isEmpty()) {
                continue; // 빈 pair 건너뛰기
            }

            String[] parts = pair.split("=", 2);
            if (parts.length == 0) {
                continue;
            }

            String key = URLDecoder.decode(parts[0], StandardCharsets.UTF_8);
            String value = parts.length > 1 ? URLDecoder.decode(parts[1], StandardCharsets.UTF_8) : "";
            tempMap.computeIfAbsent(key, k -> new ArrayList<>()).add(value);
        }

        return tempMap.entrySet().stream()
            .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().toArray(new String[0])));
    }
}

CachedHttpServletResponseWrapper.java

public class CachedHttpServletResponseWrapper extends ContentCachingResponseWrapper {

    public CachedHttpServletResponseWrapper(HttpServletResponse response) {
        super(response);
    }
}

스프링 부트 애플리케이션 입장에서 샤딩된 DB를 쓰기 위해서 직접 “복잡한” 코드를 많이 짤 필요는 없습니다. 대신, 주로 다음 두 가지 레벨 중 하나의 방식으로 샤딩을 처리하게 됩니다.

1. 외부 프록시/미들웨어 사용 (Mycat, Vitess, ProxySQL 등)

• 애플리케이션 변경 제로 또는 최소화

  • 샤드별 DB URL(호스트/포트) 대신, 프록시의 단일 접점(가상 호스트/포트)을 spring.datasource.url에 지정
  • 트래픽·샤드 키 기반 분기 로직은 프록시가 대신 수행

• 구현 사항

  1. application.yml에 한번만 프록시 접점 정보 등록

     spring:
       datasource:
         url: jdbc:mysql://proxy.example.com:3306/app_db
         username: app
         password: secret
     

  2. 필요 시 트랜잭션 격리, 커넥션 풀, 리플리카 읽기 전용 설정 등 추가 구성

데이터베이스(DB) 샤딩(DB Sharding)이란 대용량 데이터를 효율적으로 분산·관리하기 위해 하나의 거대한 데이터베이스를 여러 개의 작은 조각(샤드, shard)으로 나누어 각각을 별도의 서버에 분산 저장하고 처리하는 기법을 말합니다.

1. 왜 샤딩이 필요한가?

• 성능 확장성(Scalability)

  • 단일 서버에 모든 데이터를 저장하면 저장 용량·처리 능력이 한계에 부딪힙니다.
  • 데이터와 트래픽이 늘어날수록 로드가 집중되어 응답 지연(latency)이나 병목(bottleneck)이 발생합니다.

• 고가용성(High Availability)

  • 각 샤드를 독립된 노드에 두면, 일부 노드 장애 시에도 전체 시스템이 완전히 다운되지 않고 가용성을 유지할 수 있습니다.

• 관리 용이성

배경

• local, dev, prod 등 프로파일에선 mysql 셋팅
• test 프로파일은 h2에 schema.sql, data.sql로 데이터 셋팅
• nativeQuery를 사용하는 경우 DATE_FORMAT 같은 mysql 함수 사용.

spring:
  datasource:
    url: jdbc:h2:mem:testdb;MODE=MYSQL;DB_CLOSE_DELAY=-1

DATE_FORMAT 대체

public class H2Functions {
    public static String formatDate(java.sql.Timestamp timestamp, String format) {
        return new java.text.SimpleDateFormat(format).format(timestamp);
    }
}

schema.sql

CREATE ALIAS IF NOT EXISTS DATE_FORMAT FOR "com.example.H2Functions.formatDate";

Repository

@Query(value = "SELECT DATE_FORMAT(order_date, 'yyyy-MM-dd') AS formatted_date, COUNT(*) " +
               "FROM orders GROUP BY formatted_date", nativeQuery = true)
List<Object[]> findOrderCountGroupedByDate();

위의 코드는 예시이며, 실제로는 h2와 mysql에서 format으로 넘겨주는 형태가 다릅니다. mysql에서는 %m%d, %Y 등으로 쓰고 h2에선 ‘MMdd’, ‘yyyy’ 등을 사용합니다.