fos-blog/study
01 / 홈02 / 카테고리
01 / 홈02 / 카테고리

카테고리

  • AI 페이지로 이동
    • RAG 페이지로 이동
    • langgraph 페이지로 이동
    • agents.md
    • BMAD Method — AI 에이전트로 애자일 개발하는 방법론
    • Claude Code의 Skill 시스템 - 개발자를 위한 AI 자동화의 새로운 차원
    • Claude Code를 5주 더 쓴 결과 — 스킬·CLAUDE.md를 키워가는 방식
    • Claude Code를 11일 동안 쓴 결과 — 데이터로 본 나의 사용 패턴
    • Claude Code 멀티 에이전트 — Teams
    • AI 에이전트와 디자인의 새 컨벤션 — DESIGN.md, Google Stitch, Claude Design
    • 하네스 엔지니어링 실전 — 4인 에이전트 팀으로 코딩 파이프라인 구축하기
    • 하네스 엔지니어링 — 오래 실행되는 AI 에이전트를 위한 설계
    • 멀티모달 LLM (Multimodal Large Language Model)
    • AI 에이전트와 함께 MVP 만들기 — dooray-cli 사례
  • ai 페이지로 이동
    • agent 페이지로 이동
  • algorithm 페이지로 이동
    • live-coding 페이지로 이동
    • 분산 계산을 위한 알고리즘
  • architecture 페이지로 이동
    • [초안] 시니어 백엔드를 위한 API 설계 실전 스터디 팩 — REST · 멱등성 · 페이지네이션 · 버전 전략
    • [초안] API Versioning과 Backward Compatibility: 시니어 백엔드 관점 정리
    • 캐시 설계 전략 총정리
    • [초안] CJ푸드빌 커머스/F&B 도메인 설계 면접 대비 — 슬롯 경험을 주문·결제·쿠폰·매장 상태 설계로 번역하기
    • [초안] 커머스 Spring 서비스에 Clean/Hexagonal Architecture를 실용적으로 적용하기
    • [초안] 커머스 주문 상태와 데이터 정합성 기본기 — CJ푸드빌 면접 대비
    • [초안] 쿠폰/프로모션 동시성과 정합성 기본기 — 선착순·중복 사용 방지·발급/사용/복구
    • [초안] DDD와 도메인 모델링: 시니어 백엔드 관점의 전술/전략 패턴 실전 가이드
    • [초안] Decorator & Chain of Responsibility — 행동을 체인으로 조립하는 두 가지 방식
    • 디자인 패턴
    • [초안] 분산 아키텍처 완전 정복: Java 백엔드 시니어 인터뷰 대비 실전 가이드
    • [초안] 분산 트랜잭션과 Outbox 패턴 — 왜 2PC를 피하고 어떻게 대신할 것인가
    • 분산 트랜잭션
    • [초안] e-Commerce 주문·결제 도메인 모델링: 상태머신, 멱등성, Outbox/Saga 실전 정리
    • [초안] F&B 쿠폰·프로모션·멤버십·포인트 설계
    • [초안] F&B · e-Commerce 디지털 채널 도메인 한 장 정리 — CJ푸드빌 디지털 채널 백엔드 면접 대비
    • [초안] F&B 주문/매장/픽업 상태머신 설계 — CJ푸드빌 디지털 채널 백엔드 관점
    • [초안] F&B 이커머스 결제·환불·정산 운영 가이드
    • [초안] Hexagonal / Clean Architecture를 Spring 백엔드에 적용하기
    • [초안] 대규모 커머스 트래픽 처리 패턴 — 1,600만 고객과 올영세일을 버티는 설계
    • [초안] 레거시 JSP/jQuery 화면과 신규 API가 공존하는 백엔드 운영 전략
    • [초안] MSA 서비스 간 통신: Redis [Cache-Aside](../database/redis/cache-aside.md) × Kafka 이벤트 하이브리드 설계
    • [초안] Observability 입문: 시니어 백엔드가 장애를 탐지하고 대응하는 방식
    • [초안] Outbox / Inbox Pattern 심화 — 분산 메시징의 정합성 문제를 DB 트랜잭션으로 풀어내기
    • [초안] 결제 도메인 멱등성과 트랜잭션 재시도 기본기
    • [초안] 시니어 백엔드를 위한 Resilience 패턴 실전 가이드 — Timeout, Retry, Circuit Breaker, Bulkhead, Backpressure
    • [초안] REST API 버저닝과 모바일 앱 하위 호환성 — CJ푸드빌 디지털 채널 백엔드 관점
    • [초안] Strategy Pattern — 분기문을 없애는 설계, 시니어 백엔드 인터뷰 핵심 패턴
    • [초안] 시니어 백엔드를 위한 시스템 설계 입문 스터디 팩
    • [초안] 템플릿 메서드 패턴 - 백엔드 처리 골격을 강제하는 가장 오래되고 가장 위험한 패턴
    • [초안] 대규모 트래픽 중 무중단 마이그레이션 — Feature Flag + Shadow Mode 실전
  • database 페이지로 이동
    • mysql 페이지로 이동
    • opensearch 페이지로 이동
    • redis 페이지로 이동
    • 김영한의-실전-데이터베이스-설계 페이지로 이동
    • 커넥션 풀 크기는 얼마나 조정해야 할까?
    • 인덱스 - DB 성능 최적화의 핵심
    • [초안] JPA N+1과 커머스 조회 모델: 주문/메뉴/쿠폰 도메인에서 살아남기
    • [초안] MyBatis 기본기 — XML Mapper, resultMap, 동적 SQL, 운영 패턴 정리
    • [초안] MyBatis와 JPA/Hibernate 트레이드오프 — 레거시 백엔드를 다루는 시니어 관점
    • 역정규화 (Denormalization)
    • 데이터 베이스 정규화
  • devops 페이지로 이동
    • docker 페이지로 이동
    • k8s 페이지로 이동
    • k8s-in-action 페이지로 이동
    • observability 페이지로 이동
    • [초안] 커머스/F&B 채널 장애 첫 5분과 관측성 기본기
    • Envoy Proxy
    • [초안] F&B / e-Commerce 운영 장애 대응과 모니터링 — 백엔드 관점 정리
    • Graceful Shutdown
  • finance 페이지로 이동
    • industry-cycle 페이지로 이동
    • investing 페이지로 이동
    • stock-notes 페이지로 이동
  • http 페이지로 이동
    • HTTP Connection Pool
  • interview 페이지로 이동
    • [초안] AI 서비스 팀 경험 기반 시니어 백엔드 면접 질문 뱅크 — Spring Batch RAG / gRPC graceful shutdown / 전략 패턴 / 12일 AI 웹툰 MVP
    • [초안] CJ푸드빌 디지털 채널 Back-end 개발자 직무 분석
    • [초안] CJ푸드빌 디지털 채널 Back-end 면접 답변집 — 슬롯 도메인 경험을 커머스/F&B 설계로 번역하기
    • [초안] F&B / e-Commerce 운영 모니터링과 장애 대응 인터뷰 정리
    • Observability — 면접 답변 프레임
    • [초안] 시니어 Java 백엔드 면접 마스터 플레이북 — 김병태
    • [초안] NSC 슬롯팀 경험 기반 질문 은행 — 도메인 모델링·동시성·성능·AI 협업
  • java 페이지로 이동
    • concurrency 페이지로 이동
    • jdbc 페이지로 이동
    • opentelemetry 페이지로 이동
    • spring 페이지로 이동
    • spring-batch 페이지로 이동
    • 더_자바_코드를_조작하는_다양한_방법 페이지로 이동
    • [초안] Java 동시성 락 정리 — 커머스 메뉴/프로모션 정책 캐시 갱신 관점
    • [초안] JVM 튜닝 실전: 메모리 구조부터 Virtual Threads, GC 튜닝, 프로파일링까지
    • Java의 로깅 환경
    • MDC (Mapped Diagnostic Context)
    • Java StampedLock — 읽기 폭주에도 쓰기가 밀리지 않는 락
    • Virtual Thread와 Project Loom
  • javascript 페이지로 이동
    • typescript 페이지로 이동
    • AbortController
    • Async Iterator와 제너레이터
    • CommonJS와 ECMAScript Modules
    • 제너레이터(Generator)
    • Http Client
    • Node 백엔드 운영 패턴 — Streams 백프레셔, pipe/pipeline, 멱등성 vs 분산 락
    • Node.js
    • npm vs pnpm — 어떤 기준으로 선택했나
    • `setImmediate()`
  • kafka 페이지로 이동
    • [초안] Kafka 기본 개념 — 토픽, 파티션, 오프셋, 복제
    • Kafka를 사용하여 **데이터 정합성**은 어떻게 유지해야 할까?
    • [초안] Kafka 실전 설계: 파티션 전략, 컨슈머 그룹, 전달 보장, 재시도, 순서 보장 트레이드오프
    • 메시지 전송 신뢰성
  • linux 페이지로 이동
    • fsync — 리눅스 파일 동기화 시스템 콜
    • tmux — Terminal Multiplexer
  • network 페이지로 이동
    • L2(스위치)와 L3(라우터)의 역할 차이
    • L4와 VIP(Virtual IP Address)
    • IP Subnet
  • rabbitmq 페이지로 이동
    • [초안] RabbitMQ Basics — 실전 백엔드 관점에서 정리하는 메시지 브로커 기본기
    • [초안] RabbitMQ vs Kafka — 백엔드 메시징 선택 기준과 실전 운영 관점
  • security 페이지로 이동
    • [초안] 시니어 백엔드를 위한 보안 / 인증 스터디 팩 — Spring Security, JWT, OAuth2, OWASP Top 10
  • task 페이지로 이동
    • ai-service-team 페이지로 이동
    • nsc-slot 페이지로 이동
    • sb-dev-team 페이지로 이동
    • the-future-company 페이지로 이동
  • testing 페이지로 이동
    • [초안] 시니어 Java 백엔드를 위한 테스트 전략 완전 정리 — 피라미드부터 TestContainers, 마이크로벤치, Contract까지
  • travel 페이지로 이동
    • 오사카 3박 4일 일정표: 우메다 쇼핑, USJ, 난바·도톤보리, 오사카성
  • web 페이지로 이동
    • [초안] HTTP / Cookie / Session / Token 인증 기본기 — 레거시 JSP와 모바일 API가 공존하는 백엔드 관점
