Redis와 캐싱, 왜 필요하고 어떻게 써야 할까

1
@RestController
2
class StreamController {
3
    @Autowired
4
    private StreamRepository streamRepository;
5

6
    @GetMapping("/api/streams/popular")
7
    List<Stream> getPopularStreams() {
8
        // 매번 DB 조회
9
        return streamRepository.findTop10ByOrderByViewersDesc();
10
    }
11
}

1
1초 동안의 처리:
2
- 요청 500개
3
- DB 쿼리 500번 (각 10ms)
4
- 총 DB 시간: 5000ms (5초!)
5
- 커넥션 풀 고갈 위험
6

7
실제로는:
8
- 데이터가 1분마다 바뀜
9
- 59초 동안은 같은 데이터를 반복 조회
10
- 499번은 불필요한 쿼리!

1
// 간단한 메모리 캐시
2
class SimpleCache {
3
    private Map<String, Object> cache = new HashMap<>();
4
    private Map<String, Long> expireTime = new HashMap<>();
5

6
    void put(String key, Object value, long ttlSeconds) {
7
        cache.put(key, value);
8
        expireTime.put(key, System.currentTimeMillis() + (ttlSeconds * 1000));
9
    }
10

11
    Object get(String key) {
12
        // 만료 확인
13
        Long expire = expireTime.get(key);
14
        if (expire != null && System.currentTimeMillis() > expire) {
15
            cache.remove(key);
16
            expireTime.remove(key);
17
            return null;
18
        }
19
        return cache.get(key);
20
    }
21
}

1
캐시 적용 후:
2
- 첫 번째 요청: DB 조회 (10ms) + 캐시 저장
3
- 2~500번째 요청: 캐시 조회 (0.01ms)
4
- 총 시간: 10ms + (499 × 0.01ms) = 15ms
5
- 성능 향상: 약 333배!

1
// 2000년대 초반 스타일
2
class LocalCache {
3
    private static Map<String, Object> cache = new HashMap<>();
4

5
    static Object get(String key) {
6
        return cache.get(key);
7
    }
8

9
    static void put(String key, Object value) {
10
        cache.put(key, value);
11
    }
12
}

1
// Memcached 사용
2
MemcachedClient client = new MemcachedClient(
3
    new InetSocketAddress("localhost", 11211)
4
);
5

6
// 저장 (10분 TTL)
7
client.set("user:123", 600, userObject);
8

9
// 조회
10
User user = (User) client.get("user:123");

1
Redis의 성능:
2
- GET/SET: 초당 100,000 ops
3
- Memcached: 초당 100,000+ ops (멀티스레드, 단순 key-value에 특화)
4
- MySQL: 초당 1,000 ops
5

6
Redis vs MySQL: 100배 이상 차이!
7
(Redis를 선택하는 이유는 속도보다 다양한 서버 사이드 자료구조 지원이 핵심이다)

1
// Memcached: 문자열만
2
client.set("counter", "100");
3
String val = (String) client.get("counter");
4
int counter = Integer.parseInt(val) + 1;  // 애플리케이션에서 계산
5
client.set("counter", String.valueOf(counter));
6

7
// Redis: 원자적 연산 지원
8
redis.incr("counter");  // 한 번에 증가!

1
// Memcached: 리스트 직접 구현
2
List<String> list = (List<String>) client.get("list");
3
list.add("new item");
4
client.set("list", list);
5

6
// Redis: 리스트 자료구조 내장
7
redis.lpush("list", "new item");  // 리스트 왼쪽에 추가

1
# Spring Boot 설정 (Spring Boot 3.x부터 spring.data.redis.* 사용)
2
spring:
3
  data:
4
    redis:
5
      host: localhost
6
      port: 6379
7
  cache:
8
    type: redis

1
@Configuration
2
@EnableCaching
3
public class CacheConfig {
4
    @Bean
5
    public CacheManager cacheManager(RedisConnectionFactory factory) {
6
        return RedisCacheManager.builder(factory).build();
7
    }
8
}
9

10
@Service
11
class UserService {
12
    @Cacheable("users")  // 자동 캐싱!
13
    public User getUser(Long id) {
14
        return userRepository.findById(id).orElseThrow();
15
    }
16
}

1
// 단순 값 저장
2
redis.set("user:123:name", "홍길동");
3
String name = redis.get("user:123:name");
4

