<div id="readability-page-1" class="page"><div role="banner"> <div> <h4>29 Aug 2024</h4> Reading time ~4 minutes 
 </div> <h2 id="redis와-spring-aop를-이용한-캐시-관리-rediscacheable로-ttl-설정하기">Redis와 Spring AOP를 이용한 캐시 관리: RedisCacheable로 TTL 설정하기</h2> 애플리케이션 성능을 최적화하기 위해서는 캐시를 활용하는 것이 매우 중요합니다. 특히, Redis는 고속의 인메모리 데이터 저장소로써 Spring과 결합해 캐시를 관리하는 데 아주 유용합니다. 이번 포스팅에서는 <a href="https://github.com/RedisCacheable">@RedisCacheable</a>이라는 커스텀 어노테이션을 사용하여 TTL(Time to Live)로 Redis 캐시의 생명주기를 관리하는 방법을 소개하려 합니다. <h2 id="1-rediscacheable-어노테이션-정의">1. <a href="https://github.com/RedisCacheable">@RedisCacheable</a> 어노테이션 정의</h2> 우선 <a href="https://github.com/RedisCacheable">@RedisCacheable</a> 어노테이션을 정의합니다. 이 어노테이션은 메서드에 적용되어, 메서드의 반환값을 Redis에 캐싱하도록 해줍니다. 이를 통해 반복되는 데이터 조회 작업의 부담을 줄일 수 있습니다. <div><pre><code>@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class RedisCacheable(
 val name: String,
 val key: String = "",
 val ttl: Long = -1,
 val hasClassAndMethodNamePrefix: Boolean = false
)

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class RedisCacheEvict(
 val name: Array&lt;String&gt;,
 val key: String = "",
 val clearAll: Boolean = false,
 val hasClassAndMethodNamePrefix: Boolean = false
)

package com.samsungfire.chacpet.common.annotation

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class RedisCacheEvict(
 val name: Array&lt;String&gt;,
 val key: String = "",
 val clearAll: Boolean = false,
 val hasClassAndMethodNamePrefix: Boolean = false
)

