Spring 12: 캐싱

캐시 사용 시나리오

• • 데이터베이스 조회 최적화: 복잡한 쿼리 결과를 캐시하여 DB 부하 감소
• • 외부 API 호출 최적화: 외부 서비스 응답을 캐시하여 네트워크 지연 감소
• • 계산 결과 저장: 복잡한 연산 결과를 캐시하여 CPU 사용량 감소
• • 세션 데이터 관리: 사용자 세션 정보를 빠르게 조회

구현 예시

// 로컬 캐시 설정 (Caffeine)
@Configuration
@EnableCaching
public class LocalCacheConfig {
    
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.MINUTES));
        return cacheManager;
    }
}

// 분산 캐시 설정 (Redis)
@Configuration
@EnableCaching
public class RedisCacheConfig {
    
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration
            .defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10))
            .serializeKeysWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new GenericJackson2JsonRedisSerializer()));
                
        return RedisCacheManager.builder(factory)
            .cacheDefaults(config)
            .build();
    }
}

기본 설정

@Configuration
@EnableCaching
public class CacheConfig {
    
    // 기본 CacheManager 설정
    @Bean
    public CacheManager cacheManager() {
        // Simple 캐시 매니저 (개발용)
        return new ConcurrentMapCacheManager("users", "products", "orders");
    }
    
    // 캐시 키 생성 전략 커스터마이징
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getSimpleName());
                sb.append(".");
                sb.append(method.getName());
                for (Object param : params) {
                    sb.append("_").append(param.toString());
                }
                return sb.toString();
            }
        };
    }
    
    // 캐시 에러 핸들러
    @Bean
    public CacheErrorHandler errorHandler() {
        return new CacheErrorHandler() {
            @Override
            public void handleCacheGetError(RuntimeException exception, 
                                          Cache cache, Object key) {
                log.error("Cache get error: cache={}, key={}", 
                         cache.getName(), key, exception);
            }
            
            @Override
            public void handleCachePutError(RuntimeException exception, 
                                          Cache cache, Object key, Object value) {
                log.error("Cache put error: cache={}, key={}", 
                         cache.getName(), key, exception);
            }
            
            @Override
            public void handleCacheEvictError(RuntimeException exception, 
                                            Cache cache, Object key) {
                log.error("Cache evict error: cache={}, key={}", 
                         cache.getName(), key, exception);
            }
            
            @Override
            public void handleCacheClearError(RuntimeException exception, Cache cache) {
                log.error("Cache clear error: cache={}", cache.getName(), exception);
            }
        };
    }
}

기본 사용법

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    // 기본 캐시 적용
    @Cacheable("users")
    public User findById(Long id) {
        log.info("DB에서 사용자 조회: {}", id);
        return userRepository.findById(id).orElse(null);
    }
    
    // 복합 키 사용
    @Cacheable(value = "users", key = "#id + '_' + #includeDeleted")
    public User findById(Long id, boolean includeDeleted) {
        if (includeDeleted) {
            return userRepository.findByIdIncludingDeleted(id);
        }
        return userRepository.findById(id).orElse(null);
    }
    
    // 조건부 캐싱
    @Cacheable(value = "users", condition = "#id > 0", unless = "#result == null")
    public User findByIdConditional(Long id) {
        return userRepository.findById(id).orElse(null);
    }
    
    // SpEL 표현식 활용
    @Cacheable(value = "users", key = "#user.id", condition = "#user.active")
    public User findByUser(User user) {
        return userRepository.findById(user.getId()).orElse(null);
    }
}

기본 사용법

@Service
public class UserService {
    
    // 특정 키 제거
    @CacheEvict(value = "users", key = "#id")
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
    
    // 전체 캐시 제거
    @CacheEvict(value = "users", allEntries = true)
    public void deleteAllUsers() {
        userRepository.deleteAll();
    }
    
    // 메서드 실행 전 캐시 제거
    @CacheEvict(value = "users", key = "#user.id", beforeInvocation = true)
    public void updateUser(User user) {
        // 캐시 제거 후 업데이트 실행
        userRepository.save(user);
    }
    
    // 조건부 캐시 제거
    @CacheEvict(value = "users", key = "#id", condition = "#result == true")
    public boolean deactivateUser(Long id) {
        User user = userRepository.findById(id).orElse(null);
        if (user != null && user.isActive()) {
            user.setActive(false);
            userRepository.save(user);
            return true;
        }
        return false;
    }
    
