spring boot使用redis缓存数据与自动清除

最新推荐文章于 2024-05-28 23:33:00 发布

hello_junz

最新推荐文章于 2024-05-28 23:33:00 发布

阅读量1.4w

点赞数 4

分类专栏： spring redis 文章标签： spring boot Cacheable redis 缓存 Scheduled

本文链接：https://blog.csdn.net/hello_junz/article/details/81296177

版权

spring 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

redis

2 篇文章 0 订阅

订阅专栏

在spring boot项目中使用缓存很方便，有如下两种使用场景：

直接操作RedisTemplate缓存数据
在方法上加@Cacheable注解来缓存数据

方法1适用于缓存session、token等用户登录信息

方法2适用于缓存查询结果

直接操作RedisTemplate能够很灵活的对存入缓存中的key与value做定制化、并能很容易的实现缓存对象的过期时间。用@Cacheable注解方式的话，是不支持设置TTL，也就是说没有直接的方式设置缓存对象的过期时间，那么怎样才能实现缓存对象的自动清除呢？别着急，接着看。

一、pom配置，要加入对spring-boot-starter-cache与spring-boot-starter-data-redis的依赖

 <parent>
       <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.3.RELEASE</version>
    </parent>

   <dependencies>
   	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter</artifactId>
	</dependency>
		
        <!-- spring data redis-->
        <dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-cache</artifactId>
	</dependency>
        <dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-data-redis</artifactId>
	</dependency>
	<dependency>
 		<groupId>org.apache.commons</groupId>
 		<artifactId>commons-pool2</artifactId>
 		<version>2.0</version>
	</dependency>
        
        <!-- spring data jpa-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <!--jdbc pool -->
        <dependency>
	    <groupId>com.zaxxer</groupId>
	    <artifactId>HikariCP</artifactId>
            <version>3.1.0</version>
	</dependency>

        <!-- jdbc driver -->
        <dependency>
		<groupId>org.postgresql</groupId>
		<artifactId>postgresql</artifactId>
		<version>42.1.1</version>
	</dependency>

        <!-- auto redeploy 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>-->

        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.32</version>
        </dependency>
    </dependencies>

二、写个RedisCacheConfig文件，扩展CachingConfigurerSupport。缓存的自动清除有cacheEvict方法注解实现。

@Configuration
@EnableCaching
@EnableScheduling
public class RedisCacheConfig extends CachingConfigurerSupport{
	
	private static final Logger logger = LoggerFactory.getLogger(RedisCacheConfig.class);
	
	@Resource
	private LettuceConnectionFactory lettuceConnectionFactory;
	
	@Bean
	public KeyGenerator keyGenerator() {
		return new KeyGenerator() {
			@Override
			public Object generate(Object target, Method method, Object... params) {
				StringBuffer sb = new StringBuffer();
				sb.append(target.getClass().getName());
				sb.append(method.getName());
				for (Object obj : params) {
					sb.append(obj.toString());
				}
				return sb.toString();
			}
		};
	}


	@Bean
        public CacheManager cacheManager(){
		RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager.RedisCacheManagerBuilder
				.fromConnectionFactory(lettuceConnectionFactory);
		@SuppressWarnings("serial")
		Set<String> cacheNames = new HashSet<String>() {
			{
				add("apiCache");
				add("dictDataCache");
				add("manufacturedGood");
				add("rawMaterial");
			}
		};
         
           builder.initialCacheNames(cacheNames);
		
		   return builder.build();
        }
	
	@CacheEvict(allEntries = true, cacheNames = { "manufacturedGood", "rawMaterial"})
	@Scheduled(fixedDelay = 60*1000)
	public void cacheEvict() {
		logger.info("[RedisCacheConfig][cacheEvict] start to clear cache");
	}
	
	
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory){
    	Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
				Object.class);
		ObjectMapper om = new ObjectMapper();
		om.setVisibility(PropertyAccessor.ALL, Visibility.ANY);
	        om.enableDefaultTyping(DefaultTyping.NON_FINAL);
		jackson2JsonRedisSerializer.setObjectMapper(om);

		RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
		redisTemplate.setConnectionFactory(lettuceConnectionFactory);
		RedisSerializer<?> stringSerializer = new StringRedisSerializer();
		redisTemplate.setKeySerializer(stringSerializer);
		redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
		redisTemplate.setHashKeySerializer(stringSerializer);
		redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
		redisTemplate.afterPropertiesSet();
		
		return redisTemplate;
    }
}

说明：

在class上面需要加上@EnableCaching与@EnableScheduling注解
cacheEvict()方法就是实现缓存对象的自动清除的地方，@CacheEvict注解指明cacheNames中指定的缓存，allEntries = true表示清除每个缓存中的所有实体。@Scheduled指定以何种方式触发这个清除动作，fixedDelay = 60*1000 表明上次执行完毕后间隔1分钟清除一次。注意单位是毫秒。当然，还有其它的方式，比如fixedRate，cron等

三、通过@Cacheable自动缓存数据

@Service
public class RawMaterialQueryServiceImpl implements RawMaterialQueryService {
	
	@Autowired
	private RawMaterialDao rawMaterialDao;

	@Override
	@Cacheable(cacheNames="rawMaterial",sync=true, key="'RawMaterialID'.concat(#p0)")
	public RawMaterial getById(Integer id) {
		if(null == id) {
			return null;
		}
		Optional<RawMaterial> optional = rawMaterialDao.findById(id);
		return optional.isPresent()?optional.get():null;
	}

}

