From 8dfec947f8ddb0616fa6ef64dbe59329579b390a Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Thu, 26 Jun 2025 09:05:01 +0900
Subject: [PATCH 01/16] feat: implement user block functionality with API
 endpoints and caching

Signed-off-by: hgkim <hgkim@openerd.com>
---
 BLOCK_FEATURE_USAGE.md                        | 241 ++++++
 USER_BLOCK_IMPLEMENTATION.md                  | 687 ++++++++++++++++++
 git.environment-variables                     |   2 +-
 ...352\263\204_\354\203\235\354\204\261.http" |  31 +
 ...353\266\200_\355\231\225\354\235\270.http" |  15 +
 ...353\241\235_\354\241\260\355\232\214.http" |  15 +
 ...352\263\204_\354\241\260\355\232\214.http" |  15 +
 ...352\263\204_\355\225\264\354\240\234.http" |  15 +
 ...\355\205\214\354\212\244\355\212\270.http" |  47 ++
 ...\355\205\214\354\212\244\355\212\270.http" |   6 +
 http/block/README.md                          | 107 +++
 .../global/annotation/BlockFilter.java        |  26 +
 .../global/aspect/BlockFilterAspect.java      | 228 ++++++
 .../global/cache/local/LocalCacheType.java    |   3 +-
 .../controller/BlockTestController.java       | 248 +++++++
 .../global/security/SecurityContextUtil.java  |  12 +
 .../global/service/BlockService.java          | 262 +++++++
 .../review/controller/ReviewController.java   |   3 +
 .../app/bottlenote/user/domain/UserBlock.java |  70 ++
 .../user/domain/UserBlockRepository.java      |  71 ++
 .../repository/JpaUserBlockRepository.java    |  37 +
 21 files changed, 2139 insertions(+), 2 deletions(-)
 create mode 100644 BLOCK_FEATURE_USAGE.md
 create mode 100644 USER_BLOCK_IMPLEMENTATION.md
 create mode 100644 "http/block/01-\354\260\250\353\213\250_\352\264\200\352\263\204_\354\203\235\354\204\261.http"
 create mode 100644 "http/block/02-\354\260\250\353\213\250_\354\227\254\353\266\200_\355\231\225\354\235\270.http"
 create mode 100644 "http/block/03-\354\260\250\353\213\250_\353\252\251\353\241\235_\354\241\260\355\232\214.http"
 create mode 100644 "http/block/04-\354\260\250\353\213\250_\355\206\265\352\263\204_\354\241\260\355\232\214.http"
 create mode 100644 "http/block/05-\354\260\250\353\213\250_\352\264\200\352\263\204_\355\225\264\354\240\234.http"
 create mode 100644 "http/block/06-\354\260\250\353\213\250_\355\225\204\355\204\260_\355\205\214\354\212\244\355\212\270.http"
 create mode 100644 "http/block/07-\354\240\204\354\262\264_\354\264\210\352\270\260\355\231\224_\355\205\214\354\212\244\355\212\270.http"
 create mode 100644 http/block/README.md
 create mode 100644 src/main/java/app/bottlenote/global/annotation/BlockFilter.java
 create mode 100644 src/main/java/app/bottlenote/global/aspect/BlockFilterAspect.java
 create mode 100644 src/main/java/app/bottlenote/global/controller/BlockTestController.java
 create mode 100644 src/main/java/app/bottlenote/global/service/BlockService.java
 create mode 100644 src/main/java/app/bottlenote/user/domain/UserBlock.java
 create mode 100644 src/main/java/app/bottlenote/user/domain/UserBlockRepository.java
 create mode 100644 src/main/java/app/bottlenote/user/repository/JpaUserBlockRepository.java

diff --git a/BLOCK_FEATURE_USAGE.md b/BLOCK_FEATURE_USAGE.md
new file mode 100644
index 000000000..0f1d9e175
--- /dev/null
+++ b/BLOCK_FEATURE_USAGE.md
@@ -0,0 +1,241 @@
+# 🚫 차단 기능 사용 가이드
+
+## 🎯 구현 완료된 기능들
+
+### ✅ 1. BlockFilter 어노테이션
+- **위치**: `app.bottlenote.global.annotation.BlockFilter`
+- **용도**: 컨트롤러 메서드에 차단 필터링 적용
+
+### ✅ 2. BlockFilterAspect AOP
+- **위치**: `app.bottlenote.global.aspect.BlockFilterAspect`
+- **용도**: 어노테이션 기반 자동 차단 처리
+
+### ✅ 3. BlockService
+- **위치**: `app.bottlenote.global.service.BlockService`
+- **용도**: 차단 관계 관리 (현재 메모리 기반)
+
+### ✅ 4. ReviewController 적용 샘플
+- **적용된 메서드**: `getReviews()`, `getDetailReview()`
+
+### ✅ 5. BlockTestController
+- **위치**: `app.bottlenote.global.controller.BlockTestController`
+- **용도**: 차단 기능 테스트
+
+---
+
+## 🚀 사용 방법
+
+### 1️⃣ 기본 사용법
+```java
+// 차단된 사용자의 리뷰를 블러 처리
+@BlockFilter(userField = "authorId", type = BlockType.BLUR)
+@GetMapping("/reviews")
+public ResponseEntity<?> getReviews() {
+    // 기존 로직 그대로 유지
+}
+```
+
+### 2️⃣ 차단 타입 선택
+```java
+// 블러 처리
+@BlockFilter(type = BlockType.BLUR)
+
+// 완전 제외
+@BlockFilter(type = BlockType.EXCLUDE)
+
+// 접근 차단 (403 에러)
+@BlockFilter(type = BlockType.ACCESS_DENY)
+```
+
+### 3️⃣ 사용자 ID 필드 지정
+```java
+// 기본값: authorId
+@BlockFilter(userField = "authorId")
+
+// 다른 필드명 사용
+@BlockFilter(userField = "userId")
+@BlockFilter(userField = "writerId")
+```
+
+---
+
+## 🧪 테스트 방법
+
+### 1. 서버 실행
+```bash
+./gradlew bootRun
+```
+
+### 2. 차단 관계 생성
+```bash
+# 사용자 1이 사용자 2를 차단
+curl -X POST "http://localhost:8080/api/v1/test/block/add?blockerId=1&blockedId=2"
+```
+
+### 3. 차단 목록 확인
+```bash
+# 사용자 1의 차단 목록 조회
+curl "http://localhost:8080/api/v1/test/block/list/1"
+```
+
+### 4. 리뷰 조회 테스트
+```bash
+# JWT 토큰으로 로그인한 상태에서 리뷰 조회
+curl -H "Authorization: Bearer YOUR_JWT_TOKEN" \
+     "http://localhost:8080/api/v1/reviews/1"
+```
+
+### 5. 차단 관계 해제
+```bash
+curl -X DELETE "http://localhost:8080/api/v1/test/block/remove?blockerId=1&blockedId=2"
+```
+
+---
+
+## 📋 동작 확인 포인트
+
+### ✅ 로그 확인
+```
+2024-01-15 10:30:00 INFO  - 차단 관계 생성: 1 -> 2
+2024-01-15 10:31:00 DEBUG - 사용자 1의 차단 목록 조회: 1 명
+2024-01-15 10:32:00 INFO  - 사용자 1의 차단 필터 적용 완료 - 차단 목록: 1 개
+```
+
+### ✅ 응답 데이터 변화
+**차단 전:**
+```json
+{
+  "success": true,
+  "data": [
+    {
+      "reviewId": 123,
+      "content": "정말 맛있는 위스키입니다!",
+      "authorId": 2,
+      "authorNickname": "위스키러버"
+    }
+  ]
+}
+```
+
+**차단 후:**
+```json
+{
+  "success": true,
+  "data": [
+    {
+      "reviewId": 123,
+      "content": "*** 차단된 사용자의 글입니다 ***",
+      "authorId": 2,
+      "authorNickname": "차단된 사용자",
+      "isBlocked": true,
+      "blockReason": "BLOCKED_USER"
+    }
+  ]
+}
+```
+
+---
+
+## 🔧 다른 컨트롤러에 적용하기
+
+### 1. Import 추가
+```java
+import app.bottlenote.global.annotation.BlockFilter;
+import app.bottlenote.global.annotation.BlockFilter.BlockType;
+```
+
+### 2. 어노테이션 적용
+```java
+// 댓글 목록 조회
+@BlockFilter(userField = "authorId", type = BlockType.BLUR)
+@GetMapping("/comments")
+public ResponseEntity<?> getComments() { ... }
+
+// 팔로워 목록 조회 (차단된 사용자 제외)
+@BlockFilter(userField = "userId", type = BlockType.EXCLUDE)
+@GetMapping("/followers")
+public ResponseEntity<?> getFollowers() { ... }
+
+// 마이페이지 접근 (차단된 사용자 접근 금지)
+@BlockFilter(userField = "userId", type = BlockType.ACCESS_DENY)
+@GetMapping("/mypage/{userId}")
+public ResponseEntity<?> getMyPage(@PathVariable Long userId) { ... }
+```
+
+---
+
+## ⚠️ 주의사항
+
+### 1. 현재 제한사항
+- **메모리 기반 저장**: 서버 재시작 시 차단 관계 초기화
+- **단순 객체 복사**: 복잡한 객체 구조는 블러 처리 제한
+- **필드명 의존**: 응답 DTO의 필드명이 정확해야 함
+
+### 2. 성능 고려사항
+- **익명 사용자**: 차단 로직 적용 안함 (성능 최적화)
+- **캐시 적용**: `@Cacheable`로 반복 조회 최적화
+- **로그 레벨**: 운영 시 DEBUG 로그 비활성화 권장
+
+### 3. 보안 고려사항
+- **클라이언트 검증**: 프론트엔드에서 추가 검증 필요
+- **API 접근 제어**: 차단된 사용자의 직접 API 호출 차단 고려
+
+---
+
+## 🔄 다음 단계 (실제 운영 환경)
+
+### 1. 데이터베이스 연동
+```sql
+CREATE TABLE user_block (
+    id BIGINT AUTO_INCREMENT PRIMARY KEY,
+    blocker_id BIGINT NOT NULL,
+    blocked_id BIGINT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE KEY uk_blocker_blocked (blocker_id, blocked_id)
+);
+```
+
+### 2. Redis 캐시 적용
+```yaml
+spring:
+  cache:
+    type: redis
+  redis:
+    host: localhost
+    port: 6379
+```
+
+### 3. 차단 관리 API 개발
+- 차단하기/해제하기 API
+- 차단 목록 조회 API
+- 차단 사유 관리
+
+### 4. 프론트엔드 연동
+- 블러 UI 컴포넌트
+- 차단 버튼 추가
+- 차단 목록 관리 페이지
+
+---
+
+## 🆘 문제 해결
+
+### Q: AOP가 적용되지 않음
+**A:** `@EnableAspectJAutoProxy` 확인 또는 Spring Boot의 자동 설정 확인
+
+### Q: 필드를 찾을 수 없다는 오류
+**A:** `userField` 값이 응답 DTO의 실제 필드명과 일치하는지 확인
+
+### Q: 블러 처리가 동작하지 않음
+**A:** 객체의 setter가 있는지, 또는 필드가 final이 아닌지 확인
+
+### Q: 성능이 느림
+**A:** 차단 목록이 많은 경우 배치 조회나 캐시 TTL 조정 고려
+
+---
+
+## 📞 연락처
+
+구현 과정에서 문의사항이나 개선 제안이 있으시면 언제든 연락주세요!
+
+- 기술 문의: 개발팀 채널
+- 기능 제안: 기획팀 채널
\ No newline at end of file
diff --git a/USER_BLOCK_IMPLEMENTATION.md b/USER_BLOCK_IMPLEMENTATION.md
new file mode 100644
index 000000000..6703b3756
--- /dev/null
+++ b/USER_BLOCK_IMPLEMENTATION.md
@@ -0,0 +1,687 @@
+# 🚫 Bottle Note 유저 차단 기능 구현 가이드
+
+## 📋 목차
+1. [현재 시스템 분석](#현재-시스템-분석)
+2. [차단 기능 구현 방안 비교](#차단-기능-구현-방안-비교)
+3. [추천 구현 방안: AOP 기반](#추천-구현-방안-aop-기반)
+4. [성능 최적화 전략](#성능-최적화-전략)
+5. [프론트엔드 연동 방안](#프론트엔드-연동-방안)
+6. [구현 단계별 가이드](#구현-단계별-가이드)
+
+---
+
+## 🔍 현재 시스템 분석
+
+### 차단 기능이 필요한 조회 지점들
+- **리뷰 목록/상세 조회** - 차단된 사용자의 리뷰 블러 처리
+- **리뷰 댓글 조회** - 차단된 사용자의 댓글 블러 처리  
+- **팔로워/팔로잉 목록** - 차단된 사용자 제외 또는 블러 표시
+- **마이페이지 접근** - 차단된 사용자의 마이페이지 접근 제한
+- **유저 검색/추천** - 차단된 사용자 제외
+
+### 현재 인증 시스템
+```java
+// 익명 사용자 처리
+Long currentUserId = SecurityContextUtil.getUserIdByContext().orElse(-1L);
+
+// 로그인 필수 처리
+Long currentUserId = SecurityContextUtil.getUserIdByContext()
+    .orElseThrow(() -> new UserException(REQUIRED_USER_ID));
+```
+
+---
+
+## ⚖️ 차단 기능 구현 방안 비교
+
+### 1️⃣ 방안 1: 데이터베이스 쿼리 수정
+
+#### 🎯 구현 방식
+```sql
+-- 기존 쿼리
+SELECT * FROM review WHERE alcohol_id = ?;
+
+-- 수정된 쿼리
+SELECT r.*, 
+       CASE WHEN ub.blocker_id IS NOT NULL THEN 1 ELSE 0 END as is_blocked
+FROM review r 
+LEFT JOIN user_block ub ON ub.blocker_id = ? AND ub.blocked_id = r.user_id
+WHERE r.alcohol_id = ?;
+```
+
+#### ✅ 장점
+- **가장 직관적인 방법**
+- **DB 레벨에서 처리**로 확실한 차단
+- **성능이 좋음** (한 번의 쿼리로 해결)
+
+#### ❌ 단점
+- **모든 쿼리를 수정해야 함** (50+ 개의 쿼리)
+- **기존 코드 대량 수정** 필요
+- **유지보수 복잡도 증가**
+- **테스트 케이스 대량 수정** 필요
+
+### 2️⃣ 방안 2: 서비스 레이어 후처리
+
+#### 🎯 구현 방식
+```java
+@Service
+public class ReviewService {
+    
+    public PageResponse<ReviewListResponse> getReviews(Long alcoholId, ...) {
+        // 기존 로직으로 데이터 조회
+        var reviews = reviewRepository.findByAlcoholId(alcoholId);
+        
+        // 차단 로직 후처리
+        var filteredReviews = blockFilterService.filterBlockedContent(
+            reviews, currentUserId, ReviewListResponse::getAuthorId
+        );
+        
+        return PageResponse.of(filteredReviews);
+    }
+}
+```
+
+#### ✅ 장점
+- **기존 Repository 코드 유지**
+- **비즈니스 로직과 차단 로직 분리**
+- **테스트하기 쉬움**
+
+#### ❌ 단점
+- **모든 서비스 메서드 수정** 필요
+- **중복 코드 발생** 가능성
+- **깜빡하기 쉬움** (새로운 기능 추가 시)
+
+### 3️⃣ 방안 3: AOP 기반 통합 처리 ⭐ **추천**
+
+#### 🎯 구현 방식
+```java
+// 컨트롤러에 어노테이션만 추가
+@BlockFilter(userField = "authorId", type = BlockType.BLUR)
+@GetMapping("/{alcoholId}")
+public ResponseEntity<?> getReviews(@PathVariable Long alcoholId, ...) {
+    // 기존 로직 그대로 유지 (수정 없음!)
+    return GlobalResponse.ok(reviewService.getReviews(alcoholId, request, currentUserId));
+}
+```
+
+#### ✅ 장점
+- **기존 코드 수정 최소화** (어노테이션만 추가)
+- **중앙 집중식 관리** (차단 로직이 한 곳에)
+- **깜빡할 염려 없음** (어노테이션으로 명시적)
+- **성능 영향 최소** (응답 후처리)
+- **테스트 용이** (AOP 로직 독립 테스트)
+- **확장성 좋음** (다양한 차단 타입 지원)
+
+#### ❌ 단점
+- **AOP 개념 이해** 필요
+- **디버깅이 약간 복잡**할 수 있음
+
+### 4️⃣ 방안 4: 프론트엔드 처리
+
+#### 🎯 구현 방식
+```javascript
+// 백엔드에서 차단 정보만 제공
+const reviews = await api.getReviews(alcoholId);
+const blockedUsers = await api.getBlockedUsers();
+
+// 프론트엔드에서 블러 처리
+const filteredReviews = reviews.map(review => 
+  blockedUsers.includes(review.authorId) 
+    ? { ...review, isBlocked: true }
+    : review
+);
+```
+
+#### ✅ 장점
+- **백엔드 코드 수정 없음**
+- **실시간 차단/해제** 가능
+
+#### ❌ 단점
+- **보안 취약** (클라이언트에서 우회 가능)
+- **네트워크 비용 증가**
+- **차단된 데이터도 전송**됨
+
+---
+
+## 🏆 추천 구현 방안: AOP 기반
+
+### 📐 아키텍처 설계
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Controller    │    │   AOP Aspect    │    │   Response      │
+│                 │    │                 │    │                 │
+│ @BlockFilter   ├────┤ BlockFilterAsp- ├────┤ 블러 처리된     │
+│ @GetMapping     │    │ ect             │    │ 응답 데이터     │
+│                 │    │                 │    │                 │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+          │                       │                       │
+          │                       │                       │
+          ▼                       ▼                       ▼
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Service       │    │ BlockCacheManager│    │   Frontend      │
+│   (기존 로직)   │    │                 │    │                 │
+│   수정 없음     │    │ Redis Cache     │    │ 블러 UI 처리    │
+│                 │    │                 │    │                 │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+```
+
+### 🔧 핵심 구현 코드
+
+#### 1. 차단 필터 어노테이션
+```java
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface BlockFilter {
+    BlockType type() default BlockType.BLUR;
+    String userField() default "authorId";  // 차단 대상 사용자 ID 필드명
+}
+
+public enum BlockType {
+    BLUR,        // 블러 처리 (내용 가림)
+    EXCLUDE,     // 완전 제외 (목록에서 제거)
+    ACCESS_DENY  // 접근 차단 (403 에러)
+}
+```
+
+#### 2. AOP 어스펙트
+```java
+@Component
+@Aspect
+public class BlockFilterAspect {
+    
+    private final BlockService blockService;
+    
+    @Around("@annotation(blockFilter)")
+    public Object applyBlockFilter(ProceedingJoinPoint joinPoint, BlockFilter blockFilter) {
+        // 1. 기존 로직 실행 (수정 없음)
+        Object result = joinPoint.proceed();
+        
+        // 2. 현재 사용자 ID 확인
+        Long currentUserId = SecurityContextUtil.getUserIdByContext().orElse(-1L);
+        if (currentUserId == -1L) {
+            return result; // 익명 사용자는 차단 로직 적용 안함
+        }
+        
+        // 3. 응답 데이터에 차단 로직 적용
+        return applyBlockLogic(result, currentUserId, blockFilter);
+    }
+    
+    private Object applyBlockLogic(Object result, Long currentUserId, BlockFilter filter) {
+        // ResponseEntity에서 실제 데이터 추출
+        if (result instanceof ResponseEntity) {
+            ResponseEntity<?> response = (ResponseEntity<?>) result;
+            GlobalResponse globalResponse = (GlobalResponse) response.getBody();
+            Object data = globalResponse.getData();
+            
+            // 리스트 데이터 처리
+            if (data instanceof List) {
+                List<?> list = (List<?>) data;
+                List<?> filteredList = processListData(list, currentUserId, filter);
+                return ResponseEntity.ok(GlobalResponse.success(filteredList));
+            }
+            
+            // 단일 객체 데이터 처리
+            Object filteredData = processSingleData(data, currentUserId, filter);
+            return ResponseEntity.ok(GlobalResponse.success(filteredData));
+        }
+        
+        return result;
+    }
+}
+```
+
+#### 3. 차단 서비스
+```java
+@Service
+public class BlockService {
+    
+    private final BlockRepository blockRepository;
+    private final RedisTemplate<String, Set<Long>> redisTemplate;
+    
+    @Cacheable(value = "blocked_users", key = "#userId")
+    public Set<Long> getBlockedUserIds(Long userId) {
+        return blockRepository.findBlockedUserIdsByBlockerId(userId);
+    }
+    
+    public <T> T applyBlockFilter(T item, Long currentUserId, String userField, BlockType type) {
+        Set<Long> blockedUsers = getBlockedUserIds(currentUserId);
+        Long authorId = extractUserIdFromObject(item, userField);
+        
+        if (blockedUsers.contains(authorId)) {
+            switch (type) {
+                case BLUR:
+                    return blurContent(item);
+                case EXCLUDE:
+                    return null; // 리스트에서 제거됨
+                case ACCESS_DENY:
+                    throw new BlockedException("차단된 사용자의 컨텐츠입니다.");
+            }
+        }
+        
+        return item;
+    }
+}
+```
+
+### 🎨 사용 예시
+
+```java
+// 리뷰 목록 조회 - 차단된 사용자 리뷰 블러 처리
+@BlockFilter(userField = "authorId", type = BlockType.BLUR)
+@GetMapping("/{alcoholId}")
+public ResponseEntity<?> getReviews(@PathVariable Long alcoholId, ...) {
+    // 기존 코드 그대로 유지
+}
+
+// 팔로워 목록 조회 - 차단된 사용자 완전 제외
+@BlockFilter(userField = "userId", type = BlockType.EXCLUDE)
+@GetMapping("/{targetUserId}/follower-list")
+public ResponseEntity<?> findFollowerList(@PathVariable Long targetUserId, ...) {
+    // 기존 코드 그대로 유지
+}
+
+// 마이페이지 접근 - 차단된 사용자 접근 차단
+@BlockFilter(userField = "userId", type = BlockType.ACCESS_DENY)
+@GetMapping("/{userId}")
+public ResponseEntity<?> getMyPage(@PathVariable Long userId) {
+    // 기존 코드 그대로 유지
+}
+```
+
+---
+
+## ⚡ 성능 최적화 전략
+
+### 1️⃣ Redis 캐싱 전략
+
+```java
+@Component
+public class BlockCacheManager {
+    
+    // 사용자별 차단 목록 캐싱 (TTL: 1시간)
+    @Cacheable(value = "blocked_users", key = "#userId", unless = "#userId == -1")
+    public Set<Long> getBlockedUserIds(Long userId) {
+        return blockRepository.findBlockedUserIdsByBlockerId(userId);
+    }
+    
+    // 차단 관계 변경 시 캐시 무효화
+    @CacheEvict(value = "blocked_users", key = "#userId")
+    public void evictBlockCache(Long userId) {
+        log.info("차단 캐시 무효화: userId={}", userId);
+    }
+    
+    // 배치로 여러 사용자의 차단 목록 조회
+    public Map<Long, Set<Long>> getBulkBlockedUsers(Set<Long> userIds) {
+        return userIds.stream()
+            .filter(id -> id != -1L)  // 익명 사용자 제외
+            .collect(Collectors.toMap(
+                Function.identity(),
+                this::getBlockedUserIds
+            ));
+    }
+}
+```
+
+### 2️⃣ 데이터베이스 최적화
+
+```sql
+-- 차단 관계 테이블
+CREATE TABLE user_block (
+    id BIGINT AUTO_INCREMENT PRIMARY KEY,
+    blocker_id BIGINT NOT NULL COMMENT '차단한 사용자',
+    blocked_id BIGINT NOT NULL COMMENT '차단당한 사용자',
+    block_type VARCHAR(20) DEFAULT 'FULL',
+    reason VARCHAR(255),
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE KEY uk_blocker_blocked (blocker_id, blocked_id)
+);
+
+-- 성능 최적화 인덱스
+CREATE INDEX idx_user_block_blocker ON user_block(blocker_id);
+CREATE INDEX idx_user_block_blocked ON user_block(blocked_id);
+```
+
+### 3️⃣ 성능 비교 분석
+
+| 방식 | DB 쿼리 횟수 | 응답 시간 | 메모리 사용량 | 유지보수성 |
+|------|-------------|-----------|--------------|------------|
+| **쿼리 수정** | 1회 | 50ms | 낮음 | ⭐⭐ |
+| **서비스 후처리** | 2회 | 80ms | 중간 | ⭐⭐⭐ |
+| **AOP (캐시 적용)** | 1회 + 캐시 | 60ms | 중간 | ⭐⭐⭐⭐⭐ |
+| **프론트엔드** | 2회 | 100ms | 높음 | ⭐ |
+
+---
+
+## 🎭 프론트엔드 연동 방안
+
+### 📡 API 응답 형식
+
+#### 기존 응답
+```json
+{
+  "success": true,
+  "data": [
+    {
+      "reviewId": 123,
+      "content": "정말 맛있는 위스키입니다!",
+      "authorNickname": "위스키러버",
+      "authorProfileImage": "https://...",
+      "rating": 4.5,
+      "createdAt": "2024-01-15T10:30:00"
+    }
+  ]
+}
+```
+
+#### 차단 적용 후 응답
+```json
+{
+  "success": true,
+  "data": [
+    {
+      "reviewId": 123,
+      "content": "*** 차단된 사용자의 리뷰입니다 ***",
+      "authorNickname": "차단된 사용자",
+      "authorProfileImage": null,
+      "rating": 4.5,
+      "createdAt": "2024-01-15T10:30:00",
+      "isBlocked": true,
+      "blockReason": "BLOCKED_USER"
+    }
+  ]
+}
+```
+
+### 🎨 프론트엔드 UI 컴포넌트
+
+#### React 예시
+```tsx
+interface ReviewCardProps {
+  review: ReviewResponse;
+}
+
+const ReviewCard: React.FC<ReviewCardProps> = ({ review }) => {
+  const [showBlocked, setShowBlocked] = useState(false);
+  
+  if (review.isBlocked && !showBlocked) {
+    return (
+      <div className="review-card blocked">
+        <div className="blur-overlay">
+          <div className="blocked-message">
+            <Icon name="block" />
+            <span>차단된 사용자의 리뷰</span>
+          </div>
+          <button 
+            className="show-content-btn"
+            onClick={() => setShowBlocked(true)}
+          >
+            내용 보기
+          </button>
+        </div>
+      </div>
+    );
+  }
+  
+  return (
+    <div className={`review-card ${review.isBlocked ? 'shown-blocked' : 'normal'}`}>
+      <div className="review-header">
+        <img src={review.authorProfileImage} alt="프로필" />
+        <span className="nickname">{review.authorNickname}</span>
+        <Rating value={review.rating} />
+      </div>
+      <div className="review-content">
+        {review.content}
+      </div>
+      {review.isBlocked && (
+        <div className="blocked-indicator">
+          <span>차단된 사용자의 컨텐츠</span>
+          <button onClick={() => setShowBlocked(false)}>숨기기</button>
+        </div>
+      )}
+    </div>
+  );
+};
+```
+
+#### CSS 스타일
+```css
+.review-card.blocked {
+  position: relative;
+  filter: blur(5px);
+  opacity: 0.6;
+}
+
+.blur-overlay {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0, 0, 0, 0.8);
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  backdrop-filter: blur(10px);
+}
+
+.blocked-message {
+  color: white;
+  text-align: center;
+  margin-bottom: 16px;
+}
+
+.show-content-btn {
+  background: #007bff;
+  color: white;
+  border: none;
+  padding: 8px 16px;
+  border-radius: 4px;
+  cursor: pointer;
+}
+
+.blocked-indicator {
+  background: #fff3cd;
+  border: 1px solid #ffeaa7;
+  padding: 8px;
+  border-radius: 4px;
+  margin-top: 8px;
+  font-size: 12px;
+  color: #856404;
+}
+```
+
+---
+
+## 📋 구현 단계별 가이드
+
+### 🏗️ Phase 1: 기반 구조 구축
+
+#### 1.1 차단 도메인 모델 생성
+```java
+// 1. Entity 생성
+@Entity
+@Table(name = "user_block")
+public class UserBlock extends BaseTimeEntity {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+    
+    @Column(name = "blocker_id", nullable = false)
+    private Long blockerId;
+    
+    @Column(name = "blocked_id", nullable = false)
+    private Long blockedId;
+    
+    @Enumerated(EnumType.STRING)
+    private BlockType blockType = BlockType.FULL;
+    
+    private String reason;
+}
+
+// 2. Repository 생성
+public interface BlockRepository extends JpaRepository<UserBlock, Long> {
+    Set<Long> findBlockedIdsByBlockerId(Long blockerId);
+    boolean existsByBlockerIdAndBlockedId(Long blockerId, Long blockedId);
+}
+
+// 3. Service 생성
+@Service
+public class BlockService {
+    public void createBlock(Long blockerId, Long blockedId) { ... }
+    public void removeBlock(Long blockerId, Long blockedId) { ... }
+    public Set<Long> getBlockedUserIds(Long userId) { ... }
+}
+```
+
+#### 1.2 캐시 설정
+```yaml
+# application.yml
+spring:
+  cache:
+    type: caffeine
+    caffeine:
+      spec: maximumSize=10000,expireAfterWrite=1h
+```
+
+### 🔧 Phase 2: AOP 구현
+
+#### 2.1 어노테이션 및 AOP 구현
+```java
+// 앞서 제시한 코드 구현
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface BlockFilter { ... }
+
+@Component
+@Aspect
+public class BlockFilterAspect { ... }
+```
+
+#### 2.2 테스트 코드 작성
+```java
+@ExtendWith(MockitoExtension.class)
+class BlockFilterAspectTest {
+    
+    @Mock
+    private BlockService blockService;
+    
+    @InjectMocks
+    private BlockFilterAspect blockFilterAspect;
+    
+    @Test
+    void 차단된_사용자_리뷰_블러_처리_테스트() {
+        // Given
+        Long currentUserId = 1L;
+        Long blockedUserId = 2L;
+        when(blockService.getBlockedUserIds(currentUserId))
+            .thenReturn(Set.of(blockedUserId));
+        
+        // When & Then
+        // AOP 로직 테스트
+    }
+}
+```
+
+### 📱 Phase 3: 프론트엔드 연동
+
+#### 3.1 API 클라이언트 수정
+```typescript
+// API 타입 정의 확장
+interface BaseResponse {
+  isBlocked?: boolean;
+  blockReason?: string;
+}
+
+interface ReviewResponse extends BaseResponse {
+  reviewId: number;
+  content: string;
+  authorNickname: string;
+  // ... 기타 필드
+}
+```
+
+#### 3.2 UI 컴포넌트 개발
+```tsx
+// 앞서 제시한 React 컴포넌트 구현
+```
+
+### 🚀 Phase 4: 점진적 적용
+
+#### 4.1 우선순위별 적용
+1. **High Priority**: 리뷰 조회, 댓글 조회
+2. **Medium Priority**: 팔로우 목록, 마이페이지
+3. **Low Priority**: 검색 결과, 추천 목록
+
+#### 4.2 모니터링 설정
+```java
+@Component
+public class BlockMetrics {
+    private final MeterRegistry meterRegistry;
+    
+    public void recordBlockFilter(String endpoint, BlockType type, int blockedCount) {
+        Counter.builder("block.filter.applied")
+            .tag("endpoint", endpoint)
+            .tag("type", type.name())
+            .register(meterRegistry)
+            .increment(blockedCount);
+    }
+}
+```
+
+### 📊 Phase 5: 성능 모니터링
+
+#### 5.1 성능 지표 수집
+- 차단 캐시 히트율
+- 응답 시간 변화
+- 메모리 사용량 변화
+
+#### 5.2 알람 설정
+```yaml
+# Prometheus 규칙
+groups:
+  - name: block_system
+    rules:
+      - alert: BlockCacheHitRateLow
+        expr: block_cache_hit_rate < 0.8
+        for: 5m
+        annotations:
+          summary: "차단 캐시 히트율이 낮습니다"
+```
+
+---
+
+## 🎯 결론
+
+### ✨ 왜 AOP 방식을 추천하는가?
+
+1. **최소 침습적** - 기존 코드를 거의 수정하지 않음
+2. **중앙 집중식** - 차단 로직이 한 곳에서 관리됨  
+3. **확장 가능** - 다양한 차단 타입을 쉽게 추가
+4. **성능 효율적** - 캐시를 통한 최적화
+5. **테스트 용이** - 독립적인 테스트 가능
+
+### 🚀 기대 효과
+
+- **개발 시간 단축**: 기존 쿼리 수정 불필요
+- **유지보수성 향상**: 차단 로직 중앙화
+- **성능 안정성**: 캐시 기반 최적화
+- **사용자 경험 개선**: 세밀한 차단 옵션 제공
+
+### 📅 구현 일정 (예상)
+
+- **Week 1**: Phase 1-2 (기반 구조 + AOP)
+- **Week 2**: Phase 3 (프론트엔드 연동)  
+- **Week 3**: Phase 4-5 (점진적 적용 + 모니터링)
+
+**총 예상 개발 기간: 3주**
+
+---
+
+## 📞 문의 및 지원
+
+차단 기능 구현 과정에서 문의사항이 있으시면 언제든 연락주세요!
+
+- 기술적 문의: 개발팀 채널
+- 기획 관련: 기획팀 채널  
+- 성능 관련: DevOps 팀 채널
\ No newline at end of file
diff --git a/git.environment-variables b/git.environment-variables
index 2bf643353..b146e17ba 160000
--- a/git.environment-variables
+++ b/git.environment-variables
@@ -1 +1 @@
-Subproject commit 2bf6433534696b910c69c8237689ce9753e52f9a
+Subproject commit b146e17baab4747e4f7045340b8cb13636db09e8
diff --git "a/http/block/01-\354\260\250\353\213\250_\352\264\200\352\263\204_\354\203\235\354\204\261.http" "b/http/block/01-\354\260\250\353\213\250_\352\264\200\352\263\204_\354\203\235\354\204\261.http"
new file mode 100644
index 000000000..29264d208
--- /dev/null
+++ "b/http/block/01-\354\260\250\353\213\250_\352\264\200\352\263\204_\354\203\235\354\204\261.http"
@@ -0,0 +1,31 @@
+### 토큰 발급 (선택사항 - 토큰이 필요한 경우)
+POST {{host}}/api/v1/oauth/login
+Content-Type: application/json
+
+{
+  "email": "dev.bottle-note@gmail.com",
+  "socialType": "GOOGLE",
+  "gender": "MALE",
+  "age": 25
+}
+
+> {%
+    //토큰을 전역변수로 저장
+    client.global.set("accessToken", response.body.data.accessToken);
+%}
+
+### 차단 관계 생성 테스트
+POST {{host}}/api/v1/test/block/add?blockerId=1&blockedId=2&reason=테스트 차단
+Content-Type: application/json
+
+### 차단 관계 생성 (기본 사유)
+POST {{host}}/api/v1/test/block/add?blockerId=1&blockedId=3
+Content-Type: application/json
+
+### 차단 관계 생성 (커스텀 사유)
+POST {{host}}/api/v1/test/block/add?blockerId=2&blockedId=1&reason=부적절한 댓글
+Content-Type: application/json
+
+### 차단 관계 생성 실패 케이스 (동일 사용자)  
+POST {{host}}/api/v1/test/block/add?blockerId=1&blockedId=1&reason=자기 자신 차단
+Content-Type: application/json
\ No newline at end of file
diff --git "a/http/block/02-\354\260\250\353\213\250_\354\227\254\353\266\200_\355\231\225\354\235\270.http" "b/http/block/02-\354\260\250\353\213\250_\354\227\254\353\266\200_\355\231\225\354\235\270.http"
new file mode 100644
index 000000000..1d67b2c9d
--- /dev/null
+++ "b/http/block/02-\354\260\250\353\213\250_\354\227\254\353\266\200_\355\231\225\354\235\270.http"
@@ -0,0 +1,15 @@
+### 차단 여부 확인 (차단된 경우)
+GET {{host}}/api/v1/test/block/check?blockerId=1&blockedId=2
+Content-Type: application/json
+
+### 차단 여부 확인 (차단되지 않은 경우)
+GET {{host}}/api/v1/test/block/check?blockerId=1&blockedId=5
+Content-Type: application/json
+
+### 차단 여부 확인 (반대 방향)
+GET {{host}}/api/v1/test/block/check?blockerId=2&blockedId=1
+Content-Type: application/json
+
+### 차단 여부 확인 (존재하지 않는 사용자)
+GET {{host}}/api/v1/test/block/check?blockerId=999&blockedId=888
+Content-Type: application/json
\ No newline at end of file
diff --git "a/http/block/03-\354\260\250\353\213\250_\353\252\251\353\241\235_\354\241\260\355\232\214.http" "b/http/block/03-\354\260\250\353\213\250_\353\252\251\353\241\235_\354\241\260\355\232\214.http"
new file mode 100644
index 000000000..fc73a52d8
--- /dev/null
+++ "b/http/block/03-\354\260\250\353\213\250_\353\252\251\353\241\235_\354\241\260\355\232\214.http"
@@ -0,0 +1,15 @@
+### 차단 목록 조회 (차단한 사용자들이 있는 경우)
+GET {{host}}/api/v1/test/block/list/1
+Content-Type: application/json
+
+### 차단 목록 조회 (차단한 사용자가 없는 경우)  
+GET {{host}}/api/v1/test/block/list/10
+Content-Type: application/json
+
+### 차단 목록 조회 (여러 사용자를 차단한 경우)
+GET {{host}}/api/v1/test/block/list/2
+Content-Type: application/json
+
+### 차단 목록 조회 (존재하지 않는 사용자)
+GET {{host}}/api/v1/test/block/list/999
+Content-Type: application/json
\ No newline at end of file
diff --git "a/http/block/04-\354\260\250\353\213\250_\355\206\265\352\263\204_\354\241\260\355\232\214.http" "b/http/block/04-\354\260\250\353\213\250_\355\206\265\352\263\204_\354\241\260\355\232\214.http"
new file mode 100644
index 000000000..a477b571c
--- /dev/null
+++ "b/http/block/04-\354\260\250\353\213\250_\355\206\265\352\263\204_\354\241\260\355\232\214.http"
@@ -0,0 +1,15 @@
+### 차단 통계 조회 (차단 내역이 있는 사용자)
+GET {{host}}/api/v1/test/block/statistics/1
+Content-Type: application/json
+
+### 차단 통계 조회 (차단 내역이 없는 사용자)
+GET {{host}}/api/v1/test/block/statistics/10
+Content-Type: application/json
+
+### 차단 통계 조회 (많은 차단 내역이 있는 사용자)
+GET {{host}}/api/v1/test/block/statistics/2
+Content-Type: application/json
+
+### 차단 통계 조회 (존재하지 않는 사용자)
+GET {{host}}/api/v1/test/block/statistics/999
+Content-Type: application/json
\ No newline at end of file
diff --git "a/http/block/05-\354\260\250\353\213\250_\352\264\200\352\263\204_\355\225\264\354\240\234.http" "b/http/block/05-\354\260\250\353\213\250_\352\264\200\352\263\204_\355\225\264\354\240\234.http"
new file mode 100644
index 000000000..bed251f37
--- /dev/null
+++ "b/http/block/05-\354\260\250\353\213\250_\352\264\200\352\263\204_\355\225\264\354\240\234.http"
@@ -0,0 +1,15 @@
+### 차단 관계 해제 (기존 차단 관계)
+DELETE {{host}}/api/v1/test/block/remove?blockerId=1&blockedId=2
+Content-Type: application/json
+
+### 차단 관계 해제 (또 다른 차단 관계)
+DELETE {{host}}/api/v1/test/block/remove?blockerId=1&blockedId=3
+Content-Type: application/json
+
+### 차단 관계 해제 (존재하지 않는 차단 관계)
+DELETE {{host}}/api/v1/test/block/remove?blockerId=1&blockedId=10
+Content-Type: application/json
+
+### 차단 관계 해제 (반대 방향)
+DELETE {{host}}/api/v1/test/block/remove?blockerId=2&blockedId=1
+Content-Type: application/json
\ No newline at end of file
diff --git "a/http/block/06-\354\260\250\353\213\250_\355\225\204\355\204\260_\355\205\214\354\212\244\355\212\270.http" "b/http/block/06-\354\260\250\353\213\250_\355\225\204\355\204\260_\355\205\214\354\212\244\355\212\270.http"
new file mode 100644
index 000000000..ac175c16e
--- /dev/null
+++ "b/http/block/06-\354\260\250\353\213\250_\355\225\204\355\204\260_\355\205\214\354\212\244\355\212\270.http"
@@ -0,0 +1,47 @@
+### 테스트 시나리오 준비 - 차단 관계 생성
+# 먼저 사용자 1이 사용자 2,3을 차단하도록 설정
+POST {{host}}/api/v1/test/block/add?blockerId=1&blockedId=2&reason=테스트 차단
+Content-Type: application/json
+
+###
+POST {{host}}/api/v1/test/block/add?blockerId=1&blockedId=3&reason=테스트 차단
+Content-Type: application/json
+
+### 1. 차단 필터 테스트 (차단하지 않은 사용자로 요청)
+# 사용자 5는 아무도 차단하지 않았으므로 모든 리뷰가 그대로 보임
+GET {{host}}/api/v1/test/block/test-data/5
+Content-Type: application/json
+X-User-Id: 5
+
+### 2. 차단 필터 테스트 (차단한 사용자가 있는 경우)
+# 사용자 1이 사용자 2,3을 차단했으므로 해당 리뷰가 마스킹되어야 함
+GET {{host}}/api/v1/test/block/test-data/1
+Content-Type: application/json
+X-User-Id: 1
+
+### 3. 차단 필터 테스트 (다른 사용자로 요청)
+# 사용자 4는 아무도 차단하지 않았으므로 모든 리뷰가 그대로 보임  
+GET {{host}}/api/v1/test/block/test-data/4
+Content-Type: application/json
+X-User-Id: 4
+
+### 4. 차단 여부 확인 (사전 확인)
+# 사용자 1이 사용자 2를 차단했는지 확인
+GET {{host}}/api/v1/test/block/check?blockerId=1&blockedId=2
+Content-Type: application/json
+
+### 5. 차단 목록 확인
+# 사용자 1의 차단 목록 확인 (2,3이 나와야 함)
+GET {{host}}/api/v1/test/block/list/1
+Content-Type: application/json
+
+### 6. 차단 해제 후 재테스트
+# 사용자 1이 사용자 2의 차단을 해제
+DELETE {{host}}/api/v1/test/block/remove?blockerId=1&blockedId=2
+Content-Type: application/json
+
+###
+# 차단 해제 후 다시 테스트 (사용자 2의 리뷰가 다시 보여야 함)
+GET {{host}}/api/v1/test/block/test-data/1
+Content-Type: application/json
+X-User-Id: 1
\ No newline at end of file
diff --git "a/http/block/07-\354\240\204\354\262\264_\354\264\210\352\270\260\355\231\224_\355\205\214\354\212\244\355\212\270.http" "b/http/block/07-\354\240\204\354\262\264_\354\264\210\352\270\260\355\231\224_\355\205\214\354\212\244\355\212\270.http"
new file mode 100644
index 000000000..66614909a
--- /dev/null
+++ "b/http/block/07-\354\240\204\354\262\264_\354\264\210\352\270\260\355\231\224_\355\205\214\354\212\244\355\212\270.http"
@@ -0,0 +1,6 @@
+### 전체 차단 관계 초기화 (비활성화된 기능)
+DELETE {{host}}/api/v1/test/block/clear
+Content-Type: application/json
+
+### 참고: 이 기능은 DB 기반으로 변경되어 비활성화되었습니다.
+### 실제로는 개별 차단 해제를 사용해야 합니다.
\ No newline at end of file
diff --git a/http/block/README.md b/http/block/README.md
new file mode 100644
index 000000000..66bc3a1b0
--- /dev/null
+++ b/http/block/README.md
@@ -0,0 +1,107 @@
+# Block API 테스트 가이드
+
+이 디렉토리는 `BlockTestController`의 차단 기능을 테스트하기 위한 HTTP 파일들을 포함합니다.
+
+## 🔧 사전 준비
+
+1. **환경 설정**: 이 컨트롤러는 `local`, `dev`, `test` 환경에서만 동작합니다 (`prod` 환경에서는 비활성화)
+2. **환경 변수**: IntelliJ HTTP Client에서 `http-client.env.json` 파일의 환경을 선택해야 합니다
+   - `local`: http://localhost:30001
+   - `dev`: http://localhost:30001  
+   - `prod`: https://api.bottle-note.com/
+3. **인증**: Block API (`/api/v1/test/**`)는 인증이 필요하지 않습니다 (Spring Security에서 `permitAll()` 설정)
+4. **토큰 (선택사항)**: 필요시 01번 파일의 토큰 발급 API를 사용하여 `accessToken` 변수를 설정할 수 있습니다
+
+## 📁 테스트 파일 구성
+
+### 01-차단_관계_생성.http
+- **목적**: 차단 관계를 생성하는 API 테스트
+- **엔드포인트**: `POST /api/v1/test/block/add`
+- **파라미터**:
+  - `blockerId`: 차단하는 사용자 ID (필수)
+  - `blockedId`: 차단당하는 사용자 ID (필수)  
+  - `reason`: 차단 사유 (선택, 기본값: "테스트 차단")
+
+### 02-차단_여부_확인.http
+- **목적**: 두 사용자 간 차단 여부를 확인하는 API 테스트
+- **엔드포인트**: `GET /api/v1/test/block/check`
+- **파라미터**:
+  - `blockerId`: 차단하는 사용자 ID
+  - `blockedId`: 차단당하는 사용자 ID
+
+### 03-차단_목록_조회.http
+- **목적**: 특정 사용자가 차단한 사용자 목록을 조회하는 API 테스트
+- **엔드포인트**: `GET /api/v1/test/block/list/{userId}`
+- **경로 변수**: `userId` - 차단 목록을 조회할 사용자 ID
+
+### 04-차단_통계_조회.http
+- **목적**: 특정 사용자의 차단 통계를 조회하는 API 테스트
+- **엔드포인트**: `GET /api/v1/test/block/statistics/{userId}`
+- **경로 변수**: `userId` - 통계를 조회할 사용자 ID
+
+### 05-차단_관계_해제.http
+- **목적**: 차단 관계를 해제하는 API 테스트
+- **엔드포인트**: `DELETE /api/v1/test/block/remove`
+- **파라미터**:
+  - `blockerId`: 차단을 해제할 사용자 ID
+  - `blockedId`: 차단 해제 대상 사용자 ID
+
+### 06-차단_필터_테스트.http
+- **목적**: `@BlockFilter` 어노테이션이 적용된 API에서 차단된 사용자의 데이터가 필터링되는지 테스트
+- **엔드포인트**: `GET /api/v1/test/block/test-data/{userId}`
+- **경로 변수**: `userId` - 경로의 사용자 ID (실제로는 사용되지 않음)
+- **헤더**: `X-User-Id` - 실제 요청하는 사용자 ID (테스트용 SecurityContext 설정)
+- **특징**: 
+  - 실제 리뷰 구조와 유사한 응답 데이터 제공
+  - 차단한 사용자들의 데이터는 "차단된 사용자의 글입니다"로 마스킹됨
+  - 차단된 사용자의 닉네임이 "차단된 사용자"로 변경됨
+  - 프로필 이미지도 null로 처리됨
+
+### 07-전체_초기화_테스트.http
+- **목적**: 전체 차단 관계 초기화 API 테스트 (현재 비활성화됨)
+- **엔드포인트**: `DELETE /api/v1/test/block/clear`
+- **참고**: DB 기반으로 변경되어 안전상의 이유로 비활성화된 기능입니다
+
+## 🚀 테스트 시나리오 예시
+
+### 기본 시나리오
+1. **차단 관계 생성**: 사용자 1이 사용자 2를 차단
+2. **차단 여부 확인**: 1 → 2 차단 확인 (true), 2 → 1 차단 확인 (false)
+3. **차단 목록 조회**: 사용자 1의 차단 목록에 사용자 2가 포함되는지 확인
+4. **차단 필터 테스트**: 사용자 1로 요청 시 사용자 2의 데이터가 필터링되는지 확인
+5. **차단 관계 해제**: 사용자 1이 사용자 2의 차단을 해제
+6. **차단 여부 재확인**: 1 → 2 차단 확인 (false)
+
+### 고급 시나리오
+1. **상호 차단**: 사용자 1과 사용자 2가 서로 차단
+2. **다중 차단**: 사용자 1이 여러 사용자(2, 3, 4)를 차단
+3. **통계 확인**: 각 사용자별 차단 통계 조회
+4. **필터링 확인**: 차단된 사용자들의 데이터가 모두 필터링되는지 확인
+
+## ⚠️ 주의사항
+
+1. **환경 제한**: `prod` 환경에서는 이 API들을 사용할 수 없습니다
+2. **데이터 정합성**: 실제 운영 데이터와 연동되므로 테스트 시 주의가 필요합니다
+3. **사용자 ID**: 존재하지 않는 사용자 ID로 테스트할 경우 예외가 발생할 수 있습니다
+4. **전체 초기화**: 안전상의 이유로 비활성화되어 있으므로 개별 해제를 사용해야 합니다
+
+## 🔍 응답 형태
+
+모든 API는 `GlobalResponse` 형태로 응답합니다:
+
+```json
+{
+  "success": true,
+  "message": "성공 메시지",
+  "data": "응답 데이터"
+}
+```
+
+실패 시:
+```json
+{
+  "success": false,
+  "message": "실패 메시지",
+  "data": null
+}
+```
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/global/annotation/BlockFilter.java b/src/main/java/app/bottlenote/global/annotation/BlockFilter.java
new file mode 100644
index 000000000..c19ad46d5
--- /dev/null
+++ b/src/main/java/app/bottlenote/global/annotation/BlockFilter.java
@@ -0,0 +1,26 @@
+package app.bottlenote.global.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 차단된 사용자의 컨텐츠를 "차단된 사용자의 글입니다"로 처리하는 어노테이션
+ * <p>
+ * 사용 예시:
+ * @BlockFilter(userField = "authorId")
+ * @GetMapping("/reviews") public ResponseEntity<?> getReviews() { ... }
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface BlockFilter {
+
+	/**
+	 * 응답 객체에서 사용자 ID를 추출할 필드명
+	 * 예: "authorId", "userId", "writerId"
+	 *
+	 * @return 사용자 ID 필드명
+	 */
+	String userField() default "authorId";
+}
diff --git a/src/main/java/app/bottlenote/global/aspect/BlockFilterAspect.java b/src/main/java/app/bottlenote/global/aspect/BlockFilterAspect.java
new file mode 100644
index 000000000..ace2aaa1f
--- /dev/null
+++ b/src/main/java/app/bottlenote/global/aspect/BlockFilterAspect.java
@@ -0,0 +1,228 @@
+package app.bottlenote.global.aspect;
+
+import app.bottlenote.global.annotation.BlockFilter;
+import app.bottlenote.global.data.response.GlobalResponse;
+import app.bottlenote.global.security.SecurityContextUtil;
+import app.bottlenote.global.service.BlockService;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Field;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * 차단 필터 AOP 클래스
+ *
+ * @BlockFilter 어노테이션이 붙은 메서드의 응답을 가로채서
+ * 차단된 사용자의 컨텐츠를 필터링합니다.
+ */
+@Slf4j
+@Aspect
+@Component
+@RequiredArgsConstructor
+public class BlockFilterAspect {
+
+	private final BlockService blockService;
+	private final ObjectMapper objectMapper;
+
+	/**
+	 * @BlockFilter 어노테이션이 붙은 메서드를 Around 어드바이스로 처리
+	 */
+	@Around("@annotation(blockFilter)")
+	public Object applyBlockFilter(ProceedingJoinPoint joinPoint, BlockFilter blockFilter) throws Throwable {
+
+		// 1. 원본 메서드 실행
+		Object result = joinPoint.proceed();
+
+		// 2. 현재 사용자 ID 확인
+		Long currentUserId = SecurityContextUtil.getUserIdByContext().orElse(-1L);
+
+		if (currentUserId == -1L) {
+			// 익명 사용자는 차단 로직 적용하지 않음
+			return result;
+		}
+
+		// 3. 차단된 사용자 목록 조회
+		Set<Long> blockedUserIds = blockService.getBlockedUserIds(currentUserId);
+
+		if (blockedUserIds.isEmpty()) {
+			return result;
+		}
+
+		// 4. 응답 데이터에 차단 로직 적용 (항상 블러 처리)
+		return applyBlockFilter(result, blockedUserIds, blockFilter.userField());
+	}
+
+	/**
+	 * 응답 데이터에 차단 로직을 적용하는 메서드 (단순 블러 처리)
+	 */
+	private Object applyBlockFilter(Object result, Set<Long> blockedUserIds, String userField) {
+
+		if (!(result instanceof ResponseEntity)) {
+			return result;
+		}
+
+		ResponseEntity<?> responseEntity = (ResponseEntity<?>) result;
+		Object body = responseEntity.getBody();
+
+		if (!(body instanceof GlobalResponse)) {
+			return result;
+		}
+
+		GlobalResponse globalResponse = (GlobalResponse) body;
+		Object data = globalResponse.getData();
+
+		if (data == null) {
+			return result;
+		}
+
+		// 데이터 타입에 따른 블러 처리
+		Object filteredData;
+		if (data instanceof List) {
+			filteredData = blurListData((List<?>) data, blockedUserIds, userField);
+		} else {
+			filteredData = blurSingleData(data, blockedUserIds, userField);
+		}
+
+		// 블러 처리된 데이터로 새로운 응답 생성
+		GlobalResponse filteredResponse = GlobalResponse.success(filteredData);
+		return ResponseEntity.ok(filteredResponse);
+	}
+
+	/**
+	 * List 형태의 데이터 블러 처리
+	 */
+	@SuppressWarnings("unchecked")
+	private List<?> blurListData(List<?> dataList, Set<Long> blockedUserIds, String userField) {
+		return dataList.stream()
+				.map(item -> blurItemIfBlocked(item, blockedUserIds, userField))
+				.collect(Collectors.toList());
+	}
+
+	/**
+	 * 단일 객체 데이터 블러 처리
+	 */
+	private Object blurSingleData(Object data, Set<Long> blockedUserIds, String userField) {
+		return blurItemIfBlocked(data, blockedUserIds, userField);
+	}
+
+	/**
+	 * 개별 항목 차단 여부 확인 후 블러 처리
+	 */
+	private Object blurItemIfBlocked(Object item, Set<Long> blockedUserIds, String userField) {
+		if (item == null) {
+			return item;
+		}
+
+		// 사용자 ID 추출
+		Long userId = extractUserIdFromObject(item, userField);
+
+		if (userId == null || !blockedUserIds.contains(userId)) {
+			return item; // 차단된 사용자가 아니면 원본 반환
+		}
+
+		// 차단된 사용자면 블러 처리
+		return blurContent(item);
+	}
+
+	/**
+	 * 객체에서 사용자 ID를 추출하는 메서드
+	 */
+	private Long extractUserIdFromObject(Object obj, String fieldName) {
+		try {
+			Field field = findFieldInClass(obj.getClass(), fieldName);
+			if (field != null) {
+				field.setAccessible(true);
+				Object value = field.get(obj);
+				if (value instanceof Long) {
+					return (Long) value;
+				}
+			}
+		} catch (Exception e) {
+			log.warn("사용자 ID 추출 실패 - 객체: {}, 필드: {}, 에러: {}",
+					obj.getClass().getSimpleName(), fieldName, e.getMessage());
+		}
+		return null;
+	}
+
+	/**
+	 * 클래스 계층구조에서 필드를 찾는 메서드
+	 */
+	private Field findFieldInClass(Class<?> clazz, String fieldName) {
+		Class<?> currentClass = clazz;
+		while (currentClass != null) {
+			try {
+				return currentClass.getDeclaredField(fieldName);
+			} catch (NoSuchFieldException e) {
+				currentClass = currentClass.getSuperclass();
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * 차단된 사용자의 컨텐츠를 블러 처리하는 메서드
+	 */
+	private Object blurContent(Object originalItem) {
+		try {
+			// Jackson을 사용한 안전한 깊은 복사
+			Object clonedItem = deepCloneObject(originalItem);
+
+			// 차단된 사용자 표시로 마스킹
+			maskField(clonedItem, "content", "차단된 사용자의 글입니다");
+			maskField(clonedItem, "title", "차단된 사용자의 글입니다");
+			maskField(clonedItem, "authorNickname", "차단된 사용자");
+			maskField(clonedItem, "nickname", "차단된 사용자");
+			maskField(clonedItem, "authorProfileImage", null);
+			maskField(clonedItem, "profileImage", null);
+
+			return clonedItem;
+
+		} catch (Exception e) {
+			log.error("차단 처리 실패: {}", e.getMessage());
+			// 실패 시 원본 반환
+			return originalItem;
+		}
+	}
+
+	/**
+	 * 객체의 특정 필드를 마스킹하는 메서드
+	 */
+	private void maskField(Object obj, String fieldName, Object maskValue) {
+		try {
+			Field field = findFieldInClass(obj.getClass(), fieldName);
+			if (field != null) {
+				field.setAccessible(true);
+				field.set(obj, maskValue);
+			}
+		} catch (Exception e) {
+			// 필드가 없거나 설정 실패 시 무시 (정상적인 상황)
+		}
+	}
+
+	/**
+	 * Jackson ObjectMapper를 사용한 안전한 깊은 복사
+	 */
+	private Object deepCloneObject(Object original) {
+		try {
+			if (original == null) {
+				return null;
+			}
+			
+			// Jackson을 사용한 깊은 복사
+			String jsonString = objectMapper.writeValueAsString(original);
+			return objectMapper.readValue(jsonString, original.getClass());
+		} catch (Exception e) {
+			log.warn("객체 복사 실패, 원본 반환: {}", e.getMessage());
+			return original;
+		}
+	}
+}
diff --git a/src/main/java/app/bottlenote/global/cache/local/LocalCacheType.java b/src/main/java/app/bottlenote/global/cache/local/LocalCacheType.java
index cf34f65c5..9ddf011a1 100644
--- a/src/main/java/app/bottlenote/global/cache/local/LocalCacheType.java
+++ b/src/main/java/app/bottlenote/global/cache/local/LocalCacheType.java
@@ -9,7 +9,8 @@
 @AllArgsConstructor
 public enum LocalCacheType {
 	LOCAL_REGION_CACHE("local_cache_alcohol_region_information", 60 * 60 * 24, 1),
-	LOCAL_ALCOHOL_CATEGORY_CACHE("local_cache_alcohol_category_information", 60 * 60 * 24, 1);
+	LOCAL_ALCOHOL_CATEGORY_CACHE("local_cache_alcohol_category_information", 60 * 60 * 24, 1),
+	BLOCKED_USERS_CACHE("blocked_users", 60 * 60 * 2, 1000);
 
 	private final String cacheName; // 등록할 캐시 이름
 	private final int secsToExpireAfterWrite; // 캐시 만료 시간 ( 60 * 60 * 24  = 1일 )
diff --git a/src/main/java/app/bottlenote/global/controller/BlockTestController.java b/src/main/java/app/bottlenote/global/controller/BlockTestController.java
new file mode 100644
index 000000000..b859fe458
--- /dev/null
+++ b/src/main/java/app/bottlenote/global/controller/BlockTestController.java
@@ -0,0 +1,248 @@
+package app.bottlenote.global.controller;
+
+import app.bottlenote.global.data.response.GlobalResponse;
+import app.bottlenote.global.service.BlockService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.annotation.Profile;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 차단 기능 테스트용 컨트롤러
+ *
+ * 개발/테스트 환경에서만 활성화됩니다.
+ * 운영 환경(prod)에서는 자동으로 비활성화됩니다.
+ */
+@Slf4j
+@RestController
+@RequestMapping("/api/v1/test/block")
+@RequiredArgsConstructor
+@Profile({"local", "dev", "test", "!prod"})
+public class BlockTestController {
+
+    private final BlockService blockService;
+
+    /**
+     * 차단 관계 생성 (테스트용)
+     *
+     * @param blockerId 차단한 사용자 ID
+     * @param blockedId 차단될 사용자 ID
+     * @param reason 차단 사유 (선택사항)
+     */
+    @PostMapping("/add")
+    public ResponseEntity<?> createBlock(
+            @RequestParam Long blockerId,
+            @RequestParam Long blockedId,
+            @RequestParam(required = false, defaultValue = "테스트 차단") String reason) {
+
+        try {
+            var userBlock = blockService.createBlock(blockerId, blockedId, reason);
+            return GlobalResponse.ok("차단 관계 생성 완료: " + blockerId + " -> " + blockedId +
+                                   " (ID: " + userBlock.getId() + ")");
+        } catch (Exception e) {
+            log.error("테스트 차단 생성 실패", e);
+            return ResponseEntity.badRequest()
+                .body(GlobalResponse.fail("차단 관계 생성 실패: " + e.getMessage()));
+        }
+    }
+
+    /**
+     * 차단 관계 해제 (테스트용)
+     */
+    @DeleteMapping("/remove")
+    public ResponseEntity<?> deleteBlock(
+            @RequestParam Long blockerId,
+            @RequestParam Long blockedId) {
+
+        blockService.removeBlock(blockerId, blockedId);
+
+        return GlobalResponse.ok("차단 관계 해제 완료: " + blockerId + " -> " + blockedId);
+    }
+
+    /**
+     * 차단 목록 조회 (테스트용)
+     */
+    @GetMapping("/list/{userId}")
+    public ResponseEntity<?> getBlockList(@PathVariable Long userId) {
+
+        var blockedUsers = blockService.getBlockedUserIds(userId);
+
+        return GlobalResponse.ok(blockedUsers);
+    }
+
+    /**
+     * 차단 여부 확인 (테스트용)
+     */
+    @GetMapping("/check")
+    public ResponseEntity<?> checkBlock(
+            @RequestParam Long blockerId,
+            @RequestParam Long blockedId) {
+
+        boolean isBlocked = blockService.isBlocked(blockerId, blockedId);
+
+        return GlobalResponse.ok("차단 여부: " + isBlocked);
+    }
+
+    /**
+     * 모든 차단 관계 초기화 (테스트용) - 현재 DB 기반으로 구현되어 있어 이 기능은 비활성화
+     */
+    @DeleteMapping("/clear")
+    public ResponseEntity<?> deleteAllBlocks() {
+
+        // DB 기반으로 변경되어 전체 삭제는 위험하므로 비활성화
+        log.warn("전체 차단 관계 초기화는 DB 기반에서 지원하지 않습니다.");
+
+        return GlobalResponse.ok("DB 기반에서는 전체 초기화를 지원하지 않습니다. 개별 해제를 사용해주세요.");
+    }
+
+    /**
+     * 사용자 차단 통계 조회 (테스트용)
+     */
+    @GetMapping("/statistics/{userId}")
+    public ResponseEntity<?> getBlockStatistics(@PathVariable Long userId) {
+
+        try {
+            var statistics = blockService.getBlockStatistics(userId);
+            return GlobalResponse.ok(statistics);
+        } catch (Exception e) {
+            log.error("차단 통계 조회 실패", e);
+            return ResponseEntity.badRequest()
+                .body(GlobalResponse.fail("차단 통계 조회 실패: " + e.getMessage()));
+        }
+    }
+
+    /**
+     * 차단 기능 테스트 (테스트용) - 실제 리뷰 구조와 유사한 응답
+     *
+     * 이 API는 실제 리뷰 목록 응답과 유사한 구조로 테스트 데이터를 제공합니다.
+     * 직접 차단 필터링을 적용하여 차단된 사용자의 컨텐츠가 마스킹됩니다.
+     *
+     * 테스트 시나리오:
+     * 1. 사용자 1이 사용자 2,3을 차단한 상태에서 X-User-Id=1로 요청
+     * 2. 사용자 2,3의 리뷰 내용이 "차단된 사용자의 글입니다"로 마스킹됨
+     * 3. 닉네임이 "차단된 사용자"로 변경됨
+     */
+    @GetMapping("/test-data/{userId}")
+    public ResponseEntity<?> getTestData(@PathVariable Long userId,
+                                        @RequestHeader(value = "X-User-Id", required = false) Long requestUserId) {
+
+        log.info("차단 필터 테스트 데이터 요청 - pathUserId: {}, requestUserId: {}", userId, requestUserId);
+
+        // 요청한 사용자 ID 결정 (X-User-Id 헤더 우선)
+        Long currentUserId = requestUserId != null ? requestUserId : userId;
+
+        // 차단된 사용자 목록 조회
+        java.util.Set<Long> blockedUserIds = java.util.Collections.emptySet();
+        if (currentUserId != null && currentUserId != -1L) {
+            blockedUserIds = blockService.getBlockedUserIds(currentUserId);
+            log.info("사용자 {}의 차단 목록: {}", currentUserId, blockedUserIds);
+        }
+
+        // 실제 리뷰 구조와 유사한 테스트 데이터 생성
+        var testReviews = java.util.List.of(
+            createTestReview(1L, "정말 맛있는 위스키였습니다. 스모키한 향이 일품이네요!", "위스키_러버", "profile1.jpg", 4.5),
+            createTestReview(2L, "첫 시음인데 생각보다 부드럽고 달콤합니다. 입문자에게 추천!", "초보_위스키", "profile2.jpg", 4.0),
+            createTestReview(3L, "가격 대비 훌륭한 위스키입니다. 재구매 의향 100%", "위스키_마니아", "profile3.jpg", 4.8),
+            createTestReview(4L, "오크향이 강해서 호불호가 갈릴 것 같아요.", "리뷰_고수", "profile4.jpg", 3.5),
+            createTestReview(5L, "친구들과 함께 마시기 좋은 위스키였습니다.", "소셜_드링커", "profile5.jpg", 4.2)
+        );
+
+        // 차단된 사용자의 리뷰에 필터링 적용
+        var filteredReviews = testReviews.stream()
+            .map(review -> {
+                Long authorId = (Long) review.get("authorId");
+                if (blockedUserIds.contains(authorId)) {
+                    return applyBlockMask(review);
+                }
+                return review;
+            })
+            .collect(java.util.stream.Collectors.toList());
+
+        // 리뷰 목록 응답 구조로 래핑
+        var response = java.util.Map.of(
+            "totalCount", filteredReviews.size(),
+            "reviewList", filteredReviews,
+            "message", "차단 필터 테스트용 리뷰 데이터 (직접 필터링 적용)",
+            "blockedUserIds", blockedUserIds,
+            "currentUserId", currentUserId
+        );
+
+        return GlobalResponse.ok(response);
+    }
+
+    /**
+     * 테스트용 리뷰 데이터 생성 헬퍼 메서드
+     */
+    private java.util.Map<String, Object> createTestReview(
+        Long authorId, String content, String nickname, String profileImage, Double rating) {
+
+        java.util.Map<String, Object> review = new java.util.HashMap<>();
+
+        // 리뷰 기본 정보
+        review.put("reviewId", 1000L + authorId);
+        review.put("reviewContent", content);
+        review.put("reviewImageUrl", "review_image_" + authorId + ".jpg");
+        review.put("createAt", java.time.LocalDateTime.now().minusDays(authorId));
+        review.put("totalImageCount", 2L);
+
+        // 작성자 정보 (차단 필터링 대상)
+        review.put("authorId", authorId);
+        review.put("authorNickname", nickname);
+        review.put("authorProfileImage", profileImage);
+
+        // 사용자 정보 (UserInfo 구조 모방)
+        review.put("userInfo", java.util.Map.of(
+            "userId", authorId,
+            "nickName", nickname,
+            "userProfileImage", profileImage
+        ));
+
+        // 리뷰 상태 및 평점
+        review.put("isMyReview", false);
+        review.put("status", "PUBLIC");
+        review.put("isBestReview", rating >= 4.5);
+        review.put("rating", rating);
+
+        // 상호작용 정보
+        review.put("likeCount", (long) (Math.random() * 20));
+        review.put("replyCount", (long) (Math.random() * 10));
+        review.put("isLikedByMe", false);
+        review.put("hasReplyByMe", false);
+        review.put("viewCount", (long) (Math.random() * 100));
+
+        // 기타 정보
+        review.put("price", java.math.BigDecimal.valueOf(50000 + (authorId * 10000)));
+        review.put("sizeType", "BOTTLE_750");
+        review.put("locationInfo", "서울시 강남구");
+        review.put("tastingTagList", "스모키, 오크, 바닐라");
+
+        return review;
+    }
+
+    /**
+     * 테스트용 SecurityContext 모킹 메서드
+     * 실제 운영에서는 JWT 토큰으로 SecurityContext가 설정되지만,
+     * 테스트에서는 직접 설정합니다.
+     */
+    private void mockSecurityContext(Long userId) {
+        try {
+            // SecurityContext에 직접 사용자 ID 설정
+            // 주의: 이는 테스트용이므로 운영 환경에서는 사용하지 말 것!
+            org.springframework.security.core.context.SecurityContextHolder.getContext()
+                .setAuthentication(new org.springframework.security.authentication.TestingAuthenticationToken(
+                    userId.toString(), null, "ROLE_USER"));
+
+            log.debug("테스트용 SecurityContext 설정 완료: {}", userId);
+        } catch (Exception e) {
+            log.warn("테스트용 SecurityContext 설정 실패: {}", e.getMessage());
+        }
+    }
+}
diff --git a/src/main/java/app/bottlenote/global/security/SecurityContextUtil.java b/src/main/java/app/bottlenote/global/security/SecurityContextUtil.java
index 6ffec6cd1..c416a3d30 100644
--- a/src/main/java/app/bottlenote/global/security/SecurityContextUtil.java
+++ b/src/main/java/app/bottlenote/global/security/SecurityContextUtil.java
@@ -46,6 +46,18 @@ public static Optional<Long> getUserIdByContext() {
 		}
 
 		Object principal = authentication.getPrincipal();
+		
+		// 테스트 환경에서 TestingAuthenticationToken 지원
+		if (authentication.getClass().getSimpleName().equals("TestingAuthenticationToken")) {
+			try {
+				Long userId = Long.parseLong(principal.toString());
+				log.debug("테스트 환경에서 사용자 ID 추출: {}", userId);
+				return Optional.of(userId);
+			} catch (NumberFormatException e) {
+				log.warn("테스트 환경에서 사용자 ID 파싱 실패: {}", principal);
+				return Optional.empty();
+			}
+		}
 		if (!(principal instanceof CustomUserContext customUserContext)) {
 			log.debug("인증된 사용자의 정보가 CustomUserContext의 인스턴스가 아닙니다. 비회원 사용자일 수 있습니다.");
 			return Optional.empty();
diff --git a/src/main/java/app/bottlenote/global/service/BlockService.java b/src/main/java/app/bottlenote/global/service/BlockService.java
new file mode 100644
index 000000000..40982dd6e
--- /dev/null
+++ b/src/main/java/app/bottlenote/global/service/BlockService.java
@@ -0,0 +1,262 @@
+package app.bottlenote.global.service;
+
+import app.bottlenote.user.domain.UserBlock;
+import app.bottlenote.user.domain.UserBlockRepository;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * 사용자 차단 기능을 제공하는 서비스
+ * DB 기반으로 차단 관계를 관리하며, Redis 캐시를 통해 성능을 최적화합니다.
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class BlockService {
+
+    private final UserBlockRepository userBlockRepository;
+
+    /**
+     * 특정 사용자가 차단한 사용자들의 ID 목록을 조회
+     * Redis 캐시를 통해 성능 최적화
+     *
+     * @param userId 차단한 사용자 ID
+     * @return 차단된 사용자 ID 목록
+     */
+    @Cacheable(
+        value = "blocked_users", 
+        key = "#userId", 
+        unless = "#userId == null or #userId == -1",
+        condition = "#userId != null and #userId != -1"
+    )
+    @Transactional(readOnly = true)
+    public Set<Long> getBlockedUserIds(Long userId) {
+        if (userId == null || userId == -1L) {
+            return Collections.emptySet();
+        }
+
+        try {
+            Set<Long> blockedUsers = userBlockRepository.findBlockedUserIdsByBlockerId(userId);
+            log.debug("사용자 {}의 차단 목록 조회: {} 명", userId, blockedUsers.size());
+            return blockedUsers;
+        } catch (Exception e) {
+            log.error("차단 목록 조회 실패 - userId: {}, error: {}", userId, e.getMessage());
+            return Collections.emptySet();
+        }
+    }
+
+    /**
+     * 특정 사용자가 다른 사용자를 차단했는지 확인
+     *
+     * @param blockerId 차단한 사용자 ID
+     * @param blockedId 차단 대상 사용자 ID
+     * @return 차단 여부
+     */
+    @Transactional(readOnly = true)
+    public boolean isBlocked(Long blockerId, Long blockedId) {
+        if (blockerId == null || blockedId == null || blockerId == -1L || blockerId.equals(blockedId)) {
+            return false;
+        }
+
+        try {
+            return userBlockRepository.existsByBlockerIdAndBlockedId(blockerId, blockedId);
+        } catch (Exception e) {
+            log.error("차단 여부 확인 실패 - blockerId: {}, blockedId: {}, error: {}", 
+                     blockerId, blockedId, e.getMessage());
+            return false;
+        }
+    }
+
+    /**
+     * 상호 차단 관계 확인 (서로 차단한 경우)
+     *
+     * @param userId1 사용자 1
+     * @param userId2 사용자 2
+     * @return 상호 차단 여부
+     */
+    @Transactional(readOnly = true)
+    public boolean isMutuallyBlocked(Long userId1, Long userId2) {
+        if (userId1 == null || userId2 == null || userId1.equals(userId2)) {
+            return false;
+        }
+
+        try {
+            return userBlockRepository.existsMutualBlock(userId1, userId2);
+        } catch (Exception e) {
+            log.error("상호 차단 확인 실패 - userId1: {}, userId2: {}, error: {}", 
+                     userId1, userId2, e.getMessage());
+            return false;
+        }
+    }
+
+    /**
+     * 배치로 여러 사용자의 차단 목록 조회 (성능 최적화)
+     *
+     * @param userIds 조회할 사용자 ID 목록
+     * @return 사용자별 차단 목록 맵
+     */
+    @Transactional(readOnly = true)
+    public Map<Long, Set<Long>> getBulkBlockedUsers(Set<Long> userIds) {
+        if (userIds == null || userIds.isEmpty()) {
+            return Collections.emptyMap();
+        }
+
+        return userIds.stream()
+            .filter(id -> id != null && id != -1L)
+            .collect(Collectors.toMap(
+                Function.identity(),
+                this::getBlockedUserIds,
+                (existing, replacement) -> existing // 중복 키 처리
+            ));
+    }
+
+    /**
+     * 사용자 차단 (실제 운영용 메서드)
+     *
+     * @param currentUserId 차단하는 사용자 ID
+     * @param targetUserId 차단할 사용자 ID
+     * @param reason 차단 사유
+     * @return 생성된 차단 관계
+     */
+    @Transactional
+    @CacheEvict(value = "blocked_users", key = "#currentUserId")
+    public UserBlock blockUser(Long currentUserId, Long targetUserId, String reason) {
+        validateBlockRequest(currentUserId, targetUserId);
+        return createBlock(currentUserId, targetUserId, reason);
+    }
+
+    /**
+     * 사용자 차단 해제 (실제 운영용 메서드)
+     *
+     * @param currentUserId 차단 해제하는 사용자 ID
+     * @param targetUserId 차단 해제할 사용자 ID
+     */
+    @Transactional
+    @CacheEvict(value = "blocked_users", key = "#currentUserId")
+    public void unblockUser(Long currentUserId, Long targetUserId) {
+        validateBlockRequest(currentUserId, targetUserId);
+        removeBlock(currentUserId, targetUserId);
+    }
+
+    /**
+     * 차단 관계 생성 (내부용 - 테스트에서도 사용)
+     *
+     * @param blockerId 차단한 사용자 ID
+     * @param blockedId 차단될 사용자 ID
+     * @param reason 차단 사유
+     * @return 생성된 차단 관계
+     */
+    @Transactional
+    @CacheEvict(value = "blocked_users", key = "#blockerId")
+    public UserBlock createBlock(Long blockerId, Long blockedId, String reason) {
+        validateBlockRequest(blockerId, blockedId);
+
+        // 이미 차단된 관계인지 확인
+        if (userBlockRepository.existsByBlockerIdAndBlockedId(blockerId, blockedId)) {
+            log.warn("이미 차단된 관계입니다 - blockerId: {}, blockedId: {}", blockerId, blockedId);
+            return userBlockRepository.findByBlockerIdAndBlockedId(blockerId, blockedId)
+                .orElseThrow(() -> new IllegalStateException("차단 관계 조회 실패"));
+        }
+
+        try {
+            UserBlock userBlock = UserBlock.create(blockerId, blockedId, reason);
+            UserBlock savedBlock = userBlockRepository.save(userBlock);
+            
+            log.info("차단 관계 생성 완료 - blockerId: {}, blockedId: {}, reason: {}", 
+                    blockerId, blockedId, reason);
+            
+            return savedBlock;
+        } catch (Exception e) {
+            log.error("차단 관계 생성 실패 - blockerId: {}, blockedId: {}, error: {}", 
+                     blockerId, blockedId, e.getMessage());
+            throw new RuntimeException("차단 관계 생성에 실패했습니다.", e);
+        }
+    }
+
+    /**
+     * 차단 관계 해제
+     *
+     * @param blockerId 차단한 사용자 ID
+     * @param blockedId 차단 해제할 사용자 ID
+     */
+    @Transactional
+    @CacheEvict(value = "blocked_users", key = "#blockerId")
+    public void removeBlock(Long blockerId, Long blockedId) {
+        validateBlockRequest(blockerId, blockedId);
+
+        try {
+            UserBlock userBlock = userBlockRepository.findByBlockerIdAndBlockedId(blockerId, blockedId)
+                .orElse(null);
+
+            if (userBlock != null) {
+                userBlockRepository.delete(userBlock);
+                log.info("차단 관계 해제 완료 - blockerId: {}, blockedId: {}", blockerId, blockedId);
+            } else {
+                log.warn("해제할 차단 관계가 없습니다 - blockerId: {}, blockedId: {}", blockerId, blockedId);
+            }
+        } catch (Exception e) {
+            log.error("차단 관계 해제 실패 - blockerId: {}, blockedId: {}, error: {}", 
+                     blockerId, blockedId, e.getMessage());
+            throw new RuntimeException("차단 관계 해제에 실패했습니다.", e);
+        }
+    }
+
+    /**
+     * 차단 요청 유효성 검증
+     */
+    private void validateBlockRequest(Long blockerId, Long blockedId) {
+        if (blockerId == null || blockedId == null) {
+            throw new IllegalArgumentException("사용자 ID는 null일 수 없습니다.");
+        }
+        
+        if (blockerId.equals(blockedId)) {
+            throw new IllegalArgumentException("자기 자신을 차단할 수 없습니다.");
+        }
+        
+        if (blockerId == -1L) {
+            throw new IllegalArgumentException("익명 사용자는 차단 기능을 사용할 수 없습니다.");
+        }
+    }
+
+    /**
+     * 특정 사용자의 차단 통계 조회
+     *
+     * @param userId 사용자 ID
+     * @return 차단 통계 정보
+     */
+    @Transactional(readOnly = true)
+    public BlockStatistics getBlockStatistics(Long userId) {
+        if (userId == null || userId == -1L) {
+            return new BlockStatistics(0L, 0L);
+        }
+
+        try {
+            long blockedCount = userBlockRepository.countByBlockerId(userId);
+            long blockedByCount = userBlockRepository.countByBlockedId(userId);
+            
+            return new BlockStatistics(blockedCount, blockedByCount);
+        } catch (Exception e) {
+            log.error("차단 통계 조회 실패 - userId: {}, error: {}", userId, e.getMessage());
+            return new BlockStatistics(0L, 0L);
+        }
+    }
+
+    /**
+     * 차단 통계 정보를 담는 record
+     */
+    public record BlockStatistics(
+        long blockedCount,      // 내가 차단한 사용자 수
+        long blockedByCount     // 나를 차단한 사용자 수
+    ) {}
+}
diff --git a/src/main/java/app/bottlenote/review/controller/ReviewController.java b/src/main/java/app/bottlenote/review/controller/ReviewController.java
index 012d9476e..e5b965996 100644
--- a/src/main/java/app/bottlenote/review/controller/ReviewController.java
+++ b/src/main/java/app/bottlenote/review/controller/ReviewController.java
@@ -1,5 +1,6 @@
 package app.bottlenote.review.controller;
 
+import app.bottlenote.global.annotation.BlockFilter;
 import app.bottlenote.global.data.response.GlobalResponse;
 import app.bottlenote.global.security.SecurityContextUtil;
 import app.bottlenote.global.service.cursor.PageResponse;
@@ -42,6 +43,7 @@ public ResponseEntity<?> createReview(@RequestBody @Valid ReviewCreateRequest re
 		return GlobalResponse.ok(reviewService.createReview(reviewCreateRequest, currentUserId));
 	}
 
+	@BlockFilter(userField = "authorId")
 	@GetMapping("/{alcoholId}")
 	public ResponseEntity<?> getReviews(@PathVariable Long alcoholId, @ModelAttribute ReviewPageableRequest reviewPageableRequest) {
 		Long currentUserId = SecurityContextUtil.getUserIdByContext().orElse(-1L);
@@ -54,6 +56,7 @@ public ResponseEntity<?> getReviews(@PathVariable Long alcoholId, @ModelAttribut
 		return GlobalResponse.ok(pageResponse.content(), MetaService.createMetaInfo().add("pageable", pageResponse.cursorPageable()));
 	}
 
+	@BlockFilter(userField = "authorId")
 	@GetMapping("/detail/{reviewId}")
 	public ResponseEntity<?> getDetailReview(@PathVariable Long reviewId) {
 
diff --git a/src/main/java/app/bottlenote/user/domain/UserBlock.java b/src/main/java/app/bottlenote/user/domain/UserBlock.java
new file mode 100644
index 000000000..e16958ea8
--- /dev/null
+++ b/src/main/java/app/bottlenote/user/domain/UserBlock.java
@@ -0,0 +1,70 @@
+package app.bottlenote.user.domain;
+
+import app.bottlenote.common.domain.BaseTimeEntity;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Index;
+import jakarta.persistence.Table;
+import jakarta.persistence.UniqueConstraint;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.Comment;
+
+/**
+ * 사용자 차단 관계를 나타내는 엔티티
+ */
+@Getter
+@Entity(name = "userBlock")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Table(
+		name = "user_block",
+		uniqueConstraints = {
+				@UniqueConstraint(
+						name = "uk_blocker_blocked",
+						columnNames = {"blocker_id", "blocked_id"}
+				)
+		},
+		indexes = {
+				@Index(name = "idx_user_block_blocker", columnList = "blocker_id"),
+				@Index(name = "idx_user_block_blocked", columnList = "blocked_id")
+		}
+)
+public class UserBlock extends BaseTimeEntity {
+
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	@Comment("차단 관계 ID")
+	private Long id;
+
+	@Column(name = "blocker_id", nullable = false)
+	@Comment("차단한 사용자 ID")
+	private Long blockerId;
+
+	@Column(name = "blocked_id", nullable = false)
+	@Comment("차단당한 사용자 ID")
+	private Long blockedId;
+
+	@Column(name = "block_reason", length = 500)
+	@Comment("차단 사유")
+	private String blockReason;
+
+	@Builder
+	public UserBlock(Long blockerId, Long blockedId, String blockReason) {
+		this.blockerId = blockerId;
+		this.blockedId = blockedId;
+		this.blockReason = blockReason;
+	}
+
+	public static UserBlock create(Long blockerId, Long blockedId, String reason) {
+		return UserBlock.builder()
+				.blockerId(blockerId)
+				.blockedId(blockedId)
+				.blockReason(reason)
+				.build();
+	}
+}
diff --git a/src/main/java/app/bottlenote/user/domain/UserBlockRepository.java b/src/main/java/app/bottlenote/user/domain/UserBlockRepository.java
new file mode 100644
index 000000000..1fb9ee847
--- /dev/null
+++ b/src/main/java/app/bottlenote/user/domain/UserBlockRepository.java
@@ -0,0 +1,71 @@
+package app.bottlenote.user.domain;
+
+import java.util.Optional;
+import java.util.Set;
+
+/**
+ * 사용자 차단 관계 Repository
+ */
+public interface UserBlockRepository {
+
+    /**
+     * 차단 관계 저장
+     */
+    UserBlock save(UserBlock userBlock);
+
+    /**
+     * 차단 관계 삭제
+     */
+    void delete(UserBlock userBlock);
+
+    /**
+     * 특정 사용자가 차단한 사용자 ID 목록 조회
+     * 
+     * @param blockerId 차단한 사용자 ID
+     * @return 차단된 사용자 ID 목록
+     */
+    Set<Long> findBlockedUserIdsByBlockerId(Long blockerId);
+
+    /**
+     * 차단 관계 존재 여부 확인
+     * 
+     * @param blockerId 차단한 사용자 ID
+     * @param blockedId 차단당한 사용자 ID
+     * @return 차단 관계 존재 여부
+     */
+    boolean existsByBlockerIdAndBlockedId(Long blockerId, Long blockedId);
+
+    /**
+     * 특정 차단 관계 조회
+     * 
+     * @param blockerId 차단한 사용자 ID
+     * @param blockedId 차단당한 사용자 ID
+     * @return 차단 관계 엔티티
+     */
+    Optional<UserBlock> findByBlockerIdAndBlockedId(Long blockerId, Long blockedId);
+
+    /**
+     * 특정 사용자를 차단한 사용자 수 조회
+     * 
+     * @param blockedId 차단당한 사용자 ID
+     * @return 차단한 사용자 수
+     */
+    long countByBlockedId(Long blockedId);
+
+    /**
+     * 특정 사용자가 차단한 사용자 수 조회
+     * 
+     * @param blockerId 차단한 사용자 ID
+     * @return 차단한 사용자 수
+     */
+    long countByBlockerId(Long blockerId);
+
+    /**
+     * 상호 차단 관계 확인 (서로 차단한 경우)
+     * 
+     * @param userId1 사용자 1
+     * @param userId2 사용자 2
+     * @return 상호 차단 여부
+     */
+    boolean existsMutualBlock(Long userId1, Long userId2);
+}
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/user/repository/JpaUserBlockRepository.java b/src/main/java/app/bottlenote/user/repository/JpaUserBlockRepository.java
new file mode 100644
index 000000000..9325db9bb
--- /dev/null
+++ b/src/main/java/app/bottlenote/user/repository/JpaUserBlockRepository.java
@@ -0,0 +1,37 @@
+package app.bottlenote.user.repository;
+
+import app.bottlenote.user.domain.UserBlock;
+import app.bottlenote.user.domain.UserBlockRepository;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+import java.util.Set;
+
+@Repository
+public interface JpaUserBlockRepository extends UserBlockRepository, JpaRepository<UserBlock, Long> {
+
+    @Override
+    @Query("SELECT ub.blockedId FROM userBlock ub WHERE ub.blockerId = :blockerId")
+    Set<Long> findBlockedUserIdsByBlockerId(@Param("blockerId") Long blockerId);
+
+    @Override
+    boolean existsByBlockerIdAndBlockedId(Long blockerId, Long blockedId);
+
+    @Override
+    Optional<UserBlock> findByBlockerIdAndBlockedId(Long blockerId, Long blockedId);
+
+    @Override
+    long countByBlockedId(Long blockedId);
+
+    @Override
+    long countByBlockerId(Long blockerId);
+
+    @Override
+    @Query("SELECT COUNT(ub) = 2 FROM userBlock ub " +
+           "WHERE (ub.blockerId = :userId1 AND ub.blockedId = :userId2) " +
+           "OR (ub.blockerId = :userId2 AND ub.blockedId = :userId1)")
+    boolean existsMutualBlock(@Param("userId1") Long userId1, @Param("userId2") Long userId2);
+}
\ No newline at end of file

From 9d7508d77f6a376d0a40d03ec2c433fe339ead1f Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Fri, 27 Jun 2025 02:10:25 +0900
Subject: [PATCH 02/16] feat: implement block filtering functionality with
 @BlockFilter annotation and AOP support

Signed-off-by: hgkim <hgkim@openerd.com>
---
 http/block/block-blur-test.http               |  10 +
 .../block/annotation/BlockFilter.java.bak     |  38 +++
 .../common/block/annotation/BlockWord.java    |  28 ++
 .../block/aspect/BlockFilterAspect.java.bak   | 238 ++++++++++++++++
 .../common/block/config/BlockWordConfig.java  |  29 ++
 .../controller/BlockTestController.java.bak   |  70 +++++
 .../block/serializer/BlockWordSerializer.java | 150 ++++++++++
 .../common/block/service/BlockService.java    |  48 ++++
 .../java/app/bottlenote/common/block/v1.0.md  | 158 +++++++++++
 .../java/app/bottlenote/common/block/v1.1.md  | 189 +++++++++++++
 .../java/app/bottlenote/common/block/v1.3.md  | 181 ++++++++++++
 .../java/app/bottlenote/common/block/v1.4.md  | 154 ++++++++++
 .../java/app/bottlenote/common/block/v1.5.md  | 192 +++++++++++++
 .../global/annotation/BlockFilter.java        |  26 --
 .../global/aspect/BlockFilterAspect.java      | 228 ---------------
 .../controller/BlockTestController.java       | 248 -----------------
 .../global/service/BlockService.java          | 262 ------------------
 .../review/controller/ReviewController.java   |   2 +-
 18 files changed, 1486 insertions(+), 765 deletions(-)
 create mode 100644 http/block/block-blur-test.http
 create mode 100644 src/main/java/app/bottlenote/common/block/annotation/BlockFilter.java.bak
 create mode 100644 src/main/java/app/bottlenote/common/block/annotation/BlockWord.java
 create mode 100644 src/main/java/app/bottlenote/common/block/aspect/BlockFilterAspect.java.bak
 create mode 100644 src/main/java/app/bottlenote/common/block/config/BlockWordConfig.java
 create mode 100644 src/main/java/app/bottlenote/common/block/controller/BlockTestController.java.bak
 create mode 100644 src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java
 create mode 100644 src/main/java/app/bottlenote/common/block/service/BlockService.java
 create mode 100644 src/main/java/app/bottlenote/common/block/v1.0.md
 create mode 100644 src/main/java/app/bottlenote/common/block/v1.1.md
 create mode 100644 src/main/java/app/bottlenote/common/block/v1.3.md
 create mode 100644 src/main/java/app/bottlenote/common/block/v1.4.md
 create mode 100644 src/main/java/app/bottlenote/common/block/v1.5.md
 delete mode 100644 src/main/java/app/bottlenote/global/annotation/BlockFilter.java
 delete mode 100644 src/main/java/app/bottlenote/global/aspect/BlockFilterAspect.java
 delete mode 100644 src/main/java/app/bottlenote/global/controller/BlockTestController.java
 delete mode 100644 src/main/java/app/bottlenote/global/service/BlockService.java

diff --git a/http/block/block-blur-test.http b/http/block/block-blur-test.http
new file mode 100644
index 000000000..b201ca1a9
--- /dev/null
+++ b/http/block/block-blur-test.http
@@ -0,0 +1,10 @@
+### 블러 처리 테스트 - 차단 관계가 있는 사용자 1의 경우
+# 사용자 1이 사용자 2,3을 차단했으므로 해당 리뷰들이 블러 처리되어야 함
+GET {{host}}/api/v1/test/block/reviews
+Content-Type: application/json
+
+### 결과 확인:
+# - 사용자 2,3의 reviewContent가 "차단된 사용자의 글입니다"로 변경
+# - 사용자 2,3의 authorNickname이 "차단된 사용자의 글입니다"로 변경  
+# - 사용자 2,3의 authorProfileImage가 null로 변경
+# - 사용자 1,4,5의 리뷰는 정상 표시
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/annotation/BlockFilter.java.bak b/src/main/java/app/bottlenote/common/block/annotation/BlockFilter.java.bak
new file mode 100644
index 000000000..001bf0512
--- /dev/null
+++ b/src/main/java/app/bottlenote/common/block/annotation/BlockFilter.java.bak
@@ -0,0 +1,38 @@
+package app.bottlenote.common.block.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 차단된 사용자의 컨텐츠를 블러 처리하는 어노테이션
+ * 
+ * 사용 예시:
+ * @BlockFilter(
+ *     userField = "authorId", 
+ *     blurFields = {"reviewContent", "authorNickname", "authorProfileImage"}
+ * )
+ * @GetMapping("/reviews") 
+ * public ResponseEntity<?> getReviews() { ... }
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface BlockFilter {
+
+    /**
+     * 응답 객체에서 사용자 ID를 추출할 필드명
+     * 예: "authorId", "userId", "writerId"
+     */
+    String userField() default "authorId";
+    
+    /**
+     * 블러 처리할 필드명 배열
+     * 차단된 사용자의 경우 이 필드들이 "차단된 사용자의 글입니다"로 대체됨
+     */
+    String[] blurFields() default {
+        "content", "reviewContent", "title", 
+        "authorNickname", "nickname", 
+        "authorProfileImage", "profileImage"
+    };
+}
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/annotation/BlockWord.java b/src/main/java/app/bottlenote/common/block/annotation/BlockWord.java
new file mode 100644
index 000000000..f4ac91625
--- /dev/null
+++ b/src/main/java/app/bottlenote/common/block/annotation/BlockWord.java
@@ -0,0 +1,28 @@
+package app.bottlenote.common.block.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 차단된 사용자의 컨텐츠를 대체 메시지로 변경하는 어노테이션
+ * JSON 직렬화 시점에서 동작합니다.
+ */
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface BlockWord {
+    
+    /**
+     * 차단된 사용자 컨텐츠 대체 메시지
+     * 기본값: "차단된 사용자의 글입니다"
+     */
+    String value() default "차단된 사용자의 글입니다";
+    
+    /**
+     * 차단 판단 기준이 되는 사용자 ID 경로
+     * 기본값: "userId"
+     * 중첩 객체 예시: "userInfo.userId"
+     */
+    String userIdPath() default "userId";
+}
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/aspect/BlockFilterAspect.java.bak b/src/main/java/app/bottlenote/common/block/aspect/BlockFilterAspect.java.bak
new file mode 100644
index 000000000..bbe8632a7
--- /dev/null
+++ b/src/main/java/app/bottlenote/common/block/aspect/BlockFilterAspect.java.bak
@@ -0,0 +1,238 @@
+package app.bottlenote.common.block.aspect;
+
+import app.bottlenote.common.block.annotation.BlockFilter;
+import app.bottlenote.common.block.service.BlockService;
+import app.bottlenote.global.data.response.GlobalResponse;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Field;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * 간소화된 차단 필터 AOP
+ * 핵심 기능: 차단된 사용자의 컨텐츠를 블러 처리
+ */
+@Slf4j
+@Aspect
+@Component
+@RequiredArgsConstructor
+public class BlockFilterAspect {
+
+    private final BlockService blockService;
+    private final ObjectMapper objectMapper;
+
+    @Around("@annotation(blockFilter)")
+    public Object applyBlockFilter(ProceedingJoinPoint joinPoint, BlockFilter blockFilter) throws Throwable {
+
+        // 1. 원본 메서드 실행
+        Object result = joinPoint.proceed();
+
+        // 2. 현재 사용자 ID 추출 (테스트용으로 헤더에서 가져옴)
+        Long currentUserId = extractCurrentUserId();
+
+        if (currentUserId == -1L) {
+            log.debug("인증되지 않은 사용자 - 차단 필터 적용하지 않음");
+            return result;
+        }
+
+        // 3. 차단된 사용자 목록 조회
+        Set<Long> blockedUserIds = blockService.getBlockedUserIds(currentUserId);
+
+        if (blockedUserIds.isEmpty()) {
+            log.debug("차단한 사용자가 없음 - 필터링 건너뜀");
+            return result;
+        }
+
+        log.info("차단 필터 적용: 사용자 {}, 차단 대상 {}", currentUserId, blockedUserIds);
+
+        // 4. 응답 데이터에 블러 처리 적용
+        return applyBlurFilter(result, blockedUserIds, blockFilter);
+    }
+
+    /**
+     * 테스트용: 현재 사용자 ID 추출
+     * 실제 운영에서는 SecurityContext에서 가져옴
+     */
+    private Long extractCurrentUserId() {
+        // 현재는 테스트를 위해 고정값 반환
+        // 실제로는 SecurityContextUtil.getUserIdByContext() 사용
+        return 1L; // 테스트용: 사용자 1로 고정
+    }
+
+    /**
+     * 응답 데이터에 블러 처리 적용
+     */
+    private Object applyBlurFilter(Object result, Set<Long> blockedUserIds, BlockFilter blockFilter) {
+
+        if (!(result instanceof ResponseEntity)) {
+            return result;
+        }
+
+        ResponseEntity<?> responseEntity = (ResponseEntity<?>) result;
+        Object body = responseEntity.getBody();
+
+        if (!(body instanceof GlobalResponse)) {
+            return result;
+        }
+
+        GlobalResponse globalResponse = (GlobalResponse) body;
+        Object data = globalResponse.getData();
+
+        if (data == null) {
+            return result;
+        }
+
+        // 데이터 타입에 따른 블러 처리
+        Object blurredData;
+        if (data instanceof List) {
+            blurredData = blurListData((List<?>) data, blockedUserIds, blockFilter);
+        } else {
+            blurredData = blurSingleData(data, blockedUserIds, blockFilter);
+        }
+
+        // 블러 처리된 데이터로 새로운 응답 생성
+        GlobalResponse blurredResponse = GlobalResponse.success(blurredData);
+        return ResponseEntity.ok(blurredResponse);
+    }
+
+    /**
+     * List 형태의 데이터 블러 처리
+     */
+    @SuppressWarnings("unchecked")
+    private List<?> blurListData(List<?> dataList, Set<Long> blockedUserIds, BlockFilter blockFilter) {
+        return dataList.stream()
+                .map(item -> blurItemIfBlocked(item, blockedUserIds, blockFilter))
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * 단일 객체 데이터 블러 처리
+     */
+    private Object blurSingleData(Object data, Set<Long> blockedUserIds, BlockFilter blockFilter) {
+        return blurItemIfBlocked(data, blockedUserIds, blockFilter);
+    }
+
+    /**
+     * 개별 항목 차단 여부 확인 후 블러 처리
+     */
+    private Object blurItemIfBlocked(Object item, Set<Long> blockedUserIds, BlockFilter blockFilter) {
+        if (item == null) {
+            return item;
+        }
+
+        // 사용자 ID 추출
+        Long userId = extractUserIdFromObject(item, blockFilter.userField());
+
+        if (userId == null || !blockedUserIds.contains(userId)) {
+            return item; // 차단된 사용자가 아니면 원본 반환
+        }
+
+        log.debug("차단된 사용자의 컨텐츠 블러 처리: userId={}", userId);
+
+        // 차단된 사용자면 블러 처리
+        return applyBlurToItem(item, blockFilter.blurFields());
+    }
+
+    /**
+     * 객체에서 사용자 ID를 추출
+     */
+    private Long extractUserIdFromObject(Object obj, String fieldName) {
+        try {
+            Field field = findFieldInClass(obj.getClass(), fieldName);
+            if (field != null) {
+                field.setAccessible(true);
+                Object value = field.get(obj);
+                if (value instanceof Long) {
+                    return (Long) value;
+                }
+            }
+        } catch (Exception e) {
+            log.warn("사용자 ID 추출 실패: 객체={}, 필드={}", obj.getClass().getSimpleName(), fieldName);
+        }
+        return null;
+    }
+
+    /**
+     * 클래스 계층구조에서 필드 찾기
+     */
+    private Field findFieldInClass(Class<?> clazz, String fieldName) {
+        Class<?> currentClass = clazz;
+        while (currentClass != null) {
+            try {
+                return currentClass.getDeclaredField(fieldName);
+            } catch (NoSuchFieldException e) {
+                currentClass = currentClass.getSuperclass();
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 개별 항목에 블러 처리 적용
+     */
+    private Object applyBlurToItem(Object originalItem, String[] blurFields) {
+        try {
+            // Jackson을 사용한 깊은 복사
+            Object clonedItem = deepCloneObject(originalItem);
+
+            // 지정된 필드들을 "차단된 사용자의 글입니다"로 마스킹
+            for (String fieldName : blurFields) {
+                maskField(clonedItem, fieldName, "차단된 사용자의 글입니다");
+            }
+
+            return clonedItem;
+
+        } catch (Exception e) {
+            log.error("블러 처리 실패: {}", e.getMessage());
+            return originalItem; // 실패 시 원본 반환
+        }
+    }
+
+    /**
+     * 객체의 특정 필드를 마스킹
+     */
+    private void maskField(Object obj, String fieldName, String maskValue) {
+        try {
+            Field field = findFieldInClass(obj.getClass(), fieldName);
+            if (field != null) {
+                field.setAccessible(true);
+
+                // 필드 타입에 따라 적절한 마스킹 값 설정
+                if (fieldName.toLowerCase().contains("image") || fieldName.toLowerCase().contains("url")) {
+                    field.set(obj, null); // 이미지/URL은 null로 처리
+                } else {
+                    field.set(obj, maskValue); // 텍스트는 마스킹 메시지로 처리
+                }
+            }
+        } catch (Exception e) {
+            // 필드가 없거나 설정 실패 시 무시 (정상적인 상황)
+            log.debug("필드 마스킹 건너뜀: {}.{}", obj.getClass().getSimpleName(), fieldName);
+        }
+    }
+
+    /**
+     * Jackson을 사용한 깊은 복사
+     */
+    private Object deepCloneObject(Object original) {
+        try {
+            if (original == null) {
+                return null;
+            }
+
+            String jsonString = objectMapper.writeValueAsString(original);
+            return objectMapper.readValue(jsonString, original.getClass());
+        } catch (Exception e) {
+            log.warn("객체 복사 실패, 원본 반환: {}", e.getMessage());
+            return original;
+        }
+    }
+}
diff --git a/src/main/java/app/bottlenote/common/block/config/BlockWordConfig.java b/src/main/java/app/bottlenote/common/block/config/BlockWordConfig.java
new file mode 100644
index 000000000..5056a6cff
--- /dev/null
+++ b/src/main/java/app/bottlenote/common/block/config/BlockWordConfig.java
@@ -0,0 +1,29 @@
+package app.bottlenote.common.block.config;
+
+import app.bottlenote.common.block.serializer.BlockWordSerializer;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import jakarta.annotation.PostConstruct;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * BlockWord 시리얼라이저 설정
+ */
+@Configuration
+@RequiredArgsConstructor
+public class BlockWordConfig {
+
+    private final ObjectMapper objectMapper;
+    private final BlockWordSerializer blockWordSerializer;
+
+    @PostConstruct
+    public void configureObjectMapper() {
+        SimpleModule blockWordModule = new SimpleModule("BlockWordModule");
+
+        // String 타입에 대해 @BlockWord 어노테이션이 있을 때 커스텀 시리얼라이저 사용
+        blockWordModule.addSerializer(String.class, blockWordSerializer);
+
+        objectMapper.registerModule(blockWordModule);
+    }
+}
diff --git a/src/main/java/app/bottlenote/common/block/controller/BlockTestController.java.bak b/src/main/java/app/bottlenote/common/block/controller/BlockTestController.java.bak
new file mode 100644
index 000000000..61da4b552
--- /dev/null
+++ b/src/main/java/app/bottlenote/common/block/controller/BlockTestController.java.bak
@@ -0,0 +1,70 @@
+package app.bottlenote.common.block.controller;
+
+import app.bottlenote.common.block.annotation.BlockFilter;
+import app.bottlenote.global.data.response.GlobalResponse;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.annotation.Profile;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 간소화된 차단 기능 테스트 컨트롤러
+ * 핵심 기능: 블러 처리 테스트만 집중
+ */
+@Slf4j
+@RestController
+@RequestMapping("/api/v1/test/block")
+@Profile({"local", "dev", "test", "!prod"})
+public class BlockTestController {
+
+    /**
+     * 블러 처리 테스트용 리뷰 목록 API
+     * 
+     * 차단 관계 (하드코딩):
+     * - 사용자 1 → 사용자 2,3 차단
+     * - 사용자 2 → 사용자 4 차단 
+     * - 사용자 3 → 사용자 1,5 차단
+     */
+    @BlockFilter(
+        userField = "authorId",
+        blurFields = {"reviewContent", "authorNickname", "authorProfileImage"}
+    )
+    @GetMapping("/reviews")
+    public ResponseEntity<?> getTestReviews() {
+        
+        log.info("블러 처리 테스트용 리뷰 목록 조회");
+        
+        List<Map<String, Object>> reviews = List.of(
+            createReview(1L, "정말 맛있는 위스키였습니다!", "위스키러버", "profile1.jpg"),
+            createReview(2L, "첫 시음인데 생각보다 좋네요", "초보위스키", "profile2.jpg"), 
+            createReview(3L, "가격 대비 훌륭합니다", "위스키마니아", "profile3.jpg"),
+            createReview(4L, "오크향이 강해서 호불호가 갈릴듯", "리뷰고수", "profile4.jpg"),
+            createReview(5L, "친구들과 마시기 좋았어요", "소셜드링커", "profile5.jpg")
+        );
+        
+        return GlobalResponse.ok(Map.of(
+            "totalCount", reviews.size(),
+            "reviews", reviews
+        ));
+    }
+    
+    /**
+     * 테스트용 리뷰 데이터 생성
+     */
+    private Map<String, Object> createReview(Long authorId, String content, String nickname, String profileImage) {
+        return Map.of(
+            "reviewId", 1000L + authorId,
+            "authorId", authorId,
+            "reviewContent", content,
+            "authorNickname", nickname,
+            "authorProfileImage", profileImage,
+            "createAt", LocalDateTime.now().minusDays(authorId),
+            "likeCount", (int)(Math.random() * 20),
+            "rating", 4.0 + (Math.random() * 1.0)
+        );
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java b/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java
new file mode 100644
index 000000000..f2ef60231
--- /dev/null
+++ b/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java
@@ -0,0 +1,150 @@
+package app.bottlenote.common.block.serializer;
+
+import app.bottlenote.common.block.annotation.BlockWord;
+import app.bottlenote.common.block.service.BlockService;
+import app.bottlenote.global.security.SecurityContextUtil;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.BeanProperty;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonSerializer;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.ser.ContextualSerializer;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import java.io.IOException;
+import java.lang.reflect.Field;
+
+/**
+ * @BlockWord 어노테이션이 적용된 필드의 Jackson 커스텀 시리얼라이저
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class BlockWordSerializer extends JsonSerializer<String> implements ContextualSerializer {
+
+    private final BlockService blockService;
+    private BlockWord blockWordAnnotation;
+
+    @Override
+    public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
+        if (blockWordAnnotation == null) {
+            gen.writeString(value);
+            return;
+        }
+
+        try {
+            // 현재 사용자 ID 획득
+            Long currentUserId = SecurityContextUtil.getUserIdByContext().orElse(null);
+            if (currentUserId == null) {
+                // 비로그인 사용자는 필터링 스킵
+                gen.writeString(value);
+                return;
+            }
+
+            // 현재 직렬화 중인 객체 획득
+            Object currentObject = gen.getCurrentValue();
+            if (currentObject == null) {
+                gen.writeString(value);
+                return;
+            }
+
+            // userIdPath로 작성자 ID 추출
+            Long authorId = extractUserIdByPath(currentObject, blockWordAnnotation.userIdPath());
+            if (authorId == null) {
+                gen.writeString(value);
+                return;
+            }
+
+            // 차단 관계 확인
+            boolean isBlocked = blockService.isBlocked(currentUserId, authorId);
+            if (isBlocked) {
+                // 차단된 경우 대체 메시지로 변경
+                gen.writeString(blockWordAnnotation.value());
+            } else {
+                // 정상인 경우 원본 값 사용
+                gen.writeString(value);
+            }
+
+        } catch (Exception e) {
+            log.warn("BlockWordSerializer 처리 중 오류 발생. 원본 값 반환: {}", e.getMessage());
+            gen.writeString(value);
+        }
+    }
+
+    @Override
+    public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) 
+            throws JsonMappingException {
+        
+        if (property != null) {
+            BlockWord annotation = property.getAnnotation(BlockWord.class);
+            if (annotation != null) {
+                BlockWordSerializer serializer = new BlockWordSerializer(blockService);
+                serializer.blockWordAnnotation = annotation;
+                return serializer;
+            }
+        }
+        
+        return this;
+    }
+
+    /**
+     * 지정된 경로로 객체에서 userId 추출
+     * 
+     * @param object 대상 객체
+     * @param userIdPath userId 경로 (예: "userId", "userInfo.userId")
+     * @return 추출된 userId, 실패시 null
+     */
+    private Long extractUserIdByPath(Object object, String userIdPath) {
+        try {
+            String[] pathParts = userIdPath.split("\\.");
+            Object currentObject = object;
+
+            // 경로를 따라 객체 탐색
+            for (String part : pathParts) {
+                if (currentObject == null) {
+                    return null;
+                }
+
+                Field field = findField(currentObject.getClass(), part);
+                if (field == null) {
+                    log.warn("필드를 찾을 수 없습니다: {} in {}", part, currentObject.getClass().getSimpleName());
+                    return null;
+                }
+
+                field.setAccessible(true);
+                currentObject = field.get(currentObject);
+            }
+
+            // 최종 값이 Long 타입인지 확인
+            if (currentObject instanceof Long) {
+                return (Long) currentObject;
+            } else {
+                log.warn("userId 필드가 Long 타입이 아닙니다: {}", currentObject != null ? currentObject.getClass() : "null");
+                return null;
+            }
+
+        } catch (Exception e) {
+            log.warn("userId 추출 중 오류 발생: {}", e.getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * 클래스에서 필드 찾기 (상속 계층 포함)
+     */
+    private Field findField(Class<?> clazz, String fieldName) {
+        Class<?> currentClass = clazz;
+        
+        while (currentClass != null) {
+            try {
+                return currentClass.getDeclaredField(fieldName);
+            } catch (NoSuchFieldException e) {
+                currentClass = currentClass.getSuperclass();
+            }
+        }
+        
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/service/BlockService.java b/src/main/java/app/bottlenote/common/block/service/BlockService.java
new file mode 100644
index 000000000..6e4072657
--- /dev/null
+++ b/src/main/java/app/bottlenote/common/block/service/BlockService.java
@@ -0,0 +1,48 @@
+package app.bottlenote.common.block.service;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.Set;
+
+/**
+ * 간소화된 차단 서비스
+ * 핵심 기능: 특정 사용자가 차단한 사용자 목록 조회
+ */
+@Slf4j
+@Service
+public class BlockService {
+
+    /**
+     * 특정 사용자가 차단한 사용자들의 ID 목록을 조회
+     * 테스트용으로 하드코딩된 차단 관계
+     * 
+     * @param userId 사용자 ID
+     * @return 차단된 사용자 ID 목록
+     */
+    public Set<Long> getBlockedUserIds(Long userId) {
+        if (userId == null || userId == -1L) {
+            return Set.of();
+        }
+        
+        // 테스트용 하드코딩된 차단 관계
+        return switch (userId.intValue()) {
+            case 1 -> Set.of(2L, 3L);  // 사용자 1은 사용자 2,3을 차단
+            case 2 -> Set.of(4L);      // 사용자 2는 사용자 4를 차단  
+            case 3 -> Set.of(1L, 5L);  // 사용자 3은 사용자 1,5를 차단
+            default -> Set.of();       // 나머지는 차단 없음
+        };
+    }
+    
+    /**
+     * 두 사용자 간 차단 여부 확인
+     */
+    public boolean isBlocked(Long blockerId, Long blockedId) {
+        if (blockerId == null || blockedId == null) {
+            return false;
+        }
+        
+        Set<Long> blockedUsers = getBlockedUserIds(blockerId);
+        return blockedUsers.contains(blockedId);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/v1.0.md b/src/main/java/app/bottlenote/common/block/v1.0.md
new file mode 100644
index 000000000..5cdc7c269
--- /dev/null
+++ b/src/main/java/app/bottlenote/common/block/v1.0.md
@@ -0,0 +1,158 @@
+# 블록 필터링 v1.0 - AOP 방식
+
+## 📋 개요
+
+**AOP 기반 컨트롤러 레벨 블록 필터링**: `@BlockFilter` 어노테이션을 컨트롤러 메서드에 적용하여 차단된 사용자의 컨텐츠를 "블러" 처리하는 방식
+
+## 🎯 @BlockFilter 어노테이션
+
+```java
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface BlockFilter {
+    /**
+     * 응답 객체에서 사용자 ID를 추출할 필드명
+     */
+    String userField() default "authorId";
+    
+    /**
+     * 블러 처리할 필드명 배열
+     */
+    String[] blurFields() default {
+        "content", "reviewContent", "title", 
+        "authorNickname", "nickname", 
+        "authorProfileImage", "profileImage"
+    };
+}
+```
+
+## 📝 사용 예시
+
+### 컨트롤러 적용
+```java
+@RestController
+public class ReviewController {
+    
+    @BlockFilter(userField = "authorId")
+    @GetMapping("/{alcoholId}")
+    public ResponseEntity<?> getReviews(@PathVariable Long alcoholId) {
+        // 비즈니스 로직 실행
+        return GlobalResponse.ok(reviewService.getReviews(alcoholId));
+    }
+}
+```
+
+## 🔧 동작 원리
+
+### 1. AOP Aspect 처리 흐름
+```java
+@Around("@annotation(blockFilter)")
+public Object applyBlockFilter(ProceedingJoinPoint joinPoint, BlockFilter blockFilter) {
+    // 1. 원본 메서드 실행
+    Object result = joinPoint.proceed();
+    
+    // 2. 현재 사용자 ID 추출
+    Long currentUserId = extractCurrentUserId();
+    
+    // 3. 차단된 사용자 목록 조회
+    Set<Long> blockedUserIds = blockService.getBlockedUserIds(currentUserId);
+    
+    // 4. 응답 데이터에 블러 처리 적용
+    return applyBlurFilter(result, blockedUserIds, blockFilter);
+}
+```
+
+### 2. 블러 처리 과정
+1. **ResponseEntity → GlobalResponse → data 순으로 탐색**
+2. **데이터 타입 확인**: List 또는 단일 객체
+3. **각 항목별로 사용자 ID 추출** (`userField` 사용)
+4. **차단 대상인지 확인** (blockedUserIds에 포함 여부)
+5. **차단된 경우 객체 복제 후 필드 마스킹**
+
+### 3. 필드 마스킹 규칙
+```java
+// 텍스트 필드: "차단된 사용자의 글입니다"
+reviewContent → "차단된 사용자의 글입니다"
+authorNickname → "차단된 사용자의 글입니다"
+
+// 이미지/URL 필드: null 처리
+authorProfileImage → null
+imageUrl → null
+```
+
+## 🎨 처리 결과
+
+### 정상 사용자 응답
+```json
+{
+  "success": true,
+  "data": {
+    "reviewList": [
+      {
+        "authorId": 123,
+        "reviewContent": "정말 맛있는 위스키입니다!",
+        "authorNickname": "위스키러버",
+        "authorProfileImage": "profile.jpg"
+      }
+    ]
+  }
+}
+```
+
+### 차단된 사용자 응답 (블러 처리 후)
+```json
+{
+  "success": true,
+  "data": {
+    "reviewList": [
+      {
+        "authorId": 456,
+        "reviewContent": "차단된 사용자의 글입니다",
+        "authorNickname": "차단된 사용자의 글입니다", 
+        "authorProfileImage": null
+      }
+    ]
+  }
+}
+```
+
+## 🛠️ 구현 구조
+
+### 핵심 파일들
+- `annotation/BlockFilter.java` - 어노테이션 정의
+- `aspect/BlockFilterAspect.java` - AOP 처리 로직
+- `service/BlockService.java` - 차단 관계 조회
+- `controller/BlockTestController.java` - 테스트 컨트롤러
+
+### 주요 메서드
+1. **extractCurrentUserId()**: 현재 사용자 ID 추출 (테스트용 고정값)
+2. **applyBlurFilter()**: 응답 데이터 타입별 블러 처리 분기
+3. **blurItemIfBlocked()**: 개별 항목 차단 여부 확인 및 처리
+4. **applyBlurToItem()**: Jackson 깊은 복사 후 필드 마스킹
+5. **maskField()**: 필드 타입에 따른 마스킹 값 설정
+
+## 🚧 한계점
+
+### 1. 복잡한 처리 과정
+- **ResponseEntity → GlobalResponse → data 구조 의존성**
+- **리플렉션 기반 필드 접근으로 인한 성능 이슈**
+- **Jackson 깊은 복사로 인한 메모리 사용량 증가**
+
+### 2. 컨트롤러 결합도
+- **각 컨트롤러 메서드마다 어노테이션 추가 필요**
+- **userField 설정이 응답 구조에 의존적**
+- **새로운 응답 구조 추가 시 blurFields 재설정 필요**
+
+### 3. 유지보수 어려움
+- **AOP 처리 과정이 복잡하여 디버깅 어려움**
+- **응답 구조 변경 시 필터링 로직도 함께 수정 필요**
+- **테스트용 고정 사용자 ID 등 임시 구현 존재**
+
+### 4. 확장성 제한
+- **특정 응답 구조(GlobalResponse)에만 동작**
+- **중첩 객체 내부 필드 처리 복잡**
+- **다양한 블러 처리 방식 적용 어려움**
+
+## 📝 결론
+
+AOP 방식은 컨트롤러 레벨에서 블록 필터링을 처리하지만, 복잡한 구조와 높은 결합도로 인해 유지보수가 어려운 방식입니다. 특히 응답 구조에 대한 의존성이 높고, 성능상 오버헤드가 존재합니다.
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/v1.1.md b/src/main/java/app/bottlenote/common/block/v1.1.md
new file mode 100644
index 000000000..f3376315c
--- /dev/null
+++ b/src/main/java/app/bottlenote/common/block/v1.1.md
@@ -0,0 +1,189 @@
+# 블록 필터링 v1.1 - 복잡한 Jackson 인터페이스 방식
+
+## 📋 개요
+
+**심플한 어노테이션 기반 블록 필터링**: `@BlockWord` 어노테이션을 필드에 직접 적용하여 Jackson 직렬화 시점에서 차단된 사용자의 컨텐츠를 대체 메시지로 변경하는 방식
+
+## 🎯 핵심 아이디어
+
+### 기본 원칙
+- **필드 레벨 제어**: 응답 객체 구조는 그대로, 필드별로 블록 필터링 적용
+- **대체 메시지 방식**: 차단된 사용자 컨텐츠를 완전히 제거하지 않고 지정된 메시지로 교체
+- **Jackson 직렬화 활용**: JSON 변환 시점에서 자동으로 필터링 처리
+- **최소한의 변경**: 기존 코드 구조를 최대한 유지하면서 블록 기능 추가
+
+## 🏗️ 설계 상세
+
+### 1. 응답 구조 유지
+```java
+// ReviewListResponse - 기존 구조 그대로 유지
+public record ReviewListResponse(
+    Long totalCount,
+    List<ReviewInfo> reviewList  // 구조 변경 없음
+) {
+    public static ReviewListResponse of(Long totalCount, List<ReviewInfo> reviewList) {
+        return new ReviewListResponse(totalCount, reviewList);
+    }
+}
+```
+
+### 2. 필드 레벨 블록 필터링
+```java
+// ReviewInfo - 특정 필드에만 @BlockWord 적용
+@Builder
+public record ReviewInfo(
+    Long reviewId,
+    
+    @BlockWord  // 차단된 사용자의 리뷰 내용 필터링
+    String reviewContent,
+    
+    String reviewImageUrl,
+    // ... 기타 필드들 (블록 필터링 불필요)
+    
+    UserInfo userInfo,  // 내부에서 닉네임 필터링
+    // ... 나머지 필드들
+) {
+}
+```
+
+### 3. 사용자 정보 블록 필터링
+```java
+// UserInfo - 닉네임에 대체 메시지 적용
+public record UserInfo(
+    Long userId,  // userId는 그대로 유지 (차단 관계 판단용)
+    
+    @BlockWord(대체메시지 = "차단된 사용자")  // 커스텀 대체 메시지
+    String nickName,
+    
+    String userProfileImage  // 프로필 이미지는 유지
+) {
+    public static UserInfo of(Long userId, String nickName, String userProfileImage) {
+        return new UserInfo(userId, nickName, userProfileImage);
+    }
+}
+```
+
+## 🔧 @BlockWord 어노테이션 설계
+
+### 어노테이션 정의
+```java
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface BlockWord {
+    /**
+     * 차단된 사용자 컨텐츠 대체 메시지
+     * 기본값: 빈 문자열 (컨텐츠 완전 숨김)
+     */
+    String 대체메시지() default "";
+    
+    /**
+     * 차단 판단 기준이 되는 사용자 ID 필드명
+     * 기본값: 같은 객체 내 "userId" 필드 사용
+     */
+    String userIdField() default "userId";
+}
+```
+
+### 사용 예시
+```java
+// 케이스 1: 컨텐츠 완전 숨김
+@BlockWord
+String reviewContent;  // → ""
+
+// 케이스 2: 대체 메시지로 교체
+@BlockWord(대체메시지 = "차단된 사용자")
+String nickName;  // → "차단된 사용자"
+
+// 케이스 3: 다른 필드의 userId 참조
+@BlockWord(userIdField = "authorId", 대체메시지 = "차단된 댓글")
+String commentContent;
+```
+
+## 🎨 처리 흐름
+
+### 1. 정상 사용자 컨텐츠
+```json
+{
+  "reviewContent": "정말 맛있는 위스키입니다!",
+  "userInfo": {
+    "userId": 123,
+    "nickName": "위스키러버",
+    "userProfileImage": "profile.jpg"
+  }
+}
+```
+
+### 2. 차단된 사용자 컨텐츠 (필터링 후)
+```json
+{
+  "reviewContent": "",  // @BlockWord로 빈 문자열 처리
+  "userInfo": {
+    "userId": 456,  // userId는 유지 (시스템에서 사용)
+    "nickName": "차단된 사용자",  // 대체 메시지로 교체
+    "userProfileImage": "profile.jpg"  // 프로필 이미지는 유지
+  }
+}
+```
+
+## 🔍 동작 원리
+
+### Jackson 커스텀 시리얼라이저 처리 과정
+
+1. **필드 스캔**: `@BlockWord` 어노테이션이 붙은 필드 감지
+2. **사용자 ID 획득**: 현재 요청 사용자와 컨텐츠 작성자 ID 확인
+3. **차단 관계 검사**: `BlockService`를 통해 차단 관계 확인 (캐시 활용)
+4. **조건부 대체**: 차단된 경우에만 지정된 대체 메시지로 변경
+5. **JSON 출력**: 필터링된 결과를 JSON으로 직렬화
+
+## 🚀 장점
+
+### 1. 심플함
+- **최소한의 코드 변경**: 기존 DTO에 어노테이션만 추가
+- **직관적**: 어떤 필드가 필터링되는지 한눈에 파악 가능
+- **설정 불필요**: 복잡한 인터페이스나 설정 클래스 불필요
+
+### 2. 유연성
+- **필드별 제어**: 각 필드마다 다른 대체 메시지 설정 가능
+- **선택적 적용**: 필요한 필드에만 선택적으로 적용
+- **커스터마이징**: userIdField로 다양한 구조에 대응
+
+### 3. 성능
+- **Jackson 레벨 처리**: 직렬화 시점에만 실행으로 효율적
+- **캐시 활용**: 기존 BlockService의 캐싱 메커니즘 그대로 활용
+- **조건부 실행**: 차단 관계가 있을 때만 처리
+
+### 4. 유지보수성
+- **관심사 분리**: 비즈니스 로직과 블록 필터링 완전 분리
+- **기존 구조 유지**: 응답 객체나 컨트롤러 구조 변경 없음
+- **확장 용이**: 새로운 DTO에 쉽게 적용 가능
+
+## 🛠️ 구현 범위
+
+### Phase 1: 핵심 구성요소
+- `@BlockWord` 어노테이션 정의
+- Jackson 커스텀 시리얼라이저 구현
+- 현재 사용자 컨텍스트 획득 로직
+
+### Phase 2: DTO 적용
+- `ReviewInfo`에 `reviewContent` 필드 블록 필터링 적용
+- `UserInfo`에 `nickName` 필드 블록 필터링 적용
+
+### Phase 3: 기존 코드 정리
+- 컨트롤러의 `@BlockFilter` 어노테이션 제거
+- AOP 기반 블록 필터링 코드 제거
+
+## 🎯 예상 결과
+
+### 개발자 경험
+- **간단한 적용**: `@BlockWord` 어노테이션 하나로 블록 필터링 완성
+- **명확한 의도**: 코드만 봐도 어떤 필드가 블록 대상인지 즉시 파악
+- **디버깅 용이**: JSON 응답에서 바로 필터링 결과 확인 가능
+
+### 사용자 경험
+- **자연스러운 차단**: 차단된 사용자 컨텐츠가 자연스럽게 대체됨
+- **정보 유지**: 사용자 ID 등 필요한 메타데이터는 그대로 유지
+- **일관성**: 모든 API에서 동일한 방식으로 차단 처리
+
+## 📝 결론
+
+`@BlockWord` 어노테이션 기반 블록 필터링은 복잡한 설정 없이도 강력하고 유연한 블록 기능을 제공합니다. 기존 코드 구조를 최대한 유지하면서도 세밀한 제어가 가능한 우아한 솔루션입니다.
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/v1.3.md b/src/main/java/app/bottlenote/common/block/v1.3.md
new file mode 100644
index 000000000..1ea582fc0
--- /dev/null
+++ b/src/main/java/app/bottlenote/common/block/v1.3.md
@@ -0,0 +1,181 @@
+# 블록 필터링 v1.3 - 중첩 객체 지원 @BlockWord 방식
+
+## 📋 개요
+
+**@BlockWord 어노테이션 기반 블록 필터링**: JSON 직렬화 시점에서 차단된 사용자 컨텐츠를 자동으로 대체 메시지로 변경
+
+## 🎯 핵심 설계
+
+### @BlockWord 어노테이션 정의
+```java
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface BlockWord {
+    /**
+     * 차단된 사용자 컨텐츠 대체 메시지
+     * 기본값: "차단된 사용자의 글입니다"
+     */
+    String value() default "차단된 사용자의 글입니다";
+    
+    /**
+     * 차단 판단 기준이 되는 사용자 ID 경로
+     * 기본값: 같은 객체 내 "userId" 필드
+     * 중첩 객체: "userInfo.userId" 형태 지원
+     */
+    String userIdPath() default "userId";
+}
+```
+
+### 사용 예시
+
+#### 1. 기본 대체 메시지 사용
+```java
+@BlockWord(userIdPath = "userInfo.userId")
+String reviewContent;  // → "차단된 사용자의 글입니다"
+```
+
+#### 2. 커스텀 대체 메시지
+```java
+@BlockWord(value = "차단된 사용자", userIdPath = "userInfo.userId")  
+String nickName;  // → "차단된 사용자"
+```
+
+#### 3. 중첩 객체에서 userId 참조
+```java
+// ReviewInfo 구조
+public record ReviewInfo(
+    @BlockWord(userIdPath = "userInfo.userId")  // 내부 객체의 userId 참조
+    String reviewContent,
+    
+    UserInfo userInfo  // userId를 포함한 중첩 객체
+) {}
+
+public record UserInfo(
+    Long userId,  // 차단 판단 기준
+    
+    @BlockWord(userIdPath = "userId")  // 같은 객체 내 userId 참조
+    String nickName
+) {}
+```
+
+## 🔧 동작 원리
+
+### 1. 경로 기반 userId 획득
+- **단순 경로**: `"userId"` → 같은 객체 내 userId 필드
+- **중첩 경로**: `"userInfo.userId"` → userInfo 객체 내부의 userId 필드
+- **리플렉션 활용**: 런타임에 지정된 경로로 userId 값 추출
+
+### 2. 차단 관계 검사 흐름
+```
+1. @BlockWord 필드 감지
+2. userIdPath로 작성자 userId 추출
+3. 현재 요청 사용자 ID 획득 (SecurityContext)
+4. BlockService.isBlocked(currentUserId, authorId) 호출
+5. 차단된 경우 → 대체 메시지로 변경
+6. 정상인 경우 → 원본 값 유지
+```
+
+## 📝 적용 예시
+
+### ReviewInfo 적용
+```java
+@Builder
+public record ReviewInfo(
+    Long reviewId,
+    
+    // 리뷰 내용 - userInfo 내부의 userId로 차단 판단
+    @BlockWord(userIdPath = "userInfo.userId")
+    String reviewContent,
+    
+    String reviewImageUrl,
+    LocalDateTime createAt,
+    
+    // 사용자 정보 - 내부에서 nickName 필터링
+    UserInfo userInfo,
+    
+    Boolean isMyReview,
+    // ... 기타 필드들
+) {}
+```
+
+### UserInfo 적용
+```java
+public record UserInfo(
+    Long userId,  // 차단 판단 기준
+    
+    // 닉네임 - 같은 객체 내 userId로 차단 판단
+    @BlockWord(value = "차단된 사용자", userIdPath = "userId")
+    String nickName,
+    
+    String userProfileImage
+) {
+    public static UserInfo of(Long userId, String nickName, String userProfileImage) {
+        return new UserInfo(userId, nickName, userProfileImage);
+    }
+}
+```
+
+## 🎨 처리 결과
+
+### 정상 사용자 응답
+```json
+{
+  "reviewContent": "정말 맛있는 위스키입니다!",
+  "userInfo": {
+    "userId": 123,
+    "nickName": "위스키러버",
+    "userProfileImage": "profile.jpg"
+  }
+}
+```
+
+### 차단된 사용자 응답 (필터링 후)
+```json
+{
+  "reviewContent": "차단된 사용자의 글입니다",
+  "userInfo": {
+    "userId": 456,  // userId는 유지 (시스템 동작용)
+    "nickName": "차단된 사용자",
+    "userProfileImage": "profile.jpg"
+  }
+}
+```
+
+## 🚀 주요 특징
+
+### 1. 유연한 경로 지정
+- **단순 구조**: `userIdPath = "userId"`
+- **중첩 구조**: `userIdPath = "userInfo.userId"`
+- **깊은 중첩**: `userIdPath = "author.profile.userId"` (필요시 확장)
+
+### 2. 기본값 제공
+- **대체 메시지**: 지정하지 않으면 "차단된 사용자의 글입니다"
+- **경로**: 지정하지 않으면 같은 객체 내 "userId" 필드 사용
+
+### 3. 성능 최적화
+- **캐시 활용**: BlockService의 기존 캐싱 메커니즘 활용
+- **조건부 실행**: 차단 관계가 있을 때만 대체 처리
+- **직렬화 시점**: JSON 변환할 때만 실행
+
+## 🛠️ 구현 고려사항
+
+### 1. 경로 파싱
+- dot notation 파싱 로직 구현
+- 중첩 객체 접근을 위한 리플렉션 활용
+- 경로가 유효하지 않을 때 예외 처리
+
+### 2. 현재 사용자 컨텍스트
+- SecurityContextUtil을 통한 현재 사용자 ID 획득
+- 로그인하지 않은 사용자 처리 (필터링 스킵)
+
+### 3. Jackson 커스텀 시리얼라이저
+- @BlockWord 어노테이션 스캔
+- 필드별 조건부 값 변경
+- 원본 객체 수정 없이 직렬화 시에만 변경
+
+## 📋 장점
+
+- **직관적**: 어노테이션만 봐도 어떤 필드가 어떻게 필터링되는지 명확
+- **유연함**: 다양한 객체 구조에 대응 가능한 경로 지정 방식
+- **최소 변경**: 기존 DTO 구조 변경 없이 어노테이션만 추가
+- **성능**: 필요할 때만 실행되는 효율적인 구조
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/v1.4.md b/src/main/java/app/bottlenote/common/block/v1.4.md
new file mode 100644
index 000000000..9972a656b
--- /dev/null
+++ b/src/main/java/app/bottlenote/common/block/v1.4.md
@@ -0,0 +1,154 @@
+# 블록 필터링 v1.4 - 최종 단순화된 @BlockWord 방식
+
+## 📋 개요
+
+**@BlockWord 어노테이션**: JSON 직렬화 시점에서 차단된 사용자 컨텐츠를 대체 메시지로 자동 변경
+
+## 🎯 @BlockWord 어노테이션
+
+```java
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface BlockWord {
+    /**
+     * 차단된 사용자 컨텐츠 대체 메시지
+     * 기본값: "차단된 사용자의 글입니다"
+     */
+    String value() default "차단된 사용자의 글입니다";
+    
+    /**
+     * 차단 판단 기준이 되는 사용자 ID 경로
+     * 기본값: "userId"
+     * 중첩 객체: "userInfo.userId" 형태 지원
+     */
+    String userIdPath() default "userId";
+}
+```
+
+## 📝 사용 예시
+
+### ReviewInfo
+```java
+@Builder
+public record ReviewInfo(
+    Long reviewId,
+    
+    @BlockWord(userIdPath = "userInfo.userId")
+    String reviewContent,
+    
+    UserInfo userInfo,
+    // ... 기타 필드들
+) {}
+```
+
+### UserInfo
+```java
+public record UserInfo(
+    Long userId,
+    
+    @BlockWord(value = "차단된 사용자", userIdPath = "userId")
+    String nickName,
+    
+    String userProfileImage
+) {}
+```
+
+## 🔧 동작 흐름
+
+### 1. 현재 사용자 ID 획득
+```java
+// SecurityContextUtils 활용
+Long currentUserId = SecurityContextUtil.getUserIdByContext().orElse(null);
+
+// 비로그인 사용자 처리
+if (currentUserId == null) {
+    // 필터링 스킵, 원본 값 그대로 반환
+    return originalValue;
+}
+```
+
+### 2. 작성자 userId 추출
+```java
+// userIdPath로 리플렉션을 통해 userId 추출
+// "userId" → 같은 객체 내 userId 필드
+// "userInfo.userId" → userInfo 객체 내부의 userId 필드
+Long authorId = extractUserIdByPath(object, userIdPath);
+```
+
+### 3. 차단 관계 확인 및 처리
+```java
+// BlockService를 통한 차단 관계 확인 (캐시 제외)
+boolean isBlocked = blockService.isBlocked(currentUserId, authorId);
+
+if (isBlocked) {
+    return 대체메시지;  // "@BlockWord" 어노테이션의 value 값
+} else {
+    return 원본값;
+}
+```
+
+## 🎨 처리 결과
+
+### 정상 사용자
+```json
+{
+  "reviewContent": "정말 맛있는 위스키입니다!",
+  "userInfo": {
+    "userId": 123,
+    "nickName": "위스키러버"
+  }
+}
+```
+
+### 차단된 사용자
+```json
+{
+  "reviewContent": "차단된 사용자의 글입니다",
+  "userInfo": {
+    "userId": 456,
+    "nickName": "차단된 사용자"
+  }
+}
+```
+
+### 비로그인 사용자
+```json
+{
+  "reviewContent": "정말 맛있는 위스키입니다!",
+  "userInfo": {
+    "userId": 123,
+    "nickName": "위스키러버"
+  }
+}
+```
+
+## 🛠️ 구현 핵심 요소
+
+### 1. Jackson 커스텀 시리얼라이저
+- `@BlockWord` 어노테이션 감지
+- 필드별 조건부 값 변경
+- 직렬화 시점에서만 처리
+
+### 2. 경로 기반 userId 추출
+- dot notation 파싱: `"userInfo.userId"`
+- 리플렉션을 통한 중첩 객체 접근
+- 경로 오류 시 예외 처리
+
+### 3. 사용자 컨텍스트 처리
+- `SecurityContextUtil.getUserIdByContext()` 활용
+- `Optional<Long>` 반환값 처리
+- 비로그인 사용자는 필터링 스킵
+
+### 4. 단순한 블록 검사
+- `BlockService.isBlocked(currentUserId, authorId)` 호출
+- 캐싱 메커니즘 제외
+- 차단된 경우에만 대체 메시지 적용
+
+## 📋 처리 조건
+
+| 상황 | 동작 |
+|------|------|
+| 비로그인 사용자 | 원본 값 그대로 반환 (필터링 안 함) |
+| 로그인 + 차단 안 됨 | 원본 값 그대로 반환 |
+| 로그인 + 차단됨 | 대체 메시지로 변경 |
+| userIdPath 오류 | 원본 값 그대로 반환 + 로그 기록 |
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/v1.5.md b/src/main/java/app/bottlenote/common/block/v1.5.md
new file mode 100644
index 000000000..9c9b92861
--- /dev/null
+++ b/src/main/java/app/bottlenote/common/block/v1.5.md
@@ -0,0 +1,192 @@
+# 블록 필터링 v1.5 - Jackson 시리얼라이저 구현
+
+## 📋 개요
+
+**실제 구현된 @BlockWord 방식**: Jackson ContextualSerializer를 활용하여 직렬화 시점에서 차단된 사용자 컨텐츠를 자동으로 대체하는 구현
+
+## 🎯 구현 구성요소
+
+### 1. @BlockWord 어노테이션
+```java
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface BlockWord {
+    String value() default "차단된 사용자의 글입니다";
+    String userIdPath() default "userId";
+}
+```
+
+### 2. BlockWordSerializer
+```java
+@Component
+public class BlockWordSerializer extends JsonSerializer<String> implements ContextualSerializer {
+    
+    @Override
+    public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) {
+        // 1. 현재 사용자 ID 획득 (SecurityContextUtil)
+        // 2. 비로그인 사용자는 필터링 스킵
+        // 3. userIdPath로 작성자 ID 추출 (리플렉션)
+        // 4. BlockService.isBlocked() 호출
+        // 5. 차단된 경우 대체 메시지로 변경
+    }
+    
+    @Override
+    public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) {
+        // @BlockWord 어노테이션 감지하여 컨텍스트별 시리얼라이저 생성
+    }
+}
+```
+
+### 3. BlockWordConfig
+```java
+@Configuration
+public class BlockWordConfig {
+    
+    @PostConstruct
+    public void configureObjectMapper() {
+        SimpleModule blockWordModule = new SimpleModule("BlockWordModule");
+        blockWordModule.addSerializer(String.class, blockWordSerializer);
+        objectMapper.registerModule(blockWordModule);
+    }
+}
+```
+
+## 🔧 동작 과정
+
+### 1. 시리얼라이저 등록
+- ObjectMapper에 BlockWordSerializer를 String 타입에 대해 등록
+- @BlockWord 어노테이션이 있는 필드에서만 동작하도록 ContextualSerializer 활용
+
+### 2. 직렬화 시점 처리
+```java
+// JSON 직렬화 시점에서 자동 호출
+serialize(String value, JsonGenerator gen, SerializerProvider serializers) {
+    
+    // 현재 사용자 ID 획득
+    Long currentUserId = SecurityContextUtil.getUserIdByContext().orElse(null);
+    if (currentUserId == null) {
+        gen.writeString(value);  // 비로그인 → 원본 반환
+        return;
+    }
+    
+    // 작성자 ID 추출 (리플렉션)
+    Object currentObject = gen.getCurrentValue();
+    Long authorId = extractUserIdByPath(currentObject, userIdPath);
+    
+    // 차단 관계 확인
+    boolean isBlocked = blockService.isBlocked(currentUserId, authorId);
+    if (isBlocked) {
+        gen.writeString(대체메시지);  // 차단됨 → 대체 메시지
+    } else {
+        gen.writeString(value);     // 정상 → 원본 값
+    }
+}
+```
+
+### 3. 경로 기반 userId 추출
+```java
+private Long extractUserIdByPath(Object object, String userIdPath) {
+    String[] pathParts = userIdPath.split("\\.");
+    Object currentObject = object;
+    
+    // dot notation 경로 탐색
+    for (String part : pathParts) {
+        Field field = findField(currentObject.getClass(), part);
+        field.setAccessible(true);
+        currentObject = field.get(currentObject);
+    }
+    
+    return (Long) currentObject;
+}
+```
+
+## 📝 사용 예시
+
+### ReviewInfo 적용
+```java
+@Builder
+public record ReviewInfo(
+    Long reviewId,
+    
+    @BlockWord(userIdPath = "userInfo.userId")
+    String reviewContent,
+    
+    UserInfo userInfo
+) {}
+```
+
+### UserInfo 적용
+```java
+public record UserInfo(
+    Long userId,
+    
+    @BlockWord(value = "차단된 사용자", userIdPath = "userId")  
+    String nickName,
+    
+    String userProfileImage
+) {}
+```
+
+## 🎨 처리 결과
+
+### 정상 사용자
+```json
+{
+  "reviewContent": "정말 맛있는 위스키입니다!",
+  "userInfo": {
+    "userId": 123,
+    "nickName": "위스키러버"
+  }
+}
+```
+
+### 차단된 사용자
+```json
+{
+  "reviewContent": "차단된 사용자의 글입니다",
+  "userInfo": {
+    "userId": 456,
+    "nickName": "차단된 사용자"
+  }
+}
+```
+
+## 🛠️ 구현 특징
+
+### 1. ContextualSerializer 활용
+- BeanProperty에서 @BlockWord 어노테이션 추출
+- 어노테이션별로 독립적인 시리얼라이저 인스턴스 생성
+- 필드별 개별 설정 적용
+
+### 2. 리플렉션 기반 경로 탐색
+- dot notation 지원: "userInfo.userId"
+- 클래스 상속 계층 고려한 필드 검색
+- 실패 시 원본 값 반환으로 안정성 확보
+
+### 3. 현재 사용자 컨텍스트
+- SecurityContextUtil.getUserIdByContext() 활용
+- Optional 반환값 처리로 비로그인 사용자 고려
+- 예외 상황에서 원본 값 보존
+
+### 4. 에러 핸들링
+- 각 단계별 try-catch로 안정성 확보
+- 실패 시 로그 기록 후 원본 값 반환
+- 운영 중 장애 방지를 위한 방어적 프로그래밍
+
+## 📋 구현 파일 구조
+
+```
+common/block/
+├── annotation/
+│   └── BlockWord.java           # 어노테이션 정의
+├── serializer/
+│   └── BlockWordSerializer.java # Jackson 커스텀 시리얼라이저
+├── config/
+│   └── BlockWordConfig.java     # ObjectMapper 설정
+└── service/
+    └── BlockService.java        # 차단 관계 조회 (기존)
+```
+
+## 📝 결론
+
+Jackson의 ContextualSerializer를 활용한 방식으로 필드 레벨에서 세밀한 블록 필터링을 구현했습니다. AOP 방식의 복잡성을 제거하고 직렬화 시점에서 자연스럽게 처리되도록 구현했습니다.
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/global/annotation/BlockFilter.java b/src/main/java/app/bottlenote/global/annotation/BlockFilter.java
deleted file mode 100644
index c19ad46d5..000000000
--- a/src/main/java/app/bottlenote/global/annotation/BlockFilter.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package app.bottlenote.global.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * 차단된 사용자의 컨텐츠를 "차단된 사용자의 글입니다"로 처리하는 어노테이션
- * <p>
- * 사용 예시:
- * @BlockFilter(userField = "authorId")
- * @GetMapping("/reviews") public ResponseEntity<?> getReviews() { ... }
- */
-@Target(ElementType.METHOD)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface BlockFilter {
-
-	/**
-	 * 응답 객체에서 사용자 ID를 추출할 필드명
-	 * 예: "authorId", "userId", "writerId"
-	 *
-	 * @return 사용자 ID 필드명
-	 */
-	String userField() default "authorId";
-}
diff --git a/src/main/java/app/bottlenote/global/aspect/BlockFilterAspect.java b/src/main/java/app/bottlenote/global/aspect/BlockFilterAspect.java
deleted file mode 100644
index ace2aaa1f..000000000
--- a/src/main/java/app/bottlenote/global/aspect/BlockFilterAspect.java
+++ /dev/null
@@ -1,228 +0,0 @@
-package app.bottlenote.global.aspect;
-
-import app.bottlenote.global.annotation.BlockFilter;
-import app.bottlenote.global.data.response.GlobalResponse;
-import app.bottlenote.global.security.SecurityContextUtil;
-import app.bottlenote.global.service.BlockService;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.aspectj.lang.ProceedingJoinPoint;
-import org.aspectj.lang.annotation.Around;
-import org.aspectj.lang.annotation.Aspect;
-import org.springframework.http.ResponseEntity;
-import org.springframework.stereotype.Component;
-
-import java.lang.reflect.Field;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-/**
- * 차단 필터 AOP 클래스
- *
- * @BlockFilter 어노테이션이 붙은 메서드의 응답을 가로채서
- * 차단된 사용자의 컨텐츠를 필터링합니다.
- */
-@Slf4j
-@Aspect
-@Component
-@RequiredArgsConstructor
-public class BlockFilterAspect {
-
-	private final BlockService blockService;
-	private final ObjectMapper objectMapper;
-
-	/**
-	 * @BlockFilter 어노테이션이 붙은 메서드를 Around 어드바이스로 처리
-	 */
-	@Around("@annotation(blockFilter)")
-	public Object applyBlockFilter(ProceedingJoinPoint joinPoint, BlockFilter blockFilter) throws Throwable {
-
-		// 1. 원본 메서드 실행
-		Object result = joinPoint.proceed();
-
-		// 2. 현재 사용자 ID 확인
-		Long currentUserId = SecurityContextUtil.getUserIdByContext().orElse(-1L);
-
-		if (currentUserId == -1L) {
-			// 익명 사용자는 차단 로직 적용하지 않음
-			return result;
-		}
-
-		// 3. 차단된 사용자 목록 조회
-		Set<Long> blockedUserIds = blockService.getBlockedUserIds(currentUserId);
-
-		if (blockedUserIds.isEmpty()) {
-			return result;
-		}
-
-		// 4. 응답 데이터에 차단 로직 적용 (항상 블러 처리)
-		return applyBlockFilter(result, blockedUserIds, blockFilter.userField());
-	}
-
-	/**
-	 * 응답 데이터에 차단 로직을 적용하는 메서드 (단순 블러 처리)
-	 */
-	private Object applyBlockFilter(Object result, Set<Long> blockedUserIds, String userField) {
-
-		if (!(result instanceof ResponseEntity)) {
-			return result;
-		}
-
-		ResponseEntity<?> responseEntity = (ResponseEntity<?>) result;
-		Object body = responseEntity.getBody();
-
-		if (!(body instanceof GlobalResponse)) {
-			return result;
-		}
-
-		GlobalResponse globalResponse = (GlobalResponse) body;
-		Object data = globalResponse.getData();
-
-		if (data == null) {
-			return result;
-		}
-
-		// 데이터 타입에 따른 블러 처리
-		Object filteredData;
-		if (data instanceof List) {
-			filteredData = blurListData((List<?>) data, blockedUserIds, userField);
-		} else {
-			filteredData = blurSingleData(data, blockedUserIds, userField);
-		}
-
-		// 블러 처리된 데이터로 새로운 응답 생성
-		GlobalResponse filteredResponse = GlobalResponse.success(filteredData);
-		return ResponseEntity.ok(filteredResponse);
-	}
-
-	/**
-	 * List 형태의 데이터 블러 처리
-	 */
-	@SuppressWarnings("unchecked")
-	private List<?> blurListData(List<?> dataList, Set<Long> blockedUserIds, String userField) {
-		return dataList.stream()
-				.map(item -> blurItemIfBlocked(item, blockedUserIds, userField))
-				.collect(Collectors.toList());
-	}
-
-	/**
-	 * 단일 객체 데이터 블러 처리
-	 */
-	private Object blurSingleData(Object data, Set<Long> blockedUserIds, String userField) {
-		return blurItemIfBlocked(data, blockedUserIds, userField);
-	}
-
-	/**
-	 * 개별 항목 차단 여부 확인 후 블러 처리
-	 */
-	private Object blurItemIfBlocked(Object item, Set<Long> blockedUserIds, String userField) {
-		if (item == null) {
-			return item;
-		}
-
-		// 사용자 ID 추출
-		Long userId = extractUserIdFromObject(item, userField);
-
-		if (userId == null || !blockedUserIds.contains(userId)) {
-			return item; // 차단된 사용자가 아니면 원본 반환
-		}
-
-		// 차단된 사용자면 블러 처리
-		return blurContent(item);
-	}
-
-	/**
-	 * 객체에서 사용자 ID를 추출하는 메서드
-	 */
-	private Long extractUserIdFromObject(Object obj, String fieldName) {
-		try {
-			Field field = findFieldInClass(obj.getClass(), fieldName);
-			if (field != null) {
-				field.setAccessible(true);
-				Object value = field.get(obj);
-				if (value instanceof Long) {
-					return (Long) value;
-				}
-			}
-		} catch (Exception e) {
-			log.warn("사용자 ID 추출 실패 - 객체: {}, 필드: {}, 에러: {}",
-					obj.getClass().getSimpleName(), fieldName, e.getMessage());
-		}
-		return null;
-	}
-
-	/**
-	 * 클래스 계층구조에서 필드를 찾는 메서드
-	 */
-	private Field findFieldInClass(Class<?> clazz, String fieldName) {
-		Class<?> currentClass = clazz;
-		while (currentClass != null) {
-			try {
-				return currentClass.getDeclaredField(fieldName);
-			} catch (NoSuchFieldException e) {
-				currentClass = currentClass.getSuperclass();
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * 차단된 사용자의 컨텐츠를 블러 처리하는 메서드
-	 */
-	private Object blurContent(Object originalItem) {
-		try {
-			// Jackson을 사용한 안전한 깊은 복사
-			Object clonedItem = deepCloneObject(originalItem);
-
-			// 차단된 사용자 표시로 마스킹
-			maskField(clonedItem, "content", "차단된 사용자의 글입니다");
-			maskField(clonedItem, "title", "차단된 사용자의 글입니다");
-			maskField(clonedItem, "authorNickname", "차단된 사용자");
-			maskField(clonedItem, "nickname", "차단된 사용자");
-			maskField(clonedItem, "authorProfileImage", null);
-			maskField(clonedItem, "profileImage", null);
-
-			return clonedItem;
-
-		} catch (Exception e) {
-			log.error("차단 처리 실패: {}", e.getMessage());
-			// 실패 시 원본 반환
-			return originalItem;
-		}
-	}
-
-	/**
-	 * 객체의 특정 필드를 마스킹하는 메서드
-	 */
-	private void maskField(Object obj, String fieldName, Object maskValue) {
-		try {
-			Field field = findFieldInClass(obj.getClass(), fieldName);
-			if (field != null) {
-				field.setAccessible(true);
-				field.set(obj, maskValue);
-			}
-		} catch (Exception e) {
-			// 필드가 없거나 설정 실패 시 무시 (정상적인 상황)
-		}
-	}
-
-	/**
-	 * Jackson ObjectMapper를 사용한 안전한 깊은 복사
-	 */
-	private Object deepCloneObject(Object original) {
-		try {
-			if (original == null) {
-				return null;
-			}
-			
-			// Jackson을 사용한 깊은 복사
-			String jsonString = objectMapper.writeValueAsString(original);
-			return objectMapper.readValue(jsonString, original.getClass());
-		} catch (Exception e) {
-			log.warn("객체 복사 실패, 원본 반환: {}", e.getMessage());
-			return original;
-		}
-	}
-}
diff --git a/src/main/java/app/bottlenote/global/controller/BlockTestController.java b/src/main/java/app/bottlenote/global/controller/BlockTestController.java
deleted file mode 100644
index b859fe458..000000000
--- a/src/main/java/app/bottlenote/global/controller/BlockTestController.java
+++ /dev/null
@@ -1,248 +0,0 @@
-package app.bottlenote.global.controller;
-
-import app.bottlenote.global.data.response.GlobalResponse;
-import app.bottlenote.global.service.BlockService;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.context.annotation.Profile;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.DeleteMapping;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestHeader;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
-import org.springframework.web.bind.annotation.RestController;
-
-/**
- * 차단 기능 테스트용 컨트롤러
- *
- * 개발/테스트 환경에서만 활성화됩니다.
- * 운영 환경(prod)에서는 자동으로 비활성화됩니다.
- */
-@Slf4j
-@RestController
-@RequestMapping("/api/v1/test/block")
-@RequiredArgsConstructor
-@Profile({"local", "dev", "test", "!prod"})
-public class BlockTestController {
-
-    private final BlockService blockService;
-
-    /**
-     * 차단 관계 생성 (테스트용)
-     *
-     * @param blockerId 차단한 사용자 ID
-     * @param blockedId 차단될 사용자 ID
-     * @param reason 차단 사유 (선택사항)
-     */
-    @PostMapping("/add")
-    public ResponseEntity<?> createBlock(
-            @RequestParam Long blockerId,
-            @RequestParam Long blockedId,
-            @RequestParam(required = false, defaultValue = "테스트 차단") String reason) {
-
-        try {
-            var userBlock = blockService.createBlock(blockerId, blockedId, reason);
-            return GlobalResponse.ok("차단 관계 생성 완료: " + blockerId + " -> " + blockedId +
-                                   " (ID: " + userBlock.getId() + ")");
-        } catch (Exception e) {
-            log.error("테스트 차단 생성 실패", e);
-            return ResponseEntity.badRequest()
-                .body(GlobalResponse.fail("차단 관계 생성 실패: " + e.getMessage()));
-        }
-    }
-
-    /**
-     * 차단 관계 해제 (테스트용)
-     */
-    @DeleteMapping("/remove")
-    public ResponseEntity<?> deleteBlock(
-            @RequestParam Long blockerId,
-            @RequestParam Long blockedId) {
-
-        blockService.removeBlock(blockerId, blockedId);
-
-        return GlobalResponse.ok("차단 관계 해제 완료: " + blockerId + " -> " + blockedId);
-    }
-
-    /**
-     * 차단 목록 조회 (테스트용)
-     */
-    @GetMapping("/list/{userId}")
-    public ResponseEntity<?> getBlockList(@PathVariable Long userId) {
-
-        var blockedUsers = blockService.getBlockedUserIds(userId);
-
-        return GlobalResponse.ok(blockedUsers);
-    }
-
-    /**
-     * 차단 여부 확인 (테스트용)
-     */
-    @GetMapping("/check")
-    public ResponseEntity<?> checkBlock(
-            @RequestParam Long blockerId,
-            @RequestParam Long blockedId) {
-
-        boolean isBlocked = blockService.isBlocked(blockerId, blockedId);
-
-        return GlobalResponse.ok("차단 여부: " + isBlocked);
-    }
-
-    /**
-     * 모든 차단 관계 초기화 (테스트용) - 현재 DB 기반으로 구현되어 있어 이 기능은 비활성화
-     */
-    @DeleteMapping("/clear")
-    public ResponseEntity<?> deleteAllBlocks() {
-
-        // DB 기반으로 변경되어 전체 삭제는 위험하므로 비활성화
-        log.warn("전체 차단 관계 초기화는 DB 기반에서 지원하지 않습니다.");
-
-        return GlobalResponse.ok("DB 기반에서는 전체 초기화를 지원하지 않습니다. 개별 해제를 사용해주세요.");
-    }
-
-    /**
-     * 사용자 차단 통계 조회 (테스트용)
-     */
-    @GetMapping("/statistics/{userId}")
-    public ResponseEntity<?> getBlockStatistics(@PathVariable Long userId) {
-
-        try {
-            var statistics = blockService.getBlockStatistics(userId);
-            return GlobalResponse.ok(statistics);
-        } catch (Exception e) {
-            log.error("차단 통계 조회 실패", e);
-            return ResponseEntity.badRequest()
-                .body(GlobalResponse.fail("차단 통계 조회 실패: " + e.getMessage()));
-        }
-    }
-
-    /**
-     * 차단 기능 테스트 (테스트용) - 실제 리뷰 구조와 유사한 응답
-     *
-     * 이 API는 실제 리뷰 목록 응답과 유사한 구조로 테스트 데이터를 제공합니다.
-     * 직접 차단 필터링을 적용하여 차단된 사용자의 컨텐츠가 마스킹됩니다.
-     *
-     * 테스트 시나리오:
-     * 1. 사용자 1이 사용자 2,3을 차단한 상태에서 X-User-Id=1로 요청
-     * 2. 사용자 2,3의 리뷰 내용이 "차단된 사용자의 글입니다"로 마스킹됨
-     * 3. 닉네임이 "차단된 사용자"로 변경됨
-     */
-    @GetMapping("/test-data/{userId}")
-    public ResponseEntity<?> getTestData(@PathVariable Long userId,
-                                        @RequestHeader(value = "X-User-Id", required = false) Long requestUserId) {
-
-        log.info("차단 필터 테스트 데이터 요청 - pathUserId: {}, requestUserId: {}", userId, requestUserId);
-
-        // 요청한 사용자 ID 결정 (X-User-Id 헤더 우선)
-        Long currentUserId = requestUserId != null ? requestUserId : userId;
-
-        // 차단된 사용자 목록 조회
-        java.util.Set<Long> blockedUserIds = java.util.Collections.emptySet();
-        if (currentUserId != null && currentUserId != -1L) {
-            blockedUserIds = blockService.getBlockedUserIds(currentUserId);
-            log.info("사용자 {}의 차단 목록: {}", currentUserId, blockedUserIds);
-        }
-
-        // 실제 리뷰 구조와 유사한 테스트 데이터 생성
-        var testReviews = java.util.List.of(
-            createTestReview(1L, "정말 맛있는 위스키였습니다. 스모키한 향이 일품이네요!", "위스키_러버", "profile1.jpg", 4.5),
-            createTestReview(2L, "첫 시음인데 생각보다 부드럽고 달콤합니다. 입문자에게 추천!", "초보_위스키", "profile2.jpg", 4.0),
-            createTestReview(3L, "가격 대비 훌륭한 위스키입니다. 재구매 의향 100%", "위스키_마니아", "profile3.jpg", 4.8),
-            createTestReview(4L, "오크향이 강해서 호불호가 갈릴 것 같아요.", "리뷰_고수", "profile4.jpg", 3.5),
-            createTestReview(5L, "친구들과 함께 마시기 좋은 위스키였습니다.", "소셜_드링커", "profile5.jpg", 4.2)
-        );
-
-        // 차단된 사용자의 리뷰에 필터링 적용
-        var filteredReviews = testReviews.stream()
-            .map(review -> {
-                Long authorId = (Long) review.get("authorId");
-                if (blockedUserIds.contains(authorId)) {
-                    return applyBlockMask(review);
-                }
-                return review;
-            })
-            .collect(java.util.stream.Collectors.toList());
-
-        // 리뷰 목록 응답 구조로 래핑
-        var response = java.util.Map.of(
-            "totalCount", filteredReviews.size(),
-            "reviewList", filteredReviews,
-            "message", "차단 필터 테스트용 리뷰 데이터 (직접 필터링 적용)",
-            "blockedUserIds", blockedUserIds,
-            "currentUserId", currentUserId
-        );
-
-        return GlobalResponse.ok(response);
-    }
-
-    /**
-     * 테스트용 리뷰 데이터 생성 헬퍼 메서드
-     */
-    private java.util.Map<String, Object> createTestReview(
-        Long authorId, String content, String nickname, String profileImage, Double rating) {
-
-        java.util.Map<String, Object> review = new java.util.HashMap<>();
-
-        // 리뷰 기본 정보
-        review.put("reviewId", 1000L + authorId);
-        review.put("reviewContent", content);
-        review.put("reviewImageUrl", "review_image_" + authorId + ".jpg");
-        review.put("createAt", java.time.LocalDateTime.now().minusDays(authorId));
-        review.put("totalImageCount", 2L);
-
-        // 작성자 정보 (차단 필터링 대상)
-        review.put("authorId", authorId);
-        review.put("authorNickname", nickname);
-        review.put("authorProfileImage", profileImage);
-
-        // 사용자 정보 (UserInfo 구조 모방)
-        review.put("userInfo", java.util.Map.of(
-            "userId", authorId,
-            "nickName", nickname,
-            "userProfileImage", profileImage
-        ));
-
-        // 리뷰 상태 및 평점
-        review.put("isMyReview", false);
-        review.put("status", "PUBLIC");
-        review.put("isBestReview", rating >= 4.5);
-        review.put("rating", rating);
-
-        // 상호작용 정보
-        review.put("likeCount", (long) (Math.random() * 20));
-        review.put("replyCount", (long) (Math.random() * 10));
-        review.put("isLikedByMe", false);
-        review.put("hasReplyByMe", false);
-        review.put("viewCount", (long) (Math.random() * 100));
-
-        // 기타 정보
-        review.put("price", java.math.BigDecimal.valueOf(50000 + (authorId * 10000)));
-        review.put("sizeType", "BOTTLE_750");
-        review.put("locationInfo", "서울시 강남구");
-        review.put("tastingTagList", "스모키, 오크, 바닐라");
-
-        return review;
-    }
-
-    /**
-     * 테스트용 SecurityContext 모킹 메서드
-     * 실제 운영에서는 JWT 토큰으로 SecurityContext가 설정되지만,
-     * 테스트에서는 직접 설정합니다.
-     */
-    private void mockSecurityContext(Long userId) {
-        try {
-            // SecurityContext에 직접 사용자 ID 설정
-            // 주의: 이는 테스트용이므로 운영 환경에서는 사용하지 말 것!
-            org.springframework.security.core.context.SecurityContextHolder.getContext()
-                .setAuthentication(new org.springframework.security.authentication.TestingAuthenticationToken(
-                    userId.toString(), null, "ROLE_USER"));
-
-            log.debug("테스트용 SecurityContext 설정 완료: {}", userId);
-        } catch (Exception e) {
-            log.warn("테스트용 SecurityContext 설정 실패: {}", e.getMessage());
-        }
-    }
-}
diff --git a/src/main/java/app/bottlenote/global/service/BlockService.java b/src/main/java/app/bottlenote/global/service/BlockService.java
deleted file mode 100644
index 40982dd6e..000000000
--- a/src/main/java/app/bottlenote/global/service/BlockService.java
+++ /dev/null
@@ -1,262 +0,0 @@
-package app.bottlenote.global.service;
-
-import app.bottlenote.user.domain.UserBlock;
-import app.bottlenote.user.domain.UserBlockRepository;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.cache.annotation.CacheEvict;
-import org.springframework.cache.annotation.Cacheable;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.util.Collections;
-import java.util.Map;
-import java.util.Set;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-/**
- * 사용자 차단 기능을 제공하는 서비스
- * DB 기반으로 차단 관계를 관리하며, Redis 캐시를 통해 성능을 최적화합니다.
- */
-@Slf4j
-@Service
-@RequiredArgsConstructor
-@Transactional(readOnly = true)
-public class BlockService {
-
-    private final UserBlockRepository userBlockRepository;
-
-    /**
-     * 특정 사용자가 차단한 사용자들의 ID 목록을 조회
-     * Redis 캐시를 통해 성능 최적화
-     *
-     * @param userId 차단한 사용자 ID
-     * @return 차단된 사용자 ID 목록
-     */
-    @Cacheable(
-        value = "blocked_users", 
-        key = "#userId", 
-        unless = "#userId == null or #userId == -1",
-        condition = "#userId != null and #userId != -1"
-    )
-    @Transactional(readOnly = true)
-    public Set<Long> getBlockedUserIds(Long userId) {
-        if (userId == null || userId == -1L) {
-            return Collections.emptySet();
-        }
-
-        try {
-            Set<Long> blockedUsers = userBlockRepository.findBlockedUserIdsByBlockerId(userId);
-            log.debug("사용자 {}의 차단 목록 조회: {} 명", userId, blockedUsers.size());
-            return blockedUsers;
-        } catch (Exception e) {
-            log.error("차단 목록 조회 실패 - userId: {}, error: {}", userId, e.getMessage());
-            return Collections.emptySet();
-        }
-    }
-
-    /**
-     * 특정 사용자가 다른 사용자를 차단했는지 확인
-     *
-     * @param blockerId 차단한 사용자 ID
-     * @param blockedId 차단 대상 사용자 ID
-     * @return 차단 여부
-     */
-    @Transactional(readOnly = true)
-    public boolean isBlocked(Long blockerId, Long blockedId) {
-        if (blockerId == null || blockedId == null || blockerId == -1L || blockerId.equals(blockedId)) {
-            return false;
-        }
-
-        try {
-            return userBlockRepository.existsByBlockerIdAndBlockedId(blockerId, blockedId);
-        } catch (Exception e) {
-            log.error("차단 여부 확인 실패 - blockerId: {}, blockedId: {}, error: {}", 
-                     blockerId, blockedId, e.getMessage());
-            return false;
-        }
-    }
-
-    /**
-     * 상호 차단 관계 확인 (서로 차단한 경우)
-     *
-     * @param userId1 사용자 1
-     * @param userId2 사용자 2
-     * @return 상호 차단 여부
-     */
-    @Transactional(readOnly = true)
-    public boolean isMutuallyBlocked(Long userId1, Long userId2) {
-        if (userId1 == null || userId2 == null || userId1.equals(userId2)) {
-            return false;
-        }
-
-        try {
-            return userBlockRepository.existsMutualBlock(userId1, userId2);
-        } catch (Exception e) {
-            log.error("상호 차단 확인 실패 - userId1: {}, userId2: {}, error: {}", 
-                     userId1, userId2, e.getMessage());
-            return false;
-        }
-    }
-
-    /**
-     * 배치로 여러 사용자의 차단 목록 조회 (성능 최적화)
-     *
-     * @param userIds 조회할 사용자 ID 목록
-     * @return 사용자별 차단 목록 맵
-     */
-    @Transactional(readOnly = true)
-    public Map<Long, Set<Long>> getBulkBlockedUsers(Set<Long> userIds) {
-        if (userIds == null || userIds.isEmpty()) {
-            return Collections.emptyMap();
-        }
-
-        return userIds.stream()
-            .filter(id -> id != null && id != -1L)
-            .collect(Collectors.toMap(
-                Function.identity(),
-                this::getBlockedUserIds,
-                (existing, replacement) -> existing // 중복 키 처리
-            ));
-    }
-
-    /**
-     * 사용자 차단 (실제 운영용 메서드)
-     *
-     * @param currentUserId 차단하는 사용자 ID
-     * @param targetUserId 차단할 사용자 ID
-     * @param reason 차단 사유
-     * @return 생성된 차단 관계
-     */
-    @Transactional
-    @CacheEvict(value = "blocked_users", key = "#currentUserId")
-    public UserBlock blockUser(Long currentUserId, Long targetUserId, String reason) {
-        validateBlockRequest(currentUserId, targetUserId);
-        return createBlock(currentUserId, targetUserId, reason);
-    }
-
-    /**
-     * 사용자 차단 해제 (실제 운영용 메서드)
-     *
-     * @param currentUserId 차단 해제하는 사용자 ID
-     * @param targetUserId 차단 해제할 사용자 ID
-     */
-    @Transactional
-    @CacheEvict(value = "blocked_users", key = "#currentUserId")
-    public void unblockUser(Long currentUserId, Long targetUserId) {
-        validateBlockRequest(currentUserId, targetUserId);
-        removeBlock(currentUserId, targetUserId);
-    }
-
-    /**
-     * 차단 관계 생성 (내부용 - 테스트에서도 사용)
-     *
-     * @param blockerId 차단한 사용자 ID
-     * @param blockedId 차단될 사용자 ID
-     * @param reason 차단 사유
-     * @return 생성된 차단 관계
-     */
-    @Transactional
-    @CacheEvict(value = "blocked_users", key = "#blockerId")
-    public UserBlock createBlock(Long blockerId, Long blockedId, String reason) {
-        validateBlockRequest(blockerId, blockedId);
-
-        // 이미 차단된 관계인지 확인
-        if (userBlockRepository.existsByBlockerIdAndBlockedId(blockerId, blockedId)) {
-            log.warn("이미 차단된 관계입니다 - blockerId: {}, blockedId: {}", blockerId, blockedId);
-            return userBlockRepository.findByBlockerIdAndBlockedId(blockerId, blockedId)
-                .orElseThrow(() -> new IllegalStateException("차단 관계 조회 실패"));
-        }
-
-        try {
-            UserBlock userBlock = UserBlock.create(blockerId, blockedId, reason);
-            UserBlock savedBlock = userBlockRepository.save(userBlock);
-            
-            log.info("차단 관계 생성 완료 - blockerId: {}, blockedId: {}, reason: {}", 
-                    blockerId, blockedId, reason);
-            
-            return savedBlock;
-        } catch (Exception e) {
-            log.error("차단 관계 생성 실패 - blockerId: {}, blockedId: {}, error: {}", 
-                     blockerId, blockedId, e.getMessage());
-            throw new RuntimeException("차단 관계 생성에 실패했습니다.", e);
-        }
-    }
-
-    /**
-     * 차단 관계 해제
-     *
-     * @param blockerId 차단한 사용자 ID
-     * @param blockedId 차단 해제할 사용자 ID
-     */
-    @Transactional
-    @CacheEvict(value = "blocked_users", key = "#blockerId")
-    public void removeBlock(Long blockerId, Long blockedId) {
-        validateBlockRequest(blockerId, blockedId);
-
-        try {
-            UserBlock userBlock = userBlockRepository.findByBlockerIdAndBlockedId(blockerId, blockedId)
-                .orElse(null);
-
-            if (userBlock != null) {
-                userBlockRepository.delete(userBlock);
-                log.info("차단 관계 해제 완료 - blockerId: {}, blockedId: {}", blockerId, blockedId);
-            } else {
-                log.warn("해제할 차단 관계가 없습니다 - blockerId: {}, blockedId: {}", blockerId, blockedId);
-            }
-        } catch (Exception e) {
-            log.error("차단 관계 해제 실패 - blockerId: {}, blockedId: {}, error: {}", 
-                     blockerId, blockedId, e.getMessage());
-            throw new RuntimeException("차단 관계 해제에 실패했습니다.", e);
-        }
-    }
-
-    /**
-     * 차단 요청 유효성 검증
-     */
-    private void validateBlockRequest(Long blockerId, Long blockedId) {
-        if (blockerId == null || blockedId == null) {
-            throw new IllegalArgumentException("사용자 ID는 null일 수 없습니다.");
-        }
-        
-        if (blockerId.equals(blockedId)) {
-            throw new IllegalArgumentException("자기 자신을 차단할 수 없습니다.");
-        }
-        
-        if (blockerId == -1L) {
-            throw new IllegalArgumentException("익명 사용자는 차단 기능을 사용할 수 없습니다.");
-        }
-    }
-
-    /**
-     * 특정 사용자의 차단 통계 조회
-     *
-     * @param userId 사용자 ID
-     * @return 차단 통계 정보
-     */
-    @Transactional(readOnly = true)
-    public BlockStatistics getBlockStatistics(Long userId) {
-        if (userId == null || userId == -1L) {
-            return new BlockStatistics(0L, 0L);
-        }
-
-        try {
-            long blockedCount = userBlockRepository.countByBlockerId(userId);
-            long blockedByCount = userBlockRepository.countByBlockedId(userId);
-            
-            return new BlockStatistics(blockedCount, blockedByCount);
-        } catch (Exception e) {
-            log.error("차단 통계 조회 실패 - userId: {}, error: {}", userId, e.getMessage());
-            return new BlockStatistics(0L, 0L);
-        }
-    }
-
-    /**
-     * 차단 통계 정보를 담는 record
-     */
-    public record BlockStatistics(
-        long blockedCount,      // 내가 차단한 사용자 수
-        long blockedByCount     // 나를 차단한 사용자 수
-    ) {}
-}
diff --git a/src/main/java/app/bottlenote/review/controller/ReviewController.java b/src/main/java/app/bottlenote/review/controller/ReviewController.java
index e5b965996..4e154a604 100644
--- a/src/main/java/app/bottlenote/review/controller/ReviewController.java
+++ b/src/main/java/app/bottlenote/review/controller/ReviewController.java
@@ -1,6 +1,6 @@
 package app.bottlenote.review.controller;
 
-import app.bottlenote.global.annotation.BlockFilter;
+import app.bottlenote.common.block.annotation.BlockFilter;
 import app.bottlenote.global.data.response.GlobalResponse;
 import app.bottlenote.global.security.SecurityContextUtil;
 import app.bottlenote.global.service.cursor.PageResponse;

From c0a73f9cd50036ab7afeb691667b9759009479e7 Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Fri, 27 Jun 2025 12:56:47 +0900
Subject: [PATCH 03/16] feat: implement user blocking functionality with
 BlockWord annotation and related services

Signed-off-by: hgkim <hgkim@openerd.com>
---
 ...352\263\204_\354\203\235\354\204\261.http" |  31 ---
 ...353\266\200_\355\231\225\354\235\270.http" |  15 --
 ...353\241\235_\354\241\260\355\232\214.http" |  15 --
 ...352\263\204_\354\241\260\355\232\214.http" |  15 --
 ...352\263\204_\355\225\264\354\240\234.http" |  15 --
 ...\355\205\214\354\212\244\355\212\270.http" |  47 ----
 ...\355\205\214\354\212\244\355\212\270.http" |   6 -
 http/block/README.md                          | 107 --------
 http/block/block-blur-test.http               |  10 -
 ...\355\205\214\354\212\244\355\212\270.http" |  38 +++
 .../block/annotation/BlockFilter.java.bak     |  38 ---
 .../common/block/annotation/BlockWord.java    |  11 +-
 .../block/aspect/BlockFilterAspect.java.bak   | 238 ------------------
 .../common/block/config/BlockWordConfig.java  |  24 +-
 .../controller/BlockTestController.java.bak   |  70 ------
 .../block/serializer/BlockWordSerializer.java |  37 +--
 .../common/block/service/BlockService.java    |  48 ----
 .../java/app/bottlenote/common/block/v1.0.md  | 158 ------------
 .../java/app/bottlenote/common/block/v1.1.md  | 189 --------------
 .../java/app/bottlenote/common/block/v1.3.md  | 181 -------------
 .../java/app/bottlenote/common/block/v1.4.md  | 154 ------------
 .../java/app/bottlenote/common/block/v1.5.md  | 192 --------------
 .../review/controller/ReviewController.java   |   3 -
 .../review/facade/payload/ReviewInfo.java     |  66 ++---
 .../review/facade/payload/UserInfo.java       |   9 +-
 .../block/controller/BlockController.java     |  73 ++++++
 .../block}/domain/UserBlock.java              |   7 +-
 .../block/exception/BlockException.java       |  10 +
 .../block/exception/BlockExceptionCode.java   |  29 +++
 .../repository/JpaUserBlockRepository.java    |   5 +-
 .../repository}/UserBlockRepository.java      |   4 +-
 .../support/block/service/BlockService.java   | 174 +++++++++++++
 src/main/resources/application-logging.yml    |   3 +
 33 files changed, 407 insertions(+), 1615 deletions(-)
 delete mode 100644 "http/block/01-\354\260\250\353\213\250_\352\264\200\352\263\204_\354\203\235\354\204\261.http"
 delete mode 100644 "http/block/02-\354\260\250\353\213\250_\354\227\254\353\266\200_\355\231\225\354\235\270.http"
 delete mode 100644 "http/block/03-\354\260\250\353\213\250_\353\252\251\353\241\235_\354\241\260\355\232\214.http"
 delete mode 100644 "http/block/04-\354\260\250\353\213\250_\355\206\265\352\263\204_\354\241\260\355\232\214.http"
 delete mode 100644 "http/block/05-\354\260\250\353\213\250_\352\264\200\352\263\204_\355\225\264\354\240\234.http"
 delete mode 100644 "http/block/06-\354\260\250\353\213\250_\355\225\204\355\204\260_\355\205\214\354\212\244\355\212\270.http"
 delete mode 100644 "http/block/07-\354\240\204\354\262\264_\354\264\210\352\270\260\355\231\224_\355\205\214\354\212\244\355\212\270.http"
 delete mode 100644 http/block/README.md
 delete mode 100644 http/block/block-blur-test.http
 create mode 100644 "http/block/\354\260\250\353\213\250_\355\225\204\355\204\260\353\247\201_\355\205\214\354\212\244\355\212\270.http"
 delete mode 100644 src/main/java/app/bottlenote/common/block/annotation/BlockFilter.java.bak
 delete mode 100644 src/main/java/app/bottlenote/common/block/aspect/BlockFilterAspect.java.bak
 delete mode 100644 src/main/java/app/bottlenote/common/block/controller/BlockTestController.java.bak
 delete mode 100644 src/main/java/app/bottlenote/common/block/service/BlockService.java
 delete mode 100644 src/main/java/app/bottlenote/common/block/v1.0.md
 delete mode 100644 src/main/java/app/bottlenote/common/block/v1.1.md
 delete mode 100644 src/main/java/app/bottlenote/common/block/v1.3.md
 delete mode 100644 src/main/java/app/bottlenote/common/block/v1.4.md
 delete mode 100644 src/main/java/app/bottlenote/common/block/v1.5.md
 create mode 100644 src/main/java/app/bottlenote/support/block/controller/BlockController.java
 rename src/main/java/app/bottlenote/{user => support/block}/domain/UserBlock.java (87%)
 create mode 100644 src/main/java/app/bottlenote/support/block/exception/BlockException.java
 create mode 100644 src/main/java/app/bottlenote/support/block/exception/BlockExceptionCode.java
 rename src/main/java/app/bottlenote/{user => support/block}/repository/JpaUserBlockRepository.java (89%)
 rename src/main/java/app/bottlenote/{user/domain => support/block/repository}/UserBlockRepository.java (94%)
 create mode 100644 src/main/java/app/bottlenote/support/block/service/BlockService.java

diff --git "a/http/block/01-\354\260\250\353\213\250_\352\264\200\352\263\204_\354\203\235\354\204\261.http" "b/http/block/01-\354\260\250\353\213\250_\352\264\200\352\263\204_\354\203\235\354\204\261.http"
deleted file mode 100644
index 29264d208..000000000
--- "a/http/block/01-\354\260\250\353\213\250_\352\264\200\352\263\204_\354\203\235\354\204\261.http"
+++ /dev/null
@@ -1,31 +0,0 @@
-### 토큰 발급 (선택사항 - 토큰이 필요한 경우)
-POST {{host}}/api/v1/oauth/login
-Content-Type: application/json
-
-{
-  "email": "dev.bottle-note@gmail.com",
-  "socialType": "GOOGLE",
-  "gender": "MALE",
-  "age": 25
-}
-
-> {%
-    //토큰을 전역변수로 저장
-    client.global.set("accessToken", response.body.data.accessToken);
-%}
-
-### 차단 관계 생성 테스트
-POST {{host}}/api/v1/test/block/add?blockerId=1&blockedId=2&reason=테스트 차단
-Content-Type: application/json
-
-### 차단 관계 생성 (기본 사유)
-POST {{host}}/api/v1/test/block/add?blockerId=1&blockedId=3
-Content-Type: application/json
-
-### 차단 관계 생성 (커스텀 사유)
-POST {{host}}/api/v1/test/block/add?blockerId=2&blockedId=1&reason=부적절한 댓글
-Content-Type: application/json
-
-### 차단 관계 생성 실패 케이스 (동일 사용자)  
-POST {{host}}/api/v1/test/block/add?blockerId=1&blockedId=1&reason=자기 자신 차단
-Content-Type: application/json
\ No newline at end of file
diff --git "a/http/block/02-\354\260\250\353\213\250_\354\227\254\353\266\200_\355\231\225\354\235\270.http" "b/http/block/02-\354\260\250\353\213\250_\354\227\254\353\266\200_\355\231\225\354\235\270.http"
deleted file mode 100644
index 1d67b2c9d..000000000
--- "a/http/block/02-\354\260\250\353\213\250_\354\227\254\353\266\200_\355\231\225\354\235\270.http"
+++ /dev/null
@@ -1,15 +0,0 @@
-### 차단 여부 확인 (차단된 경우)
-GET {{host}}/api/v1/test/block/check?blockerId=1&blockedId=2
-Content-Type: application/json
-
-### 차단 여부 확인 (차단되지 않은 경우)
-GET {{host}}/api/v1/test/block/check?blockerId=1&blockedId=5
-Content-Type: application/json
-
-### 차단 여부 확인 (반대 방향)
-GET {{host}}/api/v1/test/block/check?blockerId=2&blockedId=1
-Content-Type: application/json
-
-### 차단 여부 확인 (존재하지 않는 사용자)
-GET {{host}}/api/v1/test/block/check?blockerId=999&blockedId=888
-Content-Type: application/json
\ No newline at end of file
diff --git "a/http/block/03-\354\260\250\353\213\250_\353\252\251\353\241\235_\354\241\260\355\232\214.http" "b/http/block/03-\354\260\250\353\213\250_\353\252\251\353\241\235_\354\241\260\355\232\214.http"
deleted file mode 100644
index fc73a52d8..000000000
--- "a/http/block/03-\354\260\250\353\213\250_\353\252\251\353\241\235_\354\241\260\355\232\214.http"
+++ /dev/null
@@ -1,15 +0,0 @@
-### 차단 목록 조회 (차단한 사용자들이 있는 경우)
-GET {{host}}/api/v1/test/block/list/1
-Content-Type: application/json
-
-### 차단 목록 조회 (차단한 사용자가 없는 경우)  
-GET {{host}}/api/v1/test/block/list/10
-Content-Type: application/json
-
-### 차단 목록 조회 (여러 사용자를 차단한 경우)
-GET {{host}}/api/v1/test/block/list/2
-Content-Type: application/json
-
-### 차단 목록 조회 (존재하지 않는 사용자)
-GET {{host}}/api/v1/test/block/list/999
-Content-Type: application/json
\ No newline at end of file
diff --git "a/http/block/04-\354\260\250\353\213\250_\355\206\265\352\263\204_\354\241\260\355\232\214.http" "b/http/block/04-\354\260\250\353\213\250_\355\206\265\352\263\204_\354\241\260\355\232\214.http"
deleted file mode 100644
index a477b571c..000000000
--- "a/http/block/04-\354\260\250\353\213\250_\355\206\265\352\263\204_\354\241\260\355\232\214.http"
+++ /dev/null
@@ -1,15 +0,0 @@
-### 차단 통계 조회 (차단 내역이 있는 사용자)
-GET {{host}}/api/v1/test/block/statistics/1
-Content-Type: application/json
-
-### 차단 통계 조회 (차단 내역이 없는 사용자)
-GET {{host}}/api/v1/test/block/statistics/10
-Content-Type: application/json
-
-### 차단 통계 조회 (많은 차단 내역이 있는 사용자)
-GET {{host}}/api/v1/test/block/statistics/2
-Content-Type: application/json
-
-### 차단 통계 조회 (존재하지 않는 사용자)
-GET {{host}}/api/v1/test/block/statistics/999
-Content-Type: application/json
\ No newline at end of file
diff --git "a/http/block/05-\354\260\250\353\213\250_\352\264\200\352\263\204_\355\225\264\354\240\234.http" "b/http/block/05-\354\260\250\353\213\250_\352\264\200\352\263\204_\355\225\264\354\240\234.http"
deleted file mode 100644
index bed251f37..000000000
--- "a/http/block/05-\354\260\250\353\213\250_\352\264\200\352\263\204_\355\225\264\354\240\234.http"
+++ /dev/null
@@ -1,15 +0,0 @@
-### 차단 관계 해제 (기존 차단 관계)
-DELETE {{host}}/api/v1/test/block/remove?blockerId=1&blockedId=2
-Content-Type: application/json
-
-### 차단 관계 해제 (또 다른 차단 관계)
-DELETE {{host}}/api/v1/test/block/remove?blockerId=1&blockedId=3
-Content-Type: application/json
-
-### 차단 관계 해제 (존재하지 않는 차단 관계)
-DELETE {{host}}/api/v1/test/block/remove?blockerId=1&blockedId=10
-Content-Type: application/json
-
-### 차단 관계 해제 (반대 방향)
-DELETE {{host}}/api/v1/test/block/remove?blockerId=2&blockedId=1
-Content-Type: application/json
\ No newline at end of file
diff --git "a/http/block/06-\354\260\250\353\213\250_\355\225\204\355\204\260_\355\205\214\354\212\244\355\212\270.http" "b/http/block/06-\354\260\250\353\213\250_\355\225\204\355\204\260_\355\205\214\354\212\244\355\212\270.http"
deleted file mode 100644
index ac175c16e..000000000
--- "a/http/block/06-\354\260\250\353\213\250_\355\225\204\355\204\260_\355\205\214\354\212\244\355\212\270.http"
+++ /dev/null
@@ -1,47 +0,0 @@
-### 테스트 시나리오 준비 - 차단 관계 생성
-# 먼저 사용자 1이 사용자 2,3을 차단하도록 설정
-POST {{host}}/api/v1/test/block/add?blockerId=1&blockedId=2&reason=테스트 차단
-Content-Type: application/json
-
-###
-POST {{host}}/api/v1/test/block/add?blockerId=1&blockedId=3&reason=테스트 차단
-Content-Type: application/json
-
-### 1. 차단 필터 테스트 (차단하지 않은 사용자로 요청)
-# 사용자 5는 아무도 차단하지 않았으므로 모든 리뷰가 그대로 보임
-GET {{host}}/api/v1/test/block/test-data/5
-Content-Type: application/json
-X-User-Id: 5
-
-### 2. 차단 필터 테스트 (차단한 사용자가 있는 경우)
-# 사용자 1이 사용자 2,3을 차단했으므로 해당 리뷰가 마스킹되어야 함
-GET {{host}}/api/v1/test/block/test-data/1
-Content-Type: application/json
-X-User-Id: 1
-
-### 3. 차단 필터 테스트 (다른 사용자로 요청)
-# 사용자 4는 아무도 차단하지 않았으므로 모든 리뷰가 그대로 보임  
-GET {{host}}/api/v1/test/block/test-data/4
-Content-Type: application/json
-X-User-Id: 4
-
-### 4. 차단 여부 확인 (사전 확인)
-# 사용자 1이 사용자 2를 차단했는지 확인
-GET {{host}}/api/v1/test/block/check?blockerId=1&blockedId=2
-Content-Type: application/json
-
-### 5. 차단 목록 확인
-# 사용자 1의 차단 목록 확인 (2,3이 나와야 함)
-GET {{host}}/api/v1/test/block/list/1
-Content-Type: application/json
-
-### 6. 차단 해제 후 재테스트
-# 사용자 1이 사용자 2의 차단을 해제
-DELETE {{host}}/api/v1/test/block/remove?blockerId=1&blockedId=2
-Content-Type: application/json
-
-###
-# 차단 해제 후 다시 테스트 (사용자 2의 리뷰가 다시 보여야 함)
-GET {{host}}/api/v1/test/block/test-data/1
-Content-Type: application/json
-X-User-Id: 1
\ No newline at end of file
diff --git "a/http/block/07-\354\240\204\354\262\264_\354\264\210\352\270\260\355\231\224_\355\205\214\354\212\244\355\212\270.http" "b/http/block/07-\354\240\204\354\262\264_\354\264\210\352\270\260\355\231\224_\355\205\214\354\212\244\355\212\270.http"
deleted file mode 100644
index 66614909a..000000000
--- "a/http/block/07-\354\240\204\354\262\264_\354\264\210\352\270\260\355\231\224_\355\205\214\354\212\244\355\212\270.http"
+++ /dev/null
@@ -1,6 +0,0 @@
-### 전체 차단 관계 초기화 (비활성화된 기능)
-DELETE {{host}}/api/v1/test/block/clear
-Content-Type: application/json
-
-### 참고: 이 기능은 DB 기반으로 변경되어 비활성화되었습니다.
-### 실제로는 개별 차단 해제를 사용해야 합니다.
\ No newline at end of file
diff --git a/http/block/README.md b/http/block/README.md
deleted file mode 100644
index 66bc3a1b0..000000000
--- a/http/block/README.md
+++ /dev/null
@@ -1,107 +0,0 @@
-# Block API 테스트 가이드
-
-이 디렉토리는 `BlockTestController`의 차단 기능을 테스트하기 위한 HTTP 파일들을 포함합니다.
-
-## 🔧 사전 준비
-
-1. **환경 설정**: 이 컨트롤러는 `local`, `dev`, `test` 환경에서만 동작합니다 (`prod` 환경에서는 비활성화)
-2. **환경 변수**: IntelliJ HTTP Client에서 `http-client.env.json` 파일의 환경을 선택해야 합니다
-   - `local`: http://localhost:30001
-   - `dev`: http://localhost:30001  
-   - `prod`: https://api.bottle-note.com/
-3. **인증**: Block API (`/api/v1/test/**`)는 인증이 필요하지 않습니다 (Spring Security에서 `permitAll()` 설정)
-4. **토큰 (선택사항)**: 필요시 01번 파일의 토큰 발급 API를 사용하여 `accessToken` 변수를 설정할 수 있습니다
-
-## 📁 테스트 파일 구성
-
-### 01-차단_관계_생성.http
-- **목적**: 차단 관계를 생성하는 API 테스트
-- **엔드포인트**: `POST /api/v1/test/block/add`
-- **파라미터**:
-  - `blockerId`: 차단하는 사용자 ID (필수)
-  - `blockedId`: 차단당하는 사용자 ID (필수)  
-  - `reason`: 차단 사유 (선택, 기본값: "테스트 차단")
-
-### 02-차단_여부_확인.http
-- **목적**: 두 사용자 간 차단 여부를 확인하는 API 테스트
-- **엔드포인트**: `GET /api/v1/test/block/check`
-- **파라미터**:
-  - `blockerId`: 차단하는 사용자 ID
-  - `blockedId`: 차단당하는 사용자 ID
-
-### 03-차단_목록_조회.http
-- **목적**: 특정 사용자가 차단한 사용자 목록을 조회하는 API 테스트
-- **엔드포인트**: `GET /api/v1/test/block/list/{userId}`
-- **경로 변수**: `userId` - 차단 목록을 조회할 사용자 ID
-
-### 04-차단_통계_조회.http
-- **목적**: 특정 사용자의 차단 통계를 조회하는 API 테스트
-- **엔드포인트**: `GET /api/v1/test/block/statistics/{userId}`
-- **경로 변수**: `userId` - 통계를 조회할 사용자 ID
-
-### 05-차단_관계_해제.http
-- **목적**: 차단 관계를 해제하는 API 테스트
-- **엔드포인트**: `DELETE /api/v1/test/block/remove`
-- **파라미터**:
-  - `blockerId`: 차단을 해제할 사용자 ID
-  - `blockedId`: 차단 해제 대상 사용자 ID
-
-### 06-차단_필터_테스트.http
-- **목적**: `@BlockFilter` 어노테이션이 적용된 API에서 차단된 사용자의 데이터가 필터링되는지 테스트
-- **엔드포인트**: `GET /api/v1/test/block/test-data/{userId}`
-- **경로 변수**: `userId` - 경로의 사용자 ID (실제로는 사용되지 않음)
-- **헤더**: `X-User-Id` - 실제 요청하는 사용자 ID (테스트용 SecurityContext 설정)
-- **특징**: 
-  - 실제 리뷰 구조와 유사한 응답 데이터 제공
-  - 차단한 사용자들의 데이터는 "차단된 사용자의 글입니다"로 마스킹됨
-  - 차단된 사용자의 닉네임이 "차단된 사용자"로 변경됨
-  - 프로필 이미지도 null로 처리됨
-
-### 07-전체_초기화_테스트.http
-- **목적**: 전체 차단 관계 초기화 API 테스트 (현재 비활성화됨)
-- **엔드포인트**: `DELETE /api/v1/test/block/clear`
-- **참고**: DB 기반으로 변경되어 안전상의 이유로 비활성화된 기능입니다
-
-## 🚀 테스트 시나리오 예시
-
-### 기본 시나리오
-1. **차단 관계 생성**: 사용자 1이 사용자 2를 차단
-2. **차단 여부 확인**: 1 → 2 차단 확인 (true), 2 → 1 차단 확인 (false)
-3. **차단 목록 조회**: 사용자 1의 차단 목록에 사용자 2가 포함되는지 확인
-4. **차단 필터 테스트**: 사용자 1로 요청 시 사용자 2의 데이터가 필터링되는지 확인
-5. **차단 관계 해제**: 사용자 1이 사용자 2의 차단을 해제
-6. **차단 여부 재확인**: 1 → 2 차단 확인 (false)
-
-### 고급 시나리오
-1. **상호 차단**: 사용자 1과 사용자 2가 서로 차단
-2. **다중 차단**: 사용자 1이 여러 사용자(2, 3, 4)를 차단
-3. **통계 확인**: 각 사용자별 차단 통계 조회
-4. **필터링 확인**: 차단된 사용자들의 데이터가 모두 필터링되는지 확인
-
-## ⚠️ 주의사항
-
-1. **환경 제한**: `prod` 환경에서는 이 API들을 사용할 수 없습니다
-2. **데이터 정합성**: 실제 운영 데이터와 연동되므로 테스트 시 주의가 필요합니다
-3. **사용자 ID**: 존재하지 않는 사용자 ID로 테스트할 경우 예외가 발생할 수 있습니다
-4. **전체 초기화**: 안전상의 이유로 비활성화되어 있으므로 개별 해제를 사용해야 합니다
-
-## 🔍 응답 형태
-
-모든 API는 `GlobalResponse` 형태로 응답합니다:
-
-```json
-{
-  "success": true,
-  "message": "성공 메시지",
-  "data": "응답 데이터"
-}
-```
-
-실패 시:
-```json
-{
-  "success": false,
-  "message": "실패 메시지",
-  "data": null
-}
-```
\ No newline at end of file
diff --git a/http/block/block-blur-test.http b/http/block/block-blur-test.http
deleted file mode 100644
index b201ca1a9..000000000
--- a/http/block/block-blur-test.http
+++ /dev/null
@@ -1,10 +0,0 @@
-### 블러 처리 테스트 - 차단 관계가 있는 사용자 1의 경우
-# 사용자 1이 사용자 2,3을 차단했으므로 해당 리뷰들이 블러 처리되어야 함
-GET {{host}}/api/v1/test/block/reviews
-Content-Type: application/json
-
-### 결과 확인:
-# - 사용자 2,3의 reviewContent가 "차단된 사용자의 글입니다"로 변경
-# - 사용자 2,3의 authorNickname이 "차단된 사용자의 글입니다"로 변경  
-# - 사용자 2,3의 authorProfileImage가 null로 변경
-# - 사용자 1,4,5의 리뷰는 정상 표시
\ No newline at end of file
diff --git "a/http/block/\354\260\250\353\213\250_\355\225\204\355\204\260\353\247\201_\355\205\214\354\212\244\355\212\270.http" "b/http/block/\354\260\250\353\213\250_\355\225\204\355\204\260\353\247\201_\355\205\214\354\212\244\355\212\270.http"
new file mode 100644
index 000000000..575fc8107
--- /dev/null
+++ "b/http/block/\354\260\250\353\213\250_\355\225\204\355\204\260\353\247\201_\355\205\214\354\212\244\355\212\270.http"
@@ -0,0 +1,38 @@
+### @BlockWord 시리얼라이저 테스트
+
+### 토큰 발급 (일반)
+# @no-cookie-jar
+POST {{host}}/api/v1/oauth/login
+Content-Type: application/json
+
+{
+    "email": "rkdtkfma@naver.com",
+    "socialType": "KAKAO"
+}
+
+> {%
+    //토큰을 전역변수로 저장
+    client.global.set("accessToken", response.body.data.accessToken);
+%}
+
+
+### 1. 차단 관계 생성
+POST {{host}}/api/v1/blocks/create
+Content-Type: application/json
+Authorization: Bearer {{accessToken}}
+
+{
+    "blockedUserId": 3
+}
+
+### 1-1. 차단 목록 조회 (차단이 제대로 되었는지 확인)
+GET {{host}}/api/v1/blocks
+Authorization: Bearer {{accessToken}}
+
+### 2. 리뷰 조회 - 차단된 사용자 컨텐츠 필터링 확인
+GET {{host}}/api/v1/reviews/274
+Authorization: Bearer {{accessToken}}
+
+### 3. 리뷰 상세 조회 - 차단된 사용자 컨텐츠 필터링 확인
+GET {{host}}/api/v1/reviews/detail/1
+Authorization: Bearer {{accessToken}}
diff --git a/src/main/java/app/bottlenote/common/block/annotation/BlockFilter.java.bak b/src/main/java/app/bottlenote/common/block/annotation/BlockFilter.java.bak
deleted file mode 100644
index 001bf0512..000000000
--- a/src/main/java/app/bottlenote/common/block/annotation/BlockFilter.java.bak
+++ /dev/null
@@ -1,38 +0,0 @@
-package app.bottlenote.common.block.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * 차단된 사용자의 컨텐츠를 블러 처리하는 어노테이션
- * 
- * 사용 예시:
- * @BlockFilter(
- *     userField = "authorId", 
- *     blurFields = {"reviewContent", "authorNickname", "authorProfileImage"}
- * )
- * @GetMapping("/reviews") 
- * public ResponseEntity<?> getReviews() { ... }
- */
-@Target(ElementType.METHOD)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface BlockFilter {
-
-    /**
-     * 응답 객체에서 사용자 ID를 추출할 필드명
-     * 예: "authorId", "userId", "writerId"
-     */
-    String userField() default "authorId";
-    
-    /**
-     * 블러 처리할 필드명 배열
-     * 차단된 사용자의 경우 이 필드들이 "차단된 사용자의 글입니다"로 대체됨
-     */
-    String[] blurFields() default {
-        "content", "reviewContent", "title", 
-        "authorNickname", "nickname", 
-        "authorProfileImage", "profileImage"
-    };
-}
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/annotation/BlockWord.java b/src/main/java/app/bottlenote/common/block/annotation/BlockWord.java
index f4ac91625..682027774 100644
--- a/src/main/java/app/bottlenote/common/block/annotation/BlockWord.java
+++ b/src/main/java/app/bottlenote/common/block/annotation/BlockWord.java
@@ -1,5 +1,8 @@
 package app.bottlenote.common.block.annotation;
 
+import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -11,18 +14,20 @@
  */
 @Target(ElementType.FIELD)
 @Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotationsInside
+@JsonSerialize(using = app.bottlenote.common.block.serializer.BlockWordSerializer.class)
 public @interface BlockWord {
-    
+
     /**
      * 차단된 사용자 컨텐츠 대체 메시지
      * 기본값: "차단된 사용자의 글입니다"
      */
     String value() default "차단된 사용자의 글입니다";
-    
+
     /**
      * 차단 판단 기준이 되는 사용자 ID 경로
      * 기본값: "userId"
      * 중첩 객체 예시: "userInfo.userId"
      */
     String userIdPath() default "userId";
-}
\ No newline at end of file
+}
diff --git a/src/main/java/app/bottlenote/common/block/aspect/BlockFilterAspect.java.bak b/src/main/java/app/bottlenote/common/block/aspect/BlockFilterAspect.java.bak
deleted file mode 100644
index bbe8632a7..000000000
--- a/src/main/java/app/bottlenote/common/block/aspect/BlockFilterAspect.java.bak
+++ /dev/null
@@ -1,238 +0,0 @@
-package app.bottlenote.common.block.aspect;
-
-import app.bottlenote.common.block.annotation.BlockFilter;
-import app.bottlenote.common.block.service.BlockService;
-import app.bottlenote.global.data.response.GlobalResponse;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.aspectj.lang.ProceedingJoinPoint;
-import org.aspectj.lang.annotation.Around;
-import org.aspectj.lang.annotation.Aspect;
-import org.springframework.http.ResponseEntity;
-import org.springframework.stereotype.Component;
-
-import java.lang.reflect.Field;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-/**
- * 간소화된 차단 필터 AOP
- * 핵심 기능: 차단된 사용자의 컨텐츠를 블러 처리
- */
-@Slf4j
-@Aspect
-@Component
-@RequiredArgsConstructor
-public class BlockFilterAspect {
-
-    private final BlockService blockService;
-    private final ObjectMapper objectMapper;
-
-    @Around("@annotation(blockFilter)")
-    public Object applyBlockFilter(ProceedingJoinPoint joinPoint, BlockFilter blockFilter) throws Throwable {
-
-        // 1. 원본 메서드 실행
-        Object result = joinPoint.proceed();
-
-        // 2. 현재 사용자 ID 추출 (테스트용으로 헤더에서 가져옴)
-        Long currentUserId = extractCurrentUserId();
-
-        if (currentUserId == -1L) {
-            log.debug("인증되지 않은 사용자 - 차단 필터 적용하지 않음");
-            return result;
-        }
-
-        // 3. 차단된 사용자 목록 조회
-        Set<Long> blockedUserIds = blockService.getBlockedUserIds(currentUserId);
-
-        if (blockedUserIds.isEmpty()) {
-            log.debug("차단한 사용자가 없음 - 필터링 건너뜀");
-            return result;
-        }
-
-        log.info("차단 필터 적용: 사용자 {}, 차단 대상 {}", currentUserId, blockedUserIds);
-
-        // 4. 응답 데이터에 블러 처리 적용
-        return applyBlurFilter(result, blockedUserIds, blockFilter);
-    }
-
-    /**
-     * 테스트용: 현재 사용자 ID 추출
-     * 실제 운영에서는 SecurityContext에서 가져옴
-     */
-    private Long extractCurrentUserId() {
-        // 현재는 테스트를 위해 고정값 반환
-        // 실제로는 SecurityContextUtil.getUserIdByContext() 사용
-        return 1L; // 테스트용: 사용자 1로 고정
-    }
-
-    /**
-     * 응답 데이터에 블러 처리 적용
-     */
-    private Object applyBlurFilter(Object result, Set<Long> blockedUserIds, BlockFilter blockFilter) {
-
-        if (!(result instanceof ResponseEntity)) {
-            return result;
-        }
-
-        ResponseEntity<?> responseEntity = (ResponseEntity<?>) result;
-        Object body = responseEntity.getBody();
-
-        if (!(body instanceof GlobalResponse)) {
-            return result;
-        }
-
-        GlobalResponse globalResponse = (GlobalResponse) body;
-        Object data = globalResponse.getData();
-
-        if (data == null) {
-            return result;
-        }
-
-        // 데이터 타입에 따른 블러 처리
-        Object blurredData;
-        if (data instanceof List) {
-            blurredData = blurListData((List<?>) data, blockedUserIds, blockFilter);
-        } else {
-            blurredData = blurSingleData(data, blockedUserIds, blockFilter);
-        }
-
-        // 블러 처리된 데이터로 새로운 응답 생성
-        GlobalResponse blurredResponse = GlobalResponse.success(blurredData);
-        return ResponseEntity.ok(blurredResponse);
-    }
-
-    /**
-     * List 형태의 데이터 블러 처리
-     */
-    @SuppressWarnings("unchecked")
-    private List<?> blurListData(List<?> dataList, Set<Long> blockedUserIds, BlockFilter blockFilter) {
-        return dataList.stream()
-                .map(item -> blurItemIfBlocked(item, blockedUserIds, blockFilter))
-                .collect(Collectors.toList());
-    }
-
-    /**
-     * 단일 객체 데이터 블러 처리
-     */
-    private Object blurSingleData(Object data, Set<Long> blockedUserIds, BlockFilter blockFilter) {
-        return blurItemIfBlocked(data, blockedUserIds, blockFilter);
-    }
-
-    /**
-     * 개별 항목 차단 여부 확인 후 블러 처리
-     */
-    private Object blurItemIfBlocked(Object item, Set<Long> blockedUserIds, BlockFilter blockFilter) {
-        if (item == null) {
-            return item;
-        }
-
-        // 사용자 ID 추출
-        Long userId = extractUserIdFromObject(item, blockFilter.userField());
-
-        if (userId == null || !blockedUserIds.contains(userId)) {
-            return item; // 차단된 사용자가 아니면 원본 반환
-        }
-
-        log.debug("차단된 사용자의 컨텐츠 블러 처리: userId={}", userId);
-
-        // 차단된 사용자면 블러 처리
-        return applyBlurToItem(item, blockFilter.blurFields());
-    }
-
-    /**
-     * 객체에서 사용자 ID를 추출
-     */
-    private Long extractUserIdFromObject(Object obj, String fieldName) {
-        try {
-            Field field = findFieldInClass(obj.getClass(), fieldName);
-            if (field != null) {
-                field.setAccessible(true);
-                Object value = field.get(obj);
-                if (value instanceof Long) {
-                    return (Long) value;
-                }
-            }
-        } catch (Exception e) {
-            log.warn("사용자 ID 추출 실패: 객체={}, 필드={}", obj.getClass().getSimpleName(), fieldName);
-        }
-        return null;
-    }
-
-    /**
-     * 클래스 계층구조에서 필드 찾기
-     */
-    private Field findFieldInClass(Class<?> clazz, String fieldName) {
-        Class<?> currentClass = clazz;
-        while (currentClass != null) {
-            try {
-                return currentClass.getDeclaredField(fieldName);
-            } catch (NoSuchFieldException e) {
-                currentClass = currentClass.getSuperclass();
-            }
-        }
-        return null;
-    }
-
-    /**
-     * 개별 항목에 블러 처리 적용
-     */
-    private Object applyBlurToItem(Object originalItem, String[] blurFields) {
-        try {
-            // Jackson을 사용한 깊은 복사
-            Object clonedItem = deepCloneObject(originalItem);
-
-            // 지정된 필드들을 "차단된 사용자의 글입니다"로 마스킹
-            for (String fieldName : blurFields) {
-                maskField(clonedItem, fieldName, "차단된 사용자의 글입니다");
-            }
-
-            return clonedItem;
-
-        } catch (Exception e) {
-            log.error("블러 처리 실패: {}", e.getMessage());
-            return originalItem; // 실패 시 원본 반환
-        }
-    }
-
-    /**
-     * 객체의 특정 필드를 마스킹
-     */
-    private void maskField(Object obj, String fieldName, String maskValue) {
-        try {
-            Field field = findFieldInClass(obj.getClass(), fieldName);
-            if (field != null) {
-                field.setAccessible(true);
-
-                // 필드 타입에 따라 적절한 마스킹 값 설정
-                if (fieldName.toLowerCase().contains("image") || fieldName.toLowerCase().contains("url")) {
-                    field.set(obj, null); // 이미지/URL은 null로 처리
-                } else {
-                    field.set(obj, maskValue); // 텍스트는 마스킹 메시지로 처리
-                }
-            }
-        } catch (Exception e) {
-            // 필드가 없거나 설정 실패 시 무시 (정상적인 상황)
-            log.debug("필드 마스킹 건너뜀: {}.{}", obj.getClass().getSimpleName(), fieldName);
-        }
-    }
-
-    /**
-     * Jackson을 사용한 깊은 복사
-     */
-    private Object deepCloneObject(Object original) {
-        try {
-            if (original == null) {
-                return null;
-            }
-
-            String jsonString = objectMapper.writeValueAsString(original);
-            return objectMapper.readValue(jsonString, original.getClass());
-        } catch (Exception e) {
-            log.warn("객체 복사 실패, 원본 반환: {}", e.getMessage());
-            return original;
-        }
-    }
-}
diff --git a/src/main/java/app/bottlenote/common/block/config/BlockWordConfig.java b/src/main/java/app/bottlenote/common/block/config/BlockWordConfig.java
index 5056a6cff..a1df56fc5 100644
--- a/src/main/java/app/bottlenote/common/block/config/BlockWordConfig.java
+++ b/src/main/java/app/bottlenote/common/block/config/BlockWordConfig.java
@@ -1,29 +1,19 @@
 package app.bottlenote.common.block.config;
 
-import app.bottlenote.common.block.serializer.BlockWordSerializer;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.module.SimpleModule;
-import jakarta.annotation.PostConstruct;
-import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Configuration;
 
 /**
  * BlockWord 시리얼라이저 설정
+ *
+ * @BlockWord 어노테이션에 @JsonSerialize가 직접 포함되어 있으므로
+ * 글로벌 시리얼라이저 등록은 불필요함
  */
+@Slf4j
 @Configuration
-@RequiredArgsConstructor
 public class BlockWordConfig {
 
-    private final ObjectMapper objectMapper;
-    private final BlockWordSerializer blockWordSerializer;
-
-    @PostConstruct
-    public void configureObjectMapper() {
-        SimpleModule blockWordModule = new SimpleModule("BlockWordModule");
-
-        // String 타입에 대해 @BlockWord 어노테이션이 있을 때 커스텀 시리얼라이저 사용
-        blockWordModule.addSerializer(String.class, blockWordSerializer);
-
-        objectMapper.registerModule(blockWordModule);
+    public BlockWordConfig() {
+        log.debug("BlockWordConfig 초기화 완료 - @BlockWord 어노테이션 자체에 @JsonSerialize 포함");
     }
 }
diff --git a/src/main/java/app/bottlenote/common/block/controller/BlockTestController.java.bak b/src/main/java/app/bottlenote/common/block/controller/BlockTestController.java.bak
deleted file mode 100644
index 61da4b552..000000000
--- a/src/main/java/app/bottlenote/common/block/controller/BlockTestController.java.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-package app.bottlenote.common.block.controller;
-
-import app.bottlenote.common.block.annotation.BlockFilter;
-import app.bottlenote.global.data.response.GlobalResponse;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.context.annotation.Profile;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-
-import java.time.LocalDateTime;
-import java.util.List;
-import java.util.Map;
-
-/**
- * 간소화된 차단 기능 테스트 컨트롤러
- * 핵심 기능: 블러 처리 테스트만 집중
- */
-@Slf4j
-@RestController
-@RequestMapping("/api/v1/test/block")
-@Profile({"local", "dev", "test", "!prod"})
-public class BlockTestController {
-
-    /**
-     * 블러 처리 테스트용 리뷰 목록 API
-     * 
-     * 차단 관계 (하드코딩):
-     * - 사용자 1 → 사용자 2,3 차단
-     * - 사용자 2 → 사용자 4 차단 
-     * - 사용자 3 → 사용자 1,5 차단
-     */
-    @BlockFilter(
-        userField = "authorId",
-        blurFields = {"reviewContent", "authorNickname", "authorProfileImage"}
-    )
-    @GetMapping("/reviews")
-    public ResponseEntity<?> getTestReviews() {
-        
-        log.info("블러 처리 테스트용 리뷰 목록 조회");
-        
-        List<Map<String, Object>> reviews = List.of(
-            createReview(1L, "정말 맛있는 위스키였습니다!", "위스키러버", "profile1.jpg"),
-            createReview(2L, "첫 시음인데 생각보다 좋네요", "초보위스키", "profile2.jpg"), 
-            createReview(3L, "가격 대비 훌륭합니다", "위스키마니아", "profile3.jpg"),
-            createReview(4L, "오크향이 강해서 호불호가 갈릴듯", "리뷰고수", "profile4.jpg"),
-            createReview(5L, "친구들과 마시기 좋았어요", "소셜드링커", "profile5.jpg")
-        );
-        
-        return GlobalResponse.ok(Map.of(
-            "totalCount", reviews.size(),
-            "reviews", reviews
-        ));
-    }
-    
-    /**
-     * 테스트용 리뷰 데이터 생성
-     */
-    private Map<String, Object> createReview(Long authorId, String content, String nickname, String profileImage) {
-        return Map.of(
-            "reviewId", 1000L + authorId,
-            "authorId", authorId,
-            "reviewContent", content,
-            "authorNickname", nickname,
-            "authorProfileImage", profileImage,
-            "createAt", LocalDateTime.now().minusDays(authorId),
-            "likeCount", (int)(Math.random() * 20),
-            "rating", 4.0 + (Math.random() * 1.0)
-        );
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java b/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java
index f2ef60231..f3adf9aba 100644
--- a/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java
+++ b/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java
@@ -1,15 +1,14 @@
 package app.bottlenote.common.block.serializer;
 
 import app.bottlenote.common.block.annotation.BlockWord;
-import app.bottlenote.common.block.service.BlockService;
 import app.bottlenote.global.security.SecurityContextUtil;
+import app.bottlenote.support.block.service.BlockService;
 import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.databind.BeanProperty;
 import com.fasterxml.jackson.databind.JsonMappingException;
 import com.fasterxml.jackson.databind.JsonSerializer;
 import com.fasterxml.jackson.databind.SerializerProvider;
 import com.fasterxml.jackson.databind.ser.ContextualSerializer;
-import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 
@@ -18,15 +17,19 @@
 
 /**
  * @BlockWord 어노테이션이 적용된 필드의 Jackson 커스텀 시리얼라이저
+ * 차단된 사용자의 컨텐츠를 대체 메시지로 변경합니다.
  */
 @Slf4j
 @Component
-@RequiredArgsConstructor
 public class BlockWordSerializer extends JsonSerializer<String> implements ContextualSerializer {
 
     private final BlockService blockService;
     private BlockWord blockWordAnnotation;
 
+    public BlockWordSerializer(BlockService blockService) {
+        this.blockService = blockService;
+    }
+
     @Override
     public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
         if (blockWordAnnotation == null) {
@@ -74,24 +77,29 @@ public void serialize(String value, JsonGenerator gen, SerializerProvider serial
     }
 
     @Override
-    public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) 
+    public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property)
             throws JsonMappingException {
-        
+
         if (property != null) {
+            // @BlockWord 어노테이션 찾기
             BlockWord annotation = property.getAnnotation(BlockWord.class);
+            if (annotation == null && property.getMember() != null) {
+                annotation = property.getMember().getAnnotation(BlockWord.class);
+            }
+
             if (annotation != null) {
                 BlockWordSerializer serializer = new BlockWordSerializer(blockService);
                 serializer.blockWordAnnotation = annotation;
                 return serializer;
             }
         }
-        
+
         return this;
     }
 
     /**
      * 지정된 경로로 객체에서 userId 추출
-     * 
+     *
      * @param object 대상 객체
      * @param userIdPath userId 경로 (예: "userId", "userInfo.userId")
      * @return 추출된 userId, 실패시 null
@@ -109,7 +117,6 @@ private Long extractUserIdByPath(Object object, String userIdPath) {
 
                 Field field = findField(currentObject.getClass(), part);
                 if (field == null) {
-                    log.warn("필드를 찾을 수 없습니다: {} in {}", part, currentObject.getClass().getSimpleName());
                     return null;
                 }
 
@@ -117,13 +124,7 @@ private Long extractUserIdByPath(Object object, String userIdPath) {
                 currentObject = field.get(currentObject);
             }
 
-            // 최종 값이 Long 타입인지 확인
-            if (currentObject instanceof Long) {
-                return (Long) currentObject;
-            } else {
-                log.warn("userId 필드가 Long 타입이 아닙니다: {}", currentObject != null ? currentObject.getClass() : "null");
-                return null;
-            }
+            return currentObject instanceof Long ? (Long) currentObject : null;
 
         } catch (Exception e) {
             log.warn("userId 추출 중 오류 발생: {}", e.getMessage());
@@ -136,7 +137,7 @@ private Long extractUserIdByPath(Object object, String userIdPath) {
      */
     private Field findField(Class<?> clazz, String fieldName) {
         Class<?> currentClass = clazz;
-        
+
         while (currentClass != null) {
             try {
                 return currentClass.getDeclaredField(fieldName);
@@ -144,7 +145,7 @@ private Field findField(Class<?> clazz, String fieldName) {
                 currentClass = currentClass.getSuperclass();
             }
         }
-        
+
         return null;
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/app/bottlenote/common/block/service/BlockService.java b/src/main/java/app/bottlenote/common/block/service/BlockService.java
deleted file mode 100644
index 6e4072657..000000000
--- a/src/main/java/app/bottlenote/common/block/service/BlockService.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package app.bottlenote.common.block.service;
-
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-
-import java.util.Set;
-
-/**
- * 간소화된 차단 서비스
- * 핵심 기능: 특정 사용자가 차단한 사용자 목록 조회
- */
-@Slf4j
-@Service
-public class BlockService {
-
-    /**
-     * 특정 사용자가 차단한 사용자들의 ID 목록을 조회
-     * 테스트용으로 하드코딩된 차단 관계
-     * 
-     * @param userId 사용자 ID
-     * @return 차단된 사용자 ID 목록
-     */
-    public Set<Long> getBlockedUserIds(Long userId) {
-        if (userId == null || userId == -1L) {
-            return Set.of();
-        }
-        
-        // 테스트용 하드코딩된 차단 관계
-        return switch (userId.intValue()) {
-            case 1 -> Set.of(2L, 3L);  // 사용자 1은 사용자 2,3을 차단
-            case 2 -> Set.of(4L);      // 사용자 2는 사용자 4를 차단  
-            case 3 -> Set.of(1L, 5L);  // 사용자 3은 사용자 1,5를 차단
-            default -> Set.of();       // 나머지는 차단 없음
-        };
-    }
-    
-    /**
-     * 두 사용자 간 차단 여부 확인
-     */
-    public boolean isBlocked(Long blockerId, Long blockedId) {
-        if (blockerId == null || blockedId == null) {
-            return false;
-        }
-        
-        Set<Long> blockedUsers = getBlockedUserIds(blockerId);
-        return blockedUsers.contains(blockedId);
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/v1.0.md b/src/main/java/app/bottlenote/common/block/v1.0.md
deleted file mode 100644
index 5cdc7c269..000000000
--- a/src/main/java/app/bottlenote/common/block/v1.0.md
+++ /dev/null
@@ -1,158 +0,0 @@
-# 블록 필터링 v1.0 - AOP 방식
-
-## 📋 개요
-
-**AOP 기반 컨트롤러 레벨 블록 필터링**: `@BlockFilter` 어노테이션을 컨트롤러 메서드에 적용하여 차단된 사용자의 컨텐츠를 "블러" 처리하는 방식
-
-## 🎯 @BlockFilter 어노테이션
-
-```java
-@Target(ElementType.METHOD)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface BlockFilter {
-    /**
-     * 응답 객체에서 사용자 ID를 추출할 필드명
-     */
-    String userField() default "authorId";
-    
-    /**
-     * 블러 처리할 필드명 배열
-     */
-    String[] blurFields() default {
-        "content", "reviewContent", "title", 
-        "authorNickname", "nickname", 
-        "authorProfileImage", "profileImage"
-    };
-}
-```
-
-## 📝 사용 예시
-
-### 컨트롤러 적용
-```java
-@RestController
-public class ReviewController {
-    
-    @BlockFilter(userField = "authorId")
-    @GetMapping("/{alcoholId}")
-    public ResponseEntity<?> getReviews(@PathVariable Long alcoholId) {
-        // 비즈니스 로직 실행
-        return GlobalResponse.ok(reviewService.getReviews(alcoholId));
-    }
-}
-```
-
-## 🔧 동작 원리
-
-### 1. AOP Aspect 처리 흐름
-```java
-@Around("@annotation(blockFilter)")
-public Object applyBlockFilter(ProceedingJoinPoint joinPoint, BlockFilter blockFilter) {
-    // 1. 원본 메서드 실행
-    Object result = joinPoint.proceed();
-    
-    // 2. 현재 사용자 ID 추출
-    Long currentUserId = extractCurrentUserId();
-    
-    // 3. 차단된 사용자 목록 조회
-    Set<Long> blockedUserIds = blockService.getBlockedUserIds(currentUserId);
-    
-    // 4. 응답 데이터에 블러 처리 적용
-    return applyBlurFilter(result, blockedUserIds, blockFilter);
-}
-```
-
-### 2. 블러 처리 과정
-1. **ResponseEntity → GlobalResponse → data 순으로 탐색**
-2. **데이터 타입 확인**: List 또는 단일 객체
-3. **각 항목별로 사용자 ID 추출** (`userField` 사용)
-4. **차단 대상인지 확인** (blockedUserIds에 포함 여부)
-5. **차단된 경우 객체 복제 후 필드 마스킹**
-
-### 3. 필드 마스킹 규칙
-```java
-// 텍스트 필드: "차단된 사용자의 글입니다"
-reviewContent → "차단된 사용자의 글입니다"
-authorNickname → "차단된 사용자의 글입니다"
-
-// 이미지/URL 필드: null 처리
-authorProfileImage → null
-imageUrl → null
-```
-
-## 🎨 처리 결과
-
-### 정상 사용자 응답
-```json
-{
-  "success": true,
-  "data": {
-    "reviewList": [
-      {
-        "authorId": 123,
-        "reviewContent": "정말 맛있는 위스키입니다!",
-        "authorNickname": "위스키러버",
-        "authorProfileImage": "profile.jpg"
-      }
-    ]
-  }
-}
-```
-
-### 차단된 사용자 응답 (블러 처리 후)
-```json
-{
-  "success": true,
-  "data": {
-    "reviewList": [
-      {
-        "authorId": 456,
-        "reviewContent": "차단된 사용자의 글입니다",
-        "authorNickname": "차단된 사용자의 글입니다", 
-        "authorProfileImage": null
-      }
-    ]
-  }
-}
-```
-
-## 🛠️ 구현 구조
-
-### 핵심 파일들
-- `annotation/BlockFilter.java` - 어노테이션 정의
-- `aspect/BlockFilterAspect.java` - AOP 처리 로직
-- `service/BlockService.java` - 차단 관계 조회
-- `controller/BlockTestController.java` - 테스트 컨트롤러
-
-### 주요 메서드
-1. **extractCurrentUserId()**: 현재 사용자 ID 추출 (테스트용 고정값)
-2. **applyBlurFilter()**: 응답 데이터 타입별 블러 처리 분기
-3. **blurItemIfBlocked()**: 개별 항목 차단 여부 확인 및 처리
-4. **applyBlurToItem()**: Jackson 깊은 복사 후 필드 마스킹
-5. **maskField()**: 필드 타입에 따른 마스킹 값 설정
-
-## 🚧 한계점
-
-### 1. 복잡한 처리 과정
-- **ResponseEntity → GlobalResponse → data 구조 의존성**
-- **리플렉션 기반 필드 접근으로 인한 성능 이슈**
-- **Jackson 깊은 복사로 인한 메모리 사용량 증가**
-
-### 2. 컨트롤러 결합도
-- **각 컨트롤러 메서드마다 어노테이션 추가 필요**
-- **userField 설정이 응답 구조에 의존적**
-- **새로운 응답 구조 추가 시 blurFields 재설정 필요**
-
-### 3. 유지보수 어려움
-- **AOP 처리 과정이 복잡하여 디버깅 어려움**
-- **응답 구조 변경 시 필터링 로직도 함께 수정 필요**
-- **테스트용 고정 사용자 ID 등 임시 구현 존재**
-
-### 4. 확장성 제한
-- **특정 응답 구조(GlobalResponse)에만 동작**
-- **중첩 객체 내부 필드 처리 복잡**
-- **다양한 블러 처리 방식 적용 어려움**
-
-## 📝 결론
-
-AOP 방식은 컨트롤러 레벨에서 블록 필터링을 처리하지만, 복잡한 구조와 높은 결합도로 인해 유지보수가 어려운 방식입니다. 특히 응답 구조에 대한 의존성이 높고, 성능상 오버헤드가 존재합니다.
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/v1.1.md b/src/main/java/app/bottlenote/common/block/v1.1.md
deleted file mode 100644
index f3376315c..000000000
--- a/src/main/java/app/bottlenote/common/block/v1.1.md
+++ /dev/null
@@ -1,189 +0,0 @@
-# 블록 필터링 v1.1 - 복잡한 Jackson 인터페이스 방식
-
-## 📋 개요
-
-**심플한 어노테이션 기반 블록 필터링**: `@BlockWord` 어노테이션을 필드에 직접 적용하여 Jackson 직렬화 시점에서 차단된 사용자의 컨텐츠를 대체 메시지로 변경하는 방식
-
-## 🎯 핵심 아이디어
-
-### 기본 원칙
-- **필드 레벨 제어**: 응답 객체 구조는 그대로, 필드별로 블록 필터링 적용
-- **대체 메시지 방식**: 차단된 사용자 컨텐츠를 완전히 제거하지 않고 지정된 메시지로 교체
-- **Jackson 직렬화 활용**: JSON 변환 시점에서 자동으로 필터링 처리
-- **최소한의 변경**: 기존 코드 구조를 최대한 유지하면서 블록 기능 추가
-
-## 🏗️ 설계 상세
-
-### 1. 응답 구조 유지
-```java
-// ReviewListResponse - 기존 구조 그대로 유지
-public record ReviewListResponse(
-    Long totalCount,
-    List<ReviewInfo> reviewList  // 구조 변경 없음
-) {
-    public static ReviewListResponse of(Long totalCount, List<ReviewInfo> reviewList) {
-        return new ReviewListResponse(totalCount, reviewList);
-    }
-}
-```
-
-### 2. 필드 레벨 블록 필터링
-```java
-// ReviewInfo - 특정 필드에만 @BlockWord 적용
-@Builder
-public record ReviewInfo(
-    Long reviewId,
-    
-    @BlockWord  // 차단된 사용자의 리뷰 내용 필터링
-    String reviewContent,
-    
-    String reviewImageUrl,
-    // ... 기타 필드들 (블록 필터링 불필요)
-    
-    UserInfo userInfo,  // 내부에서 닉네임 필터링
-    // ... 나머지 필드들
-) {
-}
-```
-
-### 3. 사용자 정보 블록 필터링
-```java
-// UserInfo - 닉네임에 대체 메시지 적용
-public record UserInfo(
-    Long userId,  // userId는 그대로 유지 (차단 관계 판단용)
-    
-    @BlockWord(대체메시지 = "차단된 사용자")  // 커스텀 대체 메시지
-    String nickName,
-    
-    String userProfileImage  // 프로필 이미지는 유지
-) {
-    public static UserInfo of(Long userId, String nickName, String userProfileImage) {
-        return new UserInfo(userId, nickName, userProfileImage);
-    }
-}
-```
-
-## 🔧 @BlockWord 어노테이션 설계
-
-### 어노테이션 정의
-```java
-@Target(ElementType.FIELD)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface BlockWord {
-    /**
-     * 차단된 사용자 컨텐츠 대체 메시지
-     * 기본값: 빈 문자열 (컨텐츠 완전 숨김)
-     */
-    String 대체메시지() default "";
-    
-    /**
-     * 차단 판단 기준이 되는 사용자 ID 필드명
-     * 기본값: 같은 객체 내 "userId" 필드 사용
-     */
-    String userIdField() default "userId";
-}
-```
-
-### 사용 예시
-```java
-// 케이스 1: 컨텐츠 완전 숨김
-@BlockWord
-String reviewContent;  // → ""
-
-// 케이스 2: 대체 메시지로 교체
-@BlockWord(대체메시지 = "차단된 사용자")
-String nickName;  // → "차단된 사용자"
-
-// 케이스 3: 다른 필드의 userId 참조
-@BlockWord(userIdField = "authorId", 대체메시지 = "차단된 댓글")
-String commentContent;
-```
-
-## 🎨 처리 흐름
-
-### 1. 정상 사용자 컨텐츠
-```json
-{
-  "reviewContent": "정말 맛있는 위스키입니다!",
-  "userInfo": {
-    "userId": 123,
-    "nickName": "위스키러버",
-    "userProfileImage": "profile.jpg"
-  }
-}
-```
-
-### 2. 차단된 사용자 컨텐츠 (필터링 후)
-```json
-{
-  "reviewContent": "",  // @BlockWord로 빈 문자열 처리
-  "userInfo": {
-    "userId": 456,  // userId는 유지 (시스템에서 사용)
-    "nickName": "차단된 사용자",  // 대체 메시지로 교체
-    "userProfileImage": "profile.jpg"  // 프로필 이미지는 유지
-  }
-}
-```
-
-## 🔍 동작 원리
-
-### Jackson 커스텀 시리얼라이저 처리 과정
-
-1. **필드 스캔**: `@BlockWord` 어노테이션이 붙은 필드 감지
-2. **사용자 ID 획득**: 현재 요청 사용자와 컨텐츠 작성자 ID 확인
-3. **차단 관계 검사**: `BlockService`를 통해 차단 관계 확인 (캐시 활용)
-4. **조건부 대체**: 차단된 경우에만 지정된 대체 메시지로 변경
-5. **JSON 출력**: 필터링된 결과를 JSON으로 직렬화
-
-## 🚀 장점
-
-### 1. 심플함
-- **최소한의 코드 변경**: 기존 DTO에 어노테이션만 추가
-- **직관적**: 어떤 필드가 필터링되는지 한눈에 파악 가능
-- **설정 불필요**: 복잡한 인터페이스나 설정 클래스 불필요
-
-### 2. 유연성
-- **필드별 제어**: 각 필드마다 다른 대체 메시지 설정 가능
-- **선택적 적용**: 필요한 필드에만 선택적으로 적용
-- **커스터마이징**: userIdField로 다양한 구조에 대응
-
-### 3. 성능
-- **Jackson 레벨 처리**: 직렬화 시점에만 실행으로 효율적
-- **캐시 활용**: 기존 BlockService의 캐싱 메커니즘 그대로 활용
-- **조건부 실행**: 차단 관계가 있을 때만 처리
-
-### 4. 유지보수성
-- **관심사 분리**: 비즈니스 로직과 블록 필터링 완전 분리
-- **기존 구조 유지**: 응답 객체나 컨트롤러 구조 변경 없음
-- **확장 용이**: 새로운 DTO에 쉽게 적용 가능
-
-## 🛠️ 구현 범위
-
-### Phase 1: 핵심 구성요소
-- `@BlockWord` 어노테이션 정의
-- Jackson 커스텀 시리얼라이저 구현
-- 현재 사용자 컨텍스트 획득 로직
-
-### Phase 2: DTO 적용
-- `ReviewInfo`에 `reviewContent` 필드 블록 필터링 적용
-- `UserInfo`에 `nickName` 필드 블록 필터링 적용
-
-### Phase 3: 기존 코드 정리
-- 컨트롤러의 `@BlockFilter` 어노테이션 제거
-- AOP 기반 블록 필터링 코드 제거
-
-## 🎯 예상 결과
-
-### 개발자 경험
-- **간단한 적용**: `@BlockWord` 어노테이션 하나로 블록 필터링 완성
-- **명확한 의도**: 코드만 봐도 어떤 필드가 블록 대상인지 즉시 파악
-- **디버깅 용이**: JSON 응답에서 바로 필터링 결과 확인 가능
-
-### 사용자 경험
-- **자연스러운 차단**: 차단된 사용자 컨텐츠가 자연스럽게 대체됨
-- **정보 유지**: 사용자 ID 등 필요한 메타데이터는 그대로 유지
-- **일관성**: 모든 API에서 동일한 방식으로 차단 처리
-
-## 📝 결론
-
-`@BlockWord` 어노테이션 기반 블록 필터링은 복잡한 설정 없이도 강력하고 유연한 블록 기능을 제공합니다. 기존 코드 구조를 최대한 유지하면서도 세밀한 제어가 가능한 우아한 솔루션입니다.
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/v1.3.md b/src/main/java/app/bottlenote/common/block/v1.3.md
deleted file mode 100644
index 1ea582fc0..000000000
--- a/src/main/java/app/bottlenote/common/block/v1.3.md
+++ /dev/null
@@ -1,181 +0,0 @@
-# 블록 필터링 v1.3 - 중첩 객체 지원 @BlockWord 방식
-
-## 📋 개요
-
-**@BlockWord 어노테이션 기반 블록 필터링**: JSON 직렬화 시점에서 차단된 사용자 컨텐츠를 자동으로 대체 메시지로 변경
-
-## 🎯 핵심 설계
-
-### @BlockWord 어노테이션 정의
-```java
-@Target(ElementType.FIELD)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface BlockWord {
-    /**
-     * 차단된 사용자 컨텐츠 대체 메시지
-     * 기본값: "차단된 사용자의 글입니다"
-     */
-    String value() default "차단된 사용자의 글입니다";
-    
-    /**
-     * 차단 판단 기준이 되는 사용자 ID 경로
-     * 기본값: 같은 객체 내 "userId" 필드
-     * 중첩 객체: "userInfo.userId" 형태 지원
-     */
-    String userIdPath() default "userId";
-}
-```
-
-### 사용 예시
-
-#### 1. 기본 대체 메시지 사용
-```java
-@BlockWord(userIdPath = "userInfo.userId")
-String reviewContent;  // → "차단된 사용자의 글입니다"
-```
-
-#### 2. 커스텀 대체 메시지
-```java
-@BlockWord(value = "차단된 사용자", userIdPath = "userInfo.userId")  
-String nickName;  // → "차단된 사용자"
-```
-
-#### 3. 중첩 객체에서 userId 참조
-```java
-// ReviewInfo 구조
-public record ReviewInfo(
-    @BlockWord(userIdPath = "userInfo.userId")  // 내부 객체의 userId 참조
-    String reviewContent,
-    
-    UserInfo userInfo  // userId를 포함한 중첩 객체
-) {}
-
-public record UserInfo(
-    Long userId,  // 차단 판단 기준
-    
-    @BlockWord(userIdPath = "userId")  // 같은 객체 내 userId 참조
-    String nickName
-) {}
-```
-
-## 🔧 동작 원리
-
-### 1. 경로 기반 userId 획득
-- **단순 경로**: `"userId"` → 같은 객체 내 userId 필드
-- **중첩 경로**: `"userInfo.userId"` → userInfo 객체 내부의 userId 필드
-- **리플렉션 활용**: 런타임에 지정된 경로로 userId 값 추출
-
-### 2. 차단 관계 검사 흐름
-```
-1. @BlockWord 필드 감지
-2. userIdPath로 작성자 userId 추출
-3. 현재 요청 사용자 ID 획득 (SecurityContext)
-4. BlockService.isBlocked(currentUserId, authorId) 호출
-5. 차단된 경우 → 대체 메시지로 변경
-6. 정상인 경우 → 원본 값 유지
-```
-
-## 📝 적용 예시
-
-### ReviewInfo 적용
-```java
-@Builder
-public record ReviewInfo(
-    Long reviewId,
-    
-    // 리뷰 내용 - userInfo 내부의 userId로 차단 판단
-    @BlockWord(userIdPath = "userInfo.userId")
-    String reviewContent,
-    
-    String reviewImageUrl,
-    LocalDateTime createAt,
-    
-    // 사용자 정보 - 내부에서 nickName 필터링
-    UserInfo userInfo,
-    
-    Boolean isMyReview,
-    // ... 기타 필드들
-) {}
-```
-
-### UserInfo 적용
-```java
-public record UserInfo(
-    Long userId,  // 차단 판단 기준
-    
-    // 닉네임 - 같은 객체 내 userId로 차단 판단
-    @BlockWord(value = "차단된 사용자", userIdPath = "userId")
-    String nickName,
-    
-    String userProfileImage
-) {
-    public static UserInfo of(Long userId, String nickName, String userProfileImage) {
-        return new UserInfo(userId, nickName, userProfileImage);
-    }
-}
-```
-
-## 🎨 처리 결과
-
-### 정상 사용자 응답
-```json
-{
-  "reviewContent": "정말 맛있는 위스키입니다!",
-  "userInfo": {
-    "userId": 123,
-    "nickName": "위스키러버",
-    "userProfileImage": "profile.jpg"
-  }
-}
-```
-
-### 차단된 사용자 응답 (필터링 후)
-```json
-{
-  "reviewContent": "차단된 사용자의 글입니다",
-  "userInfo": {
-    "userId": 456,  // userId는 유지 (시스템 동작용)
-    "nickName": "차단된 사용자",
-    "userProfileImage": "profile.jpg"
-  }
-}
-```
-
-## 🚀 주요 특징
-
-### 1. 유연한 경로 지정
-- **단순 구조**: `userIdPath = "userId"`
-- **중첩 구조**: `userIdPath = "userInfo.userId"`
-- **깊은 중첩**: `userIdPath = "author.profile.userId"` (필요시 확장)
-
-### 2. 기본값 제공
-- **대체 메시지**: 지정하지 않으면 "차단된 사용자의 글입니다"
-- **경로**: 지정하지 않으면 같은 객체 내 "userId" 필드 사용
-
-### 3. 성능 최적화
-- **캐시 활용**: BlockService의 기존 캐싱 메커니즘 활용
-- **조건부 실행**: 차단 관계가 있을 때만 대체 처리
-- **직렬화 시점**: JSON 변환할 때만 실행
-
-## 🛠️ 구현 고려사항
-
-### 1. 경로 파싱
-- dot notation 파싱 로직 구현
-- 중첩 객체 접근을 위한 리플렉션 활용
-- 경로가 유효하지 않을 때 예외 처리
-
-### 2. 현재 사용자 컨텍스트
-- SecurityContextUtil을 통한 현재 사용자 ID 획득
-- 로그인하지 않은 사용자 처리 (필터링 스킵)
-
-### 3. Jackson 커스텀 시리얼라이저
-- @BlockWord 어노테이션 스캔
-- 필드별 조건부 값 변경
-- 원본 객체 수정 없이 직렬화 시에만 변경
-
-## 📋 장점
-
-- **직관적**: 어노테이션만 봐도 어떤 필드가 어떻게 필터링되는지 명확
-- **유연함**: 다양한 객체 구조에 대응 가능한 경로 지정 방식
-- **최소 변경**: 기존 DTO 구조 변경 없이 어노테이션만 추가
-- **성능**: 필요할 때만 실행되는 효율적인 구조
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/v1.4.md b/src/main/java/app/bottlenote/common/block/v1.4.md
deleted file mode 100644
index 9972a656b..000000000
--- a/src/main/java/app/bottlenote/common/block/v1.4.md
+++ /dev/null
@@ -1,154 +0,0 @@
-# 블록 필터링 v1.4 - 최종 단순화된 @BlockWord 방식
-
-## 📋 개요
-
-**@BlockWord 어노테이션**: JSON 직렬화 시점에서 차단된 사용자 컨텐츠를 대체 메시지로 자동 변경
-
-## 🎯 @BlockWord 어노테이션
-
-```java
-@Target(ElementType.FIELD)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface BlockWord {
-    /**
-     * 차단된 사용자 컨텐츠 대체 메시지
-     * 기본값: "차단된 사용자의 글입니다"
-     */
-    String value() default "차단된 사용자의 글입니다";
-    
-    /**
-     * 차단 판단 기준이 되는 사용자 ID 경로
-     * 기본값: "userId"
-     * 중첩 객체: "userInfo.userId" 형태 지원
-     */
-    String userIdPath() default "userId";
-}
-```
-
-## 📝 사용 예시
-
-### ReviewInfo
-```java
-@Builder
-public record ReviewInfo(
-    Long reviewId,
-    
-    @BlockWord(userIdPath = "userInfo.userId")
-    String reviewContent,
-    
-    UserInfo userInfo,
-    // ... 기타 필드들
-) {}
-```
-
-### UserInfo
-```java
-public record UserInfo(
-    Long userId,
-    
-    @BlockWord(value = "차단된 사용자", userIdPath = "userId")
-    String nickName,
-    
-    String userProfileImage
-) {}
-```
-
-## 🔧 동작 흐름
-
-### 1. 현재 사용자 ID 획득
-```java
-// SecurityContextUtils 활용
-Long currentUserId = SecurityContextUtil.getUserIdByContext().orElse(null);
-
-// 비로그인 사용자 처리
-if (currentUserId == null) {
-    // 필터링 스킵, 원본 값 그대로 반환
-    return originalValue;
-}
-```
-
-### 2. 작성자 userId 추출
-```java
-// userIdPath로 리플렉션을 통해 userId 추출
-// "userId" → 같은 객체 내 userId 필드
-// "userInfo.userId" → userInfo 객체 내부의 userId 필드
-Long authorId = extractUserIdByPath(object, userIdPath);
-```
-
-### 3. 차단 관계 확인 및 처리
-```java
-// BlockService를 통한 차단 관계 확인 (캐시 제외)
-boolean isBlocked = blockService.isBlocked(currentUserId, authorId);
-
-if (isBlocked) {
-    return 대체메시지;  // "@BlockWord" 어노테이션의 value 값
-} else {
-    return 원본값;
-}
-```
-
-## 🎨 처리 결과
-
-### 정상 사용자
-```json
-{
-  "reviewContent": "정말 맛있는 위스키입니다!",
-  "userInfo": {
-    "userId": 123,
-    "nickName": "위스키러버"
-  }
-}
-```
-
-### 차단된 사용자
-```json
-{
-  "reviewContent": "차단된 사용자의 글입니다",
-  "userInfo": {
-    "userId": 456,
-    "nickName": "차단된 사용자"
-  }
-}
-```
-
-### 비로그인 사용자
-```json
-{
-  "reviewContent": "정말 맛있는 위스키입니다!",
-  "userInfo": {
-    "userId": 123,
-    "nickName": "위스키러버"
-  }
-}
-```
-
-## 🛠️ 구현 핵심 요소
-
-### 1. Jackson 커스텀 시리얼라이저
-- `@BlockWord` 어노테이션 감지
-- 필드별 조건부 값 변경
-- 직렬화 시점에서만 처리
-
-### 2. 경로 기반 userId 추출
-- dot notation 파싱: `"userInfo.userId"`
-- 리플렉션을 통한 중첩 객체 접근
-- 경로 오류 시 예외 처리
-
-### 3. 사용자 컨텍스트 처리
-- `SecurityContextUtil.getUserIdByContext()` 활용
-- `Optional<Long>` 반환값 처리
-- 비로그인 사용자는 필터링 스킵
-
-### 4. 단순한 블록 검사
-- `BlockService.isBlocked(currentUserId, authorId)` 호출
-- 캐싱 메커니즘 제외
-- 차단된 경우에만 대체 메시지 적용
-
-## 📋 처리 조건
-
-| 상황 | 동작 |
-|------|------|
-| 비로그인 사용자 | 원본 값 그대로 반환 (필터링 안 함) |
-| 로그인 + 차단 안 됨 | 원본 값 그대로 반환 |
-| 로그인 + 차단됨 | 대체 메시지로 변경 |
-| userIdPath 오류 | 원본 값 그대로 반환 + 로그 기록 |
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/common/block/v1.5.md b/src/main/java/app/bottlenote/common/block/v1.5.md
deleted file mode 100644
index 9c9b92861..000000000
--- a/src/main/java/app/bottlenote/common/block/v1.5.md
+++ /dev/null
@@ -1,192 +0,0 @@
-# 블록 필터링 v1.5 - Jackson 시리얼라이저 구현
-
-## 📋 개요
-
-**실제 구현된 @BlockWord 방식**: Jackson ContextualSerializer를 활용하여 직렬화 시점에서 차단된 사용자 컨텐츠를 자동으로 대체하는 구현
-
-## 🎯 구현 구성요소
-
-### 1. @BlockWord 어노테이션
-```java
-@Target(ElementType.FIELD)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface BlockWord {
-    String value() default "차단된 사용자의 글입니다";
-    String userIdPath() default "userId";
-}
-```
-
-### 2. BlockWordSerializer
-```java
-@Component
-public class BlockWordSerializer extends JsonSerializer<String> implements ContextualSerializer {
-    
-    @Override
-    public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) {
-        // 1. 현재 사용자 ID 획득 (SecurityContextUtil)
-        // 2. 비로그인 사용자는 필터링 스킵
-        // 3. userIdPath로 작성자 ID 추출 (리플렉션)
-        // 4. BlockService.isBlocked() 호출
-        // 5. 차단된 경우 대체 메시지로 변경
-    }
-    
-    @Override
-    public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) {
-        // @BlockWord 어노테이션 감지하여 컨텍스트별 시리얼라이저 생성
-    }
-}
-```
-
-### 3. BlockWordConfig
-```java
-@Configuration
-public class BlockWordConfig {
-    
-    @PostConstruct
-    public void configureObjectMapper() {
-        SimpleModule blockWordModule = new SimpleModule("BlockWordModule");
-        blockWordModule.addSerializer(String.class, blockWordSerializer);
-        objectMapper.registerModule(blockWordModule);
-    }
-}
-```
-
-## 🔧 동작 과정
-
-### 1. 시리얼라이저 등록
-- ObjectMapper에 BlockWordSerializer를 String 타입에 대해 등록
-- @BlockWord 어노테이션이 있는 필드에서만 동작하도록 ContextualSerializer 활용
-
-### 2. 직렬화 시점 처리
-```java
-// JSON 직렬화 시점에서 자동 호출
-serialize(String value, JsonGenerator gen, SerializerProvider serializers) {
-    
-    // 현재 사용자 ID 획득
-    Long currentUserId = SecurityContextUtil.getUserIdByContext().orElse(null);
-    if (currentUserId == null) {
-        gen.writeString(value);  // 비로그인 → 원본 반환
-        return;
-    }
-    
-    // 작성자 ID 추출 (리플렉션)
-    Object currentObject = gen.getCurrentValue();
-    Long authorId = extractUserIdByPath(currentObject, userIdPath);
-    
-    // 차단 관계 확인
-    boolean isBlocked = blockService.isBlocked(currentUserId, authorId);
-    if (isBlocked) {
-        gen.writeString(대체메시지);  // 차단됨 → 대체 메시지
-    } else {
-        gen.writeString(value);     // 정상 → 원본 값
-    }
-}
-```
-
-### 3. 경로 기반 userId 추출
-```java
-private Long extractUserIdByPath(Object object, String userIdPath) {
-    String[] pathParts = userIdPath.split("\\.");
-    Object currentObject = object;
-    
-    // dot notation 경로 탐색
-    for (String part : pathParts) {
-        Field field = findField(currentObject.getClass(), part);
-        field.setAccessible(true);
-        currentObject = field.get(currentObject);
-    }
-    
-    return (Long) currentObject;
-}
-```
-
-## 📝 사용 예시
-
-### ReviewInfo 적용
-```java
-@Builder
-public record ReviewInfo(
-    Long reviewId,
-    
-    @BlockWord(userIdPath = "userInfo.userId")
-    String reviewContent,
-    
-    UserInfo userInfo
-) {}
-```
-
-### UserInfo 적용
-```java
-public record UserInfo(
-    Long userId,
-    
-    @BlockWord(value = "차단된 사용자", userIdPath = "userId")  
-    String nickName,
-    
-    String userProfileImage
-) {}
-```
-
-## 🎨 처리 결과
-
-### 정상 사용자
-```json
-{
-  "reviewContent": "정말 맛있는 위스키입니다!",
-  "userInfo": {
-    "userId": 123,
-    "nickName": "위스키러버"
-  }
-}
-```
-
-### 차단된 사용자
-```json
-{
-  "reviewContent": "차단된 사용자의 글입니다",
-  "userInfo": {
-    "userId": 456,
-    "nickName": "차단된 사용자"
-  }
-}
-```
-
-## 🛠️ 구현 특징
-
-### 1. ContextualSerializer 활용
-- BeanProperty에서 @BlockWord 어노테이션 추출
-- 어노테이션별로 독립적인 시리얼라이저 인스턴스 생성
-- 필드별 개별 설정 적용
-
-### 2. 리플렉션 기반 경로 탐색
-- dot notation 지원: "userInfo.userId"
-- 클래스 상속 계층 고려한 필드 검색
-- 실패 시 원본 값 반환으로 안정성 확보
-
-### 3. 현재 사용자 컨텍스트
-- SecurityContextUtil.getUserIdByContext() 활용
-- Optional 반환값 처리로 비로그인 사용자 고려
-- 예외 상황에서 원본 값 보존
-
-### 4. 에러 핸들링
-- 각 단계별 try-catch로 안정성 확보
-- 실패 시 로그 기록 후 원본 값 반환
-- 운영 중 장애 방지를 위한 방어적 프로그래밍
-
-## 📋 구현 파일 구조
-
-```
-common/block/
-├── annotation/
-│   └── BlockWord.java           # 어노테이션 정의
-├── serializer/
-│   └── BlockWordSerializer.java # Jackson 커스텀 시리얼라이저
-├── config/
-│   └── BlockWordConfig.java     # ObjectMapper 설정
-└── service/
-    └── BlockService.java        # 차단 관계 조회 (기존)
-```
-
-## 📝 결론
-
-Jackson의 ContextualSerializer를 활용한 방식으로 필드 레벨에서 세밀한 블록 필터링을 구현했습니다. AOP 방식의 복잡성을 제거하고 직렬화 시점에서 자연스럽게 처리되도록 구현했습니다.
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/review/controller/ReviewController.java b/src/main/java/app/bottlenote/review/controller/ReviewController.java
index 4e154a604..012d9476e 100644
--- a/src/main/java/app/bottlenote/review/controller/ReviewController.java
+++ b/src/main/java/app/bottlenote/review/controller/ReviewController.java
@@ -1,6 +1,5 @@
 package app.bottlenote.review.controller;
 
-import app.bottlenote.common.block.annotation.BlockFilter;
 import app.bottlenote.global.data.response.GlobalResponse;
 import app.bottlenote.global.security.SecurityContextUtil;
 import app.bottlenote.global.service.cursor.PageResponse;
@@ -43,7 +42,6 @@ public ResponseEntity<?> createReview(@RequestBody @Valid ReviewCreateRequest re
 		return GlobalResponse.ok(reviewService.createReview(reviewCreateRequest, currentUserId));
 	}
 
-	@BlockFilter(userField = "authorId")
 	@GetMapping("/{alcoholId}")
 	public ResponseEntity<?> getReviews(@PathVariable Long alcoholId, @ModelAttribute ReviewPageableRequest reviewPageableRequest) {
 		Long currentUserId = SecurityContextUtil.getUserIdByContext().orElse(-1L);
@@ -56,7 +54,6 @@ public ResponseEntity<?> getReviews(@PathVariable Long alcoholId, @ModelAttribut
 		return GlobalResponse.ok(pageResponse.content(), MetaService.createMetaInfo().add("pageable", pageResponse.cursorPageable()));
 	}
 
-	@BlockFilter(userField = "authorId")
 	@GetMapping("/detail/{reviewId}")
 	public ResponseEntity<?> getDetailReview(@PathVariable Long reviewId) {
 
diff --git a/src/main/java/app/bottlenote/review/facade/payload/ReviewInfo.java b/src/main/java/app/bottlenote/review/facade/payload/ReviewInfo.java
index e2c80527b..bebc8ef96 100644
--- a/src/main/java/app/bottlenote/review/facade/payload/ReviewInfo.java
+++ b/src/main/java/app/bottlenote/review/facade/payload/ReviewInfo.java
@@ -1,5 +1,6 @@
 package app.bottlenote.review.facade.payload;
 
+import app.bottlenote.common.block.annotation.BlockWord;
 import app.bottlenote.global.data.serializers.CustomDeserializers.TagListDeserializer;
 import app.bottlenote.global.data.serializers.CustomSerializers.TagListSerializer;
 import app.bottlenote.review.constant.ReviewDisplayStatus;
@@ -14,37 +15,38 @@
 
 @Builder
 public record ReviewInfo(
-	// 기본 리뷰 정보
-	Long reviewId,
-	String reviewContent,
-	String reviewImageUrl,
-	LocalDateTime createAt,
-	Long totalImageCount,
-
-	// 사용자 정보
-	UserInfo userInfo,
-	Boolean isMyReview,
-
-	// 리뷰 상태 및 속성
-	ReviewDisplayStatus status,
-	Boolean isBestReview,
-	ReviewLocation locationInfo,
-	SizeType sizeType,
-
-	// 가격 및 평점 정보
-	BigDecimal price,
-	Double rating,
-
-	// 좋아요 및 댓글 정보
-	Long likeCount,
-	Long replyCount,
-	Boolean isLikedByMe,
-	Boolean hasReplyByMe,
-
-	// 기타 정보
-	Long viewCount,
-	@JsonSerialize(using = TagListSerializer.class)
-	@JsonDeserialize(using = TagListDeserializer.class)
-	String tastingTagList
+		// 기본 리뷰 정보
+		Long reviewId,
+		@BlockWord(userIdPath = "userInfo.userId")
+		String reviewContent,
+		String reviewImageUrl,
+		LocalDateTime createAt,
+		Long totalImageCount,
+
+		// 사용자 정보
+		UserInfo userInfo,
+		Boolean isMyReview,
+
+		// 리뷰 상태 및 속성
+		ReviewDisplayStatus status,
+		Boolean isBestReview,
+		ReviewLocation locationInfo,
+		SizeType sizeType,
+
+		// 가격 및 평점 정보
+		BigDecimal price,
+		Double rating,
+
+		// 좋아요 및 댓글 정보
+		Long likeCount,
+		Long replyCount,
+		Boolean isLikedByMe,
+		Boolean hasReplyByMe,
+
+		// 기타 정보
+		Long viewCount,
+		@JsonSerialize(using = TagListSerializer.class)
+		@JsonDeserialize(using = TagListDeserializer.class)
+		String tastingTagList
 ) {
 }
diff --git a/src/main/java/app/bottlenote/review/facade/payload/UserInfo.java b/src/main/java/app/bottlenote/review/facade/payload/UserInfo.java
index a7d4ddf33..2cf4ef9fd 100644
--- a/src/main/java/app/bottlenote/review/facade/payload/UserInfo.java
+++ b/src/main/java/app/bottlenote/review/facade/payload/UserInfo.java
@@ -1,9 +1,12 @@
 package app.bottlenote.review.facade.payload;
 
+import app.bottlenote.common.block.annotation.BlockWord;
+
 public record UserInfo(
-	Long userId,
-	String nickName,
-	String userProfileImage
+		Long userId,
+		@BlockWord(value = "차단된 사용자입니다")
+		String nickName,
+		String userProfileImage
 ) {
 
 	public static UserInfo of(Long userId, String nickName, String userProfileImage) {
diff --git a/src/main/java/app/bottlenote/support/block/controller/BlockController.java b/src/main/java/app/bottlenote/support/block/controller/BlockController.java
new file mode 100644
index 000000000..39ab96cd8
--- /dev/null
+++ b/src/main/java/app/bottlenote/support/block/controller/BlockController.java
@@ -0,0 +1,73 @@
+package app.bottlenote.support.block.controller;
+
+import app.bottlenote.global.data.response.GlobalResponse;
+import app.bottlenote.global.security.SecurityContextUtil;
+import app.bottlenote.support.block.exception.BlockException;
+import app.bottlenote.support.block.service.BlockService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import static app.bottlenote.support.block.exception.BlockExceptionCode.REQUIRED_USER_ID;
+
+/**
+ * 차단 관리 API
+ */
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/v1/blocks")
+public class BlockController {
+
+	private final BlockService blockService;
+
+	/**
+	 * 사용자 차단
+	 */
+	@PostMapping("/create")
+	public ResponseEntity<?> createBlock(@RequestBody BlockCreateRequest request) {
+		Long currentUserId = SecurityContextUtil.getUserIdByContext()
+				.orElseThrow(() -> new BlockException(REQUIRED_USER_ID));
+
+		blockService.blockUser(currentUserId, request.blockedUserId());
+
+		return GlobalResponse.ok("차단이 완료되었습니다.");
+	}
+
+	/**
+	 * 차단 해제
+	 */
+	@DeleteMapping("/{blockedUserId}")
+	public ResponseEntity<?> unblockUser(@PathVariable Long blockedUserId) {
+		Long currentUserId = SecurityContextUtil.getUserIdByContext()
+				.orElseThrow(() -> new BlockException(REQUIRED_USER_ID));
+
+		blockService.unblockUser(currentUserId, blockedUserId);
+
+		return GlobalResponse.ok("차단이 해제되었습니다.");
+	}
+
+	/**
+	 * 차단 목록 조회
+	 */
+	@GetMapping
+	public ResponseEntity<?> getBlockedUsers() {
+		Long currentUserId = SecurityContextUtil.getUserIdByContext()
+				.orElseThrow(() -> new BlockException(REQUIRED_USER_ID));
+
+		return GlobalResponse.ok(blockService.getBlockedUserIds(currentUserId));
+	}
+
+	/**
+	 * 차단 요청 DTO
+	 */
+	public record BlockCreateRequest(Long blockedUserId) {
+	}
+}
diff --git a/src/main/java/app/bottlenote/user/domain/UserBlock.java b/src/main/java/app/bottlenote/support/block/domain/UserBlock.java
similarity index 87%
rename from src/main/java/app/bottlenote/user/domain/UserBlock.java
rename to src/main/java/app/bottlenote/support/block/domain/UserBlock.java
index e16958ea8..e57544dba 100644
--- a/src/main/java/app/bottlenote/user/domain/UserBlock.java
+++ b/src/main/java/app/bottlenote/support/block/domain/UserBlock.java
@@ -1,4 +1,4 @@
-package app.bottlenote.user.domain;
+package app.bottlenote.support.block.domain;
 
 import app.bottlenote.common.domain.BaseTimeEntity;
 import jakarta.persistence.Column;
@@ -6,7 +6,6 @@
 import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
-import jakarta.persistence.Index;
 import jakarta.persistence.Table;
 import jakarta.persistence.UniqueConstraint;
 import lombok.AccessLevel;
@@ -28,10 +27,6 @@
 						name = "uk_blocker_blocked",
 						columnNames = {"blocker_id", "blocked_id"}
 				)
-		},
-		indexes = {
-				@Index(name = "idx_user_block_blocker", columnList = "blocker_id"),
-				@Index(name = "idx_user_block_blocked", columnList = "blocked_id")
 		}
 )
 public class UserBlock extends BaseTimeEntity {
diff --git a/src/main/java/app/bottlenote/support/block/exception/BlockException.java b/src/main/java/app/bottlenote/support/block/exception/BlockException.java
new file mode 100644
index 000000000..b2c3c1683
--- /dev/null
+++ b/src/main/java/app/bottlenote/support/block/exception/BlockException.java
@@ -0,0 +1,10 @@
+package app.bottlenote.support.block.exception;
+
+import app.bottlenote.global.exception.custom.AbstractCustomException;
+
+public class BlockException extends AbstractCustomException {
+
+    public BlockException(BlockExceptionCode blockExceptionCode) {
+        super(blockExceptionCode);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/support/block/exception/BlockExceptionCode.java b/src/main/java/app/bottlenote/support/block/exception/BlockExceptionCode.java
new file mode 100644
index 000000000..d5b500fb5
--- /dev/null
+++ b/src/main/java/app/bottlenote/support/block/exception/BlockExceptionCode.java
@@ -0,0 +1,29 @@
+package app.bottlenote.support.block.exception;
+
+import app.bottlenote.global.exception.custom.code.ExceptionCode;
+import org.springframework.http.HttpStatus;
+
+public enum BlockExceptionCode implements ExceptionCode {
+    USER_ALREADY_BLOCKED(HttpStatus.CONFLICT, "이미 차단된 사용자입니다."),
+    USER_BLOCK_NOT_FOUND(HttpStatus.NOT_FOUND, "차단 관계를 찾을 수 없습니다."),
+    CANNOT_BLOCK_SELF(HttpStatus.BAD_REQUEST, "자기 자신을 차단할 수 없습니다."),
+    REQUIRED_USER_ID(HttpStatus.BAD_REQUEST, "유저 아이디가 필요합니다.");
+
+    private final HttpStatus httpStatus;
+    private final String message;
+
+    BlockExceptionCode(HttpStatus httpStatus, String message) {
+        this.httpStatus = httpStatus;
+        this.message = message;
+    }
+
+    @Override
+    public String getMessage() {
+        return message;
+    }
+
+    @Override
+    public HttpStatus getHttpStatus() {
+        return httpStatus;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/user/repository/JpaUserBlockRepository.java b/src/main/java/app/bottlenote/support/block/repository/JpaUserBlockRepository.java
similarity index 89%
rename from src/main/java/app/bottlenote/user/repository/JpaUserBlockRepository.java
rename to src/main/java/app/bottlenote/support/block/repository/JpaUserBlockRepository.java
index 9325db9bb..fe7a4751c 100644
--- a/src/main/java/app/bottlenote/user/repository/JpaUserBlockRepository.java
+++ b/src/main/java/app/bottlenote/support/block/repository/JpaUserBlockRepository.java
@@ -1,7 +1,6 @@
-package app.bottlenote.user.repository;
+package app.bottlenote.support.block.repository;
 
-import app.bottlenote.user.domain.UserBlock;
-import app.bottlenote.user.domain.UserBlockRepository;
+import app.bottlenote.support.block.domain.UserBlock;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
diff --git a/src/main/java/app/bottlenote/user/domain/UserBlockRepository.java b/src/main/java/app/bottlenote/support/block/repository/UserBlockRepository.java
similarity index 94%
rename from src/main/java/app/bottlenote/user/domain/UserBlockRepository.java
rename to src/main/java/app/bottlenote/support/block/repository/UserBlockRepository.java
index 1fb9ee847..434bc4a80 100644
--- a/src/main/java/app/bottlenote/user/domain/UserBlockRepository.java
+++ b/src/main/java/app/bottlenote/support/block/repository/UserBlockRepository.java
@@ -1,4 +1,6 @@
-package app.bottlenote.user.domain;
+package app.bottlenote.support.block.repository;
+
+import app.bottlenote.support.block.domain.UserBlock;
 
 import java.util.Optional;
 import java.util.Set;
diff --git a/src/main/java/app/bottlenote/support/block/service/BlockService.java b/src/main/java/app/bottlenote/support/block/service/BlockService.java
new file mode 100644
index 000000000..a7a16178b
--- /dev/null
+++ b/src/main/java/app/bottlenote/support/block/service/BlockService.java
@@ -0,0 +1,174 @@
+package app.bottlenote.support.block.service;
+
+import app.bottlenote.support.block.domain.UserBlock;
+import app.bottlenote.support.block.exception.BlockException;
+import app.bottlenote.support.block.repository.UserBlockRepository;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Set;
+
+import static app.bottlenote.support.block.exception.BlockExceptionCode.CANNOT_BLOCK_SELF;
+import static app.bottlenote.support.block.exception.BlockExceptionCode.REQUIRED_USER_ID;
+import static app.bottlenote.support.block.exception.BlockExceptionCode.USER_ALREADY_BLOCKED;
+import static app.bottlenote.support.block.exception.BlockExceptionCode.USER_BLOCK_NOT_FOUND;
+
+/**
+ * 사용자 차단 관리 서비스
+ * 차단 관계 생성, 해제, 조회 및 캐싱 처리
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class BlockService {
+
+    private final UserBlockRepository userBlockRepository;
+
+    /**
+     * 사용자 차단
+     *
+     * @param blockerId 차단하는 사용자 ID
+     * @param blockedId 차단당하는 사용자 ID
+     * @param reason    차단 사유 (선택사항)
+     */
+    @Transactional
+    @CacheEvict(value = "blocked_users", key = "#blockerId")
+    public void blockUser(Long blockerId, Long blockedId, String reason) {
+        validateBlockRequest(blockerId, blockedId);
+
+        // 이미 차단된 관계인지 확인
+        if (userBlockRepository.existsByBlockerIdAndBlockedId(blockerId, blockedId)) {
+            throw new BlockException(USER_ALREADY_BLOCKED);
+        }
+
+        // 차단 관계 생성
+        UserBlock userBlock = UserBlock.create(blockerId, blockedId, reason);
+        userBlockRepository.save(userBlock);
+
+        log.info("사용자 차단 완료 - 차단자: {}, 피차단자: {}", blockerId, blockedId);
+    }
+
+    /**
+     * 사용자 차단 (사유 없음)
+     */
+    @Transactional
+    public void blockUser(Long blockerId, Long blockedId) {
+        blockUser(blockerId, blockedId, null);
+    }
+
+    /**
+     * 사용자 차단 해제
+     *
+     * @param blockerId 차단 해제하는 사용자 ID
+     * @param blockedId 차단 해제당하는 사용자 ID
+     */
+    @Transactional
+    @CacheEvict(value = "blocked_users", key = "#blockerId")
+    public void unblockUser(Long blockerId, Long blockedId) {
+        validateBlockRequest(blockerId, blockedId);
+
+        UserBlock userBlock = userBlockRepository.findByBlockerIdAndBlockedId(blockerId, blockedId)
+                .orElseThrow(() -> new BlockException(USER_BLOCK_NOT_FOUND));
+
+        userBlockRepository.delete(userBlock);
+
+        log.info("사용자 차단 해제 완료 - 차단자: {}, 피차단자: {}", blockerId, blockedId);
+    }
+
+    /**
+     * 특정 사용자가 차단한 사용자들의 ID 목록을 조회 (캐시 적용)
+     *
+     * @param userId 사용자 ID
+     * @return 차단된 사용자 ID 목록
+     */
+    @Cacheable(value = "blocked_users", key = "#userId")
+    public Set<Long> getBlockedUserIds(Long userId) {
+        if (userId == null) {
+            return Set.of();
+        }
+
+        return userBlockRepository.findBlockedUserIdsByBlockerId(userId);
+    }
+
+    /**
+     * 두 사용자 간 차단 여부 확인
+     *
+     * @param blockerId 차단하는 사용자 ID
+     * @param blockedId 차단당하는 사용자 ID
+     * @return 차단 여부
+     */
+    public boolean isBlocked(Long blockerId, Long blockedId) {
+        if (blockerId == null || blockedId == null) {
+            return false;
+        }
+
+        Set<Long> blockedUsers = getBlockedUserIds(blockerId);
+        return blockedUsers.contains(blockedId);
+    }
+
+    /**
+     * 상호 차단 여부 확인
+     *
+     * @param userId1 사용자 1 ID
+     * @param userId2 사용자 2 ID
+     * @return 상호 차단 여부
+     */
+    public boolean isMutualBlocked(Long userId1, Long userId2) {
+        if (userId1 == null || userId2 == null) {
+            return false;
+        }
+
+        return userBlockRepository.existsMutualBlock(userId1, userId2);
+    }
+
+    /**
+     * 특정 사용자를 차단한 사용자 수 조회
+     *
+     * @param userId 사용자 ID
+     * @return 해당 사용자를 차단한 사용자 수
+     */
+    public long getBlockedByCount(Long userId) {
+        if (userId == null) {
+            return 0L;
+        }
+
+        return userBlockRepository.countByBlockedId(userId);
+    }
+
+    /**
+     * 특정 사용자가 차단한 사용자 수 조회
+     *
+     * @param userId 사용자 ID
+     * @return 해당 사용자가 차단한 사용자 수
+     */
+    public long getBlockingCount(Long userId) {
+        if (userId == null) {
+            return 0L;
+        }
+
+        return userBlockRepository.countByBlockerId(userId);
+    }
+
+    /**
+     * 차단 요청 유효성 검증
+     */
+    private void validateBlockRequest(Long blockerId, Long blockedId) {
+        if (blockerId == null) {
+            throw new BlockException(REQUIRED_USER_ID);
+        }
+
+        if (blockedId == null) {
+            throw new BlockException(REQUIRED_USER_ID);
+        }
+
+        if (blockerId.equals(blockedId)) {
+            throw new BlockException(CANNOT_BLOCK_SELF);
+        }
+    }
+
+}
diff --git a/src/main/resources/application-logging.yml b/src/main/resources/application-logging.yml
index 2c4e1dc30..3d844c830 100644
--- a/src/main/resources/application-logging.yml
+++ b/src/main/resources/application-logging.yml
@@ -12,6 +12,9 @@ logging:
   level:
     org.hibernate.SQL: off           # SQL 쿼리 로깅 비활성화
     org.hibernate.orm.jdbc.bind: off # 바인딩 파라미터 로깅 비활성화
+    app.bottlenote.common.block.serializer: debug  # BlockWordSerializer 디버그
+    app.bottlenote.common.block.service: debug     # BlockService 디버그  
+    app.bottlenote.common.block.config: debug      # BlockWordConfig 디버그
     root: info
 
 --- # 개발 환경

From e86d8afd8104754feab068241f52d39e399ce3a8 Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Fri, 27 Jun 2025 13:01:22 +0900
Subject: [PATCH 04/16] docs: remove md doc

Signed-off-by: hgkim <hgkim@openerd.com>
---
 BLOCK_FEATURE_USAGE.md       | 241 ------------
 USER_BLOCK_IMPLEMENTATION.md | 687 -----------------------------------
 2 files changed, 928 deletions(-)
 delete mode 100644 BLOCK_FEATURE_USAGE.md
 delete mode 100644 USER_BLOCK_IMPLEMENTATION.md

diff --git a/BLOCK_FEATURE_USAGE.md b/BLOCK_FEATURE_USAGE.md
deleted file mode 100644
index 0f1d9e175..000000000
--- a/BLOCK_FEATURE_USAGE.md
+++ /dev/null
@@ -1,241 +0,0 @@
-# 🚫 차단 기능 사용 가이드
-
-## 🎯 구현 완료된 기능들
-
-### ✅ 1. BlockFilter 어노테이션
-- **위치**: `app.bottlenote.global.annotation.BlockFilter`
-- **용도**: 컨트롤러 메서드에 차단 필터링 적용
-
-### ✅ 2. BlockFilterAspect AOP
-- **위치**: `app.bottlenote.global.aspect.BlockFilterAspect`
-- **용도**: 어노테이션 기반 자동 차단 처리
-
-### ✅ 3. BlockService
-- **위치**: `app.bottlenote.global.service.BlockService`
-- **용도**: 차단 관계 관리 (현재 메모리 기반)
-
-### ✅ 4. ReviewController 적용 샘플
-- **적용된 메서드**: `getReviews()`, `getDetailReview()`
-
-### ✅ 5. BlockTestController
-- **위치**: `app.bottlenote.global.controller.BlockTestController`
-- **용도**: 차단 기능 테스트
-
----
-
-## 🚀 사용 방법
-
-### 1️⃣ 기본 사용법
-```java
-// 차단된 사용자의 리뷰를 블러 처리
-@BlockFilter(userField = "authorId", type = BlockType.BLUR)
-@GetMapping("/reviews")
-public ResponseEntity<?> getReviews() {
-    // 기존 로직 그대로 유지
-}
-```
-
-### 2️⃣ 차단 타입 선택
-```java
-// 블러 처리
-@BlockFilter(type = BlockType.BLUR)
-
-// 완전 제외
-@BlockFilter(type = BlockType.EXCLUDE)
-
-// 접근 차단 (403 에러)
-@BlockFilter(type = BlockType.ACCESS_DENY)
-```
-
-### 3️⃣ 사용자 ID 필드 지정
-```java
-// 기본값: authorId
-@BlockFilter(userField = "authorId")
-
-// 다른 필드명 사용
-@BlockFilter(userField = "userId")
-@BlockFilter(userField = "writerId")
-```
-
----
-
-## 🧪 테스트 방법
-
-### 1. 서버 실행
-```bash
-./gradlew bootRun
-```
-
-### 2. 차단 관계 생성
-```bash
-# 사용자 1이 사용자 2를 차단
-curl -X POST "http://localhost:8080/api/v1/test/block/add?blockerId=1&blockedId=2"
-```
-
-### 3. 차단 목록 확인
-```bash
-# 사용자 1의 차단 목록 조회
-curl "http://localhost:8080/api/v1/test/block/list/1"
-```
-
-### 4. 리뷰 조회 테스트
-```bash
-# JWT 토큰으로 로그인한 상태에서 리뷰 조회
-curl -H "Authorization: Bearer YOUR_JWT_TOKEN" \
-     "http://localhost:8080/api/v1/reviews/1"
-```
-
-### 5. 차단 관계 해제
-```bash
-curl -X DELETE "http://localhost:8080/api/v1/test/block/remove?blockerId=1&blockedId=2"
-```
-
----
-
-## 📋 동작 확인 포인트
-
-### ✅ 로그 확인
-```
-2024-01-15 10:30:00 INFO  - 차단 관계 생성: 1 -> 2
-2024-01-15 10:31:00 DEBUG - 사용자 1의 차단 목록 조회: 1 명
-2024-01-15 10:32:00 INFO  - 사용자 1의 차단 필터 적용 완료 - 차단 목록: 1 개
-```
-
-### ✅ 응답 데이터 변화
-**차단 전:**
-```json
-{
-  "success": true,
-  "data": [
-    {
-      "reviewId": 123,
-      "content": "정말 맛있는 위스키입니다!",
-      "authorId": 2,
-      "authorNickname": "위스키러버"
-    }
-  ]
-}
-```
-
-**차단 후:**
-```json
-{
-  "success": true,
-  "data": [
-    {
-      "reviewId": 123,
-      "content": "*** 차단된 사용자의 글입니다 ***",
-      "authorId": 2,
-      "authorNickname": "차단된 사용자",
-      "isBlocked": true,
-      "blockReason": "BLOCKED_USER"
-    }
-  ]
-}
-```
-
----
-
-## 🔧 다른 컨트롤러에 적용하기
-
-### 1. Import 추가
-```java
-import app.bottlenote.global.annotation.BlockFilter;
-import app.bottlenote.global.annotation.BlockFilter.BlockType;
-```
-
-### 2. 어노테이션 적용
-```java
-// 댓글 목록 조회
-@BlockFilter(userField = "authorId", type = BlockType.BLUR)
-@GetMapping("/comments")
-public ResponseEntity<?> getComments() { ... }
-
-// 팔로워 목록 조회 (차단된 사용자 제외)
-@BlockFilter(userField = "userId", type = BlockType.EXCLUDE)
-@GetMapping("/followers")
-public ResponseEntity<?> getFollowers() { ... }
-
-// 마이페이지 접근 (차단된 사용자 접근 금지)
-@BlockFilter(userField = "userId", type = BlockType.ACCESS_DENY)
-@GetMapping("/mypage/{userId}")
-public ResponseEntity<?> getMyPage(@PathVariable Long userId) { ... }
-```
-
----
-
-## ⚠️ 주의사항
-
-### 1. 현재 제한사항
-- **메모리 기반 저장**: 서버 재시작 시 차단 관계 초기화
-- **단순 객체 복사**: 복잡한 객체 구조는 블러 처리 제한
-- **필드명 의존**: 응답 DTO의 필드명이 정확해야 함
-
-### 2. 성능 고려사항
-- **익명 사용자**: 차단 로직 적용 안함 (성능 최적화)
-- **캐시 적용**: `@Cacheable`로 반복 조회 최적화
-- **로그 레벨**: 운영 시 DEBUG 로그 비활성화 권장
-
-### 3. 보안 고려사항
-- **클라이언트 검증**: 프론트엔드에서 추가 검증 필요
-- **API 접근 제어**: 차단된 사용자의 직접 API 호출 차단 고려
-
----
-
-## 🔄 다음 단계 (실제 운영 환경)
-
-### 1. 데이터베이스 연동
-```sql
-CREATE TABLE user_block (
-    id BIGINT AUTO_INCREMENT PRIMARY KEY,
-    blocker_id BIGINT NOT NULL,
-    blocked_id BIGINT NOT NULL,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    UNIQUE KEY uk_blocker_blocked (blocker_id, blocked_id)
-);
-```
-
-### 2. Redis 캐시 적용
-```yaml
-spring:
-  cache:
-    type: redis
-  redis:
-    host: localhost
-    port: 6379
-```
-
-### 3. 차단 관리 API 개발
-- 차단하기/해제하기 API
-- 차단 목록 조회 API
-- 차단 사유 관리
-
-### 4. 프론트엔드 연동
-- 블러 UI 컴포넌트
-- 차단 버튼 추가
-- 차단 목록 관리 페이지
-
----
-
-## 🆘 문제 해결
-
-### Q: AOP가 적용되지 않음
-**A:** `@EnableAspectJAutoProxy` 확인 또는 Spring Boot의 자동 설정 확인
-
-### Q: 필드를 찾을 수 없다는 오류
-**A:** `userField` 값이 응답 DTO의 실제 필드명과 일치하는지 확인
-
-### Q: 블러 처리가 동작하지 않음
-**A:** 객체의 setter가 있는지, 또는 필드가 final이 아닌지 확인
-
-### Q: 성능이 느림
-**A:** 차단 목록이 많은 경우 배치 조회나 캐시 TTL 조정 고려
-
----
-
-## 📞 연락처
-
-구현 과정에서 문의사항이나 개선 제안이 있으시면 언제든 연락주세요!
-
-- 기술 문의: 개발팀 채널
-- 기능 제안: 기획팀 채널
\ No newline at end of file
diff --git a/USER_BLOCK_IMPLEMENTATION.md b/USER_BLOCK_IMPLEMENTATION.md
deleted file mode 100644
index 6703b3756..000000000
--- a/USER_BLOCK_IMPLEMENTATION.md
+++ /dev/null
@@ -1,687 +0,0 @@
-# 🚫 Bottle Note 유저 차단 기능 구현 가이드
-
-## 📋 목차
-1. [현재 시스템 분석](#현재-시스템-분석)
-2. [차단 기능 구현 방안 비교](#차단-기능-구현-방안-비교)
-3. [추천 구현 방안: AOP 기반](#추천-구현-방안-aop-기반)
-4. [성능 최적화 전략](#성능-최적화-전략)
-5. [프론트엔드 연동 방안](#프론트엔드-연동-방안)
-6. [구현 단계별 가이드](#구현-단계별-가이드)
-
----
-
-## 🔍 현재 시스템 분석
-
-### 차단 기능이 필요한 조회 지점들
-- **리뷰 목록/상세 조회** - 차단된 사용자의 리뷰 블러 처리
-- **리뷰 댓글 조회** - 차단된 사용자의 댓글 블러 처리  
-- **팔로워/팔로잉 목록** - 차단된 사용자 제외 또는 블러 표시
-- **마이페이지 접근** - 차단된 사용자의 마이페이지 접근 제한
-- **유저 검색/추천** - 차단된 사용자 제외
-
-### 현재 인증 시스템
-```java
-// 익명 사용자 처리
-Long currentUserId = SecurityContextUtil.getUserIdByContext().orElse(-1L);
-
-// 로그인 필수 처리
-Long currentUserId = SecurityContextUtil.getUserIdByContext()
-    .orElseThrow(() -> new UserException(REQUIRED_USER_ID));
-```
-
----
-
-## ⚖️ 차단 기능 구현 방안 비교
-
-### 1️⃣ 방안 1: 데이터베이스 쿼리 수정
-
-#### 🎯 구현 방식
-```sql
--- 기존 쿼리
-SELECT * FROM review WHERE alcohol_id = ?;
-
--- 수정된 쿼리
-SELECT r.*, 
-       CASE WHEN ub.blocker_id IS NOT NULL THEN 1 ELSE 0 END as is_blocked
-FROM review r 
-LEFT JOIN user_block ub ON ub.blocker_id = ? AND ub.blocked_id = r.user_id
-WHERE r.alcohol_id = ?;
-```
-
-#### ✅ 장점
-- **가장 직관적인 방법**
-- **DB 레벨에서 처리**로 확실한 차단
-- **성능이 좋음** (한 번의 쿼리로 해결)
-
-#### ❌ 단점
-- **모든 쿼리를 수정해야 함** (50+ 개의 쿼리)
-- **기존 코드 대량 수정** 필요
-- **유지보수 복잡도 증가**
-- **테스트 케이스 대량 수정** 필요
-
-### 2️⃣ 방안 2: 서비스 레이어 후처리
-
-#### 🎯 구현 방식
-```java
-@Service
-public class ReviewService {
-    
-    public PageResponse<ReviewListResponse> getReviews(Long alcoholId, ...) {
-        // 기존 로직으로 데이터 조회
-        var reviews = reviewRepository.findByAlcoholId(alcoholId);
-        
-        // 차단 로직 후처리
-        var filteredReviews = blockFilterService.filterBlockedContent(
-            reviews, currentUserId, ReviewListResponse::getAuthorId
-        );
-        
-        return PageResponse.of(filteredReviews);
-    }
-}
-```
-
-#### ✅ 장점
-- **기존 Repository 코드 유지**
-- **비즈니스 로직과 차단 로직 분리**
-- **테스트하기 쉬움**
-
-#### ❌ 단점
-- **모든 서비스 메서드 수정** 필요
-- **중복 코드 발생** 가능성
-- **깜빡하기 쉬움** (새로운 기능 추가 시)
-
-### 3️⃣ 방안 3: AOP 기반 통합 처리 ⭐ **추천**
-
-#### 🎯 구현 방식
-```java
-// 컨트롤러에 어노테이션만 추가
-@BlockFilter(userField = "authorId", type = BlockType.BLUR)
-@GetMapping("/{alcoholId}")
-public ResponseEntity<?> getReviews(@PathVariable Long alcoholId, ...) {
-    // 기존 로직 그대로 유지 (수정 없음!)
-    return GlobalResponse.ok(reviewService.getReviews(alcoholId, request, currentUserId));
-}
-```
-
-#### ✅ 장점
-- **기존 코드 수정 최소화** (어노테이션만 추가)
-- **중앙 집중식 관리** (차단 로직이 한 곳에)
-- **깜빡할 염려 없음** (어노테이션으로 명시적)
-- **성능 영향 최소** (응답 후처리)
-- **테스트 용이** (AOP 로직 독립 테스트)
-- **확장성 좋음** (다양한 차단 타입 지원)
-
-#### ❌ 단점
-- **AOP 개념 이해** 필요
-- **디버깅이 약간 복잡**할 수 있음
-
-### 4️⃣ 방안 4: 프론트엔드 처리
-
-#### 🎯 구현 방식
-```javascript
-// 백엔드에서 차단 정보만 제공
-const reviews = await api.getReviews(alcoholId);
-const blockedUsers = await api.getBlockedUsers();
-
-// 프론트엔드에서 블러 처리
-const filteredReviews = reviews.map(review => 
-  blockedUsers.includes(review.authorId) 
-    ? { ...review, isBlocked: true }
-    : review
-);
-```
-
-#### ✅ 장점
-- **백엔드 코드 수정 없음**
-- **실시간 차단/해제** 가능
-
-#### ❌ 단점
-- **보안 취약** (클라이언트에서 우회 가능)
-- **네트워크 비용 증가**
-- **차단된 데이터도 전송**됨
-
----
-
-## 🏆 추천 구현 방안: AOP 기반
-
-### 📐 아키텍처 설계
-
-```
-┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
-│   Controller    │    │   AOP Aspect    │    │   Response      │
-│                 │    │                 │    │                 │
-│ @BlockFilter   ├────┤ BlockFilterAsp- ├────┤ 블러 처리된     │
-│ @GetMapping     │    │ ect             │    │ 응답 데이터     │
-│                 │    │                 │    │                 │
-└─────────────────┘    └─────────────────┘    └─────────────────┘
-          │                       │                       │
-          │                       │                       │
-          ▼                       ▼                       ▼
-┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
-│   Service       │    │ BlockCacheManager│    │   Frontend      │
-│   (기존 로직)   │    │                 │    │                 │
-│   수정 없음     │    │ Redis Cache     │    │ 블러 UI 처리    │
-│                 │    │                 │    │                 │
-└─────────────────┘    └─────────────────┘    └─────────────────┘
-```
-
-### 🔧 핵심 구현 코드
-
-#### 1. 차단 필터 어노테이션
-```java
-@Target(ElementType.METHOD)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface BlockFilter {
-    BlockType type() default BlockType.BLUR;
-    String userField() default "authorId";  // 차단 대상 사용자 ID 필드명
-}
-
-public enum BlockType {
-    BLUR,        // 블러 처리 (내용 가림)
-    EXCLUDE,     // 완전 제외 (목록에서 제거)
-    ACCESS_DENY  // 접근 차단 (403 에러)
-}
-```
-
-#### 2. AOP 어스펙트
-```java
-@Component
-@Aspect
-public class BlockFilterAspect {
-    
-    private final BlockService blockService;
-    
-    @Around("@annotation(blockFilter)")
-    public Object applyBlockFilter(ProceedingJoinPoint joinPoint, BlockFilter blockFilter) {
-        // 1. 기존 로직 실행 (수정 없음)
-        Object result = joinPoint.proceed();
-        
-        // 2. 현재 사용자 ID 확인
-        Long currentUserId = SecurityContextUtil.getUserIdByContext().orElse(-1L);
-        if (currentUserId == -1L) {
-            return result; // 익명 사용자는 차단 로직 적용 안함
-        }
-        
-        // 3. 응답 데이터에 차단 로직 적용
-        return applyBlockLogic(result, currentUserId, blockFilter);
-    }
-    
-    private Object applyBlockLogic(Object result, Long currentUserId, BlockFilter filter) {
-        // ResponseEntity에서 실제 데이터 추출
-        if (result instanceof ResponseEntity) {
-            ResponseEntity<?> response = (ResponseEntity<?>) result;
-            GlobalResponse globalResponse = (GlobalResponse) response.getBody();
-            Object data = globalResponse.getData();
-            
-            // 리스트 데이터 처리
-            if (data instanceof List) {
-                List<?> list = (List<?>) data;
-                List<?> filteredList = processListData(list, currentUserId, filter);
-                return ResponseEntity.ok(GlobalResponse.success(filteredList));
-            }
-            
-            // 단일 객체 데이터 처리
-            Object filteredData = processSingleData(data, currentUserId, filter);
-            return ResponseEntity.ok(GlobalResponse.success(filteredData));
-        }
-        
-        return result;
-    }
-}
-```
-
-#### 3. 차단 서비스
-```java
-@Service
-public class BlockService {
-    
-    private final BlockRepository blockRepository;
-    private final RedisTemplate<String, Set<Long>> redisTemplate;
-    
-    @Cacheable(value = "blocked_users", key = "#userId")
-    public Set<Long> getBlockedUserIds(Long userId) {
-        return blockRepository.findBlockedUserIdsByBlockerId(userId);
-    }
-    
-    public <T> T applyBlockFilter(T item, Long currentUserId, String userField, BlockType type) {
-        Set<Long> blockedUsers = getBlockedUserIds(currentUserId);
-        Long authorId = extractUserIdFromObject(item, userField);
-        
-        if (blockedUsers.contains(authorId)) {
-            switch (type) {
-                case BLUR:
-                    return blurContent(item);
-                case EXCLUDE:
-                    return null; // 리스트에서 제거됨
-                case ACCESS_DENY:
-                    throw new BlockedException("차단된 사용자의 컨텐츠입니다.");
-            }
-        }
-        
-        return item;
-    }
-}
-```
-
-### 🎨 사용 예시
-
-```java
-// 리뷰 목록 조회 - 차단된 사용자 리뷰 블러 처리
-@BlockFilter(userField = "authorId", type = BlockType.BLUR)
-@GetMapping("/{alcoholId}")
-public ResponseEntity<?> getReviews(@PathVariable Long alcoholId, ...) {
-    // 기존 코드 그대로 유지
-}
-
-// 팔로워 목록 조회 - 차단된 사용자 완전 제외
-@BlockFilter(userField = "userId", type = BlockType.EXCLUDE)
-@GetMapping("/{targetUserId}/follower-list")
-public ResponseEntity<?> findFollowerList(@PathVariable Long targetUserId, ...) {
-    // 기존 코드 그대로 유지
-}
-
-// 마이페이지 접근 - 차단된 사용자 접근 차단
-@BlockFilter(userField = "userId", type = BlockType.ACCESS_DENY)
-@GetMapping("/{userId}")
-public ResponseEntity<?> getMyPage(@PathVariable Long userId) {
-    // 기존 코드 그대로 유지
-}
-```
-
----
-
-## ⚡ 성능 최적화 전략
-
-### 1️⃣ Redis 캐싱 전략
-
-```java
-@Component
-public class BlockCacheManager {
-    
-    // 사용자별 차단 목록 캐싱 (TTL: 1시간)
-    @Cacheable(value = "blocked_users", key = "#userId", unless = "#userId == -1")
-    public Set<Long> getBlockedUserIds(Long userId) {
-        return blockRepository.findBlockedUserIdsByBlockerId(userId);
-    }
-    
-    // 차단 관계 변경 시 캐시 무효화
-    @CacheEvict(value = "blocked_users", key = "#userId")
-    public void evictBlockCache(Long userId) {
-        log.info("차단 캐시 무효화: userId={}", userId);
-    }
-    
-    // 배치로 여러 사용자의 차단 목록 조회
-    public Map<Long, Set<Long>> getBulkBlockedUsers(Set<Long> userIds) {
-        return userIds.stream()
-            .filter(id -> id != -1L)  // 익명 사용자 제외
-            .collect(Collectors.toMap(
-                Function.identity(),
-                this::getBlockedUserIds
-            ));
-    }
-}
-```
-
-### 2️⃣ 데이터베이스 최적화
-
-```sql
--- 차단 관계 테이블
-CREATE TABLE user_block (
-    id BIGINT AUTO_INCREMENT PRIMARY KEY,
-    blocker_id BIGINT NOT NULL COMMENT '차단한 사용자',
-    blocked_id BIGINT NOT NULL COMMENT '차단당한 사용자',
-    block_type VARCHAR(20) DEFAULT 'FULL',
-    reason VARCHAR(255),
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    UNIQUE KEY uk_blocker_blocked (blocker_id, blocked_id)
-);
-
--- 성능 최적화 인덱스
-CREATE INDEX idx_user_block_blocker ON user_block(blocker_id);
-CREATE INDEX idx_user_block_blocked ON user_block(blocked_id);
-```
-
-### 3️⃣ 성능 비교 분석
-
-| 방식 | DB 쿼리 횟수 | 응답 시간 | 메모리 사용량 | 유지보수성 |
-|------|-------------|-----------|--------------|------------|
-| **쿼리 수정** | 1회 | 50ms | 낮음 | ⭐⭐ |
-| **서비스 후처리** | 2회 | 80ms | 중간 | ⭐⭐⭐ |
-| **AOP (캐시 적용)** | 1회 + 캐시 | 60ms | 중간 | ⭐⭐⭐⭐⭐ |
-| **프론트엔드** | 2회 | 100ms | 높음 | ⭐ |
-
----
-
-## 🎭 프론트엔드 연동 방안
-
-### 📡 API 응답 형식
-
-#### 기존 응답
-```json
-{
-  "success": true,
-  "data": [
-    {
-      "reviewId": 123,
-      "content": "정말 맛있는 위스키입니다!",
-      "authorNickname": "위스키러버",
-      "authorProfileImage": "https://...",
-      "rating": 4.5,
-      "createdAt": "2024-01-15T10:30:00"
-    }
-  ]
-}
-```
-
-#### 차단 적용 후 응답
-```json
-{
-  "success": true,
-  "data": [
-    {
-      "reviewId": 123,
-      "content": "*** 차단된 사용자의 리뷰입니다 ***",
-      "authorNickname": "차단된 사용자",
-      "authorProfileImage": null,
-      "rating": 4.5,
-      "createdAt": "2024-01-15T10:30:00",
-      "isBlocked": true,
-      "blockReason": "BLOCKED_USER"
-    }
-  ]
-}
-```
-
-### 🎨 프론트엔드 UI 컴포넌트
-
-#### React 예시
-```tsx
-interface ReviewCardProps {
-  review: ReviewResponse;
-}
-
-const ReviewCard: React.FC<ReviewCardProps> = ({ review }) => {
-  const [showBlocked, setShowBlocked] = useState(false);
-  
-  if (review.isBlocked && !showBlocked) {
-    return (
-      <div className="review-card blocked">
-        <div className="blur-overlay">
-          <div className="blocked-message">
-            <Icon name="block" />
-            <span>차단된 사용자의 리뷰</span>
-          </div>
-          <button 
-            className="show-content-btn"
-            onClick={() => setShowBlocked(true)}
-          >
-            내용 보기
-          </button>
-        </div>
-      </div>
-    );
-  }
-  
-  return (
-    <div className={`review-card ${review.isBlocked ? 'shown-blocked' : 'normal'}`}>
-      <div className="review-header">
-        <img src={review.authorProfileImage} alt="프로필" />
-        <span className="nickname">{review.authorNickname}</span>
-        <Rating value={review.rating} />
-      </div>
-      <div className="review-content">
-        {review.content}
-      </div>
-      {review.isBlocked && (
-        <div className="blocked-indicator">
-          <span>차단된 사용자의 컨텐츠</span>
-          <button onClick={() => setShowBlocked(false)}>숨기기</button>
-        </div>
-      )}
-    </div>
-  );
-};
-```
-
-#### CSS 스타일
-```css
-.review-card.blocked {
-  position: relative;
-  filter: blur(5px);
-  opacity: 0.6;
-}
-
-.blur-overlay {
-  position: absolute;
-  top: 0;
-  left: 0;
-  right: 0;
-  bottom: 0;
-  background: rgba(0, 0, 0, 0.8);
-  display: flex;
-  flex-direction: column;
-  justify-content: center;
-  align-items: center;
-  backdrop-filter: blur(10px);
-}
-
-.blocked-message {
-  color: white;
-  text-align: center;
-  margin-bottom: 16px;
-}
-
-.show-content-btn {
-  background: #007bff;
-  color: white;
-  border: none;
-  padding: 8px 16px;
-  border-radius: 4px;
-  cursor: pointer;
-}
-
-.blocked-indicator {
-  background: #fff3cd;
-  border: 1px solid #ffeaa7;
-  padding: 8px;
-  border-radius: 4px;
-  margin-top: 8px;
-  font-size: 12px;
-  color: #856404;
-}
-```
-
----
-
-## 📋 구현 단계별 가이드
-
-### 🏗️ Phase 1: 기반 구조 구축
-
-#### 1.1 차단 도메인 모델 생성
-```java
-// 1. Entity 생성
-@Entity
-@Table(name = "user_block")
-public class UserBlock extends BaseTimeEntity {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-    
-    @Column(name = "blocker_id", nullable = false)
-    private Long blockerId;
-    
-    @Column(name = "blocked_id", nullable = false)
-    private Long blockedId;
-    
-    @Enumerated(EnumType.STRING)
-    private BlockType blockType = BlockType.FULL;
-    
-    private String reason;
-}
-
-// 2. Repository 생성
-public interface BlockRepository extends JpaRepository<UserBlock, Long> {
-    Set<Long> findBlockedIdsByBlockerId(Long blockerId);
-    boolean existsByBlockerIdAndBlockedId(Long blockerId, Long blockedId);
-}
-
-// 3. Service 생성
-@Service
-public class BlockService {
-    public void createBlock(Long blockerId, Long blockedId) { ... }
-    public void removeBlock(Long blockerId, Long blockedId) { ... }
-    public Set<Long> getBlockedUserIds(Long userId) { ... }
-}
-```
-
-#### 1.2 캐시 설정
-```yaml
-# application.yml
-spring:
-  cache:
-    type: caffeine
-    caffeine:
-      spec: maximumSize=10000,expireAfterWrite=1h
-```
-
-### 🔧 Phase 2: AOP 구현
-
-#### 2.1 어노테이션 및 AOP 구현
-```java
-// 앞서 제시한 코드 구현
-@Target(ElementType.METHOD)
-@Retention(RetentionPolicy.RUNTIME)
-public @interface BlockFilter { ... }
-
-@Component
-@Aspect
-public class BlockFilterAspect { ... }
-```
-
-#### 2.2 테스트 코드 작성
-```java
-@ExtendWith(MockitoExtension.class)
-class BlockFilterAspectTest {
-    
-    @Mock
-    private BlockService blockService;
-    
-    @InjectMocks
-    private BlockFilterAspect blockFilterAspect;
-    
-    @Test
-    void 차단된_사용자_리뷰_블러_처리_테스트() {
-        // Given
-        Long currentUserId = 1L;
-        Long blockedUserId = 2L;
-        when(blockService.getBlockedUserIds(currentUserId))
-            .thenReturn(Set.of(blockedUserId));
-        
-        // When & Then
-        // AOP 로직 테스트
-    }
-}
-```
-
-### 📱 Phase 3: 프론트엔드 연동
-
-#### 3.1 API 클라이언트 수정
-```typescript
-// API 타입 정의 확장
-interface BaseResponse {
-  isBlocked?: boolean;
-  blockReason?: string;
-}
-
-interface ReviewResponse extends BaseResponse {
-  reviewId: number;
-  content: string;
-  authorNickname: string;
-  // ... 기타 필드
-}
-```
-
-#### 3.2 UI 컴포넌트 개발
-```tsx
-// 앞서 제시한 React 컴포넌트 구현
-```
-
-### 🚀 Phase 4: 점진적 적용
-
-#### 4.1 우선순위별 적용
-1. **High Priority**: 리뷰 조회, 댓글 조회
-2. **Medium Priority**: 팔로우 목록, 마이페이지
-3. **Low Priority**: 검색 결과, 추천 목록
-
-#### 4.2 모니터링 설정
-```java
-@Component
-public class BlockMetrics {
-    private final MeterRegistry meterRegistry;
-    
-    public void recordBlockFilter(String endpoint, BlockType type, int blockedCount) {
-        Counter.builder("block.filter.applied")
-            .tag("endpoint", endpoint)
-            .tag("type", type.name())
-            .register(meterRegistry)
-            .increment(blockedCount);
-    }
-}
-```
-
-### 📊 Phase 5: 성능 모니터링
-
-#### 5.1 성능 지표 수집
-- 차단 캐시 히트율
-- 응답 시간 변화
-- 메모리 사용량 변화
-
-#### 5.2 알람 설정
-```yaml
-# Prometheus 규칙
-groups:
-  - name: block_system
-    rules:
-      - alert: BlockCacheHitRateLow
-        expr: block_cache_hit_rate < 0.8
-        for: 5m
-        annotations:
-          summary: "차단 캐시 히트율이 낮습니다"
-```
-
----
-
-## 🎯 결론
-
-### ✨ 왜 AOP 방식을 추천하는가?
-
-1. **최소 침습적** - 기존 코드를 거의 수정하지 않음
-2. **중앙 집중식** - 차단 로직이 한 곳에서 관리됨  
-3. **확장 가능** - 다양한 차단 타입을 쉽게 추가
-4. **성능 효율적** - 캐시를 통한 최적화
-5. **테스트 용이** - 독립적인 테스트 가능
-
-### 🚀 기대 효과
-
-- **개발 시간 단축**: 기존 쿼리 수정 불필요
-- **유지보수성 향상**: 차단 로직 중앙화
-- **성능 안정성**: 캐시 기반 최적화
-- **사용자 경험 개선**: 세밀한 차단 옵션 제공
-
-### 📅 구현 일정 (예상)
-
-- **Week 1**: Phase 1-2 (기반 구조 + AOP)
-- **Week 2**: Phase 3 (프론트엔드 연동)  
-- **Week 3**: Phase 4-5 (점진적 적용 + 모니터링)
-
-**총 예상 개발 기간: 3주**
-
----
-
-## 📞 문의 및 지원
-
-차단 기능 구현 과정에서 문의사항이 있으시면 언제든 연락주세요!
-
-- 기술적 문의: 개발팀 채널
-- 기획 관련: 기획팀 채널  
-- 성능 관련: DevOps 팀 채널
\ No newline at end of file

From 62aae17a73e91707bab13debb4f0519119e33bf2 Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Fri, 27 Jun 2025 13:21:26 +0900
Subject: [PATCH 05/16] docs: add block readme make by claude

Signed-off-by: hgkim <hgkim@openerd.com>
---
 .../app/bottlenote/support/block/README.md    | 114 ++++++++++++++++++
 1 file changed, 114 insertions(+)
 create mode 100644 src/main/java/app/bottlenote/support/block/README.md

diff --git a/src/main/java/app/bottlenote/support/block/README.md b/src/main/java/app/bottlenote/support/block/README.md
new file mode 100644
index 000000000..1bac86057
--- /dev/null
+++ b/src/main/java/app/bottlenote/support/block/README.md
@@ -0,0 +1,114 @@
+# Block 기능 - 사용자 차단 시스템
+
+## 📋 개요
+
+사용자 간 차단/해제 및 차단된 사용자 컨텐츠 자동 필터링을 제공하는 독립적인 도메인 모듈입니다.
+
+## 🏗️ 구조
+
+```
+support/block/                          # Block 도메인
+├── controller/BlockController.java     # REST API
+├── domain/UserBlock.java               # 차단 관계 엔티티
+├── exception/                          # Block 전용 예외
+├── repository/                         # Repository 인터페이스 & 구현체
+└── service/BlockService.java           # 비즈니스 로직
+
+common/block/                           # 공통 컴포넌트
+├── annotation/BlockWord.java           # @BlockWord 어노테이션
+├── config/BlockWordConfig.java         # Spring 설정
+└── serializer/BlockWordSerializer.java # Jackson 시리얼라이저
+```
+
+## 🎯 핵심 기능
+
+### 1. 차단 관리 API
+
+```http
+POST /api/v1/blocks/create              # 사용자 차단
+DELETE /api/v1/blocks/{blockedUserId}   # 차단 해제
+GET /api/v1/blocks                      # 차단 목록 조회
+```
+
+### 2. 자동 컨텐츠 필터링
+
+`@BlockWord` 어노테이션을 통해 JSON 직렬화 시점에서 차단된 사용자의 컨텐츠를 자동으로 대체합니다.
+
+```java
+public record ReviewInfo(
+    @BlockWord(userIdPath = "userInfo.userId")
+    String reviewContent,               // "차단된 사용자의 글입니다"
+    UserInfo userInfo
+) {}
+
+public record UserInfo(
+    Long userId,
+    @BlockWord(value = "차단된 사용자", userIdPath = "userId")
+    String nickName,                    // "차단된 사용자"
+    String userProfileImage
+) {}
+```
+
+**결과:**
+```json
+// 차단 전
+{
+    "reviewContent": "정말 맛있는 위스키입니다!",
+    "userInfo": {
+        "nickName": "위스키러버"
+    }
+}
+
+// 차단 후
+{
+    "reviewContent": "차단된 사용자의 글입니다",
+    "userInfo": {
+        "nickName": "차단된 사용자"
+    }
+}
+```
+
+## 🗄️ 데이터베이스
+
+### UserBlock 엔티티
+- **차단 관계**: blocker_id ↔ blocked_id
+- **유니크 제약**: 중복 차단 방지
+- **인덱스**: 조회 성능 최적화
+- **BaseTimeEntity**: 생성/수정 시간 자동 관리
+
+## ⚡ 성능 최적화
+
+### 캐싱
+- **차단 목록**: `@Cacheable(value = "blocked_users")` - 2시간 TTL
+- **캐시 무효화**: `@CacheEvict` - 차단/해제 시 자동 무효화
+
+### Repository 주요 메서드
+```java
+Set<Long> findBlockedUserIdsByBlockerId(Long blockerId);     // 차단 목록
+boolean existsByBlockerIdAndBlockedId(Long blockerId, Long blockedId); // 차단 여부
+boolean existsMutualBlock(Long userId1, Long userId2);       // 상호 차단
+long countByBlockerId(Long blockerId);                       // 차단한 수
+long countByBlockedId(Long blockedId);                       // 차단당한 수
+```
+
+## 🧪 테스트
+
+### HTTP 테스트 파일
+```
+http/block/차단_필터링_테스트.http
+```
+
+### 기본 테스트 시나리오
+1. 토큰 발급 → 사용자 차단 → 차단 목록 조회 → 컨텐츠 필터링 확인 → 차단 해제
+
+## 🔧 동작 원리
+
+### 차단 생성
+1. API 호출 → 유효성 검증 → 중복 확인 → DB 저장 → 캐시 무효화
+
+### 컨텐츠 필터링
+1. JSON 직렬화 → @BlockWord 감지 → 현재 사용자 확인 → 차단 여부 확인 → 대체 메시지/원본 반환
+
+---
+
+**핵심**: 간단한 어노테이션 하나로 전체 시스템에서 차단된 사용자 컨텐츠가 자동으로 필터링됩니다.
\ No newline at end of file

From ad992f73ed40d6e1116192b29cbddcffe7322ec1 Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Fri, 27 Jun 2025 14:17:40 +0900
Subject: [PATCH 06/16] feat: enhance block functionality with validation and
 service integration

Signed-off-by: hgkim <hgkim@openerd.com>
---
 git.environment-variables                            |  2 +-
 .../support/block/controller/BlockController.java    | 12 ++++--------
 .../support/block/service/BlockService.java          |  5 +++++
 .../review/controller/ReviewControllerTest.java      |  5 +++++
 4 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/git.environment-variables b/git.environment-variables
index b146e17ba..793c442a0 160000
--- a/git.environment-variables
+++ b/git.environment-variables
@@ -1 +1 @@
-Subproject commit b146e17baab4747e4f7045340b8cb13636db09e8
+Subproject commit 793c442a01a00ba80b0c39faf132b33a01f92939
diff --git a/src/main/java/app/bottlenote/support/block/controller/BlockController.java b/src/main/java/app/bottlenote/support/block/controller/BlockController.java
index 39ab96cd8..f5a60f43e 100644
--- a/src/main/java/app/bottlenote/support/block/controller/BlockController.java
+++ b/src/main/java/app/bottlenote/support/block/controller/BlockController.java
@@ -2,8 +2,10 @@
 
 import app.bottlenote.global.data.response.GlobalResponse;
 import app.bottlenote.global.security.SecurityContextUtil;
+import app.bottlenote.support.block.dto.request.BlockCreateRequest;
 import app.bottlenote.support.block.exception.BlockException;
 import app.bottlenote.support.block.service.BlockService;
+import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.ResponseEntity;
@@ -32,7 +34,7 @@ public class BlockController {
 	 * 사용자 차단
 	 */
 	@PostMapping("/create")
-	public ResponseEntity<?> createBlock(@RequestBody BlockCreateRequest request) {
+	public ResponseEntity<?> createBlock(@RequestBody @Valid BlockCreateRequest request) {
 		Long currentUserId = SecurityContextUtil.getUserIdByContext()
 				.orElseThrow(() -> new BlockException(REQUIRED_USER_ID));
 
@@ -45,7 +47,7 @@ public ResponseEntity<?> createBlock(@RequestBody BlockCreateRequest request) {
 	 * 차단 해제
 	 */
 	@DeleteMapping("/{blockedUserId}")
-	public ResponseEntity<?> unblockUser(@PathVariable Long blockedUserId) {
+	public ResponseEntity<?> deleteBlock(@PathVariable Long blockedUserId) {
 		Long currentUserId = SecurityContextUtil.getUserIdByContext()
 				.orElseThrow(() -> new BlockException(REQUIRED_USER_ID));
 
@@ -64,10 +66,4 @@ public ResponseEntity<?> getBlockedUsers() {
 
 		return GlobalResponse.ok(blockService.getBlockedUserIds(currentUserId));
 	}
-
-	/**
-	 * 차단 요청 DTO
-	 */
-	public record BlockCreateRequest(Long blockedUserId) {
-	}
 }
diff --git a/src/main/java/app/bottlenote/support/block/service/BlockService.java b/src/main/java/app/bottlenote/support/block/service/BlockService.java
index a7a16178b..dbb96e140 100644
--- a/src/main/java/app/bottlenote/support/block/service/BlockService.java
+++ b/src/main/java/app/bottlenote/support/block/service/BlockService.java
@@ -86,6 +86,7 @@ public void unblockUser(Long blockerId, Long blockedId) {
      * @param userId 사용자 ID
      * @return 차단된 사용자 ID 목록
      */
+    @Transactional(readOnly = true)
     @Cacheable(value = "blocked_users", key = "#userId")
     public Set<Long> getBlockedUserIds(Long userId) {
         if (userId == null) {
@@ -102,6 +103,7 @@ public Set<Long> getBlockedUserIds(Long userId) {
      * @param blockedId 차단당하는 사용자 ID
      * @return 차단 여부
      */
+    @Transactional(readOnly = true)
     public boolean isBlocked(Long blockerId, Long blockedId) {
         if (blockerId == null || blockedId == null) {
             return false;
@@ -118,6 +120,7 @@ public boolean isBlocked(Long blockerId, Long blockedId) {
      * @param userId2 사용자 2 ID
      * @return 상호 차단 여부
      */
+    @Transactional(readOnly = true)
     public boolean isMutualBlocked(Long userId1, Long userId2) {
         if (userId1 == null || userId2 == null) {
             return false;
@@ -132,6 +135,7 @@ public boolean isMutualBlocked(Long userId1, Long userId2) {
      * @param userId 사용자 ID
      * @return 해당 사용자를 차단한 사용자 수
      */
+    @Transactional(readOnly = true)
     public long getBlockedByCount(Long userId) {
         if (userId == null) {
             return 0L;
@@ -146,6 +150,7 @@ public long getBlockedByCount(Long userId) {
      * @param userId 사용자 ID
      * @return 해당 사용자가 차단한 사용자 수
      */
+    @Transactional(readOnly = true)
     public long getBlockingCount(Long userId) {
         if (userId == null) {
             return 0L;
diff --git a/src/test/java/app/bottlenote/review/controller/ReviewControllerTest.java b/src/test/java/app/bottlenote/review/controller/ReviewControllerTest.java
index 079626282..1d0186d0d 100644
--- a/src/test/java/app/bottlenote/review/controller/ReviewControllerTest.java
+++ b/src/test/java/app/bottlenote/review/controller/ReviewControllerTest.java
@@ -24,6 +24,7 @@
 import app.bottlenote.review.exception.ReviewException;
 import app.bottlenote.review.fixture.ReviewObjectFixture;
 import app.bottlenote.review.service.ReviewService;
+import app.bottlenote.support.block.service.BlockService;
 import app.bottlenote.user.exception.UserExceptionCode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.jsonwebtoken.ExpiredJwtException;
@@ -97,12 +98,16 @@ class ReviewControllerTest {
 	protected MockMvc mockMvc;
 	@MockBean
 	private ReviewService reviewService;
+	@MockBean
+	private BlockService blockService;
 
 	private MockedStatic<SecurityContextUtil> mockedSecurityUtil;
 
 	@BeforeEach
 	void setup() {
 		mockedSecurityUtil = mockStatic(SecurityContextUtil.class);
+		// BlockService mock 설정 - 차단되지 않은 상태로 설정
+		when(blockService.isBlocked(any(), any())).thenReturn(false);
 	}
 
 	@AfterEach

From 4641a8689c20181bf85bda4ac4d4970ac96213fa Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Fri, 27 Jun 2025 14:19:34 +0900
Subject: [PATCH 07/16] feat: add BlockCreateRequest DTO for block request
 handling

Signed-off-by: hgkim <hgkim@openerd.com>
---
 .../support/block/dto/request/BlockCreateRequest.java      | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 src/main/java/app/bottlenote/support/block/dto/request/BlockCreateRequest.java

diff --git a/src/main/java/app/bottlenote/support/block/dto/request/BlockCreateRequest.java b/src/main/java/app/bottlenote/support/block/dto/request/BlockCreateRequest.java
new file mode 100644
index 000000000..8c2ef5ef9
--- /dev/null
+++ b/src/main/java/app/bottlenote/support/block/dto/request/BlockCreateRequest.java
@@ -0,0 +1,7 @@
+package app.bottlenote.support.block.dto.request;
+
+/**
+ * 차단 요청 DTO
+ */
+public record BlockCreateRequest(Long blockedUserId) {
+}
\ No newline at end of file

From dc2aa769c42d8dd3199d75923470d7743dc45411 Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Fri, 27 Jun 2025 20:27:36 +0900
Subject: [PATCH 08/16] feat: add no arg construct

---
 .../common/block/serializer/BlockWordSerializer.java  | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java b/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java
index f3adf9aba..54da6db97 100644
--- a/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java
+++ b/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java
@@ -29,10 +29,15 @@ public class BlockWordSerializer extends JsonSerializer<String> implements Conte
     public BlockWordSerializer(BlockService blockService) {
         this.blockService = blockService;
     }
+    
+    public BlockWordSerializer() {
+        this.blockService = null;
+    }
 
     @Override
     public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
-        if (blockWordAnnotation == null) {
+        if (blockWordAnnotation == null || blockService == null) {
+            // 어노테이션이 없거나 BlockService가 없는 경우 원본 값 반환 (테스트 환경 등)
             gen.writeString(value);
             return;
         }
@@ -88,7 +93,9 @@ public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty
             }
 
             if (annotation != null) {
-                BlockWordSerializer serializer = new BlockWordSerializer(blockService);
+                BlockWordSerializer serializer = blockService != null
+                    ? new BlockWordSerializer(blockService)
+                    : new BlockWordSerializer();
                 serializer.blockWordAnnotation = annotation;
                 return serializer;
             }

From e24d6e7a48fd91a608000790cdf9132774cecd33 Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Sun, 29 Jun 2025 13:31:03 +0900
Subject: [PATCH 09/16] feat: refactor BlockWord configuration and serializer
 for improved dependency injection

Signed-off-by: hgkim <hgkim@openerd.com>
---
 .../common/block/config/BlockWordConfig.java  |  12 +-
 .../block/serializer/BlockWordSerializer.java |  47 ++-
 .../support/block/service/BlockService.java   | 296 +++++++++---------
 3 files changed, 190 insertions(+), 165 deletions(-)

diff --git a/src/main/java/app/bottlenote/common/block/config/BlockWordConfig.java b/src/main/java/app/bottlenote/common/block/config/BlockWordConfig.java
index a1df56fc5..3352343be 100644
--- a/src/main/java/app/bottlenote/common/block/config/BlockWordConfig.java
+++ b/src/main/java/app/bottlenote/common/block/config/BlockWordConfig.java
@@ -1,19 +1,11 @@
 package app.bottlenote.common.block.config;
 
+import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Configuration;
 
-/**
- * BlockWord 시리얼라이저 설정
- *
- * @BlockWord 어노테이션에 @JsonSerialize가 직접 포함되어 있으므로
- * 글로벌 시리얼라이저 등록은 불필요함
- */
 @Slf4j
 @Configuration
+@RequiredArgsConstructor
 public class BlockWordConfig {
-
-    public BlockWordConfig() {
-        log.debug("BlockWordConfig 초기화 완료 - @BlockWord 어노테이션 자체에 @JsonSerialize 포함");
-    }
 }
diff --git a/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java b/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java
index 54da6db97..93b24a481 100644
--- a/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java
+++ b/src/main/java/app/bottlenote/common/block/serializer/BlockWordSerializer.java
@@ -10,6 +10,9 @@
 import com.fasterxml.jackson.databind.SerializerProvider;
 import com.fasterxml.jackson.databind.ser.ContextualSerializer;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeansException;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
 import org.springframework.stereotype.Component;
 
 import java.io.IOException;
@@ -21,8 +24,9 @@
  */
 @Slf4j
 @Component
-public class BlockWordSerializer extends JsonSerializer<String> implements ContextualSerializer {
+public class BlockWordSerializer extends JsonSerializer<String> implements ContextualSerializer, ApplicationContextAware {
 
+    private static ApplicationContext applicationContext;
     private final BlockService blockService;
     private BlockWord blockWordAnnotation;
 
@@ -34,10 +38,31 @@ public BlockWordSerializer() {
         this.blockService = null;
     }
 
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+        BlockWordSerializer.applicationContext = applicationContext;
+    }
+
     @Override
     public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
-        if (blockWordAnnotation == null || blockService == null) {
-            // 어노테이션이 없거나 BlockService가 없는 경우 원본 값 반환 (테스트 환경 등)
+        if (blockWordAnnotation == null) {
+            // 어노테이션이 없는 경우 원본 값 반환
+            gen.writeString(value);
+            return;
+        }
+
+        // BlockService 획득 (의존성 주입된 것이 있으면 사용, 없으면 ApplicationContext에서 가져오기)
+        BlockService currentBlockService = blockService;
+        if (currentBlockService == null && applicationContext != null) {
+            try {
+                currentBlockService = applicationContext.getBean(BlockService.class);
+            } catch (Exception e) {
+                log.warn("ApplicationContext에서 BlockService를 가져오는데 실패: {}", e.getMessage());
+            }
+        }
+        
+        if (currentBlockService == null) {
+            // BlockService를 찾을 수 없는 경우 원본 값 반환 (테스트 환경 등)
             gen.writeString(value);
             return;
         }
@@ -66,7 +91,7 @@ public void serialize(String value, JsonGenerator gen, SerializerProvider serial
             }
 
             // 차단 관계 확인
-            boolean isBlocked = blockService.isBlocked(currentUserId, authorId);
+            boolean isBlocked = currentBlockService.isBlocked(currentUserId, authorId);
             if (isBlocked) {
                 // 차단된 경우 대체 메시지로 변경
                 gen.writeString(blockWordAnnotation.value());
@@ -93,9 +118,17 @@ public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty
             }
 
             if (annotation != null) {
-                BlockWordSerializer serializer = blockService != null
-                    ? new BlockWordSerializer(blockService)
-                    : new BlockWordSerializer();
+                // ApplicationContext에서 BlockService 가져오기
+                BlockService contextBlockService = null;
+                if (applicationContext != null) {
+                    try {
+                        contextBlockService = applicationContext.getBean(BlockService.class);
+                    } catch (Exception e) {
+                        log.warn("ApplicationContext에서 BlockService 가져오기 실패: {}", e.getMessage());
+                    }
+                }
+                
+                BlockWordSerializer serializer = new BlockWordSerializer(contextBlockService);
                 serializer.blockWordAnnotation = annotation;
                 return serializer;
             }
diff --git a/src/main/java/app/bottlenote/support/block/service/BlockService.java b/src/main/java/app/bottlenote/support/block/service/BlockService.java
index dbb96e140..28ee824c5 100644
--- a/src/main/java/app/bottlenote/support/block/service/BlockService.java
+++ b/src/main/java/app/bottlenote/support/block/service/BlockService.java
@@ -27,153 +27,153 @@
 @Transactional(readOnly = true)
 public class BlockService {
 
-    private final UserBlockRepository userBlockRepository;
-
-    /**
-     * 사용자 차단
-     *
-     * @param blockerId 차단하는 사용자 ID
-     * @param blockedId 차단당하는 사용자 ID
-     * @param reason    차단 사유 (선택사항)
-     */
-    @Transactional
-    @CacheEvict(value = "blocked_users", key = "#blockerId")
-    public void blockUser(Long blockerId, Long blockedId, String reason) {
-        validateBlockRequest(blockerId, blockedId);
-
-        // 이미 차단된 관계인지 확인
-        if (userBlockRepository.existsByBlockerIdAndBlockedId(blockerId, blockedId)) {
-            throw new BlockException(USER_ALREADY_BLOCKED);
-        }
-
-        // 차단 관계 생성
-        UserBlock userBlock = UserBlock.create(blockerId, blockedId, reason);
-        userBlockRepository.save(userBlock);
-
-        log.info("사용자 차단 완료 - 차단자: {}, 피차단자: {}", blockerId, blockedId);
-    }
-
-    /**
-     * 사용자 차단 (사유 없음)
-     */
-    @Transactional
-    public void blockUser(Long blockerId, Long blockedId) {
-        blockUser(blockerId, blockedId, null);
-    }
-
-    /**
-     * 사용자 차단 해제
-     *
-     * @param blockerId 차단 해제하는 사용자 ID
-     * @param blockedId 차단 해제당하는 사용자 ID
-     */
-    @Transactional
-    @CacheEvict(value = "blocked_users", key = "#blockerId")
-    public void unblockUser(Long blockerId, Long blockedId) {
-        validateBlockRequest(blockerId, blockedId);
-
-        UserBlock userBlock = userBlockRepository.findByBlockerIdAndBlockedId(blockerId, blockedId)
-                .orElseThrow(() -> new BlockException(USER_BLOCK_NOT_FOUND));
-
-        userBlockRepository.delete(userBlock);
-
-        log.info("사용자 차단 해제 완료 - 차단자: {}, 피차단자: {}", blockerId, blockedId);
-    }
-
-    /**
-     * 특정 사용자가 차단한 사용자들의 ID 목록을 조회 (캐시 적용)
-     *
-     * @param userId 사용자 ID
-     * @return 차단된 사용자 ID 목록
-     */
-    @Transactional(readOnly = true)
-    @Cacheable(value = "blocked_users", key = "#userId")
-    public Set<Long> getBlockedUserIds(Long userId) {
-        if (userId == null) {
-            return Set.of();
-        }
-
-        return userBlockRepository.findBlockedUserIdsByBlockerId(userId);
-    }
-
-    /**
-     * 두 사용자 간 차단 여부 확인
-     *
-     * @param blockerId 차단하는 사용자 ID
-     * @param blockedId 차단당하는 사용자 ID
-     * @return 차단 여부
-     */
-    @Transactional(readOnly = true)
-    public boolean isBlocked(Long blockerId, Long blockedId) {
-        if (blockerId == null || blockedId == null) {
-            return false;
-        }
-
-        Set<Long> blockedUsers = getBlockedUserIds(blockerId);
-        return blockedUsers.contains(blockedId);
-    }
-
-    /**
-     * 상호 차단 여부 확인
-     *
-     * @param userId1 사용자 1 ID
-     * @param userId2 사용자 2 ID
-     * @return 상호 차단 여부
-     */
-    @Transactional(readOnly = true)
-    public boolean isMutualBlocked(Long userId1, Long userId2) {
-        if (userId1 == null || userId2 == null) {
-            return false;
-        }
-
-        return userBlockRepository.existsMutualBlock(userId1, userId2);
-    }
-
-    /**
-     * 특정 사용자를 차단한 사용자 수 조회
-     *
-     * @param userId 사용자 ID
-     * @return 해당 사용자를 차단한 사용자 수
-     */
-    @Transactional(readOnly = true)
-    public long getBlockedByCount(Long userId) {
-        if (userId == null) {
-            return 0L;
-        }
-
-        return userBlockRepository.countByBlockedId(userId);
-    }
-
-    /**
-     * 특정 사용자가 차단한 사용자 수 조회
-     *
-     * @param userId 사용자 ID
-     * @return 해당 사용자가 차단한 사용자 수
-     */
-    @Transactional(readOnly = true)
-    public long getBlockingCount(Long userId) {
-        if (userId == null) {
-            return 0L;
-        }
-
-        return userBlockRepository.countByBlockerId(userId);
-    }
-
-    /**
-     * 차단 요청 유효성 검증
-     */
-    private void validateBlockRequest(Long blockerId, Long blockedId) {
-        if (blockerId == null) {
-            throw new BlockException(REQUIRED_USER_ID);
-        }
-
-        if (blockedId == null) {
-            throw new BlockException(REQUIRED_USER_ID);
-        }
-
-        if (blockerId.equals(blockedId)) {
-            throw new BlockException(CANNOT_BLOCK_SELF);
-        }
-    }
+	private final UserBlockRepository userBlockRepository;
+
+	/**
+	 * 사용자 차단
+	 *
+	 * @param blockerId 차단하는 사용자 ID
+	 * @param blockedId 차단당하는 사용자 ID
+	 * @param reason    차단 사유 (선택사항)
+	 */
+	@Transactional
+	@CacheEvict(value = "blocked_users", key = "#blockerId")
+	public void blockUser(Long blockerId, Long blockedId, String reason) {
+		validateBlockRequest(blockerId, blockedId);
+
+		// 이미 차단된 관계인지 확인
+		if (userBlockRepository.existsByBlockerIdAndBlockedId(blockerId, blockedId)) {
+			throw new BlockException(USER_ALREADY_BLOCKED);
+		}
+
+		// 차단 관계 생성
+		UserBlock userBlock = UserBlock.create(blockerId, blockedId, reason);
+		userBlockRepository.save(userBlock);
+
+		log.info("사용자 차단 완료 - 차단자: {}, 피차단자: {}", blockerId, blockedId);
+	}
+
+	/**
+	 * 사용자 차단 (사유 없음)
+	 */
+	@Transactional
+	public void blockUser(Long blockerId, Long blockedId) {
+		blockUser(blockerId, blockedId, null);
+	}
+
+	/**
+	 * 사용자 차단 해제
+	 *
+	 * @param blockerId 차단 해제하는 사용자 ID
+	 * @param blockedId 차단 해제당하는 사용자 ID
+	 */
+	@Transactional
+	@CacheEvict(value = "blocked_users", key = "#blockerId")
+	public void unblockUser(Long blockerId, Long blockedId) {
+		validateBlockRequest(blockerId, blockedId);
+
+		UserBlock userBlock = userBlockRepository.findByBlockerIdAndBlockedId(blockerId, blockedId)
+				.orElseThrow(() -> new BlockException(USER_BLOCK_NOT_FOUND));
+
+		userBlockRepository.delete(userBlock);
+
+		log.info("사용자 차단 해제 완료 - 차단자: {}, 피차단자: {}", blockerId, blockedId);
+	}
+
+	/**
+	 * 특정 사용자가 차단한 사용자들의 ID 목록을 조회 (캐시 적용)
+	 *
+	 * @param userId 사용자 ID
+	 * @return 차단된 사용자 ID 목록
+	 */
+	@Transactional(readOnly = true)
+	@Cacheable(value = "blocked_users", key = "#userId")
+	public Set<Long> getBlockedUserIds(Long userId) {
+		if (userId == null) {
+			return Set.of();
+		}
+
+		return userBlockRepository.findBlockedUserIdsByBlockerId(userId);
+	}
+
+	/**
+	 * 두 사용자 간 차단 여부 확인
+	 *
+	 * @param blockerId 차단하는 사용자 ID
+	 * @param blockedId 차단당하는 사용자 ID
+	 * @return 차단 여부
+	 */
+	@Transactional(readOnly = true)
+	public boolean isBlocked(Long blockerId, Long blockedId) {
+		if (blockerId == null || blockedId == null) {
+			return false;
+		}
+
+		Set<Long> blockedUsers = getBlockedUserIds(blockerId);
+		return blockedUsers.contains(blockedId);
+	}
+
+	/**
+	 * 상호 차단 여부 확인
+	 *
+	 * @param userId1 사용자 1 ID
+	 * @param userId2 사용자 2 ID
+	 * @return 상호 차단 여부
+	 */
+	@Transactional(readOnly = true)
+	public boolean isMutualBlocked(Long userId1, Long userId2) {
+		if (userId1 == null || userId2 == null) {
+			return false;
+		}
+
+		return userBlockRepository.existsMutualBlock(userId1, userId2);
+	}
+
+	/**
+	 * 특정 사용자를 차단한 사용자 수 조회
+	 *
+	 * @param userId 사용자 ID
+	 * @return 해당 사용자를 차단한 사용자 수
+	 */
+	@Transactional(readOnly = true)
+	public long getBlockedByCount(Long userId) {
+		if (userId == null) {
+			return 0L;
+		}
+
+		return userBlockRepository.countByBlockedId(userId);
+	}
+
+	/**
+	 * 특정 사용자가 차단한 사용자 수 조회
+	 *
+	 * @param userId 사용자 ID
+	 * @return 해당 사용자가 차단한 사용자 수
+	 */
+	@Transactional(readOnly = true)
+	public long getBlockingCount(Long userId) {
+		if (userId == null) {
+			return 0L;
+		}
+
+		return userBlockRepository.countByBlockerId(userId);
+	}
+
+	/**
+	 * 차단 요청 유효성 검증
+	 */
+	private void validateBlockRequest(Long blockerId, Long blockedId) {
+		if (blockerId == null) {
+			throw new BlockException(REQUIRED_USER_ID);
+		}
+
+		if (blockedId == null) {
+			throw new BlockException(REQUIRED_USER_ID);
+		}
+
+		if (blockerId.equals(blockedId)) {
+			throw new BlockException(CANNOT_BLOCK_SELF);
+		}
+	}
 
 }

From 0d841700d7259f6615062fa8c04231f36fadce7f Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Tue, 1 Jul 2025 01:11:43 +0900
Subject: [PATCH 10/16] feat: enhance block management with new endpoints and
 response structure

Signed-off-by: hgkim <hgkim@openerd.com>
---
 .../block/controller/BlockController.java     | 66 +++++++++++++----
 .../block/dto/response/UserBlockItem.java     | 10 +++
 .../block/repository/UserBlockRepository.java | 52 +------------
 .../support/block/service/BlockService.java   | 73 +++++--------------
 4 files changed, 83 insertions(+), 118 deletions(-)
 create mode 100644 src/main/java/app/bottlenote/support/block/dto/response/UserBlockItem.java

diff --git a/src/main/java/app/bottlenote/support/block/controller/BlockController.java b/src/main/java/app/bottlenote/support/block/controller/BlockController.java
index f5a60f43e..d190ad2b5 100644
--- a/src/main/java/app/bottlenote/support/block/controller/BlockController.java
+++ b/src/main/java/app/bottlenote/support/block/controller/BlockController.java
@@ -1,8 +1,10 @@
 package app.bottlenote.support.block.controller;
 
+import app.bottlenote.global.data.response.CollectionResponse;
 import app.bottlenote.global.data.response.GlobalResponse;
 import app.bottlenote.global.security.SecurityContextUtil;
 import app.bottlenote.support.block.dto.request.BlockCreateRequest;
+import app.bottlenote.support.block.dto.response.UserBlockItem;
 import app.bottlenote.support.block.exception.BlockException;
 import app.bottlenote.support.block.service.BlockService;
 import jakarta.validation.Valid;
@@ -19,9 +21,6 @@
 
 import static app.bottlenote.support.block.exception.BlockExceptionCode.REQUIRED_USER_ID;
 
-/**
- * 차단 관리 API
- */
 @Slf4j
 @RestController
 @RequiredArgsConstructor
@@ -30,40 +29,77 @@ public class BlockController {
 
 	private final BlockService blockService;
 
-	/**
-	 * 사용자 차단
-	 */
-	@PostMapping("/create")
+	@PostMapping
 	public ResponseEntity<?> createBlock(@RequestBody @Valid BlockCreateRequest request) {
 		Long currentUserId = SecurityContextUtil.getUserIdByContext()
 				.orElseThrow(() -> new BlockException(REQUIRED_USER_ID));
 
 		blockService.blockUser(currentUserId, request.blockedUserId());
+		CollectionResponse<UserBlockItem> blockedUsers = blockService.getBlockedUserItems(currentUserId);
 
-		return GlobalResponse.ok("차단이 완료되었습니다.");
+		return GlobalResponse.ok(blockedUsers);
 	}
 
-	/**
-	 * 차단 해제
-	 */
 	@DeleteMapping("/{blockedUserId}")
 	public ResponseEntity<?> deleteBlock(@PathVariable Long blockedUserId) {
 		Long currentUserId = SecurityContextUtil.getUserIdByContext()
 				.orElseThrow(() -> new BlockException(REQUIRED_USER_ID));
 
 		blockService.unblockUser(currentUserId, blockedUserId);
+		CollectionResponse<UserBlockItem> blockedUsers = blockService.getBlockedUserItems(currentUserId);
 
-		return GlobalResponse.ok("차단이 해제되었습니다.");
+		return GlobalResponse.ok(blockedUsers);
 	}
 
-	/**
-	 * 차단 목록 조회
-	 */
 	@GetMapping
 	public ResponseEntity<?> getBlockedUsers() {
 		Long currentUserId = SecurityContextUtil.getUserIdByContext()
 				.orElseThrow(() -> new BlockException(REQUIRED_USER_ID));
 
+		return GlobalResponse.ok(blockService.getBlockedUserItems(currentUserId));
+	}
+
+	@GetMapping("/ids")
+	public ResponseEntity<?> getBlockedUserIds() {
+		Long currentUserId = SecurityContextUtil.getUserIdByContext()
+				.orElseThrow(() -> new BlockException(REQUIRED_USER_ID));
+
 		return GlobalResponse.ok(blockService.getBlockedUserIds(currentUserId));
 	}
+
+	@GetMapping("/check/{targetUserId}")
+	public ResponseEntity<?> checkBlocked(@PathVariable Long targetUserId) {
+		Long currentUserId = SecurityContextUtil.getUserIdByContext()
+				.orElseThrow(() -> new BlockException(REQUIRED_USER_ID));
+
+		boolean isBlocked = blockService.isBlocked(currentUserId, targetUserId);
+		return GlobalResponse.ok(isBlocked);
+	}
+
+	@GetMapping("/mutual-check/{targetUserId}")
+	public ResponseEntity<?> checkMutualBlocked(@PathVariable Long targetUserId) {
+		Long currentUserId = SecurityContextUtil.getUserIdByContext()
+				.orElseThrow(() -> new BlockException(REQUIRED_USER_ID));
+
+		boolean isMutualBlocked = blockService.isMutualBlocked(currentUserId, targetUserId);
+		return GlobalResponse.ok(isMutualBlocked);
+	}
+
+	@GetMapping("/stats/blocked-by-count")
+	public ResponseEntity<?> getBlockedByCount() {
+		Long currentUserId = SecurityContextUtil.getUserIdByContext()
+				.orElseThrow(() -> new BlockException(REQUIRED_USER_ID));
+
+		long count = blockService.getBlockedByCount(currentUserId);
+		return GlobalResponse.ok(count);
+	}
+
+	@GetMapping("/stats/blocking-count")
+	public ResponseEntity<?> getBlockingCount() {
+		Long currentUserId = SecurityContextUtil.getUserIdByContext()
+				.orElseThrow(() -> new BlockException(REQUIRED_USER_ID));
+
+		long count = blockService.getBlockingCount(currentUserId);
+		return GlobalResponse.ok(count);
+	}
 }
diff --git a/src/main/java/app/bottlenote/support/block/dto/response/UserBlockItem.java b/src/main/java/app/bottlenote/support/block/dto/response/UserBlockItem.java
new file mode 100644
index 000000000..e33f05e1a
--- /dev/null
+++ b/src/main/java/app/bottlenote/support/block/dto/response/UserBlockItem.java
@@ -0,0 +1,10 @@
+package app.bottlenote.support.block.dto.response;
+
+import java.time.LocalDateTime;
+
+public record UserBlockItem(
+		Long userId,
+		String userName,
+		LocalDateTime blockedAt
+) {
+}
diff --git a/src/main/java/app/bottlenote/support/block/repository/UserBlockRepository.java b/src/main/java/app/bottlenote/support/block/repository/UserBlockRepository.java
index 434bc4a80..7f0f64749 100644
--- a/src/main/java/app/bottlenote/support/block/repository/UserBlockRepository.java
+++ b/src/main/java/app/bottlenote/support/block/repository/UserBlockRepository.java
@@ -1,73 +1,29 @@
 package app.bottlenote.support.block.repository;
 
 import app.bottlenote.support.block.domain.UserBlock;
+import app.bottlenote.support.block.dto.response.UserBlockItem;
 
+import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 
-/**
- * 사용자 차단 관계 Repository
- */
 public interface UserBlockRepository {
 
-    /**
-     * 차단 관계 저장
-     */
     UserBlock save(UserBlock userBlock);
 
-    /**
-     * 차단 관계 삭제
-     */
     void delete(UserBlock userBlock);
 
-    /**
-     * 특정 사용자가 차단한 사용자 ID 목록 조회
-     * 
-     * @param blockerId 차단한 사용자 ID
-     * @return 차단된 사용자 ID 목록
-     */
     Set<Long> findBlockedUserIdsByBlockerId(Long blockerId);
 
-    /**
-     * 차단 관계 존재 여부 확인
-     * 
-     * @param blockerId 차단한 사용자 ID
-     * @param blockedId 차단당한 사용자 ID
-     * @return 차단 관계 존재 여부
-     */
     boolean existsByBlockerIdAndBlockedId(Long blockerId, Long blockedId);
 
-    /**
-     * 특정 차단 관계 조회
-     * 
-     * @param blockerId 차단한 사용자 ID
-     * @param blockedId 차단당한 사용자 ID
-     * @return 차단 관계 엔티티
-     */
     Optional<UserBlock> findByBlockerIdAndBlockedId(Long blockerId, Long blockedId);
 
-    /**
-     * 특정 사용자를 차단한 사용자 수 조회
-     * 
-     * @param blockedId 차단당한 사용자 ID
-     * @return 차단한 사용자 수
-     */
     long countByBlockedId(Long blockedId);
 
-    /**
-     * 특정 사용자가 차단한 사용자 수 조회
-     * 
-     * @param blockerId 차단한 사용자 ID
-     * @return 차단한 사용자 수
-     */
     long countByBlockerId(Long blockerId);
 
-    /**
-     * 상호 차단 관계 확인 (서로 차단한 경우)
-     * 
-     * @param userId1 사용자 1
-     * @param userId2 사용자 2
-     * @return 상호 차단 여부
-     */
     boolean existsMutualBlock(Long userId1, Long userId2);
+
+    List<UserBlockItem> findBlockedUserItemsByBlockerId(Long blockerId);
 }
\ No newline at end of file
diff --git a/src/main/java/app/bottlenote/support/block/service/BlockService.java b/src/main/java/app/bottlenote/support/block/service/BlockService.java
index 28ee824c5..67461bc24 100644
--- a/src/main/java/app/bottlenote/support/block/service/BlockService.java
+++ b/src/main/java/app/bottlenote/support/block/service/BlockService.java
@@ -1,6 +1,8 @@
 package app.bottlenote.support.block.service;
 
+import app.bottlenote.global.data.response.CollectionResponse;
 import app.bottlenote.support.block.domain.UserBlock;
+import app.bottlenote.support.block.dto.response.UserBlockItem;
 import app.bottlenote.support.block.exception.BlockException;
 import app.bottlenote.support.block.repository.UserBlockRepository;
 import lombok.RequiredArgsConstructor;
@@ -10,6 +12,7 @@
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.List;
 import java.util.Set;
 
 import static app.bottlenote.support.block.exception.BlockExceptionCode.CANNOT_BLOCK_SELF;
@@ -17,10 +20,7 @@
 import static app.bottlenote.support.block.exception.BlockExceptionCode.USER_ALREADY_BLOCKED;
 import static app.bottlenote.support.block.exception.BlockExceptionCode.USER_BLOCK_NOT_FOUND;
 
-/**
- * 사용자 차단 관리 서비스
- * 차단 관계 생성, 해제, 조회 및 캐싱 처리
- */
+
 @Slf4j
 @Service
 @RequiredArgsConstructor
@@ -29,13 +29,6 @@ public class BlockService {
 
 	private final UserBlockRepository userBlockRepository;
 
-	/**
-	 * 사용자 차단
-	 *
-	 * @param blockerId 차단하는 사용자 ID
-	 * @param blockedId 차단당하는 사용자 ID
-	 * @param reason    차단 사유 (선택사항)
-	 */
 	@Transactional
 	@CacheEvict(value = "blocked_users", key = "#blockerId")
 	public void blockUser(Long blockerId, Long blockedId, String reason) {
@@ -53,20 +46,11 @@ public void blockUser(Long blockerId, Long blockedId, String reason) {
 		log.info("사용자 차단 완료 - 차단자: {}, 피차단자: {}", blockerId, blockedId);
 	}
 
-	/**
-	 * 사용자 차단 (사유 없음)
-	 */
 	@Transactional
 	public void blockUser(Long blockerId, Long blockedId) {
 		blockUser(blockerId, blockedId, null);
 	}
 
-	/**
-	 * 사용자 차단 해제
-	 *
-	 * @param blockerId 차단 해제하는 사용자 ID
-	 * @param blockedId 차단 해제당하는 사용자 ID
-	 */
 	@Transactional
 	@CacheEvict(value = "blocked_users", key = "#blockerId")
 	public void unblockUser(Long blockerId, Long blockedId) {
@@ -80,12 +64,6 @@ public void unblockUser(Long blockerId, Long blockedId) {
 		log.info("사용자 차단 해제 완료 - 차단자: {}, 피차단자: {}", blockerId, blockedId);
 	}
 
-	/**
-	 * 특정 사용자가 차단한 사용자들의 ID 목록을 조회 (캐시 적용)
-	 *
-	 * @param userId 사용자 ID
-	 * @return 차단된 사용자 ID 목록
-	 */
 	@Transactional(readOnly = true)
 	@Cacheable(value = "blocked_users", key = "#userId")
 	public Set<Long> getBlockedUserIds(Long userId) {
@@ -96,13 +74,20 @@ public Set<Long> getBlockedUserIds(Long userId) {
 		return userBlockRepository.findBlockedUserIdsByBlockerId(userId);
 	}
 
-	/**
-	 * 두 사용자 간 차단 여부 확인
-	 *
-	 * @param blockerId 차단하는 사용자 ID
-	 * @param blockedId 차단당하는 사용자 ID
-	 * @return 차단 여부
-	 */
+
+	@Transactional(readOnly = true)
+	@Cacheable(value = "blocked_user_items", key = "#userId")
+	public CollectionResponse<UserBlockItem> getBlockedUserItems(Long userId) {
+		if (userId == null) {
+			return CollectionResponse.of(0L, List.of());
+		}
+
+		List<UserBlockItem> items = userBlockRepository.findBlockedUserItemsByBlockerId(userId);
+		long totalCount = items.size();
+
+		return CollectionResponse.of(totalCount, items);
+	}
+
 	@Transactional(readOnly = true)
 	public boolean isBlocked(Long blockerId, Long blockedId) {
 		if (blockerId == null || blockedId == null) {
@@ -113,13 +98,6 @@ public boolean isBlocked(Long blockerId, Long blockedId) {
 		return blockedUsers.contains(blockedId);
 	}
 
-	/**
-	 * 상호 차단 여부 확인
-	 *
-	 * @param userId1 사용자 1 ID
-	 * @param userId2 사용자 2 ID
-	 * @return 상호 차단 여부
-	 */
 	@Transactional(readOnly = true)
 	public boolean isMutualBlocked(Long userId1, Long userId2) {
 		if (userId1 == null || userId2 == null) {
@@ -129,12 +107,6 @@ public boolean isMutualBlocked(Long userId1, Long userId2) {
 		return userBlockRepository.existsMutualBlock(userId1, userId2);
 	}
 
-	/**
-	 * 특정 사용자를 차단한 사용자 수 조회
-	 *
-	 * @param userId 사용자 ID
-	 * @return 해당 사용자를 차단한 사용자 수
-	 */
 	@Transactional(readOnly = true)
 	public long getBlockedByCount(Long userId) {
 		if (userId == null) {
@@ -144,12 +116,6 @@ public long getBlockedByCount(Long userId) {
 		return userBlockRepository.countByBlockedId(userId);
 	}
 
-	/**
-	 * 특정 사용자가 차단한 사용자 수 조회
-	 *
-	 * @param userId 사용자 ID
-	 * @return 해당 사용자가 차단한 사용자 수
-	 */
 	@Transactional(readOnly = true)
 	public long getBlockingCount(Long userId) {
 		if (userId == null) {
@@ -159,9 +125,6 @@ public long getBlockingCount(Long userId) {
 		return userBlockRepository.countByBlockerId(userId);
 	}
 
-	/**
-	 * 차단 요청 유효성 검증
-	 */
 	private void validateBlockRequest(Long blockerId, Long blockedId) {
 		if (blockerId == null) {
 			throw new BlockException(REQUIRED_USER_ID);

From 31ea611647b83461c13f127edbc65fc1860f093a Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Tue, 1 Jul 2025 01:11:59 +0900
Subject: [PATCH 11/16] feat: implement in-memory user block repository and
 associated service tests

Signed-off-by: hgkim <hgkim@openerd.com>
---
 .../fixture/InMemoryUserBlockRepository.java  | 107 +++++
 .../block/service/BlockServiceTest.java       | 424 ++++++++++++++++++
 2 files changed, 531 insertions(+)
 create mode 100644 src/test/java/app/bottlenote/support/block/fixture/InMemoryUserBlockRepository.java
 create mode 100644 src/test/java/app/bottlenote/support/block/service/BlockServiceTest.java

diff --git a/src/test/java/app/bottlenote/support/block/fixture/InMemoryUserBlockRepository.java b/src/test/java/app/bottlenote/support/block/fixture/InMemoryUserBlockRepository.java
new file mode 100644
index 000000000..678de7d73
--- /dev/null
+++ b/src/test/java/app/bottlenote/support/block/fixture/InMemoryUserBlockRepository.java
@@ -0,0 +1,107 @@
+package app.bottlenote.support.block.fixture;
+
+import app.bottlenote.support.block.domain.UserBlock;
+import app.bottlenote.support.block.dto.response.UserBlockItem;
+import app.bottlenote.support.block.repository.UserBlockRepository;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class InMemoryUserBlockRepository implements UserBlockRepository {
+
+    private final Map<Long, UserBlock> userBlocks = new HashMap<>();
+    private final Map<String, String> userNames = new HashMap<>();
+    private Long idGenerator = 1L;
+
+    public InMemoryUserBlockRepository() {
+        userNames.put("1", "테스트유저1");
+        userNames.put("2", "테스트유저2");
+        userNames.put("3", "테스트유저3");
+        userNames.put("4", "테스트유저4");
+        userNames.put("5", "테스트유저5");
+    }
+
+    @Override
+    public UserBlock save(UserBlock userBlock) {
+        Long id = idGenerator++;
+        ReflectionTestUtils.setField(userBlock, "id", id);
+        userBlocks.put(id, userBlock);
+        return userBlock;
+    }
+
+    @Override
+    public void delete(UserBlock userBlock) {
+        userBlocks.remove(userBlock.getId());
+    }
+
+    @Override
+    public Set<Long> findBlockedUserIdsByBlockerId(Long blockerId) {
+        return userBlocks.values().stream()
+                .filter(block -> block.getBlockerId().equals(blockerId))
+                .map(UserBlock::getBlockedId)
+                .collect(Collectors.toSet());
+    }
+
+    @Override
+    public boolean existsByBlockerIdAndBlockedId(Long blockerId, Long blockedId) {
+        return userBlocks.values().stream()
+                .anyMatch(block -> block.getBlockerId().equals(blockerId)
+                    && block.getBlockedId().equals(blockedId));
+    }
+
+    @Override
+    public Optional<UserBlock> findByBlockerIdAndBlockedId(Long blockerId, Long blockedId) {
+        return userBlocks.values().stream()
+                .filter(block -> block.getBlockerId().equals(blockerId)
+                    && block.getBlockedId().equals(blockedId))
+                .findFirst();
+    }
+
+    @Override
+    public long countByBlockedId(Long blockedId) {
+        return userBlocks.values().stream()
+                .filter(block -> block.getBlockedId().equals(blockedId))
+                .count();
+    }
+
+    @Override
+    public long countByBlockerId(Long blockerId) {
+        return userBlocks.values().stream()
+                .filter(block -> block.getBlockerId().equals(blockerId))
+                .count();
+    }
+
+    @Override
+    public boolean existsMutualBlock(Long userId1, Long userId2) {
+        boolean user1BlocksUser2 = existsByBlockerIdAndBlockedId(userId1, userId2);
+        boolean user2BlocksUser1 = existsByBlockerIdAndBlockedId(userId2, userId1);
+        return user1BlocksUser2 && user2BlocksUser1;
+    }
+
+    @Override
+    public List<UserBlockItem> findBlockedUserItemsByBlockerId(Long blockerId) {
+        return userBlocks.values().stream()
+                .filter(block -> block.getBlockerId().equals(blockerId))
+                .map(block -> new UserBlockItem(
+                    block.getBlockedId(),
+                    userNames.getOrDefault(block.getBlockedId().toString(), "알 수 없는 사용자"),
+                    LocalDateTime.now()
+                ))
+                .collect(Collectors.toList());
+    }
+
+    public void addUser(Long userId, String userName) {
+        userNames.put(userId.toString(), userName);
+    }
+
+    public void clear() {
+        userBlocks.clear();
+        idGenerator = 1L;
+    }
+}
diff --git a/src/test/java/app/bottlenote/support/block/service/BlockServiceTest.java b/src/test/java/app/bottlenote/support/block/service/BlockServiceTest.java
new file mode 100644
index 000000000..431bf0dff
--- /dev/null
+++ b/src/test/java/app/bottlenote/support/block/service/BlockServiceTest.java
@@ -0,0 +1,424 @@
+package app.bottlenote.support.block.service;
+
+import app.bottlenote.global.data.response.CollectionResponse;
+import app.bottlenote.support.block.dto.response.UserBlockItem;
+import app.bottlenote.support.block.exception.BlockException;
+import app.bottlenote.support.block.fixture.InMemoryUserBlockRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.Set;
+
+import static app.bottlenote.support.block.exception.BlockExceptionCode.CANNOT_BLOCK_SELF;
+import static app.bottlenote.support.block.exception.BlockExceptionCode.REQUIRED_USER_ID;
+import static app.bottlenote.support.block.exception.BlockExceptionCode.USER_ALREADY_BLOCKED;
+import static app.bottlenote.support.block.exception.BlockExceptionCode.USER_BLOCK_NOT_FOUND;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@Tag("unit")
+@DisplayName("[unit] [service] BlockService")
+class BlockServiceTest {
+
+	private BlockService blockService;
+	private InMemoryUserBlockRepository userBlockRepository;
+
+	@BeforeEach
+	void setUp() {
+		userBlockRepository = new InMemoryUserBlockRepository();
+		blockService = new BlockService(userBlockRepository);
+
+		userBlockRepository.addUser(1L, "차단자");
+		userBlockRepository.addUser(2L, "피차단자1");
+		userBlockRepository.addUser(3L, "피차단자2");
+		userBlockRepository.addUser(4L, "피차단자3");
+	}
+
+	@Nested
+	@DisplayName("사용자를 차단할 때")
+	class BlockUser {
+
+		@Test
+		@DisplayName("정상적으로 차단할 수 있다")
+		void 정상적으로_차단할_수_있다() {
+			// given
+			Long blockerId = 1L;
+			Long blockedId = 2L;
+			String reason = "스팸 메시지";
+
+			// when
+			blockService.blockUser(blockerId, blockedId, reason);
+
+			// then
+			assertTrue(userBlockRepository.existsByBlockerIdAndBlockedId(blockerId, blockedId));
+		}
+
+		@Test
+		@DisplayName("사유 없이 차단할 수 있다")
+		void 사유_없이_차단할_수_있다() {
+			// given
+			Long blockerId = 1L;
+			Long blockedId = 2L;
+
+			// when
+			blockService.blockUser(blockerId, blockedId);
+
+			// then
+			assertTrue(userBlockRepository.existsByBlockerIdAndBlockedId(blockerId, blockedId));
+		}
+
+		@ParameterizedTest
+		@NullSource
+		@DisplayName("차단자 ID가 null이면 예외가 발생한다")
+		void 차단자_ID가_null이면_예외가_발생한다(Long blockerId) {
+			// given
+			Long blockedId = 2L;
+
+			// when & then
+			BlockException exception = assertThrows(BlockException.class,
+					() -> blockService.blockUser(blockerId, blockedId));
+			assertEquals(REQUIRED_USER_ID, exception.getExceptionCode());
+		}
+
+		@ParameterizedTest
+		@NullSource
+		@DisplayName("피차단자 ID가 null이면 예외가 발생한다")
+		void 피차단자_ID가_null이면_예외가_발생한다(Long blockedId) {
+			// given
+			Long blockerId = 1L;
+
+			// when & then
+			BlockException exception = assertThrows(BlockException.class,
+					() -> blockService.blockUser(blockerId, blockedId));
+			assertEquals(REQUIRED_USER_ID, exception.getExceptionCode());
+		}
+
+		@Test
+		@DisplayName("자기 자신을 차단하려고 하면 예외가 발생한다")
+		void 자기_자신을_차단하려고_하면_예외가_발생한다() {
+			// given
+			Long userId = 1L;
+
+			// when & then
+			BlockException exception = assertThrows(BlockException.class,
+					() -> blockService.blockUser(userId, userId));
+			assertEquals(CANNOT_BLOCK_SELF, exception.getExceptionCode());
+		}
+
+		@Test
+		@DisplayName("이미 차단된 사용자를 다시 차단하려고 하면 예외가 발생한다")
+		void 이미_차단된_사용자를_다시_차단하려고_하면_예외가_발생한다() {
+			// given
+			Long blockerId = 1L;
+			Long blockedId = 2L;
+			blockService.blockUser(blockerId, blockedId);
+
+			// when & then
+			BlockException exception = assertThrows(BlockException.class,
+					() -> blockService.blockUser(blockerId, blockedId));
+			assertEquals(USER_ALREADY_BLOCKED, exception.getExceptionCode());
+		}
+	}
+
+	@Nested
+	@DisplayName("사용자 차단을 해제할 때")
+	class UnblockUser {
+
+		@Test
+		@DisplayName("정상적으로 차단을 해제할 수 있다")
+		void 정상적으로_차단을_해제할_수_있다() {
+			// given
+			Long blockerId = 1L;
+			Long blockedId = 2L;
+			blockService.blockUser(blockerId, blockedId);
+
+			// when
+			blockService.unblockUser(blockerId, blockedId);
+
+			// then
+			assertFalse(userBlockRepository.existsByBlockerIdAndBlockedId(blockerId, blockedId));
+		}
+
+		@Test
+		@DisplayName("차단하지 않은 사용자를 해제하려고 하면 예외가 발생한다")
+		void 차단하지_않은_사용자를_해제하려고_하면_예외가_발생한다() {
+			// given
+			Long blockerId = 1L;
+			Long blockedId = 2L;
+
+			// when & then
+			BlockException exception = assertThrows(BlockException.class,
+					() -> blockService.unblockUser(blockerId, blockedId));
+			assertEquals(USER_BLOCK_NOT_FOUND, exception.getExceptionCode());
+		}
+
+		@ParameterizedTest
+		@NullSource
+		@DisplayName("차단자 ID가 null이면 예외가 발생한다")
+		void 차단자_ID가_null이면_예외가_발생한다(Long blockerId) {
+			// given
+			Long blockedId = 2L;
+
+			// when & then
+			BlockException exception = assertThrows(BlockException.class,
+					() -> blockService.unblockUser(blockerId, blockedId));
+			assertEquals(REQUIRED_USER_ID, exception.getExceptionCode());
+		}
+	}
+
+	@Nested
+	@DisplayName("차단된 사용자 ID 목록을 조회할 때")
+	class GetBlockedUserIds {
+
+		@Test
+		@DisplayName("차단한 사용자들의 ID를 조회할 수 있다")
+		void 차단한_사용자들의_ID를_조회할_수_있다() {
+			// given
+			Long blockerId = 1L;
+			blockService.blockUser(blockerId, 2L);
+			blockService.blockUser(blockerId, 3L);
+
+			// when
+			Set<Long> blockedUserIds = blockService.getBlockedUserIds(blockerId);
+
+			// then
+			assertEquals(2, blockedUserIds.size());
+			assertTrue(blockedUserIds.contains(2L));
+			assertTrue(blockedUserIds.contains(3L));
+		}
+
+		@Test
+		@DisplayName("차단한 사용자가 없으면 빈 Set을 반환한다")
+		void 차단한_사용자가_없으면_빈_Set을_반환한다() {
+			// given
+			Long blockerId = 1L;
+
+			// when
+			Set<Long> blockedUserIds = blockService.getBlockedUserIds(blockerId);
+
+			// then
+			assertTrue(blockedUserIds.isEmpty());
+		}
+
+		@Test
+		@DisplayName("사용자 ID가 null이면 빈 Set을 반환한다")
+		void 사용자_ID가_null이면_빈_Set을_반환한다() {
+			// when
+			Set<Long> blockedUserIds = blockService.getBlockedUserIds(null);
+
+			// then
+			assertTrue(blockedUserIds.isEmpty());
+		}
+	}
+
+	@Nested
+	@DisplayName("차단된 사용자 상세 정보를 조회할 때")
+	class GetBlockedUserItems {
+
+		@Test
+		@DisplayName("차단한 사용자들의 상세 정보를 조회할 수 있다")
+		void 차단한_사용자들의_상세_정보를_조회할_수_있다() {
+			// given
+			Long blockerId = 1L;
+			blockService.blockUser(blockerId, 2L);
+			blockService.blockUser(blockerId, 3L);
+
+			// when
+			CollectionResponse<UserBlockItem> response = blockService.getBlockedUserItems(blockerId);
+
+			// then
+			assertEquals(2L, response.getTotalCount());
+			assertEquals(2, response.getItems().size());
+
+			UserBlockItem item1 = response.getItems().stream()
+					.filter(item -> item.userId().equals(2L))
+					.findFirst()
+					.orElseThrow();
+			assertEquals("피차단자1", item1.userName());
+			assertNotNull(item1.blockedAt());
+		}
+
+		@Test
+		@DisplayName("차단한 사용자가 없으면 빈 목록을 반환한다")
+		void 차단한_사용자가_없으면_빈_목록을_반환한다() {
+			// given
+			Long blockerId = 1L;
+
+			// when
+			CollectionResponse<UserBlockItem> response = blockService.getBlockedUserItems(blockerId);
+
+			// then
+			assertEquals(0L, response.getTotalCount());
+			assertTrue(response.getItems().isEmpty());
+		}
+
+		@Test
+		@DisplayName("사용자 ID가 null이면 빈 목록을 반환한다")
+		void 사용자_ID가_null이면_빈_목록을_반환한다() {
+			// when
+			CollectionResponse<UserBlockItem> response = blockService.getBlockedUserItems(null);
+
+			// then
+			assertEquals(0L, response.getTotalCount());
+			assertTrue(response.getItems().isEmpty());
+		}
+	}
+
+	@Nested
+	@DisplayName("차단 여부를 확인할 때")
+	class IsBlocked {
+
+		@Test
+		@DisplayName("차단된 사용자는 true를 반환한다")
+		void 차단된_사용자는_true를_반환한다() {
+			// given
+			Long blockerId = 1L;
+			Long blockedId = 2L;
+			blockService.blockUser(blockerId, blockedId);
+
+			// when
+			boolean isBlocked = blockService.isBlocked(blockerId, blockedId);
+
+			// then
+			assertTrue(isBlocked);
+		}
+
+		@Test
+		@DisplayName("차단되지 않은 사용자는 false를 반환한다")
+		void 차단되지_않은_사용자는_false를_반환한다() {
+			// given
+			Long blockerId = 1L;
+			Long blockedId = 2L;
+
+			// when
+			boolean isBlocked = blockService.isBlocked(blockerId, blockedId);
+
+			// then
+			assertFalse(isBlocked);
+		}
+
+		@ParameterizedTest
+		@NullSource
+		@DisplayName("차단자 ID가 null이면 false를 반환한다")
+		void 차단자_ID가_null이면_false를_반환한다(Long blockerId) {
+			// given
+			Long blockedId = 2L;
+
+			// when
+			boolean isBlocked = blockService.isBlocked(blockerId, blockedId);
+
+			// then
+			assertFalse(isBlocked);
+		}
+	}
+
+	@Nested
+	@DisplayName("상호 차단 여부를 확인할 때")
+	class IsMutualBlocked {
+
+		@Test
+		@DisplayName("서로 차단한 경우 true를 반환한다")
+		void 서로_차단한_경우_true를_반환한다() {
+			// given
+			Long userId1 = 1L;
+			Long userId2 = 2L;
+			blockService.blockUser(userId1, userId2);
+			blockService.blockUser(userId2, userId1);
+
+			// when
+			boolean isMutualBlocked = blockService.isMutualBlocked(userId1, userId2);
+
+			// then
+			assertTrue(isMutualBlocked);
+		}
+
+		@Test
+		@DisplayName("한쪽만 차단한 경우 false를 반환한다")
+		void 한쪽만_차단한_경우_false를_반환한다() {
+			// given
+			Long userId1 = 1L;
+			Long userId2 = 2L;
+			blockService.blockUser(userId1, userId2);
+
+			// when
+			boolean isMutualBlocked = blockService.isMutualBlocked(userId1, userId2);
+
+			// then
+			assertFalse(isMutualBlocked);
+		}
+
+		@Test
+		@DisplayName("둘 다 차단하지 않은 경우 false를 반환한다")
+		void 둘_다_차단하지_않은_경우_false를_반환한다() {
+			// given
+			Long userId1 = 1L;
+			Long userId2 = 2L;
+
+			// when
+			boolean isMutualBlocked = blockService.isMutualBlocked(userId1, userId2);
+
+			// then
+			assertFalse(isMutualBlocked);
+		}
+	}
+
+	@Nested
+	@DisplayName("차단 통계를 조회할 때")
+	class BlockStatistics {
+
+		@Test
+		@DisplayName("특정 사용자를 차단한 사용자 수를 조회할 수 있다")
+		void 특정_사용자를_차단한_사용자_수를_조회할_수_있다() {
+			// given
+			Long targetUserId = 2L;
+			blockService.blockUser(1L, targetUserId);
+			blockService.blockUser(3L, targetUserId);
+			blockService.blockUser(4L, targetUserId);
+
+			// when
+			long blockedByCount = blockService.getBlockedByCount(targetUserId);
+
+			// then
+			assertEquals(3L, blockedByCount);
+		}
+
+		@Test
+		@DisplayName("특정 사용자가 차단한 사용자 수를 조회할 수 있다")
+		void 특정_사용자가_차단한_사용자_수를_조회할_수_있다() {
+			// given
+			Long blockerId = 1L;
+			blockService.blockUser(blockerId, 2L);
+			blockService.blockUser(blockerId, 3L);
+			blockService.blockUser(blockerId, 4L);
+
+			// when
+			long blockingCount = blockService.getBlockingCount(blockerId);
+
+			// then
+			assertEquals(3L, blockingCount);
+		}
+
+		@ParameterizedTest
+		@ValueSource(longs = {999L})
+		@NullSource
+		@DisplayName("존재하지 않는 사용자의 통계는 0을 반환한다")
+		void 존재하지_않는_사용자의_통계는_0을_반환한다(Long userId) {
+			// when
+			long blockedByCount = blockService.getBlockedByCount(userId);
+			long blockingCount = blockService.getBlockingCount(userId);
+
+			// then
+			assertEquals(0L, blockedByCount);
+			assertEquals(0L, blockingCount);
+		}
+	}
+}

From 2daaf7e5746b6c02aada3123ba6e9677799d0574 Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Tue, 1 Jul 2025 01:34:00 +0900
Subject: [PATCH 12/16] feat: add user block management API documentation and
 tests

Signed-off-by: hgkim <hgkim@openerd.com>
---
 .../api/support/block/user-block.adoc         | 202 +++++++++++
 src/docs/asciidoc/index.adoc                  |   2 +
 .../block/RestDocsBlockControllerTest.java    | 317 ++++++++++++++++++
 3 files changed, 521 insertions(+)
 create mode 100644 src/docs/asciidoc/api/support/block/user-block.adoc
 create mode 100644 src/test/java/app/docs/support/block/RestDocsBlockControllerTest.java

diff --git a/src/docs/asciidoc/api/support/block/user-block.adoc b/src/docs/asciidoc/api/support/block/user-block.adoc
new file mode 100644
index 000000000..382467f3f
--- /dev/null
+++ b/src/docs/asciidoc/api/support/block/user-block.adoc
@@ -0,0 +1,202 @@
+=== 사용자 차단 관리 ===
+
+사용자 간의 차단 관계를 관리하는 기능입니다. 
+차단된 사용자와의 상호작용을 제한하여 사용자 경험을 보호합니다.
+
+==== 차단 기능 개요 ====
+
+* 특정 사용자를 차단하여 해당 사용자의 콘텐츠나 상호작용을 차단할 수 있습니다
+* 차단된 사용자는 차단한 사용자의 콘텐츠에 접근하거나 상호작용할 수 없습니다
+* 차단 관계는 일방향성이며, 상호 차단도 가능합니다
+
+'''
+
+==== 사용자 차단 ====
+
+특정 사용자를 차단합니다.
+
+[source]
+----
+POST /api/v1/blocks
+----
+
+[discrete]
+===== 요청 파라미터 =====
+
+include::{snippets}/block-create/request-fields.adoc[]
+
+[discrete]
+===== 응답 파라미터 =====
+
+include::{snippets}/block-create/response-fields.adoc[]
+
+차단 완료 후 현재 사용자가 차단한 모든 사용자 목록을 반환합니다.
+
+'''
+
+==== 차단 해제 ====
+
+차단한 사용자를 해제합니다.
+
+[source]
+----
+DELETE /api/v1/blocks/{blockedUserId}
+----
+
+[discrete]
+===== 경로 파라미터 =====
+
+include::{snippets}/block-delete/path-parameters.adoc[]
+
+[discrete]
+===== 응답 파라미터 =====
+
+include::{snippets}/block-delete/response-fields.adoc[]
+
+차단 해제 후 현재 사용자가 차단한 모든 사용자 목록을 반환합니다.
+
+'''
+
+==== 차단 목록 조회 ====
+
+현재 사용자가 차단한 사용자들의 상세 정보를 조회합니다.
+
+[source]
+----
+GET /api/v1/blocks
+----
+
+[discrete]
+===== 응답 파라미터 =====
+
+include::{snippets}/block-list/response-fields.adoc[]
+
+각 차단된 사용자의 ID, 이름, 차단 시각 정보를 포함합니다.
+
+'''
+
+==== 차단 사용자 ID 목록 조회 ====
+
+빠른 차단 여부 확인을 위해 차단된 사용자 ID만 조회합니다.
+
+[source]
+----
+GET /api/v1/blocks/ids
+----
+
+[discrete]
+===== 응답 파라미터 =====
+
+include::{snippets}/block-ids/response-fields.adoc[]
+
+클라이언트에서 빠른 필터링이나 권한 체크에 사용할 수 있습니다.
+
+'''
+
+==== 차단 여부 확인 ====
+
+특정 사용자가 차단되었는지 확인합니다.
+
+[source]
+----
+GET /api/v1/blocks/check/{targetUserId}
+----
+
+[discrete]
+===== 경로 파라미터 =====
+
+include::{snippets}/block-check/path-parameters.adoc[]
+
+[discrete]
+===== 응답 파라미터 =====
+
+include::{snippets}/block-check/response-fields.adoc[]
+
+'''
+
+==== 상호 차단 여부 확인 ====
+
+두 사용자가 서로 차단했는지 확인합니다.
+
+[source]
+----
+GET /api/v1/blocks/mutual-check/{targetUserId}
+----
+
+[discrete]
+===== 경로 파라미터 =====
+
+include::{snippets}/block-mutual-check/path-parameters.adoc[]
+
+[discrete]
+===== 응답 파라미터 =====
+
+include::{snippets}/block-mutual-check/response-fields.adoc[]
+
+상호 차단 상태에서는 양쪽 모두 상대방의 콘텐츠에 접근할 수 없습니다.
+
+'''
+
+==== 차단 통계 조회 ====
+
+===== 나를 차단한 사용자 수 =====
+
+현재 사용자를 차단한 다른 사용자들의 수를 조회합니다.
+
+[source]
+----
+GET /api/v1/blocks/stats/blocked-by-count
+----
+
+[discrete]
+====== 응답 파라미터 ======
+
+include::{snippets}/block-blocked-by-count/response-fields.adoc[]
+
+===== 내가 차단한 사용자 수 =====
+
+현재 사용자가 차단한 사용자들의 수를 조회합니다.
+
+[source]
+----
+GET /api/v1/blocks/stats/blocking-count
+----
+
+[discrete]
+====== 응답 파라미터 ======
+
+include::{snippets}/block-blocking-count/response-fields.adoc[]
+
+'''
+
+==== 에러 코드 ====
+
+차단 API 요청 시 발생할 수 있는 예외 상황입니다.
+
+[cols="1,2,3",options="header"]
+|===
+| 코드 | 상황 | 설명
+
+| 400
+| 자기 자신을 차단하려는 경우
+| 자기 자신은 차단할 수 없습니다.
+
+| 400
+| 이미 차단된 사용자를 다시 차단하려는 경우
+| 이미 차단된 사용자입니다.
+
+| 404
+| 존재하지 않는 사용자를 차단하려는 경우
+| 해당 사용자를 찾을 수 없습니다.
+
+| 404
+| 차단하지 않은 사용자를 해제하려는 경우
+| 차단 관계가 존재하지 않습니다.
+
+| 401
+| 인증되지 않은 사용자
+| 로그인이 필요합니다.
+|===
+
+** 추가되지 않은 에러 코드는 요청 바랍니다.
+** Request validation에 대한 내용은 공통 예외를 통해 처리됩니다.
\ No newline at end of file
diff --git a/src/docs/asciidoc/index.adoc b/src/docs/asciidoc/index.adoc
index b206b06c9..2a6220c7c 100644
--- a/src/docs/asciidoc/index.adoc
+++ b/src/docs/asciidoc/index.adoc
@@ -176,6 +176,8 @@ include::api/review/reply/sub-review-reply-list.adoc[]
 
 == 지원 (support) 관련 API
 
+include::api/support/block/user-block.adoc[]
+
 include::api/support/report/user-report.adoc[]
 
 include::api/support/help/help-register.adoc[]
diff --git a/src/test/java/app/docs/support/block/RestDocsBlockControllerTest.java b/src/test/java/app/docs/support/block/RestDocsBlockControllerTest.java
new file mode 100644
index 000000000..367d24f1a
--- /dev/null
+++ b/src/test/java/app/docs/support/block/RestDocsBlockControllerTest.java
@@ -0,0 +1,317 @@
+package app.docs.support.block;
+
+import app.bottlenote.global.data.response.CollectionResponse;
+import app.bottlenote.global.security.SecurityContextUtil;
+import app.bottlenote.support.block.controller.BlockController;
+import app.bottlenote.support.block.dto.request.BlockCreateRequest;
+import app.bottlenote.support.block.dto.response.UserBlockItem;
+import app.bottlenote.support.block.service.BlockService;
+import app.docs.AbstractRestDocs;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+import org.springframework.http.MediaType;
+import org.springframework.restdocs.payload.JsonFieldType;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.when;
+import static org.springframework.restdocs.mockmvc.MockMvcRestDocumentation.document;
+import static org.springframework.restdocs.mockmvc.RestDocumentationRequestBuilders.delete;
+import static org.springframework.restdocs.mockmvc.RestDocumentationRequestBuilders.get;
+import static org.springframework.restdocs.mockmvc.RestDocumentationRequestBuilders.post;
+import static org.springframework.restdocs.payload.PayloadDocumentation.fieldWithPath;
+import static org.springframework.restdocs.payload.PayloadDocumentation.requestFields;
+import static org.springframework.restdocs.payload.PayloadDocumentation.responseFields;
+import static org.springframework.restdocs.request.RequestDocumentation.parameterWithName;
+import static org.springframework.restdocs.request.RequestDocumentation.pathParameters;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@DisplayName("BlockController RestDocs 테스트")
+class RestDocsBlockControllerTest extends AbstractRestDocs {
+
+    private final BlockService blockService = mock(BlockService.class);
+    private MockedStatic<SecurityContextUtil> mockedSecurityUtil;
+
+    @Override
+    protected Object initController() {
+        return new BlockController(blockService);
+    }
+
+    @BeforeEach
+    void setup() {
+        mockedSecurityUtil = mockStatic(SecurityContextUtil.class);
+        mockedSecurityUtil.when(SecurityContextUtil::getUserIdByContext).thenReturn(Optional.of(1L));
+    }
+
+    @AfterEach
+    void tearDown() {
+        mockedSecurityUtil.close();
+    }
+
+    @DisplayName("[restdocs] 사용자를 차단할 수 있다")
+    @Test
+    void createBlockTest() throws Exception {
+        // given
+        Long currentUserId = 1L;
+        BlockCreateRequest request = new BlockCreateRequest(2L);
+        CollectionResponse<UserBlockItem> response = CollectionResponse.of(1L, List.of(
+            new UserBlockItem(2L, "차단된사용자", LocalDateTime.now())
+        ));
+
+        // when
+        doNothing().when(blockService).blockUser(currentUserId, 2L);
+        when(blockService.getBlockedUserItems(currentUserId)).thenReturn(response);
+
+        // then
+        mockMvc.perform(post("/api/v1/blocks")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(objectMapper.writeValueAsString(request)))
+            .andExpect(status().isOk())
+            .andDo(document("block-create",
+                requestFields(
+                    fieldWithPath("blockedUserId").type(JsonFieldType.NUMBER).description("차단할 사용자 ID")
+                ),
+                responseFields(
+                    fieldWithPath("success").type(JsonFieldType.BOOLEAN).description("성공 여부").ignored(),
+                    fieldWithPath("code").type(JsonFieldType.STRING).description("응답 코드").ignored(),
+                    fieldWithPath("errors").type(JsonFieldType.ARRAY).description("에러 목록").ignored(),
+                    fieldWithPath("meta").type(JsonFieldType.OBJECT).description("메타 정보").ignored(),
+                    fieldWithPath("meta.serverVersion").type(JsonFieldType.STRING).description("서버 버전").ignored(),
+                    fieldWithPath("meta.serverEncoding").type(JsonFieldType.STRING).description("서버 인코딩").ignored(),
+                    fieldWithPath("meta.serverResponseTime").type(JsonFieldType.ARRAY).description("서버 응답 시간").ignored(),
+                    fieldWithPath("meta.serverPathVersion").type(JsonFieldType.STRING).description("서버 경로 버전").ignored(),
+                    fieldWithPath("data.totalCount").type(JsonFieldType.NUMBER).description("차단된 사용자 총 수"),
+                    fieldWithPath("data.items").type(JsonFieldType.ARRAY).description("차단된 사용자 목록"),
+                    fieldWithPath("data.items[].userId").type(JsonFieldType.NUMBER).description("차단된 사용자 ID"),
+                    fieldWithPath("data.items[].userName").type(JsonFieldType.STRING).description("차단된 사용자 이름"),
+                    fieldWithPath("data.items[].blockedAt").type(JsonFieldType.ARRAY).description("차단된 시각")
+                )
+            ));
+    }
+
+    @DisplayName("[restdocs] 사용자 차단을 해제할 수 있다")
+    @Test
+    void deleteBlockTest() throws Exception {
+        // given
+        Long currentUserId = 1L;
+        Long blockedUserId = 2L;
+        CollectionResponse<UserBlockItem> response = CollectionResponse.of(0L, List.of());
+
+        // when
+        doNothing().when(blockService).unblockUser(currentUserId, blockedUserId);
+        when(blockService.getBlockedUserItems(currentUserId)).thenReturn(response);
+
+        // then
+        mockMvc.perform(delete("/api/v1/blocks/{blockedUserId}", blockedUserId))
+            .andExpect(status().isOk())
+            .andDo(document("block-delete",
+                pathParameters(
+                    parameterWithName("blockedUserId").description("차단 해제할 사용자 ID")
+                ),
+                responseFields(
+                    fieldWithPath("success").type(JsonFieldType.BOOLEAN).description("성공 여부").ignored(),
+                    fieldWithPath("code").type(JsonFieldType.STRING).description("응답 코드").ignored(),
+                    fieldWithPath("errors").type(JsonFieldType.ARRAY).description("에러 목록").ignored(),
+                    fieldWithPath("meta").type(JsonFieldType.OBJECT).description("메타 정보").ignored(),
+                    fieldWithPath("meta.serverVersion").type(JsonFieldType.STRING).description("서버 버전").ignored(),
+                    fieldWithPath("meta.serverEncoding").type(JsonFieldType.STRING).description("서버 인코딩").ignored(),
+                    fieldWithPath("meta.serverResponseTime").type(JsonFieldType.ARRAY).description("서버 응답 시간").ignored(),
+                    fieldWithPath("meta.serverPathVersion").type(JsonFieldType.STRING).description("서버 경로 버전").ignored(),
+                    fieldWithPath("data.totalCount").type(JsonFieldType.NUMBER).description("차단된 사용자 총 수"),
+                    fieldWithPath("data.items").type(JsonFieldType.ARRAY).description("차단된 사용자 목록")
+                )
+            ));
+    }
+
+    @DisplayName("[restdocs] 차단된 사용자 목록을 조회할 수 있다")
+    @Test
+    void getBlockedUsersTest() throws Exception {
+        // given
+        Long currentUserId = 1L;
+        CollectionResponse<UserBlockItem> response = CollectionResponse.of(2L, List.of(
+            new UserBlockItem(2L, "차단된사용자1", LocalDateTime.now()),
+            new UserBlockItem(3L, "차단된사용자2", LocalDateTime.now())
+        ));
+
+        // when
+        when(blockService.getBlockedUserItems(currentUserId)).thenReturn(response);
+
+        // then
+        mockMvc.perform(get("/api/v1/blocks"))
+            .andExpect(status().isOk())
+            .andDo(document("block-list",
+                responseFields(
+                    fieldWithPath("success").type(JsonFieldType.BOOLEAN).description("성공 여부").ignored(),
+                    fieldWithPath("code").type(JsonFieldType.STRING).description("응답 코드").ignored(),
+                    fieldWithPath("errors").type(JsonFieldType.ARRAY).description("에러 목록").ignored(),
+                    fieldWithPath("meta").type(JsonFieldType.OBJECT).description("메타 정보").ignored(),
+                    fieldWithPath("meta.serverVersion").type(JsonFieldType.STRING).description("서버 버전").ignored(),
+                    fieldWithPath("meta.serverEncoding").type(JsonFieldType.STRING).description("서버 인코딩").ignored(),
+                    fieldWithPath("meta.serverResponseTime").type(JsonFieldType.ARRAY).description("서버 응답 시간").ignored(),
+                    fieldWithPath("meta.serverPathVersion").type(JsonFieldType.STRING).description("서버 경로 버전").ignored(),
+                    fieldWithPath("data.totalCount").type(JsonFieldType.NUMBER).description("차단된 사용자 총 수"),
+                    fieldWithPath("data.items").type(JsonFieldType.ARRAY).description("차단된 사용자 목록"),
+                    fieldWithPath("data.items[].userId").type(JsonFieldType.NUMBER).description("차단된 사용자 ID"),
+                    fieldWithPath("data.items[].userName").type(JsonFieldType.STRING).description("차단된 사용자 이름"),
+                    fieldWithPath("data.items[].blockedAt").type(JsonFieldType.ARRAY).description("차단된 시각")
+                )
+            ));
+    }
+
+    @DisplayName("[restdocs] 차단된 사용자 ID 목록을 조회할 수 있다")
+    @Test
+    void getBlockedUserIdsTest() throws Exception {
+        // given
+        Long currentUserId = 1L;
+        Set<Long> response = Set.of(2L, 3L);
+
+        // when
+        when(blockService.getBlockedUserIds(currentUserId)).thenReturn(response);
+
+        // then
+        mockMvc.perform(get("/api/v1/blocks/ids"))
+            .andExpect(status().isOk())
+            .andDo(document("block-ids",
+                responseFields(
+                    fieldWithPath("success").type(JsonFieldType.BOOLEAN).description("성공 여부").ignored(),
+                    fieldWithPath("code").type(JsonFieldType.STRING).description("응답 코드").ignored(),
+                    fieldWithPath("errors").type(JsonFieldType.ARRAY).description("에러 목록").ignored(),
+                    fieldWithPath("meta").type(JsonFieldType.OBJECT).description("메타 정보").ignored(),
+                    fieldWithPath("meta.serverVersion").type(JsonFieldType.STRING).description("서버 버전").ignored(),
+                    fieldWithPath("meta.serverEncoding").type(JsonFieldType.STRING).description("서버 인코딩").ignored(),
+                    fieldWithPath("meta.serverResponseTime").type(JsonFieldType.ARRAY).description("서버 응답 시간").ignored(),
+                    fieldWithPath("meta.serverPathVersion").type(JsonFieldType.STRING).description("서버 경로 버전").ignored(),
+                    fieldWithPath("data").type(JsonFieldType.ARRAY).description("차단된 사용자 ID 목록")
+                )
+            ));
+    }
+
+    @DisplayName("[restdocs] 특정 사용자 차단 여부를 확인할 수 있다")
+    @Test
+    void checkBlockedTest() throws Exception {
+        // given
+        Long currentUserId = 1L;
+        Long targetUserId = 2L;
+        Boolean response = true;
+
+        // when
+        when(blockService.isBlocked(currentUserId, targetUserId)).thenReturn(response);
+
+        // then
+        mockMvc.perform(get("/api/v1/blocks/check/{targetUserId}", targetUserId))
+            .andExpect(status().isOk())
+            .andDo(document("block-check",
+                pathParameters(
+                    parameterWithName("targetUserId").description("차단 여부를 확인할 사용자 ID")
+                ),
+                responseFields(
+                    fieldWithPath("success").type(JsonFieldType.BOOLEAN).description("성공 여부").ignored(),
+                    fieldWithPath("code").type(JsonFieldType.STRING).description("응답 코드").ignored(),
+                    fieldWithPath("errors").type(JsonFieldType.ARRAY).description("에러 목록").ignored(),
+                    fieldWithPath("meta").type(JsonFieldType.OBJECT).description("메타 정보").ignored(),
+                    fieldWithPath("meta.serverVersion").type(JsonFieldType.STRING).description("서버 버전").ignored(),
+                    fieldWithPath("meta.serverEncoding").type(JsonFieldType.STRING).description("서버 인코딩").ignored(),
+                    fieldWithPath("meta.serverResponseTime").type(JsonFieldType.ARRAY).description("서버 응답 시간").ignored(),
+                    fieldWithPath("meta.serverPathVersion").type(JsonFieldType.STRING).description("서버 경로 버전").ignored(),
+                    fieldWithPath("data").type(JsonFieldType.BOOLEAN).description("차단 여부")
+                )
+            ));
+    }
+
+    @DisplayName("[restdocs] 상호 차단 여부를 확인할 수 있다")
+    @Test
+    void checkMutualBlockedTest() throws Exception {
+        // given
+        Long currentUserId = 1L;
+        Long targetUserId = 2L;
+        Boolean response = false;
+
+        // when
+        when(blockService.isMutualBlocked(currentUserId, targetUserId)).thenReturn(response);
+
+        // then
+        mockMvc.perform(get("/api/v1/blocks/mutual-check/{targetUserId}", targetUserId))
+            .andExpect(status().isOk())
+            .andDo(document("block-mutual-check",
+                pathParameters(
+                    parameterWithName("targetUserId").description("상호 차단 여부를 확인할 사용자 ID")
+                ),
+                responseFields(
+                    fieldWithPath("success").type(JsonFieldType.BOOLEAN).description("성공 여부").ignored(),
+                    fieldWithPath("code").type(JsonFieldType.STRING).description("응답 코드").ignored(),
+                    fieldWithPath("errors").type(JsonFieldType.ARRAY).description("에러 목록").ignored(),
+                    fieldWithPath("meta").type(JsonFieldType.OBJECT).description("메타 정보").ignored(),
+                    fieldWithPath("meta.serverVersion").type(JsonFieldType.STRING).description("서버 버전").ignored(),
+                    fieldWithPath("meta.serverEncoding").type(JsonFieldType.STRING).description("서버 인코딩").ignored(),
+                    fieldWithPath("meta.serverResponseTime").type(JsonFieldType.ARRAY).description("서버 응답 시간").ignored(),
+                    fieldWithPath("meta.serverPathVersion").type(JsonFieldType.STRING).description("서버 경로 버전").ignored(),
+                    fieldWithPath("data").type(JsonFieldType.BOOLEAN).description("상호 차단 여부")
+                )
+            ));
+    }
+
+    @DisplayName("[restdocs] 나를 차단한 사용자 수를 조회할 수 있다")
+    @Test
+    void getBlockedByCountTest() throws Exception {
+        // given
+        Long currentUserId = 1L;
+        Long response = 5L;
+
+        // when
+        when(blockService.getBlockedByCount(currentUserId)).thenReturn(response);
+
+        // then
+        mockMvc.perform(get("/api/v1/blocks/stats/blocked-by-count"))
+            .andExpect(status().isOk())
+            .andDo(document("block-blocked-by-count",
+                responseFields(
+                    fieldWithPath("success").type(JsonFieldType.BOOLEAN).description("성공 여부").ignored(),
+                    fieldWithPath("code").type(JsonFieldType.STRING).description("응답 코드").ignored(),
+                    fieldWithPath("errors").type(JsonFieldType.ARRAY).description("에러 목록").ignored(),
+                    fieldWithPath("meta").type(JsonFieldType.OBJECT).description("메타 정보").ignored(),
+                    fieldWithPath("meta.serverVersion").type(JsonFieldType.STRING).description("서버 버전").ignored(),
+                    fieldWithPath("meta.serverEncoding").type(JsonFieldType.STRING).description("서버 인코딩").ignored(),
+                    fieldWithPath("meta.serverResponseTime").type(JsonFieldType.ARRAY).description("서버 응답 시간").ignored(),
+                    fieldWithPath("meta.serverPathVersion").type(JsonFieldType.STRING).description("서버 경로 버전").ignored(),
+                    fieldWithPath("data").type(JsonFieldType.NUMBER).description("나를 차단한 사용자 수")
+                )
+            ));
+    }
+
+    @DisplayName("[restdocs] 내가 차단한 사용자 수를 조회할 수 있다")
+    @Test
+    void getBlockingCountTest() throws Exception {
+        // given
+        Long currentUserId = 1L;
+        Long response = 3L;
+
+        // when
+        when(blockService.getBlockingCount(currentUserId)).thenReturn(response);
+
+        // then
+        mockMvc.perform(get("/api/v1/blocks/stats/blocking-count"))
+            .andExpect(status().isOk())
+            .andDo(document("block-blocking-count",
+                responseFields(
+                    fieldWithPath("success").type(JsonFieldType.BOOLEAN).description("성공 여부").ignored(),
+                    fieldWithPath("code").type(JsonFieldType.STRING).description("응답 코드").ignored(),
+                    fieldWithPath("errors").type(JsonFieldType.ARRAY).description("에러 목록").ignored(),
+                    fieldWithPath("meta").type(JsonFieldType.OBJECT).description("메타 정보").ignored(),
+                    fieldWithPath("meta.serverVersion").type(JsonFieldType.STRING).description("서버 버전").ignored(),
+                    fieldWithPath("meta.serverEncoding").type(JsonFieldType.STRING).description("서버 인코딩").ignored(),
+                    fieldWithPath("meta.serverResponseTime").type(JsonFieldType.ARRAY).description("서버 응답 시간").ignored(),
+                    fieldWithPath("meta.serverPathVersion").type(JsonFieldType.STRING).description("서버 경로 버전").ignored(),
+                    fieldWithPath("data").type(JsonFieldType.NUMBER).description("내가 차단한 사용자 수")
+                )
+            ));
+    }
+}

From 58c8f705ee546747cfc8c2600b0962efd7c8eaa9 Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Tue, 1 Jul 2025 01:55:18 +0900
Subject: [PATCH 13/16] feat: update JpaUserBlockRepository with new query for
 blocked user items and rename test tasks

Signed-off-by: hgkim <hgkim@openerd.com>
---
 build.gradle                                  |  6 +--
 .../repository/JpaUserBlockRepository.java    | 42 +++++++++++--------
 2 files changed, 28 insertions(+), 20 deletions(-)

diff --git a/build.gradle b/build.gradle
index 99fac61f6..01d09f647 100644
--- a/build.gradle
+++ b/build.gradle
@@ -206,17 +206,17 @@ tasks.named('test') {
 		excludeTags 'data-jpa-test', 'integration'
 	}
 }
-tasks.register('integrationTest', Test) {
+tasks.register('integration_test', Test) {
 	useJUnitPlatform {
 		includeTags 'integration'
 	}
 }
-tasks.register('unitTest', Test) {
+tasks.register('unit_test', Test) {
 	useJUnitPlatform {
 		includeTags 'unit'
 	}
 }
-tasks.register('check_rule', Test) {
+tasks.register('check_rule_test', Test) {
 	useJUnitPlatform {
 		includeTags 'rule'
 	}
diff --git a/src/main/java/app/bottlenote/support/block/repository/JpaUserBlockRepository.java b/src/main/java/app/bottlenote/support/block/repository/JpaUserBlockRepository.java
index fe7a4751c..5df8fafdb 100644
--- a/src/main/java/app/bottlenote/support/block/repository/JpaUserBlockRepository.java
+++ b/src/main/java/app/bottlenote/support/block/repository/JpaUserBlockRepository.java
@@ -1,36 +1,44 @@
 package app.bottlenote.support.block.repository;
 
 import app.bottlenote.support.block.domain.UserBlock;
+import app.bottlenote.support.block.dto.response.UserBlockItem;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
+import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 
 @Repository
 public interface JpaUserBlockRepository extends UserBlockRepository, JpaRepository<UserBlock, Long> {
 
-    @Override
-    @Query("SELECT ub.blockedId FROM userBlock ub WHERE ub.blockerId = :blockerId")
-    Set<Long> findBlockedUserIdsByBlockerId(@Param("blockerId") Long blockerId);
+	@Override
+	@Query("SELECT ub.blockedId FROM userBlock ub WHERE ub.blockerId = :blockerId")
+	Set<Long> findBlockedUserIdsByBlockerId(@Param("blockerId") Long blockerId);
 
-    @Override
-    boolean existsByBlockerIdAndBlockedId(Long blockerId, Long blockedId);
+	@Override
+	boolean existsByBlockerIdAndBlockedId(Long blockerId, Long blockedId);
 
-    @Override
-    Optional<UserBlock> findByBlockerIdAndBlockedId(Long blockerId, Long blockedId);
+	@Override
+	Optional<UserBlock> findByBlockerIdAndBlockedId(Long blockerId, Long blockedId);
 
-    @Override
-    long countByBlockedId(Long blockedId);
+	@Override
+	long countByBlockedId(Long blockedId);
 
-    @Override
-    long countByBlockerId(Long blockerId);
+	@Override
+	long countByBlockerId(Long blockerId);
 
-    @Override
-    @Query("SELECT COUNT(ub) = 2 FROM userBlock ub " +
-           "WHERE (ub.blockerId = :userId1 AND ub.blockedId = :userId2) " +
-           "OR (ub.blockerId = :userId2 AND ub.blockedId = :userId1)")
-    boolean existsMutualBlock(@Param("userId1") Long userId1, @Param("userId2") Long userId2);
-}
\ No newline at end of file
+	@Override
+	@Query("SELECT COUNT(ub) = 2 FROM userBlock ub " +
+			"WHERE (ub.blockerId = :userId1 AND ub.blockedId = :userId2) " +
+			"OR (ub.blockerId = :userId2 AND ub.blockedId = :userId1)")
+	boolean existsMutualBlock(@Param("userId1") Long userId1, @Param("userId2") Long userId2);
+
+	@Override
+	@Query("SELECT new app.bottlenote.support.block.dto.response.UserBlockItem(u.id, u.nickName, ub.createAt) " +
+			"FROM userBlock ub JOIN users u ON ub.blockedId = u.id " +
+			"WHERE ub.blockerId = :blockerId")
+	List<UserBlockItem> findBlockedUserItemsByBlockerId(@Param("blockerId") Long blockerId);
+}

From 9dfa2e0a645e0fd88bfe16012a9c9f47fd113fab Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Tue, 1 Jul 2025 02:00:17 +0900
Subject: [PATCH 14/16] feat: refactor JPQL queries in JpaUserBlockRepository
 for improved readability

Signed-off-by: hgkim <hgkim@openerd.com>
---
 .../repository/JpaUserBlockRepository.java    | 20 ++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/src/main/java/app/bottlenote/support/block/repository/JpaUserBlockRepository.java b/src/main/java/app/bottlenote/support/block/repository/JpaUserBlockRepository.java
index 5df8fafdb..0d6db8d36 100644
--- a/src/main/java/app/bottlenote/support/block/repository/JpaUserBlockRepository.java
+++ b/src/main/java/app/bottlenote/support/block/repository/JpaUserBlockRepository.java
@@ -15,7 +15,9 @@
 public interface JpaUserBlockRepository extends UserBlockRepository, JpaRepository<UserBlock, Long> {
 
 	@Override
-	@Query("SELECT ub.blockedId FROM userBlock ub WHERE ub.blockerId = :blockerId")
+	@Query("""
+		SELECT ub.blockedId FROM userBlock ub WHERE ub.blockerId = :blockerId
+		""")
 	Set<Long> findBlockedUserIdsByBlockerId(@Param("blockerId") Long blockerId);
 
 	@Override
@@ -31,14 +33,18 @@ public interface JpaUserBlockRepository extends UserBlockRepository, JpaReposito
 	long countByBlockerId(Long blockerId);
 
 	@Override
-	@Query("SELECT COUNT(ub) = 2 FROM userBlock ub " +
-			"WHERE (ub.blockerId = :userId1 AND ub.blockedId = :userId2) " +
-			"OR (ub.blockerId = :userId2 AND ub.blockedId = :userId1)")
+	@Query("""
+		SELECT COUNT(ub) = 2 FROM userBlock ub 
+		WHERE (ub.blockerId = :userId1 AND ub.blockedId = :userId2) 
+		OR (ub.blockerId = :userId2 AND ub.blockedId = :userId1)
+		""")
 	boolean existsMutualBlock(@Param("userId1") Long userId1, @Param("userId2") Long userId2);
 
 	@Override
-	@Query("SELECT new app.bottlenote.support.block.dto.response.UserBlockItem(u.id, u.nickName, ub.createAt) " +
-			"FROM userBlock ub JOIN users u ON ub.blockedId = u.id " +
-			"WHERE ub.blockerId = :blockerId")
+	@Query("""
+		SELECT new app.bottlenote.support.block.dto.response.UserBlockItem(u.id, u.nickName, ub.createAt) 
+		FROM userBlock ub JOIN users u ON ub.blockedId = u.id 
+		WHERE ub.blockerId = :blockerId
+		""")
 	List<UserBlockItem> findBlockedUserItemsByBlockerId(@Param("blockerId") Long blockerId);
 }

From c13aadbc8c393fe2ae119542f357042cc64d12c6 Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Tue, 1 Jul 2025 02:20:50 +0900
Subject: [PATCH 15/16] feat: standardize CI pipeline step names and improve
 test execution order

Signed-off-by: hgkim <hgkim@openerd.com>
---
 .../workflows/dev_continuous_integration.yml  | 33 ++++++++++---------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/.github/workflows/dev_continuous_integration.yml b/.github/workflows/dev_continuous_integration.yml
index a0e058298..e7511b7ed 100644
--- a/.github/workflows/dev_continuous_integration.yml
+++ b/.github/workflows/dev_continuous_integration.yml
@@ -1,4 +1,4 @@
-name: Dev CI Pipeline
+name: dev ci pipeline
 
 on:
   workflow_dispatch:
@@ -32,19 +32,19 @@ jobs:
         run: |
           echo "Branch: ${{ github.event.pull_request.base.ref || github.ref_name }}"
 
-      - name: Checkout Code (코드 체크아웃)
+      - name: checkout code
         uses: actions/checkout@v4
         with:
           submodules: true
           token: ${{ secrets.GIT_ACCESS_TOKEN }}
 
-      - name: Setup JDK (자바 설정)
+      - name: setup jdk
         uses: actions/setup-java@v4
         with:
           java-version: '21'
           distribution: 'temurin'
 
-      - name: Setup Gradle Cache (그래들 캐시 설정)
+      - name: setup gradle cache
         uses: actions/cache@v3
         with:
           path: ~/.gradle/caches
@@ -52,28 +52,29 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-gradle-
 
-      - name: Install Dependencies (종속성 설치)
+      - name: install dependencies
         run: ./gradlew dependencies
 
-      - name: Run Integration Tests (통합 테스트 실행)
-        run: ./gradlew clean integrationTest
+      - name: run unit tests
+        run: ./gradlew unit_test
 
-      - name: Run Unit Tests (단위 테스트 실행)
-        run: ./gradlew unitTest
+      - name: run rules tests
+        run: ./gradlew check_rule_test
 
-      - name: Build Project (프로젝트 빌드)
-        run: ./gradlew build
+      - name: run integration tests
+        run: ./gradlew integration_test
 
-      - name: Store Test Results (테스트 결과 저장)
+      - name: build project
+        run: ./gradlew build -x test --build-cache --parallel
+
+      - name: store test results
         if: always()
         uses: actions/upload-artifact@v4
         with:
           name: test-results
-          path: |
-            build/reports/tests/
-            build/reports/integration-tests/
+          path: build/reports/
 
-      - name: Publish Test Report (테스트 보고서 발행)
+      - name: publish test report
         uses: mikepenz/action-junit-report@v3
         if: always()
         with:

From c1f813255fbb71eacb95415055f70fee9ba456c4 Mon Sep 17 00:00:00 2001
From: hgkim <hgkim@openerd.com>
Date: Tue, 1 Jul 2025 21:13:00 +0900
Subject: [PATCH 16/16] feat: exclude asciidoctor from build step in CI
 configuration

Signed-off-by: hgkim <hgkim@openerd.com>
---
 .github/workflows/dev_continuous_integration.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/dev_continuous_integration.yml b/.github/workflows/dev_continuous_integration.yml
index e7511b7ed..113f35a1d 100644
--- a/.github/workflows/dev_continuous_integration.yml
+++ b/.github/workflows/dev_continuous_integration.yml
@@ -65,7 +65,7 @@ jobs:
         run: ./gradlew integration_test
 
       - name: build project
-        run: ./gradlew build -x test --build-cache --parallel
+        run: ./gradlew build -x test -x asciidoctor --build-cache --parallel
 
       - name: store test results
         if: always()