</code></pre></div> <ul> <li>name: Redis에서 사용할 캐시 이름을 지정합니다.</li> <li>key: 캐시에 사용할 특정 키를 지정합니다. 메서드의 파라미터 값들을 기반으로 키가 생성됩니다.</li> <li>ttl: 캐시의 유효 기간을 초 단위로 설정합니다. 기본값은 -1로, 이 경우 캐시가 만료되지 않습니다.</li> <li>hasClassAndMethodNamePrefix: 캐시 키에 클래스와 메서드 이름을 포함할지 여부를 설정합니다.</li> <li>clearAll: 주어진 명명 이하로 * 를 추가해서 삭제시 사용</li> </ul> <ol> <li>RedisCacheable 어노테이션 처리하기 이제 AOP를 사용해 RedisCacheable 어노테이션을 처리하는 방법을 설명하겠습니다. RedisCacheAspect 클래스를 통해 어노테이션이 적용된 메서드를 가로채어 캐시를 관리하는 로직을 추가합니다.</li> </ol> <div><pre><code>@Aspect
@Component
class RedisCacheAspect(
 private val redisTemplate: RedisTemplate&lt;String, Any?&gt;
) {

 @Around("@annotation(redisCacheable)")
 fun cacheableProcess(joinPoint: ProceedingJoinPoint, redisCacheable: RedisCacheable): Any? {
 val cacheKey = generateKey(
 redisCacheable.name,
 joinPoint,
 redisCacheable.hasClassAndMethodNamePrefix,
 redisCacheable.key
 )
 val cacheTTL = redisCacheable.ttl

 redisTemplate.opsForValue().get(cacheKey)?.let {
 return it
 }

 val methodReturnValue = joinPoint.proceed()
 if (cacheTTL &lt; 0) {
 redisTemplate.opsForValue().set(cacheKey, methodReturnValue)
 } else {
 redisTemplate.opsForValue().set(cacheKey, methodReturnValue, cacheTTL, TimeUnit.SECONDS)
 }
 return methodReturnValue
 }


 @Around("@annotation(redisCacheEvict)")
 fun cacheEvictProcess(joinPoint: ProceedingJoinPoint, redisCacheEvict: RedisCacheEvict): Any? {
 val methodReturnValue = joinPoint.proceed()

 redisCacheEvict.name.forEach { cacheName -&gt;
 if (redisCacheEvict.clearAll) {
 val keys = redisTemplate.keys("$cacheName*")
 if (keys.isNotEmpty()) {
 redisTemplate.delete(keys)
 }
 } else {
 val cacheKey =
 generateKey(cacheName, joinPoint, redisCacheEvict.hasClassAndMethodNamePrefix, redisCacheEvict.key)
 redisTemplate.delete(cacheKey)
 }
 }

 return methodReturnValue
 }


 @Around("@annotation(redisCachePut)")
 fun cachePutProcess(joinPoint: ProceedingJoinPoint, redisCachePut: RedisCachePut): Any? {
 val cacheKey = generateKey(
 redisCachePut.name,
 joinPoint,
 redisCachePut.hasClassAndMethodNamePrefix,
 redisCachePut.key
 )
 val cacheTTL = redisCachePut.ttl

 val methodReturnValue = joinPoint.proceed()
 if (cacheTTL &lt; 0) {
 redisTemplate.opsForValue().set(cacheKey, methodReturnValue)
 } else {
 redisTemplate.opsForValue().set(cacheKey, methodReturnValue, cacheTTL, TimeUnit.SECONDS)
 }
 return methodReturnValue
 }

 private fun generateKey(
 cacheName: String,
 joinPoint: ProceedingJoinPoint,
 hasClassAndMethodNamePrefix: Boolean,
 key: String
 ): String {
 val generatedKey = if (key.isEmpty()) {
 StringUtils.arrayToCommaDelimitedString(joinPoint.args)
 } else {
 getParameterValueByKey(joinPoint, key)
 ?: throw IllegalArgumentException("No matching parameter for key: $key")
 }

 return if (hasClassAndMethodNamePrefix) {
 val target = joinPoint.target::class.simpleName
 val method = (joinPoint.signature as MethodSignature).method.name
 "$cacheName::$target.$method($generatedKey)"
 } else {
 "$cacheName::($generatedKey)"
 }
 }

 private val parser = SpelExpressionParser()
 private fun getParameterValueByKey(joinPoint: ProceedingJoinPoint, key: String): String? {
 val signature = joinPoint.signature as MethodSignature
 val parameterNames = signature.parameterNames

 val context = StandardEvaluationContext()
 parameterNames.forEachIndexed { index, indexedValue
 -&gt; context.setVariable(indexedValue, joinPoint.args[index]) }

 return parser.parseExpression(key).getValue(context, String::class.java)
 }
}
</code></pre></div> <h2 id="3-캐시-키-생성과-ttl-적용">3. 캐시 키 생성과 TTL 적용</h2> generateKey 메서드를 이용해 캐시 키를 생성합니다. 이 키는 Redis에 저장될 데이터의 고유 식별자가 됩니다. TTL 값은 캐시의 생명주기를 관리하는 데 사용되며, 지정된 TTL이 지나면 캐시는 자동으로 만료됩니다. TTL 값이 지정되지 않았다면 캐시는 영구적으로 유지됩니다. <h2 id="4-실제-사용-예시">4. 실제 사용 예시</h2> 이제 <a href="https://github.com/RedisCacheable">@RedisCacheable</a> 어노테이션을 실제 코드에 적용해 보겠습니다: <div><pre><code>@RedisCacheable(name = "petCache", key = "#petType", ttl = 3600)
fun getPetDetails(petType: String): PetDetails {
 // 데이터베이스 또는 외부 API를 통해 데이터를 조회하는 로직
 return petService.getPetDetails(petType)
}
</code></pre></div> 위 메서드는 petType을 키로 하여 petCache에 캐싱됩니다. 캐시는 3600초(1시간) 동안 유효하며, 이후에는 자동으로 만료됩니다. <h2 id="5-적재된-cache가-redis-에서-조회가-안될-경우-처리-방법">5. 적재된 cache가 redis 에서 조회가 안될 경우 처리 방법</h2> <div><pre><code> @Bean
 fun redisTemplate(connectionFactory: RedisConnectionFactory): RedisTemplate&lt;String, Any&gt;? {
 val template = RedisTemplate&lt;String, Any&gt;().apply {
 setConnectionFactory(connectionFactory)
 setKeySerializer(StringRedisSerializer())
 }
 return template
 }
