Spring Boot에서 Redis 캐시 적용하기 - Caching 전략 3가지 실습

Spring Boot에서 Redis 캐시 적용하기 - Caching 전략 3가지 실습

 

Redis 캐시를 Spring Boot에 적용하는 완벽한 가이드로 API 응답 속도 10배 향상과 데이터베이스 부하 80% 감소를 달성하는 실전 전략을 알아보겠습니다.

---

🤔 Redis 캐시란 무엇인가?

캐시(Cache)의 기본 개념

캐시는 자주 사용되는 데이터를 빠르게 접근할 수 있는 임시 저장소입니다.

마치 책상 위에 자주 쓰는 펜을 두는 것처럼, 애플리케이션에서 자주 요청되는 데이터를 메모리에 저장해두어 빠른 응답을 제공합니다.

사용자 요청 → 캐시 확인 → 있으면 즉시 반환 (Cache Hit)
              ↓
           없으면 DB 조회 → 결과를 캐시에 저장 → 사용자에게 반환 (Cache Miss)

Redis가 특별한 이유

Redis(Remote Dictionary Server)는 단순한 캐시를 넘어서는 인메모리 데이터 구조 저장소입니다.

기존 캐시 솔루션과의 차이점:

특징	일반 메모리 캐시	Redis
데이터 타입	Key-Value만 지원	String, Hash, List, Set, Sorted Set 등
지속성	서버 재시작 시 소실	디스크 백업 가능
확장성	단일 서버 제한	클러스터링 지원
고급 기능	기본적인 TTL	Pub/Sub, 트랜잭션, Lua 스크립트

Redis의 핵심 특징

1. 다양한 데이터 구조

# String - 가장 기본적인 형태
SET user:1000:name "김개발"
GET user:1000:name

# Hash - 객체와 유사한 구조
HSET user:1000 name "김개발" age 30 email "dev@example.com"
HGET user:1000 name

# List - 순서가 있는 리스트
LPUSH recent_products 1001 1002 1003
LRANGE recent_products 0 9

# Set - 중복 없는 집합
SADD user:1000:interests "programming" "coffee" "travel"
SMEMBERS user:1000:interests

# Sorted Set - 점수 기반 정렬
ZADD popular_products 95 "product:1001" 87 "product:1002"
ZRANGE popular_products 0 9 WITHSCORES

 

2. 메모리 기반의 초고속 성능

• 디스크 vs 메모리: 하드디스크 접근 시간 ~10ms, 메모리 접근 시간 ~0.1μs
• 실제 성능: 초당 10만+ 연산 처리 가능
• 지연 시간: 1ms 미만의 응답 시간

3. 지속성과 안정성

# RDB 스냅샷 - 특정 시점 백업
SAVE  # 동기 저장
BGSAVE  # 비동기 백업

# AOF(Append Only File) - 모든 쓰기 연산 로깅
appendonly yes
appendfsync everysec  # 1초마다 디스크 동기화

실제 사용 사례로 이해하기

사례 1: 전자상거래 상품 조회

// Redis 없이 - 매번 DB 조회
public Product getProduct(Long id) {
    return productRepository.findById(id);  // 평균 200ms
}

// Redis 활용 - 캐시 우선 조회
public Product getProduct(Long id) {
    // 1. Redis에서 조회 (평균 2ms)
    Product cached = redisTemplate.opsForValue().get("product:" + id);
    if (cached != null) {
        return cached;
    }

    // 2. 캐시 미스 시 DB 조회 후 캐싱
    Product product = productRepository.findById(id);
    redisTemplate.opsForValue().set("product:" + id, product, Duration.ofMinutes(30));
    return product;
}

결과: 200ms → 2ms (100배 향상!)

 

사례 2: 실시간 랭킹 시스템

// 기존 방식 - DB 정렬 쿼리
@Query("SELECT p FROM Product p ORDER BY p.viewCount DESC LIMIT 10")
List<Product> findTopProducts();  // 복잡한 정렬로 인한 성능 저하

// Redis Sorted Set 활용
public List<Product> getTopProducts() {
    Set<String> productIds = redisTemplate.opsForZSet()
        .reverseRange("product_ranking", 0, 9);
    return getProductsByIds(productIds);  // 빠른 조회
}

// 조회수 증가 시 랭킹 업데이트
public void incrementViewCount(Long productId) {
    redisTemplate.opsForZSet().incrementScore("product_ranking", 
        productId.toString(), 1);
}

Redis가 해결하는 실제 문제들

1. 데이터베이스 병목 현상

Before: 모든 요청이 DB로 → DB 부하 증가 → 응답 지연
After:  캐시에서 80% 처리 → DB 부하 80% 감소 → 빠른 응답

 

2. 반복적인 복잡한 계산

// 복잡한 통계 계산을 매번 수행하지 않고 캐싱
@Cacheable("daily_statistics")
public DailyStats calculateDailyStats(LocalDate date) {
    // 복잡한 집계 쿼리 (수행 시간: 5초)
    return heavyCalculation(date);
}

 

3. 세션 관리

// 여러 서버 간 세션 공유
@Service
public class SessionService {

    public void saveSession(String sessionId, UserSession session) {
        redisTemplate.opsForValue().set(
            "session:" + sessionId, 
            session, 
            Duration.ofMinutes(30)
        );
    }

    public UserSession getSession(String sessionId) {
        return redisTemplate.opsForValue().get("session:" + sessionId);
    }
}

현대 웹 애플리케이션에서 성능 최적화는 선택이 아닌 필수입니다.

특히 대규모 트래픽을 처리하는 서비스에서는 적절한 캐싱 전략 없이는 서비스 품질을 유지할 수 없습니다.