FOS-BLOG · FOOTERall systems normal·v0.1 · 2026.04.27·seoul, kr
Ffos-blog/study

개발 학습 기록을 정리하는 블로그입니다. 공부하면서 기록하고, 기록하면서 다시 배웁니다.

visitors
01site
  • Home↗
  • Posts↗
  • Categories↗
  • About↗
02policy
  • 소개/about
  • 개인정보처리방침/privacy
  • 연락처/contact
03categories
  • AI↗
  • Algorithm↗
  • DB↗
  • DevOps↗
  • Java/Spring↗
  • JS/TS↗
  • React↗
  • Next.js↗
  • System↗
04connect
  • GitHub@jon890↗
  • Source repositoryjon890/fos-study↗
  • RSS feed/rss.xml↗
  • Newsletter매주 1 회 · 한 편의 글→
© 2026 FOS Study. All posts MIT-licensed.
built with·Next.js·Tailwind v4·Geist·Pretendard·oklch
fos-blog/architecture/[초안] Decorator & Chain o…
system

[초안] Decorator & Chain of Responsibility — 행동을 체인으로 조립하는 두 가지 방식

--- 둘 다 "여러 개의 작은 처리 단위를 체인으로 이어서 최종 결과를 만든다"는 공통 의도를 가진다. 그래서 현장에서 자주 혼동된다. 실제로 "데코레이터를 쓴다"고 말한 코드가 책임 연쇄 구조일 때도 있고, 반대인 경우도 있다. 이 글의 목적은 두 패턴의 구조적 차이와 선택 기준을 정리하는 것이다. 한 번 정리해두면 설계 단계에서 "우리 상황은 어느 쪽...

