[Redis] Redis Cache를 활용해 데이터 조회 속도 개선하기 - (2)

📖 목차

 

 

 

---

지난번 포스팅에서 Redis의 어떤 특징 때문에 성능이 개선되는지 알아보았다.

 

[Redis] Redis Cache를 활용해 데이터 조회 속도 개선하기 - (1)

[Redis] Redis Cache를 활용해 데이터 조회 속도 개선하기 - (1)

 

 

이번 포스팅에서는 Redis 명령어를 직접적으로 사용하지 않고,

Spring Cache 어노테이션을 적용하여 조회 성능을 개선하는 방법을 알아보자.

 

 

 

 

 

 

 

📌   Spring Cache 어노테이션 이용하기 

  Spring의 캐싱 어노테이션을 사용하면, 애플리케이션 코드에서 직접적으로 Redis 명령어를 호출하지 않아도 Redis가 자동으로 사용된다. 캐싱 어노테이션의 종류는 다음과 같다.

 

 

 

1. @Cacheable : 메소드의 실행 결과를 캐시에 저장한다.

@Service
public class UserService {

    ...

    @Cacheable(cacheNames = "cacheName", key = "#key")
    public ReturnType methodName(ParamType key) {
        // 메소드 실행 로직
    }

    @Cacheable(cacheNames = "userCache", key = "#userId")
    public User getUserById(String userId) {
        // 메소드 실행 로직
    }
}

 

 

• 동일한 키로 메소드를 다시 호출하면 캐시 된 값을 반환한다.
• 캐시에 값이 있으면 메소드를 실행하지 않고 캐시 된 값을 반환한다.
• 캐시에 값이 없으면 메소드를 실행하고 결과를 캐시에 저장한다.
• 데이터베이스 조회와 같은 시간이 많이 걸리는 작업의 결과를 캐싱할 때 사용한다.

 

 

 

 

2. @CachePut : 메소드의 실행 결과를 캐시에 저장한다.

@Service
public class UserService {

    ...

    @CachePut(cacheNames = "cacheName", key = "#key")
    public ReturnType methodName(ParamType key) {
        // 메소드 실행 로직
    }

    @CachePut(cacheNames = "userCache", key = "#user.id")
    public User updateUser(User user) {
        // 메소드 실행 로직
    }
}

 

 

• 메소드를 실행한 후 항상 캐시를 갱신한다.
• 캐시를 갱신하지만 @Cacheable과 달리 메소드 실행을 생략하지 않는다.
• 매번 메소드를 실행하여 최신 값을 캐시에 저장한다.
• 특정 조건에 따라 캐시를 갱신해야 하는 경우에 사용한다.

 

 

 

 

3. @CacheEvict : 캐시에서 하나 이상의 항목을 제거한다.

@Service
public class UserService {

    ...    
    @CacheEvict(cacheNames = "cacheName", key = "#key", beforeInvocation = false)
    public void methodName(ParamType key) {
    // 메소드 실행 로직
    }

    @CacheEvict(cacheNames = "userCache", key = "#userId", beforeInvocation = true)
    public void deleteUserById(String userId) {
        // 메소드 실행 로직
    }
}

 

 

• 메소드 실행 후 캐시를 비운다.
• beforeInvocation 속성을 true로 설정하면 메소드 실행 전에 캐시를 비운다.
• 데이터 변경 후 캐시를 무효화하여 일관성을 유지할 때 사용한다.

 

 

 

 

---

 

 

 

 

    캐싱 어노테이션을 적용해 Redis의 캐싱 기능을 사용해 보자. Spring의 어노테이션 기반의 캐시 기능을 사용하기 위해서는 다음과 같이 의존성을 추가해주어야한다.