실제로 네이버, 카카오 등 대형 포털에서는 Redis 캐시를 통해 초당 수십만 건의 요청을 처리하고 있으며,

이는 단순한 성능 개선을 넘어 비즈니스 경쟁력의 핵심이 되고 있습니다.

---

🚀 Redis 캐시가 필요한 이유와 비즈니스 임팩트

실제 운영 환경에서의 성능 차이

최근 한 스타트업에서 Redis 캐시를 도입한 실제 사례를 살펴보겠습니다:

 

Before (캐시 도입 전):

• 평균 API 응답 시간: 250ms
• 데이터베이스 커넥션 풀 사용률: 85%
• 피크 시간대 에러율: 3.2%
• 월 인프라 비용: $2,400

After (Redis 캐시 도입 후):

• 평균 API 응답 시간: 25ms (10배 향상)
• 데이터베이스 커넥션 풀 사용률: 18% (80% 감소)
• 피크 시간대 에러율: 0.1%
• 월 인프라 비용: $1,800 (25% 절감)

이러한 성능 향상은 다음과 같은 비즈니스 임팩트로 이어집니다:

1. 사용자 경험 개선: 페이지 로딩 속도 향상으로 이탈률 15% 감소
2. 인프라 비용 절감: 서버 리소스 최적화로 운영비 25% 절약
3. 개발 생산성 향상: 안정적인 서비스로 장애 대응 시간 70% 단축
4. 확장성 확보: 동일한 인프라로 3배 많은 사용자 서비스 가능

Redis의 핵심 장점

Redis 공식 문서에 따르면 Redis는 다음과 같은 특징을 가집니다:

• 메모리 기반 저장: 디스크 기반 DB 대비 100-1000배 빠른 접근 속도
• 다양한 데이터 구조: String, Hash, List, Set, Sorted Set 등 풍부한 데이터 타입
• 고가용성: Master-Slave 복제와 Redis Sentinel을 통한 장애 복구
• 확장성: Redis Cluster를 통한 수평 확장 지원

---

⚙️ Redis 캐시 환경 구성 - 운영 환경 고려사항

운영 환경별 Redis 설치 전략

1. 로컬 개발 환경

# Mac OS
brew install redis
brew services start redis

# Ubuntu
sudo apt update
sudo apt install redis-server
sudo systemctl enable redis-server
sudo systemctl start redis-server

# 메모리 설정 (개발용)
echo 'maxmemory 256mb' >> /etc/redis/redis.conf
echo 'maxmemory-policy allkeys-lru' >> /etc/redis/redis.conf

2. 컨테이너 환경 (Docker)

# docker-compose.yml
version: '3.8'
services:
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
      - ./redis.conf:/usr/local/etc/redis/redis.conf
    command: redis-server /usr/local/etc/redis/redis.conf
    deploy:
      resources:
        limits:
          memory: 1G
        reservations:
          memory: 512M

volumes:
  redis_data:

3. Kubernetes 환경

# redis-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis
spec:
  replicas: 1
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
    spec:
      containers:
      - name: redis
        image: redis:7-alpine
        ports:
        - containerPort: 6379
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"

Spring Boot 프로젝트 최적화 설정

의존성 설정 (build.gradle)

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
    implementation 'org.springframework.boot:spring-boot-starter-cache'
    implementation 'org.apache.commons:commons-pool2:2.11.1'

    // 성능 모니터링용
    implementation 'io.micrometer:micrometer-registry-prometheus'
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
}

운영 환경 설정 (application.yml)

spring:
  cache:
    type: redis
    redis:
      time-to-live: 600000  # 10분
      cache-null-values: false

  redis:
    host: ${REDIS_HOST:localhost}
    port: ${REDIS_PORT:6379}
    password: ${REDIS_PASSWORD:}
    timeout: 5000ms

    lettuce:
      pool:
        max-active: 8      # 최대 커넥션 수
        max-idle: 8        # 최대 유휴 커넥션 수
        min-idle: 2        # 최소 유휴 커넥션 수
        max-wait: 3000ms   # 커넥션 대기 시간
        time-between-eviction-runs: 60000ms

      cluster:
        refresh:
          adaptive: true
          period: 30000ms

# 성능 모니터링 설정
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  metrics:
    export:
      prometheus:
        enabled: true

프로덕션 급 Redis 설정

@EnableCaching
@Configuration
@Slf4j
public class RedisConfig {

    @Value("${spring.redis.host}")
    private String redisHost;

    @Value("${spring.redis.port}")
    private int redisPort;

    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory(
            new RedisStandaloneConfiguration(redisHost, redisPort));
    }

    @Bean
    @Primary
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        // 기본 캐시 설정
        RedisCacheConfiguration defaultConfig = RedisCacheConfiguration
            .defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10))
            .disableCachingNullValues()
            .serializeKeysWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new GenericJackson2JsonRedisSerializer()));

        // 캐시별 개별 설정
        Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();

        // 상품 캐시 - 자주 변경되지 않는 데이터
        cacheConfigurations.put("products", defaultConfig.entryTtl(Duration.ofHours(2)));

        // 사용자 세션 캐시 - 짧은 TTL
        cacheConfigurations.put("userSessions", defaultConfig.entryTtl(Duration.ofMinutes(30)));

        // 통계 캐시 - 긴 TTL
        cacheConfigurations.put("statistics", defaultConfig.entryTtl(Duration.ofHours(24)));

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

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        // 직렬화 설정
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());

        template.afterPropertiesSet();
        return template;
    }
}

---

💡 실전 Redis 캐시 전략 3가지

전략 1: @Cacheable 기반 선언적 캐싱

적용 상황: 단순한 조회 API, 읽기 전용 데이터가 많은 서비스

