Redis 캐시 전략 완벽 가이드 – 캐시와 세션 관리를 제대로 설계하는 법

[Redis가 단순 캐시와 다른 이유]

일반 캐시 솔루션:
  ┌─────────────────────┐
  │  Key → String(Value) │  (문자열만 저장 가능)
  └─────────────────────┘

Redis:
  ┌─────────────────────────────────────────┐
  │  Key → String   (단순 값, 카운터)        │
  │  Key → Hash     (객체 필드 단위 조작)    │
  │  Key → List     (메시지 큐, 로그)        │
  │  Key → Set      (태그, 중복 없는 집합)   │
  │  Key → Sorted Set (순위표, 스케줄링)     │
  │  Key → Bitmap   (대규모 플래그 관리)     │
  │  Key → HyperLogLog (근사 카운팅)        │
  │  Key → Stream   (이벤트 로그)            │
  └─────────────────────────────────────────┘

[접근 속도 비교]

RAM 접근:      100ns  (나노초)
SSD 랜덤 I/O: 100μs  (마이크로초, RAM 대비 1,000배 느림)
HDD 랜덤 I/O: 10ms   (밀리초, RAM 대비 100,000배 느림)
네트워크(LAN): 0.5ms  (밀리초)

→ Redis: 초당 100만 건 이상 읽기·쓰기 처리 가능
→ MySQL: 초당 수천~수만 건 (인덱스·디스크 I/O 포함)

