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.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.springframework.cache.Cache;

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.cache.interceptor.CacheErrorHandler;

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 {

	private static final Logger LOGGER = LogManager.getLogger(CacheConfig.class);

	@Override

	public CacheErrorHandler errorHandler() {

		return new CacheErrorHandler() {

			@Override

			public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {

				LOGGER.warn("Cache get error on [{}] key [{}]: {}", cache.getName(), key, e.getMessage());

				cache.evict(key);

			}

			@Override

			public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {

				LOGGER.warn("Cache put error on [{}] key [{}]: {}", cache.getName(), key, e.getMessage());

			}

			@Override

			public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {

				LOGGER.warn("Cache evict error on [{}] key [{}]: {}", cache.getName(), key, e.getMessage());

			}

			@Override

			public void handleCacheClearError(RuntimeException e, Cache cache) {

				LOGGER.warn("Cache clear error on [{}]: {}", cache.getName(), e.getMessage());

			}

		};

	}

	@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)));

		cacheConfigurations.put("offer.definition", jdkConfig);

		cacheConfigurations.put("monthOfferIds", 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 redisThreeHourCacheManager() {

		return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(jedisConnectionFactory())

				.cacheDefaults(cacheConfiguration().entryTtl(Duration.ofHours(3)))

				.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();

	}

}