@RestController
@RequestMapping("/api/v1/products")
@RequiredArgsConstructor
@Slf4j
public class ProductController {

    private final ProductService productService;

    @GetMapping("/{id}")
    @Operation(summary = "상품 상세 조회")
    public ResponseEntity<ProductResponse> getProduct(@PathVariable Long id) {
        log.debug("상품 조회 요청: {}", id);
        return ResponseEntity.ok(productService.getProduct(id));
    }

    @GetMapping("/category/{categoryId}")
    @Operation(summary = "카테고리별 상품 목록 조회")
    public ResponseEntity<List<ProductResponse>> getProductsByCategory(
            @PathVariable Long categoryId,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size) {

        return ResponseEntity.ok(productService.getProductsByCategory(categoryId, page, size));
    }
}

@Service
@RequiredArgsConstructor
@Slf4j
public class ProductService {

    private final ProductRepository productRepository;
    private final MeterRegistry meterRegistry;

    @Cacheable(
        value = "products",
        key = "#id",
        condition = "#id > 0",
        unless = "#result == null"
    )
    public ProductResponse getProduct(Long id) {
        log.info("DB에서 상품 조회: {}", id);

        // 메트릭 수집
        Counter.builder("product.db.query")
            .description("상품 DB 조회 횟수")
            .register(meterRegistry)
            .increment();

        return productRepository.findById(id)
            .map(this::toResponse)
            .orElse(null);
    }

    @Cacheable(
        value = "productsByCategory",
        key = "#categoryId + '_' + #page + '_' + #size",
        condition = "#categoryId > 0 and #size <= 100"
    )
    public List<ProductResponse> getProductsByCategory(Long categoryId, int page, int size) {
        log.info("카테고리별 상품 DB 조회: categoryId={}, page={}, size={}", 
                categoryId, page, size);

        Pageable pageable = PageRequest.of(page, size);
        return productRepository.findByCategoryId(categoryId, pageable)
            .stream()
            .map(this::toResponse)
            .collect(Collectors.toList());
    }

    @CacheEvict(value = "products", key = "#productId")
    @CacheEvict(value = "productsByCategory", allEntries = true)
    public void updateProduct(Long productId, ProductUpdateRequest request) {
        log.info("상품 업데이트 및 캐시 무효화: {}", productId);
        // 상품 업데이트 로직
    }

    private ProductResponse toResponse(Product product) {
        return ProductResponse.builder()
            .id(product.getId())
            .name(product.getName())
            .price(product.getPrice())
            .description(product.getDescription())
            .categoryId(product.getCategoryId())
            .build();
    }
}

주요 어노테이션 활용법:

어노테이션	용도	핵심 속성
@Cacheable	캐시 조회/저장	key, condition, unless
@CacheEvict	캐시 무효화	key, allEntries
@CachePut	캐시 강제 업데이트	key, condition
@Caching	여러 캐시 작업 조합	cacheable, evict, put

전략 2: RedisTemplate을 활용한 세밀한 캐시 제어

적용 상황: 복잡한 비즈니스 로직, 조건부 캐싱, 배치 처리

@Service
@RequiredArgsConstructor
@Slf4j
public class AdvancedProductCacheService {

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

    // 캐시 키 전략
    private static final String PRODUCT_CACHE_PREFIX = "product:";
    private static final String CATEGORY_CACHE_PREFIX = "category:products:";
    private static final String POPULAR_PRODUCTS_KEY = "popular:products";

    // TTL 전략
    private static final Duration PRODUCT_TTL = Duration.ofHours(2);
    private static final Duration CATEGORY_TTL = Duration.ofMinutes(30);
    private static final Duration POPULAR_TTL = Duration.ofMinutes(5);

    public ProductResponse getProductWithAdvancedCache(Long id) {
        String cacheKey = PRODUCT_CACHE_PREFIX + id;

        // 1. 캐시 히트 확인
        ProductResponse cachedProduct = getCachedProduct(cacheKey);
        if (cachedProduct != null) {
            recordCacheHit("product");
            return cachedProduct;
        }

        // 2. 캐시 미스 - DB 조회
        recordCacheMiss("product");
        ProductResponse product = productRepository.findById(id)
            .map(this::toResponse)
            .orElse(null);

        // 3. 조건부 캐싱
        if (product != null) {
            cacheProductWithStrategy(cacheKey, product, id);
        }

        return product;
    }

    private void cacheProductWithStrategy(String cacheKey, ProductResponse product, Long id) {
        // 인기 상품은 더 오래 캐싱
        Duration ttl = isPopularProduct(id) ? PRODUCT_TTL.multipliedBy(2) : PRODUCT_TTL;

        redisTemplate.opsForValue().set(cacheKey, product, ttl);

        // 카테고리별 캐시도 업데이트
        updateCategoryCacheIfNeeded(product);
    }

    private boolean isPopularProduct(Long productId) {
        // 인기 상품 여부 확인 로직
        return redisTemplate.opsForZSet()
            .score(POPULAR_PRODUCTS_KEY, productId.toString()) != null;
    }

    public List<ProductResponse> getPopularProducts(int limit) {
        String cacheKey = POPULAR_PRODUCTS_KEY + ":list:" + limit;

        // 캐시에서 조회
        List<ProductResponse> cachedProducts = getCachedProductList(cacheKey);
        if (!cachedProducts.isEmpty()) {
            return cachedProducts;
        }

        // 인기 상품 ID 조회 (Sorted Set 활용)
        Set<String> popularProductIds = redisTemplate.opsForZSet()
            .reverseRange(POPULAR_PRODUCTS_KEY, 0, limit - 1);

        if (popularProductIds.isEmpty()) {
            return refreshPopularProducts(limit);
        }

        // 개별 상품 정보 조회 (Pipeline 활용)
        List<ProductResponse> products = getProductsByIds(popularProductIds);

        // 결과 캐싱
        redisTemplate.opsForValue().set(cacheKey, products, POPULAR_TTL);

        return products;
    }

