NaEun's Notes

Codex Chat 삭제하는 방법 (MacOS)

annovation — Wed, 6 May 2026 19:50:33 +0900

Codex 저장 구조

Codex는 로컬에 세션 파일을 저장한다.
해당 파일을 앱 UI 내에서 삭제하는 기능은 아직 제공되지 않고 있기 때문에 로컬에 저장된 파일 경로로 직접 삭제해야한다.
macOS 기본 경로는 다음과 같다.

~/.codex/sessions
~/.codex/archived_sessions

해결 방법 : archived chat 직접 삭제하기

Finder 로 삭제하기

1. Codex 앱에서 삭제할 chat을 Archive Chat 으로 옮긴다.

2. Finder 를 연다.

3. ⌘ + Shift + G를 누른다.

4. 아래 경로로 이동한다.

~/.codex/archived_sessions/

5. 삭제할 archived session 파일을 휴지통으로 이동한다.

Terminal 로 삭제하기

1. Codex 앱에서 삭제할 chat을 Archive Chat 으로 옮긴다.

2. archived session 목록을 확인하려면

cd ~/.codex/archived_sessions
ls

3. 특정 파일만 삭제하려면

rm 파일명

➡️ 예시

rm session-abc123.jsonl

4. 보관된 채팅을 전부 삭제하려면