// Spring Boot Redis 기본 설정
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(
            RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        // Key: String 직렬화
        template.setKeySerializer(new StringRedisSerializer());
        // Value: JSON 직렬화 (Jackson)
        template.setValueSerializer(
            new GenericJackson2JsonRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(
            new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

// String 활용 예시
@Service
@RequiredArgsConstructor
public class StringRedisExamples {

    private final StringRedisTemplate stringRedisTemplate;

    // ① 단순 캐싱 (TTL 포함)
    public void cacheProductName(Long productId, String name) {
        stringRedisTemplate.opsForValue().set(
            "product:name:" + productId,
            name,
            Duration.ofHours(1)     // 1시간 후 자동 만료
        );
    }

    // ② 원자적 카운터 (동시성 안전)
    public Long incrementViewCount(Long postId) {
        return stringRedisTemplate.opsForValue()
            .increment("post:views:" + postId);
        // INCR 명령은 원자적 → 동시에 1,000명이 호출해도 정확히 1,000 증가
    }

    // ③ 분산 환경 유니크 ID 생성
    public Long generateOrderId() {
        return stringRedisTemplate.opsForValue()
            .increment("global:order:sequence");
    }

    // ④ NX(Not Exists) 옵션 – 없을 때만 저장 (분산 락 기초)
    public Boolean setIfAbsent(String key, String value, Duration ttl) {
        return stringRedisTemplate.opsForValue()
            .setIfAbsent(key, value, ttl);
        // 이미 존재하면 false 반환 → 동시 요청 중 하나만 성공
    }
}

@Service
@RequiredArgsConstructor
public class HashRedisExamples {

    private final RedisTemplate<String, Object> redisTemplate;

    // 사용자 프로필 Hash 저장 (JSON 통째로 저장 vs Hash 비교)
    public void saveUserProfile(Long userId, UserProfile profile) {
        String key = "user:profile:" + userId;

        // 방법 1: String으로 JSON 통째 저장 (단점: 하나의 필드 변경 시 전체 덮어써야 함)
        // redisTemplate.opsForValue().set(key, profile);

        // 방법 2: Hash로 필드별 저장 (장점: 특정 필드만 수정 가능)
        Map<String, Object> fields = new HashMap<>();
        fields.put("name", profile.getName());
        fields.put("email", profile.getEmail());
        fields.put("grade", profile.getGrade().name());
        fields.put("point", profile.getPoint());

        redisTemplate.opsForHash().putAll(key, fields);
        redisTemplate.expire(key, Duration.ofDays(7));
    }

    // 특정 필드만 업데이트 (포인트 적립 시 전체 재저장 불필요)
    public void updateUserPoint(Long userId, int newPoint) {
        redisTemplate.opsForHash().put(
            "user:profile:" + userId, "point", newPoint);
    }

    // 여러 필드 한 번에 조회 (네트워크 왕복 최소화)
    public Map<Object, Object> getUserProfile(Long userId) {
        return redisTemplate.opsForHash()
            .entries("user:profile:" + userId);
    }
}

@Service
@RequiredArgsConstructor
public class SortedSetRedisExamples {

    private final RedisTemplate<String, Object> redisTemplate;
    private static final String WEEKLY_RANK_KEY = "rank:weekly:score";

    // 점수 업데이트 (O(log N) 시간 복잡도)
    public void updateScore(String userId, double score) {
        redisTemplate.opsForZSet().add(WEEKLY_RANK_KEY, userId, score);
    }

    // 점수 증가 (원자적)
    public Double incrementScore(String userId, double delta) {
        return redisTemplate.opsForZSet()
            .incrementScore(WEEKLY_RANK_KEY, userId, delta);
    }

    // 상위 N명 조회 (점수 내림차순)
    public Set<ZSetOperations.TypedTuple<Object>> getTopRankers(int topN) {
        return redisTemplate.opsForZSet()
            .reverseRangeWithScores(WEEKLY_RANK_KEY, 0, topN - 1);
    }

    // 특정 유저의 순위 조회 (0-based index)
    public Long getUserRank(String userId) {
        Long rank = redisTemplate.opsForZSet()
            .reverseRank(WEEKLY_RANK_KEY, userId);
        return rank != null ? rank + 1 : null;  // 1-based 순위로 변환
    }

    // 범위 조회 (점수 500~1000 사이 유저)
    public Set<Object> getUsersByScoreRange(double minScore, double maxScore) {
        return redisTemplate.opsForZSet()
            .rangeByScore(WEEKLY_RANK_KEY, minScore, maxScore);
    }
}

@Service
@RequiredArgsConstructor
public class ListRedisExamples {

    private final RedisTemplate<String, Object> redisTemplate;

    // 최근 본 상품 (최대 20개, 오래된 것 자동 제거)
    public void addRecentProduct(Long userId, Long productId) {
        String key = "user:recent:products:" + userId;

        // 왼쪽에 추가 (가장 최근 항목이 앞으로)
        redisTemplate.opsForList().leftPush(key, productId);

        // 20개 초과 시 오래된 항목 제거
        redisTemplate.opsForList().trim(key, 0, 19);
        redisTemplate.expire(key, Duration.ofDays(30));
    }

    // 최근 본 상품 조회
    public List<Object> getRecentProducts(Long userId) {
        return redisTemplate.opsForList()
            .range("user:recent:products:" + userId, 0, -1);
    }

    // 경량 메시지 큐 (LPUSH + BRPOP 패턴)
    public void enqueue(String queueName, Object message) {
        redisTemplate.opsForList().leftPush("queue:" + queueName, message);
    }

    public Object dequeue(String queueName, long timeoutSeconds) {
        // BRPOP: 큐가 비어있으면 블로킹 대기 (polling 없이 효율적)
        return redisTemplate.opsForList()
            .rightPop("queue:" + queueName, Duration.ofSeconds(timeoutSeconds));
    }
}

[Cache-Aside 흐름]

클라이언트 요청
  ↓
애플리케이션 → Redis 조회
  ├── Cache HIT: Redis에서 즉시 반환 ✅ (DB 접근 없음)
  └── Cache MISS:
        ↓
        DB 조회 → 결과를 Redis에 저장(TTL 설정) → 클라이언트 반환

@Service
@RequiredArgsConstructor
public class ProductCacheService {

    private final RedisTemplate<String, Object> redisTemplate;
    private final ProductRepository productRepository;

    private static final String PRODUCT_CACHE_KEY = "product:detail:";
    private static final Duration PRODUCT_TTL = Duration.ofHours(1);

    // Cache-Aside 수동 구현
    public ProductDto getProduct(Long productId) {
        String cacheKey = PRODUCT_CACHE_KEY + productId;

        // 1단계: 캐시 조회
        ProductDto cached = (ProductDto) redisTemplate.opsForValue().get(cacheKey);
        if (cached != null) {
            log.debug("[CACHE HIT] product:{}", productId);
            return cached;
        }

        // 2단계: Cache Miss → DB 조회
        log.debug("[CACHE MISS] product:{}", productId);
        ProductDto product = productRepository.findById(productId)
            .map(ProductDto::from)
            .orElseThrow(() -> new ProductNotFoundException(productId));

        // 3단계: 캐시 저장 (TTL 설정)
        redisTemplate.opsForValue().set(cacheKey, product, PRODUCT_TTL);

        return product;
    }

    // 상품 수정 시 캐시 무효화 (Cache Invalidation)
    public ProductDto updateProduct(Long productId, ProductUpdateRequest request) {
        Product updated = productRepository.save(/* 업데이트 로직 */);

        // 캐시 삭제 → 다음 조회 시 DB에서 최신 데이터 가져옴
        redisTemplate.delete(PRODUCT_CACHE_KEY + productId);

        return ProductDto.from(updated);
    }
}

// Spring의 @Cacheable로 Cache-Aside 자동화
@Service
@RequiredArgsConstructor
public class ProductServiceWithAnnotation {

    private final ProductRepository productRepository;

    @Cacheable(
        value = "productDetail",        // 캐시 이름 (Redis key prefix)
        key = "#productId",             // 캐시 키
        unless = "#result == null"      // null이면 캐시 저장 안 함
    )
    public ProductDto getProduct(Long productId) {
        return productRepository.findById(productId)
            .map(ProductDto::from)
            .orElse(null);
        // 첫 호출: DB 조회 + 캐시 저장
        // 이후 호출: Redis에서 즉시 반환 (메서드 자체 실행 안 됨)
    }

    @CachePut(
        value = "productDetail",
        key = "#result.id"              // 저장 후 캐시 갱신
    )
    public ProductDto updateProduct(Long id, ProductUpdateRequest req) {
        // 업데이트 로직 → 반환값으로 캐시 자동 갱신
        return ProductDto.from(productRepository.save(/* 업데이트 */));
    }

    @CacheEvict(
        value = "productDetail",
        key = "#productId"             // 특정 키 삭제
    )
    public void deleteProduct(Long productId) {
        productRepository.deleteById(productId);
    }

    @CacheEvict(
        value = "productDetail",
        allEntries = true              // 전체 캐시 초기화 (주의: 대규모 환경에서 위험)
    )
    public void clearAllProductCache() { }
}

[Write-Through 흐름]

클라이언트 쓰기 요청
  ↓
애플리케이션 → DB 저장
            → Redis 캐시 동시 업데이트
  ↓
클라이언트 응답 (DB + 캐시 모두 최신 상태)

@Service
@RequiredArgsConstructor
public class UserProfileWriteThroughService {

    private final RedisTemplate<String, Object> redisTemplate;
    private final UserRepository userRepository;

    @Transactional
    public UserProfile updateProfile(Long userId, ProfileUpdateRequest request) {
        // 1단계: DB 저장
        User user = userRepository.findById(userId).orElseThrow();
        user.updateProfile(request.getName(), request.getBio());
        User saved = userRepository.save(user);

        // 2단계: Redis 동시 업데이트 (Write-Through)
        UserProfile profile = UserProfile.from(saved);
        redisTemplate.opsForValue().set(
            "user:profile:" + userId,
            profile,
            Duration.ofDays(7)
        );

        return profile;
    }

    // 조회: 항상 캐시에 최신 데이터 존재 → Cache Miss 거의 없음
    public UserProfile getProfile(Long userId) {
        UserProfile cached = (UserProfile) redisTemplate.opsForValue()
            .get("user:profile:" + userId);

        if (cached != null) return cached;

        // 최초 조회 시 DB에서 로드 (이후 Write-Through로 항상 최신 유지)
        User user = userRepository.findById(userId).orElseThrow();
        UserProfile profile = UserProfile.from(user);
        redisTemplate.opsForValue().set(
            "user:profile:" + userId, profile, Duration.ofDays(7));
        return profile;
    }
}

@Service
@RequiredArgsConstructor
public class ViewCountWriteBehindService {

    private final RedisTemplate<String, Object> redisTemplate;
    private final PostRepository postRepository;

    // 조회수 증가: Redis에만 즉시 반영 (초당 수만 건 처리 가능)
    public Long incrementViewCount(Long postId) {
        String key = "post:views:" + postId;
        return redisTemplate.opsForValue().increment(key);
        // DB는 아직 업데이트 안 됨 → 비동기 배치로 처리
    }

    // 스케줄러로 주기적 DB 동기화 (Write-Behind 구현)
    @Scheduled(fixedDelay = 60000)  // 1분마다 실행
    public void flushViewCountsToDB() {
        // "post:views:*" 패턴의 키 조회
        Set<String> keys = redisTemplate.keys("post:views:*");
        if (keys == null || keys.isEmpty()) return;

        for (String key : keys) {
            try {
                String postIdStr = key.replace("post:views:", "");
                Long postId = Long.parseLong(postIdStr);

                // Redis에서 현재 값 가져오기 + 삭제 (원자적 GETDEL)
                Object viewCount = redisTemplate.opsForValue().getAndDelete(key);
                if (viewCount != null) {
                    // DB에 누적 업데이트
                    postRepository.incrementViewCount(
                        postId, Long.parseLong(viewCount.toString()));
                }
            } catch (Exception e) {
                log.error("[Write-Behind] 조회수 동기화 실패: key={}", key, e);
            }
        }
    }
}

// Redis Cache 설정 – TTL별 캐시 그룹 정의
@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public RedisCacheManager cacheManager(
            RedisConnectionFactory connectionFactory) {

        // 기본 캐시 설정
        RedisCacheConfiguration defaultConfig =
            RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(10))
                .serializeKeysWith(
                    RedisSerializationContext.SerializationPair
                        .fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(
                    RedisSerializationContext.SerializationPair
                        .fromSerializer(new GenericJackson2JsonRedisSerializer()))
                .disableCachingNullValues();  // null 캐싱 방지

        // 용도별 TTL 커스터마이징
        Map<String, RedisCacheConfiguration> cacheConfigs = new HashMap<>();
        cacheConfigs.put("productDetail",
            defaultConfig.entryTtl(Duration.ofHours(1)));
        cacheConfigs.put("userProfile",
            defaultConfig.entryTtl(Duration.ofDays(1)));
        cacheConfigs.put("categoryList",
            defaultConfig.entryTtl(Duration.ofDays(7)));    // 자주 안 바뀌는 데이터
        cacheConfigs.put("stockInfo",
            defaultConfig.entryTtl(Duration.ofSeconds(30))); // 실시간성 중요

        return RedisCacheManager.builder(connectionFactory)
            .cacheDefaults(defaultConfig)
            .withInitialCacheConfigurations(cacheConfigs)
            .build();
    }
}

[캐시 스탬피드 발생 시나리오]

인기 상품 캐시 TTL: 1시간
→ 정각에 캐시 만료
→ 동시에 1,000개의 요청이 Cache Miss
→ 1,000개의 SELECT 쿼리 DB 동시 도달
→ DB CPU 100% → 쿼리 타임아웃 → 서비스 장애

@Service
@RequiredArgsConstructor
public class StampedePreventionService {

    private final RedisTemplate<String, Object> redisTemplate;
    private final ProductRepository productRepository;

    public ProductDto getProductSafe(Long productId) {
        String cacheKey = "product:detail:" + productId;
        String lockKey  = "lock:product:" + productId;

        // 1단계: 캐시 조회
        ProductDto cached = (ProductDto) redisTemplate.opsForValue().get(cacheKey);
        if (cached != null) return cached;

        // 2단계: 캐시 미스 → 분산 락 획득 시도
        Boolean acquired = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, "LOCKED", Duration.ofSeconds(5));

        if (Boolean.TRUE.equals(acquired)) {
            // 락 획득 성공 → DB 조회 후 캐시 저장
            try {
                // 다시 한번 캐시 확인 (락 대기 중 다른 스레드가 캐시 저장했을 수 있음)
                cached = (ProductDto) redisTemplate.opsForValue().get(cacheKey);
                if (cached != null) return cached;

                ProductDto product = productRepository.findById(productId)
                    .map(ProductDto::from)
                    .orElseThrow();
                redisTemplate.opsForValue()
                    .set(cacheKey, product, Duration.ofHours(1));
                return product;
            } finally {
                redisTemplate.delete(lockKey);  // 반드시 락 해제
            }
        } else {
            // 락 획득 실패 → 잠깐 대기 후 재시도 (다른 스레드가 캐시 저장 중)
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return getProductSafe(productId);   // 재귀 재시도
        }
    }
}

// 여러 캐시의 TTL을 동시에 만료되지 않도록 랜덤화
public void cacheWithJitter(String key, Object value, Duration baseTtl) {
    // 기본 TTL의 ±10% 범위에서 랜덤 TTL 설정
    long baseSeconds = baseTtl.getSeconds();
    long jitter = (long) (baseSeconds * 0.1 * (Math.random() * 2 - 1));
    Duration ttlWithJitter = Duration.ofSeconds(baseSeconds + jitter);

    redisTemplate.opsForValue().set(key, value, ttlWithJitter);
    // → 3,600초 TTL → 3,240 ~ 3,960초 랜덤 설정
    // → 동시 만료 방지
}

// 캐시가 만료되기 전에 확률적으로 미리 갱신
public ProductDto getProductWithEarlyRefresh(Long productId) {
    String cacheKey = "product:detail:" + productId;
    String ttlKey   = "product:ttl:" + productId;

    ProductDto cached = (ProductDto) redisTemplate.opsForValue().get(cacheKey);
    Long remainingTtl = redisTemplate.getExpire(cacheKey, TimeUnit.SECONDS);

    if (cached != null && remainingTtl != null) {
        // 남은 TTL이 전체의 20% 이하 + 확률적 갱신
        long totalTtl = 3600L;
        double refreshProbability = Math.exp(-remainingTtl / (totalTtl * 0.2));
        if (Math.random() < refreshProbability) {
            log.debug("[PER] 조기 캐시 갱신: product:{}", productId);
            // 백그라운드 갱신 (현재 요청은 캐시 반환)
            CompletableFuture.runAsync(() -> refreshCache(productId));
        }
        return cached;
    }

    return refreshCache(productId);
}

// 해결책: Null 캐싱 (존재하지 않는 데이터도 캐시)
public ProductDto getProductWithNullCache(Long productId) {
    String cacheKey = "product:detail:" + productId;

    Object cached = redisTemplate.opsForValue().get(cacheKey);

    if (cached != null) {
        // "NULL" 문자열이면 없는 데이터 → 404 반환
        if ("NULL".equals(cached)) {
            throw new ProductNotFoundException(productId);
        }
        return (ProductDto) cached;
    }

    // DB 조회
    Optional<Product> product = productRepository.findById(productId);

    if (product.isEmpty()) {
        // 없는 데이터 → 짧은 TTL로 NULL 캐싱 (DB 부하 방지)
        redisTemplate.opsForValue()
            .set(cacheKey, "NULL", Duration.ofMinutes(5));
        throw new ProductNotFoundException(productId);
    }

    ProductDto dto = ProductDto.from(product.get());
    redisTemplate.opsForValue().set(cacheKey, dto, Duration.ofHours(1));
    return dto;
}

# redis.conf 또는 application.yml
spring:
  data:
    redis:
      host: localhost
      port: 6379

# Redis maxmemory 및 Eviction 정책 설정 (redis.conf)
# maxmemory 2gb
# maxmemory-policy allkeys-lru

// 메모리 사용량 모니터링
@Component
@RequiredArgsConstructor
public class RedisMemoryMonitor {

    private final RedisTemplate<String, Object> redisTemplate;

    @Scheduled(fixedDelay = 60000)
    public void checkMemoryUsage() {
        Properties info = redisTemplate.getConnectionFactory()
            .getConnection().serverCommands().info("memory");

        String usedMemory     = info.getProperty("used_memory_human");
        String maxMemory      = info.getProperty("maxmemory_human");
        String evictedKeys    = info.getProperty("evicted_keys");

        log.info("[Redis] 메모리: {}/{}, 퇴거 키: {}",
            usedMemory, maxMemory, evictedKeys);

        // 메모리 사용률 80% 초과 시 알림
        long used = Long.parseLong(info.getProperty("used_memory"));
        long max  = Long.parseLong(info.getProperty("maxmemory"));
        if (max > 0 && (double) used / max > 0.8) {
            alertService.sendMemoryAlert(used, max);
        }
    }
}

[분산 환경 세션 문제]

로드밸런서
    ├── 서버 A (세션 저장: userId=1 로그인 완료)
    ├── 서버 B (세션 없음: userId=1 모름)
    └── 서버 C (세션 없음: userId=1 모름)

사용자 첫 요청 → 서버 A → 로그인 처리 → 세션 저장
사용자 두 번째 요청 → 서버 B로 라우팅 → "세션 없음" → 로그아웃 처리 ❌

[Redis 분산 세션 구조]

로드밸런서
    ├── 서버 A ─┐
    ├── 서버 B ─┼──→ Redis (중앙 세션 저장소)
    └── 서버 C ─┘        ↑
                     session:abc123 → {userId:1, role:USER, ...}
                     session:def456 → {userId:2, role:ADMIN, ...}

모든 서버가 Redis에서 세션을 읽고 씀 → 어느 서버로 요청이 가도 동일한 세션

<!-- pom.xml -->
<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session-data-redis</artifactId>
</dependency>

# application.yml
spring:
  session:
    store-type: redis
    redis:
      namespace: "myapp:session"    # Redis key prefix
      flush-mode: on-save           # 세션 변경 시에만 Redis 저장 (성능 최적화)
    timeout: 30m                    # 세션 만료 시간 (마지막 접근 기준)
  data:
    redis:
      host: ${REDIS_HOST:localhost}
      port: ${REDIS_PORT:6379}
      password: ${REDIS_PASSWORD:}
      lettuce:
        pool:
          max-active: 10
          max-idle: 5
          min-idle: 2

@Configuration
@EnableRedisHttpSession(
    maxInactiveIntervalInSeconds = 1800,    // 30분 세션 유지
    redisNamespace = "myapp:session"
)
public class SessionConfig {

    // Redis 세션 직렬화 설정
    @Bean
    public RedisSerializer<Object> springSessionDefaultRedisSerializer() {
        return new GenericJackson2JsonRedisSerializer();
    }
}

// 세션 활용 컨트롤러
@RestController
@RequiredArgsConstructor
public class AuthController {

    private final AuthService authService;

    @PostMapping("/api/login")
    public ResponseEntity<LoginResponse> login(
            @RequestBody LoginRequest request,
            HttpSession session) {

        UserInfo userInfo = authService.authenticate(
            request.getEmail(), request.getPassword());

        // Redis에 세션 데이터 저장
        session.setAttribute("userId",   userInfo.getId());
        session.setAttribute("userRole", userInfo.getRole().name());
        session.setAttribute("loginAt",  LocalDateTime.now().toString());

        // JSESSIONID 쿠키 자동 발급 → 이후 요청에 자동 포함
        return ResponseEntity.ok(LoginResponse.of(userInfo));
    }

    @PostMapping("/api/logout")
    public ResponseEntity<Void> logout(HttpSession session) {
        session.invalidate();   // Redis에서 세션 즉시 삭제
        return ResponseEntity.noContent().build();
    }

    @GetMapping("/api/me")
    public ResponseEntity<UserInfo> getMyInfo(HttpSession session) {
        Long userId = (Long) session.getAttribute("userId");
        if (userId == null) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
        return ResponseEntity.ok(authService.getUserInfo(userId));
    }
}

@Service
@RequiredArgsConstructor
public class JwtBlacklistService {

    private final RedisTemplate<String, Object> redisTemplate;

    private static final String BLACKLIST_PREFIX = "jwt:blacklist:";

    // 로그아웃 시 토큰을 블랙리스트에 추가
    public void blacklistToken(String token) {
        String jti = jwtParser.extractJti(token);      // JWT ID (고유 식별자)
        long remainingTtl = jwtParser.getRemainingTtl(token);  // 남은 유효 시간

        // 토큰이 자연 만료될 때까지만 블랙리스트 유지 (메모리 효율)
        redisTemplate.opsForValue().set(
            BLACKLIST_PREFIX + jti,
            "REVOKED",
            Duration.ofSeconds(remainingTtl)
        );
        log.info("[JWT] 토큰 무효화: jti={}, ttl={}s", jti, remainingTtl);
    }

    // 요청마다 블랙리스트 확인 (필터에서 호출)
    public boolean isBlacklisted(String token) {
        String jti = jwtParser.extractJti(token);
        return Boolean.TRUE.equals(
            redisTemplate.hasKey(BLACKLIST_PREFIX + jti));
    }
}

// JWT 인증 필터에서 블랙리스트 확인
@Component
@RequiredArgsConstructor
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private final JwtBlacklistService blacklistService;
    private final JwtTokenParser jwtParser;

    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain filterChain) throws ServletException, IOException {

        String token = extractToken(request);

        if (token != null) {
            // 블랙리스트 확인 (로그아웃된 토큰 차단)
            if (blacklistService.isBlacklisted(token)) {
                response.setStatus(HttpStatus.UNAUTHORIZED.value());
                return;
            }

            // 정상 토큰 처리
            if (jwtParser.isValid(token)) {
                Authentication auth = jwtParser.getAuthentication(token);
                SecurityContextHolder.getContext().setAuthentication(auth);
            }
        }

        filterChain.doFilter(request, response);
    }
}

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.25.2</version>
</dependency>

