Posts on Pink Spider

분산락(distributed lock) deep dive

Fri, 13 Feb 2026 11:14:05 +0900

분산 시스템에서 여러 대의 서버가 동일한 자원에 동시에 접근할 때, 데이터의 일관성을 유지하기 위해 사용하는 기술이 바로 **분산락(Distributed Lock)**입니다.

단일 서버 환경에서는 synchronized나 ReentrantLock 같은 자바 표준 API로 동시성을 제어할 수 있지만, 서버가 여러 대라면 각 서버의 로컬 락은 서로를 알지 못합니다. 이때 모든 서버가 공통으로 바라보는 외부 저장소를 활용해 “누가 자원을 선점했는지"를 기록하는 것이 핵심입니다.

1. 분산락이 필요한 이유

동일한 DB 레코드에 대해 여러 인스턴스가 동시에 수정 요청을 보낼 때, **레이스 컨디션(Race Condition)**이 발생하여 데이터가 꼬일 수 있습니다.

Redis pub/sub 과 streams

Thu, 12 Feb 2026 11:14:05 +0900

Redis를 활용한 메시징 시스템의 두 기능은 모두 “데이터를 전달한다"는 목적은 같지만, **철학(Philosophy)**과 데이터 보존 방식에서 결정적인 차이가 있습니다.

한마디로 요약하자면: **Pub/Sub은 ‘방송’**이고, **Streams는 ‘기록이 남는 로그’**입니다.

1. Redis Pub/Sub (Publish/Subscribe)

가장 전통적인 형태의 메시징 모델입니다. 발신자가 메시지를 던지면, 그 순간 연결되어 있는 모든 수신자에게 실시간으로 전달됩니다.

휘발성 (Fire and Forget): 메시지를 보낸 후 어디에도 저장하지 않습니다. 수신자가 오프라인 상태라면 그 메시지는 영원히 사라집니다.
실시간성: 지연 시간이 거의 없어 실시간 알림이나 채팅에 적합합니다.
팬아웃(Fan-out): 하나의 메시지를 수천 명의 구독자에게 동시에 뿌릴 때 매우 효율적입니다.

2. Redis Streams

Kafka와 유사한 기능을 Redis에 구현한 모델입니다. 단순 전달을 넘어 데이터의 ‘이력’을 관리합니다.

Spring Boot 비동기 프로그래밍:Future 패턴

Tue, 27 Jan 2026 11:25:18 +0900

Spring Boot(또는 Java)에서 Future 패턴은 비동기 프로그래밍을 위한 핵심 디자인 패턴입니다. 쉽게 말해, **“지금 당장 결과를 줄 수는 없지만, 미래의 어느 시점에 작업이 완료되면 결과물을 넘겨주겠다”**는 약속(Promise)과 같습니다.

1. Future 패턴의 핵심 개념

일반적인 동기(Synchronous) 방식에서는 작업이 끝날 때까지 스레드가 아무것도 못 하고 기다려야 합니다(Blocking). 반면, Future 패턴을 사용하면 작업을 별도의 스레드에 맡기고 메인 스레드는 자기 할 일을 계속할 수 있습니다.

주요 특징

비차단(Non-blocking): 결과가 나올 때까지 기다리지 않고 다른 작업을 수행할 수 있어 효율적입니다.
지연 실행: 결과가 실제로 필요한 시점까지 데이터 계산을 미룰 수 있습니다.
결합성: 여러 비동기 작업의 결과를 합치거나, 순차적으로 실행하는 흐름을 만들 수 있습니다.

2. Spring Boot에서의 구현 방식

Spring Boot에서는 주로 CompletableFuture와 @Async 어노테이션을 조합하여 이 패턴을 구현합니다.

정규화(Normalization)와 반정규화(Denormalization) 의 트레이드오프

Wed, 21 Jan 2026 21:20:45 +0900

데이터베이스 설계에서 **정규화(Normalization)**와 **반정규화(Denormalization)**는 데이터의 **무결성(Integrity)**과 성능(Performance) 사이의 균형을 맞추는 핵심적인 개념입니다.

이 둘의 관계는 흔히 **“데이터 정합성 vs. 읽기 성능”**의 트레이드오프(Trade-off)로 요약할 수 있습니다. 각 개념의 특징과 트레이드오프 요소를 상세히 분석해 드리겠습니다.

1. 핵심 트레이드오프 요약

가장 먼저 이해해야 할 큰 그림은 다음과 같습니다.

정규화: 데이터를 쪼개서 중복을 제거하고 무결성을 지킵니다. (쓰기 성능 향상, 읽기 시 JOIN 비용 발생)
반정규화: 성능을 위해 의도적으로 데이터를 중복시킵니다. (읽기 성능 향상, 쓰기 시 동기화 비용 발생)

2. 정규화 (Normalization)

데이터의 중복을 최소화하고, 이상 현상(Anomaly)을 방지하기 위해 테이블을 분리하는 과정입니다.

스프링부트(Spring Boot)와 JPA(Hibernate) 환경에서 스트리밍 쿼리(Streaming Query)

Tue, 20 Jan 2026 21:20:45 +0900

장단점

스프링부트(Spring Boot)와 JPA(Hibernate) 환경에서 **스트리밍 쿼리(Streaming Query)**는 대용량 데이터를 처리할 때 메모리 문제를 해결하기 위해 사용하는 매우 중요한 기술입니다.

일반적으로 데이터를 List<T> 형태로 조회하면 모든 결과가 애플리케이션 메모리(RAM)에 적재되지만, 스트리밍 쿼리는 데이터베이스 커서(Cursor)를 사용하여 필요한 만큼만 조금씩 가져와 처리하는 방식입니다.

요청하신 스트리밍 쿼리의 특징과 장단점을 정리해 드립니다.

1. 스트리밍 쿼리의 주요 특징

스트리밍 쿼리는 Java 8의 Stream<T> API를 활용하여 DB 결과를 물 흐르듯 처리합니다.

커서(Cursor) 기반 동작: 데이터베이스 내부의 커서를 이동시키며 데이터를 순차적으로 읽어옵니다.
지연 로딩(Lazy Loading)과 유사: Stream 객체를 생성한 시점에는 쿼리만 실행되고, 실제 데이터는 stream.forEach()나 next() 등을 호출할 때 가져옵니다.
트랜잭션 의존성: 스트림 처리가 끝날 때까지 DB 연결(Connection)을 유지해야 하므로, 반드시 활성화된 트랜잭션 안에서 수행되어야 합니다.

2. 장점 (Pros)

대용량 데이터 처리(Batch 작업, 엑셀 다운로드 등)에서 강력한 이점을 가집니다.

Memcached 와 redis 비교

Tue, 20 Jan 2026 09:41:22 +0900

Memcached와 Redis는 둘 다 고성능 인메모리(In-memory) 키-값(Key-Value) 저장소로, 주로 데이터베이스 부하를 줄이고 애플리케이션 속도를 높이는 캐시(Cache) 용도로 사용된다는 공통점이 있습니다.

하지만 “단순함과 멀티스레드(Memcached)” 대 **“강력한 기능과 유연성(Redis)”**이라는 명확한 차이가 있습니다.

두 기술의 핵심적인 차이를 4가지 관점(데이터 구조, 아키텍처, 영속성, 확장성)에서 정리해 드립니다.

1. 한눈에 보는 비교 (Executive Summary)

특징	Memcached	Redis
주요 컨셉	고성능, 단순함, 멀티스레드	다양한 자료구조, 영속성, 기능 풍부
자료 구조	String (단순 문자열/바이너리)	String, List, Set, Hash, Sorted Set, Geo 등
스레드 모델	멀티 스레드 (Multi-threaded)	싱글 스레드 (Single-threaded) (I/O는 멀티 가능)
데이터 영속성	지원 안 함 (재부팅 시 데이터 소멸)	지원 (RDB, AOF)
확장성(Clustering)	클라이언트 측 분산 (Consistent Hashing)	서버 측 분산 (Redis Cluster)
복제(Replication)	지원 안 함	Master-Slave 복제 지원
주요 용도	단순 캐싱 (세션, HTML 조각)	복잡한 캐싱, 리더보드, 대기열, 메시지 브로커

2. 상세 차이점 분석

① 데이터 구조 (Data Structures)