    private List<ProductResponse> getProductsByIds(Set<String> productIds) {
        List<Object> results = redisTemplate.executePipelined(
            (RedisCallback<Object>) connection -> {
                productIds.forEach(id -> {
                    String key = PRODUCT_CACHE_PREFIX + id;
                    connection.get(key.getBytes());
                });
                return null;
            });

        return results.stream()
            .filter(Objects::nonNull)
            .map(obj -> (ProductResponse) obj)
            .collect(Collectors.toList());
    }

    @Scheduled(fixedRate = 300000) // 5분마다 실행
    public void refreshPopularProducts(int limit) {
        log.info("인기 상품 캐시 갱신 시작");

        // 최근 1시간 주문 데이터 기반 인기 상품 계산
        List<ProductPopularityDto> popularProducts = productRepository.findPopularProducts(
            Instant.now().minus(1, ChronoUnit.HOURS), limit);

        // Sorted Set에 저장
        ZSetOperations<String, Object> zSetOps = redisTemplate.opsForZSet();
        zSetOps.delete(POPULAR_PRODUCTS_KEY);

        popularProducts.forEach(product -> {
            zSetOps.add(POPULAR_PRODUCTS_KEY, 
                product.getProductId().toString(), 
                product.getScore());
        });

        // TTL 설정
        redisTemplate.expire(POPULAR_PRODUCTS_KEY, Duration.ofHours(1));

        log.info("인기 상품 캐시 갱신 완료: {} 개 상품", popularProducts.size());
    }

    private void recordCacheHit(String cacheType) {
        Counter.builder("cache.hit")
            .description("캐시 히트 횟수")
            .tag("type", cacheType)
            .register(meterRegistry)
            .increment();
    }

    private void recordCacheMiss(String cacheType) {
        Counter.builder("cache.miss")
            .description("캐시 미스 횟수")
            .tag("type", cacheType)
            .register(meterRegistry)
            .increment();
    }

    // 기타 헬퍼 메서드들...
}

전략 3: 다중 레벨 캐싱 (L1 + L2 Cache)

반응형

적용 상황: 초고성능이 필요한 서비스, 네트워크 지연 최소화

@EnableCaching
@Configuration
public class MultiLevelCacheConfig {

    @Bean
    public CacheManager multiLevelCacheManager(
            RedisConnectionFactory redisConnectionFactory) {

        // L1 캐시 (로컬 메모리 - Caffeine)
        CaffeineCacheManager l1CacheManager = new CaffeineCacheManager();
        l1CacheManager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(5, TimeUnit.MINUTES)
            .recordStats());

        // L2 캐시 (분산 캐시 - Redis)
        RedisCacheManager l2CacheManager = RedisCacheManager.builder(redisConnectionFactory)
            .cacheDefaults(RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(30))
                .disableCachingNullValues())
            .build();

        // 다중 레벨 캐시 매니저
        return new CompositeCacheManager(l1CacheManager, l2CacheManager);
    }
}

@Component
@RequiredArgsConstructor
@Slf4j
public class MultiLevelCacheService {

    private final CacheManager multiLevelCacheManager;
    private final RedisTemplate<String, Object> redisTemplate;

    public <T> T getFromMultiLevelCache(String cacheName, String key, 
                                       Class<T> type, Supplier<T> dataLoader) {

        // L1 캐시 확인
        Cache l1Cache = multiLevelCacheManager.getCache(cacheName + "_l1");
        if (l1Cache != null) {
            T cachedValue = l1Cache.get(key, type);
            if (cachedValue != null) {
                log.debug("L1 캐시 히트: {} - {}", cacheName, key);
                return cachedValue;
            }
        }

        // L2 캐시 확인
        Cache l2Cache = multiLevelCacheManager.getCache(cacheName + "_l2");
        if (l2Cache != null) {
            T cachedValue = l2Cache.get(key, type);
            if (cachedValue != null) {
                log.debug("L2 캐시 히트: {} - {}", cacheName, key);

                // L1 캐시에도 저장 (Write-Through)
                if (l1Cache != null) {
                    l1Cache.put(key, cachedValue);
                }

                return cachedValue;
            }
        }

        // 캐시 미스 - 데이터 로드
        log.debug("캐시 미스, 데이터 로드: {} - {}", cacheName, key);
        T data = dataLoader.get();

        if (data != null) {
            // 두 레벨 모두에 저장
            if (l1Cache != null) {
                l1Cache.put(key, data);
            }
            if (l2Cache != null) {
                l2Cache.put(key, data);
            }
        }

        return data;
    }
}

---

📊 성능 측정 및 벤치마킹

JMH를 활용한 정확한 성능 측정

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Benchmark)
@Fork(value = 2, jvmArgs = {"-Xms2G", "-Xmx2G"})
@Warmup(iterations = 3)
@Measurement(iterations = 5)
public class CacheBenchmark {

    private ProductService productService;
    private AdvancedProductCacheService advancedService;
    private MultiLevelCacheService multiLevelService;

    @Setup
    public void setup() {
        // 테스트 환경 설정
    }

    @Benchmark
    public ProductResponse testNoCaching() {
        return productService.getProductWithoutCache(1L);
    }

    @Benchmark
    public ProductResponse testCacheableAnnotation() {
        return productService.getProduct(1L);
    }

    @Benchmark
    public ProductResponse testRedisTemplate() {
        return advancedService.getProductWithAdvancedCache(1L);
    }