    // 여러 캐시 동시 제거
    @CacheEvict(value = {"users", "user-profiles", "user-statistics"}, key = "#id")
    public void removeUserFromAllCaches(Long id) {
        // 사용자 관련 모든 캐시 제거
    }
}

기본 사용법

@Service
public class UserService {
    
    // 업데이트 후 캐시 갱신
    @CachePut(value = "users", key = "#user.id")
    public User updateUser(User user) {
        User updated = userRepository.save(user);
        log.info("사용자 업데이트 및 캐시 갱신: {}", updated.getId());
        return updated;
    }
    
    // 생성 후 캐시에 저장
    @CachePut(value = "users", key = "#result.id")
    public User createUser(User user) {
        User created = userRepository.save(user);
        return created;
    }
    
    // 조건부 캐시 업데이트
    @CachePut(value = "users", key = "#user.id", 
              condition = "#user.active == true", 
              unless = "#result == null")
    public User activateUser(User user) {
        user.setActive(true);
        user.setLastLoginDate(LocalDateTime.now());
        return userRepository.save(user);
    }
    
    // 여러 캐시 동시 업데이트
    @Caching(put = {
        @CachePut(value = "users", key = "#result.id"),
        @CachePut(value = "active-users", key = "#result.id", condition = "#result.active")
    })
    public User updateUserStatus(Long id, boolean active) {
        User user = userRepository.findById(id).orElseThrow();
        user.setActive(active);
        return userRepository.save(user);
    }
}

복합 캐시 작업

@Service
public class ComplexCacheService {
    
    // 여러 캐시에서 동시 조회
    @Caching(cacheable = {
        @Cacheable(value = "users", key = "#id"),
        @Cacheable(value = "user-profiles", key = "#id", condition = "#includeProfile")
    })
    public UserWithProfile getUserWithProfile(Long id, boolean includeProfile) {
        User user = userRepository.findById(id).orElse(null);
        if (user == null) return null;
        
        UserProfile profile = includeProfile ? 
            profileRepository.findByUserId(id) : null;
            
        return new UserWithProfile(user, profile);
    }
    
    // 업데이트 시 관련 캐시들 처리
    @Caching(
        put = {
            @CachePut(value = "users", key = "#user.id"),
            @CachePut(value = "user-summaries", key = "#user.id")
        },
        evict = {
            @CacheEvict(value = "user-lists", allEntries = true),
            @CacheEvict(value = "statistics", allEntries = true)
        }
    )
    public User updateUserAndRefreshCaches(User user) {
        User updated = userRepository.save(user);
        
        // 통계 재계산 트리거
        statisticsService.recalculateUserStatistics();
        
        return updated;
    }
    
    // 조건부 복합 캐시 작업
    @Caching(
        cacheable = @Cacheable(value = "products", key = "#id", 
                              condition = "#useCache == true"),
        put = @CachePut(value = "recent-products", key = "#id", 
                       condition = "#updateRecent == true")
    )
    public Product getProduct(Long id, boolean useCache, boolean updateRecent) {
        Product product = productRepository.findById(id).orElse(null);
        
        if (updateRecent && product != null) {
            // 최근 조회 상품 목록 업데이트
            recentProductService.addToRecent(product);
        }
        
        return product;
    }
}

Maven 의존성

<dependencies>
    <!-- Spring Boot Starter Data Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <!-- Redis Connection Pool (Lettuce) -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
    
    <!-- JSON 직렬화를 위한 Jackson -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
    
    <!-- 캐시 추상화 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
</dependencies>

기본 RedisTemplate 설정

@Configuration
@EnableCaching
public class RedisConfig {
    
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        LettuceConnectionFactory factory = new LettuceConnectionFactory(
            new RedisStandaloneConfiguration("localhost", 6379)
        );
        
        // 연결 풀 설정
        factory.setPoolConfig(jedisPoolConfig());
        factory.setValidateConnection(true);
        