dependencies {
    // Spring Boot Starter for Cache
    implementation 'org.springframework.boot:spring-boot-starter-cache'

    // JSON 직렬화 및 역직렬화 관련 Jackson 라이브러리
    implementation 'com.fasterxml.jackson.core:jackson-databind'
    implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310'
}
/*
   직렬화: Java 객체를 JSON 문자열로 변환
   역직렬화: JSON 문자열을 Java 객체로 변환
*/

 

 

 

 

 

  지난번 동시성 제어 포스팅에서 Redis기본 세팅을 마쳤다는 가정하에, RedisConfig 클래스에 다음 로직을 추가해 준다.

[Redis] Redisson을 이용한 분산 락 구현으로 동시성 이슈 해결

@Configuration
public class RedisConfig {
    ...
    
    @Bean
    public RedisTemplate<String, Object> objectRedisTemplate(
        RedisConnectionFactory connectionFactory) {

        // ObjectMapper 설정 로직        
        
        RedisTemplate<String, Object> template = new RedisTemplate<>();

        template.setConnectionFactory(connectionFactory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer(objectMapper));
        
        return template;
    }
}

 

 

 

 

 

  Cache설정에 관련된 내용은 CacheConfig 클래스에 따로 분리해 준다. 캐시 설정을 활성화해주기 위해 @EnableCaching 어노테이션도 추가해 주도록 하자. 이때, TTL을 설정할 수 있는데, TTL(Time-To-Live)은 캐시에 저장된 데이터가 유지되는 시간을 나타낸다. 설정한 기간이 지나면 자동으로 삭제된다. TTL은 캐시 설정에서 중요한 부분이며, 데이터의 유효 기간을 관리하고 메모리 또는 디스크 공간을 최적화하는 데 도움을 준다.

@Configuration
@EnableCaching
public class CacheConfig {

    public static final String CACHE_180_SECOND = "cache180"; // 캐시 만료 시간 3분으로 설정

    @Bean
    public RedisCacheManager redisCacheManager(RedisConnectionFactory cf, ResourceLoader rl) {
        RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(
            cf);

        // ObjectMapper 설정 로직

        RedisCacheConfiguration configuration = RedisCacheConfiguration
            .defaultCacheConfig(rl.getClassLoader())
            .disableCachingNullValues()
            .serializeKeysWith(fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(
                fromSerializer(new GenericJackson2JsonRedisSerializer(objectMapper)))
            .entryTtl(Duration.ofDays(1));

        Map<String, RedisCacheConfiguration> cacheConfigurationMap = new HashMap<>();
        cacheConfigurationMap.put(CACHE_180_SECOND,
            configuration.entryTtl(Duration.ofSeconds(180L)));

        return builder.cacheDefaults(configuration)
            .withInitialCacheConfigurations(cacheConfigurationMap).build();
    }
}

 

 

 

  데이터의 수정이 자주 일어나지 않고, 단순 조회를 빈번하게 하는 장바구니 도메인에 @Cacheable, @CacheEvict 어노테이션을 적용해 보자.

@Service
@RequiredArgsConstructor
@Transactional
public class CartService {

    ...
    
    @CacheEvict(cacheNames = CACHE_180_SECOND, key = "'cart:' + #p0", beforeInvocation = false)
    public CartInfo addCart(String email, Long productId, Integer quantity) {
        // 장바구니 생성 로직
    }

    @CacheEvict(cacheNames = CACHE_180_SECOND, key = "'cart:' + #p0", beforeInvocation = false)
    public CartInfo updateCart(String email, Long cartId, Integer quantity) {
        // 장바구니 상품 수정 로직
    }

    @CacheEvict(cacheNames = CACHE_180_SECOND, key = "'cart:' + #p0", beforeInvocation = false)
    public void deleteCart(String email, Long cartId) {
        // 장바구니 상품 삭제 로직
    }

    @Transactional(readOnly = true)
    @Cacheable(cacheNames = CACHE_180_SECOND, key = "'cart:' + #p0")
    public List<CartInfo> getCarts(String email) {
       // 장바구니 조회 로직 
    }
}

 

✔️ 사용된 캐시 전략

