증상:

@Cacheable 어노테이션을 추가했는데, 메서드가 계속 실행되고 캐시가 동작하지 않아요.

가능한 원인:

1. @EnableCaching 어노테이션 누락
2. 자체 호출(self-invocation) 문제
3. 캐시 키 생성 오류
4. 프록시 관련 문제

해결책:

// 1. @EnableCaching 확인
@SpringBootApplication
@EnableCaching  // 이 어노테이션이 있는지 확인!
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

// 2. 자체 호출 문제 해결
@Service
public class ProductService {
    
    @Autowired
    private ApplicationContext context;
    
    @Cacheable("products")
    public Product getProduct(Long id) {
        // 캐시 적용됨
        return findProductById(id);
    }
    
    public Product updateAndGet(Long id) {
        // 문제: 직접 호출하면 캐시가 동작하지 않음
        // return getProduct(id);  // ❌
        
        // 해결: 프록시를 통해 호출
        ProductService proxy = context.getBean(ProductService.class);
        return proxy.getProduct(id);  // ✅
    }
    
    private Product findProductById(Long id) {
        // DB 조회 로직
    }
}

// 3. 캐시 키 디버깅
@Cacheable(value = "products", key = "#id", condition = "#id > 0")
public Product getProduct(Long id) {
    System.out.println("캐시 키: " + id);  // 키 값 확인
    return productRepository.findById(id).orElse(null);
}
            

증상:

트랜잭션 내에서 데이터를 변경하고 캐시를 업데이트했는데, 트랜잭션이 롤백되면 캐시와 DB가 불일치해요.

가능한 원인:

캐시 작업이 트랜잭션보다 먼저 실행되어 트랜잭션 롤백 시 캐시는 업데이트된 상태로 남아있어요.

해결책:

// 문제가 있는 코드
@Transactional
@CachePut(value = "users", key = "#user.id")
public User updateUser(User user) {
    // 트랜잭션이 롤백되면 DB는 원래대로 돌아가지만
    // 캐시는 이미 업데이트된 상태로 남아있음
    return userRepository.save(user);
}

// 해결책 1: @Caching 어노테이션과 트랜잭션 분리
@Transactional
public User updateUserInTransaction(User user) {
    return userRepository.save(user);
}

@CachePut(value = "users", key = "#result.id")
public User updateUser(User user) {
    try {
        return updateUserInTransaction(user);
    } catch (Exception e) {
        // 트랜잭션 실패 시 캐시 업데이트 안 함
        throw e;
    }
}

// 해결책 2: TransactionSynchronizationManager 사용
@Transactional
public User updateUser(User user) {
    User savedUser = userRepository.save(user);
    
    TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
        @Override
        public void afterCommit() {
            // 트랜잭션이 성공적으로 커밋된 후에만 캐시 업데이트
            cacheManager.getCache("users").put(user.getId(), savedUser);
        }
    });
    
    return savedUser;
}
            

증상:

캐시에서 가져온 객체를 수정했더니 다른 요청에도 영향을 미쳐요.

가능한 원인:

캐시는 객체 참조를 저장하므로, 캐시된 객체를 수정하면 캐시의 내용도 변경돼요.

해결책:

// 문제가 있는 코드
@Cacheable("products")
public Product getProduct(Long id) {
    return productRepository.findById(id).orElse(null);
}

// 클라이언트 코드
Product product = productService.getProduct(123L);
product.setPrice(product.getPrice() * 0.9);  // 할인 적용
// 이제 다른 모든 요청도 할인된 가격을 보게 됨! 😱

// 해결책 1: 방어적 복사
@Cacheable("products")
public Product getProduct(Long id) {
    Product product = productRepository.findById(id).orElse(null);
    if (product != null) {
        // 복사본 반환
        return new Product(product);  // 복사 생성자 사용
    }
    return null;
}

// 해결책 2: 불변 객체 사용
@Cacheable("products")
public ProductDto getProduct(Long id) {
    Product product = productRepository.findById(id).orElse(null);
    if (product != null) {
        // 불변 DTO 반환
        return new ProductDto(product);
    }
    return null;
}