Memcached: 오직 **문자열(String)**만 저장합니다. 리스트나 해시 같은 구조를 저장하려면 JSON 등으로 직렬화(Serialize)해서 문자열로 만든 뒤 저장해야 합니다. 데이터를 수정하려면 전체 데이터를 가져와서 수정한 뒤 다시 덮어써야 하는 단점이 있습니다.
Redis: 다양한 자료구조를 지원합니다. 리스트(List)에 요소를 추가하거나, 해시(Hash)의 특정 필드만 수정하는 등 효율적인 데이터 조작이 가능합니다.
활용 예: ‘실시간 랭킹’ 구현 시 Redis의 Sorted Set을 쓰면 매우 쉽게 구현 가능합니다.

② 스레드 모델 (Architecture)

가장 큰 아키텍처 차이입니다.

Kubernetes(쿠버네티스)와 Docker(도커)의 관계

Tue, 06 Jan 2026 10:30:03 +0900

Kubernetes(쿠버네티스)와 Docker(도커)의 관계는 **“경쟁 관계"가 아니라 “상호 보완적인 관계”**입니다. 이 둘의 차이를 명확히 이해하기 위해 가장 쉬운 비유를 들어 설명해 드리겠습니다.

1. 핵심 비유: 화물선과 항만 시스템

이 두 기술의 관계를 물류 시스템에 비유하면 아주 명확해집니다.

Docker (컨테이너): **‘규격화된 화물 컨테이너 박스’**입니다.
물건(애플리케이션 코드, 라이브러리 등)을 박스에 담아 포장하는 기술입니다.
이 박스만 있으면 어떤 배(서버)나 트럭(노트북)에 실어도 내용물이 안전하게 전달됩니다.
Kubernetes (조타수/항만 관리자): **‘수천 개의 컨테이너를 관리하는 시스템’**입니다.
컨테이너가 배에 잘 실렸는지, 배가 흔들려 컨테이너가 떨어지면(에러 발생) 다시 실어주는지, 화물이 많아지면 배를 더 부를지(스케일링)를 결정합니다.

코딩 테스트 합격자 되기(자바편) - 30. 간단한 유니온 파인드 알고리즘 구현하기

Mon, 29 Dec 2025 09:37:03 +0900

답

import java.util.ArrayList;

// 30. 간단한 유니온 파인드 알고리즘 구현하기
public class Solution30 {

    private static int[] parent;

    private static int findRootNode(int x) {
        if (parent[x] == x) {
            return x;
        }
        parent[x] = findRootNode(parent[x]);
        return parent[x];
    }

    private static void union(int x, int y) {
        int root1 = findRootNode(x);
        int root2 = findRootNode(y);
        parent[root2] = root1;
    }

    public static Boolean[] solution(int k, int[][] operations) {

        parent = new int[k];

        for (int i = 0; i < k; i++) {
            parent[i] = i;
        }

        ArrayList<Boolean> answer = new ArrayList<>();

        for (int[] op : operations) {
            if (op[0] == 0) {
                union(op[1], op[2]);
            }
            else {
                answer.add(findRootNode(op[1]) == findRootNode(op[2]));
            }
        }

        return answer.toArray(new Boolean[0]);
    }
}

코드에서 return answer.toArray(new Boolean[0]); 구문은 ArrayList<Boolean> 타입인 answer를 Boolean[] 배열로 변환하여 반환하는 역할을 합니다.

Git에 보안에 문제되거나 민감정보를 커밋했는지 확인하자

Wed, 17 Dec 2025 11:16:03 +0900

프로그램으로 확인하기.

방법 1: 직접 만든 스크립트 (의존성 없음)

chmod +x scan-secrets.sh
./scan-secrets.sh

소스는 여기

방법 2: gitleaks 사용 (더 정확함, 권장)

# gitleaks 설치
brew install gitleaks  # 또는 apt install gitleaks

# 각 레포에서 실행
git clone git@github.com:dev-minimalism/kr-canslim-notifier.git
cd kr-canslim-notifier
gitleaks detect --source . --verbose

# 전체 히스토리 포함
gitleaks detect --source . --verbose --log-opts="--all"

방법 3: truffleHog (엔트로피 기반 탐지)

pip install truffleHog
truffleHog git git@github.com:dev-minimalism/kr-canslim-notifier.git --since_commit HEAD~100

혹은 히스토리 다 날려버리고 초기화 하기

git checkout --orphan latest_branch
git add .
git commit -m "initial commit after reset"
git branch -D main
git branch -m main
git push -f origin main

특정 파일만 히스토리에서 완전히 없애기 (.env의 예)

git filter-branch --force --index-filter "git rm --cached --ignore-unmatch .env" --prune-empty --tag-name-filter cat -- --all

로컬 맥에 여러 jdk를 다루기 위한 툴 - SDKMAN

Mon, 08 Dec 2025 08:49:54 +0900

SDKMAN의 핵심은 **“설치(Install) -> 전환(Switch) -> 확인(Check)”**의 흐름입니다. 가장 자주 쓰는 명령어 위주로 깔끔하게 정리해 드리겠습니다.

1. 설치 가능한 버전 목록 보기 (`list`)

먼저 어떤 버전을 설치할 수 있는지 확인해야 합니다.

sdk list java

화면 조작: 목록이 길게 나옵니다. Space(다음 페이지), Enter(한 줄 아래), q(나가기) 키를 기억하세요.
식별자(Identifier): 맨 오른쪽 열에 있는 텍스트가 중요합니다. (예: 24-open, 17.0.10-tem 등) 설치할 때 이 이름을 사용합니다.

2. 버전 설치하기 (`install`)

원하는 버전의 식별자(Identifier)를 입력하여 설치합니다.

Aggregate 패턴과 Bulkhead 패턴

Tue, 11 Nov 2025 10:16:50 +0900

IT 개발에서 Aggregate 패턴과 Bulkhead 패턴은 모두 **마이크로서비스 아키텍처(MSA)**나 분산 시스템에서 자주 사용되는 **설계 패턴(Design Pattern)**입니다. 각각의 목적은 다르지만, 시스템 안정성과 응답 효율을 높이기 위한 공통 목표를 가집니다. 아래에서 자세히 설명드릴게요.

🧩 1. Aggregate 패턴

💡 개념

Aggregate 패턴은 **도메인 주도 설계(DDD: Domain-Driven Design)**에서 등장하는 개념으로, 데이터의 일관성과 변경 단위를 정의하기 위한 구조입니다. 즉, 관련된 엔터티(Entity)와 값 객체(Value Object)를 하나의 **집합(Aggregate)**으로 묶고, 그 집합의 일관성을 책임지는 루트 엔터티를 Aggregate Root라고 부릅니다.

Java는 multi paradigm 언어일까?

Mon, 20 Oct 2025 13:50:50 +0900

Java는 멀티 패러다임 언어인가?

Java는 멀티 패러다임 언어라고 할 수 있습니다. 특히 Java 8 이후로는 더욱 명확해졌습니다. 초기에는 “순수한” 객체지향 언어를 목표로 했지만, 시간이 지나면서 다양한 프로그래밍 패러다임을 수용하게 되었습니다.

Java가 지원하는 프로그래밍 패러다임

1. 객체지향 프로그래밍 (OOP) - 핵심 패러다임

// 클래스, 상속, 캡슐화, 다형성
public class Animal {
    private String name;
    