rm -rf ~/.codex/archived_sessions/*

주의할 점

필요한 채팅은 백업
archived_sessions 전체 삭제 시 복구 어려움
sessions 폴더와 archived_sessions 폴더를 혼동하지 않기

참고 자료

1. OpenAI Developers

https://developers.openai.com/codex/app/troubleshooting

Troubleshooting – Codex app | OpenAI Developers

FAQ and fixes for common Codex app issues

developers.openai.com

[block-server] 휴지통 자동 삭제 기능 구현 (2)

annovation — Sat, 28 Mar 2026 23:30:51 +0900

Application

DemoApplication.java

PR Link

feat: 문서 휴지통 자동 삭제 기능 추가 by hellonaeunkim · Pull Request #43 · jho951/Block-server

Part (해당되는 것만 체크) BE FE Infra Docs Test #️⃣ 연관된 이슈 closes #41 작업 내용 1. 주요 변경 사항 요약 기존 문서 삭제 API를 soft delete에서 hard delete로 변경 문서를 휴지통으로 보내는 별

github.com

Code

package com.documents;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

코드 해석

@EnableScheduling
- Spring에서 @Scheduled가 붙은 메서드를 찾아서 주기적으로 실행하도록 켜는 설정
- Spring이 애플리케이션 시작 시 스케줄링 기능을 활성화하고, 예를 들어 아래 나오는 DocumentTrashPurgeScheduler.java 같은 Spring Bean 안의 @Scheduled 메서드를 등록해서 실행한다.

참고 자료

Spring Javadoc : @EnableScheduling

Schedular

DocumentTrashPurgeScheduler.java

PR Link

feat: 문서 휴지통 자동 삭제 기능 추가 by hellonaeunkim · Pull Request #43 · jho951/Block-server

github.com

Code

package com.documents;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import com.documents.service.DocumentService;

import lombok.RequiredArgsConstructor;

@Component
@RequiredArgsConstructor
public class DocumentTrashPurgeScheduler {

	private final DocumentService documentService;

	@Scheduled(fixedDelay = 60000)
	public void purgeExpiredTrash() {
		documentService.purgeExpiredTrash();
	}
}

코드 해석

이 클래스는 휴지통에 들어간 문서 중 만료된 문서를 주기적으로 정리하는 스케줄러 역할을 한다.
Spring의 @Scheduled를 이용해서 일정 주기마다 휴지통 만료 문서를 자동 삭제하도록 만든 배치성 컴포넌트이다.
실행될 때 직접 삭제 로직을 구현하지 않고 documentService.purgeExpiredTrash()를 호출함
즉, 스케줄링 책임과 비즈니스 삭제 책임을 분리한 구조

코드 설명

@Component : Spring이 관리하는 Bean
@Scheduled(fixedDelay = 60000)
- 이전 실행이 끝난 뒤 60초 후 다시 실행

클래스를 따로 둔 이유

스케줄링은 실행 트리거 역할, 실제 정책 판단과 DB 삭제는 서비스 계층 역할로 구분하여 구현
이렇게 분리하면 테스트가 쉬워진다. 즉, 서비스는 스케줄러 없이도 단위 테스트가 가능해진다.
나중에 수동 실행(휴지통 비즈니스 로직 직접 호출), 관리자 API, 다른 배치 시스템으로 바꿔도 서비스 재사용 가능

fixedDelay

참고 자료

documentService.purgeExpiredTrash()documentService.purgeExpiredTrash()

Service

DocumentServiceImpl.java

PR Link

feat: 문서 휴지통 자동 삭제 기능 추가 by hellonaeunkim · Pull Request #43 · jho951/Block-server

github.com

Code

@Override
@Transactional
public void purgeExpiredTrash() {
    LocalDateTime expiredAt = LocalDateTime.now().minusMinutes(TRASH_RETENTION_MINUTES);
    List<Document> expiredTrashRoots = documentRepository.findExpiredTrashRoots(expiredAt);

    for (Document expiredTrashRoot : expiredTrashRoots) {
        documentRepository.delete(expiredTrashRoot);
    }
}

...

private void validateTrashRestoreAvailable(Document document) {
    LocalDateTime restoreDeadline = document.getDeletedAt().plusMinutes(TRASH_RESTORE_AVAILABLE_MINUTES);
    LocalDateTime restoreDeadline = document.getDeletedAt().plusMinutes(TRASH_RETENTION_MINUTES);
    if (!LocalDateTime.now().isBefore(restoreDeadline)) {
        throw new BusinessException(BusinessErrorCode.DOCUMENT_NOT_FOUND);
    }
	}

Repository

DocumentRepository.java

PR Link

feat: 문서 휴지통 자동 삭제 기능 추가 by hellonaeunkim · Pull Request #43 · jho951/Block-server

github.com

Code

@Query("""
    select d
    from Document d
    left join d.parent p
    where d.deletedAt is not null
      and d.deletedAt <= :expiredAt
      and (
        p is null
        or p.deletedAt is null
      )
    order by
      d.deletedAt asc,
      d.createdAt asc,
      d.id asc
    """)
List<Document> findExpiredTrashRoots(@Param("expiredAt") LocalDateTime expiredAt);

Github repo

https://github.com/jho951/Block-server/pull/43

feat: 문서 휴지통 자동 삭제 기능 추가 by hellonaeunkim · Pull Request #43 · jho951/Block-server

github.com

[block-server] 휴지통 자동 삭제 기능 구현 (1) : Spring Scheduling vs Spring Batch

annovation — Mon, 23 Mar 2026 23:41:56 +0900

Spring Scheduling

소제목

Spring Batch

소제목

두꺼운 밑줄 스타일

구분	Scheduler (@Scheduled)	Spring Batch
목적	작업 실행 시점 관리	대용량 데이터 처리
역할	“언제 실행할까”	“어떻게 처리할까”
데이터 처리	단순 로직	대량 데이터 처리 최적화
구조	메서드 단위 실행	Job → Step 구조
트랜잭션	직접 처리	자동 관리
실패 처리	없음 (직접 구현)	재시작, retry 지원
사용 난이도	쉬움	비교적 복잡

참고 자료

1) Spring Framework Docs : Spring Scheduling

https://docs.spring.io/spring-framework/reference/integration/scheduling.html?utm_source=chatgpt.com

Task Execution and Scheduling :: Spring Framework

All Spring cron expressions have to conform to the same format, whether you are using them in @Scheduled annotations, task:scheduled-tasks elements, or someplace else. A well-formed cron expression, such as * * * * * *, consists of six space-separated time

docs.spring.io

[block-server] 프로젝트 구조

annovation — Fri, 20 Mar 2026 23:49:54 +0900

Structure

Notion 스타일의 문서 계층과 블록 트리를 다루는 백엔드 서비스이며, Spring Boot 기반 Gradle 멀티모듈 구조로 책임을 분리한 것이 핵심!


  Block-server
├─ AGENTS.md
├─ README.md
├─ docker
│  ├─ Dockerfile
│  ├─ docker-compose.yml
│  └─ docker.sh
├─ docs
│  ├─ REQUIREMENTS.md
│  ├─ decisions
│  │  ├─ 000-adr-template.md
│  │  └─ README.md
│  ├─ discussions
│  │  ├─ 000-strategy-review-template.md
│  │  └─ README.md
│  ├─ roadmap
│  │  ├─ README.md
│  │  └─ v2
│  │     └─ blocks
│  │        ├─ block-delete.md
│  │        └─ block-restore.md
│  └─ runbook
│     └─ DEBUG.md
├─ documents-api
│  ├─ build.gradle
│  └─ src
│     └─ main
│        └─ java
│           └─ com
│              └─ documents
│                 ├─ api
│                 │  ├─ block
│                 │  │  ├─ BlockApiMapper.java
│                 │  │  ├─ BlockController.java
│                 │  │  ├─ dto
│                 │  │  │  ├─ BlockResponse.java
│                 │  │  │  ├─ CreateBlockRequest.java
│                 │  │  │  └─ UpdateBlockRequest.java
│                 │  │  ├─ support
│                 │  │  │  └─ BlockJsonCodec.java
│                 │  │  └─ validation
│                 │  │     ├─ BlockContentValidator.java
│                 │  │     └─ ValidBlockContent.java
│                 │  ├─ code
│                 │  │  ├─ ErrorCode.java
│                 │  │  └─ SuccessCode.java
│                 │  ├─ document
│                 │  │  ├─ DocumentApiMapper.java
│                 │  │  ├─ DocumentController.java
│                 │  │  ├─ dto
│                 │  │  │  ├─ CreateDocumentRequest.java
│                 │  │  │  ├─ DocumentResponse.java
│                 │  │  │  ├─ MoveDocumentRequest.java
│                 │  │  │  └─ UpdateDocumentRequest.java
│                 │  │  ├─ support
│                 │  │  │  └─ DocumentJsonCodec.java
│                 │  │  └─ validation
│                 │  │     ├─ DocumentMetaValidator.java
│                 │  │     └─ ValidDocumentMeta.java
│                 │  ├─ dto
│                 │  │  ├─ BaseResponse.java
│                 │  │  └─ GlobalResponse.java
│                 │  ├─ exception
│                 │  │  ├─ GlobalException.java
│                 │  │  └─ GlobalExceptionHandler.java
│                 │  └─ workspace
│                 │     ├─ WorkspaceController.java
│                 │     └─ dto
│                 │        ├─ CreateWorkspaceRequest.java
│                 │        └─ WorkspaceResponse.java
│                 └─ common
│                    └─ SwaggerConfig.java
├─ documents-boot
│  ├─ build.gradle
│  └─ src
│     └─ main
│        └─ java
│           └─ com
│              └─ documents
│                 └─ DemoApplication.java
├─ documents-core
│  ├─ build.gradle
│  └─ src
│     └─ main
│        └─ java
│           └─ com
│              └─ documents
│                 ├─ common
│                 │  └─ BaseEntity.java
│                 ├─ domain
│                 │  ├─ Block.java
│                 │  ├─ BlockType.java
│                 │  ├─ Document.java
│                 │  └─ Workspace.java
│                 ├─ exception
│                 │  ├─ BusinessErrorCode.java
│                 │  └─ BusinessException.java
│                 └─ service
│                    ├─ BlockService.java
│                    ├─ DocumentService.java
│                    └─ WorkspaceService.java
├─ documents-infrastructur
│  └─ src
│     └─ main
│        └─ java
│           └─ com
│              └─ documents
│                 ├─ repository
│                 │  ├─ BlockRepository.java
│                 │  ├─ DocumentRepository.java
│                 │  └─ WorkspaceRepository.java
│                 ├─ service
│                 │  ├─ BlockServiceImpl.java
│                 │  ├─ DocumentServiceImpl.java
│                 │  └─ WorkspaceServiceImpl.java
│                 └─ support
│                    ├─ OrderedSortKeyGenerator.java
│                    └─ TextNormalizer.java
└─ prompts
   ├─ 0-initial-setup.md
   ├─ README.md
   ├─ explainer
   └─ plan

Explains

documents-boot

애플리케이션 실행 진입점, 프로필/환경설정, 패키징 담당
`DemoApplication.java`가 위치하며, 실제 서버 실행과 설정 로딩을 담당한다.
즉, 다른 모듈이 기능을 제공하는 라이브러리라면 `documents-boot`는 그것들을 조립해서 실행 가능한 애플리케이션으로 만드는 역할을 한다.

documents-api

외부 요청을 직접 받는 계층이다.
이 모듈에는 다음과 같은 요소가 들어 있다.
- `Controller`: 문서, 블록, 워크스페이스 API 엔드포인트
- `dto`: 요청/응답 객체
- `validation`: 요청값 검증 로직
- `support`: JSON 변환 보조 로직
- `code`, `exception`: 공통 응답 코드와 예외 처리
- `SwaggerConfig`: API 문서화 설정
즉, HTTP 요청을 받아 검증하고, 도메인 계층에 작업을 위임한 뒤, 다시 응답 형식으로 변환하는 역할을 맡는다.

documents-core

서비스의 중심 규칙을 담는 계층이다.
여기에는 다음이 위치한다.
- `domain`: `Document`, `Block`, `Workspace` 같은 핵심 엔티티
- `service`: 도메인 서비스 인터페이스
- `exception`: 비즈니스 예외와 에러 코드
- `common`: 공통 엔티티 기반 클래스
중요한 점은, 이 계층은 "무엇을 해야 하는가"를 정의한다는 것이다.
구체적으로 어떻게 저장하는지는 여기서 다루지 않고, 서비스 계약과 도메인 모델 중심으로 구조를 잡고 있다.

documents-infrastructure

실제 구현을 담당한다.
이 모듈에는 다음이 있다.
- `repository`: JPA Repository
- `service`: `documents-core`의 서비스 인터페이스 구현체
- `support`: 정렬 키 생성기, 문자열 정규화 같은 보조 유틸리티
예를 들어 문서 이동, 블록 생성, soft delete 같은 실제 비즈니스 처리는 이 계층의 `ServiceImpl`에서 수행된다.
즉, `core`가 계약이라면 `infrastructure`는 그 계약의 실행체다.

문서화와 운영 보조 구조

루트에는 코드 외에도 협업과 기록을 위한 디렉터리가 따로 존재한다.
- `docs/REQUIREMENTS.md`: 현재 유효한 요구사항 기준서
- `docs/decisions`: 채택된 기술 결정(ADR)
- `docs/discussions`: 전략 검토, 비교, 회의 메모
- `docs/roadmap`: 후속 버전 확장 계획
- `docs/runbook`: 재현 가능한 디버깅 절차
- `prompts`: AI 작업 로그와 설명 문서
이 구조는 단순히 코드를 작성하는 데서 끝나지 않고, "왜 이렇게 만들었는지", "무엇을 결정했는지", "다음엔 무엇을 할지"까지 함께 관리하려는 의도가 반영된 설계다.

실행 환경

루트의 `docker/` 디렉터리는 로컬 실행 환경을 담당한다.
- `Dockerfile`
- `docker-compose.yml`
- `docker.sh`
즉, 애플리케이션과 DB를 포함한 실행 환경을 빠르게 재현할 수 있도록 준비된 구조다.
`docker-compose.yml`을 활용해 애플리케이션과 MySQL 같은 실행 의존성을 함께 올릴 수 있도록 구성해, 로컬 개발 환경을 빠르게 재현할 수 있게 했다.

Github Repo

https://github.com/jho951/Block-server

GitHub - jho951/Block-server: server drawer

server drawer. Contribute to jho951/Block-server development by creating an account on GitHub.

github.com

[바이브 코딩] MacOS Codex CLI 설치

annovation — Tue, 17 Mar 2026 22:50:39 +0900

1. Node.js 설치 확인

Node.js 설치 확인

node -v

zsh: command not found: node 처럼 아무것도 안나온다면, brew 로 설치

brew install node

2. Codex CLI 설치

Codex CLI 설치

npm install -g @openai/codex

node 버전이 오래된 경우 Error 가 뜨기도 한다.
ex. node -v 명령어를 통해 확인한 버전이 v20.11.0 였는데 오류가 나서 brew upgrade node 후 다시 진행했더니 오류가 없었다.

설치 확인

codex --version

설치된 codex cli 버전 확인

계정 연동

codex

터미널에 codex 입력 후 아래와 같이 계정을 연동할 수 있는 옵션이 뜬다.

Mac 의 경우 Codex 앱에 로그인이 되어있으면 추가로 웹페이지로 리다이렉트해서 로그인하는 과정 없이 바로 연동이 되는 것 같다.

CLI 명령어

Codex 실행

codex

또는 바로 프롬프트 명령 가능

codex "Explain this project"

Codex 종료

/quit

모델 변경

/model

빠른 응답, 가벼운 작업

/fast

/fast
Explain this file

깊은 분석, 복잡한 작업

/slow

/slow
Find architecture problems in this repo

현재 변경사항 리뷰

/review --uncommitted

터미널 명령 직접 실행

!ls
!pwd
!git status

Codex 안에서 앞에 ! 붙이면 실제 shell command 실행

참고 자료

1) 블로그 : 맥북에 Codex CLI 설치하기 (feat. Ghat GPT CLI 설치 방법)

https://ratatou2.tistory.com/333

맥북에 Codex CLI 설치하기 (feat. Ghat GPT CLI 설치 방법)

Ghat GPT 유료를 쓰면 Codex가 무료..?난 몰랐다 GPT 유료버전을 쓰면 Codex를 준다는 것을 ㅠ지금이라도 알았으니까 얼른 써야지 뭐...Codex는 Cluade CLI처럼 터미널 창에서 쓸 수 있는 AI 코딩툴? 같은 것

ratatou2.tistory.com

[바이브 코딩] AGENTS.md 로 코딩 에이전트 활용하기

annovation — Mon, 16 Mar 2026 16:00:05 +0900

바이브 코딩

AGENTS.md

OpenAI Codex 팀에서 처음 발표한 AI 에이전트 용 표준 규칙 파일
프로젝트에서 AI 에이전트에게 필요한 맥락과 지침을 주입시켜주는 간단한 마크다운 파일

AI 에이전트가 뭐지? (참고 자료)

단순히 답하는 AI가 아니라 실제 작업을 스스로 수행하고 끝까지 완료하는 실행형 AI 시스템

효율적인 AGENTS.md 구조

하나의 AGENTS.md는 500줄 이내로 유지

LLM 모델의 특성상 컨텍스트 윈도우 사이즈가 한정되어 있기 때문에 에이전트 규칙이 차지하는 정의 때문에 컨텍스트 낭비가 생길 수 있다.

❓컨텍스트
LLM이 쓸 수 있는 제한된 공간

❓LLM
자연어를 토큰과 숫자(벡터)로 변환한 뒤, 이전 문맥을 기반으로 다음에 올 ‘단어(토큰)’의 확률을 계산해 생성하는 모델
ex. 나는 밥을 먹었다. (자연어) -> 나는 / 밥을 / 먹었다. (토큰) -> 숫자 (벡터)로 변환 -> 나는 밥을 ___. 에서 먹었다를 예측

❓컨텍스트 원도우 사이즈
LLM이 한 번에 읽고 기억할 수 있는 텍스트 용량의 한계

큰 프로젝트에서는 여러 개의 조합 가능한 작은 규칙으로 나누어 정의

여러 개의 중첩된 파일로 구조적으로 규칙 파일 정의

출처 : https://www.youtube.com/watch?v=LHx_EFoLonQ

AGENTS.md 파일도 소스코드와 함께 버전관리 하기

코드가 변경되었을 때, 관련된 AGENTS.md 파일도 함께 수정하여 버전 관리를 코드와 같이 해주는 것을 권장

❓버전 관리
파일의 변화 과정을 시간순으로 저장하고 관리하는 것

AI 에이전트가 실제로 코드를 생성하고 작업할 때 AGENTS.md 파일이 큰 영향을 미치기 때문에 코드 리뷰에서 코드만 리뷰하는 것이 아닌, AGENTS.md 파일도 함께 리뷰 하는 것을 권장

신규 팀원 온보딩에 AGENTS.md 활용하기

AGENTS.md 파일에는 아래와 같은 여러 가지 정보가 포함되어 있기 때문에 프로젝트의 코드베이스를 굉장히 빠르게 파악하고 작업을 시작할 수 있는 역할을 할 수 있다.

출처 : https://www.youtube.com/watch?v=LHx_EFoLonQ

한 번 작성으로 끝나는 것이 아니라 계속해서 반복적으로 개선하기

프로젝트 구조 변경, 새로운 기술 스택 추가, 정해진 규칙 준수 여부를 지속적으로 모니터링하고 업데이트 하는 것이 필요하다.

읽어 보기

1. 컬리 기술 블로그 : https://helloworld.kurly.com/blog/vibe-coding-with-claude-code/

Claude Code를 활용한 예측 가능한 바이브 코딩 전략

에이전트 주도 개발에서 발생하는 문제를 해결하고, 컨텍스트를 정밀하게 관리하는 방법

helloworld.kurly.com

참고 자료

1) 유튜브 - 개발동생 : 코딩 에이전트 성능을 20배 올리는 가장 쉬운 방법 | AGENTS.md로 표준 규칙 파일 정의하기

https://www.youtube.com/watch?v=LHx_EFoLonQ

[동시성 처리] 동시성 문제 (Race Condition) 해결 방법 3가지 관점 - (3) Redis Distributed Lock

annovation — Wed, 11 Mar 2026 23:52:22 +0900

Redis Distributed Lock

Redis에서 제공하는 대표적인 라이브러리 Lettuce 와 Reddison 을 활용하여 해결할 수 있다.

Lettuce

1) 특징

비동기(Async) 및 동기(Sync) 방식 모두 지원하는 Redis 클라이언트이다.

❗️Redis 클라이언트 란?
애플리케이션(Spring, Node 등)이 Redis 서버와 통신하기 위해 사용하는 라이브러리

Netty 기반의 비동기 I/O 처리를 지원한다.

❗️Netty 란?
Lettuce가 Redis 서버와 통신할 때 사용하는 비동기 내부 네트워크 프레임워크

Lettuce는 분산락을 제공하는 라이브러리가 아니라 Redis 명령을 실행하는 클라이언트이기 때문에 lock을 Redis 명령어로 직접 구현해야 한다.

❗️setnx 명령어를 활용하여 분산락 구현
setnx : Set If Not Exist의 줄임말로, 특정 key에 value 값이 존재하지 않을 경우에 값을 설정(set) 하는 명령어

spin Lock 방식

- lock을 획득하려는 스레드가 lock을 사용할 수 있는지 반복적으로 확인하면서 lock을 시도하는 방식
- retry 로직을 작성해야한다.

Spring Data Redis 라이브러리에서 기본적으로 사용 가능하다.
Spring Boot 2.x 이상에서는 기본 Redis 클라이언트로 Lettuce가 사용된다.
Redis 명령을 이용한 간단한 분산 락 구현은 가능하다.

2) 장점

Lettuce는 Redis Cluster 환경에서도 사용할 수 있다.

❗️Redis 클러스터 환경(cluster environment) 이란? (공식 문서)
여러 개의 Redis 서버를 묶어서 하나의 Redis처럼 사용하는 구조
데이터를 여러 서버에 나눠 저장(sharding) 하는 것

3) 단점 (참고 자료)

단순한 분산 락을 구현하는 데 사용할 수 있지만, 완전한 Redisson 수준의 분산 락을 제공하지 않음

❗️분산 락
여러 프로세스가 공유 자원을 '상호 배타적으로' 접근하도록 하는 것 (redis 공식 문서)
즉, 여러 서버나 요청이 같은 데이터를 사용하려고 할 때, 동시에 처리하지 않고 한 요청이 작업을 끝낼 때까지 다른 요청은 기다리게 만드는 것

4) 사용 방법

infrastructure/redis/RedisLockRepository.java

@RequiredArgsConstructor
@Component
public class RedisLockRepository {
    private RedisTemplate<String, String> redisTemplate;

    public Boolean lock(Long key) {
        return redisTemplate
                .opsForValue()
                .setIfAbsent(generateKey(key), "lock", Duration.ofMillis(3_000));
    }

    public Boolean unlock(Long key) {
        return redisTemplate.delete(generateKey(key));
    }

    public String generateKey(Long key) {
        return key.toString();
    }
}

➡️ lock(Long key) 메서드

public boolean lock(Long key) {
    return redisTemplate.opsForValue()
        .setIfAbsent(key, "lock", Duration.ofMillis(3000));
}

Duration.ofMillis(3_000) : 3초 후 자동으로 lock 삭제

실제 Redis 명령

SET key value NX PX 3000

key가 없으면 생성 → 락 획득
key가 있으면 실패 → 이미 다른 스레드가 락 사용중

➡️ unlock(Longe key) 메서드

public void unlock(Long key) {
    redisTemplate.delete(key);
}

실제 Redis 명령

DEL key

lock 삭제 → 다른 프로세스가 lock 획득 가능

Reddison

1) 특징

2) 장점

3) 단점

4) 사용 방법

참고 자료

[동시성 처리] 동시성 문제 (Race Condition) 해결 방법 3가지 관점 - (2) Database Lock

annovation — Mon, 9 Mar 2026 03:09:41 +0900

Database Lock

데이터베이스가 제공하는 Lock을 활용하여 데이터 정합성을 맞출 수 있다.

Pessimistic Lock (비관적 락)

출처 : https://minjooig.tistory.com/147#비관적%20락(Perssimistic%20Locking)이란%3F-1

실제 데이터에 직접적으로 Lock을 거는 방식
다른 트랜잭션은 Lock이 해제되기 전까지 데이터를 읽을 수 없다.

1) 특징 (참고 자료)

데이터 충돌을 피하기 위해 먼저 Lock을 걸고 작업을 진행
일반적으로 Exclusive Lock(X Lock, 배타적 락)을 사용해 다른 트랜잭션의 Read/Write을 방지한다.
은행 계좌, 항공권 좌석, 콘서트 티켓 등 충돌이 빈번하고 데이터 정합성이 중요한 환경에서 유용하다.

2) 장점 (참고 자료)

충돌이 빈번하게 일어날 경우 Optimistic Lock보다 성능이 좋을 수 있다.
Lock을 통해 update를 제어하기 때문에 데이터의 정합성이 보장된다.
(데이터를 수정할 때 미리 잠가(lock) 버리기 때문에, 여러 사람이 동시에 건드려도 데이터가 꼬이지 않는다는 의미)

3) 단점 (참고 자료)

서로 다른 자원을 쥐고 놓지 않는 데드락(Deadlock) 발생 가능

4) 사용 방법

Spring Data JPA에서는 @Lock 어노테이션을 사용하여 구현할 수 있다.

public interface StockRepository extends JpaRepository<Stock, Long> {
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("select s from Stock s where s.id = :id")
    Stock findByIdWithPessimistic(Long id);
}

➡️ @Lock(LockModeType.PESSIMISTIC_WRITE)

해당 데이터에 대해 쓰기 잠금을 설정하여, 다른 트랜잭션이 해당 데이터를 읽거나 수정하지 못하게 막는다.

Optimistic Lock (낙관적 락)

출처 : https://minjooig.tistory.com/147#비관적%20락(Perssimistic%20Locking)이란%3F-1

데이터를 읽고 수정할 때까지 락을 걸지 않고, 수정 시점에서 충돌 여부를 확인
실제로 락을 이용하지 않고 version 을 이용해 데이터 정합성을 맞춤

1) 특징 (참고 자료)

먼저 데이터를 읽은 후에 update를 할 때 내가 읽은 버전이 맞는 확인하며 업데이트한다.
일반적으로 버전번호 또는 타임스탬프를 활용해 변경 여부를 확인
동시성이 높은 환경에서 유용하며, 충돌 가능성이 낮은 경우 적합

2) 장점 (참고 자료)

별도의 Lock을 잡지 않아 Pessimistic Lock보다 성능상으로 이점이 있다.

3) 단점 (참고 자료 1, 참고 자료 2)

충돌이 발생하면 다시 데이터를 읽고 재시도해야 한다.
update가 실패했을 때 재시도 로직을 개발자가 직접 작성해야 하는 번거로움이 있다.

3-1) 예외처리를 하는 이유 (참고 자료)

1. 사용자 A가 Stock 데이터를 조회 (SELECT)

id=1, quantity=100, version=1

2. 사용자 B가 동일한 Stock 데이터를 조회 (SELECT)

id=1, quantity=100, version=1

3. 사용자 A가 Stock을 업데이트 (UPDATE)

UPDATE stock SET quantity=90, version=2 WHERE id=1 AND version=1;

성공적으로 업데이트됨 (version=2로 증가)

4. 사용자 B가 Stock을 업데이트 시도 (UPDATE)

UPDATE stock SET quantity=80, version=2 WHERE id=1 AND version=1;

version=1을 가진 데이터가 없으므로 예외 발생 (OptimisticLockException)

4) 사용 방법

Stock Entity Class 에 version 컬럼 추가

@Entity
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Stock {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private Long productId;

  private Long quantity;

  @Version
  private Long version;
  
  //생략...
}

➡️ 주의 : javax.persistence 패키지에 있는 @Version 어노테이션을 사용

Repository

public interface StockRepository extends JpaRepository<Stock, Long> {

  @Lock(LockModeType.OPTIMISTIC)
  @Query(" select s from Stock s where s.id = :id ")
  Stock findByIdWithOptimisticLock(Long id);
  
}

➡️ Spring Data JPA에서는 @Lock 어노테이션을 사용하여 구현할 수 있습니다.

facade 생성

@Component
public class OptimisticLockStockFacade {

    private final OptimisticLockStockService optimisticLockStockService;

    public OptimisticLockStockFacade(OptimisticLockStockService optimisticLockStockService){
        this.optimisticLockStockService = optimisticLockStockService;
    }

    public void decrease(Long id, Long quantity) throws InterruptedException{
        while (true) {  //업데이트를 실패했을 때 재시도를 해야함
            try {
                optimisticLockStockService.decrease(id, quantity);

                //정상적으로 업데이트 되면 빠져나감
                break;
            } catch (Exception e) {
                //수량 감소 실패 시, 재시도
                Thread.sleep(50);
            }
        }
    }
}

➡️ Optimistic Lock은 실패했을 경우 재시도를 해야하기 때문에 facade(퍼사드)와 같은 재시도 로직을 생성해야한다.

Named Lock

1-1) 특징

이름을 가진 메타데이터를 사용하는 metadata locking 방법이다. (참고 자료)
이름을 가진 lock을 획득한 후 해제할 때까지 다른 세션이 이 lock을 획득할 수 없도록 한다. (참고 자료)
트랜잭션이 종료 될 때 Lock이 자동으로 해제되지 않으므로 별도의 명령어로 해제가 필요하다. (참고 자료)
MySQL에서는 GET_LOCK() 함수를 사용해서 사용자가 정의한 이름(name)을 기준으로 lock을 획득할 수 있다. (공식 문서)

1-2) Named Lock 데이터 적용 과정 (참고 자료)

Named Lock은 DB에 락을 걸지 않고, 별도의 공간에 락을 건다.
session-1이 1이라는 이름으로 락을 건다면 session-1이 1을 해지한 후에 락을 얻을 수 있다.

2) 장점

3) 단점 (참고 자료)

락을 획득하지 못하면 대기하거나 재시도 로직 필요
트랜잭션 종료 시 자동으로 Lock 해제 되지 않아 Lock을 걸고 해제하는 별도 로직이 필요

4) 사용 방법 (참고 자료)

Named Lock 을 수행하는 repository 를 생성 한다.

public interface LockRepository extends JpaRepository<Stock, Long> {
    @Query(value = "select get_lock(:key, 3000)", nativeQuery = true)
    void getLock(String key);

    @Query(value = "select release_lock(:key)", nativeQuery = true)
    void releaseLock(String key);
}

Lock 획득 해제하는 별도의 명령을 위해 Facade 패턴을 생성한다.

@Component
public class NamedLockStockFacade {

    private final LockRepository lockRepository;
    private final StockService stockService;

    public NamedLockStockFacade(LockRepository lockRepository, StockService stockService){
        this.lockRepository = lockRepository;
        this.stockService = stockService;
    }

    //decrease 메서드
    @Transactional
    public void decrease(Long id, Long quantity){
        try {
            //lock 획득
            lockRepository.getLock(id.toString());
            //재고 감소
            stockService.decrease(id, quantity);
        }finally {
            //모든 로직이 종료되었을 때, lock 해제
            lockRepository.releaseLock(id.toString());
        }
    }
}

StockService propagation 수정

@Transactional(propagation = Propagation.REQUIRES_NEW)
public synchronized void decrease(Long id, Long quantity){
    // Stock 조회
    Stock stock = stockRepository.findById(id).orElseThrow();

    // 재고를 감소
    stock.decrease(quantity);

    // 갱신된 값을 저장
    stockRepository.saveAndFlush(stock);
}

➡️ 부모의 트랜잭션과 별도로 실행되어야 하기 때문에 propagation을 변경해주어야 한다.

❗️Propagation(전파) 란?

현재 메서드가 트랜잭션을 어떻게 사용할지 결정하는 규칙

ex.
@Transactional(propagation = Propagation.REQUIRED) -> 기존 트랜잭션 사용, 없으면 새로 생성
@Transactional(propagation = Propagation.REQUIRES_NEW) -> 항상 새로운 트랜잭션 생성, 기존 트랜잭션은 일시 정지

connection pool size 수정

같은 데이터 소스를 사용하기 위해 connection pool size를 변경합니다.
maximum-pool-size: 40

참고 자료

1) 블로그 : SpringBoot 동시성 이슈 해결방법[3] - Lock

https://velog.io/@kiteof_park/SpringBoot-pessimistic-lock

SpringBoot 동시성 이슈 해결방법[3] - Lock

synchronized의 한계와 Lock의 종류 - Pessimistic Lock, Optimistic Lock, Named Lock

velog.io

2) 블로그 : [Java/Spring] 재고 시스템으로 알아보는 동시성 이슈와 해결 방법

https://velog.io/@ha02e/Java-Spring-ConcurrencyIssue#2-database-lock

[Java/Spring] 재고 시스템으로 알아보는 동시성 이슈와 해결 방법

인프런 재고시스템으로 알아보는 동시성이슈 해결방법 강의를 듣고 작성한 글입니다.

velog.io

3) 블로그 : [Java/Spring] 재고시스템으로 알아보는 동시성 이슈 해결 방법

https://girokeulhaja.tistory.com/107

[Java/Spring] 재고시스템으로 알아보는 동시성 이슈 해결 방법

❗해당 포스팅은 인프런에서 제공해 주는 강의 내용을 개인적으로 정리하였음을 알려드립니다. 재고시스템으로 알아보는 동시성이슈 해결방법 강의 | 최상용 - 인프런최상용 | , 동시성 이슈

girokeulhaja.tistory.com

4) 유튜브 : 락의 두 종류: 비관적 락 vs 낙관적 락

https://www.youtube.com/watch?v=oJrVl6QKzHw

5) 블로그 : 인프런) 재고시스템으로 알아보는 동시성 이슈 해결 (1)

https://dodop-blog.tistory.com/463

인프런) 재고시스템으로 알아보는 동시성 이슈 해결 (1)

동시성 이슈 해결을 위한 인프런 강의를 듣고 실습해보았다. https://www.inflearn.com/course/%EB%8F%99%EC%8B%9C%EC%84%B1%EC%9D%B4%EC%8A%88-%EC%9E%AC%EA%B3%A0%EC%8B%9C%EC%8A%A4%ED%85%9C/dashboard 재고시스템으로 알아보는 동

dodop-blog.tistory.com

6) MySQL Docs : Locking Functions

https://dev.mysql.com/doc/refman/8.0/en/locking-functions.html

MySQL :: MySQL 8.0 Reference Manual :: 14.14 Locking Functions

This section describes functions used to manipulate user-level locks. Table 14.19 Locking Functions GET_LOCK(str,timeout) Tries to obtain a lock with a name given by the string str, using a timeout of timeout seconds. A negative timeout value means infin

dev.mysql.com

[동시성 처리] 동시성 문제 (Race Condition) 해결 방법 3가지 관점 - (1) Synchronized

annovation — Fri, 6 Mar 2026 18:12:12 +0900

동시성 문제 (Race Condition)

해결 방법

레이스 컨디션을 해결하는 방법에는 크게 3가지 관점이 있다.
첫번째는 Java에서 지원하는 Synchronized 방법으로 해결하기
두번째는 DB가 제공하는 Lock 을 이용하여 데이터 정합성 맞추기
세번째는 Redis 를 활용하여 대표적인 라이브러리 Lettuce 와 Ressison 으로 해결하기

동시성 문제 (Race Condition) 이란?

https://annovation.tistory.com/508

[동시성 처리] Java 에서 발생하는 동시성 문제란?

Java 동시성 문제 (Race Condition, 레이스 컨디션) Java 동시성 문제란?Java에서 여러 스레드가 같은 데이터(필드/객체 상태) 를 공유하며 실행될 때, 올바른 제어 없이 접근하면 오류가 생긴다.이렇게

annovation.tistory.com

Application Level

Java에서 제공하는 Synchronized 키워드를 사용하여 한 개의 스레드만 접근 가능하도록 제한할 수 있다.

Synchronized

//@Transactional
public synchronized void decrease(Long id, Long quantity) {
    // Stock 조회
    // 재고를 감소시킨 뒤
    // 갱신된 값을 저장
    Stock stock = stockRepository.findById(id).orElseThrow();
    stock.decrease(quantity);

    stockRepository.save(stock);
}

synchronized 키워드를 메서드 선언부에 붙여, 해당 메서드는 하나의 스레드만 접근 가능하도록 제한한다.

✅ @Transactional 을 주석처리하는 이유 (출처)

1) @Transactional의 동작 원리

@Transactional은 Spring AOP 기반 프록시(proxy)를 통해 트랜잭션 경계를 생성한다. (공식 문서)

Spring uses AOP proxies to apply transactional behavior.

❗️개념 정리

1) Spring AOP(Aspect Oriented Programming) 란? (공식 문서)
- 관점 지향 프로그래밍이란 뜻으로, 공통 기능을 비즈니스 로직에서 분리해서 자동으로 적용하는 기술이다.
ex.
공통 기능 (ex. 로그)
↓
비즈니스 로직 실행
// Spring은 실제 객체 대신 Proxy 객체를 먼저 호출하고, Proxy가 공통 기능을 실행한 뒤 실제 비즈니스 로직을 호출한다.
↓
공통 기능 (ex. 로그)

2) 프록시(proxy) 란?
- Spring 에서 AOP 개념을 구현한 기능으로, 원래 객체 대신 호출을 받아서 중간에서 처리하는 객체
ex. 원래 객체 UserService를 호출했다면, Spring이 만든 UserServiceProxy가 호출된다.

3) 트랜잭션 이란?
- 여러 데이터베이스 작업(DB 안의 데이터를 읽거나 변경하는 모든 행위, CRUD)을 하나의 논리적 작업 단위로 묶는 것이다.
- 즉 여러 쿼리(데이터베이스에게 요청을 보내는 명령문)가 실행되더라도 전부 성공하거나 / 전부 실패해야 한다.

즉, Spring이 해당 메서드를 감싼 프록시(proxy) 객체를 생성해 트랜잭션을 관리한다.
예를 들면, StockService 를 필드로 가지는 클래스를 새로 만들어서 실행 (참고자료)
Proxy 예시

class OrderServiceProxy {

    OrderService target;

    public void order() {

        System.out.println("로그 시작");

        target.order();

        System.out.println("로그 종료");
    }
}

실행 흐름

Client
 ↓
Proxy.order()
 ↓
OrderService.order()

2) @Transactional 을 주석처리하는 이유

commit(트랜잭션의 모든 작업을 최종 확정해 DB에 영구 저장하는 것)은 트랜잭션 완료 시점에 이루어진다.
commit 전에 DB에 기록되지만, 다른 트랜잭션에서는 그 변경사항을 볼 수 없다.
따라서 재고 감소 메서드 decrease()가 완료되고 실제 DB에 반영 전에 다른 스레드가 decrease()를 호출하면, 다른 스레드는 갱신되기 전에 값을 가져가 이전과 동일한 문제가 발생한다.
즉, 현재 테스트 코드에서는 여러 스레드가 동시에 실행되지만, 하나의 트랜잭션 안에서 commit이 되지 않은채 데이터에 접근하는 구조이다.

3) synchronized 동작 방식

synchronized 키워드는 같은 인스턴스에서 실행되는 여러 스레드가 하나씩 순차적으로 메서드를 실행하도록 보장한다.
같은 인스턴스에서 적용되는 synchronized Lock 예시

StockService service = new StockService();

두 스레드

Thread A → service.decrease()
Thread B → service.decrease()

이 경우

Thread A → lock(service)
Thread B → 대기

결과

A 실행
B 실행

다른 인스턴스에서 적용되는 synchronized Lock 예시

StockService service1 = new StockService();
StockService service2 = new StockService();

두 스레드

Thread A → service1.decrease()
Thread B → service2.decrease()

이 경우

lock(service1)
lock(service2)

결과

동시에 실행

synchronized는 객체 기준으로 Lock을 잡는데 Spring이 Proxy를 사용하면 Lock이 걸리는 객체와 호출 객체가 달라질 수 있다.

4) 정리

@Transactional이 적용되면 Spring은 원본 StockService 대신 프록시 객체를 통해 메서드를 실행하여 트랜잭션을 관리한다.
하지만 synchronized는 원본 객체 인스턴스를 기준으로 동기화되기 때문에, 프록시가 개입하는 구조에서는 의도한 대로 동기화가 보장되지 않을 가능성이 있다.

✅ synchronized 한계 (출처)

synchronized는 하나의 프로세스 안에서만 동기화를 보장한다.
서버가 1대일 때는 데이터 접근을 서버 1대만 해서 괜찮겠지만,
서버가 2대 혹은 그 이상인 경우 데이터 접근을 여러 곳에서 할 수 있게 된다.
실제 운영 서비스는 대부분 2대 이상의 서버를 사용하므로 synchronized 거의 사용❌

참고 자료

1) Spring Docs : Using @Transactional

https://docs.spring.io/spring-framework/reference/data-access/transaction/declarative/annotations.html

Using @Transactional :: Spring Framework

The @Transactional annotation is metadata that specifies that an interface, class, or method must have transactional semantics (for example, "start a brand new read-only transaction when this method is invoked, suspending any existing transaction"). The de

docs.spring.io

2) 블로그 : 동시성 이슈 해결방법[2] - synchronized

https://velog.io/@kiteof_park/SpringBoot-java-synchronized

동시성 이슈 해결방법[2] - synchronized

synchronized로 동시성 이슈를 해결하지 못하는 이유와 @Transactional과의 충돌!

velog.io

[DB] Redis 실습 2

annovation — Thu, 5 Mar 2026 23:11:58 +0900

Spring Boot에서 Redis 사용해보기

Redis의 Hash 자료구조로 저장되는 엔티티(Entity) 만들기

엔티티(Entity) : 저장소(DB, Redis 등)에 저장되는 도메인 객체(클래스)
도메인 객체(Domain Object) : 서비스가 다루는 현실 세계의 개념(ex. 상품, 주문, 계좌 등) 들을 코드로 표현한 객체

1) 요구사항

아래와 같은 도메인 객체의 속성(필드)을 가지는 주문 ID, 판매 물품, 갯수, 총액, 결제 여부에 대한 데이터를 지정하기 위한 ItemOrder 클래스를 RedisHash 만들기

1. 주문 ID - String
2. 판매 물품 - String
3. 갯수 - Integer
4. 총액 - Long
5. 주문 상태 - String

2) 코드 구현

ItemOrder.java

import lombok.*;
import org.springframework.data.annotation.Id;
import org.springframework.data.redis.core.RedisHash;

@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
@RedisHash("order")
public class ItemOrder {
    @Id
    private String id;
    private String item;
    private Integer count;
    private Long totalPrice;
    private String status;
}

➡️ @RedisHash

- 이 클래스가 Redis의 Hash 자료구조로 저장되는 엔티티(Entity)라는 것을 Spring에게 알려준다.

주문에 대한 CRUD를 진행하는 기능

1) 요구사항

ItemOrder의 속성값들을 ID를 제외하고 클라이언트에서 전달해준다. (Spring Boot 서버에서 ID를 생성해야 함)
성공하면 저장된 ItemOrder를 사용자에게 응답해준다.

2) 코드 구현 : Spring Data Redis Repository 의 CrudRepository 활용

OrderRepository.java

import org.springframework.data.repository.CrudRepository;

public interface OrderRepository
        extends CrudRepository<ItemOrder, String> {}

➡️ CrudRepository

- 기본적인 CURD 메서드를 제공하는 인터페이스 (save(), findById(), deleteById() ... )

OrderController.java

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.server.ResponseStatusException;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("orders")
public class OrderController {
    private final OrderRepository orderRepository;

    public OrderController(
            OrderRepository orderRepository
    ) {
        this.orderRepository = orderRepository;
    }

    @PostMapping
    public ItemOrder create(
            @RequestBody
            ItemOrder order
    ) {
        return orderRepository.save(order);
    }

    @GetMapping
    public List<ItemOrder> readAll() {
        List<ItemOrder> orders = new ArrayList<>();
        orderRepository.findAll()
                .forEach(orders::add);
        return orders;
    }

    @GetMapping("{id}")
    public ItemOrder readOne(
            @PathVariable("id")
            String id
    ) {
        return orderRepository.findById(id)
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
    }

    @PutMapping("{id}")
    public ItemOrder update(
            @PathVariable("id")
            String id,
            @RequestBody
            ItemOrder order
    ) {
        ItemOrder target = orderRepository
                .findById(id)
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
        target.setItem(order.getItem());
        target.setCount(order.getCount());
        target.setTotalPrice(order.getTotalPrice());
        target.setStatus(order.getStatus());
        return orderRepository.save(target);
    }

    @DeleteMapping("{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void delete(
            @PathVariable("id")
            String id
    ) {
        orderRepository.deleteById(id);
    }
}

3) 코드 구현 : RedisTemplate 을 활용해 직접 Redis 명령을 사용

RedisConfig.java

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Integer> articleTemplate(
            RedisConnectionFactory redisConnectionFactory
    ) {
        RedisTemplate<String, Integer> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setKeySerializer(RedisSerializer.string());
        template.setValueSerializer(new GenericToStringSerializer<>(Integer.class));
        return template;
    }
}

➡️ RedisTemplate Bean 생성하는 코드

3-1) 각 코드 의미

@Configuration : Spring Bean 설정을 하는 클래스라는 의미
@Bean
- 해당 어노테이션이 붙은 메서드가 반환하는 객체를 Spring Bean 으로 등록 한다.
- 즉, 위 코드에서는 RedisTemplate 을 Spring 이 관리하게 된다.
RedisConnectionFactory : Redis 서버와 연결을 만드는 객체
RedisTemplate

RedisTemplate<String, Integer>

➡️ Redis 명령을 실행하는 클래스

➡️ 예시

redisTemplate.opsForValue().increment("article:1");

Serializer 설정 (중요)

template.setValueSerializer(
    new GenericToStringSerializer<>(Integer.class)
);

➡️ Redis 는 문자열 기반 저장소이기 때문에 Java 객체를 Redis 저장 가능 형태로 변환 해야 한다.

이를 Serializer 라고 하고 위 코드는 Integer → String 변환하고 있다.

3-2) ArticleController.java

RedisConfig로 설정한 RedisTemplate 클래스를 Controller에서 사용하는 예시

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("articles")
public class ArticleController {
    private final ValueOperations<String, Integer> ops;

    public ArticleController(
            RedisTemplate<String, Integer> articleTemplate
    ) {
        ops = articleTemplate.opsForValue();
    }

    @GetMapping("{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void read(
            @PathVariable("id")
            Long id
    ) {
        ops.increment("articles:%d".formatted(id));
    }
}

참고 자료

https://teamsparta.notion.site/1-6-2-2242dc3ef51481f3a285e1abb7bd48e8

챕터1-6 : 실습2 | Notion

Spring Boot에서 Redis 사용해보기

teamsparta.notion.site

[DB] Redis 실습 1

annovation — Wed, 4 Mar 2026 23:54:16 +0900

블로그 별 조회수를 Redis로 확인하기

구현 기능

아래와 같은 조건의 '내 블로그 글 별 조회수'를 Redis로 확인하는 기능을 만드려고 한다.

1. 블로그 URL의 PATH는 /articles/{id} 형식이다.
2. 로그인 여부와 상관없이 새로고침 될때마다 조회수가 하나 증가한다.
3. 이를 관리하기 위해 적당한 데이터 타입을 선정하고,
4. 사용자가 임의의 페이지에 접속할 때 실행될 명령을 작성해보자.

Redis 명령어

Redis의 String 타입은 숫자 카운터로 사용할 수 있고 값을 증가(INCR) 또는 감소(DECR)시키는 연산을 제공한다.

1) 특정 게시글 조회수 증가

INCR articles:{id}

2) 특정 게시글 조회수 증가 예시

INCR articles:1
INCR articles:2
INCR articles:3

1번 게시글 조회수 +1

3) 오늘의 조회수 따로 관리

INCR articles:1:today

1번 게시글의 오늘 조회수 +1

4) 하루가 지나면 날짜 키로 변경

RENAME articles:1:today articles:2026-03-05

오늘 카운터를 날짜 기준 기록으로 변경

Spring 사용 예시

조회수 증가 Service

@Service
@RequiredArgsConstructor
public class ArticleViewService {

    private final StringRedisTemplate redisTemplate;

    public Long increaseView(Long articleId) {

        String key = "articles:" + articleId;

        return redisTemplate
                .opsForValue()
                .increment(key);
    }
}

redisTemplate : Spring이 제공하는 API (RedisTemplate)를 통해 Redis 명령을 실행
opsForValue() : Redis의 String 자료형을 다루는 API
increment() : 내부적으로 Redis 명령 'INCR key'를 실행

블로그에 로그인 한 사람들의 조회수와 가장 많은 조회수를 기록한 글을 Redis로 확인하기

구현 기능

아래와 같은 조건의 '블로그에 로그인한 사람들의 조회수와 가장 많은 조회수를 기록한 글'을 Redis로 확인하는 기능을 만드려고 한다.

1. 블로그 URL의 PATH는 `/articles/{id}` 형식이다.
2. 로그인 한 사람들의 계정은 영문으로만 이뤄져 있다.
3. 이를 관리하기 위해 적당한 데이터 타입을 선정하고,
4. 사용자가 임의의 페이지에 접속할 때 실행될 명령을 작성해보자.
5. 만약 상황에 따라 다른 명령이 실행되어야 한다면, 주석으로 추가해보자.

Redis 명령어

중복을 허용하지 않는 자료형 Set을 활용할 수 있다.

1) Set에 값 추가 (중복 허용 안 됨)

SADD articles:1 alex
SADD articles:1 brad
SADD articles:1 chad

Redis 내부

articles:1 = {alex, brad, chad}

2) Set에 들어있는 원소 개수 반환

SCARD articles:1

결과

3) 중복된 값 저장하는 경우 : SADD 반환값은 0

SADD articles:1 alex brad chad

이미 내부에 alex, brad, chad 가 저장되어 있다면, 반환값은 0이다.

4) 따라서 SADD의 결과에 따라 명령어 실행 여부 결정 가능

# SADD의 결과에 따라 명령 실행
# 0이면 스킵
# 1이면 Sorted Set에 추가

ZADD articles:ranks 1 articles:1

ZINCRBY articles:ranks 1 articles:1

ZADD

Sorted Set "articles:ranks"에
member = articles:1
score = 1
로 추가

ZINCRBY

articles:1의 score를 1 증가

가장 높은 조회수의 글을 보고 싶다면

ZRANGE articles:ranks 0 0 REV

Spring 사용 예시

import java.util.concurrent.TimeUnit;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class ArticleLikeService {

    private final StringRedisTemplate redis;

    public ArticleLikeService(StringRedisTemplate redis) {
        this.redis = redis;
    }

    /**
     * userId가 articleId에 좋아요를 누르면:
     * 1) Set에 userId 추가 (중복이면 0)
     * 2) 새로 추가된 경우에만 Sorted Set 랭킹 점수 +1
     */
    public boolean like(Long articleId, String userId) {
        String likeSetKey = "article:" + articleId + ":likes";     // Set
        String rankKey = "articles:ranks";                         // ZSet
        String member = "articles:" + articleId;                   // ZSet member

        Long added = redis.opsForSet().add(likeSetKey, userId);    // Redis: SADD
        if (added == null) added = 0L;

        if (added == 1L) {
            redis.opsForZSet().incrementScore(rankKey, member, 1); // Redis: ZINCRBY
            return true; // 처음 좋아요 성공
        }
        return false;     // 이미 좋아요 눌렀음
    }

    public Long likeCount(Long articleId) {
        String likeSetKey = "article:" + articleId + ":likes";
        return redis.opsForSet().size(likeSetKey);                 // Redis: SCARD
    }

    public Double rankScore(Long articleId) {
        String rankKey = "articles:ranks";
        String member = "articles:" + articleId;
        return redis.opsForZSet().score(rankKey, member);          // Redis: ZSCORE
    }
}