@Service
@RequiredArgsConstructor
public class DistributedLockService {

    private final RedissonClient redissonClient;

    // 재고 차감 – 동시 요청 시 하나만 처리
    public OrderResult deductStock(Long productId, int quantity)
            throws InterruptedException {

        String lockKey = "lock:stock:" + productId;
        RLock lock = redissonClient.getLock(lockKey);

        // 최대 3초 대기, 10초 후 자동 해제 (서버 장애 대비)
        boolean acquired = lock.tryLock(3, 10, TimeUnit.SECONDS);

        if (!acquired) {
            throw new StockLockException("재고 처리 중입니다. 잠시 후 다시 시도하세요.");
        }

        try {
            // 락 보유 중 단독 실행 보장
            Product product = productRepository.findByIdWithLock(productId);

            if (product.getStock() < quantity) {
                throw new InsufficientStockException(productId, quantity);
            }

            product.deductStock(quantity);
            productRepository.save(product);

            return OrderResult.success(productId, quantity);

        } finally {
            // 반드시 락 해제 (finally 블록에서)
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }

    // @DistributedLock 어노테이션으로 AOP 추상화
    @DistributedLock(
        key = "'stock:' + #productId",
        waitTime = 3,
        leaseTime = 10
    )
    public void deductStockWithAop(Long productId, int quantity) {
        // 락 획득/해제를 AOP가 자동 처리
        Product product = productRepository.findById(productId).orElseThrow();
        product.deductStock(quantity);
        productRepository.save(product);
    }
}

// 발행자 (Publisher)
@Service
@RequiredArgsConstructor
public class NotificationPublisher {

