feat : redis TTL 적용

local -> ehCache
이외의 profile -> redis
사용하도록 변경

app/kac-app/src/main/java/kr/co/palnet/kac/app/config/CachingConfig.java

@@ -13,43 +13,40 @@ import org.springframework.cache.jcache.JCacheCacheManager;
 import org.springframework.context.annotation.AdviceMode;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Primary;
+import org.springframework.context.annotation.Profile;
 
 import javax.cache.Caching;
 import javax.cache.spi.CachingProvider;
 import java.time.Duration;
 
 @Configuration
+@Profile("local")
 @EnableCaching(proxyTargetClass = true, mode = AdviceMode.PROXY)
 public class CachingConfig {
 
-    @Primary
+
-    @Bean(name = "ehCacheManager")
+    @Bean(name = "customCacheManager")
     public JCacheCacheManager ehCacheManager() {
         CachingProvider cachingProvider = Caching.getCachingProvider();
         javax.cache.CacheManager jCacheManager = cachingProvider.getCacheManager();
 
-        javax.cache.configuration.Configuration<Object, Object> jCacheConfiguration =
+        //이부분에 캐싱 설정 추가
-                Eh107Configuration.fromEhcacheCacheConfiguration(
+        jCacheManager.createCache("code", createCacheConfiguration(Duration.ofSeconds(10), Duration.ofSeconds(20)));
-                CacheConfigurationBuilder.newCacheConfigurationBuilder(Object.class, Object.class,
+        jCacheManager.createCache("flight", createCacheConfiguration(Duration.ofSeconds(10), Duration.ofSeconds(20)));
-                                ResourcePoolsBuilder.newResourcePoolsBuilder()
-                                        .heap(10000, EntryUnit.ENTRIES))
-                        .withSizeOfMaxObjectSize(1000, MemoryUnit.B)
-                        .withExpiry(ExpiryPolicyBuilder.timeToIdleExpiration(Duration.ofSeconds(10)))
-                        .withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(Duration.ofSeconds(10))));
 
-        jCacheManager.createCache("code", jCacheConfiguration);
+        return new JCacheCacheManager(jCacheManager);
-        jCacheManager.createCache("flight", Eh107Configuration.fromEhcacheCacheConfiguration(
+    }
+    
+    //cache 기본 설정
+    private javax.cache.configuration.Configuration<Object, Object> createCacheConfiguration(Duration timeToIdle, Duration timeToLive) {
+        return  Eh107Configuration.fromEhcacheCacheConfiguration(
                 CacheConfigurationBuilder.newCacheConfigurationBuilder(Object.class, Object.class,
                                 ResourcePoolsBuilder.newResourcePoolsBuilder()
                                         .heap(5000, EntryUnit.ENTRIES))
                         .withSizeOfMaxObjectSize(500, MemoryUnit.B)
-                        .withExpiry(ExpiryPolicyBuilder.timeToIdleExpiration(Duration.ofSeconds(10)))
+                        .withExpiry(ExpiryPolicyBuilder.timeToIdleExpiration(timeToIdle))
-                        .withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(Duration.ofSeconds(20)))));
+                        .withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(timeToLive)));
-
-        return new JCacheCacheManager(jCacheManager);
     }