    public void makeSound() {
        System.out.println("Some sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

2. 명령형 프로그래밍 (Imperative)

// 상태 변경과 제어 흐름을 명시적으로 작성
public static int factorial(int n) {
    int result = 1;
    for (int i = 1; i <= n; i++) {
        result *= i;  // 상태 변경
    }
    return result;
}

3. 함수형 프로그래밍 (Functional) - Java 8+

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

public class FunctionalExample {
    public static void main(String[] args) {
        // 1. 람다 표현식과 고차 함수
        Function<Integer, Integer> square = x -> x * x;
        Function<Integer, Integer> addOne = x -> x + 1;
        
        // 함수 합성
        Function<Integer, Integer> squareThenAdd = square.andThen(addOne);
        System.out.println(squareThenAdd.apply(3)); // 10
        
        // 2. 불변성과 순수 함수
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> doubled = numbers.stream()
            .map(n -> n * 2)  // 원본을 변경하지 않음
            .collect(Collectors.toList());
        
        // 3. 함수를 파라미터로 전달
        calculate(10, 5, (a, b) -> a + b); // 15
        calculate(10, 5, (a, b) -> a * b); // 50
    }
    
    static void calculate(int x, int y, BinaryOperator<Integer> operation) {
        System.out.println(operation.apply(x, y));
    }
}

4. 제네릭 프로그래밍 (Generic)

// 타입 파라미터를 사용한 일반화
public class Box<T> {
    private T content;
    
    public void set(T content) {
        this.content = content;
    }
    
    public T get() {
        return content;
    }
}

// 제네릭 메서드
public static <T extends Comparable<T>> T findMax(List<T> list) {
    return list.stream()
        .max(Comparable::compareTo)
        .orElse(null);
}

5. 동시성/병렬 프로그래밍 (Concurrent/Parallel)

import java.util.concurrent.*;

public class ConcurrentExample {
    public static void main(String[] args) throws Exception {
        // CompletableFuture를 사용한 비동기 프로그래밍
        CompletableFuture<String> future1 = CompletableFuture
            .supplyAsync(() -> fetchDataFromAPI1());
            
        CompletableFuture<String> future2 = CompletableFuture
            .supplyAsync(() -> fetchDataFromAPI2());
            
        // 두 작업을 결합
        CompletableFuture<String> combined = future1
            .thenCombine(future2, (result1, result2) -> result1 + " " + result2);
            
        System.out.println(combined.get());
    }
}

6. 반응형 프로그래밍 (Reactive) - 라이브러리 사용

// RxJava 또는 Project Reactor 사용 예제
Flux.just(1, 2, 3, 4, 5)
    .filter(n -> n % 2 == 0)
    .map(n -> n * 2)
    .subscribe(System.out::println);

다양한 패러다임을 혼합한 실제 예제

import java.util.*;
import java.util.concurrent.*;
import java.util.stream.*;

// OOP: 클래스와 인터페이스 정의
interface DataProcessor<T> {
    CompletableFuture<List<T>> process(List<T> data);
}

public class HybridExample implements DataProcessor<Integer> {
    private final ExecutorService executor = Executors.newFixedThreadPool(4);
    
    @Override
    public CompletableFuture<List<Integer>> process(List<Integer> data) {
        // 함수형 + 동시성 프로그래밍
        return CompletableFuture.supplyAsync(() -> 
            data.parallelStream()           // 병렬 처리
                .filter(n -> n > 0)         // 함수형: 필터링
                .map(this::complexCalculation)  // 메서드 참조
                .sorted()                    // 정렬
                .collect(Collectors.toList()),
            executor
        );
    }
    
    // 명령형 스타일의 복잡한 계산
    private Integer complexCalculation(Integer n) {
        int result = n;
        for (int i = 0; i < 3; i++) {
            result = result * 2 + 1;
        }
        return result;
    }
    
    public static void main(String[] args) throws Exception {
        HybridExample processor = new HybridExample();
        List<Integer> data = Arrays.asList(1, -2, 3, 4, -5, 6);
        
        // 비동기 처리 시작
        CompletableFuture<List<Integer>> future = processor.process(data);
        
        // 콜백 체인 (함수형)
        future.thenApply(result -> {
            System.out.println("처리 결과: " + result);
            return result;
        })
        .thenAccept(result -> {
            // 결과 활용
            int sum = result.stream().mapToInt(Integer::intValue).sum();
            System.out.println("합계: " + sum);
        })
        .get(); // 완료 대기
        
        processor.executor.shutdown();
    }
}

Java의 멀티 패러다임 특징

장점

점진적 도입: 기존 OOP 코드베이스에 함수형 요소를 점진적으로 도입 가능
유연성: 문제에 가장 적합한 패러다임 선택 가능
생태계: 다양한 스타일의 라이브러리와 호환

한계

완전하지 않은 함수형: 불변성이 언어 차원에서 강제되지 않음
혼재된 스타일: 여러 패러다임이 섞여 일관성 유지가 어려울 수 있음
학습 곡선: 모든 패러다임을 효과적으로 사용하려면 학습이 필요

결론

Java는 “실용적인” 멀티 패러다임 언어입니다. 순수한 함수형 언어(Haskell)나 순수한 객체지향 언어(Smalltalk)와 달리, Java는 실용성을 중시하며 여러 패러다임의 장점을 선택적으로 활용할 수 있게 설계되었습니다. 특히 Java 8 이후로는 현대적인 프로그래밍 패러다임을 적극적으로 수용하고 있어, 진정한 멀티 패러다임 언어로 진화했다고 볼 수 있습니다.

Tue, 14 Oct 2025 11:25:18 +0900

DB의 테이블의 row가 너무 많아질떄 (예 하루에 10만건씩 누적), 대처 방법

“하루 10만 건씩 계속 누적”이면 1년에 3,650만 건입니다. 초반엔 버티지만, 몇 달만 지나도 쿼리·백업·VACUUM/OPTIMIZE 비용이 급증하죠. 아래 순서대로 적용해보세요.

1) 먼저 결정할 것 (운영 정책)

보존 기간: 예) “6개월은 온라인(핫), 2년은 아카이브(콜드), 그 외 삭제”
주요 조회 패턴: 최근 N일만 조회? 특정 사용자/키 기준 조회? 집계 위주?
SLA/성능: p95 응답시간, 허용 가능한 쓰기 지연

2) 즉시 효과 (스키마/인덱스/쓰기)

인덱스 슬림화: 실제 조건/정렬에 쓰는 컬럼만 인덱스. 불필요한 복합 인덱스 제거.

Access Token을 http header에 보내는 것과 body에 보내는 것의 차이

Fri, 12 Sep 2025 08:25:18 +0900

HTTP API 호출 시 access token을 헤더와 바디에 보내는 것 사이에는 몇 가지 중요한 보안상 차이점이 있습니다:

주요 보안 차이점

1. 로깅 및 모니터링

헤더: 대부분의 웹 서버와 프록시는 기본적으로 Authorization 헤더를 로그에서 마스킹하거나 제외합니다
바디: 요청 바디는 디버깅 목적으로 로그에 기록될 가능성이 높아 토큰이 평문으로 노출될 위험이 있습니다

2. 캐싱 동작

헤더: HTTP 캐시는 Authorization 헤더가 있는 요청을 기본적으로 캐시하지 않습니다
바디: 바디에 토큰이 있어도 캐시 정책에 따라 응답이 캐시될 수 있어, 의도치 않은 토큰 노출 위험이 있습니다

3. 프록시 및 미들웨어 처리

헤더: 표준 인증 헤더로 인식되어 보안 미들웨어에서 적절히 처리됩니다
바디: 일반 데이터로 취급되어 보안 처리가 누락될 수 있습니다

4. 브라우저 개발자 도구

헤더: 네트워크 탭에서 볼 수는 있지만, Authorization 헤더임을 명확히 인식할 수 있습니다
바디: 일반 데이터처럼 보여 개발자가 민감한 정보임을 놓칠 수 있습니다

권장사항

// ✅ 권장: Authorization 헤더 사용
fetch('/api/data', {
  headers: {
    'Authorization': 'Bearer ' + accessToken,
    'Content-Type': 'application/json'
  }
});

// ❌ 비권장: 바디에 토큰 포함
fetch('/api/data', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    accessToken: accessToken,
    otherData: data
  })
});

결론: Authorization 헤더를 사용하는 것이 보안상 더 안전하며, HTTP 표준을 준수하는 방법입니다. 대부분의 보안 도구와 인프라가 이를 전제로 설계되어 있어 더 나은 보안 보장을 제공합니다.

Java에서 event를 활용한 구현 예시

Mon, 01 Sep 2025 16:13:53 +0900

1) 이벤트 정의 (POJO/record 권장)

// src/main/java/com/example/user/event/UserSignedUpEvent.java
package com.example.user.event;

import java.time.Instant;

public record UserSignedUpEvent(Long userId, String email, Instant occurredAt) {}

Spring 6+/Boot 3에서는 ApplicationEvent를 상속할 필요가 없습니다. 평범한 POJO/record가 좋아요.

2) 이벤트 발행 (raise)

// src/main/java/com/example/user/service/SignUpService.java
package com.example.user.service;

import com.example.user.event.UserSignedUpEvent;
import com.example.user.model.User;
import com.example.user.repo.UserRepository;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.Instant;

@Service
public class SignUpService {

    private final UserRepository userRepository;
    private final ApplicationEventPublisher publisher;

    public SignUpService(UserRepository userRepository, ApplicationEventPublisher publisher) {
        this.userRepository = userRepository;
        this.publisher = publisher;
    }

    @Transactional
    public Long signUp(String email, String name) {
        User user = userRepository.save(new User(email, name));  // JPA 엔티티 저장 가정
        // 이벤트 발행 (트랜잭션 안에서)
        publisher.publishEvent(new UserSignedUpEvent(user.getId(), user.getEmail(), Instant.now()));
        return user.getId();
    }
}

3) 동기 리스너 (기본)

// src/main/java/com/example/user/listener/AuditLogListener.java
package com.example.user.listener;