    private final RedisTemplate<String, Object> redisTemplate;

    public void publishOrderCompleted(OrderCompletedEvent event) {
        redisTemplate.convertAndSend(
            "channel:order:completed",  // 채널 이름
            event                       // JSON 직렬화 후 발행
        );
    }
}

// 구독자 (Subscriber) 설정
@Configuration
public class RedisSubscriberConfig {

    @Bean
    public RedisMessageListenerContainer container(
            RedisConnectionFactory connectionFactory,
            MessageListenerAdapter orderCompletedListener) {

        RedisMessageListenerContainer container =
            new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);

        // 채널 구독 등록
        container.addMessageListener(
            orderCompletedListener,
            new PatternTopic("channel:order:*")  // 패턴 구독
        );
        return container;
    }

    @Bean
    public MessageListenerAdapter orderCompletedListener(
            OrderEventHandler handler) {
        return new MessageListenerAdapter(handler, "handleOrderCompleted");
    }
}

@Component
@Slf4j
public class OrderEventHandler {

    public void handleOrderCompleted(OrderCompletedEvent event) {
        log.info("[Pub/Sub] 주문 완료 이벤트 수신: orderId={}", event.getOrderId());
        // 푸시 알림, 이메일 발송, 재고 업데이트 등 처리
    }
}