        return factory;
    }
    
    @Bean
    public GenericObjectPoolConfig jedisPoolConfig() {
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxTotal(128);
        poolConfig.setMaxIdle(128);
        poolConfig.setMinIdle(16);
        poolConfig.setTestOnBorrow(true);
        poolConfig.setTestOnReturn(true);
        poolConfig.setTestWhileIdle(true);
        poolConfig.setMinEvictableIdleTimeMillis(Duration.ofSeconds(60).toMillis());
        poolConfig.setTimeBetweenEvictionRunsMillis(Duration.ofSeconds(30).toMillis());
        poolConfig.setNumTestsPerEvictionRun(3);
        poolConfig.setBlockWhenExhausted(true);
        return poolConfig;
    }
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        
        // 키 직렬화 설정
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        
        // 값 직렬화 설정
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        
        // 기본 직렬화 설정
        template.setDefaultSerializer(new GenericJackson2JsonRedisSerializer());
        
        template.afterPropertiesSet();
        return template;
    }
    
    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(factory);
        return template;
    }
}

커스텀 직렬화 구현

// 커스텀 User 직렬화
public class UserRedisSerializer implements RedisSerializer<User> {
    
    private final ObjectMapper objectMapper;
    
    public UserRedisSerializer() {
        this.objectMapper = new ObjectMapper();
        this.objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        this.objectMapper.registerModule(new JavaTimeModule());
    }
    
    @Override
    public byte[] serialize(User user) throws SerializationException {
        if (user == null) {
            return new byte[0];
        }
        try {
            return objectMapper.writeValueAsBytes(user);
        } catch (JsonProcessingException e) {
            throw new SerializationException("Error serializing User", e);
        }
    }
    
    @Override
    public User deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length == 0) {
            return null;
        }
        try {
            return objectMapper.readValue(bytes, User.class);
        } catch (IOException e) {
            throw new SerializationException("Error deserializing User", e);
        }
    }
}

// 압축 직렬화 (대용량 데이터용)
public class CompressedJsonRedisSerializer implements RedisSerializer<Object> {
    
    private final ObjectMapper objectMapper = new ObjectMapper();
    
    @Override
    public byte[] serialize(Object object) throws SerializationException {
        if (object == null) {
            return new byte[0];
        }
        try {
            byte[] json = objectMapper.writeValueAsBytes(object);
            return compress(json);
        } catch (Exception e) {
            throw new SerializationException("Error serializing object", e);
        }
    }
    
    @Override
    public Object deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length == 0) {
            return null;
        }
        try {
            byte[] decompressed = decompress(bytes);
            return objectMapper.readValue(decompressed, Object.class);
        } catch (Exception e) {
            throw new SerializationException("Error deserializing object", e);
        }
    }
    
    private byte[] compress(byte[] data) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (GZIPOutputStream gzipOut = new GZIPOutputStream(baos)) {
            gzipOut.write(data);
        }
        return baos.toByteArray();
    }
    
    private byte[] decompress(byte[] compressed) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (GZIPInputStream gzipIn = new GZIPInputStream(new ByteArrayInputStream(compressed))) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = gzipIn.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
        }
        return baos.toByteArray();
    }
}

기본 RedisCacheManager 설정

@Configuration
@EnableCaching
public class RedisCacheConfig {
    
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10))
            .serializeKeysWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new GenericJackson2JsonRedisSerializer()))
            .disableCachingNullValues();
            
        return RedisCacheManager.builder(factory)
            .cacheDefaults(config)
            .build();
    }
    
    // 캐시별 개별 설정
    @Bean
    public CacheManager customCacheManager(RedisConnectionFactory factory) {
        // 기본 설정
        RedisCacheConfiguration defaultConfig = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10))
            .serializeKeysWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new GenericJackson2JsonRedisSerializer()));
        
        // 캐시별 개별 설정
        Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
        
        // 사용자 캐시 - 30분 TTL
        cacheConfigurations.put("users", defaultConfig
            .entryTtl(Duration.ofMinutes(30))
            .prefixCacheNameWith("user:"));
        
        // 상품 캐시 - 1시간 TTL
        cacheConfigurations.put("products", defaultConfig
            .entryTtl(Duration.ofHours(1))
            .prefixCacheNameWith("product:"));
        
        // 세션 캐시 - 24시간 TTL
        cacheConfigurations.put("sessions", defaultConfig
            .entryTtl(Duration.ofHours(24))
            .prefixCacheNameWith("session:"));
        
        // 통계 캐시 - 5분 TTL, null 값 허용
        cacheConfigurations.put("statistics", defaultConfig
            .entryTtl(Duration.ofMinutes(5))
            .prefixCacheNameWith("stats:")
            .serializeNullValues());
        
        return RedisCacheManager.builder(factory)
            .cacheDefaults(defaultConfig)
            .withInitialCacheConfigurations(cacheConfigurations)
            .build();
    }
}