import com.example.user.event.UserSignedUpEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.event.EventListener;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
public class AuditLogListener {
    private static final Logger log = LoggerFactory.getLogger(AuditLogListener.class);

    @Order(0) // 여러 리스너가 있을 때 순서 제어 가능 (낮을수록 먼저)
    @EventListener
    public void onUserSignedUp(UserSignedUpEvent event) {
        log.info("AUDIT: userId={}, email={}, at={}", event.userId(), event.email(), event.occurredAt());
    }
}

기본은 “동기 실행”이라 발행 시점에 즉시 호출됩니다.

Java Spring에서 "reflection(리플렉션)"

Tue, 29 Jul 2025 14:07:45 +0900

Java Spring에서 “reflection(리플렉션)“은 Java의 런타임 시점에 클래스, 메서드, 필드 등에 접근하고 조작할 수 있는 기능을 의미합니다. 일반적인 컴파일 시점이 아닌, 실행 중인 애플리케이션의 구조를 동적으로 분석하거나 변경하는 데 활용됩니다.

💡 리플렉션이란?

Java 리플렉션 API는 java.lang.reflect 패키지를 통해 제공되며, 다음과 같은 기능을 제공합니다:

클래스 이름으로 Class 객체를 얻기
클래스의 생성자, 메서드, 필드 정보 조회
메서드 호출, 필드 값 읽기/쓰기 등 동적 조작
접근 제한자(private 등) 무시하고 접근 (setAccessible(true))

🛠 Spring에서 리플렉션이 쓰이는 주요 예

Spring 프레임워크는 내부적으로 리플렉션을 매우 광범위하게 사용합니다:

JPA사용시 row level lock 적용

Thu, 24 Jul 2025 10:07:45 +0900

Spring Boot 3 + JPA + MySQL 환경에서 특정 테이블에 대해 find 및 save 작업 시 row-level lock만 사용하고 table-level lock을 피하고 싶을 경우, 다음과 같은 전략을 사용할 수 있습니다.

✅ 핵심 개념 요약

MySQL InnoDB 스토리지 엔진은 기본적으로 row-level lock을 지원하며, JPA의 기본 동작은 row-level lock을 사용합니다.
그러나 다음 조건을 만족하지 않으면 innoDB라도 table lock이 발생할 수 있습니다:
- WHERE 절에 인덱스를 잘 사용하지 못하거나
- 락 모드가 명시되지 않았거나
- UPDATE나 SELECT ... FOR UPDATE에서 범위 검색을 제대로 구성하지 않았거나

✅ 전제 조건: 테이블이 InnoDB 엔진인지 확인

SHOW TABLE STATUS WHERE Name = 'your_table_name';

Engine 컬럼이 InnoDB여야 row-level lock이 적용됩니다.
만약 MyISAM이면 row-level lock이 불가능하므로 반드시 InnoDB로 변경해야 합니다:

ALTER TABLE your_table_name ENGINE = InnoDB;

✅ JPA에서 row-level locking만 적용하기

1. `@Lock(LockModeType.PESSIMISTIC_WRITE)` 또는 `@Lock(LockModeType.PESSIMISTIC_READ)`

@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {

    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("SELECT o FROM Order o WHERE o.id = :id")
    Optional<Order> findByIdForUpdate(@Param("id") Long id);
}

PESSIMISTIC_WRITE는 SELECT ... FOR UPDATE를 실행하여 row-level exclusive lock을 겁니다.
이 쿼리는 해당 row를 다른 트랜잭션에서 변경하지 못하게 막습니다.
PESSIMISTIC_READ는 공유락을 걸며 읽기는 허용하되 쓰기는 막습니다.

⚠️ 주의: 이 방법은 반드시 트랜잭션(@Transactional) 안에서 사용되어야 실제로 락이 적용됩니다.

Java Pathfinder 사용법

Thu, 03 Jul 2025 10:49:24 +0900

아래에 Java Pathfinder (JPF) 사용하는 방법을 자세히 안내드립니다. Java Pathfinder는 자바 프로그램의 모델 체킹(model checking) 도구로, 프로그램의 상태 공간을 탐색하여 버그나 데드락 등을 찾는 데 활용됩니다.

아래 내용을 단계별로 설명드릴게요.

🧭 1. Java Pathfinder(JPF)란?

**Java Pathfinder (JPF)**는 자바 프로그램을 실행하며 상태공간을 체계적으로 탐색하는 툴입니다.

주요 기능

멀티스레딩 버그 탐지
Assertion 위반 검출
Deadlock 탐지
Non-deterministic 동작 검증
Symbolic execution (jpf-symbc) 지원

⚙️ 2. 설치

JPF는 GitHub 저장소에서 직접 빌드하는 것이 일반적입니다.

Mutation Testing in Java, Pitest

Thu, 03 Jul 2025 10:44:24 +0900

아래에 Java에서 PIT (Pitest) Mutation Testing을 사용하는 방법을 단계별로 정리해 드립니다. PIT는 자바 코드의 테스트 커버리지를 실제로 검증하는 강력한 도구로, 잘못된(변이된) 코드를 테스트가 얼마나 잘 잡아내는지를 측정합니다.

📌 1. PIT(Pitest) 소개

Mutation Testing이란?
- 기존 코드를 일부러 “변이(mutant)” 시켜서 테스트를 돌려보는 기법입니다.
- 테스트가 이 변이를 검출하지 못하면, 테스트에 허점이 있다는 뜻입니다.
- 단순한 라인 커버리지보다 더 신뢰성 있는 테스트 품질 지표를 제공합니다.
PIT의 특징
- JUnit 기반 테스트와 잘 통합됩니다.
- Maven, Gradle, Ant에서 쉽게 사용 가능합니다.
- HTML 및 XML 리포트를 생성합니다.

⚙️ 2. Maven 프로젝트에 PIT 적용

2.1 Maven 플러그인 추가

pom.xml에 다음 플러그인을 설정합니다:

boot3 에서 postgresql에 직접 접속이 아닌 ssh tunnel 로 접속하는 방법

Thu, 03 Jul 2025 08:44:24 +0900

Spring Boot 3에서 SSH 터널을 통한 PostgreSQL 연결을 위한 설정 방법을 알려드리겠습니다.

1. application.yml 설정

spring:
  datasource:
    url: jdbc:postgresql://localhost:5433/your_database_name
    username: your_db_username
    password: your_db_password
    driver-class-name: org.postgresql.Driver
  
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: true
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
        format_sql: true

# SSH 터널 설정 (커스텀 프로퍼티)
app:
    ssh:
      tunnel:
        host: your-ssh-server.com
        port: 22
        username: ssh_username
        private-key-path: ~/.ssh/id_rsa
        local-port: 5433
        remote-host: localhost  # SSH 서버에서 본 DB 호스트
        remote-port: 5432       # 실제 PostgreSQL 포트

2. SSH 터널 자동 연결을 위한 Configuration 클래스## 3. 필요한 의존성 추가 (build.gradle)

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.postgresql:postgresql'
    implementation 'com.github.mwiede:jsch:0.2.17'
    
    // 기타 필요한 의존성들...
}

3. ssh key 만들기 예시

ssh-keygen -t rsa -b 4096 -m PEM -f ~/.ssh/id_rsa -C "ceo@pink-spider.io"

DB가 설치된 서버에 ~/.ssh 등에 authorized_keys (권한 644) 파일에 id_rsa.pub 내용 추가해야 됩니다.
rsa가 아닌 OpenSSh로 keygen 했을 경우 com.github.mwiede:jsch 가 아닌 다른 라이브러리를 써야 됩니다.

SshTunnelConfig


@Configuration
@Slf4j
@Profile({"local", "dev", "stage", "prod"})
public class SshTunnelConfig {

    @Value("${app.ssh.tunnel.host}")
    private String sshHost;

    @Value("${app.ssh.tunnel.port}")
    private int sshPort;

    @Value("${app.ssh.tunnel.username}")
    private String sshUsername;

    @Value("${app.ssh.tunnel.private-key-path}")
    private String privateKeyPath;

    @Value("${app.ssh.tunnel.local-port}")
    private int localPort;

    @Value("${app.ssh.tunnel.remote-host}")
    private String remoteHost;

    @Value("${app.ssh.tunnel.remote-port}")
    private int remotePort;

    @Value("${app.ssh.tunnel.passphrase:}")
    private String passphrase;

    private Session session;

