캐시 시스템 설계 구현

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public CacheManager cacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        
        // 1. 공통 데이터 캐시 (긴 TTL)
        CaffeineCache staticCache = new CaffeineCache("staticCache",
                Caffeine.newBuilder()
                        .expireAfterWrite(1, TimeUnit.HOURS)
                        .maximumSize(500)
                        .build());

        // 2. 유저 데이터 캐시 (짧은 TTL)
        CaffeineCache userCache = new CaffeineCache("userCache",
                Caffeine.newBuilder()
                        .expireAfterWrite(1, TimeUnit.MINUTES)
                        .maximumSize(10000)
                        .build());

        cacheManager.setCaches(Arrays.asList(staticCache, userCache));
        return cacheManager;
    }
}

@Configuration
public class RedisConfig {

    @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                            MessageListenerAdapter listenerAdapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(listenerAdapter, new PatternTopic("cache-invalidation"));
        return container;
    }

    @Bean
    MessageListenerAdapter listenerAdapter(CacheMessageSubscriber subscriber) {
        return new MessageListenerAdapter(subscriber, "onMessage");
    }
}

// 메시지 객체
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CacheMessage implements Serializable {
    private String cacheName;
    private String key;
}

@Component
@RequiredArgsConstructor
public class CacheMessageSubscriber {
    private final CacheManager cacheManager;

    public void onMessage(String message) {
        // 실제로는 JSON 역직렬화 로직 필요
        // ObjectMapper.readValue(message, CacheMessage.class)
        CacheMessage cacheMessage = deserialize(message); 
        
        Cache cache = cacheManager.getCache(cacheMessage.getCacheName());
        if (cache != null) {
            cache.evict(cacheMessage.getKey()); // 로컬 캐시 제거
            System.out.println("L1 캐시 무효화 완료: " + cacheMessage.getKey());
        }
    }
}

@Service
@RequiredArgsConstructor
public class UserService {
    private final RedisTemplate<String, Object> redisTemplate;
    private final CacheManager cacheManager;

    @Cacheable(cacheNames = "userCache", key = "#userId")
    public UserProfile getUserProfile(String userId) {
        // L1 Miss 시 실행: Redis(L2)에서 조회하는 로직 (생략)
        return fetchFromRedis(userId);
    }

    public void updateUserProfile(String userId, UserProfile profile) {
        // 1. DB/Redis 업데이트
        updateInRedis(userId, profile);

        // 2. Pub/Sub 메시지 발행 (전체 서버 L1 무효화)
        redisTemplate.convertAndSend("cache-invalidation", new CacheMessage("userSpecificCache", userId));
    }
}

@Cacheable(cacheNames = "userSpecificCache", key = "#userId", sync = true)

@Service
@RequiredArgsConstructor
public class UserCacheService {
    private final RedisTemplate<String, Object> redisTemplate;
    private final CacheManager cacheManager;

    public void updateUserData(String userId, UserProfile profile) {
        // 1. Redis (L2) 업데이트
        String redisKey = "user:" + userId;
        redisTemplate.opsForValue().set(redisKey, profile);

        // 2. Local (L1) 업데이트 (현재 서버)
        cacheManager.getCache("userCache").put(userId, profile);

        // 3. 타 서버 L1 무효화 메시지 발행
        redisTemplate.convertAndSend("cache-invalidation", new CacheMessage("userCache", userId));

        // 4. Write-Behind를 위한 변경 로그 기록 (Set에 저장하여 중복 제거)
        redisTemplate.opsForSet().add("pending-db-updates", userId);
    }
}

@Component
@RequiredArgsConstructor
public class WriteBehindWorker {
    private final RedisTemplate<String, Object> redisTemplate;
    private final UserRepository userRepository;

    @Scheduled(fixedDelay = 5000) // 5초마다 DB 업데이트
    public void persistToDb() {
        // 1. 업데이트 대상 키들을 한꺼번에 가져옴
        Set<Object> pendingUserIds = redisTemplate.opsForSet().members("pending-db-updates");
        if (pendingUserIds == null || pendingUserIds.isEmpty()) return;

        // 2. Redis에서 해당 데이터들 Multi-Get (네트워크 최적화)
        List<String> keys = pendingUserIds.stream().map(id -> "user:" + id).toList();
        List<Object> profiles = redisTemplate.opsForValue().multiGet(keys);

        // 3. DB Bulk Save (JPA saveAll 등 사용)
        // userRepository.saveAll(profiles...);
        System.out.println(profiles.size() + "건의 데이터를 DB에 일괄 저장했습니다.");

        // 4. 처리 완료된 키 삭제
        redisTemplate.delete("pending-db-updates");
    }
}

@Service
@RequiredArgsConstructor
public class ConcurrentUserCacheService {
    private final RedissonClient redissonClient;
    private final RedisTemplate<String, Object> redisTemplate;
    private final CacheManager cacheManager;

    public void updateUserDataWithLock(String requestId, String userId, UserProfile profile) {
        String lockKey = "lock:user:" + userId;
        RLock lock = redissonClient.getLock(lockKey);

        try {
            // 1. 락 획득 시도 (최대 5초 대기, 10초간 점유)
            if (lock.tryLock(5, 10, TimeUnit.SECONDS)) {
                try {
                    // 2. 멱등성 체크 (중복 요청 방지)
                    String idempotencyKey = "req:" + requestId;
                    Boolean isFirstRequest = redisTemplate.opsForValue()
                            .setIfAbsent(idempotencyKey, "processing", Duration.ofMinutes(5));
                    
                    if (Boolean.FALSE.equals(isFirstRequest)) {
                        return; // 이미 처리된 요청이면 종료
                    }

                    // 3. 비즈니스 로직 및 캐시 업데이트 (원자적 수행 권장)
                    updateCacheAndPublish(userId, profile);
                    
                } finally {
                    lock.unlock(); // 락 해제
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    private void updateCacheAndPublish(String userId, UserProfile profile) {
        String redisKey = "user:" + userId;
        
        // Redis 파이프라인이나 Lua 스크립트를 쓰면 더 안전합니다.
        redisTemplate.execute(new SessionCallback<Object>() {
            @Override
            public Object execute(RedisOperations operations) {
                operations.multi(); // 트랜잭션 시작
                operations.opsForValue().set(redisKey, profile);
                operations.opsForSet().add("pending-db-updates", userId);
                operations.convertAndSend("cache-invalidation", 
                    new CacheMessage("userCache", userId));
                return operations.exec();
            }
        });

        // 현재 서버의 L1 캐시도 즉시 업데이트
        cacheManager.getCache("userCache").put(userId, profile);
    }
}