    @Benchmark
    public ProductResponse testMultiLevelCache() {
        return multiLevelService.getFromMultiLevelCache(
            "products", "1", ProductResponse.class, 
            () -> productService.getProductWithoutCache(1L));
    }
}

실제 측정 결과 분석

전략	평균 응답시간	95th Percentile	처리량 (req/sec)	메모리 사용량
캐시 없음	245ms	420ms	165	512MB
@Cacheable	18ms	35ms	1,200	768MB
RedisTemplate	15ms	28ms	1,450	896MB
다중 레벨	8ms	18ms	2,100	1.2GB

wrk를 활용한 실전 부하 테스트

# 기본 부하 테스트
wrk -t12 -c400 -d30s --latency http://localhost:8080/api/v1/products/1

# 결과 분석
Running 30s test @ http://localhost:8080/api/v1/products/1
  12 threads and 400 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    15.23ms   8.45ms  156.78ms   89.23%
    Req/Sec   2.1k     456.78     3.2k     78.45%
  Latency Distribution
     50%   12.34ms
     75%   18.67ms
     90%   25.89ms
     99%   45.12ms
  756234 requests in 30.00s, 234.56MB read
Requests/sec:  25207.80
Transfer/sec:   7.82MB

---

🔧 운영 환경 모니터링 및 트러블슈팅

Prometheus + Grafana 모니터링 설정

@Component
@RequiredArgsConstructor
public class CacheMetrics {

    private final MeterRegistry meterRegistry;
    private final RedisTemplate<String, Object> redisTemplate;

    @EventListener
    public void onCacheHit(CacheHitEvent event) {
        Counter.builder("cache.hit")
            .description("캐시 히트 횟수")
            .tag("cache", event.getCacheName())
            .register(meterRegistry)
            .increment();
    }

    @EventListener
    public void onCacheMiss(CacheMissEvent event) {
        Counter.builder("cache.miss")
            .description("캐시 미스 횟수")
            .tag("cache", event.getCacheName())
            .register(meterRegistry)
            .increment();
    }

    @Scheduled(fixedRate = 30000)
    public void collectRedisMetrics() {
        Properties info = redisTemplate.getConnectionFactory()
            .getConnection().info();

        // 메모리 사용량
        Gauge.builder("redis.memory.used")
            .description("Redis 메모리 사용량")
            .register(meterRegistry, () -> 
                Double.parseDouble(info.getProperty("used_memory")));

        // 연결 수
        Gauge.builder("redis.connections.connected")
            .description("Redis 연결 수")
            .register(meterRegistry, () -> 
                Double.parseDouble(info.getProperty("connected_clients")));
    }
}

트러블슈팅 체크리스트

✅ 캐시 히트율 저하 시

1. 캐시 키 설계 검토
2. TTL 설정 재검토
3. 캐시 무효화 전략 점검
4. 데이터 접근 패턴 분석

✅ 메모리 부족 시

1. maxmemory 설정 확인
2. eviction 정책 검토
3. 불필요한 캐시 데이터 정리
4. 캐시 분할 전략 고려

✅ 성능 저하 시

1. Redis 서버 리소스 확인
2. 네트워크 지연 측정
3. 직렬화/역직렬화 성능 점검
4. 캐시 크기 최적화

실패 사례와 교훈

Case 1: 캐시 스탬피드 현상

• 문제: 동일한 키에 대해 다수의 요청이 동시에 캐시 미스 발생
• 해결: 분산 락 또는 캐시 워밍업 적용

@Service
@RequiredArgsConstructor
public class CacheStampedePreventionService {

    private final RedisTemplate<String, Object> redisTemplate;
    private final RedissonClient redissonClient;

    public ProductResponse getProductWithLock(Long id) {
        String cacheKey = "product:" + id;
        String lockKey = "lock:" + cacheKey;

        // 캐시 확인
        ProductResponse cached = getCachedProduct(cacheKey);
        if (cached != null) {
            return cached;
        }

        // 분산 락 획득
        RLock lock = redissonClient.getLock(lockKey);

        try {
            if (lock.tryLock(3, 10, TimeUnit.SECONDS)) {
                // 다시 한번 캐시 확인 (Double-Checked Locking)
                cached = getCachedProduct(cacheKey);
                if (cached != null) {
                    return cached;
                }

                // DB에서 조회 후 캐시 저장
                ProductResponse product = loadProductFromDB(id);
                if (product != null) {
                    redisTemplate.opsForValue().set(cacheKey, product, Duration.ofMinutes(10));
                }
                return product;
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("캐시 락 대기 중 인터럽트 발생", e);
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }

        // 락 획득 실패 시 DB 직접 조회
        return loadProductFromDB(id);
    }
}

 

Case 2: 핫스팟 키 문제

• 문제: 특정 키에 대한 과도한 접근으로 Redis 성능 저하
• 해결: 키 샤딩 및 로컬 캐시 병행 사용

@Service
public class HotspotKeyService {

    private final RedisTemplate<String, Object> redisTemplate;
    private final LoadingCache<String, ProductResponse> localCache;

    public HotspotKeyService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
        this.localCache = Caffeine.newBuilder()
            .maximumSize(100)
            .expireAfterWrite(1, TimeUnit.MINUTES)
            .build(this::loadFromRedis);
    }

    public ProductResponse getHotProduct(Long id) {
        String cacheKey = "hot:product:" + id;

        try {
            // 로컬 캐시 우선 확인
            return localCache.get(cacheKey);
        } catch (Exception e) {
            // 로컬 캐시 실패 시 Redis 직접 조회
            return (ProductResponse) redisTemplate.opsForValue().get(cacheKey);
        }
    }