说明：

在getById这个方法上的@Cacheable注解对查询结果做缓存，将查询的结果缓存到rawMaterial中，key为固定前缀RawMaterialID加上查询参数id。sync=true，多线程用相同的id调用此方法，如果没有命中，只有一个线程会调用方法中的查询动作，其它线程会等待。

四、直接调用。写个辅助类，直接操作RedisTemplate。在put对象时，可以直接指定过期时间。

@Component
public class RedisUtil {
	
	private static final Logger logger = LoggerFactory.getLogger(RedisUtil.class);
	
	private static final String FRONT_END_SESSION_CACHE_PREFIX = "FE_SESS_";
	private static final String BACK_END_SESSION_CACHE_PREFIX = "BE_SESS_";
	private static final String LOCALE_CACHE_PREFIX = "LOCALE_";
	
	@Value("${cache.redis.defaultlocale}")
	private String defaultLocale;
	
	@Value("${cache.redis.session.backend.expiretime}")
	private int beSessionExpireTime;
	
	@Value("${cache.redis.session.frontend.expiretime}")
	private int feSessionExpireTime;

	@Resource
        private RedisTemplate<Object, Object> redisTemplate;
	
	public void cacheFrontEndSession(String sessionId,Integer userId) {
		if(StringUtil.assertNull(sessionId)) {
			return;
		}
		putWithTimeout(FRONT_END_SESSION_CACHE_PREFIX+sessionId, userId,feSessionExpireTime);
	}
	
	public boolean removeFrontEndSession(String sessionId) {
		if(StringUtil.assertNull(sessionId)) {
			return true;
		}
		return delete(FRONT_END_SESSION_CACHE_PREFIX+sessionId);
	}
	
	public Integer getFrontEndSessionCache(String sessionId) {
		try {
			Object value = get(FRONT_END_SESSION_CACHE_PREFIX+sessionId);
			if(null != value) {
				putWithTimeout(FRONT_END_SESSION_CACHE_PREFIX+sessionId, value,feSessionExpireTime);
				return Integer.parseInt(value+"");
			}else {
				return null;
			}
			
		}catch(Exception e) {
			return null;
		}
	}
	
	public void cacheBackEndSession(String sessionId,Integer userId) {
		if(StringUtil.assertNull(sessionId)) {
			return;
		}
		putWithTimeout(BACK_END_SESSION_CACHE_PREFIX+sessionId, userId,beSessionExpireTime);
	}
	
	public boolean removeBackEndSession(String sessionId) {
		if(StringUtil.assertNull(sessionId)) {
			return true;
		}
		return delete(BACK_END_SESSION_CACHE_PREFIX+sessionId);
	}
	
	public Integer getBackEndSessionCache(String sessionId) {

		try {
			Object value = get(BACK_END_SESSION_CACHE_PREFIX+sessionId);
			if(null != value) {
				putWithTimeout(BACK_END_SESSION_CACHE_PREFIX+sessionId, value,beSessionExpireTime);
				return Integer.parseInt(value+"");
			}else {
				return null;
			}
			
		}catch(Exception e) {
			return null;
		}
	}
	
	public void cacheLocale(Integer userId,String locale) {
		if(null == userId) {
			return;
		}
		put(LOCALE_CACHE_PREFIX+userId, locale);
	}
	
	public String getLocaleCache(Integer userId) {
		try {
			return (String)get(LOCALE_CACHE_PREFIX+userId);
		}catch(Exception e) {
			return null;
		}
	}
	
	private void put(Object key,Object value) {
		redisTemplate.opsForValue().set(key, value);
	}
	
	private void putWithTimeout(Object key,Object value,long timeout) {
		redisTemplate.opsForValue().set(key, value,timeout,TimeUnit.SECONDS);
	}
	
	private Object get(Object key) {
		if(null == key) {
			return null;
		}
		return redisTemplate.opsForValue().get(key);
	}
	
	private boolean delete(Object key) {
		if(null == key) {
			return true;
		}
		return redisTemplate.delete(key);
	}

	public String getDefaultLocale() {
		return defaultLocale;
	}
	
}

五、配置文件application.properties

#=====================redis config================================
spring.cache.type=redis
spring.redis.host=192.168.1.252
spring.redis.port=6379
spring.redis.password=xxxxx
spring.redis.database=0
spring.redis.timeout=5000
spring.redis.lettuce.pool.max-idle=50
spring.redis.lettuce.pool.min-idle=10
spring.redis.lettuce.pool.max-active=-1
spring.redis.lettuce.pool.max-wait=-1
cache.redis.defaultlocale=zh_CN
#session过期时间，单位：秒
cache.redis.session.backend.expiretime=300
cache.redis.session.frontend.expiretime=3600

总结，通过上述步骤，展示了在spring boot项目中同时使用通过操作RedisTemplate和@Cacheable的方式来缓存数据，并实现缓存的自动清除功能。

hello_junz

关注

4
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
spring boot使用redis缓存数据与自动清除

在spring boot项目中使用缓存很方便，有如下两种使用场景：直接操作RedisTemplate缓存数据在方法上加@Cacheable注解来缓存数据方法1适用于缓存session、token等用户登录信息方法2适用于缓存查询结果直接操作RedisTemplate能够很灵活的对存入缓存中的key与value做定制化、并能很容易的实现缓存对象的过期时间。用@Cacheable注解...
复制链接

扫一扫