  읽기 전략: 캐시를 먼저 확인하고, 캐시에 데이터가 없을 경우 DB에서 데이터를 가져오는 Look Aside(Lazy Loading) 전략 사용.
  쓰기 전략: 변경된 내용만 DB에 반영하고 해당 캐시는 제거 또는 무효화하는 Write-around전략 사용.

 

 

 

 

 

  캐시 어노테이션을 적용하고, 장바구니 조회 API를 실행해 보면 Redis에 데이터가 없으므로 조회 쿼리가 실행되는 것을 확인할 수 있다. 이때, @Cacheable에 의해 Redis에 데이터가 저장된다.

<장바구니 조회 API를 실행하면 쿼리가 실행되는 것을 확인할 수 있다.>

 

 

 

  그 후, 다시 한번 조회해 보면 쿼리는 실행되지 않고 캐시에서 조회가 되는 것을 확인할 수 있다. @Cacheable에 의해 Redis에서 조회가 이루어진다. 또한, 장바구니 수정 및 삭제가 일어났을 경우에 @CacheEvict에 의해 데이터가 삭제되는 것을 확인할 수 있다.

<redis-cli에서 cache가 저장되어 조회되는 것과 삭제되어 조회되지 않는 것을 확인할 수 있다.>

 

  

 

  위에서 설명한 대로 Look Aside + Write Around  조합이 사용되었기 때문에 DB에 저장된 데이터가 수정, 추가, 삭제될 때마다 캐시 또한 삭제해주어야 한다. 만약, 데이터가 변경될 때마다 캐시를 비워주지 않으면 캐시와 DB의 데이터 사이에 정합성 문제가 발생한다. 그렇기 때문에 데이터가 변경될 때마다 캐시를 제거해 주는 작업이 중요하다.

 

 

 

---

 

 

 

 

📌   Redis Cache를 활용해 데이터 조회 성능 개선하기

  캐시가 저장되는 것을 확인했으니 성능 개선이 되는지 직접 확인을 해보자.

<10,000건의 데이터를 넣고 조회를 했을 때의 응답 속도 - 캐시에서 가져오기 전>

 

 

 

  이렇게 대량의 데이터를 조회할 경우, 응답 속도가 지연되는 것을 확인하였다. 사용자가 늘어남에 따라 서버에 같은 요청이 반복적으로 발생했을 때, DB에 무리가 가고 성능이 떨어질 수 있다. 캐싱 처리 전, DB에서 조회 쿼리가 실행되고 10,000건의 데이터를 기준으로 4460ms의 응답 속도가 걸리는 것을 확인할 수 있다. 캐싱이 적용되었을 때 얼만큼의 차이가 있는지 확인해보자.

<10,000건의 데이터를 넣고 조회를 했을 때의 응답 속도 - 캐시에서 가져온 데이터>

 

 

 

  조회 쿼리가 실행되지 않으며, 데이터를 캐시에서 가져오는 것을 확인할 수 있다. 응답 속도 또한 199ms로 95.5%가 감소한 것을 확인할 수 있다. 캐싱 전후의 성능 차이를 확인하기 위해 조금 더 많은 데이터를 조회하는 상황에서 비교를 해보자. 

 

<캐시 적용 전과 후의 조회 응답 속도>

 

 

 

  조회 응답 속도 성능측정 결과, 조회하는 데이터의 수가 많아질수록 응답시간이 5배가량 차이나는 것을 확인할 수 있었다.

* 위의 성능 비교는 전부 같은 환경에서 테스트를 진행한 것이지만, 보다 정확한 성능 비교를 위해서는 상세한 테스트가 필요할 것이다.

 

 

 

 

 

 

 

  여기까지 Spring Cache 어노테이션 및 Redis Cache를 활용해 데이터 조회 속도를 개선하는 법에 대해 알아보았다.

 

 

 

 

 

📌  참고

Spring Cache, 제대로 사용하기

 

 

Redis 에 @Cacheable, @CachePut, @CacheEvict 적용해보기

 

[Spring + Redis] Redis cache를 적용해 조회 성능 개선 방법

 

 

Spring Boot와 Redis로 캐싱 구현하기 | 요즘IT