    @PostConstruct
    public void createSshTunnel() {
        try {
            log.info("JSch SSH 터널 연결 시작...");

            // 로컬 포트가 사용 가능한지 확인
            if (!isPortAvailable(localPort)) {
                throw new RuntimeException("로컬 포트 " + localPort + "가 이미 사용 중입니다.");
            }

            JSch jsch = new JSch();

            // 개인키 파일 경로 처리
            String keyPath = privateKeyPath;
            if (keyPath.startsWith("~/")) {
                keyPath = System.getProperty("user.home") + keyPath.substring(1);
            }

            // 파일 존재 및 읽기 권한 확인
            File keyFile = new File(keyPath);
            if (!keyFile.exists()) {
                throw new RuntimeException("SSH 개인키 파일을 찾을 수 없습니다: " + keyPath);
            }

            if (!keyFile.canRead()) {
                throw new RuntimeException("SSH 개인키 파일을 읽을 수 없습니다. 파일 권한을 확인하세요: " + keyPath);
            }

            log.info("SSH 개인키 파일: {}", keyPath);

            // 키 형식 확인 (RSA 형식인지 체크)
            try (java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.FileReader(keyFile))) {
                String firstLine = reader.readLine();
                log.info("키 파일 형식: {}", firstLine);

                if (firstLine != null && !firstLine.contains("BEGIN RSA PRIVATE KEY")) {
                    log.warn("RSA 형식이 아닌 키가 감지되었습니다: {}", firstLine);
                    log.warn("RSA 형식 키를 생성하려면: ssh-keygen -t rsa -b 4096 -m PEM -f {}", keyPath);
                }
            }

            // 개인키 추가
            if (passphrase != null && !passphrase.trim().isEmpty()) {
                jsch.addIdentity(keyPath, passphrase);
                log.info("패스프레이즈와 함께 개인키 로드 완료");
            } else {
                jsch.addIdentity(keyPath);
                log.info("개인키 로드 완료");
            }

            // SSH 세션 생성
            session = jsch.getSession(sshUsername, sshHost, sshPort);
            session.setConfig("StrictHostKeyChecking", "no");
            session.setConfig("PreferredAuthentications", "publickey");
            session.setTimeout(30000);

            log.info("SSH 서버 연결 시도: {}@{}:{}", sshUsername, sshHost, sshPort);
            session.connect();
            log.info("SSH 연결 성공");

            // 포트 포워딩 설정
            session.setPortForwardingL(localPort, remoteHost, remotePort);

            // 포트가 열릴 때까지 대기
            waitForPortToOpen(localPort, 10000);

            log.info("SSH 터널이 성공적으로 생성되었습니다: localhost:{} -> {}:{}:{}",
                localPort, sshHost, remoteHost, remotePort);

        } catch (JSchException e) {
            log.error("SSH 터널 생성 실패: {}", e.getMessage(), e);

            // 구체적인 에러 메시지 제공
            if (e.getMessage().contains("invalid privatekey")) {
                log.error("개인키 형식이 잘못되었습니다. RSA 형식 키를 사용하세요.");
                log.error("새 RSA 키 생성: ssh-keygen -t rsa -b 4096 -m PEM -f ~/.ssh/level_up_rsa");
            } else if (e.getMessage().contains("Auth fail")) {
                log.error("인증에 실패했습니다. 공개키가 서버에 등록되어 있는지 확인하세요.");
                log.error("공개키 등록: ssh-copy-id -i {} {}@{}", privateKeyPath + ".pub", sshUsername, sshHost);
            } else if (e.getMessage().contains("Connection refused")) {
                log.error("서버 연결이 거부되었습니다. 호스트와 포트를 확인하세요.");
            }

            cleanupResources();
            throw new RuntimeException("SSH 터널 연결에 실패했습니다: " + e.getMessage(), e);
        } catch (Exception e) {
            log.error("예상치 못한 오류: {}", e.getMessage(), e);
            cleanupResources();
            throw new RuntimeException("SSH 터널 설정 중 오류가 발생했습니다: " + e.getMessage(), e);
        }
    }

    @PreDestroy
    @EventListener(ContextClosedEvent.class)
    public void closeSshTunnel() {
        log.info("SSH 터널 종료 시작...");
        cleanupResources();
        log.info("SSH 터널 종료 완료");
    }

    private void cleanupResources() {
        if (session != null && session.isConnected()) {
            try {
                session.disconnect();
                log.info("SSH 세션이 종료되었습니다.");
            } catch (Exception e) {
                log.warn("SSH 세션 종료 중 오류: {}", e.getMessage());
            }
        }
    }

    private boolean isPortAvailable(int port) {
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    private void waitForPortToOpen(int port, long timeoutMillis) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        while (System.currentTimeMillis() - startTime < timeoutMillis) {
            try (java.net.Socket socket = new java.net.Socket()) {
                socket.connect(new java.net.InetSocketAddress("localhost", port), 1000);
                log.info("포트 {}가 성공적으로 열렸습니다.", port);
                return;
            } catch (Exception e) {
                // 포트가 아직 열리지 않음, 재시도
                Thread.sleep(500);
            }
        }
        log.warn("포트 {}가 {}ms 내에 열리지 않았습니다.", port, timeoutMillis);
    }
}

Property-Based Testing(PBT) 와 jqwik

Fri, 27 Jun 2025 10:18:03 +0900

**Property-Based Testing(PBT)**은 입력과 결과 간의 **일반적인 속성(Property)**을 정의하고, 테스트 프레임워크가 그 속성을 충족하는지를 무작위로 생성된 다양한 입력값에 대해 확인하는 방식의 테스트입니다. 단위 테스트처럼 특정 입력값만 확인하는 것이 아니라, 수천 개의 입력 조합을 자동으로 검사할 수 있다는 점에서 매우 강력합니다.

🔍 Property-Based Testing이란?

✅ 핵심 개념

속성(Property): 테스트 대상 함수나 로직이 항상 만족해야 하는 일반적인 법칙 또는 규칙.
입력값 자동 생성: PBT 프레임워크가 다양한 입력값을 무작위로 생성.
Fail case 축소(Shrinking): 실패한 입력값이 발생했을 때, 실패를 재현할 수 있는 최소 입력값으로 줄여서 디버깅을 쉽게 함.

🆚 단위 테스트와의 비교

항목	단위 테스트 (Example-based)	속성 기반 테스트 (Property-based)
입력값	고정된 사례 수동 지정	자동 생성된 다양한 값
테스트 범위	제한적	매우 광범위
유지보수	로직 변경 시 테스트 추가 필요	Property만 잘 정의하면 자동 적용
실패 시 디버깅	명확한 입력값	축소 과정 필요

🧪 Spring Boot에서 Property-Based Test 사용하는 방법

Spring Boot 자체는 JUnit을 기반으로 한 단위 테스트가 기본이며, PBT는 외부 라이브러리를 사용해서 통합하는 것이 일반적입니다. 가장 널리 쓰이는 Java 기반 라이브러리는 다음과 같습니다:

우분투에 postgresql 설치하기

Mon, 23 Jun 2025 10:14:00 +0900

Ubuntu에서 PostgreSQL을 설치하고 외부 접속을 허용하려면 다음과 같은 단계로 진행하면 됩니다.

1. PostgreSQL 설치

sudo apt update
sudo apt install postgresql postgresql-contrib

설치 후 PostgreSQL 서비스가 자동 시작됩니다. 상태 확인:

sudo systemctl status postgresql

2. PostgreSQL 유저 및 DB 설정

PostgreSQL 설치 시 기본적으로 postgres라는 유저가 생성됩니다.

sudo -i -u postgres
psql

원하는 유저와 DB를 만들고 비밀번호 설정:

CREATE USER myuser WITH PASSWORD 'mypassword';
CREATE DATABASE mydb OWNER myuser;

권한 부여:

About curring

Fri, 20 Jun 2025 14:11:00 +0900

커링(Currying)은 여러 개의 인자를 받는 함수를 하나의 인자만 받는 함수들의 연속으로 변환하는 기법입니다. 수학자 하스켈 커리(Haskell Curry)의 이름에서 따온 용어입니다.

기본 개념

일반적인 함수:

function add(a, b, c) {
    return a + b + c;
}

add(1, 2, 3); // 6

커링된 함수:

function curriedAdd(a) {
    return function(b) {
        return function(c) {
            return a + b + c;
        };
    };
}

curriedAdd(1)(2)(3); // 6

화살표 함수로 간단하게

const curriedAdd = a => b => c => a + b + c;

const result = curriedAdd(1)(2)(3); // 6

부분 적용 (Partial Application)

커링의 가장 큰 장점은 부분 적용이 가능하다는 것입니다:

const curriedAdd = a => b => c => a + b + c;