2026.04.19·6 min read·184 views

왜 이 두 패턴을 같이 보는가

둘 다 "여러 개의 작은 처리 단위를 체인으로 이어서 최종 결과를 만든다"는 공통 의도를 가진다. 그래서 현장에서 자주 혼동된다. 실제로 "데코레이터를 쓴다"고 말한 코드가 책임 연쇄 구조일 때도 있고, 반대인 경우도 있다.

이 글의 목적은 두 패턴의 구조적 차이와 선택 기준을 정리하는 것이다. 한 번 정리해두면 설계 단계에서 "우리 상황은 어느 쪽에 더 가까운가"를 분명히 고를 수 있다.


한 줄 요약

  • Decorator Pattern — 대상 객체를 감싸서 기능을 추가·변형한다. 체인은 "원본 → 장식1 → 장식1+장식2 → ..." 식으로 누적된다. 매 단계가 다음 단계로 결과를 전달한다
  • Chain of Responsibility(CoR) — 요청을 핸들러 체인으로 흘려보내고, 책임 있는 핸들러를 만나면 거기서 멈추거나 통과한다. 각 핸들러는 처리할지 말지, 다음으로 넘길지를 자기가 결정한다
축DecoratorChain of Responsibility
의도기능 추가요청 처리 위임
체인 종료체인 끝까지 전달조기 종료 가능
반환값변환된 객체처리 결과 또는 통과
각 단계 관점"나는 장식한다""내 책임인가? 아니면 다음에게"
실행 순서순서 중요 (누적)순서 중요 (우선순위)

