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

@RestController
class StreamController {
    @Autowired
    private StreamRepository streamRepository;

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

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

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

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

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

    Object get(String key) {
        // 만료 확인
        Long expire = expireTime.get(key);
        if (expire != null && System.currentTimeMillis() > expire) {
            cache.remove(key);
            expireTime.remove(key);
            return null;
        }
        return cache.get(key);
    }
}

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

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

    static Object get(String key) {
        return cache.get(key);
    }

    static void put(String key, Object value) {
        cache.put(key, value);
    }
}

// Memcached 사용
MemcachedClient client = new MemcachedClient(
    new InetSocketAddress("localhost", 11211)
);

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

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

Redis의 성능:
- GET/SET: 초당 100,000 ops
- Memcached: 초당 60,000 ops
- MySQL: 초당 1,000 ops

100배 이상 차이!

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

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

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

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

# Spring Boot 설정
spring:
  redis:
    host: localhost
    port: 6379
  cache:
    type: redis

@Configuration
@EnableCaching
public class CacheConfig {
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        return RedisCacheManager.builder(factory).build();
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

spring:
  redis:
    host: localhost
    port: 6379
    password: # 비밀번호 (선택)
    timeout: 3000ms
    lettuce:
      pool:
        max-active: 10  # 최대 커넥션
        max-idle: 10    # 유휴 커넥션
        min-idle: 2     # 최소 커넥션
  cache:
    type: redis
    redis:
      time-to-live: 600000  # 10분 (밀리초)

@Configuration
public class RedisConfig {

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

        // JSON 직렬화
        Jackson2JsonRedisSerializer<Object> serializer =
            new Jackson2JsonRedisSerializer<>(Object.class);

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

        return template;
    }
}

@Service
class StreamService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

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

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

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

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

        return streams;
    }
}

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10))  // 기본 TTL: 10분
            .serializeKeysWith(
                RedisSerializationContext.SerializationPair
                    .fromSerializer(new StringRedisSerializer())
            )
            .serializeValuesWith(
                RedisSerializationContext.SerializationPair
                    .fromSerializer(new Jackson2JsonRedisSerializer<>(Object.class))
            );

        return RedisCacheManager.builder(factory)
            .cacheDefaults(config)
            .build();
    }
}

@Service
class UserService {

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

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

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

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

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

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

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

@Configuration
@EnableCaching
public class CacheConfig {

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

        return cacheManager;
    }
}

# application.yml (간단 버전)
spring:
  cache:
    type: caffeine
    caffeine:
      spec: maximumSize=1000,expireAfterWrite=10m
    cache-names:
      - users
      - categories
      - streams

@Service
class CategoryService {

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

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

@Test
void cachePerformanceTest() {
    // 첫 요청 (Cache Miss)
    long start1 = System.currentTimeMillis();
    categoryService.getAllCategories();
    long time1 = System.currentTimeMillis() - start1;

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

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

@Bean
public CacheManager cacheManager() {
    CaffeineCacheManager cacheManager = new CaffeineCacheManager();

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

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

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

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

    cacheManager.setCacheNames(caches.keySet());
    return cacheManager;
}

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

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

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

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

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    @Primary  // 기본은 Redis
    public CacheManager redisCacheManager(RedisConnectionFactory factory) {
        return RedisCacheManager.builder(factory)
            .cacheDefaults(RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(10)))
            .build();
    }

    @Bean
    public CacheManager localCacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.MINUTES));
        return cacheManager;
    }
}

@Service
class CachingService {

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

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

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager manager = new CaffeineCacheManager();
        manager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .recordStats());  // 통계 기록 활성화
        return manager;
    }
}

@RestController
class CacheStatsController {

    @Autowired
    private CacheManager cacheManager;

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

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

                CacheStats cacheStats = nativeCache.stats();
                stats.put(cacheName, cacheStats);
            }
        }

        return stats;
    }
}

// 결과
{
  "categories": {
    "hitCount": 9850,
    "missCount": 150,
    "hitRate": 0.985,  // 98.5% 히트율!
    "evictionCount": 0
  }
}

@Service
class ProductService {
    @Autowired
    private RedisTemplate<String, Product> redis;

    @Autowired
    private ProductRepository repository;

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

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

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

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

        return product;
    }
}

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

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

        return saved;
    }
}

@Service
class ViewCountService {
    @Autowired
    private RedisTemplate<String, Long> redis;

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

    // 주기적으로 DB 반영 (1분마다)
    @Scheduled(fixedDelay = 60000)
    public void syncToDatabase() {
        Set<String> keys = redis.keys("stream:*:views");

        for (String key : keys) {
            Long streamId = extractStreamId(key);
            Long views = redis.opsForValue().get(key);

            // DB 업데이트
            streamRepository.updateViews(streamId, views);

            // 캐시 삭제
            redis.delete(key);
        }
    }
}

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

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

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

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

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

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

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

        if (Boolean.TRUE.equals(acquired)) {
            try {
                // Lock 획득 성공 → DB 조회
                List<Stream> streams = streamRepository.findTop10();
                redis.set(cacheKey, streams, 10, TimeUnit.MINUTES);
                return streams;
            } finally {
                redis.delete(lockKey);
            }
        } else {
            // Lock 획득 실패 → 잠시 대기 후 재시도
            Thread.sleep(100);
            return getPopularStreams();
        }
    }
}

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

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

        // 캐시 확인
        if (redis.hasKey(key)) {
            User cached = redis.get(key);
            if (cached == null) {
                throw new UserNotFoundException(id);
            }
            return cached;
        }

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

        if (user.isPresent()) {
            // 있으면 1시간 캐싱
            redis.set(key, user.get(), 1, TimeUnit.HOURS);
            return user.get();
        } else {
            // 없어도 5분 캐싱 (null)
            redis.set(key, null, 5, TimeUnit.MINUTES);
            throw new UserNotFoundException(id);
        }
    }
}

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

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

    public User getUser(Long id) {
        // Bloom Filter 확인
        if (!userIds.mightContain(id)) {
            // 100% 없음!
            throw new UserNotFoundException(id);
        }

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

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

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

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

        redis.set("product:" + product.getId(),
                  product,
                  ttl, TimeUnit.SECONDS);
    }
}

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

    // 1분마다 DB에 배치 업데이트
    @Scheduled(fixedDelay = 60000)
    public void syncToDatabase() {
        Set<String> keys = redis.keys("video:*:views");

        List<VideoView> updates = new ArrayList<>();
        for (String key : keys) {
            String videoId = extractVideoId(key);
            Long views = redis.getAndDelete(key);  // 가져오고 삭제

            updates.add(new VideoView(videoId, views));
        }

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

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

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

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

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

        redis.set(key, posts, 15, TimeUnit.MINUTES);
        return posts;
    }

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

        for (Long followerId : followers) {
            redis.delete("feed:" + followerId);
        }
    }
}