// 부분 적용
const add5 = curriedAdd(5);
const add5And3 = add5(3);

console.log(add5And3(2)); // 10 (5 + 3 + 2)
console.log(add5(4)(1)); // 10 (5 + 4 + 1)

실용적인 예제들

1. 문자열 검사 함수

const hasSubstring = substring => str => str.includes(substring);

const hasReact = hasSubstring('React');
const hasVue = hasSubstring('Vue');

console.log(hasReact('React 개발자')); // true
console.log(hasVue('Vue.js 프레임워크')); // true

// 배열에서 활용
const frameworks = ['React', 'Angular', 'Vue', 'Svelte'];
const reactItems = frameworks.filter(hasReact);
console.log(reactItems); // ['React']

2. 수학 연산

const multiply = a => b => a * b;
const divide = a => b => a / b;

const double = multiply(2);
const triple = multiply(3);
const half = divide(1/2); // 또는 multiply(0.5)

console.log(double(5)); // 10
console.log(triple(4)); // 12

const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(double);
console.log(doubled); // [2, 4, 6, 8, 10]

3. 이벤트 핸들러

const log = level => message => {
    console.log(`[${level}] ${message}`);
};

const logError = log('ERROR');
const logInfo = log('INFO');

logError('데이터베이스 연결 실패'); // [ERROR] 데이터베이스 연결 실패
logInfo('서버 시작됨'); // [INFO] 서버 시작됨

4. API 요청

const apiRequest = method => url => data => {
    return fetch(url, {
        method: method,
        headers: { 'Content-Type': 'application/json' },
        body: data ? JSON.stringify(data) : undefined
    });
};

const get = apiRequest('GET');
const post = apiRequest('POST');
const put = apiRequest('PUT');

// 사용
get('/api/users')();
post('/api/users')({ name: '김철수', email: 'kim@example.com' });

자동 커링 함수 만들기

function curry(fn) {
    return function curried(...args) {
        if (args.length >= fn.length) {
            return fn.apply(this, args);
        } else {
            return function(...nextArgs) {
                return curried.apply(this, args.concat(nextArgs));
            };
        }
    };
}

// 사용 예
function add(a, b, c) {
    return a + b + c;
}

const curriedAdd = curry(add);

console.log(curriedAdd(1)(2)(3)); // 6
console.log(curriedAdd(1, 2)(3)); // 6
console.log(curriedAdd(1)(2, 3)); // 6
console.log(curriedAdd(1, 2, 3)); // 6

라이브러리에서의 활용

Lodash

const _ = require('lodash');

const add = (a, b, c) => a + b + c;
const curriedAdd = _.curry(add);

console.log(curriedAdd(1)(2)(3)); // 6

Ramda

const R = require('ramda');

const users = [
    { name: '김철수', age: 25 },
    { name: '이영희', age: 30 },
    { name: '박민수', age: 35 }
];

const getProperty = R.curry((prop, obj) => obj[prop]);
const getName = getProperty('name');

const names = users.map(getName);
console.log(names); // ['김철수', '이영희', '박민수']

커링의 장점

재사용성: 특정 매개변수가 고정된 새로운 함수를 쉽게 생성
가독성: 함수의 의도가 더 명확해짐
함수 조합: 다른 고차 함수들과 조합하기 쉬움
부분 적용: 필요할 때 일부 인자만 먼저 적용 가능

주의사항

성능: 함수 호출이 중첩되므로 약간의 오버헤드 발생
디버깅: 스택 트레이스가 복잡해질 수 있음
가독성: 과도하게 사용하면 오히려 코드를 이해하기 어려워질 수 있음

커링은 함수형 프로그래밍의 핵심 개념 중 하나로, 코드의 재사용성과 모듈성을 크게 향상시킬 수 있는 강력한 기법입니다.

Curring in Java

Fri, 20 Jun 2025 14:11:00 +0900

1. 함수형 인터페이스 사용 (Java 8+)

기본적인 커링 구현

import java.util.function.Function;

public class CurryingExample {
    
    // 3개 인자를 받는 함수를 커링
    public static Function<Integer, Function<Integer, Function<Integer, Integer>>> 
           curriedAdd() {
        return a -> b -> c -> a + b + c;
    }
    
    public static void main(String[] args) {
        // 사용 예
        Function<Integer, Function<Integer, Function<Integer, Integer>>> add = curriedAdd();
        
        int result1 = add.apply(1).apply(2).apply(3); // 6
        System.out.println(result1);
        
        // 부분 적용
        Function<Integer, Function<Integer, Integer>> add5 = add.apply(5);
        Function<Integer, Integer> add5And3 = add5.apply(3);
        
        int result2 = add5And3.apply(2); // 10
        System.out.println(result2);
    }
}

더 복잡한 예제 - 문자열 처리

import java.util.function.Function;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StringCurrying {
    
    // 문자열 포함 검사 함수
    public static Function<String, Function<String, Boolean>> contains() {
        return substring -> str -> str.contains(substring);
    }
    
    // 문자열 변환 함수
    public static Function<String, Function<String, String>> replace() {
        return target -> replacement -> str -> str.replace(target, replacement);
    }
    
    public static void main(String[] args) {
        List<String> frameworks = Arrays.asList("React", "Angular", "Vue", "Svelte");
        
        // 부분 적용된 함수 생성
        Function<String, Boolean> hasReact = contains().apply("React");
        
        // 스트림과 함께 사용
        List<String> reactItems = frameworks.stream()
            .filter(hasReact::apply)
            .collect(Collectors.toList());
        
        System.out.println(reactItems); // [React]
        
        // 문자열 치환
        Function<String, String> replaceJavaWithKotlin = 
            replace().apply("Java").apply("Kotlin");
        
        String result = replaceJavaWithKotlin.apply("I love Java programming");
        System.out.println(result); // I love Kotlin programming
    }
}

2. 제네릭을 활용한 범용 커링 유틸리티

import java.util.function.*;

public class CurryUtil {
    
    // 2개 인자 함수 커링
    public static <A, B, R> Function<A, Function<B, R>> 
           curry(BiFunction<A, B, R> function) {
        return a -> b -> function.apply(a, b);
    }
    
    // 3개 인자 함수를 위한 함수형 인터페이스
    @FunctionalInterface
    public interface TriFunction<A, B, C, R> {
        R apply(A a, B b, C c);
    }
    
    // 3개 인자 함수 커링
    public static <A, B, C, R> Function<A, Function<B, Function<C, R>>> 
           curry(TriFunction<A, B, C, R> function) {
        return a -> b -> c -> function.apply(a, b, c);
    }
    
    public static void main(String[] args) {
        // BiFunction 커링
        BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;
        Function<Integer, Function<Integer, Integer>> curriedMultiply = curry(multiply);
        
        Function<Integer, Integer> double_ = curriedMultiply.apply(2);
        System.out.println(double_.apply(5)); // 10
        
        // TriFunction 커링
        TriFunction<Integer, Integer, Integer, Integer> add3 = (a, b, c) -> a + b + c;
        Function<Integer, Function<Integer, Function<Integer, Integer>>> curriedAdd3 = curry(add3);
        
        int result = curriedAdd3.apply(1).apply(2).apply(3);
        System.out.println(result); // 6
    }
}

3. 클래스 기반 구현

public class MathOperations {
    
    public static class CurriedAdd {
        private final int first;
        
        private CurriedAdd(int first) {
            this.first = first;
        }
        
        public static CurriedAdd of(int first) {
            return new CurriedAdd(first);
        }
        
        public CurriedAddSecond with(int second) {
            return new CurriedAddSecond(first, second);
        }
        
        public class CurriedAddSecond {
            private final int second;
            
            private CurriedAddSecond(int first, int second) {
                this.second = second;
            }
            
            public int and(int third) {
                return first + second + third;
            }
        }
    }
    
    public static void main(String[] args) {
        int result = CurriedAdd.of(1).with(2).and(3); // 6
        System.out.println(result);
        
        // 부분 적용
        CurriedAdd add5 = CurriedAdd.of(5);
        CurriedAdd.CurriedAddSecond add5And3 = add5.with(3);
        
        int result2 = add5And3.and(2); // 10
        System.out.println(result2);
    }
}

4. 실용적인 예제 - HTTP 클라이언트