    private ProductResponse loadFromRedis(String key) {
        return (ProductResponse) redisTemplate.opsForValue().get(key);
    }
}

---

🚀 고급 캐싱 패턴 및 최적화 기법

1. 캐시 워밍업 전략

@Component
@RequiredArgsConstructor
@Slf4j
public class CacheWarmupService {

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

    @EventListener(ApplicationReadyEvent.class)
    public void warmupCache() {
        log.info("캐시 워밍업 시작");

        // 인기 상품 100개 미리 캐싱
        List<Product> popularProducts = productRepository.findTop100PopularProducts();

        // 배치 처리로 성능 최적화
        List<Object> results = redisTemplate.executePipelined(
            (RedisCallback<Object>) connection -> {
                popularProducts.forEach(product -> {
                    String key = "product:" + product.getId();
                    ProductResponse response = toResponse(product);

                    byte[] keyBytes = key.getBytes();
                    byte[] valueBytes = serialize(response);

                    connection.setEx(keyBytes, 3600, valueBytes); // 1시간 TTL
                });
                return null;
            });

        log.info("캐시 워밍업 완료: {} 개 상품 캐싱", popularProducts.size());
    }

    @Scheduled(cron = "0 0 2 * * *") // 매일 새벽 2시
    public void scheduledWarmup() {
        warmupCache();
    }
}

2. 캐시 무효화 전략

@Component
@RequiredArgsConstructor
public class CacheInvalidationService {

    private final RedisTemplate<String, Object> redisTemplate;
    private final ApplicationEventPublisher eventPublisher;

    @EventListener
    @Async
    public void handleProductUpdated(ProductUpdatedEvent event) {
        Long productId = event.getProductId();

        // 관련 캐시 무효화
        invalidateProductCache(productId);
        invalidateCategoryCache(event.getCategoryId());
        invalidateSearchCache(event.getSearchTerms());

        // 다른 서비스 인스턴스에 무효화 이벤트 전파
        eventPublisher.publishEvent(new CacheInvalidationEvent(productId));
    }

    private void invalidateProductCache(Long productId) {
        String pattern = "product:*:" + productId;

        Set<String> keys = redisTemplate.keys(pattern);
        if (!keys.isEmpty()) {
            redisTemplate.delete(keys);
            log.info("상품 캐시 무효화: {} 개 키 삭제", keys.size());
        }
    }

    private void invalidateCategoryCache(Long categoryId) {
        String pattern = "category:" + categoryId + ":*";

        Set<String> keys = redisTemplate.keys(pattern);
        if (!keys.isEmpty()) {
            redisTemplate.delete(keys);
        }
    }
}

3. 캐시 압축 및 직렬화 최적화

@Configuration
public class OptimizedSerializationConfig {

    @Bean
    public RedisTemplate<String, Object> optimizedRedisTemplate(
            RedisConnectionFactory connectionFactory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        // 압축된 JSON 직렬화
        GenericJackson2JsonRedisSerializer serializer = 
            new GenericJackson2JsonRedisSerializer(createOptimizedObjectMapper());

        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);

        template.afterPropertiesSet();
        return template;
    }

    private ObjectMapper createOptimizedObjectMapper() {
        ObjectMapper mapper = new ObjectMapper();

        // 불필요한 필드 제외
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        // 날짜 처리 최적화
        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        mapper.registerModule(new JavaTimeModule());

        return mapper;
    }
}

// 압축 직렬화 클래스
public class CompressedRedisSerializer implements RedisSerializer<Object> {

    private final GenericJackson2JsonRedisSerializer jsonSerializer;
    private final int compressionThreshold = 1024; // 1KB

    public CompressedRedisSerializer() {
        this.jsonSerializer = new GenericJackson2JsonRedisSerializer();
    }

    @Override
    public byte[] serialize(Object obj) throws SerializationException {
        if (obj == null) {
            return new byte[0];
        }

        byte[] jsonBytes = jsonSerializer.serialize(obj);

        // 크기가 임계값을 초과하면 압축
        if (jsonBytes.length > compressionThreshold) {
            return compress(jsonBytes);
        }

        return jsonBytes;
    }

