Redis 캐시 전략 패턴 정리

@Service
public class UserService {

    @Cacheable(value = "users", key = "#userId")
    public UserDto getUser(Long userId) {
        // Cache Miss 시에만 실행됨
        return userRepository.findById(userId)
            .map(UserDto::from)
            .orElseThrow();
    }

    @CacheEvict(value = "users", key = "#userId")
    public void updateUser(Long userId, UserDto dto) {
        User user = userRepository.findById(userId).orElseThrow();
        user.update(dto);
        userRepository.save(user);
    }
}

@Service
public class UserService {

    @CachePut(value = "users", key = "#result.id")
    public UserDto createUser(UserCreateDto dto) {
        User user = User.create(dto);
        User saved = userRepository.save(user);
        return UserDto.from(saved);
    }

    @CachePut(value = "users", key = "#userId")
    public UserDto updateUser(Long userId, UserDto dto) {
        User user = userRepository.findById(userId).orElseThrow();
        user.update(dto);
        User saved = userRepository.save(user);
        return UserDto.from(saved);
    }
}

@Service
public class ViewCountService {

    private final RedisTemplate<String, Long> redisTemplate;

    public void incrementViewCount(String articleId) {
        String key = "viewCount:" + articleId;
        redisTemplate.opsForValue().increment(key);
    }

    @Scheduled(fixedDelay = 60000)
    public void syncViewCountToDB() {
        ScanOptions options = ScanOptions.scanOptions()
            .match("viewCount:*")
            .count(1000)
            .build();

        try (Cursor<String> keys = redisTemplate.scan(options)) {
            while (keys.hasNext()) {
                String key = keys.next();
                Long count = redisTemplate.opsForValue().get(key);
                String articleId = key.replace("viewCount:", "");

                articleRepository.updateViewCount(articleId, count);
                redisTemplate.delete(key);
            }
        }
    }
}

@Service
public class PopularArticleService {

    @Cacheable(value = "popularArticles", key = "'top10'")
    public List<ArticleDto> getPopularArticles() {
        return articleRepository.findTop10ByOrderByViewCountDesc()
            .stream()
            .map(ArticleDto::from)
            .collect(Collectors.toList());
    }

    @Scheduled(fixedDelay = 50000) // TTL 60초 가정
    public void refreshPopularArticles() {
        List<ArticleDto> articles = articleRepository.findTop10ByOrderByViewCountDesc()
            .stream()
            .map(ArticleDto::from)
            .collect(Collectors.toList());
        cacheManager.getCache("popularArticles").put("top10", articles);
    }
}

// 캐시 만료 시점에 100개 요청이 동시에 들어오면
// 100개 모두 DB 조회 발생
@Cacheable("data")
public DataDto getData() {
    return repository.findData(); // 100번 실행됨
}

@Cacheable(value = "data", key = "#id", sync = true)
public DataDto getData(Long id) {
    // 같은 인스턴스 안에서는 첫 번째 요청만 실행되고 나머지는 대기
    return repository.findById(id)
        .map(DataDto::from)
        .orElseThrow();
}

@Configuration
public class RedissonConfig {

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
            .setAddress("redis://localhost:6379");
        return Redisson.create(config);
    }
}

@Service
public class DataService {

    private final RedissonClient redissonClient;
    private final CacheManager cacheManager;
    private final DataRepository repository;

    public DataDto getData(Long id) {
        String cacheKey = "data:" + id;
        DataDto cached = getFromCache(cacheKey);

        if (cached != null) {
            return cached;
        }

        RLock lock = redissonClient.getLock("lock:" + cacheKey);
        boolean locked = false;

        try {
            // 최대 5초 동안 락 획득을 기다리고, 락을 잡으면 10초 뒤 자동 해제된다.
            locked = lock.tryLock(5, 10, TimeUnit.SECONDS);
            if (locked) {
                // 락을 기다리는 동안 다른 인스턴스가 캐시를 채웠을 수 있으므로 다시 확인
                cached = getFromCache(cacheKey);
                if (cached != null) {
                    return cached;
                }

                DataDto data = repository.findById(id)
                    .map(DataDto::from)
                    .orElseThrow();

                saveToCache(cacheKey, data);
                return data;
            }
        } catch (InterruptedException e) {
            // 락 대기 중 인터럽트가 발생하면 인터럽트 상태를 복구하고 실패로 처리한다.
            Thread.currentThread().interrupt();
            throw new IllegalStateException("Interrupted while acquiring cache rebuild lock: " + cacheKey, e);
        } finally {
            if (locked && lock.isHeldByCurrentThread()) {
                // 현재 스레드가 잡은 락일 때만 해제한다.
                lock.unlock();
            }
        }

        throw new IllegalStateException("Failed to acquire cache rebuild lock: " + cacheKey);
    }

