Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.config;

import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
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;
import java.util.concurrent.TimeUnit;

@Configuration
@EnableCaching
@PropertySource("classpath:application.properties")
public class CacheConfig extends CachingConfigurerSupport {

        @Override
        @Bean
        public CacheManager cacheManager() {
                CaffeineCacheManager cacheManager = new CaffeineCacheManager();
                return cacheManager;
        }

        @Bean
        public CacheManager timeoutCacheManager() {
                CaffeineCacheManager cacheManager = new CaffeineCacheManager();
                Caffeine<Object, Object> caffeine = Caffeine.newBuilder().expireAfterWrite(5, TimeUnit.MINUTES);
                cacheManager.setCaffeine(caffeine);
                return cacheManager;
        }

        @Bean
        public CacheManager timeout15CacheManager() {
                CaffeineCacheManager cacheManager = new CaffeineCacheManager();
                Caffeine<Object, Object> caffeine = Caffeine.newBuilder().expireAfterWrite(15, TimeUnit.MINUTES);
                cacheManager.setCaffeine(caffeine);
                return cacheManager;
        }

        @Bean
        public CacheManager oneDayCacheManager() {
                CaffeineCacheManager cacheManager = new CaffeineCacheManager();
                Caffeine<Object, Object> caffeine = Caffeine.newBuilder().expireAfterWrite(6, TimeUnit.HOURS);
                cacheManager.setCaffeine(caffeine);
                return cacheManager;
        }


        @Bean
        public CacheManager twoMintimeoutCacheManager() {
                CaffeineCacheManager cacheManager = new CaffeineCacheManager();
                Caffeine<Object, Object> caffeine = Caffeine.newBuilder().expireAfterWrite(2, TimeUnit.MINUTES);
                cacheManager.setCaffeine(caffeine);
                return cacheManager;
        }

        @Bean
        public CacheManager fiveMintimeoutCacheManager() {
                CaffeineCacheManager cacheManager = new CaffeineCacheManager();
                Caffeine<Object, Object> caffeine = Caffeine.newBuilder().expireAfterWrite(5, TimeUnit.MINUTES);
                cacheManager.setCaffeine(caffeine);
                return cacheManager;
        }

        @Bean
        public CacheManager thirtyMinsTimeOutCacheManager() {
                CaffeineCacheManager cacheManager = new CaffeineCacheManager();
                Caffeine<Object, Object> caffeine = Caffeine.newBuilder().expireAfterWrite(30, TimeUnit.MINUTES);
                cacheManager.setCaffeine(caffeine);
                return cacheManager;


        }


        @Bean
        JedisConnectionFactory jedisConnectionFactory() {
                return new JedisConnectionFactory();
        }

        @Bean
        public RedisTemplate<String, Object> redisTemplate() {
                RedisTemplate<String, Object> template = new RedisTemplate<>();
                template.setConnectionFactory(jedisConnectionFactory());
                template.setKeySerializer(new StringRedisSerializer());
                template.setValueSerializer(new GenericJackson2JsonRedisSerializer(getObjectMapper()));
                template.setHashKeySerializer(new StringRedisSerializer());
                template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer(getObjectMapper()));
                return template;
        }

        @Bean
        public RedisCacheConfiguration cacheConfiguration() {
                return RedisCacheConfiguration.defaultCacheConfig()
                                .entryTtl(Duration.ofMinutes(120))
                                .disableCachingNullValues()
                                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(
                                                new GenericJackson2JsonRedisSerializer(
                                                                this.getObjectMapper().enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY))));
        }

        private ObjectMapper getObjectMapper() {
                ObjectMapper mapper = new ObjectMapper().registerModule(new JavaTimeModule());
                return mapper;
        }

        @Bean
        public CacheManager redisVeryShortCacheManager() {
                return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(jedisConnectionFactory())
                                .cacheDefaults(cacheConfiguration().entryTtl(Duration.ofMinutes(15)))
                                .build();
        }

        @Bean
        public CacheManager redisShortCacheManager() {
                return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(jedisConnectionFactory())
                                .cacheDefaults(cacheConfiguration().entryTtl(Duration.ofMinutes(60)))
                                .build();
        }
        private RedisCacheConfiguration jdkCacheConfiguration(Duration ttl) {
                return RedisCacheConfiguration.defaultCacheConfig()
                                .entryTtl(ttl)
                                .disableCachingNullValues()
                                .serializeValuesWith(RedisSerializationContext.SerializationPair
                                                .fromSerializer(new JdkSerializationRedisSerializer()));
        }

        @Bean
        public CacheManager redisCacheManager() {
                RedisCacheConfiguration defaultJsonConfig = cacheConfiguration().entryTtl(Duration.ofHours(6));
                RedisCacheConfiguration jdkConfig = jdkCacheConfiguration(Duration.ofHours(6));

                Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
                cacheConfigurations.put("offer.achievement", jdkCacheConfiguration(Duration.ofMinutes(30)));
                // Use JDK serialization for caches returning Map<Integer, ...>
                // to preserve Integer key types (JSON serializes map keys as String)
                cacheConfigurations.put("allOffers", jdkConfig);
                cacheConfigurations.put("offer.slabpayout", jdkConfig);
                cacheConfigurations.put("catalog.published_yearmonth", jdkConfig);

                return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(jedisConnectionFactory())
                                .cacheDefaults(defaultJsonConfig)
                                .withInitialCacheConfigurations(cacheConfigurations)
                                .build();
        }
        @Bean
        public CacheManager redisOneDayCacheManager() {
                return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(jedisConnectionFactory())
                                .cacheDefaults(cacheConfiguration().entryTtl(Duration.ofDays(1)))
                                .build();
        }
        @Bean
        public CacheManager redisFortnightlyCacheManage() {
                return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(jedisConnectionFactory())
                                .cacheDefaults(cacheConfiguration().entryTtl(Duration.ofDays(15).minusMinutes(5)))
                                .build();
        }

        @Bean
        public CacheManager redisEternalCacheManager() {
                return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(jedisConnectionFactory())
                                .cacheDefaults(cacheConfiguration().entryTtl(Duration.ZERO))
                                .build();
        }

}