Cache-Aside 동작 원리

Write-Through 구현

@Service
public class WriteThroughUserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Transactional
    public User createUser(User user) {
        // 1. DB에 저장
        User savedUser = userRepository.save(user);
        
        // 2. 캐시에도 동시 저장
        String cacheKey = "user:" + savedUser.getId();
        redisTemplate.opsForValue().set(cacheKey, savedUser, 
            Duration.ofMinutes(30));
        
        log.info("사용자 생성 및 캐시 저장: {}", savedUser.getId());
        return savedUser;
    }
    
    @Transactional
    public User updateUser(User user) {
        try {
            // 1. DB 업데이트
            User updatedUser = userRepository.save(user);
            
            // 2. 캐시 업데이트
            String cacheKey = "user:" + user.getId();
            redisTemplate.opsForValue().set(cacheKey, updatedUser, 
                Duration.ofMinutes(30));
            
            return updatedUser;
        } catch (Exception e) {
            // 캐시 업데이트 실패 시 롤백
            log.error("사용자 업데이트 실패: {}", user.getId(), e);
            throw e;
        }
    }
    
    // Spring Cache Abstraction으로 Write-Through 구현
    @CachePut(value = "users", key = "#user.id")
    @Transactional
    public User updateUserWithCache(User user) {
        return userRepository.save(user);
    }
    
    // 배치 Write-Through
    @Transactional
    public List<User> createUsers(List<User> users) {
        List<User> savedUsers = userRepository.saveAll(users);
        
        // 캐시에 배치 저장
        Map<String, Object> cacheData = new HashMap<>();
        for (User user : savedUsers) {
            cacheData.put("user:" + user.getId(), user);
        }
        
        redisTemplate.opsForValue().multiSet(cacheData);
        
        // TTL 설정
        for (String key : cacheData.keySet()) {
            redisTemplate.expire(key, Duration.ofMinutes(30));
        }
        
        return savedUsers;
    }
}

Write-Behind 구현