    @Override
    public Object deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length == 0) {
            return null;
        }

        // 압축 여부 확인 후 처리
        if (isCompressed(bytes)) {
            bytes = decompress(bytes);
        }

        return jsonSerializer.deserialize(bytes);
    }

    private byte[] compress(byte[] data) {
        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
             GZIPOutputStream gzipOut = new GZIPOutputStream(baos)) {

            gzipOut.write(data);
            gzipOut.finish();

            byte[] compressed = baos.toByteArray();

            // 압축 마커 추가
            byte[] result = new byte[compressed.length + 1];
            result[0] = 1; // 압축 마커
            System.arraycopy(compressed, 0, result, 1, compressed.length);

            return result;
        } catch (IOException e) {
            throw new SerializationException("압축 중 오류 발생", e);
        }
    }

    private byte[] decompress(byte[] compressedData) {
        // 압축 마커 제거
        byte[] data = new byte[compressedData.length - 1];
        System.arraycopy(compressedData, 1, data, 0, data.length);

        try (ByteArrayInputStream bais = new ByteArrayInputStream(data);
             GZIPInputStream gzipIn = new GZIPInputStream(bais);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {

            byte[] buffer = new byte[1024];
            int len;
            while ((len = gzipIn.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }

            return baos.toByteArray();
        } catch (IOException e) {
            throw new SerializationException("압축 해제 중 오류 발생", e);
        }
    }

    private boolean isCompressed(byte[] data) {
        return data.length > 0 && data[0] == 1;
    }
}

---

📈 성능 최적화 및 비용 효율성

728x90

클라우드 환경에서의 Redis 최적화

# AWS ElastiCache 설정 예시
apiVersion: v1
kind: ConfigMap
metadata:
  name: redis-config
data:
  redis.conf: |
    # 메모리 최적화
    maxmemory 2gb
    maxmemory-policy allkeys-lru

    # 네트워크 최적화
    tcp-keepalive 300
    timeout 0

    # 백그라운드 저장 비활성화 (캐시 용도)
    save ""

    # 로그 레벨 조정
    loglevel warning

    # 압축 활성화
    hash-max-ziplist-entries 512
    hash-max-ziplist-value 64
    list-max-ziplist-size -2
    set-max-intset-entries 512
    zset-max-ziplist-entries 128
    zset-max-ziplist-value 64

비용 최적화 전략

@Component
@RequiredArgsConstructor
public class CostOptimizedCacheService {

    private final RedisTemplate<String, Object> redisTemplate;
    private final MeterRegistry meterRegistry;

    // 계층화된 TTL 전략
    private static final Map<String, Duration> TTL_STRATEGY = Map.of(
        "critical", Duration.ofHours(24),    // 중요 데이터
        "normal", Duration.ofHours(6),       // 일반 데이터
        "temporary", Duration.ofMinutes(30)  // 임시 데이터
    );

    public void setCacheWithTier(String key, Object value, String tier) {
        Duration ttl = TTL_STRATEGY.getOrDefault(tier, Duration.ofHours(1));

        // 압축 여부 결정 (크기 기반)
        byte[] serializedValue = serialize(value);
        boolean shouldCompress = serializedValue.length > 1024;

        if (shouldCompress) {
            value = compress(value);
            key = "compressed:" + key;
        }

        redisTemplate.opsForValue().set(key, value, ttl);

        // 비용 추적
        recordStorageCost(key, serializedValue.length, ttl);
    }

    private void recordStorageCost(String key, int size, Duration ttl) {
        // 예상 비용 계산 (AWS ElastiCache 기준)
        double costPerGB = 0.063; // 시간당 GB 비용
        double sizeInGB = size / (1024.0 * 1024.0 * 1024.0);
        double hourlyTTL = ttl.toHours();
        double estimatedCost = sizeInGB * costPerGB * hourlyTTL;

        Timer.Sample sample = Timer.start(meterRegistry);
        sample.stop(Timer.builder("cache.storage.cost")
            .description("캐시 저장 비용")
            .tag("tier", extractTier(key))
            .register(meterRegistry));

        Gauge.builder("cache.storage.size")
            .description("캐시 저장 크기")
            .tag("key", key)
            .register(meterRegistry, () -> size);
    }

    @Scheduled(cron = "0 0 1 * * *") // 매일 새벽 1시
    public void optimizeCacheStorage() {
        // 사용률이 낮은 캐시 데이터 정리
        Set<String> keys = redisTemplate.keys("*");

        keys.parallelStream()
            .filter(this::isLowUsageKey)
            .forEach(key -> {
                redisTemplate.delete(key);
                log.info("저사용률 캐시 삭제: {}", key);
            });
    }

    private boolean isLowUsageKey(String key) {
        // 접근 빈도 확인 로직
        Long ttl = redisTemplate.getExpire(key);
        if (ttl == null || ttl < 0) {
            return false;
        }

        // 마지막 접근 시간 확인
        String lastAccessKey = "last_access:" + key;
        String lastAccess = (String) redisTemplate.opsForValue().get(lastAccessKey);

        if (lastAccess == null) {
            return true;
        }

        LocalDateTime lastAccessTime = LocalDateTime.parse(lastAccess);
        return lastAccessTime.isBefore(LocalDateTime.now().minusHours(24));
    }
}

---

🔒 보안 및 운영 고려사항

Redis 보안 강화

@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class SecureRedisConfig {

    @Value("${app.redis.password}")
    private String redisPassword;

    @Bean
    public LettuceConnectionFactory secureRedisConnectionFactory() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName("localhost");
        config.setPort(6379);
        config.setPassword(redisPassword);

        // SSL 설정
        LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
            .useSsl()
            .and()
            .commandTimeout(Duration.ofSeconds(5))
            .build();

        return new LettuceConnectionFactory(config, clientConfig);
    }

    @Bean
    public RedisTemplate<String, Object> secureRedisTemplate(
            RedisConnectionFactory connectionFactory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        // 암호화된 직렬화 설정
        template.setDefaultSerializer(new EncryptedJsonSerializer());

        return template;
    }
}

// 암호화 직렬화 클래스
public class EncryptedJsonSerializer implements RedisSerializer<Object> {

    private final GenericJackson2JsonRedisSerializer jsonSerializer;
    private final AESUtil aesUtil;

    public EncryptedJsonSerializer() {
        this.jsonSerializer = new GenericJackson2JsonRedisSerializer();
        this.aesUtil = new AESUtil();
    }

    @Override
    public byte[] serialize(Object obj) throws SerializationException {
        if (obj == null) {
            return new byte[0];
        }

        byte[] jsonBytes = jsonSerializer.serialize(obj);

        // 민감 데이터 암호화
        if (containsSensitiveData(obj)) {
            return aesUtil.encrypt(jsonBytes);
        }

        return jsonBytes;
    }

    @Override
    public Object deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length == 0) {
            return null;
        }

        // 암호화 여부 확인 후 복호화
        if (aesUtil.isEncrypted(bytes)) {
            bytes = aesUtil.decrypt(bytes);
        }

        return jsonSerializer.deserialize(bytes);
    }

    private boolean containsSensitiveData(Object obj) {
        // 민감 데이터 포함 여부 확인 로직
        return obj.getClass().isAnnotationPresent(Sensitive.class);
    }
}