</code></pre></div> <code>setKeySerializer(StringRedisSerializer())</code> 라인은 RedisTemplate이 Redis에 데이터를 저장하거나 조회할 때 사용하는 키의 직렬화 방식을 설정하는 부분입니다. RedisTemplate은 Redis와의 상호작용을 추상화하여 간단한 API를 제공합니다. 이 때 Redis에 저장되는 데이터의 키와 값은 각각 직렬화가 필요합니다. KeySerializer는 Redis에 저장되는 키를 어떻게 직렬화할지를 결정합니다. 기본적으로 RedisTemplate의 키 직렬화는 <code>JdkSerializationRedisSerializer</code>을 사용합니다. 이 방식은 Java의 기본 직렬화 방식을 사용하여 객체를 바이트 배열로 변환합니다. 하지만, 일반적으로 Redis 키는 문자열로 저장되는 것이 좋습니다. 그 이유는 <ul> <li>문자열은 Redis CLI나 기타 관리 도구로 쉽게 조회할 수 있습니다.</li> <li>다른 언어나 시스템과의 호환성이 높습니다.</li> </ul> <h2 id="마치며">마치며</h2> 이번 포스팅에서는 <a href="https://github.com/RedisCacheable">@RedisCacheable</a> 어노테이션과 AOP를 활용해 Redis 캐싱을 어떻게 구현하고 TTL로 캐시의 생명주기를 관리하는지를 살펴보았습니다. 이를 통해 데이터 조회 성능을 크게 향상시킬 수 있으며, 특히 빈번한 데이터 변경이 없는 경우 유용하게 사용할 수 있습니다. Redis와 Spring의 조합을 통해 성능 최적화에 한 발 더 나아가 보세요! <h2 id="참고자료">참고자료</h2> <ul> <li><a href="https://docs.spring.io/spring-data/redis/reference/redis/redis-cache.html">Redis Cache</a></li> <li><a href="https://github.com/spring-projects/spring-framework/blob/main/spring-context/src/main/java/org/springframework/cache/interceptor/SimpleKey.java">spring-framework/spring-context/src/main/java/org/springframework/cache/interceptor/SimpleKey.java</a></li> <li><a href="https://jgrammer.tistory.com/entry/Spring-Boot-%EB%A7%8C%EB%A3%8C%EC%8B%9C%EA%B0%84-%EC%84%A4%EC%A0%95%EC%9D%84-%EC%9C%84%ED%95%9C-Redis-Cache-AOP-%EC%9E%91%EC%84%B1">Spring Boot 캐시 만료시간 설정을 위한 Redis Cache AOP 작성</a></li> </ul> </div></div>

lahuman

Daniel Lim