5
// TTL 설정 (10분)
6
redis.setex("session:abc", 600, "user-data");
7

8
// 원자적 증가
9
redis.incr("page:views");      // 1 증가
10
redis.incrby("page:views", 5); // 5 증가

1
// 최근 본 방송 10개
2
redis.lpush("user:123:recent-streams", "stream-1");
3
redis.lpush("user:123:recent-streams", "stream-2");
4
redis.lpush("user:123:recent-streams", "stream-3");
5

6
// 최근 10개만 유지
7
redis.ltrim("user:123:recent-streams", 0, 9);
8

9
// 조회
10
List<String> recent = redis.lrange("user:123:recent-streams", 0, 9);

1
// 온라인 사용자
2
redis.sadd("online-users", "user:123");
3
redis.sadd("online-users", "user:456");
4

5
// 멤버인지 확인 (O(1))
6
boolean isOnline = redis.sismember("online-users", "user:123");
7

8
// 전체 온라인 사용자 수
9
long count = redis.scard("online-users");
10

11
// 집합 연산
12
Set<String> commonFriends = redis.sinter("user:123:friends", "user:456:friends");

1
// 실시간 순위 (점수, 멤버)
2
redis.zadd("stream-ranking", 1000, "stream-1");  // 시청자 1000명
3
redis.zadd("stream-ranking", 500, "stream-2");   // 시청자 500명
4
redis.zadd("stream-ranking", 2000, "stream-3");  // 시청자 2000명
5

6
// Top 10 조회 (높은 순)
7
Set<String> top10 = redis.zrevrange("stream-ranking", 0, 9);
8
// 결과: [stream-3, stream-1, stream-2]
9

10
// 순위 조회
11
long rank = redis.zrevrank("stream-ranking", "stream-1");  // 1 (2등)
12

13
// 점수 증가
14
redis.zincrby("stream-ranking", 100, "stream-2");  // 500 → 600

1
// 사용자 정보 저장
2
Map<String, String> user = new HashMap<>();
3
user.put("name", "홍길동");
4
user.put("age", "25");
5
user.put("email", "hong@example.com");
6

7
redis.hset("user:123", user);
8

9
// 특정 필드만 조회
10
String name = redis.hget("user:123", "name");
11

12
// 전체 조회
13
Map<String, String> userData = redis.hgetall("user:123");
14

15
// 필드 하나만 업데이트
16
redis.hset("user:123", "age", "26");

1
dependencies {
2
    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
3
    implementation 'org.springframework.boot:spring-boot-starter-cache'
4
}

1
# Spring Boot 3.x부터 spring.data.redis.* 사용
2
spring:
3
  data:
4
    redis:
5
      host: localhost
6
      port: 6379
7
      password: # 비밀번호 (선택)
8
      timeout: 3000ms
9
      lettuce:
10
        pool:
11
          max-active: 10  # 최대 커넥션
12
          max-idle: 10    # 유휴 커넥션
13
          min-idle: 2     # 최소 커넥션
14
  cache:
15
    type: redis
16
    redis:
17
      time-to-live: 600000  # 10분 (밀리초)

1
@Configuration
2
public class RedisConfig {
3

4
    @Bean
5
    public RedisTemplate<String, Object> redisTemplate(
6
            RedisConnectionFactory connectionFactory) {
7
        RedisTemplate<String, Object> template = new RedisTemplate<>();
8
        template.setConnectionFactory(connectionFactory);
9

10
        // JSON 직렬화
11
        // Object.class로 Jackson2JsonRedisSerializer를 생성하면 역직렬화 시 LinkedHashMap으로 반환된다
12
        GenericJackson2JsonRedisSerializer serializer =
13
            new GenericJackson2JsonRedisSerializer();
14

15
        template.setKeySerializer(new StringRedisSerializer());
16
        template.setValueSerializer(serializer);
17
        template.setHashKeySerializer(new StringRedisSerializer());
18
        template.setHashValueSerializer(serializer);
19

20
        return template;
21
    }
22
}