@Service
class TrendService {
    // 해시태그 카운트 증가
    public void trackHashtag(String hashtag) {
        String key = "trend:" + getCurrentHour();  // trend:2024-11-09-15

        redis.zincrby(key, 1, hashtag);  // Sorted Set 점수 증가

        // 1시간 후 자동 삭제
        redis.expire(key, 1, TimeUnit.HOURS);
    }

    // 현재 시간 Top 10 트렌드
    public List<String> getTopTrends() {
        String key = "trend:" + getCurrentHour();

        // 상위 10개 (높은 점수 순)
        return redis.zrevrange(key, 0, 9);
    }
}

@Service
class LeaderboardService {
    // 점수 업데이트
    public void updateScore(Long userId, int score) {
        redis.zadd("leaderboard", score, "user:" + userId);
    }

    // Top 100 조회
    public List<RankEntry> getTop100() {
        Set<TypedTuple<String>> top = redis.zrevrangeWithScores("leaderboard", 0, 99);

        int rank = 1;
        List<RankEntry> result = new ArrayList<>();
        for (TypedTuple<String> entry : top) {
            result.add(new RankEntry(
                rank++,
                entry.getValue(),
                entry.getScore().intValue()
            ));
        }
        return result;
    }

    // 내 순위 조회
    public RankEntry getMyRank(Long userId) {
        String key = "user:" + userId;

        Long rank = redis.zrevrank("leaderboard", key);  // 순위
        Double score = redis.zscore("leaderboard", key);  // 점수

        if (rank == null) {
            return new RankEntry(-1, key, 0);  // 순위권 밖
        }

        return new RankEntry(rank.intValue() + 1, key, score.intValue());
    }
}

// 사용 예시
@Service
class StreamService {

    @Cacheable(value = "streams", key = "#id")
    public Stream getStream(Long id) {
        return streamRepository.findById(id).orElseThrow();
    }

    @CachePut(value = "streams", key = "#stream.id")
    public Stream updateStream(Stream stream) {
        return streamRepository.save(stream);
    }

    @CacheEvict(value = "streams", key = "#id")
    public void deleteStream(Long id) {
        streamRepository.deleteById(id);
    }
}

@RestController
class StreamController {
    @Autowired
    private StreamRepository streamRepository;

    @GetMapping("/api/streams/popular")
    List<Stream> getPopularStreams() {
        // Query DB every time
        return streamRepository.findTop10ByOrderByViewersDesc();
    }
}

Processing in 1 second:
- 500 requests
- 500 DB queries (10ms each)
- Total DB time: 5000ms (5 seconds!)
- Risk of connection pool exhaustion

In reality:
- Data changes every minute
- For 59 seconds, the same data is queried repeatedly
- 499 queries are unnecessary!

// Simple in-memory cache
class SimpleCache {
    private Map<String, Object> cache = new HashMap<>();
    private Map<String, Long> expireTime = new HashMap<>();

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

    Object get(String key) {
        // Check expiration
        Long expire = expireTime.get(key);
        if (expire != null && System.currentTimeMillis() > expire) {
            cache.remove(key);
            expireTime.remove(key);
            return null;
        }
        return cache.get(key);
    }
}

After applying cache:
- First request: DB query (10ms) + cache store
- Requests 2-500: Cache lookup (0.01ms)
- Total time: 10ms + (499 x 0.01ms) = 15ms
- Performance improvement: ~333x!

// Early 2000s style
class LocalCache {
    private static Map<String, Object> cache = new HashMap<>();

    static Object get(String key) {
        return cache.get(key);
    }

    static void put(String key, Object value) {
        cache.put(key, value);
    }
}

// Using Memcached
MemcachedClient client = new MemcachedClient(
    new InetSocketAddress("localhost", 11211)
);

// Store (10-minute TTL)
client.set("user:123", 600, userObject);

// Retrieve
User user = (User) client.get("user:123");

Redis Performance:
- GET/SET: 100,000 ops/sec
- Memcached: 60,000 ops/sec
- MySQL: 1,000 ops/sec

More than 100x difference!

// Memcached: Strings only
client.set("counter", "100");
String val = (String) client.get("counter");
int counter = Integer.parseInt(val) + 1;  // Computed in the application
client.set("counter", String.valueOf(counter));

// Redis: Atomic operations supported
redis.incr("counter");  // Increment in one step!

// Memcached: Manually implement lists
List<String> list = (List<String>) client.get("list");
list.add("new item");
client.set("list", list);

// Redis: Built-in list data structure
redis.lpush("list", "new item");  // Add to the left of the list