Redis와 Spring AOP를 이용한 캐시 관리: RedisCacheable로 TTL 설정하기
애플리케이션 성능을 최적화하기 위해서는 캐시를 활용하는 것이 매우 중요합니다. 특히, Redis는 고속의 인메모리 데이터 저장소로써 Spring과 결합해 캐시를 관리하는 데 아주 유용합니다. 이번 포스팅에서는 @RedisCacheable이라는 커스텀 어노테이션을 사용하여 TTL(Time to Live)로 Redis 캐시의 생명주기를 관리하는 방법을 소개하려 합니다.
1. @RedisCacheable 어노테이션 정의
우선 @RedisCacheable 어노테이션을 정의합니다. 이 어노테이션은 메서드에 적용되어, 메서드의 반환값을 Redis에 캐싱하도록 해줍니다. 이를 통해 반복되는 데이터 조회 작업의 부담을 줄일 수 있습니다.
@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class RedisCacheable(
 val name: String,
 val key: String = "",
 val ttl: Long = -1,
 val hasClassAndMethodNamePrefix: Boolean = false
)
@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class RedisCacheEvict(
 val name: Array<String>,
 val key: String = "",
 val clearAll: Boolean = false,
 val hasClassAndMethodNamePrefix: Boolean = false
)
package com.samsungfire.chacpet.common.annotation
@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class RedisCacheEvict(
 val name: Array<String>,
 val key: String = "",
 val clearAll: Boolean = false,
 val hasClassAndMethodNamePrefix: Boolean = false
)
name: Redis에서 사용할 캐시 이름을 지정합니다.
key: 캐시에 사용할 특정 키를 지정합니다. 메서드의 파라미터 값들을 기반으로 키가 생성됩니다.
ttl: 캐시의 유효 기간을 초 단위로 설정합니다. 기본값은 -1로, 이 경우 캐시가 만료되지 않습니다.
hasClassAndMethodNamePrefix: 캐시 키에 클래스와 메서드 이름을 포함할지 여부를 설정합니다.
clearAll: 주어진 명명 이하로 * 를 추가해서 삭제시 사용
RedisCacheable 어노테이션 처리하기
이제 AOP를 사용해 RedisCacheable 어노테이션을 처리하는 방법을 설명하겠습니다. RedisCacheAspect 클래스를 통해 어노테이션이 적용된 메서드를 가로채어 캐시를 관리하는 로직을 추가합니다.
@Aspect
@Component
class RedisCacheAspect(
 private val redisTemplate: RedisTemplate<String, Any?>
) {
 @Around("@annotation(redisCacheable)")
 fun cacheableProcess(joinPoint: ProceedingJoinPoint, redisCacheable: RedisCacheable): Any? {
 val cacheKey = generateKey(
 redisCacheable.name,
 joinPoint,
 redisCacheable.hasClassAndMethodNamePrefix,
 redisCacheable.key
 )
 val cacheTTL = redisCacheable.ttl
 redisTemplate.opsForValue().get(cacheKey)?.let {
 return it
 }
 val methodReturnValue = joinPoint.proceed()
 if (cacheTTL < 0) {
 redisTemplate.opsForValue().set(cacheKey, methodReturnValue)
 } else {
 redisTemplate.opsForValue().set(cacheKey, methodReturnValue, cacheTTL, TimeUnit.SECONDS)
 }
 return methodReturnValue
 }
 @Around("@annotation(redisCacheEvict)")
 fun cacheEvictProcess(joinPoint: ProceedingJoinPoint, redisCacheEvict: RedisCacheEvict): Any? {
 val methodReturnValue = joinPoint.proceed()
 redisCacheEvict.name.forEach { cacheName ->
 if (redisCacheEvict.clearAll) {
 val keys = redisTemplate.keys("$cacheName*")
 if (keys.isNotEmpty()) {
 redisTemplate.delete(keys)
 }
 } else {
 val cacheKey =
 generateKey(cacheName, joinPoint, redisCacheEvict.hasClassAndMethodNamePrefix, redisCacheEvict.key)
 redisTemplate.delete(cacheKey)
 }
 }
 return methodReturnValue
 }
 @Around("@annotation(redisCachePut)")
 fun cachePutProcess(joinPoint: ProceedingJoinPoint, redisCachePut: RedisCachePut): Any? {
 val cacheKey = generateKey(
 redisCachePut.name,
 joinPoint,
 redisCachePut.hasClassAndMethodNamePrefix,
 redisCachePut.key
 )
 val cacheTTL = redisCachePut.ttl
 val methodReturnValue = joinPoint.proceed()
 if (cacheTTL < 0) {
 redisTemplate.opsForValue().set(cacheKey, methodReturnValue)
 } else {
 redisTemplate.opsForValue().set(cacheKey, methodReturnValue, cacheTTL, TimeUnit.SECONDS)
 }
 return methodReturnValue
 }
 private fun generateKey(
 cacheName: String,
 joinPoint: ProceedingJoinPoint,
 hasClassAndMethodNamePrefix: Boolean,
 key: String
 ): String {
 val generatedKey = if (key.isEmpty()) {
 StringUtils.arrayToCommaDelimitedString(joinPoint.args)
 } else {
 getParameterValueByKey(joinPoint, key)
 ?: throw IllegalArgumentException("No matching parameter for key: $key")
 }
 return if (hasClassAndMethodNamePrefix) {
 val target = joinPoint.target::class.simpleName
 val method = (joinPoint.signature as MethodSignature).method.name
 "$cacheName::$target.$method($generatedKey)"
 } else {
 "$cacheName::($generatedKey)"
 }
 }
 private val parser = SpelExpressionParser()
 private fun getParameterValueByKey(joinPoint: ProceedingJoinPoint, key: String): String? {
 val signature = joinPoint.signature as MethodSignature
 val parameterNames = signature.parameterNames
 val context = StandardEvaluationContext()
 parameterNames.forEachIndexed { index, indexedValue
 -> context.setVariable(indexedValue, joinPoint.args[index]) }
 return parser.parseExpression(key).getValue(context, String::class.java)
 }
}
3. 캐시 키 생성과 TTL 적용
generateKey 메서드를 이용해 캐시 키를 생성합니다. 이 키는 Redis에 저장될 데이터의 고유 식별자가 됩니다. TTL 값은 캐시의 생명주기를 관리하는 데 사용되며, 지정된 TTL이 지나면 캐시는 자동으로 만료됩니다. TTL 값이 지정되지 않았다면 캐시는 영구적으로 유지됩니다.
4. 실제 사용 예시
이제 @RedisCacheable 어노테이션을 실제 코드에 적용해 보겠습니다:
@RedisCacheable(name = "petCache", key = "#petType", ttl = 3600)
fun getPetDetails(petType: String): PetDetails {
 // 데이터베이스 또는 외부 API를 통해 데이터를 조회하는 로직
 return petService.getPetDetails(petType)
}
위 메서드는 petType을 키로 하여 petCache에 캐싱됩니다. 캐시는 3600초(1시간) 동안 유효하며, 이후에는 자동으로 만료됩니다.
5. 적재된 cache가 redis 에서 조회가 안될 경우 처리 방법
 @Bean
 fun redisTemplate(connectionFactory: RedisConnectionFactory): RedisTemplate<String, Any>? {
 val template = RedisTemplate<String, Any>().apply {
 setConnectionFactory(connectionFactory)
 setKeySerializer(StringRedisSerializer())
 }
 return template
 }