1
@Service
2
class StreamService {
3
    @Autowired
4
    private RedisTemplate<String, Object> redisTemplate;
5

6
    // 인기 방송 캐싱
7
    public List<Stream> getPopularStreams() {
8
        String key = "popular-streams";
9

10
        // 1. 캐시 확인
11
        List<Stream> cached = (List<Stream>) redisTemplate.opsForValue().get(key);
12
        if (cached != null) {
13
            return cached;  // 캐시 히트!
14
        }
15

16
        // 2. DB 조회
17
        List<Stream> streams = streamRepository.findTop10ByOrderByViewersDesc();
18

19
        // 3. 캐시 저장 (5분)
20
        redisTemplate.opsForValue().set(key, streams, 5, TimeUnit.MINUTES);
21

22
        return streams;
23
    }
24
}

1
@Configuration
2
@EnableCaching
3
public class CacheConfig {
4

5
    @Bean
6
    public CacheManager cacheManager(RedisConnectionFactory factory) {
7
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
8
            .entryTtl(Duration.ofMinutes(10))  // 기본 TTL: 10분
9
            .serializeKeysWith(
10
                RedisSerializationContext.SerializationPair
11
                    .fromSerializer(new StringRedisSerializer())
12
            )
13
            // Object.class로 Jackson2JsonRedisSerializer를 생성하면 역직렬화 시 LinkedHashMap으로 반환된다
14
            .serializeValuesWith(
15
                RedisSerializationContext.SerializationPair
16
                    .fromSerializer(new GenericJackson2JsonRedisSerializer())
17
            );
18

19
        return RedisCacheManager.builder(factory)
20
            .cacheDefaults(config)
21
            .build();
22
    }
23
}

1
@Service
2
class UserService {
3

4
    // 캐시에 저장 (키: users::123)
5
    @Cacheable(value = "users", key = "#id")
6
    public User getUser(Long id) {
7
        return userRepository.findById(id)
8
            .orElseThrow(() -> new UserNotFoundException(id));
9
    }
10

11
    // 캐시 업데이트
12
    @CachePut(value = "users", key = "#user.id")
13
    public User updateUser(User user) {
14
        return userRepository.save(user);
15
    }
16

17
    // 캐시 삭제
18
    @CacheEvict(value = "users", key = "#id")
19
    public void deleteUser(Long id) {
20
        userRepository.deleteById(id);
21
    }
22

23
    // 전체 캐시 삭제
24
    @CacheEvict(value = "users", allEntries = true)
25
    public void deleteAllUsers() {
26
        userRepository.deleteAll();
27
    }
28
}

1
@Service
2
class CategoryService {
3
    @Cacheable("categories")
4
    public List<Category> getAllCategories() {
5
        // 카테고리는 거의 안 바뀜 (한 달에 한 번?)
6
        // 하지만 매 페이지마다 조회됨
7
        return categoryRepository.findAll();
8
    }
9
}

1
// 이 코드는 Redis든, Caffeine이든, EhCache든 똑같이 동작
2
@Cacheable("users")
3
public User getUser(Long id) {
4
    return userRepository.findById(id).orElseThrow();
5
}

1
dependencies {
2
    implementation 'org.springframework.boot:spring-boot-starter-cache'
3
    implementation 'com.github.ben-manes.caffeine:caffeine:3.1.8'
4
}

1
@Configuration
2
@EnableCaching
3
public class CacheConfig {
4

5
    @Bean
6
    public CacheManager cacheManager() {
7
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
8
        cacheManager.setCaffeine(Caffeine.newBuilder()
9
            .initialCapacity(100)         // 초기 용량
10
            .maximumSize(1000)            // 최대 1000개
11
            .expireAfterWrite(10, TimeUnit.MINUTES)  // 10분 후 만료
12
            .recordStats());              // 통계 기록
13

14
        return cacheManager;
15
    }
16
}

1
# application.yml (간단 버전)
2
spring:
3
  cache:
4
    type: caffeine
5
    caffeine:
6
      spec: maximumSize=1000,expireAfterWrite=10m
7
    cache-names:
8
      - users
9
      - categories
10
      - streams

1
@Service
2
class CategoryService {
3

4
    @Cacheable("categories")
5
    public List<Category> getAllCategories() {
6
        // 첫 요청: DB 조회 후 로컬 메모리에 저장
7
        // 이후 10분간: 메모리에서 즉시 반환
8
        return categoryRepository.findAll();
9
    }
10

11
    @CacheEvict(value = "categories", allEntries = true)
12
    public void refreshCategories() {
13
        // 관리자가 카테고리 변경 시 캐시 초기화
14
    }
15
}