-
     @Bean
     public HibernatePropertiesCustomizer hibernatePropertiesCustomizer(CacheManager cacheManager) {
         return hibernateProperties -> hibernateProperties.put(org.hibernate.cache.jcache.ConfigSettings.CACHE_MANAGER, cacheManager);

app/kac-app/src/main/java/kr/co/palnet/kac/app/config/RedisCacheConfig.java

@@ -7,6 +7,7 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
 import org.springframework.data.redis.cache.RedisCacheConfiguration;
 import org.springframework.data.redis.cache.RedisCacheManager;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
@@ -17,9 +18,12 @@ import org.springframework.data.redis.serializer.RedisSerializationContext;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 
 import java.time.Duration;
+import java.util.HashMap;
+import java.util.Map;
 
 @Configuration
 @EnableCaching
+@Profile("!local")
 public class RedisCacheConfig {
 
     @Value("${spring.data.redis.host}")
@@ -41,59 +45,37 @@ public class RedisCacheConfig {
         return lettuceConnectionFactory;
     }
 
-//    @Bean
+    @Bean(name = "customCacheManager")
-//    public RedisCacheManager redisCacheManager(RedisConnectionFactory connectionFactory) {
-//        // local date time 역직렬화 위해 추가 코드
-//        ObjectMapper objectMapper = new ObjectMapper();
-//        objectMapper.registerModule(new JavaTimeModule());
-//        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
-//        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(objectMapper);
-//
-//        RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig()
-//                .entryTtl(Duration.ofSeconds(600))
-//                .disableCachingNullValues()
-//                .serializeKeysWith(
-//                        RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())
-//                )
-//                .serializeValuesWith(
-//                        RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer)
-//                );
-//
-//        Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
-//        for (CacheType value : CacheType.values()) {
-//            cacheConfigurations.put(value.name(),
-//                    RedisCacheConfiguration.defaultCacheConfig()
-//                            .prefixCacheNameWith("code")
-//                            .entryTtl(Duration.ofSeconds(600))
-//                            .disableCachingNullValues()
-//                            .serializeKeysWith(
-//                                    RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())
-//                            )
-//                            .serializeValuesWith(
-//                                    RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer)
-//                            ));
-//        }
-//
-//        return RedisCacheManager.RedisCacheManagerBuilder
-//                .fromConnectionFactory(connectionFactory)
-//                .cacheDefaults(configuration)
-//                .withInitialCacheConfigurations(cacheConfigurations).build();
-//    }
-
-    @Bean(name = "redisCacheManager")
     public RedisCacheManager redisCacheManager(RedisConnectionFactory cf) {
-    	ObjectMapper objectMapper = new ObjectMapper();
-    	objectMapper.registerModule(new JavaTimeModule());
-    	objectMapper.activateDefaultTyping(objectMapper.getPolymorphicTypeValidator(),
-    			ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
-    	GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(objectMapper);
 
-        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
+        return RedisCacheManager
+                .RedisCacheManagerBuilder
+                .fromConnectionFactory(cf)
+                .cacheDefaults(defaultConfig())
+                .withInitialCacheConfigurations(customConfigurationMap())
+                .build();
+    }
+
+    //캐시 설정 추가
+    private Map<String, RedisCacheConfiguration> customConfigurationMap() {
+        Map<String, RedisCacheConfiguration> customConfigurationMap = new HashMap<>();
+        customConfigurationMap.put("code", defaultConfig().entryTtl(Duration.ofSeconds(10L)));
+        customConfigurationMap.put("flight", defaultConfig().entryTtl(Duration.ofMinutes(1L)));
+        return customConfigurationMap;
+    }
+    
+    //기본설정
+    private RedisCacheConfiguration defaultConfig() {
+        ObjectMapper objectMapper = new ObjectMapper();
+        objectMapper.registerModule(new JavaTimeModule());
+        objectMapper.activateDefaultTyping(objectMapper.getPolymorphicTypeValidator(),
+                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
+        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(objectMapper);
+
+        return RedisCacheConfiguration.defaultCacheConfig()
                 .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer))
                 .entryTtl(Duration.ofMinutes(3L));
-
-        return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(cf).cacheDefaults(redisCacheConfiguration).build();
     }
 
 }

web/api-common/src/main/java/kr/co/palnet/kac/api/v1/common/code/service/ComCodeService.java

@@ -19,13 +19,13 @@ import java.util.List;
 @Slf4j
 @RequiredArgsConstructor
 @Service
-@CacheConfig(cacheNames = "code")
+@CacheConfig
 public class ComCodeService {
 
     private final ComCodeDomainService comCodeDomainService;
     
     // 모든 코드 조회
-    @Cacheable(value = "code", key = "#rq?.siteCd", cacheManager = "ehCacheManager")
+    @Cacheable(cacheNames = "code", key = "#rq?.siteCd", cacheManager = "customCacheManager")
     public CodeGroupRSWrapper getAllGroup(SearchCodeAllRQ rq) {
         List<ComCdGroupBas> comCdGroupBasList = comCodeDomainService.getComCdGroupBasList(rq.getSiteCd());
         List<CodeGroupRS> codeGroupRSList = comCdGroupBasList.stream().map(group -> {
@@ -56,7 +56,7 @@ public class ComCodeService {
     }
 
     // 그룹 목록 조회 - 코드 그룹만
-    @Cacheable(value = "code", key = "'all'" , cacheManager = "redisCacheManager")
+    @Cacheable(cacheNames = "code", key = "'all'" , cacheManager = "customCacheManager")
     public CodeGroupRSWrapper getAllGroupCode() {
         List<ComCdGroupBas> comCdGroupBasList = comCodeDomainService.getComCdGroupBasList();
         List<CodeGroupRS> rs = comCdGroupBasList.stream().map(CodeGroupRS::toRS).toList();
@@ -67,7 +67,7 @@ public class ComCodeService {
     }
 
     // 코드 목록 조회 - 코드 - 언어
-    @Cacheable(value = "flight", key = "'KeyIs:' + #rq?.groupCd + '/' +#rq?.langDivCd")
+    @Cacheable(cacheNames = "flight", key = "'KeyIs:' + #rq?.groupCd + '/' +#rq?.langDivCd", cacheManager = "customCacheManager")
     public CodeRsWrapper getAllCodeByGroup(SearchCodeRQ rq) {
         List<ComCdBas> comCdBasList = comCodeDomainService.getComCdBasList(rq.getGroupCd());
         List<CodeRS> rs = comCdBasList.stream().map(entity -> {