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.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;

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 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();
        }
        @Bean
        public CacheManager redisCacheManager() {
                Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
                cacheConfigurations.put("offer.achievement", cacheConfiguration().entryTtl(Duration.ofMinutes(30)));
                return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(jedisConnectionFactory())
                                .cacheDefaults(cacheConfiguration().entryTtl(Duration.ofHours(6)))
                                .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();
        }

}