1
@Test
2
void cachePerformanceTest() {
3
    // 첫 요청 (Cache Miss)
4
    long start1 = System.currentTimeMillis();
5
    categoryService.getAllCategories();
6
    long time1 = System.currentTimeMillis() - start1;
7

8
    // 두 번째 요청 (Cache Hit)
9
    long start2 = System.currentTimeMillis();
10
    categoryService.getAllCategories();
11
    long time2 = System.currentTimeMillis() - start2;
12

13
    System.out.println("첫 요청: " + time1 + "ms");  // 15ms
14
    System.out.println("캐시 히트: " + time2 + "ms");  // 0ms
15
}

1
@Bean
2
public CacheManager cacheManager() {
3
    CaffeineCacheManager cacheManager = new CaffeineCacheManager();
4

5
    // 캐시별로 다른 설정 가능
6
    Map<String, CaffeineCache> caches = new HashMap<>();
7

8
    // 사용자 정보: 접근 후 10분간 유지
9
    caches.put("users", buildCache(Caffeine.newBuilder()
10
        .expireAfterAccess(10, TimeUnit.MINUTES)
11
        .maximumSize(1000)));
12

13
    // 카테고리: 쓰기 후 1시간 유지
14
    caches.put("categories", buildCache(Caffeine.newBuilder()
15
        .expireAfterWrite(1, TimeUnit.HOURS)
16
        .maximumSize(100)));
17

18
    // 인기 방송: 크기 기반 만료 (최대 500개)
19
    caches.put("popular-streams", buildCache(Caffeine.newBuilder()
20
        .maximumSize(500)
21
        .expireAfterWrite(1, TimeUnit.MINUTES)));
22

23
    cacheManager.setCacheNames(caches.keySet());
24
    return cacheManager;
25
}
26

27
private CaffeineCache buildCache(Caffeine<Object, Object> builder) {
28
    return new CaffeineCache("cache", builder.build());
29
}

1
// expireAfterWrite: 작성 후 10분
2
Caffeine.newBuilder()
3
    .expireAfterWrite(10, TimeUnit.MINUTES)
4
    // 시간: 0분 -> 조회 -> 5분 -> 조회 -> 11분
5
    // 결과: 0분에 캐싱, 11분에 만료 (조회 무관)
6

7
// expireAfterAccess: 마지막 접근 후 10분
8
Caffeine.newBuilder()
9
    .expireAfterAccess(10, TimeUnit.MINUTES)
10
    // 시간: 0분 -> 조회 -> 5분 -> 조회 -> 11분 -> 조회
11
    // 결과: 5분에 조회했으니 15분까지 유지 (계속 연장됨)
12

13
// 커스텀 만료: 동적 TTL
14
Caffeine.newBuilder()
15
    .expireAfter(new Expiry<String, User>() {
16
        public long expireAfterCreate(String key, User user, long currentTime) {
17
            // VIP는 1시간, 일반은 10분
18
            return user.isVip()
19
                ? TimeUnit.HOURS.toNanos(1)
20
                : TimeUnit.MINUTES.toNanos(10);
21
        }
22
    })

1
@Configuration
2
@EnableCaching
3
public class CacheConfig {
4

5
    @Bean
6
    @Primary  // 기본은 Redis
7
    public CacheManager redisCacheManager(RedisConnectionFactory factory) {
8
        return RedisCacheManager.builder(factory)
9
            .cacheDefaults(RedisCacheConfiguration.defaultCacheConfig()
10
                .entryTtl(Duration.ofMinutes(10)))
11
            .build();
12
    }
13

14
    @Bean
15
    public CacheManager localCacheManager() {
16
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
17
        cacheManager.setCaffeine(Caffeine.newBuilder()
18
            .maximumSize(1000)
19
            .expireAfterWrite(10, TimeUnit.MINUTES));
20
        return cacheManager;
21
    }
22
}

1
@Service
2
class CachingService {
3

4
    // 로컬 캐시: 변경 거의 없고, 서버마다 달라도 괜찮음
5
    @Cacheable(value = "categories", cacheManager = "localCacheManager")
6
    public List<Category> getCategories() {
7
        return categoryRepository.findAll();
8
    }
9

10
    // Redis: 서버 간 공유 필요
11
    @Cacheable(value = "users", cacheManager = "redisCacheManager")
12
    public User getUser(Long id) {
13
        return userRepository.findById(id).orElseThrow();
14
    }
15
}