참고 자료

https://teamsparta.notion.site/1-5-1-2242dc3ef51481478520c62135a0e3c9

챕터1-5 : 실습1 | Notion

Redis 설치 및 기본 명령어 사용해보기

teamsparta.notion.site

[DB] Spring에서 Redis 사용해보기 : RedisTemplate 써보기

annovation — Tue, 3 Mar 2026 23:36:29 +0900

RedisTemplate

RedisTemplate 이란?

Spring Data Redis 에서 제공하는 핵심 클래스 (공식 문서)
Key를 직접 설정하고 자료형도 직접 선택해 가면서 Redis를 활용하고 싶다면, RedisTemplate 을 사용할 수 있다.
RedisTemplate 을 정의하면서 Key와 Value로 사용될 Java 클래스를 정하고, 이후 사용할 세부 작업을 RedisOperations 를 이용해 가져오는 방식이다.

StringRedisTemplate

StringRedisTemplate 이란?

RedisTemplate을 상속받은 클래스로, 복잡한 작업없이 Java의 문자열만 다루는 경우, StringRedisTemplate 이 기본으로 만들어진다.
이는 Key와 Value를 전부 Java의 문자열이라고 가정, 문자열 데이터를 주고받기 위한 작업들을 준비하며, 기본 설정을 가지고 자동으로 만들어져 주입되는 Spring Bean 이다.
Redis의 String 자료형만 사용하는것이 아닌, Redis와 Spring Boot 사이에 데이터를 주고받는 과정에서 직렬화 - 역직렬화 할때 Java의 String으로 취급되는 클래스이다.
Redis List에 넣을 때 Java 문자열을 넣고, Redis Set에 넣을 때 Java 문자열을 넣는다는 의미이다.

RedisTemplateTests.java

@SpringBootTest
public class RedisTemplateTests {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    
    @Test
    public void stringOpsTest() {

    }
}

참고 자료

https://teamsparta.notion.site/1-4-Spring-Redis-2242dc3ef5148183b059f5f71a15b28c

챕터1-4 : Spring에서 Redis 사용해보기 | Notion

Spring Boot 프로젝트 준비

teamsparta.notion.site

[DB] Spring에서 Redis 사용해보기

annovation — Mon, 2 Mar 2026 23:59:42 +0900

의존성 추가

새 프로젝트 생성 시

Spring Data Redis (Access+Driver) 추가

1) Spring Initializr 로 추가할 때

2) IntelliJ IDE 로 추가할 때

기존 프로젝트에 추가 시

build.gradle에 아래 코드 추가

dependencies {
  ...
  implementation 'org.springframework.boot:spring-boot-starter-data-redis'
}

application.yml 추가

src/main/resources 경로에 application.yml 추가

spring:
  data:
    redis:
      host: <서버 주소>
      port: <포트 번호>
      username: <사용자 계정, 기본값 default>
      password: <사용자 비밀번호>

host와 port를 작성하지 않으면 docker-compose 로 설정해둔 값 혹은 설정한 값이 없다면, 기본값인 localhost:6379에 연결을 시도한다.

실습 : Redis에 데이터 저장하기

도메인 객체 만들기 : Item.java

// package, import 생략

@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
@RedisHash("item")
public class Item implements Serializable {
    @Id
    private Long id;
    private String name;
    private String description;
    private Integer price;
}

참고 자료

https://teamsparta.notion.site/1-4-Spring-Redis-2242dc3ef5148183b059f5f71a15b28c

챕터1-4 : Spring에서 Redis 사용해보기 | Notion

Spring Boot 프로젝트 준비

teamsparta.notion.site

[DB] Redis 타입 살펴보기 (공부중..)

annovation — Fri, 27 Feb 2026 22:42:54 +0900

Redis 타입 별 명령어

Redis는 Key - Value 데이터베이스 이다. 그래서 대부분의 명령이 Key를 바탕으로 동작하게 되며, Value로 사용하고자 하는 자료형에 따라 다른 명령어를 사용하게 된다.
또한 대부분의 명령이 존재하지 않는 Key를 이용해도 정상적으로 동작하며, 없는 Key에 데이터를 저장하면 Key를 생성한다.
단, 이미 만든 Key에 해당하는 데이터와 다른 자료형의 명령을 사용하는 경우 오류가 발생할 수 있다.

String

가장 기본적인 자료형이며, Redis가 Java의 Map<String, String> 처럼 동작한다고 생각할 수 있다.
단순 문자열이지만, 실제 메모리에는 바이트 배열 (ex. [68 65 6C 6C 6F]) 로 저장된다.
따라서 바이트로 저장되는 이미지, 음성, 영상, 파일 또는 이메일 본문 등도 보관이 가능하다.
분산된 구조에서 비교적 큰 사이즈의 데이터를 주고받을 때 Key만 전달해서 데이터 위치를 전달하는 방식으로 활용할 수 있다.

GET, SET

SET을 통해 저장할 수 있는 최대 크기는 512MB 이다.

SET user:email alex@example.com
GET user:email

SET <key> <value> : key에 value 문자열 데이터를 저장, " 으로 공백 구분
GET <key> : key에 저장된 문자열 반환

INCR, DECR

만약 저장된 데이터가 정수 데이터라면 데이터를 바로 증가, 감소가 가능하다.

SET user:count 1
INCR user:count
DECR user:count

INCR key : key에 저장된 데이터를 1 증가
DECR key : key에 저장된 데이터를 1 감소

MSET, MGET

여러 Key - Value를 한번에 다루고 싶다면 MSET, MGET 을 활용할 수 있다.

MSET user:name alex user:email alex@example.com
MGET user:name user:email

MSET key value [key value …] : key value의 형태로 주어진 인자들을 각 key에 value를 저장
MGET key [key] : 주어진 모든 key에 해당하는 데이터를 반환

List

Linked List 구현체
Linked List이기 때문에, 중간의 데이터를 활용하는 용도 보다는 양끝의 데이터, 즉 스택 또는 큐 처럼 사용할 수 있다.
예를 들어, A, B, C 데이터가 Linked List 로 저장되어 있을 때, 양 끝에 데이터를 삽입하고 조회하는 방식으로 활용 가능하다.
List의 경우 소셜 네트워크에서 많이 사용하는 자료형이다.
ex. List는 데이터가 순서가 있으므로 최신글 -> 오래된글 의 시간 순서로 정렬된 데이터를 저장할 때 유용
대표적으로 X (구 트위터)가 List를 바탕으로 Timeline을 구성했다고 한다.

X → A → B → C

Redis는 Key - Value 형태로 저장되므로 Map<String, List<String>> 의 형태로 사용한다고 생각하면 된다.

LPUSH, RPUSH, LPOP, RPOP

PUSH 또는 POP을 L 또는 R과 조합하여, 왼쪽 또는 오른쪽에 데이터를 추가 / 제거가 가능하다.

LPUSH user:list alex  # [alex]
LPUSH user:list brad  # [brad, alex]
RPUSH user:list chad  # [brad, alex, chad]
RPUSH user:list dave  # [brad, alex, chad, dave]

LPOP user:list        # brad
RPOP user:list        # chad

LPUSH key value : key에 저장된 리스트의 앞쪽에 value를 저장
RPUSH key value : key에 저장된 리스트의 뒤쪽에 value를 저장
LPOP key : key에 저장된 리스트의 앞쪽에서 값을 반환 및 제거
RPOP key : key에 저장된 리스트의 뒤쪽에서 값을 반환 및 제거

LLEN, LRANGE

리스트를 사용하면서 흔히 사용하는 길이 구하기, 범위 내 원소 반환하기 등의 기능도 제공한다.

LLEN user:list
LRANGE user:list 0 3
LRANGE user:list 0 -1

LLEN key : key에 저장된 리스트의 길이를 반환
- 없는 Key를 대상으로 하면 0이 되지만, 다른 자료형을 저장한 Key를 대상으로 하면 오류가 발생
LRANGE key start end : key의 start부터 end까지 원소들을 반환
- 시작을 0으로 생각하고,
- end가 실제 길이를 벗어나도 오류가 발생하진 않는다.
- start > end일 경우 빈 결과가 반환된다.
- 음수의 경우 리스트의 뒤에서부터 데이터를 가져온다.

Set

Set은 순서가 없고 중복되지 않는 문자열들의 집합이다.

SADD, SREM, SMEMBERS, SISMEMBER, SCARD

SADD user:java alex  # [alex]
SADD user:java brad  # [alex, brad]
SADD user:java chad  # [alex, brad, chad]
SREM user:java alex  # [brad, chad]

SMEMBERS user:java        # [alex, brad, chad]
SISMEMBER user:java brad  # true
SISMEMBER user:java dave  # false

SADD key value : key에 저장된 집합에 value를 추가
SREM key value : key에 저장된 집합의 value를 제거
SMEMBERS key : key에 저장된 집합의 모든 원소를 반환
SISMEMBER key value : key에 저장된 집합에 value가 존재하는지 반환
SCARD key : key에 저장된 집합의 크기를 반환

SINTER, SUNION, SINTERCARD

여기에 복수의 집합이 있다면, 교집합, 합집합 등의 기능을 제공한다.
결과 집합 자체를 반환하기도, 결과 집합의 크기를 반환하기도 한다.

# 다른 Set에 추가한 뒤,
SADD user:python alex
SADD user:python dave

SINTER user:java user:python        # [alex]
SUNION user:java user:python        # [alex, brad, chad, dave]
SINTERCARD 2 user:java user:python  # 1

SINTER key1 key2 : key1과 key2에 저장된 집합들의 교집합의 원소들을 반환
SUNION key1 key2 : key1과 key2에 저장된 집합들의 합집합의 원소들을 반환
SINTERCARD number key1 [key2 ...] : number개의 key에 저장된 집합들의 교집합의 크기를 반환

SISMEMBER

SADD user:java alex   # [alex]
SADD user:java brad   # [alex, brad]
SADD user:java chad   # [alex, brad, chad]

SISMEMBER user:java brad   # true
SISMEMBER user:java dave   # false

중복을 허용하지 않으며, 어떤 데이터의 존재 여부를 확인하는 SISMEMBER 같은 경우 O(1)의 시간복잡도를 가지고 있다.
그래서 중복 없는 방문 수, 인증 토큰 블랙리스트 등을 구현할때 활용할 수 있다.

❗️단, 매우 높은 방문수를 기록하는 서비스의 경우 실제 데이터가 필요하지 않다면, 근사값을 돌려주는 확률형 자료형을 사용하는게 권장됩니다.

Hash

Field - Value 쌍으로 이뤄진 자료형
Hash 데이터를 가져오기 위해 Key를 사용하고, 이후 다시 Key에 저장된 Hash 데이터에 Field - Value 쌍을 넣어주는 형식으로 동작
즉, Redis 전체가 Map이라면 Hash는 Map<String, Map<String, String>>의 형식이라고 생각할 수 있다.
Hash는 본래 하나의 키에 복잡한 데이터 (객체의 데이터 라던지)를 하나의 키에 저장하는 용도로 주로 활용되고, 공식 문서에서도 여러 Key에 걸쳐 객체의 데이터를 표현하기 보단 Hash를 자주 활용할 것을 권장하고 있다. (공식 문서)
장바구니 같은 기능은 사용자별로, 어떤 물품이 몇개나 담겨있는지와 같은 정보가 포함되어야 한다. 사용자 마다 Hash 데이터를 생성하고, 물품 - 갯수 형식으로 데이터를 저장하면 사용자별 장바구니를 쉽게 저장할 수 있다.

While hashes are handy to represent objects ...

HSET, HGET, HMGET, HGETALL, HKEYS, HLEN

HSET user:alex name alex age 25
HSET user:alex major CSE

HGET user:alex name
HGET user:alex age

HMGET user:alex age major
HGETALL user:alex

HKEYS user:alex
HLEN user:alex

HSET key field value [field value] : key의 Hash에 field에 value를 넣는다. 한번에 여러 field - value 쌍을 넣어줄 수 있다.
HGET key field: key에 저장된 Hash의 field에 저장된 value를 반환. 없는 field의 경우 null
HMGET key field [field] : key에 저장된 Hash에서 복수의 field에 저장된 value를 반환
HGETALL key : key에 저장된 Hash에 저장된 field - value를 전부 반환
HKEYS key : key에 저장된 Hash에 저장된 field를 전부 반환
HLEN key : key에 저장된 Hash에 저장된 field의 갯수를 반환

Sorted Set

이름처럼 정렬된 집합이다.
Set과 동일하게, 유일한 값들만 유지하지만 여기에 더해 각 값들에 score라고하는 실수를 함께 보관한다.
그리고 데이터를 가져올 때, score를 바탕으로 정렬하여 값들을 가져올 수 있다.
대표적으로 리더보드나 Rate Limiter, 즉 순위와 관련된 기능을 만드는데 사용된다.

✅ Rate Limiter란, API 등을 제공할 때 짧은 시간에 지나치게 많은 요청을 막기 위한 기능을 의미합니다.

ZADD, ZINCRBY, ZRANK, ZRANGE, ZREVRANK, ZREVRANGE

ZADD user:ranks 10 alex
ZADD user:ranks 9 brad 11 chad
ZADD user:ranks 8 dave

ZINCRBY user:ranks 2 alex

ZRANK user:ranks alex
ZRANGE user:ranks 0 3

ZREVRANK user:ranks alex
ZREVRANGE user:ranks 0 3

ZADD key score member [score member ...] : key의 Sorted Set에 score를 점수로 가진 member를 추가, 이미 있는 member의 경우 새로운 score를 설정
ZRANK key member : key의 Sorted Set의 member의 순위를 오름차순 기준으로 0에서 부터 세서 반환
ZRANGE key start stop : key의 Sorted Set의 member들을 start 부터 stop 순위까지 오름차순 기준으로 반환
ZREVRANK key member : key의 Sorted Set의 member의 순위를 내림차순 기준으로 0에서 부터 세서 반환
ZREVRANGE key start stop : key의 Sorted Set의 member들을 start 부터 stop 순위까지 내림차순 기준으로 반환
ZINCRBY key increment member : key의 Sorted Set의 member의 score를 increment 만큼 증가 (음수를 전달하면 감소)

그 외 공용 명령

그 외 자료형과 상관없이 사용할 수 있는 명령들이 있다.

DEL, EXPIRE, EXPIRETIME

대표적으로 많이 사용하는 건, Key를 제거하기 위한 DEL, 만료시각 설정을 위한 EXPIRE 등이 있다.

SET somekey "to be deleted"
DEL somekey

SET expirekey "to be expired"
EXPIRE expirekey 5
EXPIRETIME expirekey

DEL key : key(와 저장된 데이터)를 제거
EXPIRE key seconds : key의 TTL(유효시각)을 seconds로 설정, seconds초가 지나면 key 제거
EXPIRETIME key : key가 만료되는 시각을 Unix Timestamp로 반환

KEYS *

모든 Key를 확인

KEYS *

glob 패턴 형식을 전달하여, 패턴에 일치하는 키를 반환하는 메서드이다.
* 은 임의갯수의 글자를 대체하는 와일드카드입니다. 지금은 * 만 있으므로, 모든 Key와 일치하는 패턴이기 때문에 모든 Key가 반환된다.

✅ glob 패턴 이란?
Linux 파일시스템 등에서 흔히 사용하며, 와일드카드(wildcard)를 이용해 문자열을 매칭하는 간단한 패턴 규칙이다.

ex.
* 모든 문자열
? 한 글자
[abc] 특정 문자
[a-z] 문자 범위

ex.
h?llo - hello, hallo, hxllo
h*llo - hllo, heeeello
h[ae]llo - hello, hallo (not hillo)
h[^e]llo - hallo, hbllo, ... (not hello)
h[a-b]llo - hallo, hbllo

✅ 와일드카드(wildcard) 란?
임의의 문자나 문자열을 대신해서 매칭되는 특수 문자

FLUSHDB

모든 Key 제거

FLUSHDB

참고 자료

https://teamsparta.notion.site/1-3-Redis-2242dc3ef5148154a4f6c97065cf1b51

챕터1-3 : Redis 타입 살펴보기 | Notion

Redis를 설치하고 성공적으로 연결했다면, 이제 데이터를 저장해 봅시다.

teamsparta.notion.site

[DB] Redis 설치하기 (MacOS)

annovation — Thu, 26 Feb 2026 22:41:43 +0900

로컬 환경에 설치하기

Homebrew를 이용해 Redis 설치

1. Homebrew를 설치한 적 없다면, Homebrew 먼저 설치

Homebrew 설치 페이지 : https://brew.sh/

Homebrew

The Missing Package Manager for macOS (or Linux).

brew.sh

Homebrew 설치 명령어

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. Homebrew를 이용해 Redis를 설치

아래 명령어를 터미널에 입력

brew install redis

3. 백그라운드에서 Redis 실행

brew services start redis

Docker에 설치하기 (권장)

Docker 사용을 권장하는 이유

컨테이너화된 환경을 제공함으로써 OS 차이, 라이브러리 버전 차이 등으로 인한 오류를 예방할 수 있다.

docker-compose.yml 이 필요한 이유

여러 개의 컨테이너로 구성된 애플리케이션을 YAML 파일로 정의하고 한 번의 명령어로 실행할 수 있게 해준다.

Docker 이용해 Redis 설치하기

Docker가 설치되어 있다면 명령어 하나로 Redis를 실행해볼 수 있다.

redis : Redis의 기본(Core) 서버 이미지로, 가장 표준적인 Redis 기능만 포함된 최소 구성 버전입니다. 단순 캐시·세션·Pub/Sub 등 기본 기능 실습에 적합
redis/redis-stack-server : 기본 Redis에 Redis Stack 모듈(ex. JSON, Search, Bloom, TimeSeries 등)이 포함된 서버 이미지이다. JSON 문서 저장, 전문 검색, 확률형 자료구조 등을 사용할 때 선택한다.
redis/redis-stack : redis/redis-stack-server에 Redis Insight(웹 기반 관리 GUI)가 추가된 통합 이미지이다. 서버 기능과 함께 시각적 관리 도구까지 함께 사용하려는 경우 적합하다.
Docker Hub에서 Redis를 찾아보면 세가지 이미지가 상단에 나오게 되는데, 이중 한가지를 선택해서 사용할 수 있다.

❗️Docker Hub 란?

컨테이너 이미지를 저장하고(push) 검색하고 다운로드(pull) 할 수 있는 공식 이미지 레지스트리(registry) 서비스이다.

컨테이너(Container) : 이미지를 실행한 인스턴스로, 격리된 환경에서 애플리케이션이 동작하는 실행 단위
이미지(Image) : 컨테이너를 생성하기 위한 실행 파일과 라이브러리, 설정을 포함한 불변 템플릿
레지스트리(Registry) : Docker 이미지를 저장·관리하고 네트워크를 통해 배포하는 저장소 시스템
도커 허브(Docker Hub) : 컨테이너 이미지를 저장하고 공유하는 Docker 공식 public registry

Run Redis Stack on Docker (공식 문서)

Redis 공식 문서에 Docker 를 통해 Redis Stack 이미지를 다운 받는 방법이 안내되어있다.

1. 프로젝트 루트에 docker-compose.yml 을 생성한다.

services:
  redis-stack:
    image: redis/redis-stack
    container_name: redis-stack-compose
    restart: always
    environment:
      REDIS_ARGS: "--requirepass systempass"
    ports:
      - 6379:6379
      - 8001:8001

위 예시의 systempass가 비밀번호의 역할을 한다. 이 부분을 수정하면 접속할 때 비밀번호가 바뀌니 주의!

2. docker-compose.yml 이 있는 폴더에서 터미널은 열어 아래 명령어를 실행한다.

docker compose up -d

자동으로 최신 버전의 Redis Stack 이미지를 사용하게 된다.

3. Redis 컨테이너가 정상적으로 실행되었는지 확인한다.

docker compose ps

Up 3 minutes : 컨테이너 프로세스가 살아 있음을 의미

Intellij IDEA UE에서 연결해보기

1. Database 탭을 찾아 클릭

2. + 를 누른 다음, Data Source > Redis를 찾아거나, 검색을 통해 Data Source를 선택한 다음, Redis를 입력하면 쉽게 찾을 수 있다.

3. 자신의 Redis 인스턴스의 Host와 Port(위의 과정을 따랐다면 localhost, 6379)를, 이후 User는 default, Password는 로컬에 설치한 경우 생략, Docker로 설치한 경우 자신이 password에 넣은 값을 넣어준다.

4. 이후 Test Connection을 클릭해서 잘 연결되면, OK를 누른다.

5. console 탭에서 명령어들을 사용해서 데이터를 가져올 수 있다.

명령어 예시 (Command + Enter 로 명령어 한 줄 씩 실행 가능)

SET start "hello world"
GET start

console 탭 예시

명령어를 통해 가져온 데이터

❗️console 탭이 사라지면 Database 탭에서 다시 열 수 있다

Redis Insight를 이용해 연결해보기

Redis Insight 란?

Redis 전용 IDE (ex. MySQL Workbench)
간단한 기능 테스트만 할 때는 엄청 필요한 도구는 아닐 수 있다.

App Store 에서 설치하기

MacOS의 경우 App Store 에 등록된 Redis Insight 를 다운로드 가능하다.

Docker 로 설치하기

1. 위에 소개된 docker-compose.yml 를 사용한 경우, Redis Insight 도 같이 설치된다.

services:
  redis-stack:
    image: redis/redis-stack
    container_name: redis-stack-compose
    restart: always
    environment:
      REDIS_ARGS: "--requirepass systempass"
    ports:
      - 6379:6379
      - 8001:8001

redis/redis-stack : 이 이미지는 Redis 서버 + Redis Stack 모듈 + Redis Insight까지 포함된 통합 이미지이다.

2. 따라서 바로 localhost:8001 로 들어가면, 웹 애플리케이션으로 확인 가능하다.

3. Username 과 Password를 입력 후 Test Connection 을 진행한다.

Connection이 성공했다면, Apply Changes 클릭하면 왼쪽 메뉴 바에 새로운 기능들이 활성화 된다.

참고 자료

https://teamsparta.notion.site/1-2-Redis-2242dc3ef51481d0b7a7d2f163d2df05

챕터1-2 : Redis 설치하기 | Notion

코드스니펫

teamsparta.notion.site

[DB] 인메모리 저장소와 Redis 기초

annovation — Wed, 25 Feb 2026 23:58:05 +0900

인메모리 저장소

In-Memory = 메모리 안에서 동작한다는 의미

인메모리 저장소의 필요성

Spring Boot 기반의 애플리케이션에서 일반적으로 사용하는 데이터 저장소는 관계형 데이터베이스(RDBMS)이다.
관계형 데이터베이스의 주된 목적은 영속성(Persistence) 보장이다.
영속성 데이터란, 애플리케이션이 종료되더라도 유지되어야 하는 데이터를 의미한다.
예를 들어, 회원 정보, 주문 내역, 결제 기록, 게시글과 같은 데이터들은 파일시스템에 데이터를 저장함으로서 서비스가 종료되어도 유지되어야 한다.

❗️파일시스템(File System)이란?

파일시스템은 운영체제가 디스크(SSD, HDD)에 데이터를 저장하고 관리하는 구조이다.
데이터를 파일 단위로 저장한다.

하지만 서비스를 만들다보면 영구 보관이 필요없는 일시적인 데이터를 저장해야 하는 상황이 발생할 수 있다.
예를 들어, 로그인 정보, 장바구니, 조회수 카운팅, 실시간 랭킹과 같은 기능은 사용자의 행동에 따라 비번하게 데이터의 수정이 발생한다.
이런 상황에서 파일시스템에 데이터를 저장하는 것은 특성상 속도가 느려진다.

❗️파일시스템(File System) 기반 저장이 상대적으로 느린 이유?

디스크 기반 저장이기 때문이다. 디스크에 데이터를 쓰는 행위는 물리적인 I/O 작업이고 메모리 접근에 비해 속도가 매우 느리다.
이에 반해 데이터를 디스크가 아닌 RAM에 저장하는 인메모리 저장 방식은 디스크에 저장하는 파일시스템 방식에 비해 속도가 매우 빠르다.

대표적인 인메모리 DB : Redis

1) Redis 란?

Redis는 REmote DIctionary Server를 줄인말로, Java의 Map과 같은 방식으로 데이터를 저장하는 데이터베이스이다.

"user:1"
    ├── name → sati
    └── age  → 30

2) Redis 특징

일반적인 관계형 데이터베이스와 다른 가장 큰 특징은 In-Memory 데이터베이스이다.
메모리, 즉 RAM에 데이터를 저장하기 때문에 복잡한 입출력 과정 필요 없다.
RDBMS(관계형 데이터베이스)에 비해 더 빠르게 동작하는 대신, 언제든 사라질 수 있는 데이터를 다룬다는 차이를 가진다.
특정 게시글의 조회수와 같이 빠르게 업데이트되는 데이터, 사용자 세션, 장바구니와 같은 시간이 지나면 삭제되는 데이터 등을 저장하기 위해 가장 많이 사용된다.
대표적인 NoSQL 데이터베이스로, 데이터를 단순히 Key, Value를 저장하는 것이 아닌 자료 구조 (data structure)를 저장한다.

NoSQL

NoSQL 이란?