// 해결책 3: Jackson을 사용한 직렬화/역직렬화
@Bean
public CacheManager cacheManager(ObjectMapper objectMapper) {
    CaffeineCacheManager cacheManager = new CaffeineCacheManager();
    cacheManager.setCaffeine(Caffeine.newBuilder()
            .expireAfterWrite(10, TimeUnit.MINUTES));
    
    // Jackson을 사용한 직렬화/역직렬화로 깊은 복사 구현
    cacheManager.setAllowNullValues(true);
    cacheManager.setCacheLoader(new CacheLoader<Object, Object>() {
        @Override
        public Object load(Object key) {
            return null;
        }
        
        @Override
        public Object reload(Object key, Object oldValue) {
            try {
                // 깊은 복사 구현
                String json = objectMapper.writeValueAsString(oldValue);
                return objectMapper.readValue(json, oldValue.getClass());
            } catch (Exception e) {
                return oldValue;
            }
        }
    });
    
    return cacheManager;
}
            

증상:

시간이 지날수록 애플리케이션 메모리 사용량이 계속 증가해요.

가능한 원인:

캐시 크기 제한이 없거나, 캐시 항목이 너무 큰 경우예요.

해결책:

// 해결책 1: 캐시 크기 제한
@Bean
public CacheManager cacheManager() {
    CaffeineCacheManager cacheManager = new CaffeineCacheManager();
    cacheManager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(1000)  // 최대 1000개 항목으로 제한
            .expireAfterWrite(1, TimeUnit.HOURS));  // 1시간 후 만료
    return cacheManager;
}

// 해결책 2: 큰 객체는 별도 처리
@Cacheable(value = "largeObjects", key = "#id", condition = "#result != null && #result.size() < 1024")
public byte[] getLargeObject(String id) {
    // 결과가 너무 크면 캐시하지 않음
    return largeObjectRepository.findById(id);
}

// 해결책 3: 캐시 통계 모니터링
@Scheduled(fixedRate = 300000)  // 5분마다 실행
public void monitorCacheSize() {
    Cache usersCache = cacheManager.getCache("users");
    if (usersCache instanceof CaffeineCache) {
        CaffeineCache caffeineCache = (CaffeineCache) usersCache;
        com.github.benmanes.caffeine.cache.Cache<Object, Object> nativeCache = 
                caffeineCache.getNativeCache();
        
        long estimatedSize = nativeCache.estimatedSize();
        log.info("현재 users 캐시 크기: {} 항목", estimatedSize);
        
        if (estimatedSize > 10000) {
            log.warn("캐시 크기가 너무 큽니다! 일부 항목을 제거합니다.");
            nativeCache.cleanUp();  // 만료된 항목 정리
        }
    }
}
            

증상:

@Async와 @Cacheable을 함께 사용했는데 캐시가 제대로 동작하지 않아요.

가능한 원인:

@Async 메서드는 별도의 프록시를 통해 실행되므로 캐시 프록시와 충돌할 수 있어요.

해결책:

// 문제가 있는 코드
@Async
@Cacheable("asyncData")
public CompletableFuture<Data> getDataAsync(String key) {
    // 비동기 + 캐시 조합이 제대로 동작하지 않을 수 있음
    return CompletableFuture.supplyAsync(() -> dataService.fetchData(key));
}

// 해결책 1: 메서드 분리
@Cacheable("data")
public Data getData(String key) {
    return dataService.fetchData(key);
}

@Async
public CompletableFuture<Data> getDataAsync(String key) {
    // 캐시 기능이 있는 동기 메서드 호출
    return CompletableFuture.completedFuture(getData(key));
}

// 해결책 2: 수동 캐시 관리
@Async
public CompletableFuture<Data> getDataAsync(String key) {
    Cache cache = cacheManager.getCache("asyncData");
    Data cachedData = cache.get(key, Data.class);
    
    if (cachedData != null) {
        return CompletableFuture.completedFuture(cachedData);
    }
    
    return CompletableFuture.supplyAsync(() -> {
        Data newData = dataService.fetchData(key);
        cache.put(key, newData);
        return newData;
    });
}
            