1
@Configuration
2
@EnableCaching
3
public class CacheConfig {
4

5
    @Bean
6
    public CacheManager cacheManager() {
7
        CaffeineCacheManager manager = new CaffeineCacheManager();
8
        manager.setCaffeine(Caffeine.newBuilder()
9
            .maximumSize(1000)
10
            .expireAfterWrite(10, TimeUnit.MINUTES)
11
            .recordStats());  // 통계 기록 활성화
12
        return manager;
13
    }
14
}

1
@RestController
2
class CacheStatsController {
3

4
    @Autowired
5
    private CacheManager cacheManager;
6

7
    @GetMapping("/cache/stats")
8
    public Map<String, CacheStats> getCacheStats() {
9
        Map<String, CacheStats> stats = new HashMap<>();
10

11
        for (String cacheName : cacheManager.getCacheNames()) {
12
            Cache cache = cacheManager.getCache(cacheName);
13
            if (cache instanceof CaffeineCache) {
14
                CaffeineCache caffeineCache = (CaffeineCache) cache;
15
                com.github.benmanes.caffeine.cache.Cache<Object, Object> nativeCache =
16
                    caffeineCache.getNativeCache();
17

18
                CacheStats cacheStats = nativeCache.stats();
19
                stats.put(cacheName, cacheStats);
20
            }
21
        }
22

23
        return stats;
24
    }
25
}

1
// 결과
2
{
3
  "categories": {
4
    "hitCount": 9850,
5
    "missCount": 150,
6
    "hitRate": 0.985,  // 98.5% 히트율!
7
    "evictionCount": 0
8
  }
9
}

1
@Service
2
class ProductService {
3
    @Autowired
4
    private RedisTemplate<String, Product> redis;
5

6
    @Autowired
7
    private ProductRepository repository;
8

9
    public Product getProduct(Long id) {
10
        String key = "product:" + id;
11

12
        // 1. 캐시 확인
13
        Product cached = redis.opsForValue().get(key);
14
        if (cached != null) {
15
            return cached;  // Cache Hit
16
        }
17

18
        // 2. DB 조회 (Cache Miss)
19
        Product product = repository.findById(id)
20
            .orElseThrow(() -> new NotFoundException(id));
21

22
        // 3. 캐시 저장
23
        redis.opsForValue().set(key, product, 1, TimeUnit.HOURS);
24

25
        return product;
26
    }
27
}

1
// Read-Through: 캐시 라이브러리가 로딩을 담당
2
// Caffeine의 LoadingCache가 대표적인 Read-Through 구현
3
LoadingCache<Long, Product> productCache = Caffeine.newBuilder()
4
    .expireAfterWrite(1, TimeUnit.HOURS)
5
    .build(id -> repository.findById(id)  // 캐시 미스 시 자동으로 호출됨
6
        .orElseThrow(() -> new NotFoundException(id)));
7

8
// 사용: 항상 캐시에만 요청
9
Product product = productCache.get(productId);

1
@Service
2
class ProductService {
3
    public Product updateProduct(Product product) {
4
        // 1. DB 업데이트
5
        Product saved = repository.save(product);
6

7
        // 2. 캐시 업데이트
8
        String key = "product:" + product.getId();
9
        redis.opsForValue().set(key, saved, 1, TimeUnit.HOURS);
10

11
        return saved;
12
    }
13
}

1
@Service
2
class ViewCountService {
3
    @Autowired
4
    private RedisTemplate<String, Long> redis;
5

6
    // 조회수 증가 (캐시만)
7
    public void incrementView(Long streamId) {
8
        String key = "stream:" + streamId + ":views";
9
        redis.opsForValue().increment(key);
10
    }
11

12
    // 주기적으로 DB 반영 (1분마다)
13
    @Scheduled(fixedDelay = 60000)
14
    public void syncToDatabase() {
15
        // `KEYS` 명령은 O(N) 블로킹이므로 프로덕션에서는 반드시 `SCAN`을 사용해야 한다
16
        ScanOptions scanOptions = ScanOptions.scanOptions().match("stream:*:views").count(100).build();
17
        try (Cursor<String> cursor = redis.scan(scanOptions)) {
18
            while (cursor.hasNext()) {
19
                String key = cursor.next();
20
                Long streamId = extractStreamId(key);
21

22
                // GETDEL로 읽기와 삭제를 원자적으로 수행 (Redis 6.2+)
23
                Long views = redis.opsForValue().getAndDelete(key);
24
                if (views != null) {
25
                    streamRepository.updateViews(streamId, views);
26
                }
27
            }
28
        }
29
    }
30
}