NoSQL은 데이터베이스를 만드는 접근법의 일종으로, 'Not Only SQL'을 의미한다.
RDBMS(관계형 데이터베이스)는 일반적으로 테이블 형식으로 데이터를 저장하고, 그 데이터를 회수하기 위해 SQL을 사용한다.

SELECT * FROM users;

반면 Redis는 단순 문자열(String)부터, 리스트, 집합, Hash 등 다양한 형태의 데이터를 저장하며, 이 데이터를 회수하기 위해 SQL을 사용하지 않는다.

SET greeting "Hello, Redis!"
GET greeting

일반적인 관계형 데이터베이스가 약점을 가진 확장성, 유연성, 성능에 대한 문제를 해결하기 위해 사용되는 경우가 많으며, 컴퓨터 기술의 발전과 웹의 활성화로 인해 비정형 데이터를 더 높은 성능으로 사용하는데 초점이 맞춰진 경우가 많다.

NoSQL의 데이터 관리 방식

미리 정의된 구조(schema : ex. 데이터 타입, NULL 허용 여부, 기본값, 제약 조건, 인덱스, 외래키 등)와 SQL을 사용하는 RDBMS와 달리, NoSQL은 데이터를 관리하는 방법이 다양하다.

1. Key-Value (ex. Redis)

가장 단순한 형태의 데이터베이스로, Key에 Value를 저장하는 형태이다.
JSON, Python의 Dictionary, Java의 Map의 형태로 데이터를 관리한다고 생각할 수 있다.

"user:1" → "{ name: 'sati', age: 30 }"
"order:1" → "{ userId: 1, items: ['apple', 'banana'] }"

2. Document (ex. MongoDB)

객체를 표현하는 Document라는 단위로 데이터를 저장하는 형태이다.
Key - Value에서 발전했다고 볼 수 있으며, JSON, XML 등 복잡한 데이터를 저장하고 관리한다.

{
  "userId": 1,
  "name": "sati",
  "orders": [
    {
      "orderId": 1,
      "items": [
        { "product": "apple", "qty": 2 },
        { "product": "banana", "qty": 1 }
      ]
    }
  ]
}

3. Column-Family (ex. cassandra)

각 Row의 Column이 고정되어있지 않고, 필요한 데이터 Column을 이름, 데이터, Timestamp와 함께 저장하는 형태의 데이터베이스 이다.

PRIMARY KEY (user_id, order_id)

user_id | order_id | product | qty
-----------------------------------
1       | 1        | apple   | 2
1       | 1        | banana  | 1

Redis 활용 사례

Redis는 NoSQL 중에서도 Key-Value Store로 작동하는 인메모리 데이터베이스이며, 지연이 적은 읽기 / 쓰기 성능을 가졌다.
그렇기 때문에 일시적인 데이터, 변경이 잦은 데이터를 다뤄야 되는 상황에서 많이 활용된다.

1. Session Clustering : 여러 애플리케이션 인스턴스에서 같은 세션 정보를 사용할 수 있도록 도와준다.

2. Caching : 자주 사용되는 데이터를 저장해두어, 데이터베이스 조회를 줄이고 전반적인 응답속도를 개선한다. (웹 어플리케이션의 성능에 많은 영향을 미친다.)

3. 지원하는 다양한 자료구조를 바탕으로 리더보드, 방문수 트래킹, 좌표 기반 검색 등의 기능을 쉽게 구현할 수 있게 해준다.

참고 자료

https://teamsparta.notion.site/1-1-Redis-2242dc3ef514811a85e0e562dfcae13c

챕터1-1 : 인메모리 저장소와 Redis 기초 | Notion

인메모리 저장소의 필요성

teamsparta.notion.site

[동시성 처리] 재고 감소 통합 테스트 코드 6 - Optimistic Lock(낙관적 락) 멀티 스레드 테스트 코드

annovation — Tue, 24 Feb 2026 21:17:09 +0900

Optimistic Lock(낙관적 락) 테스트 코드

Optimistic Lock(낙관적 락) 을 적용한 동시성 처리 테스트 코드를 분석해보자 !

테스트 코드

@Test
@DisplayName("재고 감소 - 100개 동시 요청 시 정확히 차감")
void decreaseStock_when100ConcurrentRequests_thenSuccess() throws Exception {

    // given
    int threadCount = 100;

    ExecutorService executorService = Executors.newFixedThreadPool(threadCount);

    CountDownLatch countDownLatch = new CountDownLatch(threadCount);

    List<Future<?>> futures = new ArrayList<>();

	// when
    for (int i = 0; i < threadCount; i++) {
        futures.add(executorService.submit(() -> {
            try {
                stockRetryFacade.decreaseWithRetry(StockFixture.decreaseRequest(product, 1));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            } finally {
                countDownLatch.countDown();
            }
        }));
    }

    countDownLatch.await();

    for (Future<?> future : futures) {
        future.get(); // 스레드 내부 예외를 테스트 실패로 반영
    }

    executorService.shutdown();

    // then
    Stock updatedStock = jpaStockRepository
            .findByProductId(product.getProductId())
            .orElseThrow();

    assertEquals(0, updatedStock.getQuantity());
}

given

given : 테스트 환경 준비

1) 동시에 실행할 스레드 개수 설정

int threadCount = 100;

2) 스레드 풀 생성 (100개의 스레드를 동시에 실행할 수 있는 환경)

ExecutorService executorService = Executors.newFixedThreadPool(threadCount);

newFixedThreadPool(100): 최대 100개의 작업을 동시에 실행

3) CountDownLatch : 모든 스레드가 작업을 완료할 때까지 대기하기 위한 동기화 도구

CountDownLatch countDownLatch = new CountDownLatch(threadCount);

100으로 초기화 → 각 스레드가 countDown()을 호출할 때마다 1씩 감소
0이 되면 await()에서 대기 중인 메인 스레드가 계속 진행

4) Future 리스트 : 각 스레드의 실행 결과를 추적하기 위한 컨테이너

List<Future<?>> futures = new ArrayList<>();

Future를 통해 스레드 내부에서 발생한 예외를 감지할 수 있음

when

when : 실제 테스트 실행

// 100번 반복하면서 100개의 재고 감소 작업을 동시에 제출
for (int i = 0; i < threadCount; i++) {

    // executorService.submit(): 작업을 스레드 풀에 제출
    // submit()은 Future 객체를 반환 → 나중에 결과 확인 가능
    futures.add(executorService.submit(() -> {
        try {
            // 실제 재고 감소 로직 실행 (재시도 로직 포함)
            // 각 스레드는 재고를 1개씩 감소시키려고 시도
            stockRetryFacade.decreaseWithRetry(
                StockFixture.decreaseRequest(product, 1)
            );

        } catch (InterruptedException e) {
            // InterruptedException 발생 시
            // 1. 현재 스레드의 인터럽트 상태를 복원
            Thread.currentThread().interrupt();

            // 2. RuntimeException으로 감싸서 다시 던짐
            //    (Runnable은 checked exception을 던질 수 없기 때문)
            throw new RuntimeException(e);

        } finally {
            // 작업 성공/실패 여부와 관계없이 항상 실행
            // countDownLatch를 1 감소시켜 "이 스레드는 작업 완료했다"고 알림
            countDownLatch.countDown();
        }
    }));
}

// 모든 스레드가 countDown()을 호출할 때까지 메인 스레드를 여기서 대기
// countDownLatch가 0이 될 때까지 블로킹
// → 100개 스레드가 모두 작업을 완료하면 다음으로 진행
countDownLatch.await();

// Future 리스트를 순회하면서 각 스레드의 실행 결과 확인
for (Future<?> future : futures) {
    // future.get(): 해당 스레드가 완료될 때까지 대기하고 결과를 가져옴
    // 스레드 내부에서 예외가 발생했다면 여기서 ExecutionException 발생
    // → 테스트 실패로 처리됨
    future.get();
}

// 스레드 풀 종료 (더 이상 새 작업을 받지 않음)
// 리소스 정리를 위해 항상 호출해야 함
executorService.shutdown();

1) Future 가 필요한 이유는 뭘까용?

Future 가 없으면 스레드 내부 예외가 숨겨진다.
예를 들어 :

@Test
void test() {
    ExecutorService executor = Executors.newFixedThreadPool(2);
    CountDownLatch latch = new CountDownLatch(2);

    // 스레드 1
    executor.submit(() -> {
        try {
            throw new RuntimeException("에러!");  // ← 예외 발생
        } finally {
            latch.countDown();
        }
    });

    // 스레드 2
    executor.submit(() -> {
        try {
            System.out.println("정상 실행");
        } finally {
            latch.countDown();
        }
    });

    latch.await();
    executor.shutdown();
    
    // 테스트는 통과! (예외를 몰라서)
}

스레드 1: 성공 (재고 99)
스레드 2: 성공 (재고 98)
...
스레드 50: NullPointerException 발생! ← 하지만 테스트는 계속 진행
...
스레드 100: 성공

결과: 재고가 50 (50번만 성공)

하지만 assertEquals(0, stock.getQuantity()) 에서 실패
→ "왜 50이지?" 원인을 알 수 없음!

Future 를 사용하면 스레드 내부 예외가 명확하게 드러난다.
예외를 객체에 저장해 get()을 통해 호출 가능하기 때문에 스레드 안에서 발생한 예외를 호출한 쪽에서 확실하게 확인할 수 있다.
예를 들어 :

@Test
void test() throws Exception {
    ExecutorService executor = Executors.newFixedThreadPool(2);
    CountDownLatch latch = new CountDownLatch(2);
    List<Future<?>> futures = new ArrayList<>();

    // 스레드 1
    futures.add(executor.submit(() -> {
        try {
            throw new RuntimeException("에러!");
        } finally {
            latch.countDown();
        }
    }));

    // 스레드 2
    futures.add(executor.submit(() -> {
        try {
            System.out.println("정상 실행");
        } finally {
            latch.countDown();
        }
    }));

    latch.await();

    // Future로 예외 확인
    for (Future<?> future : futures) {
        future.get();  // ← ExecutionException 발생! 테스트 실패
    }

    executor.shutdown();
}

2) 왜 자료 구조를 ArrayList 로 썼을까용?

순차 접근이 주 목적

// 순차적으로 모든 Future를 확인
for (Future<?> future : futures) {
    future.get();  // 하나씩 차례대로 확인
}

➡️ 인덱스 기반 빠른 접근 : O(1)

크기를 미리 알수 있고, 데이터 추가에 용이하다.

int threadCount = 100;  // 크기 고정

// 정확히 100개의 Future가 들어갈 것을 알고 있음
List<Future<?>> futures = new ArrayList<>(threadCount);  // 초기 용량 지정 가능

for (int i = 0; i < threadCount; i++) {
    futures.add(executor.submit(...));  // 끝에 추가만 함
}

➡️ 데이터 추가(append) : O(1) (평균)

2-1) LinkedList 랑은 무슨 차인데용?

// LinkedList
List<Future<?>> futures = new LinkedList<>();
for (int i = 0; i < 100; i++) {
    futures.add(executor.submit(...));  // O(1)
}
for (Future<?> future : futures) {
    future.get();  // 순회는 괜찮지만 메모리 오버헤드
}

메모리 오버헤드(실제 데이터 저장 외에 추가로 소비되는 메모리)가 크다. (각 노드마다 prev, next 포인터)
인덱스 접근 느림 : O(n)
캐시 지역성

// ArrayList: 연속된 메모리 → CPU 캐시 히트율 높음
for (Future<?> future : futures) {
    future.get();  // ← 빠름
}

// LinkedList: 흩어진 메모리 → CPU 캐시 미스 많음
for (Future<?> future : futures) {
    future.get();  // ← 상대적으로 느림
}

3) 실행 흐름

## 실행 흐름

1. 스레드 풀 생성 (100개)
   
2. 100개 작업 제출 (각각 재고 1씩 감소)
   
3. 모든 작업 동시 실행 (경쟁 상태 발생 가능)
   
4. countDownLatch.await() - 모든 작업 완료 대기
   
5. future.get() - 각 스레드 예외 확인
   
6. DB 조회 - 최종 재고 확인
   
7. assertEquals(0, ...) - 재고가 정확히 0인지 검증

then

then : 결과 검증

1) DB에서 최신 재고 데이터 조회

Stock updatedStock = jpaStockRepository
            .findByProductId(product.getProductId())  // productId로 재고 조회
            .orElseThrow();  // 없으면 예외 발생

@BeforeEach에서 생성한 stock 객체가 아닌, DB에서 다시 가져와야 함!

2) 검증

assertEquals(0, updatedStock.getQuantity());

100개 스레드가 각각 1씩 감소시켰으므로 초기 재고 100 - (100번 × 1씩 감소) = 0이어야 함
만약 동시성 제어가 제대로 안 되었다면 0보다 큰 값이 나올 수 있음

핵심 개념 정리

1. ExecutorService (출처)

ExecutorService executorService = Executors.newFixedThreadPool(100);

여러 작업을 병렬로 실행하기 위한 스레드 풀
newFixedThreadPool(100): 최대 100개의 작업을 동시에 실행

2. CountDownLatch

CountDownLatch latch = new CountDownLatch(100);
latch.countDown();  // -1 감소
latch.await();      // 0이 될 때까지 대기

여러 스레드의 작업 완료를 동기화
카운터가 0이 되면 대기 중인 스레드가 진행

3. Future (출처)

Future<?> future = executorService.submit(...);
future.get();  // 결과 대기 + 예외 확인

Java 표준 라이브러리
비동기 작업의 결과를 나타내는 객체
get() : 작업 완료 대기 + 예외가 있으면 던짐
Java 8 이후부터는 CompletableFuture 사용을 권장한다고 한다.

참고 자료

1) Oracle Docs : Future

https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/concurrent/Future.html

Future (Java SE 21 & JDK 21)

Type Parameters: V - The result type returned by this Future's get method All Known Subinterfaces: RunnableFuture , RunnableScheduledFuture , ScheduledFuture All Known Implementing Classes: CompletableFuture, CountedCompleter, ForkJoinTask, FutureTask, Rec

docs.oracle.com

2) Oracle Docs : ExecutorService

https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html

ExecutorService (Java Platform SE 8 )

An Executor that provides methods to manage termination and methods that can produce a Future for tracking progress of one or more asynchronous tasks. An ExecutorService can be shut down, which will cause it to reject new tasks. Two different methods are p

docs.oracle.com

3) Oracle Docs : CountDownLatch

https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CountDownLatch.html

CountDownLatch (Java Platform SE 8 )

A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes. A CountDownLatch is initialized with a given count. The await methods block until the current count reaches zero due to invo

docs.oracle.com

[동시성 처리] Optimistic Lock (낙관적 락) 재시도 로직

annovation — Mon, 23 Feb 2026 23:53:49 +0900

Optimistic Lock (낙관적 락) 재시도 로직

Optimistic Lock (낙관적 락) 에서는 실패했을 경우 재시도를 해야하는데, 아래 다양한 방법들을 통해 구현할 수 있다.

Spring Retry

Facade 패턴

@Component
@RequiredArgsConstructor
public class StockRetryFacade {

    private final StockService stockService; // @Transactional 메서드 가진 서비스

    public StockResult decreaseWithRetry(StockRequests.Decrease request)
            throws InterruptedException {
        int maxRetries = 100;
        int attempt = 0;

        while (true) {
            try {
                return stockService.decreaseStock(request); // 1회 시도 (새 트랜잭션)
            } catch (OptimisticLockingFailureException e) {
                if (++attempt >= maxRetries) {
                    throw e;
                }
                Thread.sleep(50);
            }
        }
    }
}

재시도 구현 시 검토해야 할 4가지 원칙

낙관적 락에서 발생하는 Conflict는 시스템 장애가 아니다. 오히려 동시성 환경에서 자연스럽게 발생하는 정상적인 제어 흐름이다. 따라서 모든 충돌을 '에러'로 취급해 무조건 재시도하는 것은 올바른 전략이 아니다. 서비스 특성과 트래픽 패턴에 맞는 재시도 설계가 필요하다.

Fresh Read의 원칙 (최신 데이터 재조회)

재시도 시에는 반드시 Primary DB에서 최신 버전 데이터를 다시 조회해야 한다.
메모리에 로드되어 있던 기존 객체를 그대로 들고 재시도하는 것은 무의미한 연쇄 충돌을 야기하고 CPU 자원을 낭비한다.

충돌 발생
   ↓
Primary DB에서 최신 상태 재조회
   ↓
비즈니스 로직 재계산
   ↓
다시 CAS 시도

➡️ CAS 란?

Compare And Swap 의 약자로, 현재 값이 expected 값과 같으면 새로운 값으로 교체 아니면 아무것도 하지 않고 실패
예를 들면 :

UPDATE character_state
SET current_sal = ?, update_version = update_version + 1
WHERE character_id = ?
  AND update_version = ?

지수 백오프와 지터

충돌 직후 즉시 재시도하면 또다시 충돌할 가능성이 매우 높다.
예를 들면 :

1. 모두 같은 값을 읽음

A → SAL=1000, version=1

B → SAL=1000, version=1

C → SAL=1000, version=1

2. A가 먼저 성공

UPDATE ... WHERE version=1

✔ 성공

SAL = 1100

version = 2

3. 나머지는 실패

여기서 B와 C가 즉시 재시도를 한다면?

4. B와 C가 바로 같은 값을 다시 읽음

B → SAL=1100, version=2

C → SAL=1100, version=2

5. 앞선 상황과 같이 B와 C 중 하나만 성공하고 실패한 요청은 다시 데이터를 읽고 또 동시에 업데이트를 시도하는 상황 반복

6. 따라서 실패한 요청을 흩어놓으면 또다시 동시에 부딪히는 상황을 예방할 수 있다.

B → 50ms 기다림

C → 120ms 기다림

따라서 재시도 간격을 2^n 형태로 늘리는 지수 백오프를 적용하고, 여기에 무작위 값인 지터(Jitter)를 섞어 요청 시점을 분산시켜야 한다.

delay = base * 2^n + random_jitter

예를 들면 :

시도 횟수	대기 시간
1회	50ms
2회	100ms
3회	200ms
4회	400ms

이는 수많은 요청이 한꺼번에 몰리는 현상을 방지하여 DB의 병목을 막아주는 핵심 기술이다.

멱등성(Idempotency) 보장

서버 내부 재시도 (OptimisticLockException 이후 retry)가 중복 처리되거나, 네트워크 이슈로 응답 받지 못한 클라이언트가 재요청을 보낼 경우, 동일한 비즈니스 요청이 2번 이상 실행될 가능성이 생긴다.
즉, Optimistic Lock 은 동시성 제어만 보장할 뿐, 중복 실행 방지는 보장하지 않는다.
이 경우, 클라이언트가 모든 요청에 대한 고유한 ID인 request_id를 생성하고 이를 기반으로 멱등성 테이블을 운용하여, 동일한 요청에 대해서는 실제 DB 쓰기 없이 이전의 성공 결과를 반환하는 안전장치가 병행되어야 한다.

CREATE TABLE idempotency (
    request_id VARCHAR(64) PRIMARY KEY,
    response_payload JSON,
    created_at DATETIME
);

➡️ 해당 테이블에 동일한 request_id가 존재한다면 이미 처리된 요청이고, 존재하지 않으면 해당 요청은 처음 처리하는 것임을 나타낸다.

❗️멱등성(Idempotency) 이란?

같은 요청을 여러 번 보내도 결과가 한 번 보낸 것과 동일하게 유지되는 성질이다.
어떤 연산을 한 번 수행하든 여러 번 수행하든 최종 상태가 동일하면 멱등하다고 한다. (참고 자료)

예를 들어, HTTP 메서드를 기준으로 보면 GET은 여러 번 호출해도 같은 결과가 돌아오고, 리소스에 변화를 일으키지 않기 때문에 멱등성이 보장된 메서드이다.

PUT /users/1로 이름을 '홍길동'으로 설정하는 요청은 여러 번 보내도 결과는 동일 → 멱등
POST /orders는 호출할 때마다 주문이 새로 생성 → 멱등하지 않음

최대 재시도 횟수 제한

낙관적 락에서의 재시도는 일시적인 충돌을 완화하기 위한 전략일 뿐, 무한히 반복되어서는 안된다.
충돌이 일정 횟수 이상 반복된다는 것은 단순한 타이밍 문제를 넘어, 특정 데이터에 과도한 경합(Hot Row Contention)이 발생하고 있다는 신호일 수 있다.
예를 들어 3~5회 이상 충돌이 반복된다면 이는 단순한 일시적 충돌이 아니라 설계적 병목 가능성을 의심해야 할 상황이다.
이 경우, 사용자에게 명확한 에러를 반환하거나, 비즈니스 로직에 따라 비관적 락 등으로의 전환을 검토해야 하는 신호일 수 있다.

참고 자료

1) 뱅크샐러드 블로그 : 뱅크샐러드가 게임을 만들 때 데이터 정합성을 유지하는 법 (feat. 낙관적 락)

https://blog.banksalad.com/tech/banksalad-optimistic-lock/

뱅크샐러드가 게임을 만들 때 데이터 정합성을 유지하는 법 (feat. 낙관적 락) | 뱅크샐러드

안녕하세요 금융쇼핑 PA…

blog.banksalad.com

2) 토스 블로그 : 멱등성이 뭔가요?

https://docs.tosspayments.com/blog/what-is-idempotency

멱등성이 뭔가요? | 토스페이먼츠 개발자센터

생소한 표현이지만 알고 보면 쉬워요. 멱등성에 대해 이해하고 API를 멱등하게 제공하기 위한 방법도 함께 알아봐요.

docs.tosspayments.com

[동시성 처리] DB Lock : Optimistic Lock (낙관적 락) - 실습

annovation — Fri, 20 Feb 2026 23:29:16 +0900

Optimistic Lock (낙관적 락)

Optimistic Lock (낙관적 락) 이란?

https://annovation.tistory.com/509

[동시성 처리] 동시성 문제 (Race Condition) 해결 방법 3가지 관점 (실습중..)

동시성 문제 (Race Condition) 해결 방법레이스 컨디션을 해결하는 방법에는 크게 3가지 관점이 있다.첫번째는 Java에서 지원하는 Synchronized 방법으로 해결하기두번째는 DB가 제공하는 Lock 을 이용하

annovation.tistory.com

동시성 처리

동시성 처리 전 코드

StockController

@Operation(summary = "재고 감소 API", description = "상품 주문시 재고가 감소한다.")
@PutMapping
public ResponseEntity<ApiResponse<StockResponse>> decreaseStock(
        @Valid @RequestBody StockRequests.Decrease request) {

    // 재고 감소 로직 호출
    StockResult result = stockService.decreaseStock(request);

    return ResponseEntity.status(HttpStatus.OK)
            .body(ApiResponse.success(StockResponse.from(result)));
}

@Operation(summary = "재고 복원 API", description = "상품 취소시 재고가 복원된다.")
@PutMapping("/restore")
public ResponseEntity<ApiResponse<StockResponse>> restoreStock(
        @Valid @RequestBody StockRequests.Restore request) {

    // 재고 복원 로직 호출
    StockResult result = stockService.restoreStock(request);

    return ResponseEntity.status(HttpStatus.OK)
            .body(ApiResponse.success(StockResponse.from(result)));
}

StockServiceImpl.decreaseStock

@Override
@Transactional
public StockResult decreaseStock(StockRequests.Decrease request) {

    Product product = getProductOrThrow(request.productId());

    Stock stock = getStockOrThrow(request.productId());

    stock.decreaseQuantity(request.quantity());

    return StockResult.from(stock, product.getName());
}

Stock

public void decreaseQuantity(int decreaseQuantity) {
    validateDecreaseQuantity(decreaseQuantity);

    if (this.quantity < decreaseQuantity) {
        throw new GlobalException(INSUFFICIENT_STOCK);
    }

    this.quantity -= decreaseQuantity;
}

JpaStockRepository

public interface JpaStockRepository extends JpaRepository<Stock, UUID> {

    Optional<Stock> findByProductId(UUID productId);
}

StockRepository

public interface StockRepository {

	Stock save(Stock stock);

	Optional<Stock> findByProductId(UUID productId);
}

StockRepositoryAdapter

@Repository
@RequiredArgsConstructor
public class StockRepositoryAdapter implements StockRepository {

	private final JpaStockRepository jpaStockRepository;

	@Override
	public Stock save(Stock stock) {
		return jpaStockRepository.save(stock);
	}

	@Override
	public Optional<Stock> findByProductId(UUID productId) {
		return jpaStockRepository.findByProductId(productId);
	}
}

StockCurrencyTest

try {
    stockServiceImpl.decreaseStock(
            StockFixture.decreaseRequest(product, 1)
    );
}

동시성 처리 전 테스트 코드 결과

재고 100개에 대해 1개씩 100번 동시 차감했을 때 0이 되어야 하는데, 실제로는 88이 남아 동시성 제어가 제대로 되지 않아 일부 차감이 반영되지 않은 상태에서 발생한 AssertionFailedError가 발생했다.

동시성 처리 한 코드

StockController

@PutMapping
public ResponseEntity<ApiResponse<StockResponse>> decreaseStock(
	@Valid @RequestBody StockRequests.Decrease request) {
    
    StockResult result = stockRetryFacade.decreaseWithRetry(request);
    
    return ResponseEntity.status(HttpStatus.OK).body(ApiResponse.success(StockResponse.from(result)));
}

@PutMapping("/restore")
public ResponseEntity<ApiResponse<StockResponse>> restoreStock(
	@Valid @RequestBody StockRequests.Restore request) {
    
    StockResult result = stockRetryFacade.restoreWithRetry(request);
    
    return ResponseEntity.status(HttpStatus.OK).body(ApiResponse.success(StockResponse.from(result)));
}

➡️ 낙관적 락 재시도 로직을 사용할 수 있도록 Facade 클래스를 Controller에서 반영하도록 수정

StockServiceImpl

private Stock getStockWithLockOrThrow(UUID productId) {
        return stockRepository
                .findByProductWithOptimisticLock(productId)
                .orElseThrow(() -> new GlobalException(STOCK_NOT_FOUND));
    }

➡️ Lock 조회 메서드 추가

Stock