@Service
public class WriteBehindService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private TaskExecutor taskExecutor;
    
    private final Queue<User> writeQueue = new ConcurrentLinkedQueue<>();
    
    // 즉시 캐시에 저장, DB는 비동기 처리
    public User updateUserAsync(User user) {
        String cacheKey = "user:" + user.getId();
        
        // 1. 캐시에 즉시 저장
        redisTemplate.opsForValue().set(cacheKey, user, Duration.ofMinutes(30));
        
        // 2. 쓰기 큐에 추가
        writeQueue.offer(user);
        
        // 3. 비동기 DB 업데이트 스케줄링
        taskExecutor.execute(() -> {
            try {
                Thread.sleep(100); // 배치 처리를 위한 지연
                flushWriteQueue();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        
        return user;
    }
    
    // 큐에 쌓인 데이터를 배치로 DB에 저장
    @Async
    public void flushWriteQueue() {
        List<User> usersToWrite = new ArrayList<>();
        User user;
        
        // 큐에서 사용자들을 가져옴
        while ((user = writeQueue.poll()) != null && usersToWrite.size() < 100) {
            usersToWrite.add(user);
        }
        
        if (!usersToWrite.isEmpty()) {
            try {
                userRepository.saveAll(usersToWrite);
                log.info("배치 DB 업데이트 완료: {} 건", usersToWrite.size());
            } catch (Exception e) {
                log.error("배치 DB 업데이트 실패", e);
                // 실패한 데이터를 다시 큐에 추가
                writeQueue.addAll(usersToWrite);
            }
        }
    }
    
    // 스케줄링을 통한 주기적 플러시
    @Scheduled(fixedDelay = 5000) // 5초마다
    public void scheduledFlush() {
        if (!writeQueue.isEmpty()) {
            flushWriteQueue();
        }
    }
    
    // 애플리케이션 종료 시 남은 데이터 처리
    @PreDestroy
    public void shutdown() {
        log.info("애플리케이션 종료 - 남은 쓰기 작업 처리");
        while (!writeQueue.isEmpty()) {
            flushWriteQueue();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
    }
}

TTL 설정 전략

@Service
public class TTLCacheService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    // 데이터 특성별 TTL 설정
    public void cacheUserProfile(User user) {
        String key = "user:profile:" + user.getId();
        // 사용자 프로필: 1시간 TTL
        redisTemplate.opsForValue().set(key, user, Duration.ofHours(1));
    }
    
    public void cacheProductPrice(Long productId, BigDecimal price) {
        String key = "product:price:" + productId;
        // 상품 가격: 10분 TTL (자주 변경됨)
        redisTemplate.opsForValue().set(key, price, Duration.ofMinutes(10));
    }
    
    public void cacheSessionData(String sessionId, Object sessionData) {
        String key = "session:" + sessionId;
        // 세션 데이터: 30분 TTL
        redisTemplate.opsForValue().set(key, sessionData, Duration.ofMinutes(30));
    }
    
    public void cacheStatistics(String key, Object stats) {
        // 통계 데이터: 1일 TTL
        redisTemplate.opsForValue().set("stats:" + key, stats, Duration.ofDays(1));
    }
    
    // 동적 TTL 설정
    public void cacheWithDynamicTTL(String key, Object value, CacheType type) {
        Duration ttl = calculateTTL(type);
        redisTemplate.opsForValue().set(key, value, ttl);
    }
    
    private Duration calculateTTL(CacheType type) {
        switch (type) {
            case REAL_TIME:
                return Duration.ofMinutes(1);
            case FREQUENT_UPDATE:
                return Duration.ofMinutes(10);
            case MODERATE_UPDATE:
                return Duration.ofHours(1);
            case STATIC_DATA:
                return Duration.ofDays(1);
            default:
                return Duration.ofMinutes(30);
        }
    }
    
    // TTL 연장
    public boolean extendTTL(String key, Duration additionalTime) {
        Long currentTTL = redisTemplate.getExpire(key, TimeUnit.SECONDS);
        if (currentTTL != null && currentTTL > 0) {
            Duration newTTL = Duration.ofSeconds(currentTTL).plus(additionalTime);
            return redisTemplate.expire(key, newTTL);
        }
        return false;
    }
    
    // 조건부 TTL 갱신
    public void refreshTTLIfNeeded(String key, Duration threshold, Duration newTTL) {
        Long remainingTTL = redisTemplate.getExpire(key, TimeUnit.SECONDS);
        if (remainingTTL != null && remainingTTL < threshold.getSeconds()) {
            redisTemplate.expire(key, newTTL);
            log.debug("TTL 갱신: key={}, newTTL={}", key, newTTL);
        }
    }
}

기본 엔티티 조회 캐싱

@Service
public class UserCacheService {
    
    @Autowired
    private UserRepository userRepository;
    
    // 기본 ID 조회
    @Cacheable(value = "users", key = "#id")
    public User findById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
    
    // 이메일로 조회
    @Cacheable(value = "users-by-email", key = "#email")
    public User findByEmail(String email) {
        return userRepository.findByEmail(email);
    }
    
    // 복합 조건 조회
    @Cacheable(value = "users", key = "#email + '_' + #status")
    public User findByEmailAndStatus(String email, UserStatus status) {
        return userRepository.findByEmailAndStatus(email, status);
    }
    
    // 조건부 캐싱 (활성 사용자만)
    @Cacheable(value = "active-users", key = "#id", 
               condition = "#includeInactive == false")
    public User findActiveUser(Long id, boolean includeInactive) {
        if (includeInactive) {
            return userRepository.findById(id).orElse(null);
        }
        return userRepository.findByIdAndActiveTrue(id);
    }
    
    // null 값 캐싱 방지
    @Cacheable(value = "users", key = "#id", unless = "#result == null")
    public User findByIdNotNull(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

페이징 목록 캐싱

@Service
public class ListCacheService {
    
    // 기본 페이징 목록
    @Cacheable(value = "user-lists", 
               key = "'page_' + #page + '_size_' + #size + '_sort_' + #sort")
    public Page<User> findUsers(int page, int size, String sort) {
        Sort sortObj = Sort.by(Sort.Direction.ASC, sort);
        Pageable pageable = PageRequest.of(page, size, sortObj);
        return userRepository.findAll(pageable);
    }
    
    // 필터링된 목록
    @Cacheable(value = "filtered-users", 
               key = "#filter.hashCode() + '_' + #page + '_' + #size")
    public Page<User> findFilteredUsers(UserFilter filter, int page, int size) {
        Pageable pageable = PageRequest.of(page, size);
        return userRepository.findByFilter(filter, pageable);
    }
    
    // 카테고리별 상품 목록
    @Cacheable(value = "products-by-category", 
               key = "#categoryId + '_' + #page + '_' + #size + '_' + #sortBy")
    public Page<Product> findProductsByCategory(Long categoryId, int page, 
                                               int size, String sortBy) {
        Sort sort = Sort.by(Sort.Direction.ASC, sortBy);
        Pageable pageable = PageRequest.of(page, size, sort);
        return productRepository.findByCategoryId(categoryId, pageable);
    }
    
    // 검색 결과 캐싱
    @Cacheable(value = "search-results", 
               key = "#keyword + '_' + #page + '_' + #size",
               condition = "#keyword.length() >= 3")
    public Page<Product> searchProducts(String keyword, int page, int size) {
        Pageable pageable = PageRequest.of(page, size);
        return productRepository.findByNameContaining(keyword, pageable);
    }
}

조회수 카운터

@Service
public class ViewCounterService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private ProductRepository productRepository;
    
    // 조회수 증가 (Redis 카운터 사용)
    public void incrementViewCount(Long productId) {
        String key = "product:views:" + productId;
        redisTemplate.opsForValue().increment(key);
        
        // TTL 설정 (1일)
        redisTemplate.expire(key, Duration.ofDays(1));
    }
    
    // 조회수 조회 (캐시 + DB 합산)
    public long getViewCount(Long productId) {
        String key = "product:views:" + productId;
        
        // Redis에서 증분 조회수 가져오기
        Long incrementalViews = (Long) redisTemplate.opsForValue().get(key);
        if (incrementalViews == null) {
            incrementalViews = 0L;
        }
        
        // DB에서 기본 조회수 가져오기
        Product product = productRepository.findById(productId).orElse(null);
        long baseViews = product != null ? product.getViewCount() : 0L;
        
        return baseViews + incrementalViews;
    }
    
    // 주기적으로 Redis 카운터를 DB에 반영
    @Scheduled(fixedRate = 300000) // 5분마다
    @Transactional
    public void syncViewCountsToDB() {
        Set<String> keys = redisTemplate.keys("product:views:*");
        if (keys == null || keys.isEmpty()) {
            return;
        }
        
        for (String key : keys) {
            try {
                Long productId = Long.parseLong(key.substring("product:views:".length()));
                Long incrementalViews = (Long) redisTemplate.opsForValue().get(key);
                
                if (incrementalViews != null && incrementalViews > 0) {
                    // DB 업데이트
                    productRepository.incrementViewCount(productId, incrementalViews);
                    
                    // Redis 카운터 리셋
                    redisTemplate.delete(key);
                    
                    log.debug("조회수 동기화: productId={}, views={}", 
                             productId, incrementalViews);
                }
            } catch (Exception e) {
                log.error("조회수 동기화 실패: key={}", key, e);
            }
        }
    }
}

애플리케이션 시작 시 워밍업

@Component
public class CacheWarmupService {
    
    @Autowired
    private UserService userService;
    
    @Autowired
    private ProductService productService;
    
    @Autowired
    private CategoryService categoryService;
    
    @EventListener(ApplicationReadyEvent.class)
    @Async
    public void warmupCacheOnStartup() {
        log.info("캐시 워밍업 시작");
        
        try {
            // 1. 인기 사용자 데이터 로드
            warmupPopularUsers();
            
            // 2. 인기 상품 데이터 로드
            warmupPopularProducts();
            
            // 3. 카테고리 데이터 로드
            warmupCategories();
            
            // 4. 설정 데이터 로드
            warmupConfigurations();
            
            log.info("캐시 워밍업 완료");
        } catch (Exception e) {
            log.error("캐시 워밍업 실패", e);
        }
    }
    
    private void warmupPopularUsers() {
        List<Long> popularUserIds = userRepository.findPopularUserIds(100);
        for (Long userId : popularUserIds) {
            try {
                userService.findById(userId); // 캐시에 로드
                Thread.sleep(10); // 부하 분산
            } catch (Exception e) {
                log.warn("사용자 캐시 워밍업 실패: userId={}", userId, e);
            }
        }
        log.info("인기 사용자 캐시 워밍업 완료: {} 건", popularUserIds.size());
    }
    
    private void warmupPopularProducts() {
        List<Long> popularProductIds = productRepository.findPopularProductIds(500);
        
        // 병렬 처리로 성능 향상
        popularProductIds.parallelStream()
            .forEach(productId -> {
                try {
                    productService.findById(productId);
                } catch (Exception e) {
                    log.warn("상품 캐시 워밍업 실패: productId={}", productId, e);
                }
            });
        
        log.info("인기 상품 캐시 워밍업 완료: {} 건", popularProductIds.size());
    }
    
    private void warmupCategories() {
        // 모든 카테고리는 자주 사용되므로 전체 로드
        List<Category> categories = categoryService.findAll();
        log.info("카테고리 캐시 워밍업 완료: {} 건", categories.size());
    }
    
    private void warmupConfigurations() {
        // 시스템 설정 데이터 로드
        configurationService.getAllConfigurations();
        log.info("설정 데이터 캐시 워밍업 완료");
    }
}

데이터 유형별 캐시 전략

// 1. 정적 데이터 (설정, 코드 테이블)
@Configuration
public class StaticDataCacheConfig {
    
    @Bean
    public CacheManager staticDataCacheManager() {
        return RedisCacheManager.builder(redisConnectionFactory())
            .cacheDefaults(RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(24)) // 긴 TTL
                .disableCachingNullValues())
            .build();
    }
}

// 2. 사용자 데이터 (프로필, 설정)
@Cacheable(value = "user-profiles", key = "#userId")
public UserProfile getUserProfile(Long userId) {
    return userProfileRepository.findByUserId(userId);
}

// 3. 동적 데이터 (실시간 가격, 재고)
@Cacheable(value = "real-time-prices", key = "#productId", 
           condition = "#useCache == true")
public ProductPrice getCurrentPrice(Long productId, boolean useCache) {
    return priceService.getCurrentPrice(productId);
}

// 4. 집계 데이터 (통계, 리포트)
@Cacheable(value = "daily-statistics", key = "#date")
public DailyStats getDailyStatistics(LocalDate date) {
    return statisticsService.calculateDailyStats(date);
}

// 5. 세션 데이터
@Cacheable(value = "user-sessions", key = "#sessionId")
public UserSession getUserSession(String sessionId) {
    return sessionRepository.findBySessionId(sessionId);
}

핵심 메트릭 수집

@Component
public class CacheMetricsCollector {
    
    @Autowired
    private MeterRegistry meterRegistry;
    
    @Autowired
    private CacheManager cacheManager;
    
    @PostConstruct
    public void initializeMetrics() {
        // 캐시별 히트율 메트릭
        cacheManager.getCacheNames().forEach(cacheName -> {
            Cache cache = cacheManager.getCache(cacheName);
            if (cache instanceof CaffeineCache) {
                com.github.benmanes.caffeine.cache.Cache<Object, Object> nativeCache = 
                    ((CaffeineCache) cache).getNativeCache();
                
                Gauge.builder("cache.hit.ratio")
                    .tag("cache", cacheName)
                    .register(meterRegistry, nativeCache, c -> c.stats().hitRate());
                
                Gauge.builder("cache.size")
                    .tag("cache", cacheName)
                    .register(meterRegistry, nativeCache, c -> c.estimatedSize());
            }
        });
    }
    
    // 캐시 이벤트 리스너
    @EventListener
    public void handleCacheHit(CacheHitEvent event) {
        Counter.builder("cache.operations")
            .tag("cache", event.getCacheName())
            .tag("operation", "hit")
            .register(meterRegistry)
            .increment();
    }
    
    @EventListener
    public void handleCacheMiss(CacheMissEvent event) {
        Counter.builder("cache.operations")
            .tag("cache", event.getCacheName())
            .tag("operation", "miss")
            .register(meterRegistry)
            .increment();
    }
    
    @EventListener
    public void handleCacheEvict(CacheEvictEvent event) {
        Counter.builder("cache.operations")
            .tag("cache", event.getCacheName())
            .tag("operation", "evict")
            .register(meterRegistry)
            .increment();
    }
    
    // Redis 연결 상태 모니터링
    @Scheduled(fixedRate = 30000) // 30초마다
    public void monitorRedisConnection() {
        try {
            redisTemplate.execute((RedisCallback<String>) connection -> {
                return connection.ping();
            });
            
            Gauge.builder("redis.connection.status")
                .register(meterRegistry, () -> 1.0); // 연결됨
                
        } catch (Exception e) {
            Gauge.builder("redis.connection.status")
                .register(meterRegistry, () -> 0.0); // 연결 끊김
                
            log.error("Redis 연결 상태 확인 실패", e);
        }
    }
}

실전 코드 패턴

// 1. 배치 조회 패턴
@Service
public class BatchCacheService {
    
    public Map<Long, User> getUsersBatch(List<Long> userIds) {
        List<String> keys = userIds.stream()
            .map(id -> "user:" + id)
            .collect(Collectors.toList());
        
        List<Object> cachedUsers = redisTemplate.opsForValue().multiGet(keys);
        Map<Long, User> result = new HashMap<>();
        List<Long> missedIds = new ArrayList<>();
        
        for (int i = 0; i < userIds.size(); i++) {
            Long userId = userIds.get(i);
            User user = (User) cachedUsers.get(i);
            
            if (user != null) {
                result.put(userId, user);
            } else {
                missedIds.add(userId);
            }
        }
        
        // 캐시 미스된 데이터 DB에서 조회
        if (!missedIds.isEmpty()) {
            List<User> dbUsers = userRepository.findAllById(missedIds);
            
            // 배치로 캐시에 저장
            Map<String, Object> cacheData = new HashMap<>();
            for (User user : dbUsers) {
                result.put(user.getId(), user);
                cacheData.put("user:" + user.getId(), user);
            }
            
            if (!cacheData.isEmpty()) {
                redisTemplate.opsForValue().multiSet(cacheData);
                // TTL 설정
                cacheData.keySet().forEach(key -> 
                    redisTemplate.expire(key, Duration.ofMinutes(10)));
            }
        }
        
        return result;
    }
}

// 2. Circuit Breaker 패턴
@Component
public class CacheCircuitBreaker {
    
    private final AtomicInteger failureCount = new AtomicInteger(0);
    private final AtomicLong lastFailureTime = new AtomicLong(0);
    private final int failureThreshold = 5;
    private final long recoveryTimeout = 60000; // 1분
    
    public <T> T executeWithCircuitBreaker(Supplier<T> cacheOperation, 
                                          Supplier<T> fallbackOperation) {
        if (isCircuitOpen()) {
            log.warn("캐시 Circuit Breaker 열림 - Fallback 실행");
            return fallbackOperation.get();
        }
        
        try {
            T result = cacheOperation.get();
            onSuccess();
            return result;
        } catch (Exception e) {
            onFailure();
            log.warn("캐시 작업 실패 - Fallback 실행", e);
            return fallbackOperation.get();
        }
    }
    
    private boolean isCircuitOpen() {
        if (failureCount.get() >= failureThreshold) {
            return System.currentTimeMillis() - lastFailureTime.get() < recoveryTimeout;
        }
        return false;
    }
    
    private void onSuccess() {
        failureCount.set(0);
    }
    
    private void onFailure() {
        failureCount.incrementAndGet();
        lastFailureTime.set(System.currentTimeMillis());
    }
}

// 3. 캐시 압축 패턴
@Service
public class CompressedCacheService {
    
    public void setCacheCompressed(String key, Object value) {
        try {
            byte[] serialized = serialize(value);
            byte[] compressed = compress(serialized);
            
            redisTemplate.opsForValue().set(key + ":compressed", compressed);
            redisTemplate.expire(key + ":compressed", Duration.ofMinutes(10));
            
        } catch (Exception e) {
            log.error("압축 캐시 저장 실패: key={}", key, e);
        }
    }
    
    @SuppressWarnings("unchecked")
    public <T> T getCacheCompressed(String key, Class<T> type) {
        try {
            byte[] compressed = (byte[]) redisTemplate.opsForValue()
                .get(key + ":compressed");
            
            if (compressed != null) {
                byte[] decompressed = decompress(compressed);
                return (T) deserialize(decompressed);
            }
        } catch (Exception e) {
            log.error("압축 캐시 조회 실패: key={}", key, e);
        }
        return null;
    }
}