import java.util.function.Function;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class CurriedHttpClient {
    
    public static Function<String, Function<String, Function<String, HttpRequest>>> 
           httpRequest() {
        return method -> url -> body -> {
            HttpRequest.Builder builder = HttpRequest.newBuilder()
                .uri(URI.create(url));
            
            switch (method.toUpperCase()) {
                case "GET":
                    builder.GET();
                    break;
                case "POST":
                    builder.POST(HttpRequest.BodyPublishers.ofString(body));
                    break;
                case "PUT":
                    builder.PUT(HttpRequest.BodyPublishers.ofString(body));
                    break;
            }
            
            return builder.build();
        };
    }
    
    public static void main(String[] args) {
        // 부분 적용된 함수들 생성
        Function<String, Function<String, HttpRequest>> get = 
            httpRequest().apply("GET");
        Function<String, Function<String, HttpRequest>> post = 
            httpRequest().apply("POST");
        
        // 사용
        HttpRequest getRequest = get.apply("https://api.example.com/users").apply("");
        HttpRequest postRequest = post.apply("https://api.example.com/users")
            .apply("{\"name\":\"김철수\"}");
        
        System.out.println("GET: " + getRequest.uri());
        System.out.println("POST: " + postRequest.uri());
    }
}

5. Vavr 라이브러리 사용

Vavr(이전 Javaslang)는 자바에서 함수형 프로그래밍을 더 쉽게 할 수 있게 해주는 라이브러리입니다:

JS에서 클로저(closure)란...

Fri, 20 Jun 2025 14:06:17 +0900

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

📌 기본 개념

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

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

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에 계속 접근할 수 있는 이유는 클로저 때문입니다.

All About Join

Wed, 18 Jun 2025 11:27:58 +0900

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 구현 예시

Mon, 16 Jun 2025 20:49:58 +0900

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);
    }
}

Boot에서 샤딩된 DB 사용하려면

Tue, 10 Jun 2025 08:49:58 +0900

스프링 부트 애플리케이션 입장에서 샤딩된 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 Shading

Tue, 10 Jun 2025 08:44:58 +0900

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

1. 왜 샤딩이 필요한가?

성능 확장성(Scalability)
- 단일 서버에 모든 데이터를 저장하면 저장 용량·처리 능력이 한계에 부딪힙니다.
- 데이터와 트래픽이 늘어날수록 로드가 집중되어 응답 지연(latency)이나 병목(bottleneck)이 발생합니다.
고가용성(High Availability)
- 각 샤드를 독립된 노드에 두면, 일부 노드 장애 시에도 전체 시스템이 완전히 다운되지 않고 가용성을 유지할 수 있습니다.
관리 용이성

H2에서 mysql function 쓰려면

Sun, 01 Jun 2025 20:20:45 +0900

배경

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’ 등을 사용합니다.

MySql Slow Query 모니터링

Thu, 29 May 2025 20:20:45 +0900

MySQL에서 Slow Query(슬로우 쿼리) 를 모니터링하는 것은 성능 최적화를 위한 중요한 작업입니다. 다음은 슬로우 쿼리를 모니터링하는 일반적인 방법들입니다:

1. 슬로우 쿼리 로그 활성화하기

슬로우 쿼리를 기록하기 위해 MySQL 설정을 조정합니다.

방법 1: `my.cnf` 또는 `my.ini` 파일 수정

[mysqld]
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 1
log_queries_not_using_indexes = 1

slow_query_log: 슬로우 쿼리 로그 기능 활성화
slow_query_log_file: 로그 파일 위치
long_query_time: 몇 초 이상 걸리는 쿼리를 느린 쿼리로 간주할지 설정 (초 단위)
log_queries_not_using_indexes: 인덱스를 사용하지 않는 쿼리도 로그에 기록

설정 후 MySQL을 재시작해야 반영됩니다.

msa에서 트랜잭션 처리 정책

Mon, 26 May 2025 20:20:45 +0900

MSA(Microservices Architecture) 환경에서 서비스 간 호출 중 오류가 발생했을 때의 트랜잭션 처리 정책은 일반적으로 분산 트랜잭션 또는 사후 보상 트랜잭션(Compensating Transaction) 방식으로 구분되며, 다음과 같은 용어와 정책으로 설명됩니다.

1. SAGA 패턴

정의: MSA에서 가장 널리 쓰이는 트랜잭션 처리 패턴으로, 각 서비스의 로컬 트랜잭션이 성공하면 다음 서비스를 호출하고, 중간에 실패 시 이전에 수행된 작업을 보상 작업(Compensation) 으로 되돌립니다.
종류:
- Choreography 기반: 서비스들이 이벤트를 발행하고 서로 구독하면서 트랜잭션을 이어감. 오케스트레이터가 없음.
- Orchestration 기반: 중앙 컨트롤러(오케스트레이터)가 전체 트랜잭션 흐름을 제어.
예시: 주문 → 결제 → 배송 순서에서 결제 실패 시, 주문을 취소하는 보상 트랜잭션 수행.

Singleton Pattern

Mon, 26 May 2025 20:20:45 +0900

자바(Java)에서 **싱글톤 패턴(Singleton Pattern)**은 특정 클래스의 인스턴스를 하나만 생성하고, 전체 애플리케이션에서 공유할 수 있도록 보장하는 디자인 패턴입니다. 주로 공통된 설정, 로깅, 스레드 풀, 캐시, DB 연결 관리 등에 사용됩니다.

✅ 싱글톤 패턴의 핵심 개념

클래스의 인스턴스를 하나만 생성.
전역 접근점(Global Access Point) 제공.
생성자를 private으로 숨김.
정적 메서드로 인스턴스를 반환.

📦 싱글톤 패턴 구현 예제

1. 기본 싱글톤 (Lazy Initialization)

public class Singleton {
    private static Singleton instance;

    // 생성자를 private으로 설정하여 외부에서 new로 인스턴스 생성하지 못하도록 함
    private Singleton() {}

    // 인스턴스를 필요할 때 생성
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    public void showMessage() {
        System.out.println("Hello from Singleton!");
    }
}

사용 예시:

멱등성(Idempotence)에 대하여

Mon, 26 May 2025 20:20:45 +0900

멱등성(Idempotence)은 컴퓨터 과학에서 자주 등장하는 중요한 개념입니다. 아래에 일반적인 의미와 API 개발과의 관련성을 나누어 자세히 설명드리겠습니다.

💡 멱등성(Idempotence)이란?

멱등성이란 동일한 연산을 여러 번 수행해도 결과가 같아지는 성질을 말합니다. 수학에서 출발한 개념인데, 예를 들어 함수 f(x)가 있을 때 다음이 성립하면 멱등함수라고 합니다:

f(f(x)) = f(x)

예시 (수학적 관점)

절댓값 함수: | |x|| = |x|
집합의 합집합 연산: A ∪ A = A

🌐 멱등성과 API 개발

웹 API 설계 시, 멱등성은 안정적이고 예측 가능한 API를 만들기 위해 매우 중요한 성질입니다. 특히 REST API에서는 각 HTTP 메서드가 멱등성을 가질지를 설계 시 명확히 고려해야 합니다.

Object[] 와 ArrayList

목적	코드
`ArrayList` 선언	`List<Partner> p = new ArrayList<>();`
리스트 → 배열 변환	`Partner[] pArray = pList.toArray(new Partner[0]);`

항목	전통적 CRUD	CQRS
모델 공유	읽기/쓰기 동일한 모델 사용	읽기와 쓰기 모델 분리
확장성	제한적	읽기/쓰기 각각 확장 가능
복잡도	낮음	상대적으로 높음
성능 최적화	어렵다	읽기에 최적화된 구조 가능

항목	Spring 어노테이션	Jakarta 어노테이션
어노테이션 경로	`org.springframework.transaction.annotation.Transactional`	`jakarta.transaction.Transactional`
소속	Spring Framework	Jakarta EE (구 Java EE)
API 레벨	Spring 전용 기능	Java 표준 사양 (JSR-907 등) 기반

항목	`abstract class`	`interface`
키워드	`abstract class ClassName`	`interface InterfaceName`
다중 상속	불가 (단일 상속만 가능)	가능 (여러 인터페이스 구현 가능)
생성자	생성자 정의 가능	생성자 없음
필드	인스턴스 변수, 정적 변수 가능	`public static final` 상수만 선언 가능 (Java 8 이전 기준)
메서드 구현	일부 메서드 구현 가능	Java 8부터는 `default`, `static` 메서드 구현 가능
접근 제어자	다양한 접근 제어자(`private`, `protected`, `public`) 사용 가능	모든 메서드는 기본적으로 `public abstract` (Java 9 이후 `private` 메서드도 가능)
목적	“IS-A” 관계 (상속 기반의 계층화)	기능 정의용, 계약 기반 구조 (다형성, 플러그인)