운영 환경 모니터링 대시보드

@RestController
@RequestMapping("/admin/cache")
@RequiredArgsConstructor
public class CacheMonitoringController {

    private final RedisTemplate<String, Object> redisTemplate;
    private final MeterRegistry meterRegistry;

    @GetMapping("/stats")
    public ResponseEntity<CacheStats> getCacheStats() {
        Properties info = redisTemplate.getConnectionFactory()
            .getConnection().info();

        CacheStats stats = CacheStats.builder()
            .usedMemory(Long.parseLong(info.getProperty("used_memory")))
            .connectedClients(Integer.parseInt(info.getProperty("connected_clients")))
            .totalCommandsProcessed(Long.parseLong(info.getProperty("total_commands_processed")))
            .cacheHitRate(calculateHitRate())
            .build();

        return ResponseEntity.ok(stats);
    }

    @GetMapping("/keys/{pattern}")
    public ResponseEntity<List<String>> getKeysByPattern(@PathVariable String pattern) {
        Set<String> keys = redisTemplate.keys(pattern);
        return ResponseEntity.ok(new ArrayList<>(keys));
    }

    @DeleteMapping("/keys/{pattern}")
    public ResponseEntity<Integer> deleteKeysByPattern(@PathVariable String pattern) {
        Set<String> keys = redisTemplate.keys(pattern);
        Long deleted = redisTemplate.delete(keys);
        return ResponseEntity.ok(deleted.intValue());
    }

    private double calculateHitRate() {
        Counter hitCounter = meterRegistry.find("cache.hit").counter();
        Counter missCounter = meterRegistry.find("cache.miss").counter();

        if (hitCounter != null && missCounter != null) {
            double hits = hitCounter.count();
            double misses = missCounter.count();
            return hits / (hits + misses) * 100;
        }

        return 0.0;
    }
}

---

🎯 팀 차원의 캐싱 전략 및 문화

캐싱 가이드라인 및 코드 리뷰 체크리스트

// 캐싱 어노테이션 활용 가이드
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CacheGuideline {

    /**
     * 캐시 사용 이유
     */
    String reason();

    /**
     * 예상 히트율
     */
    String expectedHitRate() default "80%";

    /**
     * 리뷰 포인트
     */
    String[] reviewPoints() default {};
}

// 사용 예시
@Service
public class ProductService {

    @CacheGuideline(
        reason = "상품 정보는 자주 변경되지 않으며 조회 빈도가 높음",
        expectedHitRate = "90%",
        reviewPoints = {"TTL 설정이 적절한가?", "캐시 무효화 전략이 있는가?"}
    )
    @Cacheable(value = "products", key = "#id")
    public ProductResponse getProduct(Long id) {
        // 구현
    }
}

캐싱 성능 리포트 자동화

@Component
@RequiredArgsConstructor
@Slf4j
public class CachePerformanceReporter {

    private final MeterRegistry meterRegistry;
    private final EmailService emailService;

    @Scheduled(cron = "0 0 9 * * MON") // 매주 월요일 9시
    public void sendWeeklyReport() {
        CachePerformanceReport report = generateWeeklyReport();

        String reportContent = formatReport(report);
        emailService.sendToTeam("주간 캐시 성능 리포트", reportContent);

        log.info("주간 캐시 성능 리포트 전송 완료");
    }

    private CachePerformanceReport generateWeeklyReport() {
        // 지난 주 메트릭 수집
        double avgHitRate = getAverageHitRate();
        long totalRequests = getTotalRequests();
        double avgResponseTime = getAverageResponseTime();

        return CachePerformanceReport.builder()
            .period("지난 주")
            .averageHitRate(avgHitRate)
            .totalRequests(totalRequests)
            .averageResponseTime(avgResponseTime)
            .recommendations(generateRecommendations(avgHitRate))
            .build();
    }

    private List<String> generateRecommendations(double hitRate) {
        List<String> recommendations = new ArrayList<>();

        if (hitRate < 80) {
            recommendations.add("캐시 히트율이 낮습니다. TTL 설정을 검토해보세요.");
        }

        if (hitRate > 95) {
            recommendations.add("캐시 히트율이 매우 높습니다. TTL을 늘려 메모리를 절약할 수 있습니다.");
        }

        return recommendations;
    }
}

---

📚 결론 및 다음 단계

Spring Boot에서 Redis 캐시를 효과적으로 활용하는 것은 단순한 성능 최적화를 넘어 비즈니스 경쟁력을 확보하는 핵심 전략입니다.

핵심 성공 요인

1. 적절한 전략 선택: 서비스 특성에 맞는 캐싱 전략 적용
2. 지속적인 모니터링: 캐시 성능 지표 추적 및 최적화
3. 팀 차원의 접근: 캐싱 문화 구축 및 가이드라인 수립
4. 보안 고려: 민감 데이터 보호 및 접근 제어

실무 적용 로드맵

1단계 (1-2주): 기본 캐싱 적용

• @Cacheable 어노테이션으로 주요 API 캐싱
• 기본 모니터링 설정

2단계 (3-4주): 고도화

• RedisTemplate 활용한 세밀한 제어
• 캐시 무효화 전략 구축

3단계 (5-8주): 최적화

• 다중 레벨 캐싱 적용
• 성능 최적화 및 비용 절감

추가 학습 자료

• Spring Boot 공식 캐싱 가이드
• Redis 성능 최적화 문서
• Caffeine 캐시 라이브러리

Redis 캐시를 통한 성능 개선은 사용자 경험 향상과 비즈니스 성장을 위한 필수 투자입니다.

오늘부터 단계적으로 적용해보시기 바랍니다.