1
// 문제 상황
2
@Cacheable(value = "popular", key = "'streams'")
3
public List<Stream> getPopularStreams() {
4
    // TTL 10분
5
    return streamRepository.findTop10ByOrderByViewersDesc();
6
}
7

8
// 10분 후 캐시 만료
9
// → 동시에 100개 요청 들어옴
10
// → 100개 모두 DB 조회!
11
// → DB 폭발!

1
@Service
2
class StreamService {
3
    private final LoadingCache<String, List<Stream>> cache = Caffeine.newBuilder()
4
        .expireAfterWrite(10, TimeUnit.MINUTES)
5
        .build(key -> {
6
            // 여러 요청이 동시에 와도
7
            // 첫 번째만 실행됨!
8
            return streamRepository.findTop10ByOrderByViewersDesc();
9
        });
10

11
    public List<Stream> getPopularStreams() {
12
        return cache.get("popular-streams");
13
    }
14
}

1
@Service
2
class StreamService {
3
    public List<Stream> getPopularStreams() {
4
        String cacheKey = "popular-streams";
5
        String lockKey = "lock:popular-streams";
6

7
        // 1. 캐시 확인
8
        List<Stream> cached = redis.get(cacheKey);
9
        if (cached != null) return cached;
10

11
        // 2. Lock 획득 시도 (5초 대기)
12
        Boolean acquired = redis.setIfAbsent(lockKey, "1", 5, TimeUnit.SECONDS);
13

14
        if (Boolean.TRUE.equals(acquired)) {
15
            try {
16
                // Lock 획득 성공 → DB 조회
17
                List<Stream> streams = streamRepository.findTop10();
18
                redis.set(cacheKey, streams, 10, TimeUnit.MINUTES);
19
                return streams;
20
            } finally {
21
                redis.delete(lockKey);
22
            }
23
        } else {
24
            // Lock 획득 실패 → 잠시 대기 후 재시도 (최대 3회)
25
            int retries = 0;
26
            while (retries < 3) {
27
                Thread.sleep(100);
28
                cached = redis.get(cacheKey);
29
                if (cached != null) return cached;
30
                retries++;
31
            }
32
            throw new RuntimeException("캐시 갱신 대기 시간 초과");
33
        }
34
    }
35
}

1
// 공격 시나리오
2
for (int i = 0; i < 10000; i++) {
3
    getUser(9999999 + i);  // 존재하지 않는 사용자
4
    // → 캐시 Miss
5
    // → DB 조회
6
    // → 데이터 없음
7
    // → 캐시 안 함
8
    // → 반복!
9
}

1
@Service
2
class UserService {
3
    public User getUser(Long id) {
4
        String key = "user:" + id;
5

6
        // 캐시 확인 (get 1번으로 통합 — hasKey + get 2번 호출은 불필요한 RTT 발생)
7
        Object cached = redis.opsForValue().get(key);
8
        if (cached != null) {
9
            // "없음"이 캐싱된 경우 → DB로 안 가고 동일하게 not-found 처리
10
            if (cached instanceof NullValue) throw new UserNotFoundException(id);
11
            return (User) cached;
12
        }
13

14
        // DB 조회
15
        Optional<User> user = repository.findById(id);
16

17
        if (user.isPresent()) {
18
            // 있으면 1시간 캐싱
19
            redis.set(key, user.get(), 1, TimeUnit.HOURS);
20
            return user.get();
21
        } else {
22
            // 없음도 5분 캐싱 — 단, raw null이 아니라 NullValue '마커'를 저장한다.
23
            // (null을 그대로 넣으면 읽을 때 NullValue로 복원된다는 보장이 없어
24
            //  캐시 미스로 취급 → 관통 방어가 무력화됨)
25
            redis.set(key, NullValue.INSTANCE, 5, TimeUnit.MINUTES);
26
            throw new UserNotFoundException(id);
27
        }
28
    }
29
}