항목	Platform Thread	Virtual Thread
구현	OS 레벨에서 관리	JVM에서 직접 관리
생성 비용	무겁고 리소스 많이 사용	가볍고 거의 무제한 생성 가능
컨텍스트 스위칭	OS 스케줄러에 의존	JVM 스케줄러 사용 (빠름)
동시성 처리	제한적인 동시성	고밀도 동시성 처리 가능

요소	`HashMap`	`LinkedHashMap`
`null` 키 허용	1개 가능	1개 가능
`null` 값 허용	여러 개 가능	여러 개 가능

개념	설명
Entity	식별자가 있어 고유하게 구분되는 객체 (ex. `Order`, `User`)
Value Object	식별자 없이 값 자체로 의미가 있는 객체 (ex. `Address`, `Money`)
Aggregate	도메인 객체들의 군집. 하나의 루트 엔티티(Aggregate Root)가 존재
Repository	도메인 객체를 저장하고 조회하는 인터페이스 (`findById`, `save`)
Service (도메인 서비스)	특정 엔티티에 속하지 않는 비즈니스 로직 담당
Factory	복잡한 객체 생성 로직 담당
Bounded Context	특정 도메인 모델이 적용되는 명확한 경계

어노테이션	역할
`@Mock`	가짜(Mock) 객체 생성
`@InjectMocks`	테스트 대상 객체를 생성하고, `@Mock` 객체를 그 안에 주입

항목	Stub	Mock
목적	고정된 값 반환 (단순 대체)	동작 검증 + 유연한 설정
기능	미리 정의된 응답 제공	호출 여부, 호출 횟수, 파라미터 검증 등 가능
테스트 타입	주로 상태 기반 테스트 (State-based)	주로 행위 기반 테스트 (Behavior-based)
예시	“이 메서드가 호출되면 무조건 이 값을 리턴”	“이 메서드가 정확히 한 번 호출됐는지 확인하자”

타입	설명	주로 하는 일	대표 예시
Dummy	값이 필요하지만 아무 역할도 하지 않는 객체	메서드 시그니처 채우기 용	`new User(null)`처럼 값만 채움
Fake	실제 구현에 가까우나, 단순하거나 in-memory 기반	간단한 대체 구현	InMemory DB, FakeEmailSender
Stub	고정된 응답을 리턴하는 객체	상태 기반 테스트	`when(repo.findById()).thenReturn()`
Mock	행위 기반, 호출 여부나 순서 검증이 가능한 객체	행위 기반 테스트	`verify(repo).save()`
Spy	실제 객체를 감싸면서, 부분적으로 mock 가능	실제 동작 + 호출 감시	`spy(new UserService(...))`

테스트 목적	적합한 더블
파라미터 채우기만 하면 됨	Dummy
고정된 값 리턴만 필요	Stub
호출 여부/횟수 검증	Mock
실제 객체 + 일부 mocking	Spy
실제 구현 비슷한 동작 필요	Fake

항목	설명
Trace ID	전체 요청 흐름을 추적하기 위한 고유 ID
Span ID	Trace 내에서 개별 작업을 구분하는 ID

속성	설명
`value` 또는 `cacheNames`	사용할 캐시 이름 지정
`key`	캐시 키를 지정 (SpEL 표현식 사용 가능)
`condition`	캐싱할 조건 지정 (SpEL)
`unless`	결과를 저장하지 않을 조건 (SpEL)

항목	VO (Value Object)	DTO (Data Transfer Object)
목적	값 자체를 표현	데이터 전달
불변성	보통 불변	보통 가변
사용 위치	도메인 모델	계층 간 데이터 전달
equals/hashCode	값 기준으로 재정의	일반적으로 재정의하지 않음
로직 포함	가능	없음 (순수 데이터만)

옵션	대상	설명
`-Xmx512m`	힙(Heap) 메모리	힙 메모리의 최대 크기만 제한
`-XX:MaxRAM=512m`	전체 JVM 메모리	힙 + 메타스페이스 + 네이티브 메모리를 포함한 JVM 전체 메모리 제한

항목	`@Component`	`@Bean`
붙이는 위치	클래스	메서드
등록 방식	자동 등록 (컴포넌트 스캔)	수동 등록 (개발자가 명시적으로 생성)
사용 용도	애플리케이션 내부 클래스	외부 라이브러리, 복잡한 초기화
설정 클래스 필요 여부	필요 없음	`@Configuration` 필요

Posts on Pink Spider

분산락(distributed lock) deep dive

1. 분산락이 필요한 이유

Redis pub/sub 과 streams

1. Redis Pub/Sub (Publish/Subscribe)

2. Redis Streams

Spring Boot 비동기 프로그래밍:Future 패턴

1. Future 패턴의 핵심 개념

주요 특징

2. Spring Boot에서의 구현 방식

정규화(Normalization)와 반정규화(Denormalization) 의 트레이드오프

1. 핵심 트레이드오프 요약

2. 정규화 (Normalization)

스프링부트(Spring Boot)와 JPA(Hibernate) 환경에서 스트리밍 쿼리(Streaming Query)

장단점

1. 스트리밍 쿼리의 주요 특징

2. 장점 (Pros)

Memcached 와 redis 비교

1. 한눈에 보는 비교 (Executive Summary)

2. 상세 차이점 분석

① 데이터 구조 (Data Structures)

② 스레드 모델 (Architecture)

Kubernetes(쿠버네티스)와 Docker(도커)의 관계

1. 핵심 비유: 화물선과 항만 시스템

코딩 테스트 합격자 되기(자바편) - 30. 간단한 유니온 파인드 알고리즘 구현하기

답

Git에 보안에 문제되거나 민감정보를 커밋했는지 확인하자

프로그램으로 확인하기.

혹은 히스토리 다 날려버리고 초기화 하기

특정 파일만 히스토리에서 완전히 없애기 (.env의 예)

로컬 맥에 여러 jdk를 다루기 위한 툴 - SDKMAN

1. 설치 가능한 버전 목록 보기 (list)

2. 버전 설치하기 (install)

Aggregate 패턴과 Bulkhead 패턴

🧩 1. Aggregate 패턴

💡 개념

Java는 multi paradigm 언어일까?

Java는 멀티 패러다임 언어인가?

Java가 지원하는 프로그래밍 패러다임

1. 객체지향 프로그래밍 (OOP) - 핵심 패러다임

2. 명령형 프로그래밍 (Imperative)

3. 함수형 프로그래밍 (Functional) - Java 8+

4. 제네릭 프로그래밍 (Generic)

5. 동시성/병렬 프로그래밍 (Concurrent/Parallel)

6. 반응형 프로그래밍 (Reactive) - 라이브러리 사용

다양한 패러다임을 혼합한 실제 예제

Java의 멀티 패러다임 특징

장점

한계

결론

DB의 테이블의 row가 너무 많아질떄 (예 하루에 10만건씩 누적), 대처 방법

1) 먼저 결정할 것 (운영 정책)

2) 즉시 효과 (스키마/인덱스/쓰기)

Access Token을 http header에 보내는 것과 body에 보내는 것의 차이

주요 보안 차이점

1. 로깅 및 모니터링

2. 캐싱 동작

3. 프록시 및 미들웨어 처리

4. 브라우저 개발자 도구

권장사항

Java에서 event를 활용한 구현 예시

1) 이벤트 정의 (POJO/record 권장)

2) 이벤트 발행 (raise)

3) 동기 리스너 (기본)

Java Spring에서 "reflection(리플렉션)"

💡 리플렉션이란?

🛠 Spring에서 리플렉션이 쓰이는 주요 예

JPA사용시 row level lock 적용

✅ 핵심 개념 요약

✅ 전제 조건: 테이블이 InnoDB 엔진인지 확인

✅ JPA에서 row-level locking만 적용하기

1. @Lock(LockModeType.PESSIMISTIC_WRITE) 또는 @Lock(LockModeType.PESSIMISTIC_READ)

Java Pathfinder 사용법

🧭 1. Java Pathfinder(JPF)란?

⚙️ 2. 설치

Mutation Testing in Java, Pitest

📌 1. PIT(Pitest) 소개

⚙️ 2. Maven 프로젝트에 PIT 적용

2.1 Maven 플러그인 추가

boot3 에서 postgresql에 직접 접속이 아닌 ssh tunnel 로 접속하는 방법

1. 설치 가능한 버전 목록 보기 (`list`)

2. 버전 설치하기 (`install`)

1. `@Lock(LockModeType.PESSIMISTIC_WRITE)` 또는 `@Lock(LockModeType.PESSIMISTIC_READ)`

방법 1: `my.cnf` 또는 `my.ini` 파일 수정