setKeySerializer(StringRedisSerializer()) 라인은 RedisTemplate이 Redis에 데이터를 저장하거나 조회할 때 사용하는 키의 직렬화 방식을 설정하는 부분입니다.
RedisTemplate은 Redis와의 상호작용을 추상화하여 간단한 API를 제공합니다. 이 때 Redis에 저장되는 데이터의 키와 값은 각각 직렬화가 필요합니다. KeySerializer는 Redis에 저장되는 키를 어떻게 직렬화할지를 결정합니다.
기본적으로 RedisTemplate의 키 직렬화는 JdkSerializationRedisSerializer을 사용합니다. 이 방식은 Java의 기본 직렬화 방식을 사용하여 객체를 바이트 배열로 변환합니다. 하지만, 일반적으로 Redis 키는 문자열로 저장되는 것이 좋습니다. 그 이유는
문자열은 Redis CLI나 기타 관리 도구로 쉽게 조회할 수 있습니다.
다른 언어나 시스템과의 호환성이 높습니다.
마치며
이번 포스팅에서는 @RedisCacheable 어노테이션과 AOP를 활용해 Redis 캐싱을 어떻게 구현하고 TTL로 캐시의 생명주기를 관리하는지를 살펴보았습니다. 이를 통해 데이터 조회 성능을 크게 향상시킬 수 있으며, 특히 빈번한 데이터 변경이 없는 경우 유용하게 사용할 수 있습니다. Redis와 Spring의 조합을 통해 성능 최적화에 한 발 더 나아가 보세요!
참고자료
Redis Cache
spring-framework/spring-context/src/main/java/org/springframework/cache/interceptor/SimpleKey.java
Spring Boot 캐시 만료시간 설정을 위한 Redis Cache AOP 작성

Spring framework Cache

댓글