SpringBoot+Swagger-UI+Redis作爲緩存使用的學習記錄

在新版本的開發過程中項目中用到Redis，所以趁着最近學習下Rdis的使用方法，項目代碼已經上傳，碼雲地址：https://gitee.com/dcxgit/springboot_practice/releases

1.0.2版本

首先搭建基礎的SpringBoot代碼並引入相關jar包這裏不做介紹，主要介紹Redis，

項目結構：

引入jar包

<!-- 整合redis -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
			<version>1.4.7.RELEASE</version>
		</dependency>

application.properties配置信息

設置端口號
server.port=8099
#配置數據庫連接信息
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/studentdorm?characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=123456

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

spring.cache.ehcache.cofnig=ehcache.xml
#掃描mapper.xml文件
mybatis.mapper-locations=classpath:mapper/*.xml
#顯示sql語句
logging.level.com.dcx.dao=debug
#-------------------------------Redis--------------------------------
spring.redis.host=localhost
spring.redis.port=6379
#根據需要
spring.redis.password=123456
# 連接超時時間（毫秒）
spring.redis.timeout=10000
# Redis默認情況下有16個分片，這裏配置具體使用的分片，默認是0
spring.redis.database=0
# 連接池最大連接數（使用負值表示沒有限制） 默認 8
spring.redis.lettuce.pool.max-active=8
# 連接池最大阻塞等待時間（使用負值表示沒有限制） 默認 -1
spring.redis.lettuce.pool.max-wait=-1
# 連接池中的最大空閒連接 默認 8
spring.redis.lettuce.pool.max-idle=8
# 連接池中的最小空閒連接 默認 0
spring.redis.lettuce.pool.min-idle=0

redis中的配置信息

/**   
 * @Title: RedisConfig.java 
 * @Package com.dcx.comm.redis 
 * @Description: TODO
 * @author : cxding  
 * @date 2019年4月18日 下午1:49:56 
 * @version V1.0   
 */
package com.dcx.comm.redis;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.annotation.JsonAutoDetect;

import redis.clients.jedis.JedisPoolConfig;

/**
 * @ClassName: RedisConfig
 * @Description: TODO
 * @author : cxding
 * @date 2019年4月18日 下午1:49:56
 * @version 1.0
 */
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
	/**
	 * 1.創建JedisPoolConfig對象。在該對象中完成一些鏈接池配置
	 * 
	 * @ConfigurationProperties:會將前綴相同的當做一個JedisPoolConfig實體，裏面的作爲屬性
	 *
	 */
	@Bean
	@ConfigurationProperties(prefix = "spring.redis.lettuce.pool")
	public JedisPoolConfig jedisPoolConfig() {
		JedisPoolConfig config = new JedisPoolConfig();
		return config;
	}

	/**
	 * 2.創建JedisConnectionFactory：配置redis鏈接信息
	 */
	@Bean
	@ConfigurationProperties(prefix = "spring.redis")
	public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig config) {
		JedisConnectionFactory factory = new JedisConnectionFactory();
		return factory;
	}

	/**
	 * 3.創建RedisTemplate:用於執行Redis操作的方法
	 */
	@Bean
	public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) {
		RedisTemplate<String, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(factory);

		// 使用Jackson2JsonRedisSerializer來序列化和反序列化redis的value值
		Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);

		ObjectMapper mapper = new ObjectMapper();
		mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
		mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
		serializer.setObjectMapper(mapper);

		template.setValueSerializer(serializer);
		// 使用StringRedisSerializer來序列化和反序列化redis的key值
		template.setKeySerializer(new StringRedisSerializer());
		template.afterPropertiesSet();

		return template;
	}

	/**
	 * 
	 * @Title: simpleKeyGenerator 
	 * @author: cxding
	 * @createTime: 2019年4月23日 下午3:11:48
	 * @return KeyGenerator
	 */
	@Bean
	public KeyGenerator simpleKeyGenerator() {
		return (o, method, objects) -> {
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.append(o.getClass().getSimpleName());
			stringBuilder.append(".");
			stringBuilder.append(method.getName());
			stringBuilder.append("[");
			for (Object obj : objects) {
				stringBuilder.append(obj.toString());
			}
			stringBuilder.append("]");
			return stringBuilder.toString();
		};
	}
	
	/**
	 * redis緩存配置
	 * @Title: cacheManager 
	 * @author: cxding
	 * @createTime: 2019年4月23日 下午3:12:01
	 * @param redisConnectionFactory
	 * @return CacheManager
	 */
	@Bean
	public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
		return new RedisCacheManager(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
				this.getRedisCacheConfigurationWithTtl(600), // 默認策略，未配置的 key 會使用這個
				this.getRedisCacheConfigurationMap() // 指定 key 策略
		);
	}

	// 爲緩存使用
	private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
		Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
		//這裏如果只是幾個固定的方法可以在這裏寫定參數，------------------另一個功能設置不同失效時間，當數據量大的時候防止緩存雪崩
		//redisCacheConfigurationMap.put("stu", this.getRedisCacheConfigurationWithTtl(30));
		// redisCacheConfigurationMap.put("UserInfoListAnother", this.getRedisCacheConfigurationWithTtl(18000));
		return redisCacheConfigurationMap;
	}

	// 爲緩存使用
	private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
		Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(
				Object.class);
		ObjectMapper om = new ObjectMapper();
		om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
		om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
		jackson2JsonRedisSerializer.setObjectMapper(om);

		RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
		redisCacheConfiguration = redisCacheConfiguration
				.serializeValuesWith(
						RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
				.entryTtl(Duration.ofSeconds(seconds));

		return redisCacheConfiguration;
	}

}

同時啓動類上加上註解