구조 비교

Decorator

plaintext
Original ──▶ DecoratorA(wraps) ──▶ DecoratorB(wraps) ──▶ 최종 결과

각 데코레이터는 같은 인터페이스를 구현하면서 내부에 원본을 품는다. 메서드 호출은 원본에 위임하되, 앞뒤로 자기 기능을 덧댄다.

java
interface Coffee {
    int cost();
}
 
class BaseCoffee implements Coffee {
    public int cost() { return 3000; }
}
 
class MilkDecorator implements Coffee {
    private final Coffee base;
    MilkDecorator(Coffee base) { this.base = base; }
    public int cost() { return base.cost() + 500; }
}
 
class CaramelDecorator implements Coffee {
    private final Coffee base;
    CaramelDecorator(Coffee base) { this.base = base; }
    public int cost() { return base.cost() + 800; }
}
 
// 사용
Coffee order = new CaramelDecorator(new MilkDecorator(new BaseCoffee()));
order.cost(); // 4300

Chain of Responsibility

plaintext
Request ──▶ HandlerA ──▶ HandlerB ──▶ HandlerC ──▶ (처리 or 실패)
                    ↓(내가 처리)
                  [종료]

각 핸들러는 다음 핸들러를 참조로 가지고, 자기 책임이면 처리하고 끝내거나, 아니면 다음으로 넘긴다.

java
abstract class AuthHandler {
    protected AuthHandler next;
    void setNext(AuthHandler next) { this.next = next; }
    abstract Result handle(Request req);
}
 
class JwtHandler extends AuthHandler {
    Result handle(Request req) {
        if (req.hasHeader("Authorization")) {
            return verifyJwt(req);  // 내 책임 → 처리하고 끝
        }
        return next != null ? next.handle(req) : Result.unauthorized();
    }
}
 
class ApiKeyHandler extends AuthHandler {
    Result handle(Request req) {
        if (req.hasHeader("X-API-Key")) {
            return verifyApiKey(req);
        }
        return next != null ? next.handle(req) : Result.unauthorized();
    }
}

Spring Security의 FilterChain, Servlet Filter, OkHttp Interceptor가 대표적인 CoR 구현이다.


실제 구분이 흐려지는 지점

두 패턴은 구현 관점에선 비슷한 뼈대를 가진다. 인터페이스 하나 + 여러 구현체 + 순서 있는 적용. 그래서 "체인"을 코드로 표현하는 순간 두 가지가 섞여 보이기도 한다.

핵심 질문 세 가지로 구별할 수 있다.

  1. 각 단계가 결과를 변환하는가, 통과 여부를 결정하는가

    • 변환(입력 → 새 입력) → Decorator
    • 통과 또는 종료 → Chain of Responsibility
  2. 체인 끝까지 반드시 가는가, 중간에 끝날 수 있는가

    • 반드시 끝까지 → Decorator
    • 중간에 종료 가능 → Chain of Responsibility
  3. 각 단계가 "감싸는 구조"인가, "다음 핸들러를 참조하는 구조"인가

    • 감쌈(composition) → Decorator
    • 참조(next pointer) → CoR

두 패턴이 자연스럽게 섞이는 경우도 있다. Servlet Filter는 CoR이지만 Filter 내부에서 ServletRequest나 ServletResponse를 감싸 새 객체로 전달하는 식으로 Decorator를 섞는다. 이땐 **"요청 라우팅은 CoR, 요청/응답 변환은 Decorator"**가 공존한다.


언제 Decorator가 더 적합한가

  • 처리 로직이 순서 있는 누적 변환일 때. 각 단계가 앞 단계의 결과를 받아 변형한다
  • 모든 단계가 실행되어야 할 때(또는 조건부로 스킵만 하고 반드시 다음으로 넘길 때)
  • 반환값이 변환된 같은 타입의 객체일 때
  • 단위 테스트가 순수 함수 스타일로 쉬운 경우

대표 사례 — Java IO Stream (BufferedReader → InputStreamReader → FileInputStream), 할인 계산 체인, 슬롯 당첨 금액의 단계별 배수 적용.

언제 Chain of Responsibility가 더 적합한가

  • 누가 처리할지 미리 알 수 없을 때. 요청에 따라 서로 다른 핸들러가 책임을 가진다
  • 조기 종료 가능성이 있을 때. 한 핸들러가 처리하면 이후 핸들러는 실행하지 않아도 된다
  • 횡단 관심사(logging, auth, rate limiting)를 체인으로 조립할 때
  • 요청이 어떤 핸들러에도 매칭되지 않아 전체 통과 실패가 유효한 결과일 때