@Getter
@Entity
@Table(name = "p_stock")
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Stock extends BaseEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.UUID)
    @Column(name = "stock_id", nullable = false)
    private UUID stockId;

    @Column(name = "product_id", nullable = false)
    private UUID productId;

    @Column(name = "company_id", nullable = false)
    private UUID companyId;

    @Column(name = "hub_id", nullable = false)
    private UUID hubId;

    @Column(name = "quantity", nullable = false)
    private int quantity;

    @Version
    private Long version;

➡️ Stock Entity 에 Version 필드 추가

JpaStockRepository

public interface JpaStockRepository extends JpaRepository<Stock, UUID> {

    Optional<Stock> findByProductId(UUID productId);

    @Lock(LockModeType.OPTIMISTIC)
    @Query("SELECT s FROM Stock s WHERE s.productId = :productId")
    Optional<Stock> findByProductWithOptimisticLock(@Param("productId") UUID productId);
}

StockRepository

public interface StockRepository {

	Stock save(Stock stock);

	Optional<Stock> findByProductId(UUID productId);
	
	Optional<Stock> findByProductWithOptimisticLock(UUID productId);
}

StockRepositoryAdapter

@Repository
@RequiredArgsConstructor
public class StockRepositoryAdapter implements StockRepository {

    private final JpaStockRepository jpaStockRepository;

    @Override
    public Stock save(Stock stock) {
        return jpaStockRepository.save(stock);
    }

    @Override
    public Optional<Stock> findByProductId(UUID productId) {
        return jpaStockRepository.findByProductId(productId);
    }

    @Override
    public Optional<Stock> findByProductWithOptimisticLock(UUID productId) {
        return jpaStockRepository.findByProductWithOptimisticLock(productId);
    }
}

applicaiton/service/StockRetryFacade.java 추가

@Component
@RequiredArgsConstructor
public class StockRetryFacade {

    private final StockService stockService; // @Transactional 메서드 가진 서비스

    public StockResult decreaseWithRetry(StockRequests.Decrease request)
            throws InterruptedException {
        int maxRetries = 100;
        int attempt = 0;

        while (true) {
            try {
                return stockService.decreaseStock(request); // 1회 시도 (새 트랜잭션)
            } catch (OptimisticLockingFailureException e) {
                if (++attempt >= maxRetries) {
                    throw e;
                }
                Thread.sleep(50);
            }
        }
    }
}

➡️ Optimistic Lock은 실패했을 경우 재시도를 해야하기 때문에 이를 구현하기 위한 방법 중 강의에 소개된 facade(퍼사드)를 통해 생성하였다.

StockCurrencyTest

@Test
@DisplayName("재고 감소 - 100개 동시 요청 시 정확히 차감")
void decreaseStock_when100ConcurrentRequests_thenSuccess() throws Exception {

    // given
    int threadCount = 100;

    ExecutorService executorService = Executors.newFixedThreadPool(threadCount);

    CountDownLatch countDownLatch = new CountDownLatch(threadCount);

    List<Future<?>> futures = new ArrayList<>();

	// when
    for (int i = 0; i < threadCount; i++) {
        futures.add(executorService.submit(() -> {
            try {
                stockRetryFacade.decreaseWithRetry(StockFixture.decreaseRequest(product, 1));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            } finally {
                countDownLatch.countDown();
            }
        }));
    }

    countDownLatch.await();

    for (Future<?> future : futures) {
        future.get(); // 스레드 내부 예외를 테스트 실패로 반영
    }

    executorService.shutdown();

    // then
    Stock updatedStock = jpaStockRepository
            .findByProductId(product.getProductId())
            .orElseThrow();

    assertEquals(0, updatedStock.getQuantity());
}

➡️ 테스트에서 StockServiceImpl 대신 StockRetryFacade를 주입해 decreaseWithRetry를 호출하도록 수정

동시성 처리 후 테스트 코드 결과

[동시성 처리] Trouble Shooting : Pessimistic Lock 적용 오류

annovation — Thu, 19 Feb 2026 16:33:27 +0900

진행 환경

Java 17
Spring Boot 3.5.7
MySQL 8.0.44
Gradle

문제 상황

Pessimistic Lock (낙관적 락) 적용을 위해 @Lock(LockModeType.PESSIMISTIC_WRITE) 추가 후 아래와 같은 오류 발생

➡️ TransactionRequiredException: Query requires transaction be in progress

문제 증상

PESSIMISTIC_WRITE 락 쿼리를 트랜잭션 없이 실행해서 난 오류

원인 분석

원인 1 : 테스트 코드에서 단순히 재고 데이터를 읽어오는 작업이더라도 트랜잭션이 걸려있어야 한다.

현재 테스트 코드에서 레이스 컨디션 검증 포인트는 아래 stockServiceImpl 에서 decreaseStock 을 통해 동시 호출 하는 구간이다.

for (int i = 0; i < threadCount; i++) {
            executorService.submit(() -> {

                try {
                    stockServiceImpl.decreaseStock(
                            StockFixture.decreaseRequest(product, 1)
                    );
                } finally {
                    countDownLatch.countDown();
                }
            });
        }

그런데, JpaStockRepository.findByProductId에 @Lock(PESSIMISTIC_WRITE) 을 통해 동시성 처리를 하고 있기 때문에 findByProductId 와 같은 단순 조회 로직이더라도 SELECT가 아니라 락 쿼리(FOR UPDATE)로 실행되고 이는 트랜잭션 환경이 필수적이다.

public interface JpaStockRepository extends JpaRepository<Stock, UUID> {

    @Lock(LockModeType.PESSIMISTIC_WRITE)
    Optional<Stock> findByProductId(UUID productId);
}

현재 StockServiceImpl 메서드들은 트랜잭션이 걸려있지만, 테스트 코드에서는 StockServiceImpl 을 거치지 않고 테스트가 Repository를 직접 호출 했기 때문에 해당 호출 자체에는 트랜잭션이 없다.

Stock updatedStock = jpaStockRepository
                .findByProductId(product.getProductId())
                .orElseThrow();

        assertEquals(0, updatedStock.getQuantity());

해결 방안 검토

해결 방안 1 : Lock 없는 메서드로 읽기

✅ 새롭게 발견한 문제점 : 단순 조회 API 까지 Lock 조회가 되어 성능이 떨어진다.

@Override
@Transactional(readOnly = true)
public StockResult getStockByProductId(UUID productId) {

    Product product = getProductOrThrow(productId);

    Stock stock = getStockOrThrow(productId);

    return StockResult.from(stock, product.getName());
}

따라서 조회용으로 Lock 이 없는 메서드를 따로 분리하여 설계한다.

public interface JpaStockRepository extends JpaRepository<Stock, UUID> {

    Optional<Stock> findByProductId(UUID productId); // 일반 조회

    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("select s from Stock s where s.productId = :productId")
    Optional<Stock> findByProductIdForUpdate(@Param("productId") UUID productId);
}

결과

테스트 코드 정상적으로 통과!

[동시성 처리] DB Lock : Pessimistic Lock (비관적 락) - 실습

annovation — Wed, 18 Feb 2026 23:56:03 +0900

Pessimistic Lock (비관적 락)

Pessimistic Lock (비관적 락) 이란?

https://annovation.tistory.com/509

[동시성 처리] 동시성 문제 (Race Condition) 해결 방법 3가지 관점 (실습중..)

annovation.tistory.com

동시성 처리

동시성 처리 전 코드

StockServiceImpl

@Override
@Transactional
public StockResult decreaseStock(StockRequests.Decrease request) {

    Product product = getProductOrThrow(request.productId());

    Stock stock = getStockOrThrow(request.productId());

    stock.decreaseQuantity(request.quantity());

    return StockResult.from(stock, product.getName());
}

Stock

public void decreaseQuantity(int decreaseQuantity) {
    validateDecreaseQuantity(decreaseQuantity);

    if (this.quantity < decreaseQuantity) {
        throw new GlobalException(INSUFFICIENT_STOCK);
    }

    this.quantity -= decreaseQuantity;
}

JpaStockRepository

public interface JpaStockRepository extends JpaRepository<Stock, UUID> {

    Optional<Stock> findByProductId(UUID productId);
}

StockRepository

public interface StockRepository {

	Stock save(Stock stock);

	Optional<Stock> findByProductId(UUID productId);
}

StockRepositoryAdapter

@Repository
@RequiredArgsConstructor
public class StockRepositoryAdapter implements StockRepository {

	private final JpaStockRepository jpaStockRepository;

	@Override
	public Stock save(Stock stock) {
		return jpaStockRepository.save(stock);
	}

	@Override
	public Optional<Stock> findByProductId(UUID productId) {
		return jpaStockRepository.findByProductId(productId);
	}
}

동시성 처리 전 테스트 코드 결과

재고 100개에 대해 1개씩 100번 동시 차감했을 때 0이 되어야 하는데, 실제로는 88이 남아 동시성 제어가 제대로 되지 않아 일부 차감이 반영되지 않은 상태에서 발생한 AssertionFailedError가 발생했다.

동시성 처리 한 코드

JpaStockRepository

public interface JpaStockRepository extends JpaRepository<Stock, UUID> {

    Optional<Stock> findByProductId(UUID productId);

    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("select s from Stock s where s.productId = :productId")
    Optional<Stock> findByProductIdForUpdate(@Param("productId") UUID productId);
}

➡️ @Lock(PESSIMISTIC_WRITE)가 붙어서 실행 시점에 FOR UPDATE가 추가된다.

StockRepository

public interface StockRepository {

	Stock save(Stock stock);

	Optional<Stock> findByProductId(UUID productId);
	
	Optional<Stock> findByProductIdForUpdate(UUID productId);
}

StockRepositoryAdapter

@Repository
@RequiredArgsConstructor
public class StockRepositoryAdapter implements StockRepository {

	private final JpaStockRepository jpaStockRepository;

	@Override
	public Stock save(Stock stock) {
		return jpaStockRepository.save(stock);
	}

	@Override
	public Optional<Stock> findByProductId(UUID productId) {
		return jpaStockRepository.findByProductId(productId);
	}
	
	@Override
	public Optional<Stock> findByProductIdForUpdate(UUID productId) {
		return jpaStockRepository.findByProductIdForUpdate(productId);
	}
}

StockServiceImpl

private Stock getStockForUpdateOrThrow(UUID productId) {
    return stockRepository.findByProductIdForUpdate(productId)
            .orElseThrow(() -> new GlobalException(STOCK_NOT_FOUND));
}

➡️ Lock 조회 메서드 추가

동시성 처리 후 테스트 코드 결과

테스트가 성공적으로 통과되었다 !

[동시성 처리] Trouble Shooting : 멀티스레드 재고 감소 통합 테스트 코드 Eureka Server Connection refused

annovation — Mon, 16 Feb 2026 23:32:52 +0900

진행 환경

Java 17
Spring Boot 3.5.7
MySQL 8.0.44
Gradle

문제 상황

재고 감소 시 동시에 100개의 요청을 정확히 차감하는지 테스트 하는 코드에서 오류 발생

문제 증상

org.springframework.web.client.ResourceAccessException: I/O error on GET request for "http://localhost:8761/eureka/apps/": Connect to http://localhost:8761 failed: Connection refused

Eureka 서버(8761 포트)에 연결하려고 했는데 해당 포트에 서버가 떠 있지 않아서 거절당한 것

원인 분석

원인 1 : 테스트 실행 중 Config Client가 활성화되어 Eureka를 통해 Config Server를 찾으려 함

@SpringBootTest 가 전체 ApplicationContext를 다 올리고 있다.

✅ @SpringBootTest 동작 흐름

테스트 클래스에서 @SpringBootTest 발견
Spring Test Framework가 테스트 컨텍스트 생성
SpringApplication.run 을 통해 ApplicationContext 생성
Spring Boot auto-configuration + Test 환경 설정 적용
테스트 실행

✅ ApplicationContext 개념 및 역할

1) ApplicationContext 란? (공식 문서)

Spring Container
Bean 정의, 의존성 주입, 라이프사이클 관리 제공
환경, 프로퍼티, 메시지, 이벤트 처리 포함

It extends the BeanFactory interface, so it provides all the functionality of BeanFactory and more.

2) Context 란?

Context = 환경 + 설정 + Bean들의 집합
현재 애플리케이션이 동작하는 설정 환경 전체
즉, 현재 실행 중인 Spring 컨테이너의 전체 상태

A Spring ApplicationContext is essentially a container of beans.

해결 방안 검토

해결 방안 1 : 기존 Config Server 트러블슈팅 해결 방안을 적용

https://annovation.tistory.com/512

[동시성 처리] Trouble Shooting : 테스트 코드 Config Client 오류

문제 상황 문제 상황Stock 테스트 코드에서 yml 설정으로 config server 를 false 설정 했음에도 관련 오류로 인해 테스트 실행이 안되는 상황 발생 문제 코드 - StockServiceTest.java@ActiveProfiles("test")@Sp

annovation.tistory.com

해결 방법

해결 방법 : 해당 트러블슈팅으로 인해 기존에 작성해둔 application-test.yml 을 적용한다.

@ActiveProfiles("test")
@SpringBootTest
public class StockCurrencyTest {

...(생략)...

}

✅ @ActiveProfiles("test") 역할 (공식 문서)

테스트에서 사용할 프로필을 지정
지정된 프로필만 적용해서 context를 로딩
테스트 환경 분리/커스터마이징에 사용

✅ 여기서 말하는 프로필(profile) 이란?

서로 다른 환경(dev, test, prod)에 따라 다른 Bean을 등록하기 위한 기능 (공식 문서)

Bean definition profiles provide a way to register different beans for different environments.

✅ application-test.yml 을 사용하는데 프로필(profile) 개념이 연관되는 이유?

1) profile-specific

application-test.yml 과 같은 형식으로 설정값(Property)을 분리해 환경마다 다른 Bean 을 주입시킬 수 있다. (공식 문서)

You can specify profile-specific configuration files by using the application-{profile}.yml format.

2) Profile 은

어떤 Bean을 등록할지 결정하면서 동시에
어떤 yml 파일을 로드할지 결정한다.

yml은 설정값이고, profile은 Bean과 설정을 모두 제어하는 환경 스위치다.

참고 자료

1) Spring Docs : ActiveProfiles

https://docs.spring.io/spring-framework/reference/testing/annotations/integration-spring/annotation-activeprofiles.html

@ActiveProfiles :: Spring Framework

@ActiveProfiles is an annotation that can be applied to a test class to declare which bean definition profiles should be active when loading an ApplicationContext for an integration test.

docs.spring.io

[동시성 처리] synchronized vs Reentrant Lock - 실습

annovation — Sun, 15 Feb 2026 22:50:57 +0900

실습

synchronized

https://annovation.tistory.com/509

동시성 이슈 해결방법[2] - synchronized

synchronized로 동시성 이슈를 해결하지 못하는 이유와 @Transactional과의 충돌!

velog.io

Reentrant Lock

기본 사용법

private final ReentrantLock lock = new ReentrantLock();

public void method() {
    lock.lock();
    try {
        // 비즈니스 로직
    } finally {
        lock.unlock();
    }
}

HubEleven 프로젝트 적용 실습

@Service
@RequiredArgsConstructor
public class StockServiceImpl implements StockService {

    private final StockRepository stockRepository;
    private final ProductRepository productRepository;

    private final ReentrantLock lock = new ReentrantLock();

	... (생략) ...

    @Override
    @Transactional
    public StockResult decreaseStock(StockRequests.Decrease request) {

        lock.lock();
        try {
            Product product = getProductOrThrow(request.productId());

            Stock stock = getStockOrThrow(request.productId());

            stock.decreaseQuantity(request.quantity());

            return StockResult.from(stock, product.getName());
        } finally {
            lock.unlock();
        }
    }
}

✅ 한계 : MSA 와 같은 멀티 서버에서는 무용지물

멀티 서버 구성 예시

Server A → JVM A → Heap A → Object A(모니터 A)
Server B → JVM B → Heap B → Object B(모니터 B)

Server A에서 synchronized/ReentrantLock으로 임계영역을 막아도
Server B에서는 완전히 별개의 락이라 동시에 들어올 수 있음

참고 자료

1) Oracle Docs : ReentrantLock

https://docs.oracle.com/javase/17/docs/api/java.base/java/util/concurrent/locks/ReentrantLock.html

Overview (Java SE 17 & JDK 17)

This document is divided into two sections: Java SE The Java Platform, Standard Edition (Java SE) APIs define the core Java platform for general-purpose computing. These APIs are in modules whose names start with java. JDK The Java Development Kit (JDK) AP

docs.oracle.com

[동시성 처리] JVM Lock : synchronized VS Reentrant Lock (실습중..)

annovation — Sat, 14 Feb 2026 22:10:56 +0900

JVM 동시성 처리

synchronized

synchronized를 쓰면 동시에 여러 스레드가 접근하는 상황(Thread interference) 을 막는다.
메모리 일관성 문제(memory consistency) 도 예방한다.

Synchronized methods enable a simple strategy for preventing thread interference and memory consistency errors.

synchronized는 모니터 락(intrinsic lock) 을 사용하는 동기화 메커니즘이다.
한 객체에 대해 한 번에 한 스레드만 락을 획득할 수 있다.

Each object is associated with a monitor, which a thread can lock or unlock. Only one thread at a time may hold a lock on a monitor.

synchronized 메서드/블록은 이 모니터 락을 획득 → 코드 실행 → 자동 해제 한다.
JVM은 락을 자동으로 획득/해제한다(프로그램이 직접 unlock 호출 X)

Reentrant Lock

기본 동작은 synchronized와 같다(상호 배제).
그러나 기능이 더 많고 유연하다.

A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor lock accessed using synchronized methods and statements, but with extended capabilities.

2) 재진입성 (Reentrant)

같은 스레드가 같은 락을 여러 번 얻을 수 있다 → 재진입 가능(Reentrant)

A ReentrantLock is owned by the thread last successfully locking, but not yet unlocking it… The method will return immediately if the current thread already owns the lock.

예시

lock.lock();
methodA();
lock.unlock();

➡️ methodA 내부에서 또 lock.lock()을 호출 가능

3) 공정성 설정 (fair)

new ReentrantLock(true) → 오래 기다린 스레드 먼저!
반면 synchronized는 기본적으로 공정성 보장을 제공하지 않음

The constructor for this class accepts an optional fairness parameter. When set true, under contention, locks favor granting access to the longest-waiting thread.

4) Memory Sync

ReentrantLock 역시 JVM의 synchronized와 동일한 메모리 가시성 보장(happens-before) 을 제공한다.

All Lock implementations must enforce the same memory synchronization semantics as provided by the built-in monitor lock …

비교

synchronized

Reentrant Lock

참고 자료

1) 블로그 : [JAVA] synchronized VS Reentrant Lock (차이점)

https://velog.io/@may_yun/JAVA-synchronized-VS-Reentrant-Lock-차이점

[JAVA] synchronized VS Reentrant Lock (차이점)

상호 배제를 통한 동기화의 개념을 선행하고 보면 이해하는데 도움이 됩니다.현재 데이터를 사용하고 있는 해당 스레드를 제외하고 나머지 스레드들은 데이터에 접근 할 수 없도록 막는 개념Jav

velog.io

2) Oracle Docs : Synchronized

https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html

Synchronized Methods (The Java™ Tutorials > Essential Java Classes > Concurrency)

The Java Tutorials have been written for JDK 8. Examples and practices described in this page don't take advantage of improvements introduced in later releases and might use technology no longer available. See Dev.java for updated tutorials taking advantag

docs.oracle.com

3) Oracle Docs : ReentrantLock

https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/ReentrantLock.html

ReentrantLock (Java Platform SE 8 )

Acquires the lock only if it is not held by another thread at the time of invocation. Acquires the lock if it is not held by another thread and returns immediately with the value true, setting the lock hold count to one. Even when this lock has been set to

docs.oracle.com

4) 블로그 : 처음부터 다시 배우는 Java 동시성 제어

https://myvelop.tistory.com/262

처음부터 다시 배우는 Java 동시성 제어

이 글에서는 synchronized 키워드의 JVM 모니터 락이 실제로 어떻게 동작하는지 살펴보고, ReentrantLock이 제공하는 동시성 처리 기능을 알아본 뒤, 동시성 프로그래밍을 할 때 발생할 수 있는 생산자-

myvelop.tistory.com

[동시성 처리] Trouble Shooting : 테스트 코드 .env 환경 변수 적용

annovation — Fri, 13 Feb 2026 12:48:12 +0900

문제 상황

환경 변수(DB_USERNAME)가 정상적으로 치환되지 않아 실제 DB 계정이 아닌 ${DB_USERNAME} 문자열로 접속을 시도하면서 인증에 실패한 문제

문제 증상

org.hibernate.exception.GenericJDBCException: 
unable to obtain isolated JDBC connection 
[Access denied for user '${DB_USERNAME}'@'localhost' (using password: YES)]

원인 분석

원인 1 : 루트에 위치한 .env 환경 변수 값을 읽어오지 못하는 상황

본 프로젝트의 .env 파일은 루트 디렉터리(/Users/ann/Programming/Java Projects/hub-eleven/.env)에 위치하며, 루트는 settings.gradle 기준으로 정의한다.
해당 .env 파일의 DB_USERNAME 과 DB_PASSWORD 값을 읽어오지 못해 테스트용 로컬 MySQL 에 접속하지 못하는 에러 발생

해결 방안 검토

해결 방안 1 : .env 환경 변수란?

환경변수(Environment Variables)는 운영체제에서 제공하는 동적인 값으로, 애플리케이션이 실행되는 환경에 따라 설정 값을 다르게 적용할 수 있도록 도와준다. Spring Boot 프로젝트에서도 환경변수를 활용하면 코드 수정 없이 설정을 변경할 수 있어 유지보수성과 보안성이 향상된다. (출처)

해결 방안 2 : 왜 문제가 되었나요?

실행 방식별로 .env 주입 주체가 다르다 (IDE 실행 vs 테스트 실행)

앱 실행(Run) : IntelliJ의 EnvFile 플러그인, Docker compose, 쉘 스크립트 등이 .env를 읽어 환경변수로 넣어줌 (출처)
테스트(Test) : Gradle/Maven 테스트 JVM은 별도 프로세스라서 위 주입이 적용되지 않음 (특히 IntelliJ에서 Run 구성과 Test 구성이 따로일 때)

✅ 해결

IntelliJ라면 Run/Debug Configurations에서 “테스트 구성”에도 EnvFile(또는 Environment variables) 적용
Gradle 사용 시 test { environment "KEY","VALUE" }로 주입

해결 방법

해결 방법 : 테스트 프로필 설정에 .env를 명시적으로 import 하도록 설정

import: "optional:file:.env[.properties],optional:file:../.env[.properties]"

file:.env : 현재 실행 디렉터리 기준
file:../.env : 한 단계 상위(루트) 기준
[.properties] : .env를 KEY=VALUE 형식으로 파싱
optional: : 파일이 없어도 앱 시작 실패 방지(디버깅 시 제거 가능)

그 외 더 다양한 해결 방법들도 있다.

https://imdeepskyblue.tistory.com/66

SpringBoot 애플리케이션에 .env 통합하는 방법 세가지

안녕하세요. 저는 요즘에 합세랑 솦커톤, 과제로 인해서 프로젝트를 새로 세팅해야 하는 상황이 많았는데요!특히 환경 설정을 하면서 환경 변수를 분리하게 되는데 저는 분리하는 방법이 다양

imdeepskyblue.tistory.com

참고 자료

1) 블로그 : [Spring Boot] 프로젝트에서 환경변수 설정하는 방법

https://msj9965.tistory.com/5

[Spring Boot] 프로젝트에서 환경변수 설정하는 방법

1. 환경변수란?환경변수(Environment Variables)는 운영체제에서 제공하는 동적인 값으로, 애플리케이션이 실행되는 환경에 따라 설정 값을 다르게 적용할 수 있도록 도와준다. Spring Boot 프로젝트에서

msj9965.tistory.com

[DBeaver] Access denied for user 'root@localhost' (using password : YES)

annovation — Thu, 12 Feb 2026 09:48:28 +0900

문제 상황

allowPublicKeyRetrieval = true 설정 이후, Access denied for user 'root@localhost' (using password : YES) 에러 발생

원인 분석

원인 1 : 잘못된 Password 입력

dmg 파일과 충돌로 인해 HomeBrew MySQL 을 재설치 했더니 Password 오류가 난다.

해결 방법

해결 방법 : Password 변경

1) 실행중인 MySQL 종료

mysql.server stop

brew services start mysql 로 서버를 켰다면 아래 명령어 입력

brew services stop mysql

2) Password 없이 MySQL에 접속하기 위해 아래 명령어 입력

mysqld_safe --skip-grant-tables

3) root 유저로 MySQL 접속

mysql -u root

새 터미널을 켜서 입력해야 들어가진다.

4) mysql DB 사용하도록 설정

use mysql;

5) 권한 초기화

FLUSH PRIVILEGES;

6) 비밀번호 변경

ALTER USER 'root'@'localhost' IDENTIFIED BY '새로운비밀번호';

cf. 각 명령어는 반드시 세미콜론(;)으로 끝내야 하며, '새로운비밀번호' 부분에는 변경할 비밀번호를 입력하면 된다.

7) 다시 권한 초기화

FLUSH PRIVILEGES;

8) 다음 exit 명령어를 통해 나갔다가 다시 접속하면 문제 없이 초기화 되어있는 것을 확인 할 수 있다.

exit;

9) 새 비밀번호로 접속 테스트

mysql -u root -p

10) 터미널 종료

pkill mysqld
pkill mysqld_safe

이걸 해줘야 'mysqld_safe --skip-grant-tables' 로 켜놨던 터미널이 종료된다.

11) MySQL 서버 재실행

brew services start mysql

드디어

됐다..

참고 자료

1) 블로그 : 맥 환경에서 MySQL 비밀번호 재설정하기 (ver 9.0)

https://yermxx.tistory.com/70

맥 환경에서 MySQL 비밀번호 재설정하기 (ver 9.0)

비밀번호 까먹으면 손이 고생하더라.. 비슷한 문제를 겪고 계신 분들에게 도움이 되길 바란다. 참고로 맥 환경 + MySQL 9.0 버전에서 시도했다. MySQL 서버 재시작하기 - 먼저 MySQL 서버를 중

yermxx.tistory.com