증상:

Redis 캐시를 사용할 때 "Cannot serialize" 예외가 발생해요.

가능한 원인:

캐시에 저장하려는 객체가 직렬화 가능하지 않아요.

해결책:

// 해결책 1: 직렬화 가능하게 만들기
@Entity
public class Product implements Serializable {  // Serializable 구현
    private static final long serialVersionUID = 1L;
    
    // 필드, 메서드 등
}

// 해결책 2: JSON 직렬화 사용 (Redis)
@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    // Jackson2JsonRedisSerializer 사용
    Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
    
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    serializer.setObjectMapper(objectMapper);
    
    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                    .fromSerializer(serializer))
            .entryTtl(Duration.ofMinutes(30));
                    
    return RedisCacheManager.builder(connectionFactory)
            .cacheDefaults(config)
            .build();
}

// 해결책 3: DTO 사용
@Cacheable("products")
public ProductDto getProduct(Long id) {
    Product product = productRepository.findById(id).orElse(null);
    // Entity 대신 직렬화 가능한 DTO 반환
    return product != null ? new ProductDto(product) : null;
}
            

증상:

condition이나 unless 속성이 예상대로 동작하지 않아요.

가능한 원인:

SpEL 표현식 오류나 컨텍스트 문제일 수 있어요.

해결책:

// 문제가 있는 코드
@Cacheable(value = "users", key = "#id", condition = "#user.admin")  // ❌ #user 변수 없음
public User getUser(Long id) {
    return userRepository.findById(id).orElse(null);
}

// 해결책 1: 올바른 변수 참조
@Cacheable(value = "users", key = "#id", condition = "#id > 0")  // ✅
public User getUser(Long id) {
    return userRepository.findById(id).orElse(null);
}

// 해결책 2: unless 사용 시 주의
@Cacheable(value = "users", key = "#id", unless = "#result == null || #result.admin")
public User getUser(Long id) {
    return userRepository.findById(id).orElse(null);
}

// 해결책 3: 디버깅을 위한 로깅 추가
@Cacheable(
    value = "users", 
    key = "#id", 
    condition = "#id > 0", 
    unless = "#result == null || #result.admin"
)
public User getUser(Long id) {
    System.out.println("조건 평가: id > 0 = " + (id > 0));
    User user = userRepository.findById(id).orElse(null);
    if (user != null) {
        System.out.println("unless 평가: result.admin = " + user.isAdmin());
    }
    return user;
}
            

증상:

@CacheEvict를 호출했는데 캐시가 여전히 이전 데이터를 반환해요.

가능한 원인:

캐시 키가 일치하지 않거나, 다른 캐시 저장소를 사용하고 있을 수 있어요.

해결책:

// 문제가 있는 코드
@Cacheable(value = "users", key = "#userId")
public User getUser(Long userId) {
    return userRepository.findById(userId).orElse(null);
}

@CacheEvict(value = "users", key = "#user.id")  // 키 불일치 가능성
public void updateUser(User user) {
    userRepository.save(user);
}

// 해결책 1: 키 일관성 유지
@Cacheable(value = "users", key = "#userId")
public User getUser(Long userId) {
    return userRepository.findById(userId).orElse(null);
}

@CacheEvict(value = "users", key = "#user.id")
public void updateUser(User user) {
    // 로깅 추가
    System.out.println("캐시 무효화: users::" + user.getId());
    userRepository.save(user);
}

// 해결책 2: 모든 항목 제거 (확실한 방법)
@CacheEvict(value = "users", allEntries = true)
public void updateUser(User user) {
    userRepository.save(user);
}

// 해결책 3: 여러 캐시 동시 무효화
@Caching(evict = {
    @CacheEvict(value = "users", key = "#user.id"),
    @CacheEvict(value = "userProfiles", key = "#user.id"),
    @CacheEvict(value = "userPermissions", key = "#user.id")
})
public void updateUser(User user) {
    userRepository.save(user);
}