# Redis Sentinel 설정 (마스터 장애 시 자동 페일오버)
spring:
  data:
    redis:
      sentinel:
        master: mymaster           # Sentinel에 등록된 마스터 이름
        nodes:
          - sentinel1:26379
          - sentinel2:26379
          - sentinel3:26379
        password: ${SENTINEL_PASSWORD}

# Redis Cluster 설정 (수평 확장)
spring:
  data:
    redis:
      cluster:
        nodes:
          - redis-node1:6379
          - redis-node2:6379
          - redis-node3:6379
          - redis-node4:6379
          - redis-node5:6379
          - redis-node6:6379       # 3 마스터 + 3 레플리카
        max-redirects: 3
      lettuce:
        cluster:
          refresh:
            adaptive: true         # 클러스터 토폴로지 변경 자동 감지
            period: 30s

[Redis 실무 운영 체크리스트]

□ maxmemory 설정: 전체 RAM의 60~70%로 제한 (OS 여유분 확보)?
□ Eviction 정책: 용도에 맞는 정책 선택 (캐시→allkeys-lru 권장)?
□ persistence 설정: 캐시 전용이면 RDB/AOF 끄기 (성능 향상)?
□ TTL 필수 설정: 모든 캐시 키에 TTL 지정 (메모리 누수 방지)?
□ 키 네이밍 규칙: "서비스:도메인:ID" 형식으로 통일?
□ 연결 풀 설정: Lettuce 풀 크기 최적화 완료?
□ 직렬화 전략: JSON 직렬화로 타입 안정성 확보?
□ 고가용성: Sentinel 또는 Cluster 구성 완료?
□ 모니터링: 메모리 사용률·히트율·Eviction 수 알림 설정?
□ 슬로우 로그: slowlog-log-slower-than 설정으로 느린 명령 추적?
□ 캐시 스탬피드 방지: Mutex Lock 또는 TTL Jitter 적용?
□ 보안: requirepass 설정, 외부 포트 차단, TLS 적용?