2) 블로그 : Mac Mysql root계정 비밀번호 분실 해결하기

https://dev-woody.tistory.com/75

Mac Mysql root계정 비밀번호 분실 해결하기

brew unistall mysql을 통해서 Mysql을 지우고 다시 깔았지만, 비밀번호는 그대로 남아있어서 사용이 불가능했었다. 우선 실행중인 상태의 Mysql 서버를 종료시켜준다. mysql.server stop 다음 비밀번호 없이

dev-woody.tistory.com

[DBeaver] Public Key Retrieval is not allowed

annovation — Wed, 11 Feb 2026 09:00:52 +0900

문제 상황

DBeaver 에서 MySQL 연결 시도 중 Public Key Retrieval is not allowed 에러 발생

원인 분석

원인 1 : MySQL 8.0 이상 보안 정책

보안상의 이유로 MySQL 8.0 이상 부터 기본적으로 MySQL 서버는 클라이언트가 요청하는 공개키에 대해 허용하지 않도록 지원하기 떄문이라고 한다.

해결 방법

해결 방법 : Driver properties -> allowPublicKeyRetrieval -> true로 변경

참고 자료

1) 블로그 : DBeaver(디비버) Public Key Retrieval is not allowed 에러

https://computer-science-student.tistory.com/719

DBeaver(디비버) Public Key Retrieval is not allowed 에러

DBeaver(디비버) Public Key Retrieval is not allowed 에러 디비버에서 MySQL 데이터베이스 접속을 잘하다가 갑자기 Public Key Retrieval is not allowed 에러를 만났다. MySQL의 8.x 버전 이후부터 발생하는 문제라고 한

computer-science-student.tistory.com

2) 블로그 : Public Key Retrieval is not allowed 오류 해결하기

https://wookku.tistory.com/272

[DBeaver] Public Key Retrieval is not allowed 오류 해결하기

안녕하세요. 어느덧 여름이 지나고 이제는 제법 쌀쌀한 날씨가 되어가고 있습니다.낮에는 그럼에도 덥고, 아침과 저녁에는 추운 날씨네요. 저는 살짝 콧물을 훌쩍이며 글을 적고 있습니다.모두

wookku.tistory.com

3) MySQL Docs

https://dev.mysql.com/doc/connector-j/en/connector-j-connp-props-security.html

MySQL :: MySQL Connector/J Developer Guide :: 6.3.5 Security

MySQL Connector/J Developer Guide / ... / Connector/J Reference / Configuration Properties / Security paranoid Take measures to prevent exposure sensitive information in error messages and clear data structures holding sensitive data when p

dev.mysql.com

[터미널 명령어] HomeBrew 명령어

annovation — Tue, 10 Feb 2026 16:04:00 +0900

1) brew 로 설치한 프로그램 리스트

brew ls

2) MySQL 서버 켜져있는지 확인

brew services list | grep mysql

3) MySQL 자동 실행 (재부팅 시 자동으로 다시 켜짐)

brew services start mysql

Mac 부팅할 때 자동으로 켜지고
터미널을 닫아도 안 꺼지고
로그아웃해도 계속 살아있고
명시적으로 끄기 전까지 계속 실행되는 상태 유지

4) MySQL 직접 끄기

brew services stop mysql

5) MySQL 지금만 켜기 (재부팅 시 다시 안켜짐)

mysql.server start

5-1) 서버 실행 중인지 확인

pgrep -fl mysqld

➡️

3741 /.../opt/homebrew/.../mysqld_safe ...
3852 /opt/homebrew/.../mysqld ...

5-2) 직접 끄기

mysql.server stop

[MSA] Spring Cloud Config Client 동작 구조 (with Spring Docs)

annovation — Mon, 9 Feb 2026 23:22:47 +0900

구조

Config Client와 Config Server 연동

1) Config Client는 Spring Boot 앱이 Config Server와 통신하는 역할

Spring Boot 애플리케이션이 Config Client를 포함하면
→ Config Server에 HTTP로 접근해서 설정 데이터를 받아온다.
받아온 설정 데이터는 Spring Environment에 반영된다.

“A Spring Boot application can take immediate advantage of the Spring Config Server (or other external property sources)… and initializes Spring Environment with remote property sources. (출처)

➡️ 즉, Config Client는 원격 중앙 설정 저장소(Config Server) 에서 설정을 가져와 Spring 애플리케이션의 기존 설정 환경에 “로딩”하는 구조

2) Config Server 설정 방법

Config Server 데이터를 가져오려면 아래와 같은 설정이 기본 형태

spring.config.import=optional:configserver:

➡️ 이 설정이 있으면 Config Server를 기본적으로 http://localhost:8888로 연결 시도
→ Optional prefix를 제거하면, 서버 연결 실패 시 바로 예외를 발생시킨다.

3) 레거시 방식인 bootstrap 기반 연결도 지원

이 경우 Config Server 주소를 bootstrap.yml에 설정하고 Config Client가 시작하면서 바로 서버와 연결된다.

핵심 구조 요약

Spring Boot App
    │ (spring.cloud.config on classpath)
    ▼
Config Client 자동 구성
    │
    │ 1. spring.config.import 또는 bootstrap 설정으로 Config Server 위치 확인
    ▼
Config Server (HTTP endpoint, default localhost:8888)
    │
    │ 2. Remote config file(e.g., git repo)에서 설정 읽기
    ▼
Config Client
    │
    │ 3. Spring Environment에 remote properties merge
    ▼
ApplicationContext 완성

참고 자료

https://docs.spring.io/spring-cloud-config/reference/client.html?utm_source

Spring Cloud Config Client :: Spring Cloud Config

Retry works with the Spring Boot spring.config.import statement and the normal properties work. However, if the import statement is in a profile, such as application-prod.properties, then you need a different way to configure retry. Configuration needs to

docs.spring.io

[MySQL] MySQL 8.0.45-arm 64 켜졌다 꺼졌다 반복 on MacOs

annovation — Sat, 7 Feb 2026 22:41:12 +0900

문제 상황

맥 8.0.45-arm 64 환경에서 MySQL 서버가 켜졌다 꺼졌다를 반복하는 오류 발생

문제 증상

OFF

원인 분석

원인 1 : HomeBrew 로 설치한 MySQL 과 Community Server 에서 설치한 dmg 버전 충돌

1) bash : HomeBrew 에 MySQL 설치되어있는지 확인

which mysql
mysql --version
brew list | grep mysql

➡️

/opt/homebrew/bin/mysql
mysql  Ver 9.0.1 for macos15.1 on arm64 (Homebrew)
mysql

MySQL 클라이언트는 Homebrew 버전(9.0.1)을 쓰고 있다는 의미

2) bash : MySQL 서버가 동작 중인지 확인

ps aux | grep mysqld

➡️ 버전 2개

/usr/local/mysql/bin/mysqld ... --datadir=/usr/local/mysql/data ...
/opt/homebrew/opt/mysql/bin/mysqld ... --datadir=/opt/homebrew/var/mysql ...

공식 dmg(installer)로 설치된 MySQL 서버와 Homebrew로 설치된 MySQL 서버가 동시에 동작 중임을 알 수 있다.

분석 : 같은 포트(기본 3306)을 동시에 사용하려고 함

지금 어떤 MySQL 서버를 켰는지/어떤 클라이언트를 실행했는지 / 어떤 소켓·포트를 보고 있는지가 섞이기 때문

해결 방안 검토

해결 방안 1 : dmg 버전 제거, HomeBrew 만 사용

1) 우선 충돌 멈추기위해 dmg 버전과 HomeBrew 버전 정지

launchctl bootout gui/$(id -u)/homebrew.mxcl.mysql 2>/dev/null
launchctl disable gui/$(id -u)/homebrew.mxcl.mysql 2>/dev/null
pkill -9 mysqld_safe
pkill -9 mysqld

bootout → launchd에서 MySQL 자동 실행 언로드
disable → 재부팅해도 다시 안 올라오게 차단
그 다음 pkill → 이제 감시자가 없으니 진짜로 종료

➡️ 꺼졌다 켜졌다를 반복하기 때문에 PID (Process ID, 현재 실행중인 프로그램에 붙는 고유 번호) 를 알 수 없기 때문에 강제로 종료시킨다.

2) 제거 되었는지 확인

pkill -9 mysqld
pgrep -fl mysqld || echo "mysqld 없음"
mysqld 없음

3) dmg MySQL 완전 제거

sudo /usr/local/mysql/bin/mysql.server stop

sudo rm -rf /usr/local/mysql
sudo rm -rf /usr/local/mysql-*

sudo rm -rf /Library/StartupItems/MySQLCOM

sudo rm -rf /Library/PreferencePanes/MySQL.prefPane

sudo rm -rf /Library/LaunchDaemons/com.oracle.oss.mysql.mysqld.plist

sudo rm -rf /var/db/receipts/com.mysql.*

코드 의미는 차례대로 :
- DMG(MySQL.pkg) 버전 서비스 중지
- DMG 버전 본체 디렉토리 삭제
- 아주 옛날 DMG 버전에서 쓰던 부팅 자동 실행 스크립트 삭제
- 시스템 설정에 보이는 MySQL 설정 패널 제거
- Oracle DMG MySQL 자동 실행 launchd 데몬
- macOS의 설치 기록을 지우는 명령

➡️ 비밀번호는 mac 로그인 password

4) dmg 버전 삭제되었는지 확인

ls -d /usr/local/mysql*

➡️ 아무것도 안나오면 삭제된 것

sudo launchctl list | grep -i oracle || echo "oracle mysql 데몬 없음"

5) Homebrew 서비스로 실행

brew services start mysql

6) 상태 확인

brew services list
mysqladmin ping

➡️ 실행이 안될 경우

error: 'Can't connect to local MySQL server through socket '/tmp/mysql.sock' (2)'

에러 메세지

ls -ld /opt/homebrew/var/mysql || mkdir -p /opt/homebrew/var/mysql

데이터 디렉토리 존재 확인

/opt/homebrew/opt/mysql/bin/mysqld_safe \
  --datadir=/opt/homebrew/var/mysql \
  --socket=/tmp/mysql.sock &

에러가 /tmp/mysql.sock 없다고 했으니, 서버 실행 (socket을 /tmp/mysql.sock로 고정)

/opt/homebrew/opt/mysql/bin/mysqladmin --socket=/tmp/mysql.sock ping

살아있는지 확인 (socket 지정)
mysqld is alive 나오면 성공

/opt/homebrew/opt/mysql/bin/mysql --socket=/tmp/mysql.sock -u root

접속