    private DataDto getFromCache(String cacheKey) {
        // 분산 락을 직접 다루기 때문에 @Cacheable 대신 CacheManager로 명시적으로 조회한다.
        Cache cache = cacheManager.getCache("data");
        return cache != null ? cache.get(cacheKey, DataDto.class) : null;
    }

    private void saveToCache(String cacheKey, DataDto data) {
        // TTL은 RedisCacheConfiguration의 "data" 캐시 설정을 따른다.
        Cache cache = cacheManager.getCache("data");
        if (cache != null) {
            cache.put(cacheKey, data);
        }
    }
}

RLock lock = redissonClient.getLock("lock:" + cacheKey);
boolean locked = false;

try {
    locked = lock.tryLock(5, 10, TimeUnit.SECONDS);
    if (!locked) {
        throw new IllegalStateException("Failed to acquire lock: " + cacheKey);
    }

    // DB 조회 후 캐시 재생성
} finally {
    if (locked && lock.isHeldByCurrentThread()) {
        lock.unlock();
    }
}

@Service
public class FencedDataService {

    private final RedissonClient redissonClient;
    private final CacheManager cacheManager;
    private final DataRepository repository;

    public void rebuildCacheWithFence(Long id) {
        String cacheKey = "data:" + id;
        RLock lock = redissonClient.getLock("lock:" + cacheKey);
        boolean locked = false;

        try {
            locked = lock.tryLock(5, 10, TimeUnit.SECONDS);
            if (!locked) {
                throw new IllegalStateException("Failed to acquire lock: " + cacheKey);
            }

            // 락을 획득한 순서대로 증가하는 fencing token을 발급한다.
            long fencingToken = redissonClient
                .getAtomicLong("fence:" + cacheKey)
                .incrementAndGet();

            DataDto data = repository.findById(id)
                .map(DataDto::from)
                .orElseThrow();

            // 실제 저장 시점에 token을 비교해서 늦게 도착한 이전 작업자의 쓰기를 막는다.
            saveIfCurrent(cacheKey, data, fencingToken);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new IllegalStateException("Interrupted while acquiring lock: " + cacheKey, e);
        } finally {
            if (locked && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

public record FencedCacheValue<T>(T data, long fencingToken) {
}

private void saveIfCurrent(String cacheKey, DataDto data, long fencingToken) {
    Cache cache = cacheManager.getCache("data");
    if (cache == null) {
        return;
    }

    FencedCacheValue<DataDto> current = cache.get(cacheKey, FencedCacheValue.class);
    if (current != null && current.fencingToken() > fencingToken) {
        // 더 최신 token으로 저장된 값이 있으므로 늦게 끝난 이전 작업자의 결과는 버린다.
        return;
    }

    cache.put(cacheKey, new FencedCacheValue<>(data, fencingToken));
}

public DataDto getData(Long id) {
    String cacheKey = "data:" + id;
    CachedData cached = getFromCacheWithTTL(cacheKey);

    if (cached != null) {
        long remainingTTL = cached.getRemainingTTL();
        long totalTTL = 600; // 10분

        double refreshProbability = 1.0 - ((double) remainingTTL / totalTTL);

        if (Math.random() < refreshProbability * 0.1) {
            CompletableFuture.runAsync(() -> refreshCache(id));
        }

        return cached.getData();
    }

    return loadAndCache(id);
}

RedisCacheConfiguration.defaultCacheConfig()
    .entryTtl((key, value) -> {
        Duration baseTtl = Duration.ofSeconds(5);
        double ratio = 0.2;
        long maxJitter = (long) (baseTtl.toMillis() * ratio);
        long jitter = ThreadLocalRandom.current().nextLong(maxJitter + 1);
        return Duration.ofMillis(baseTtl.toMillis() - jitter);
    });