대표 사례 — 웹 프레임워크 Filter/Interceptor, 인증 미들웨어 체인, Approval 워크플로우(1차 승인 → 2차 승인 → ...).


Spring/Java 생태계에서의 예시

Decorator

  • java.io.InputStream 계열 — BufferedInputStream이 FileInputStream을 감싸서 버퍼링 추가
  • Spring의 TransactionAwareCacheDecorator — Cache에 트랜잭션 동기화 추가
  • 도메인 레벨 커스텀 Decorator — 당첨 계산, 가격 할인, 배송비 계산 등

Chain of Responsibility

  • Servlet Filter + FilterChain.doFilter()
  • Spring Security의 SecurityFilterChain
  • Spring MVC의 HandlerInterceptor
  • OkHttp Interceptor
  • Micrometer Observation 체인

실제 사례 — 슬롯 당첨 계산 데코레이터 체인

Decorator Pattern이 도메인 로직에 깔끔하게 맞는 사례 하나를 언어·도메인 독립적으로 정리했다: 슬롯 당첨 계산 — Decorator 체인 + 우선순위 정렬.

요점만 옮기면 이렇다.

  • PayableItemDecorator<C> 인터페이스 — decorate(), isApplicable(), getPriority(), createContext()
  • 프리게임 배수 · 프로그레시브 · 멀티플라이어 심볼 등 각 변환을 독립 Decorator로 구현
  • AbstractWinService.applyDecorators()가 우선순위 정렬 후 순차 적용
  • 새 변환 규칙 추가 시 기존 서비스·데코레이터 코드 무변경(OCP)

이 사례에서 Decorator를 선택한 이유는 "순서 있는 누적 변환"이라는 본질이 분명했기 때문이다. CoR로 구현하면 "다음 단계로 넘기지 않는 경우"가 거의 없어서 구조가 어색해진다.


설계 체크리스트

Decorator를 고를 때

  • 체인의 모든(또는 대부분) 단계가 결과를 변환하는가
  • 반환 타입이 입력과 동일한가
  • 단계가 누적되는 순서가 명확히 정의 가능한가
  • 각 Decorator가 isApplicable() 같은 조건으로 스스로 스킵 판단할 수 있는가
  • 불변 객체 기반으로 설계 가능한가(withX() / builder)

Chain of Responsibility를 고를 때

  • 요청마다 담당 핸들러가 달라지는가
  • 조기 종료가 자연스러운가
  • 핸들러들이 서로 다른 종류의 처리를 수행하는가(auth, log, rate limit 등)
  • 마지막 핸들러에 도달했는데도 처리되지 않는 경우가 유효한 상태인가

공통 안티패턴

  • 체인 길이가 2 이하인데 패턴을 썼다면 과설계 — if-else가 더 단순할 수 있다
  • 각 단계가 서로 의존하면서 "다음 단계가 뭔지 알아야 내 동작을 결정한다" — 체인 구조가 본질과 안 맞는 신호
  • @SuppressWarnings("unchecked")가 여러 레이어에 퍼져 있다면 제네릭 설계를 다시 보라 — 컨텍스트 타입을 좁혀 한 레이어에서만 캐스팅하게 구성

한 줄 정리

Decorator는 "결과를 층층이 덧붙이는 변환기", CoR는 "책임 있는 처리기를 찾아가는 라우터". 체인처럼 보여도 의도가 다르다.


참고

  • GoF, Design Patterns, 1994 — Decorator와 Chain of Responsibility 원전
  • Spring Framework Reference — FilterChain / HandlerInterceptor 구조
  • Strategy Pattern — Decorator 안에 전략을 품는 조합 사례
on this page
  • 01왜 이 두 패턴을 같이 보는가
  • 02한 줄 요약
  • 03구조 비교
  • Decorator
  • Chain of Responsibility
  • 04실제 구분이 흐려지는 지점
  • 05언제 Decorator가 더 적합한가
  • 06언제 Chain of Responsibility가 더 적합한가
  • 07Spring/Java 생태계에서의 예시
  • Decorator
  • Chain of Responsibility
  • 08실제 사례 — 슬롯 당첨 계산 데코레이터 체인
  • 09설계 체크리스트
  • Decorator를 고를 때
  • Chain of Responsibility를 고를 때
  • 공통 안티패턴
  • 10한 줄 정리
  • 11참고

댓글 (0)