1
@Service
2
class UserService {
3
    private BloomFilter<Long> userIds = BloomFilter.create(
4
        Funnels.longFunnel(),
5
        1000000,  // 예상 개수
6
        0.01      // 오류율 1%
7
    );
8

9
    @PostConstruct
10
    void init() {
11
        // 시작 시 모든 사용자 ID 로딩
12
        List<Long> ids = repository.findAllIds();
13
        ids.forEach(userIds::put);
14
    }
15

16
    public User getUser(Long id) {
17
        // Bloom Filter 확인
18
        if (!userIds.mightContain(id)) {
19
            // 100% 없음!
20
            throw new UserNotFoundException(id);
21
        }
22

23
        // 나머지는 기존 로직
24
        // (Bloom Filter: 있다고 했지만 실제로 없을 수 있음, 1% 확률)
25
        return getUserFromCacheOrDB(id);
26
    }
27
}

1
// 문제 코드
2
for (Product product : products) {
3
    redis.set("product:" + product.getId(),
4
              product,
5
              1, TimeUnit.HOURS);  // 모두 같은 TTL!
6
}
7

8
// 1시간 후
9
// → 모든 캐시 동시 만료
10
// → DB에 동시에 수천 개 쿼리
11
// → 장애!

1
@Service
2
class ProductService {
3
    public void cacheProduct(Product product) {
4
        // 1시간 + 랜덤(0~10분)
5
        long ttl = 3600 + ThreadLocalRandom.current().nextInt(0, 600);
6

7
        redis.set("product:" + product.getId(),
8
                  product,
9
                  ttl, TimeUnit.SECONDS);
10
    }
11
}

1
@Service
2
class VideoViewService {
3
    // 조회수 증가 (Redis에만 저장, 초당 수만 건)
4
    public void incrementView(String videoId) {
5
        redis.incr("video:" + videoId + ":views");
6
    }
7

8
    // 1분마다 DB에 배치 업데이트
9
    @Scheduled(fixedDelay = 60000)
10
    public void syncToDatabase() {
11
        // `KEYS` 명령은 O(N) 블로킹이므로 프로덕션에서는 반드시 `SCAN`을 사용해야 한다
12
        ScanOptions scanOptions = ScanOptions.scanOptions().match("video:*:views").count(100).build();
13
        List<VideoView> updates = new ArrayList<>();
14

15
        try (Cursor<String> cursor = redis.scan(scanOptions)) {
16
            while (cursor.hasNext()) {
17
                String key = cursor.next();
18
                String videoId = extractVideoId(key);
19
                Long views = redis.getAndDelete(key);  // 가져오고 삭제
20

21
                if (views != null) {
22
                    updates.add(new VideoView(videoId, views));
23
                }
24
            }
25
        }
26

27
        // 배치 업데이트 (1번의 쿼리로)
28
        videoRepository.batchUpdateViews(updates);
29
    }
30
}

1
@Service
2
class FeedService {
3
    // 사용자 피드 생성 (무거운 작업)
4
    public List<Post> generateFeed(Long userId) {
5
        String key = "feed:" + userId;
6

7
        // 캐시 확인 (15분 TTL)
8
        List<Post> cached = redis.get(key);
9
        if (cached != null) return cached;
10

11
        // 피드 생성 (팔로우한 사람들의 최근 게시물)
12
        List<Long> following = followRepository.findFollowingIds(userId);
13
        List<Post> posts = postRepository.findRecentByUserIds(following, 50);
14

15
        // 좋아요/댓글 수 추가 (N+1 방지)
16
        Map<Long, PostStats> stats = getStatsFromCache(posts);
17
        posts.forEach(post -> post.setStats(stats.get(post.getId())));
18

19
        redis.set(key, posts, 15, TimeUnit.MINUTES);
20
        return posts;
21
    }
22

23
    // 새 게시물 작성 시 팔로워들의 캐시 무효화
24
    public void invalidateFollowerFeeds(Long userId) {
25
        List<Long> followers = followRepository.findFollowerIds(userId);
26

27
        for (Long followerId : followers) {
28
            redis.delete("feed:" + followerId);
29
        }
30
    }
31
}