tail -n 200 /opt/homebrew/var/mysql/*.err

안켜지면 에러 로그 보기

해결 방법

해결 방법 : HomeBrew MySQL 재설치 ^_^

https://juzdalua.tistory.com/127

MySQL) M1 macbook MySQL 완전 삭제

mysql을 설치했다 지웠는데 재설치 후 에러가 난다면, 기존에 삭제되지 않은 설정 값 때문일 수 있다. # mysql 강제종료 ps -ef | grep mysql kill -9 [mysql PID] # 삭제 brew services stop mysql brew uninstall mysql # 파

juzdalua.tistory.com

[동시성 처리] Trouble Shooting : 테스트 코드 Config Client 오류

annovation — Fri, 6 Feb 2026 22:55:29 +0900

문제 상황

Stock 테스트 코드에서 yml 설정으로 config server 를 false 설정 했음에도 관련 오류로 인해 테스트 실행이 안되는 상황 발생

문제 코드

- StockServiceTest.java

@ActiveProfiles("test")
@SpringBootTest
class StockServiceImplTest {

    ...
    
}

- application-test.yml

spring:
  cloud:
    config:
      enabled: false
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/hubeleven_test?useSSL=false&serverTimezone=Asia/Seoul&characterEncoding=UTF-8
    username: 비밀
    password: 비밀
  jpa:
    hibernate:
      ddl-auto: create-drop
    properties:
      hibernate:
        format_sql: true
    show-sql: true

문제 증상

ConfigClientFailFastException: Could not locate PropertySource and the resource is not optional
ResourceAccessException: I/O error on GET request for "http://localhost:8888/...": Connection refused

원인 분석

원인 1 : Config Server 연결 시도

Spring Boot 2.4+ / Spring Cloud 조합에서 spring.config.import=configserver: 가 (application.yml 등 다른 파일에) 있으면, application-local.yml이 다 로드되기 전에 configserver import를 먼저 처리하려고 시도한다.

원인 2 : application-test.yml .env 환경 변수 읽어오기 실패

  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/hubeleven_test?allowPublicKeyRetrieval=true&useSSL=false&serverTimezone=Asia/Seoul&characterEncoding=UTF-8
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}

테스트 yml 에서 ${DB_USERNAME} 과 ${DB_PASSWORD} 을 불러오지 못한다.

해결 방안 검토

해결 방안 1 : main/resources/application.yml

아래의 test/resources/application-test.yml 에 config server 를 불러오지 않도록 설정된 값이 작동할 수 있게 main yml 파일을 수정해야한다.

spring:
  cloud:
    config:
      enabled: false

아래와 같이 import 에 optional: 을 설정해줘야 test yml 에서 config server false 가 제대로 동작한다.

spring:
  application:
    name: product-service
  config:
    import: "optional:configserver:"
  cloud:
    config:
      discovery:
        enabled: true
        service-id: config

➡️ optional: 은 Config Server 에서 설정을 못 가져와도 애플리케이션을 중단시키지 않고 계속 기동하게 만드는 방식 (출처)

➡️ spring.config.import: 에 지정된 경로/서비스가 발견되면, Spring Boot 초기화 과정에서 추가적인 설정 데이터로 로딩되고 그 설정은 기존 설정보다 우선순위가 높게 적용된다. (출처)

해결 방안 2 : 일단 루트에 있는 .env 파일을 못읽어와서 테스트용 username 과 password 는 변수처리 하지 않고 명시적으로 작성

spring:
  cloud:
    config:
      enabled: false
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/hubeleven_test?allowPublicKeyRetrieval=true&useSSL=false&serverTimezone=Asia/Seoul&characterEncoding=UTF-8
    username: test
    password: test

테스트 yml 파일에서 루트에 있는 .env 파일 읽어오는 방법을 따로 찾아봐야할 것 같다.

해결 방법

해결 방법 : 근데 결국 ${DB_USERNAME}, ${DB_PASSWORD} 얘네가 문제였다.

처음에 optional 도 붙여서 실행했는데도 테스트 코드 오류 났었는데, 이걸 해결하니까 다 잘 작동 된다..

참고 자료

1) Spring Docs

https://docs.spring.io/spring-cloud-config/reference/client.html

Spring Cloud Config Client :: Spring Cloud Config

docs.spring.io

[동시성 처리] Java 에서 발생하는 동시성 문제란?

annovation — Wed, 4 Feb 2026 22:04:10 +0900

Java 동시성 문제 (Race Condition, 레이스 컨디션)

Java 동시성 문제란?

Java에서 여러 스레드가 같은 데이터(필드/객체 상태) 를 공유하며 실행될 때, 올바른 제어 없이 접근하면 오류가 생긴다.
이렇게 여러 스레드가 공유 메모리(객체, 필드, 배열 등)에 접근할 때 명확한 동기화 규칙이 없어서, 값이 다르게 보이거나 실행 순서가 뒤틀리는 현상을 뜻한다.

동시성 문제가 발생하는 이유

1) Thread interference (스레드 간 간섭)

여러 스레드가 같은 데이터에 접근/수정하면서 연산이 서로 끼어들어 결과가 깨지는 문제 (전형적인 race condition의 형태)
Java의 모든 객체의 필드, static 변수, 배열 요소는 힙 메모리에 존재하는데, 이 영역은 여러 스레드가 동시에 읽고, 쓸수 있기 때문에 접근 순서를 규정하지 않으면 문제가 발생한다. (§17.4.1 Shared Variables)

2) Memory consistency errors (메모리 일관성 오류)

한 스레드가 쓴 값이 다른 스레드에서 제때 보이지 않거나(stale), 실행 순서가 기대와 다르게 관찰되는 문제(가시성/순서 문제)
(§17.4 Memory Model, §17.4-A/B 예제)

멀티스레드로 처리할 때 레이스 컨디션이 일어나는 이유

예상 작업 순서

Thread-1	Stock	Thread-2
select *from stockwhere id = 1	{id: 1, quantity: 5}
update set quantity = 4from stockwhere id = 1	{id: 1, quantity: 4}
	{id: 1, quantity: 4}	select *from stockwhere id = 1
	{id: 1, quantity: 3}	update set quantity = 3from stockwhere id = 1

Thread-1 이 데이터를 가져가 update 한 값을 Thread-2 가 가져간 이후 update 하는 것을 예상

실제 작업 순서

Thread-1	Stock	Thread-2
select *from stockwhere id = 1	{id: 1, quantity: 5}
	{id: 1, quantity: 5}	select *from stockwhere id = 1
update set quantity = 4from stockwhere id = 1	{id: 1, quantity: 4}
	{id: 1, quantity: 4}	update set quantity = 4from stockwhere id = 1

하지만, 실제로는 Thread-1 이 데이터를 가져가 update 하기 전에 Thread-2 가 값을 읽고 각각 update 를 수행하면서 한 쪽 변경이 덮어써지는 Lost Update 가 발생한다.

출처

1) Oracle Docs : Synchronization

https://docs.oracle.com/javase/tutorial/essential/concurrency/sync.html

Synchronization (The Java™ Tutorials > Essential Java Classes > Concurrency)

docs.oracle.com

2) Oracle Docs : Chapter 17. Threads and Locks

https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html

Chapter 17. Threads and Locks

class A { final int x; A() { x = 1; } int f() { return d(this,this); } int d(A a1, A a2) { int i = a1.x; g(a1); int j = a2.x; return j - i; } static void g(A a) { // uses reflection to change a.x to 2 } } In the d method, the compiler is allowed to reorder

docs.oracle.com

3) 블로그 : 재고시스템으로 알아보는 동시성 이슈 해결방법 1

https://velog.io/@kdmin0706/Java-Spring

[Java & Spring] 재고시스템으로 알아보는 동시성이슈 해결방법(1)

인프런 "재고시스템으로 알아보는 동시성이슈 해결방법" 강의를 듣고 작성한 글입니다. 동시성 문제란!? 동일한 데이터에 2개 이상의 스레드 혹은, 세션에서 가변 데이터를 동시에 제어할 때 나

velog.io

4) 블로그 : [재고시스템으로 알아보는 동시성 이슈 해결방법] #2 재고감소 로직 작성 및 테스트

https://dev-rosiepoise.tistory.com/129

[재고시스템으로 알아보는 동시성 이슈 해결방법] #2 재고감소 로직 작성 및 테스트

들어가기 전 ..1. 이전 게시글과 이어지는 게시글이므로 프로젝트 환경 및 세팅은 아래 링크에서 확인해주세요!2. 전체 코드는 아래의 Git에서 확인 가능합니다!참고하면 좋을 이전 글 [재고시스

dev-rosiepoise.tistory.com

[동시성 처리] 재고 감소 통합 테스트 코드 7 - 멀티 스레드

annovation — Tue, 3 Feb 2026 23:27:14 +0900

멀티 스레드 테스트 코드

진행 환경

Java 17
Spring Boot 3.5.7
MySQL 8.0.44
Gradle

StockCurrencyTest.java

@SpringBootTest
public class StockCurrencyTest {

    @Autowired
    private StockServiceImpl stockServiceImpl;

    @Autowired
    private StockRepository stockRepository;

    @Autowired
    private JpaStockRepository jpaStockRepository;

    @Autowired
    private JpaProductRepository jpaProductRepository;

    private Product product;

    @BeforeEach
    void setUp() {
        product = ProductFixture.createDefault();
        jpaProductRepository.saveAndFlush(product);

        Stock stock = StockFixture.createFromProductWithQuantity(product, 100);
        jpaStockRepository.saveAndFlush(stock);
    }

    @AfterEach
    void tearDown() {
        jpaStockRepository.deleteAll();
        jpaProductRepository.deleteAll();
    }

    @Test
    @DisplayName("재고 감소 - 100개 동시 요청 시 정확히 차감")
    void decreaseStock_when100ConcurrentRequests_thenSuccess() throws InterruptedException {

        // given
        int threadCount = 100;

        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);

        CountDownLatch countDownLatch = new CountDownLatch(threadCount);

		// when
        for (int i = 0; i < threadCount; i++) {
            executorService.submit(() -> {

                try {
                    stockServiceImpl.decreaseStock(
                            StockFixture.decreaseRequest(product, 1)
                    );
                } finally {
                    countDownLatch.countDown();
                }
            });
        }

        countDownLatch.await();

		// then
        Stock updatedStock = stockRepository
                .findByProductId(product.getProductId())
                .orElseThrow();

        assertEquals(0, updatedStock.getQuantity());
    }
}

재고가 100개인 상품에 대해 100개의 스레드가 동시에 재고 1개씩 감소 요청 → 최종 재고가 0이 되는지 검증

코드 흐름

given, when, then

1) given : 테스트 준비

int threadCount = 100;
ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
CountDownLatch countDownLatch = new CountDownLatch(threadCount);

threadCount = 100 → 동시에 실행할 작업(요청) 수
ExecutorService → 100개의 스레드를 동시에 실행하기 위한 스레드 풀
- Java에서 멀티스레딩을 쉽게 관리하기 위한 인터페이스
- new Thread()를 여러 개 생성하는 대신 미리 만들어진 스레드 풀에서 스레드를 재사용
- execute(), submit() 등의 메서드를 사용해 비동기 작업 실행 가능 (출처)

CountDownLatch(100) → 모든 스레드가 작업을 끝낼 때까지 기다리기 위한 장치
- 각 스레드가 끝날 때마다 countDown()
- latch.await()이 호출되면 요청이 모두 끝날 때까지 대기 후 다음 코드 실행 (출처)
- 메인 스레드는 await()로 대기

2) when : 동시 요청 실행

for (int i = 0; i < threadCount; i++) {
    executorService.submit(() -> {
        try {
            stockServiceImpl.decreaseStock(
                    StockFixture.decreaseRequest(product, 1)
            );
        } finally {
            countDownLatch.countDown();
        }
    });
}

100번 반복 → 100개의 작업 제출
- 즉, 100명이 동시에 같은 상품 재고를 1개씩 감소시키는 상황

각 작업은 :
- decreaseStock(product, 1) 호출
  - 같은 상품
  - 재고 1개 감소
- finally에서 countDownLatch.countDown()
  - 예외가 나도 반드시 호출되게 보장

3) 모든 스레드 종료 대기

countDownLatch.await();

메인 테스트 스레드가 여기서 멈춤
100개의 재고 감소 요청이 모두 끝날 때까지 대기
이 줄이 없으면 → 아직 작업이 끝나기 전에 결과를 조회해버릴 수 있음

4) then : 결과 검증

Stock updatedStock = jpaStockRepository
        .findByProductId(product.getProductId())
        .orElseThrow();

assertEquals(0, updatedStock.getQuantity());

DB에서 최신 재고 조회
최종 재고 수량이 0인지 확인

[Java] 변수(Variables) 헷갈리는 문법 정리

annovation — Sun, 1 Feb 2026 23:24:29 +0900

변수의 값

변수에 값을 대입하는 것은 변수에 들어있는 값을 복사해서 대입하는 것이다.

기본형

int a = 10;
int b = a;

a = 20; // a 값 변경

이때 b는 그대로 10이 나온다.

public static void main(String[] args) {
	int a = 10;
	changePrimitive(a);

	static void changePrimitive(int x) {
				x = 20;
				
		}
	
}

a = 10, x에 int 값 10이 복사되어 넘어가므로 x = 10
changePrimitive에서 x = 20으로 바뀌므로 최종 결과는 a = 10, x = 20

참조형

Data dataA = new Data();
dataA.value = 10;
Data dataB = dataA;

dataA의 값을 바꾸나, dataB의 값을 바꾸나, 참조하고 있는 메모리 주소값이 같기 때문에 dataA.value와 dataB.value의 값은 언제나 같다.

변수 초기화

멤버 변수 : 자동 초기화

인스턴스의 멤버 변수는 인스턴스를 생성할 때 자동으로 초기화된다.
int = 0, boolean = false, 참조형 = null
개발자가 초기값을 직접 지정할 수 있다.

지역 변수 : 수동 초기화

지역 변수는 항상 직접 초기화해야 한다.

Java의 변수 타입 기본형(Primitive Type) vs 참조형 (Reference Type)

기본형 (Primitive Type)

int, long, double, boolean 같이 변수에 직접 값을 넣을 수 있는 데이터 타입

참조형 (Reference Type)

객체와 배열같이 데이터에 접근하기 위해 참조 주소를 변수에 저장하는 데이터 타입

형변환 (Type Casting)

같은 타입끼리 계산은 값을 타입 반환 ex. int + int = int, double + double = double
서로 다른 타입의 계산은 큰 범위로 자동 형변환 ex. int + double = double + double

출처

https://www.inflearn.com/course/%EA%B9%80%EC%98%81%ED%95%9C%EC%9D%98-%EC%9E%90%EB%B0%94-%EC%9E%85%EB%AC%B8/dashboard?cid=332505

[지금 무료]김영한의 자바 입문 - 코드로 시작하는 자바 첫걸음| 김영한 - 인프런 강의

현재 평점 5.0점 수강생 54,098명인 강의를 만나보세요. 프로그래밍에 처음 입문하는 분들을 위한 자바 강의입니다. 코드를 따라하면서 손쉽게 자바를 배울 수 있습니다. 자바(Java) 프로그래밍 언

www.inflearn.com

[동시성 처리] 재고 감소 통합 테스트 코드 6 - test DB

annovation — Sat, 31 Jan 2026 17:10:53 +0900

테스트 코드를 위한 DB 연결

MySQL 보다 가벼운 H2 DB 를 사용해도 되지만, 실제 서비스 환경에서는 MySQL 을 사용하기 때문에 테스트의 신뢰성을 높이기 위해 MySQL DB 를 연결하기로 했다.
Docker 로 테스트용 MySQL 을 팀원 공용으로 사용하면 DB 버전이나 설정 차이 없이 동일한 환경에서 테스트 가능하지만, 동시에 테스트를 진행하게될 경우 간섭을 받을 수 있어 우선 로컬에서 MySQL 을 생성하여 테스트하기로 했다.

테스트 코드를 위한 MySQL 생성

Local MySQL 생성

1) MySQL 과 DBeaver 연결

설치 방법

https://codingapple.com/unit/sql-mysql-dbeaver-install/

MySQL & DBeaver 설치하려면 (맥 / 윈도우)

1:08 윈도우에 MySQL 설치는 3:09 맥북에 MySQL 설치는 5:11 DBeaver 설치 & 데이터베이스 연결 DBMS가 뭐냐면 Database Management System 의 약자인데 데이터베이스 조작을 쉽게 도와주는 프로그램입니다. DBMS를

codingapple.com

새 데이터 베이스 연결

MySQL 설치시 설정했던 Username 과 Password 입력

2) 테스트용 MySQL DB 생성

① SQL문으로 직접 생성

CREATE DATABASE IF NOT EXISTS hubEleven_test

② DBeaver 툴을 사용하여 생성

- 1. 연결된 MySQL localhost 오른쪽 클릭 → Create New Database

- 2. Database 이름 설정 후 OK

3) 새로 생성한 로컬 MySQL 프로젝트 설정

yml 설정

spring:
  cloud:
    config:
      enabled: false
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/hubEleven_test?useSSL=false&serverTimezone=Asia/Seoul&characterEncoding=UTF-8
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
  jpa:
    hibernate:
      ddl-auto: create-drop
    properties:
      hibernate:
        format_sql: true
    show-sql: true

1) spring.cloud.config.enabled: false

운영 환경에서는 Config Server를 사용하지만, 로컬 테스트 환경에서는 외부 인프라 의존성을 제거하기 위해 Config Client를 비활성화

2) spring.datasource.*

driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/hubEleven_test
username: ${DB_USERNAME}
password: ${DB_PASSWORD}

① 테스트 전용 DB 사용

hubEleven_test를 사용해서 운영 DB와 물리적으로 분리
실수로 데이터 삭제/변경되는 사고 방지

② 환경변수로 계정 정보 관리

계정/비밀번호를 yml에 직접 쓰지 않음
보안 + 환경별 설정 분리

프로젝트 연결

1) intelliJ 오른쪽 DB 메뉴에서 MySQL DB 연결

2) DBeaver 에서 생성한 test DB 연결해주면 끄읏!

개선되어야 할 점

현재 Docker로 띄우는 MySQL 포트 localhost:3306 과 테스트용 로컬 MySQL localhost:3306 가 같기 때문에 두 서버를 동시에 띄울 수 없다는 한계가 존재한다.
이 경우 Docker MySQL 포트를 다른 서버에 포워딩하는 방식이 해결 방법 중 하나가 될 수 있을 것 같다.

docker run --name mark-board-mysql -e MYSQL_ROOT_PASSWORD=root -p 3307:3306 -d mysql:8.0.38

참고 자료

1) 코딩 애플 : MySQL & DBeaver 설치하려면 (맥 / 윈도우)https://codingapple.com/unit/sql-mysql-dbeaver-install/

MySQL & DBeaver 설치하려면 (맥 / 윈도우)

codingapple.com

2) Docker MySQL 포트 충돌 문제 해결

https://hwangjoonyoung.com/posts/docker-mysql-port/

Docker MySQL 포트 충돌 문제 해결 - Blog

도커 환경을 구성하면서 마주친 문제

hwangjoonyoung.com

[동시성 처리] 재고 감소 통합 테스트 코드 5 - 단일 스레드

annovation — Fri, 30 Jan 2026 17:27:11 +0900

단일 스레드 환경 리팩토링 with TestFixture

Test Fixture 도입 전 단일 스레드 테스트 코드

1) @BeforeEach

@BeforeEach
    public void setUp() {

        // 테스트용 고정 ID 생성 (각 테스트마다 새로 생성)
        testProductId = UUID.randomUUID(); // TODO : Test Fixture
        testCompanyId = UUID.randomUUID();
        testHubId = UUID.randomUUID();

        Stock stock = Stock.create(testProductId, testCompanyId, testHubId, 100);
        jpaStockRepository.saveAndFlush(stock);
    }

2) decreaseStock_success

    @Test
    @DisplayName("재고 감소 - 단일 요청 성공")
    void decreaseStock_success() {

        // given
        int decreaseAmount = 10;

        StockRequests.Decrease request = new StockRequests.Decrease(testProductId, decreaseAmount);

        // when
        StockResult result = stockServiceImpl.decreaseStock(request);

        // then - 반환값 검증
        assertThat(result.productId()).isEqualTo(testProductId);
        assertThat(result.productId()).isEqualTo(testCompanyId);
        assertThat(result.productId()).isEqualTo(testHubId);
        assertThat(result.quantity()).isEqualTo(90L);

        // then - 실제 DB 재고 검증
        Stock updatedStock =
                jpaStockRepository
                        .findByProductId(testProductId)
                        .orElseThrow(() -> new AssertionError("재고가 존재해야 합니다"));

        assertThat(updatedStock.getQuantity()).isEqualTo(90L);
    }

Test Fixture 도입 후 단일 스레드 테스트 코드

1) @BeforeEach

@BeforeEach
    public void setUp() {

        product = ProductFixture.createDefault();
        jpaProductRepository.saveAndFlush(product);

        Stock stock = StockFixture.createFromProductWithQuantity(product, 100);
        jpaStockRepository.saveAndFlush(stock);
    }

Fixture 로 책임 이동

2) decreaseStock_success

@Test
    @DisplayName("재고 감소 - 단일 요청 성공")
    void decreaseStock_success() {

        // given
        int decreaseAmount = 10;

        StockRequests.Decrease request = StockFixture.decreaseRequest(
                product, decreaseAmount);

        // when
        StockResult result = stockServiceImpl.decreaseStock(request);

        // then - 반환값 검증
        assertThat(result.productId()).isEqualTo(product.getProductId());
        assertThat(result.companyId()).isEqualTo(product.getCompanyId());
        assertThat(result.hubId()).isEqualTo(product.getHubId());
        assertThat(result.quantity()).isEqualTo(90);
    }

ProductFixture.java

test/java/com.hubeleven.product/stock/application/fixtures/ProductFixture.java

public class ProductFixture {

    // ===== ID =====

    public static final UUID COMPANY_ID = UUID.randomUUID();

    public static final UUID HUB_ID = UUID.randomUUID();

    // ===== Factory Methods =====

    public static Product createDefault() {
        return Product.create(
                "Default Product",
                COMPANY_ID,
                HUB_ID
        );
    }
    
    private ProductFixture() {
    }
}

Stock 이 생성되려면 Product 가 먼저 만들어져야하기 때문에 ProductFixture 도 만들어줘야한다.

StockFixture.java

test/java/com.hubeleven.product/stock/application/fixtures/StockFixture.java

public class StockFixture {

    // ===== Factory Methods =====

    public static Stock createFromProductWithQuantity(Product product, int quantity) {
        return Stock.create(
                product.getProductId(),
                product.getCompanyId(),
                product.getHubId(),
                quantity
        );
    }

    public static StockRequests.Decrease decreaseRequest(Product product, int quantity) {
        return new StockRequests.Decrease(
                product.getProductId(),
                quantity
        );
    }

    private StockFixture() {
    }
}

우선 현재 테스트에서 바뀌는 필드는 quantity 하나이기 때문에, Builder 패턴은 도입하지 않았다.

[동시성 처리] 재고 감소 통합 테스트 코드 4 - 단일 스레드

annovation — Thu, 29 Jan 2026 23:51:28 +0900

단일 스레드 환경 with Test Fixture

test/java/com.hubeleven.product/stock/application/fixtures/StockFixture.java

Stock 도메인 테스트용 StockFixture 클래스 생성

// fixtures/StockFixture.java
public class StockFixture {

    // ===== Factory Methods =====

    public static Stock createDefault() {
        return Stock.create(PRODUCT_ID, COMPANY_ID, HUB_ID, 100);
    }

    public static Stock createWithQuantity(int quantity) {
        return Stock.create(PRODUCT_ID, COMPANY_ID, HUB_ID, quantity);
    }

    public static Stock lowStock() {
        return createWithQuantity(5);
    }

    public static Stock outOfStock() {
        return createWithQuantity(0);
    }

    // ===== Builder =====

    public static Builder builder() {
        return new Builder();
    }

    public static class Builder {
        private UUID productId = PRODUCT_ID;
        private UUID companyId = COMPANY_ID;
        private UUID hubId = HUB_ID;
        private int quantity = 100;

        public Builder productId(UUID productId) {
            this.productId = productId;
            return this;
        }

        public Builder companyId(UUID companyId) {
            this.companyId = companyId;
            return this;
        }

        public Builder hubId(UUID hubId) {
            this.hubId = hubId;
            return this;
        }

        public Builder quantity(int quantity) {
            this.quantity = quantity;
            return this;
        }

        public Stock build() {
            return Stock.create(productId, companyId, hubId, quantity);
        }
    }

    private StockFixture() {}
}

Factory Methods

// ===== Factory Methods =====

    public static Stock createDefault() {
        return Stock.create(PRODUCT_ID, COMPANY_ID, HUB_ID, 100);
    }

    public static Stock createWithQuantity(int quantity) {
        return Stock.create(PRODUCT_ID, COMPANY_ID, HUB_ID, quantity);
    }

    public static Stock lowStock() {
        return createWithQuantity(5);
    }

    public static Stock outOfStock() {
        return createWithQuantity(0);
    }

✅ 테스트가 무엇을 검증하는지 명확히 드러나는 Factory 메서드 구현

Builder

// ===== Builder =====

    public static Builder builder() {
        return new Builder();
    }

    public static class Builder {
        private UUID productId = PRODUCT_ID;
        private UUID companyId = COMPANY_ID;
        private UUID hubId = HUB_ID;
        private int quantity = 100;

        public Builder productId(UUID productId) {
            this.productId = productId;
            return this;
        }

        public Builder companyId(UUID companyId) {
            this.companyId = companyId;
            return this;
        }

        public Builder hubId(UUID hubId) {
            this.hubId = hubId;
            return this;
        }

        public Builder quantity(int quantity) {
            this.quantity = quantity;
            return this;
        }

        public Stock build() {
            return Stock.create(productId, companyId, hubId, quantity);
        }
    }

✅ 필요한 값으로 바꿔서 사용 가능한 Builder 패턴 구현

인스턴스 생성 차단

private StockFixture() {}

StockFixture 클래스는 객체를 생성하기 위한 클래스가 아니기 때문에 new StockFixture() 는 의미가 없다.
Java 에서는 생성자를 만들지 않으면 기본 생성자가 자동으로 만들어지지만, StockFixutre 는 인스턴스가 아무 역할도 하지 않기 때문에 쓸모 없는 객체 생성으로 인해 잘못된 사용 가능성이 있다.
이를 위해 private 으로 인스턴스 생성을 차단한다.

[Spring] 객체 지향 설계와 스프링

annovation — Tue, 27 Jan 2026 22:26:55 +0900

객체 지향 설계와 Spring 연관성

Spring 애기에 왜 객체 지향 이야기가 나오는가?

Spring 은 아래 기술로 객체 지향의 특징인 다형성과 OCP, DIP 를 가능하게 지원한다.

DI (Dependency Dependency) : 의존 관계, 의존성 주입
DI 컨테이너 제공
- Java 객체들을 어떤 컨테이너 안에 넣어 놓고 이 안에서 의존 관계를 서로 연결해주고 주입해주는 기능
- 위와 같은 기술을 활용하면, 클라이언트 코드 변경 없이 기능 확장 가능
- 쉽게 부품을 교체하듯이 개발 가능

Spring이 없던 시절..

어떤 개발자가 좋은 객체 지향 개발을 하려고 OCP, DIP 원칙을 지키며 개발을 해보니, 만들어야할 것들이 너무 많아서 배보다 배꼽이 큰 상황이 되어버렸다.
그래서 OCP, DIP 원칙들을 프레임워크로 만들어버렸다..!
순수한 Java 로 OCP, DIP 원칙들을 지키면서 개발을 해보면, 결국 Spring Framework 와 같은 기능을 만들게 된다. (더 장확히는 DI 컨테이너)

정리

모든 설계에 역할(인터페이스)과 구현(구현체)을 분리해야 한다.
애플리케이션 설계도 공연을 설계하듯 배역만 만들어두고 배우는 언제든지 유연하게 교체하고 변경할 수 있도록 만드는 것이 좋은 객체 지향 설계이다.
이것을 가능하게 하려면, 다형성 뿐만 아니라 OCP, DIP 원칙을 모두 준수해야 한다.
다형성, OCP, DIP 를 가능하게 하려면 중간 역할이 필요한데, 그게 바로 Spring Container 이다.

이상적으로는 모든 설계에 인터페이스를 부여하는 것이 좋다.

이상적으로는 모든 설계에 인터페이스를 부여하는 것이 좋다.
장점 : 인터페이스를 먼저 작성 후 하부 구현 기술들에 대한 선택을 미룰 수 있다. → 변경 범위가 작아 유연
ex. 어떤 DB를 사용하지 미정일 때 (RDB, NoSQL, 관계형 DB 등), 인터페이스만 정의 해놓고 우선 다른 부분을 개발 가능하다.
ex. 할인 정책을 개발해야 하는데 아직 구체적으로 정채지지 않았을 때, 할인 정책에 대한 인터페이스를 만들고 간단한 구현체만 작성해놓고 개발 가능하다. (0원 할인 처럼)

실무론적 고민

이상적으로는 인터페이스를 도입하는 것이 좋지만, 무분별한 도입은 '추상화'라는 비용이 발생한다.
추상화가 되면, 개발자가 코드를 한번 더 열어봐야 하는 상황이 발생한다.
추상화가 됨으로써 장점도 있지만, 발생하는 단점을 넘어설 때 선택을 해야한다.
따라서 추천하는 방법은, 기능을 확장할 가능성이 없다면, 구체 클래스를 직접 사용하고, 향후 꼭 필요할 때 리팩토링해서 인터페이스를 도입하는 것

출처

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard

스프링 핵심 원리 - 기본편| 김영한 - 인프런 강의

현재 평점 5.0점 수강생 49,149명인 강의를 만나보세요. 스프링 입문자가 예제를 만들어가면서 스프링의 핵심 원리를 이해하고, 스프링 기본기를 확실히 다질 수 있습니다. 스프링 기본 기능, 스프

www.inflearn.com

[Spring] 좋은 객체 지향 설계의 5가지 원칙 (SOLID)

annovation — Mon, 26 Jan 2026 23:45:25 +0900

SOLID

SOLID 란?

'클린코드' 저자 로버트 마틴(Robert Martin)이 정의한 좋은 객체 지향 설계의 5가지 원칙

SRP : 단일 책임 원칙(Single Responsibility Principle)
OCP : 개방 폐쇄 원칙(Open Closed Principle)
LSP : 리스코프 치환 원칙(Liskov substitution Principle)
ISP : 인터페이스 분리 원칙(Interface Segregation Principle)
DIP : 의존관계 역전 원칙(Dependency Inversion Principle)

SRP

SRP (Single Responsibility Principle, 단일 책임 원칙)

하나의 클래스는 하나의 책임만 가져야 한다.
- 여기서의 책임은 문맥과 상황에 따라 다르다.
SRP 원칙을 잘 지키며 설계하는 중요한 기준은 변경이다.
- 변경이 있을 때 파급이 적으면 SRP 원칙을 잘 지킨 것
  ex. UI 하나 변경 할 때, SQL 코드부터 애플리케이션 코드 전부 고쳐야 한다면 잘못된 설계
변경이 있을 때 하나의 클래스나 하나의 지점만 고치면 SRP를 잘 따르는 설계라고 볼 수 있다.

OCP (가장 중요한 원칙)

OCP (Open/Closed Principle, 개방 폐쇄 원칙)

소프트웨어 요소는 확장에는 열려 있으나 변경에는 닫혀 있어야 한다.
다형성을 활용하여 인터페이스를 구현한 새로운 클래스를 만들어 새로운 기능을 구현하면 OCP 원칙으로 설계 가능
단, 다형성을 활용해도 코드 수정이 필요해 OCP 원칙이 지켜지지 않는 경우가 생길 수 있다.

다형성을 활용했지만, OCP 원칙이 지켜지지 않는 경우

첫 번째 코드 (MemoryMemberRepository 사용)

public class MemberService {

    private MemberRepository memberRepository = new MemoryMemberRepository();

}

두 번째 코드 (JdbcMemberRepository로 변경한 버전)

public class MemberService {

    // private MemberRepository memberRepository = new MemoryMemberRepository();
    private MemberRepository memberRepository = new JdbcMemberRepository();

}

➡️ 같은 타입(MemberRepository)으로 서로 다른 구현체를 만들 수 있는 '다형성'의 개념을 활용하고 있지만, 구현 객체를 변경하려면 클라이언트 코드(MemberService)를 변경해야 하므로 OCP 원칙은 지켜지지 않고 있다.

➡️ 이를 해결하기 위해서는, 객체를 생성하고 연관관계를 맺어주는 별도의 중간 역할이 필요한데, 이 역할을 바로 Spring이 지원해주는 것이다!

Spring Container 가 해주는 역할
따라서, 이렇게 OCP 원칙을 지키기 위해 DI와 IoC 컨테이너가 필요하다 (다음 강의에서 코드로 직접 실습해봐야 이해되는 부분)

LSP

LSP (Liskov Substitution Principle, 리스코프 치환 원칙)

서브 타입은 언제나 상위 타입으로 교체할 수 있어야한다. 즉, 서브 타입은 상위 타입이 약속한 규약을 지켜야함을 강조
프로그램의 객체는 프로그램의 정확성을 깨뜨리지 않으면서 하위 타입의 인스턴스로 바꿀 수 있어야 한다.
다형성을 지원하기 위한 원칙으로, 하위 클래스는 인터페이스 규약을 전부 지켜야 한다는 원칙이다.
ex. 자동차 인터페이스의 엑셀은 앞으로 가는 기능인데, 뒤로 가도록 구현하면 LSP 위반
인터페이스를 구현한 구현체를 믿고 사용하려면, 이 원칙이 필요하다.
단순히 컴파일에 성공하는 것을 넘어서는 이야기다. 즉, 코드가 문법적으로 맞는지(컴파일)보다, 의미적으로 약속을 지켰는지가 중요한 원칙이다.

ISP

ISP (Interface Segregation Principle, 인터페이스 분리 원칙)

클라이언트 입장에서 인터페이스를 분리해야함을 강조
특정 클라이언트를 위한 인터페이스 여러 개가, 범용 인터페이스 하나보다 낫다.
ex. 자동차 인터페이스 → 운전 인터페이스, 정비 인터페이스로 분리
ex. 사용자 클라이언트 → 운전자 클라이언트, 정비사 클라이언트로 분리
특정 인터페이스 자체가 변해도 다른 클라이언트에 영향을 주지 않는다.
ex. 정비 인터페이스 변경이 운전자 클라이언트에 영향을 주지 않음
인터페이스가 명확해지고, 대체 가능성이 높아진다.

DIP (중요한 원칙)

DIP (Dependency Inversion Principle, 의존관계 역전 원칙)

어떤 Class 를 참조해야하는 상황이 생기면, 그 Class 를 직접 참조하는 것이 아닌 대상의 상위 요소(추상 클래스 or 인터페이스)로 참조하라는 원칙 (출처)
상위 수준의 모듈은 하위 수준의 모듈에 의존해서는 안 되며, 모두 추상화에 의존해야 함을 강조 (출처)
추상화(인터페이스)에 의존하고 구체화(구현 클래스)에 의존하지 말 것
클라이언트가 인터페이스에 의존하여 구현체를 유연하게 변경할 수 있게된다. 구현체에 의존하면 변경이 어려워진다.

DIP 위반 예시

public class MemberService {

    private MemberRepository memberRepository = new MemoryMemberRepository();

}

MemberService(상위 요소)가 MemoryMemberRepository(하위 요소)를 직접 의존(참조)하고 있으므로 DIP 위반
구현체(MemoryMemberRepository) 변경 시 MemberSerivce의 코드 수정이 필요하기 때문 (다음 강의에 이어서 어떻게 해결할지에 대한 방법 안내)

정리

객체 지향의 핵심은 다형성
하지만 다형성만으로는 구현 객체를 변경할 때 클라이언트 코드도 함께 변경된다.
다형성만으로 OCP 와 DIP 같은 원칙을 준수하여 설계할 수 없다.

참고하면 좋은 자료

1) 블로그 - SOLID

https://inpa.tistory.com/entry/OOP-%F0%9F%92%A0-%EA%B0%9D%EC%B2%B4-%EC%A7%80%ED%96%A5-%EC%84%A4%EA%B3%84%EC%9D%98-5%EA%B0%80%EC%A7%80-%EC%9B%90%EC%B9%99-SOLID

객체 지향 설계의 5가지 원칙 - S.O.L.I.D

객체 지향 설계의 5원칙 S.O.L.I.D 모든 코드에서 LSP를 지키기에는 어려움. 리스코프 치환 원칙에 따르면 자식 클래스의 인스턴스가 부모 클래스의 인스턴스를 대신하더라도 의도에 맞게 작동되어

inpa.tistory.com

2) 매일메일 - SOLID

https://www.maeil-mail.kr/question/110

매일메일 - 기술 면접 질문 구독 서비스

기술 면접 질문을 매일매일 메일로 보내드릴게요!

www.maeil-mail.kr

3) 매일메일 - 객체 지향 프로그래밍

https://www.maeil-mail.kr/question/258

매일메일 - 기술 면접 질문 구독 서비스

기술 면접 질문을 매일매일 메일로 보내드릴게요!

www.maeil-mail.kr

출처

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard

스프링 핵심 원리 - 기본편| 김영한 - 인프런 강의

현재 평점 5.0점 수강생 49,140명인 강의를 만나보세요. 스프링 입문자가 예제를 만들어가면서 스프링의 핵심 원리를 이해하고, 스프링 기본기를 확실히 다질 수 있습니다. 스프링 기본 기능, 스프

www.inflearn.com

[Spring] 좋은 객체 지향 프로그래밍이란?

annovation — Fri, 23 Jan 2026 23:14:59 +0900

객체 지향 프로그래밍

객체 지향 프로그래밍 이란?^[각주:1]

컴퓨터 프로그램을 명령어의 목록으로 보는 시각에서 벗어나 여러 개의 독립된 단위
즉, “객체”들의 모임으로 파악하고자 하는 것이다.
각각의 객체는 메시지를 주고받고, 데이터를 처리할 수 있다. (협력)
객체 지향 프로그래밍은 프로그램을 유연하고 변경이 용이하게 만들기 때문에 대규모 소프트웨어 개발에 많이 사용된다.

유연하고 변경이 용이?

레고 블럭 조립 하듯 컴포넌트를 쉽고 유연하게 변경하며 개발할 수 있는 방법

객체 지향 특징 4가지

추상화 (Abstraction)
캡슐화 (Encapsulation)
상속 (Inheritance)
다형성 (Polymorphism) : 객체 지향의 핵심

다형성 (Polymorphism)

비유

1) 운전자 - 자동차

운전자는 운전면허증만 있으면 자동차가 K3 에서 아반떼로 바뀌어도 운전이 가능하다.
운전자(클라이언트)를 위해 자동차 역할(인터페이스)을 통해 새로운 자동차 기능을 제공할 수 있다.

2) 공연 무대 (로미오와 줄리엣 공연)

줄리엣(서버)의 배우(구현)이 바뀐다고 해서 로미오(클라이언트)에 영향을 주지 않는다.

✅ 결론

두 예시 모두 유연하고 변경이 용이한 예시를 보여준다.
즉, 다른 대상으로 대체 가능하다는 것을 뜻한다.

역할과 구현을 분리

위 예시처럼 역할과 구현으로 구분하면 단순하면서 유연해지고 변경이 편리해진다.

구현체를 무한하게 확장할 수 있는 설계가 가능하다.
따라서 인터페이스를 안정적으로 잘 설계하는 것이 매우 중요하다.

✅ 장점

클라이언트는 대상의 역할(인터페이스)만 알면 된다.
클라이언트는 구현 대상의 내부 구조를 몰라도 된다.
클라이언트는 구현 대상의 내부 구조가 변경되어도 영향을 받지 않는다.
클라이언트는 구현 대상 자체를 변경해도 영향을 받지 않는다.

Java에서의 다형성 (Polymorphism)

Java에서의 다형성 활용

역할과 구현을 분리
- 역할 = 인터페이스
- 구현 = 인터페이스를 구현한 클래스, 구현 객체
객체를 설계할 때 역할과 구현을 명확히 분리
객체 설계시 역할(인터페이스)을 먼저 부여하고, 그 역할을 수행하는 구현 객체 만들기

객체의 협력이라는 관계부터 생각

수 많은 객체 클라이언트와 객체 서버는 서로 협력 관계를 가진다.
- 클라이언트 = 요청하는 사람
- 서버 = 클라이언트의 요청을 받아 응답하는 사람
혼자 있는 객체는 없다.

Java에서의 활용 예시

Overriding

다형성으로 인터페이스를 구현한 객체를 실행 시점에 유연하게 변경할 수 있다.
- 즉, 클라이언트는 코드의 인터페이스 타입만 알고 있고, 실제로 어떤 구현 클래스 객체를 쓸지는 프로그램 실행 중에 변경 가능
클래스와 상속 관계에서도 다형성, 오버라이딩 적용 가능

다형성의 본질

인터페이스를 구현한 객체 인스턴스를 실행 시점에 유연하게 변경할 수 있다.
다형성의 본질을 이해하려면 협력이라는 객체 사이의 관계에서 시작해야한다.
즉, 클라이언트와 서버의 협력 관계 클라이언트를 변경하지 않고, 서버의 구현 기능을 유연하게 변경할 수 있다는 것이 다형성의 본질이다.

다형성의 한계

역할(인터페이스) 자체가 변하면 클라이언트, 서버 모두 큰 변경이 발생한다.
ex. 자동차 역할을 비행기 역할로 변경해야 한다면? 연극에서 대본 자체가 변경되어야 한다면?
따라서 가장 변화가 없는 방식으로 인터페이스를 안정적으로 설계하는 것이 가장 중요하다.

Spring과 객체 지향

그래서 객체 지향의 특징인 '다형성'과 Spring 이 도대체 무슨 연관인거지?
Spring은 객체 지향의 '다형성' 특징을 가장 극대화해서 사용할 수 있도록 도와주는 프레임워크이다.
ex. DI (의존성 주입), IoC (제어의 역전)
Spring을 사용하면 레고 블럭 조립하듯, 공연 무대의 배우를 선택하듯 구현을 편리하게 변경할 수 있다.

출처

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8

스프링 핵심 원리 - 기본편| 김영한 - 인프런 강의

현재 평점 5.0점 수강생 49,145명인 강의를 만나보세요. 스프링 입문자가 예제를 만들어가면서 스프링의 핵심 원리를 이해하고, 스프링 기본기를 확실히 다질 수 있습니다. 스프링 기본 기능, 스프

www.inflearn.com

주석 출처

https://ko.wikipedia.org/wiki/객체_지향_프로그래밍 [본문으로]

[Spring] Spring 이란?

annovation — Thu, 22 Jan 2026 23:41:39 +0900

Spring

출처 : https://www.edureka.co/blog/videos/building-web-application-using-spring-framework/

Spring 이란?

Spring 은 특정한 하나가 아니라 아래 나열된 여러가지 기술들의 모음이라고 볼 수 있다.

필수

Spring Framework : Spring 의 가장 핵심

출처 : https://spring.io/projects

Spring Boot : Spring Framework 를 편리하게 사용할 수 있게 해주는 프레임워크

출처 : https://spring.io/projects

선택

Spring Data
- 데이터베이스 CRUD 를 편리하게 사용할 수 있도록 도와주는 기술
- 주로 Spring Data JPA 를 많이 사용
Spring Session
- 세셔 기능을 편리하게 사용할 수 있도록 도와주는 기능
- ex. 세션 만료 시간 통합 관리, 세션 무효화, 사용자별 동시 로그인 제어, Spring Security 와 연동
Spring Security
- Spring Framework 로 만든 애플리케이션을 보호하기 위한 보안 프레임워크
- 로그인, 회원관리, 권한 설정, 해킹 방지 등의 보안 기능을 개발자가 직접 만들고 관리할 필요 없음
Spring Rest Docs
- 테스트를 통해 검증된 REST API 만 문서로 생성해주는 도구
- 코드와 문서의 불일치 방지
Spring Batch
- 대용량 데이터를 한 번에 묶어서(batch) 처리하기 위한 배치 처리 프레임워크
- 정해진 시간, 조건에 따라 많은 데이터를 안정적으로 처리해줌
Spring Cloud
- MSA 환경에서 필요한 공통 인프라 관리 도구

Spring 단어

Spring 은 문맥에 따라 다양하게 해석될 수 있다.
좁게는 Spring 의 핵심 기술인 Spring DI Container 기술을 뜻한다.
Spring Framework 자체를 의미하기도 한다.
Spring Boot, Spring Framework 등을 모두 포함한 스프링 생태계로 사용되기도 한다.

Spring Framework

Spring Framework 구성

핵심 기술
- Spring DI 컨테이너
- AOP
- 이벤트
- 기타
Web 기술
- Spring MVC
- Spring WebFlux
데이터 접근 기술
- DB 트랜잭션
- JDBC
- ORM 지원
- XML 지원
기술 통합
- 캐시
- 이메일
- 원격 접근
- 스케줄링
테스트
- Spring 기반 테스트 지원
언어
- Kotlin
- Groovy

Spring Boot

Spring Boot 란?

Spring Boot 는 Spring Framework 를 편리하게 사용할 수 있도록 지원해주는 프레임워크이다.
최근에는 프로젝트에서 Spring Boot 를 기본으로 사용한다.

특징

Tomcat 같은 웹 서버를 내장해서 별도의 웹 서버를 설치하지 않아도 됨
- 단독으로 실행할 수 있는 Spring 애플리케이션을 쉽게 생성
- Tomcat 설치나 서버 설정 따로 필요 없음
손쉬운 빌드 구성을 위한 starter 종속성 제공
- ex. 웹 API 를 만들고 싶을 때,
  implementation 'org.springframework.boot:spring-boot-starter-web'
  을 통해서 해당 기능을 쓰려면 필요한 라이브러리들을 가져와준다.

Spring 과 3rd party (외부) 라이브러리 자동 구성
- ex. MySQL 을 사용하려고 하면,
  implementation 'mysql:mysql-connector-j'
  라이브러리를 추가하고,
  spring:
    datasource:
      url: jdbc:mysql://localhost:3306/test
      username: root
      password: 1234
  yml 설정 파일을 작성하면 Spring 이 자동으로 연동해준다.
메트릭, 상태 확인, 외부 구성 같은 프로덕션 준비 기능 제공
- implementation 'spring-boot-starter-actuator'
  을 통해 운영할 때 꼭 필요한 기능들을 기본으로 제공
- ex. 서버가 살아있는지, 메모리를 얼마나 쓰는지, DB 연결 상태는 어떤지 등
관례에 의한 간결한 설정
- 대부분의 사람들이 이렇게 쓸 거라 가정하고 기본값을 정해줌

Spring은 왜 만들었나요?

Spring 의 핵심 개념을 이해하면 기술을 이해하기 쉬워지기 때문에 Spring 이 만들어진 이유에 대해 알아보자
이 기술은 왜 만들었는지? 핵심 컨셉은 무엇인지?

Spring 핵심 개념

Java 언어 기반의 프레임워크
Java 언어의 가장 큰 특징은 객체 지향 언어
Spring 은 객체 지향 언어가 가진 강력한 특징을 살려내는 프레임워크
Spring 은 좋은 객체 지향 애플리케이션을 개발할 수 있게 도와주는 프레임워크

그래서 그게 뭔데?

Spring 이전에는 EJB 라는 기술이 있었지만, 굉장히 의존적이고 복잡하고 어려운 단점이 있었다.
이렇게 의존적일 경우, EJB에 종속되어 EJB 스탕이로만 개발해야하기 때문에 객체 지향이 가진 좋은 장점들을 잃게 된다.
이러한 단점을 극복하고 객체 지향 본래의 특성을 활용하기 위해 순수한 Java 로 돌아가기 위한 POJO 개념이 등장하기도 했다.
이러한 POJO 기반 개발을 실제로 가능하게 만들기 위해 Spring은 객체 생성과 의존성 관리를 컨테이너가 담당하는 IoC와 DI 개념을 도입하였다.

결론

Spring 이 제대로 된 객체지향 프로그래밍을 할 수 있게 도와주는 도구라는 것

어렵네

좋은 객체 지향 프로그램이란 뭘까를 이해해야 Spring Framework 를 제대로 이해할 수 있다.
이것이 모든 것의 출발점 !
Spring 의 본질을 알면 객체 지향 프로그래밍에 얼마나 최적화 되어있는지 이해할 수 있다.

출처

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B8%B0%EB%B3%B8%ED%8E%B8/dashboard

스프링 핵심 원리 - 기본편| 김영한 - 인프런 강의

현재 평점 5.0점 수강생 49,133명인 강의를 만나보세요. 스프링 입문자가 예제를 만들어가면서 스프링의 핵심 원리를 이해하고, 스프링 기본기를 확실히 다질 수 있습니다. 스프링 기본 기능, 스프

www.inflearn.com

[리팩토링] 권한 별 기능 제한 로직 구현 (3) (업데이트 중..)

annovation — Fri, 16 Jan 2026 17:51:28 +0900

Controller

@PreAuthorize

@PreAuthorize("hasRole('MASTER')")
@PutMapping("/users/{userId}")
public void update(
        @PathVariable Long userId,
        @AuthenticationPrincipal CustomUserDetails user
) {
}

userRole 역할 별로 필터링 하기

@AuthenticationPrincipal

@GetMapping("/profile")
public ResponseEntity<?> profile(
        @AuthenticationPrincipal CustomUserDetails userDetails
) {
    profileService.getProfile(userDetails.getUserId());
    return ResponseEntity.ok().build();
}

user 정보 받아오기

[리팩토링] 공통 모듈 수정으로 인한 리팩토링

annovation — Thu, 15 Jan 2026 18:14:10 +0900

공통 모듈 repo 위치 변경

build.gradle 변경

repositories

repositories {
    mavenCentral()
    maven { url 'https://jitpack.io' }
}

implementation

implementation 'com.github.ElevenHub:HubEleven-common:v0.0.1'

변경 사유

기존 common (공통 모듈) 이 팀장님 개인 repo 위치에 있어, 팀원 모두 공통 모듈 변경 가능하도록 팀 organization repo로 변경

응답값 변경

기존 코드

@Operation(summary = "주문 생성 API", description = "새로운 주문을 생성한다.")
    @PostMapping
    public ResponseEntity<ApiResponse<OrderResponse>> create(
            @Valid @RequestBody OrderRequests.Create request) {

        OrderResult result = orderService.create(request);

        return ApiResponseEntity.success(OrderResponse.from(result));
    }

return ApiResponseEntity.success(OrderResponse.from(result));

변경 코드

@Operation(summary = "주문 생성 API", description = "새로운 주문을 생성한다.")
    @PostMapping
    public ResponseEntity<ApiResponse<OrderResponse>> create(
            @Valid @RequestBody OrderRequests.Create request) {

        OrderResult result = orderService.create(request);

        return ResponseEntity.status(HttpStatus.CREATED)
                .body(ApiResponse.success(OrderResponse.from(result)));
    }

return ResponseEntity.status(HttpStatus.CREATED).body(ApiResponse.success(OrderResponse.from(result)));

변경 사유

ErrorCode

기존 코드

public enum OrderErrorCode implements StatusCode {
    // Company
    REQUESTOR_COMPANY_NOT_FOUND(HttpStatus.NOT_FOUND, "업체를 찾을 수 없습니다."),
    RECIPIENT_COMPANY_NOT_FOUND(HttpStatus.NOT_FOUND, "업체를 찾을 수 없습니다."),

    // Product
    PRODUCT_NOT_FOUND(HttpStatus.NOT_FOUND, "상품을 찾을 수 없습니다."),

    // Stock
    STOCK_RESTORE_FAILED(HttpStatus.BAD_REQUEST, "재고 복구에 실패했습니다."),
    STOCK_INSUFFICIENT(HttpStatus.BAD_REQUEST, "재고가 부족합니다."),

    // Order
    ORDER_NOT_FOUND(HttpStatus.NOT_FOUND, "주문을 찾을 수 없습니다."),

    // Authorization
    MASTER_ONLY(HttpStatus.FORBIDDEN, "MASTER 권한이 있어야 수행할 수 있습니다."),
    HUB_MANAGER_ONLY(HttpStatus.FORBIDDEN, "HUB_MANAGER 권한이 있어야 수행할 수 있습니다."),
    DELIVERY_MANAGER_ONLY(HttpStatus.FORBIDDEN, "DELIVERY_MANAGER 권한이 있어야 수행할 수 있습니다."),
    COMPANY_MANAGER_ONLY(HttpStatus.FORBIDDEN, "COMPANY_MANAGER 권한이 있어야 수행할 수 있습니다.");

    private final HttpStatus httpStatus;
    private final String message;

    @Override
    public String getName() {
        return name();
    }
}

변경 코드

@Getter
@RequiredArgsConstructor
public enum OrderErrorCode implements ErrorCode {
    // Company
    REQUESTOR_COMPANY_NOT_FOUND(HttpStatus.NOT_FOUND, "업체를 찾을 수 없습니다."),
    RECIPIENT_COMPANY_NOT_FOUND(HttpStatus.NOT_FOUND, "업체를 찾을 수 없습니다."),

    // Product
    PRODUCT_NOT_FOUND(HttpStatus.NOT_FOUND, "상품을 찾을 수 없습니다."),

    // Stock
    STOCK_RESTORE_FAILED(HttpStatus.BAD_REQUEST, "재고 복구에 실패했습니다."),
    STOCK_INSUFFICIENT(HttpStatus.BAD_REQUEST, "재고가 부족합니다."),

    // Order
    ORDER_NOT_FOUND(HttpStatus.NOT_FOUND, "주문을 찾을 수 없습니다."),

    // Authorization
    MASTER_ONLY(HttpStatus.FORBIDDEN, "MASTER 권한이 있어야 수행할 수 있습니다."),
    HUB_MANAGER_ONLY(HttpStatus.FORBIDDEN, "HUB_MANAGER 권한이 있어야 수행할 수 있습니다."),
    DELIVERY_MANAGER_ONLY(HttpStatus.FORBIDDEN, "DELIVERY_MANAGER 권한이 있어야 수행할 수 있습니다."),
    COMPANY_MANAGER_ONLY(HttpStatus.FORBIDDEN, "COMPANY_MANAGER 권한이 있어야 수행할 수 있습니다.");

    private final HttpStatus httpStatus;
    private final String message;
}

implements 를 ErrorCode 로 변경
기존 StatusCode 의 Override 메서드 삭제

변경 사유

[BAEKJOON / Java] 25494. 단순한 문제 (Small) (업데이트 중..)

annovation — Tue, 13 Jan 2026 23:52:03 +0900

Question

https://www.acmicpc.net/problem/25494

Algorithm

Code

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    private void solution() throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();
        while (t-->0) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            int c = Integer.parseInt(st.nextToken());
            int cnt = 0;
            for (int i = 1; i <= a; i++) {
                for (int j = 1; j <= b; j++) {
                    for (int k = 1; k <= c; k++) {
                        if (i%j==j%k && j%k==k%i && i%j==k%i) {
                            cnt++;
                        }
                    }
                }
            }
            sb.append(cnt).append('\n');
        }
        System.out.println(sb);
    }

    public static void main(String[] args) throws Exception {
        new Main().solution();
    }
}

시간 복잡도

코딩 테스트 유형

annovation — Mon, 12 Jan 2026 23:50:38 +0900

참고 자료

https://littlemobs.com/blog/coding-test-algorithms-top-down-overview/

코딩 테스트 준비 전 모르면 큰일나는 알고리즘 문제 유형 파악 및 꿀팁 정리 - LittleMobs

코딩 테스트를 준비할 시간이 부족하거나, 어디서부터 공부를 시작해야 할지 막막한가? 일단 무작정 알고리즘 문제풀이 사이트에 접속하여 문제를 풀고 있지만 잘하고 있는 것이 맞는지 의문이

littlemobs.com

[리팩토링] 권한 별 기능 제한 로직 구현 (2)

annovation — Thu, 8 Jan 2026 21:56:59 +0900

Controller → Service

Controller 에서 User 정보 받아오기

@Operation(summary = "주문 전체 조회 API", description = "주문 전체 목록을 조회한다.")
    @GetMapping
    public ResponseEntity<ApiResponse<CommonPageResponse<OrderResponse>>> getOrders(
            CommonPageRequest request,
            @RequestHeader("X-User-Id") Long userId,
            @RequestHeader("X-User-Role") String userRole
    ) {

Header에서 받아온 userId 와 userRole 을 활용해 권한 관리 로직을 구현한다.

User Role 을 통해 Controller 에서 1차 검증

User ID 를 통해 Service 에서 2차 검증

AuthorizationValidator

AuthorizationValidator 클래스로 User Role 검증 로직 분리

package com.hubEleven.order.application.validator;

import com.commonLib.common.exception.GlobalException;
import com.hubEleven.order.domain.exception.OrderErrorCode;
import org.springframework.stereotype.Component;

@Component
public class AuthorizationValidator {

    public void validateMaster(String userRole) {
        if (!"MASTER".equalsIgnoreCase(userRole)) {
            throw new GlobalException(OrderErrorCode.MASTER_ONLY);
        }
    }

    public void validateHubManager(String userRole) {
        if (!"HUB_MANAGER".equalsIgnoreCase(userRole)) {
            throw new GlobalException(OrderErrorCode.HUB_MANAGER_ONLY);
        }
    }

    public void validateDeliveryManager(String userRole) {
        if (!"DELIVERY_MANAGER".equalsIgnoreCase(userRole)) {
            throw new GlobalException(OrderErrorCode.DELIVERY_MANAGER_ONLY);
        }
    }

    public void validateCompanyMaanger(String userRole) {
        if (!"COMPANY_MANAGER".equalsIgnoreCase(userRole)) {
            throw new GlobalException(OrderErrorCode.COMPANY_MANAGER_ONLY);
        }
    }
}

application/validaor 패키지에 Controller 에서 활용할 메서드를 클래스로 분리
해당 클래스를 통해 Controller 에서는 User Role 을 통해 권한을 검증할 수 있는 로직

참고 자료

https://github.com/ElevenHub/HubEleven/pull/89/files

[refactor] 허브(Hub) 권한 및 userId 연결 by hinoyat · Pull Request #89 · ElevenHub/HubEleven

#️⃣연관된 이슈 #88 작업 내용 gateway에서 받아온 사용자 정보 사용하도록 리팩토링 했습니다.

github.com

[리팩토링] 권한 별 기능 제한 로직 구현 (1) (업데이트 중..)

annovation — Wed, 7 Jan 2026 23:15:56 +0900

권한 관리

상품 (Product) 도메인 권한

주문 (Order) 도메인 권한

권한 로직

Controller

@PostMapping
public ResponseEntity<ApiResponse<HubResponseDto>> createHub(
        @Valid @RequestBody HubCreateRequestDto request,
        @RequestHeader("X-User-Id") Long userId,
        @RequestHeader("X-User-Role") String userRole,
        @RequestHeader("X-Username") String userNameString) {
    if (!"MASTER".equalsIgnoreCase(userRole)) {
        throw new GlobalException(HubErrorCode.MASTER_ONLY);
    }
    CreateHubCommand command = request.toCommand(userId);
    HubResult result = hubService.createHub(command);
    HubResponseDto response = HubResponseDto.from(result);
    return ApiResponseEntity.success(response);
}

전체 실행 흐름

1. 클라이언트가 HTTP 요청 보냄

POST /hubs (예시)
Body
- HubCreateRequestDto에 매핑될 JSON
Headers
- X-User-Id : 123
- X-User-Role : MASTER
- X-Username : sati
여기서 핵심은, 이 헤더들은 Spring이 자동으로 꺼내서 파라미터에 주입한다는 점

2. 스프링이 매핑되는 컨트롤러 메서드 찾음

@PostMapping이 붙은 메서드가 해당 경로/HTTP 메서드와 매칭되면 실행 대상으로 선택됨

참고 자료

https://github.com/ElevenHub/HubEleven/pull/89/files?diff=split&w=0

[refactor] 허브(Hub) 권한 및 userId 연결 by hinoyat · Pull Request #89 · ElevenHub/HubEleven

#️⃣연관된 이슈 #88 작업 내용 gateway에서 받아온 사용자 정보 사용하도록 리팩토링 했습니다.

github.com

[리팩토링] Trouble Shooting : Swagger Request DTO 메서드 충돌

annovation — Tue, 6 Jan 2026 21:04:22 +0900

문제 상황

Spring Boot + springdoc-openapi 환경에서 API 문서를 Swagger UI로 확인하던 중, 서로 다른 Request DTO임에도 Swagger에서 하나의 Schema로 인식되는 문제가 발생했다.

- ProductRequests.Create

public class ProductRequests {

	public record Create(
			@NotBlank(message = "상품명은 필수 입력 항목입니다.") @Size(max = 150, message = "상품명은 150자 이하여야 합니다.")
					String name,
			@NotNull(message = "업체 ID는 필수 입력 항목입니다.") UUID companyId,
			@NotNull(message = "허브 ID는 필수 입력 항목입니다.") UUID hubId) {}
}

- StockRequests.Create

public class StockRequests {

	public record Create(
			@NotNull(message = "수량은 필수 입력 항목입니다.") @Min(value = 0, message = "수량은 0 이상이어야 합니다.")
					int quantity,
			@NotNull(message = "상품 ID는 필수 입력 항목입니다.") UUID productId,
			@NotNull(message = "업체 ID는 필수 입력 항목입니다.") UUID companyId,
			@NotNull(message = "허브 ID는 필수 입력 항목입니다.") UUID hubId) {}
}

두 도메인 모두 Create라는 이름의 record를 사용하고 있었고, Controller에서는 다음과 같이 사용 중이었다.

- ProductController

@PostMapping("/products")
public void createProduct(@RequestBody ProductRequests.Create request) {}

- StockController

@PostMapping("/stocks")
public void createStock(@RequestBody StockRequests.Create request) {}

문제 증상

Product / Stock API가 같은 Request 구조로 표시

원인 분석

Swagger(OpenAPI)의 schema 생성 방식 문제

springdoc-openapi는 기본적으로 클래스의 단순 이름(Simple Name) 을 기준으로 Schema 이름을 생성한다.

schemaName = Create

ProductRequests.Create
StockRequests.Create

➡️ 둘 다 Swagger 입장에서는 같은 Create

이로 인해 Schema 이름 충돌이 발생했다. (참고)

해결 방안 검토

1. DTO 이름 변경

StockRequests.CreateStock

하지만 이 경우 Controller에서 다음과 같은 중복 표현이 발생한다.

StockRequests.CreateStock  // Stock이 두 번 반복됨

➡️ 도메인 구조 가독성이 나빠짐

2. 코드 구조는 유지하고, Swagger 문서에서만 Schema 이름을 분리

이를 위해 OpenAPI 전용 어노테이션인 @Schema를 사용

해결 방법

@Schema 사용

- 적용 코드

import io.swagger.v3.oas.annotations.media.Schema;

public class StockRequests {

    @Schema(name = "StockCreateRequest", description = "재고 생성 요청")
    public record Create(
        int quantity,
        UUID productId,
        UUID companyId,
        UUID hubId
    ) {}
}

Product 쪽도 동일하게 적용

@Schema(name = "ProductCreateRequest", description = "상품 생성 요청")
public record Create(
    String name,
    UUID companyId,
    UUID hubId
) {}

@Schema 어노테이션

@Schema는 Swagger/OpenAPI 문서 생성 시 데이터 모델(스키마)의 메타 정보(이름, 설명, 예시 등)를 정의하기 위한 어노테이션으로, 서버 로직이나 validation에는 영향을 주지 않고 API 문서를 더 명확하게 만들어 준다. (출처)

생각해볼 것

규모가 더 커져서 다양한 Request 들이 필요해질 때, @Schema 사용만으로는 유지보수가 어려워질 것 같다.
하나의 클래스에 관리하고 있는 Request 를 따로 분리하는 방법도 고려해봐야할 것 같다.

참고 자료

1) springdoc-openapi github

https://github.com/springdoc/springdoc-openapi/issues/548

Fully qualified names · Issue #548 · springdoc/springdoc-openapi

Hi, Is it possible to show fully qualified java type names in the schemas? Its quite possible there might be multiple classes with same class simple name but different package names used . R

github.com

[동시성 처리] Trouble Shooting : 테스트 코드 런타임 에러 발생

annovation — Mon, 5 Jan 2026 21:51:19 +0900

테스트 코드 런타임 에러

동시성 처리 테스트 진행을 위해 재고 감소 로직 테스트 코드 작성 중 런타임 에러 발생

런타임 에러 내용

ConfigClientFailFastException: Could not locate PropertySource ... failing

ResourceAccessException: I/O error ... http://localhost:8888/... Connection refused

테스트가 @SpringBootTest로 ApplicationContext를 띄우는 순간 Spring Cloud Config Client가 설정을 가져오려고 http://localhost:8888/product-service/default 로 GET 요청을 보냄
그런데 localhost:8888(Config Server)가 안 떠있어서 Connection refused

Spring Cloud Config Client

Spring Cloud Config Client 란?

Spring Cloud Config provides client-side and server-side support for externalized configuration in a distributed system.

Spring Cloud Config는 분산 시스템에서 외부화된 설정을 관리하기 위해 클라이언트 측과 서버 측 지원을 제공한다. (출처)
Config Client는 애플리케이션 안에 포함되는 라이브러리이다.
애플리케이션이 시작될 때 외부 Config Server로부터 설정을 가져오는 역할을 한다.

트러블 슈팅

해결 방법

1) Config Client 비활성화

spring:
  cloud:
    config:
      enabled: false

2) Config Client optional 처리

spring:
  config:
    import: optional:configserver:

요약

Spring Cloud Config Client는 애플리케이션 시작 시 외부 Config Server에서 설정을 로드하는 선택적 컴포넌트이며,
테스트 환경에서는 spring.cloud.config.enabled=false 또는 optional:configserver: 설정을 통해 로컬 설정만 사용하도록 구성할 수 있다.

어렵다.

참고 자료

1) Spring docs

https://docs.spring.io/spring-cloud-config/docs/current/reference/html/

Spring Cloud Config

Spring Cloud Config provides server-side and client-side support for externalized configuration in a distributed system. With the Config Server, you have a central place to manage external properties for applications across all environments. The concepts o

docs.spring.io

[프로그래머스 / MySQL] Lv.1 조건에 맞는 도서 리스트 출력하기

annovation — Sun, 4 Jan 2026 22:45:41 +0900

Question

https://school.programmers.co.kr/learn/courses/30/lessons/144853

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

Algorithm

1. 날짜 형식

PUBLISHED_DATE 컬럼의 날짜 형식을 YYYY-MM-DD 형태로 변환

date_format(PUBLISHED_DATE, '%Y-%m-%d') AS PUBLISHED_DATE

2. 년도, 카테고리

YEAR(PUBLISHED_DATE) = 2021
→ 출판 연도가 2021년인 데이터만 필터링
CATEGORY = '인문'
→ 카테고리가 ‘인문’인 도서만 선택
AND 조건이므로 두 조건을 모두 만족하는 데이터만 조회

3. 오름차순 정렬

ASC는 오름차순 (생략해도 기본값은 ASC)

Code

SELECT BOOK_ID, date_format(PUBLISHED_DATE, '%Y-%m-%d') AS PUBLISHED_DATE
FROM BOOK
WHERE YEAR(PUBLISHED_DATE) = 2021 AND CATEGORY = '인문'
ORDER BY PUBLISHED_DATE ASC;

참고 자료

https://lungfish.tistory.com/entry/프로그래머스MYSQL-조건에-맞는-도서-리스트-출력하기

[프로그래머스/MYSQL] 조건에 맞는 도서 리스트 출력하기

코딩테스트 연습 - 조건에 맞는 도서 리스트 출력하기 | 프로그래머스 스쿨 프로그래머스코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고

lungfish.tistory.com