Springboot集成Redis

*.conf：配置文件，配置redis的一些特征，如修改监听端口等。

Redis-server.exe : redis服务器启动文件。
	redis-server.exe redis.windows.conf

Redis-cli.exe : 客户端启动文件
	redis-cli.exe -h 127.0.0.1 -p 6379 –a password

 <dependency>

<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<--!进行redisTemplate配置的时候需要此jar包 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
</dependency>

# REDIS (RedisProperties)
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=1000

package com.study.springboot.config;

import java.time.Duration;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
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.connection.RedisConnectionFactory;
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.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

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

//Redis的核心配置类，这个类提供了两个方法（其实提供了两个bean，这两个bean会加载到spring的context里边，供使用者进行调用）
@Configuration //这个标签，通常与@bean结合使用，当@bean使用到该类的方法上，代表将该方法做为一个bean交给了spring的context进行了管理。
@EnableCaching //允许使用我们的缓存cache
public class RedisConfig extends CachingConfigurerSupport{
	
	@Bean //此时，将我们的redisTemplate加载到了我们的spring的上下文中，applicationContext
	public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory){
		//自主实现我们的redisTemplate方法。
		RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
		//序列化
		RedisSerializer<String> redisSerializer = new StringRedisSerializer();
		//引入json串的转换类
		Jackson2JsonRedisSerializer jasonJackson2JsonRedisSerializer = 
				new Jackson2JsonRedisSerializer(Object.class);
		ObjectMapper om = new ObjectMapper();
		//设置我们的objectMapper的访问权限
		om.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
		om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
		jasonJackson2JsonRedisSerializer.setObjectMapper(om);
		
		//redisTemplate
		redisTemplate.setConnectionFactory(factory);
		//redis key的序列化
		redisTemplate.setKeySerializer(redisSerializer);
		//value 序列化 使用的是jasonJackson2JsonRedisSerializer。我们的value大部分都是通过对象转化来的
		redisTemplate.setValueSerializer(jasonJackson2JsonRedisSerializer);
		//value的序列化 hashmap的序列化
		redisTemplate.setHashValueSerializer(jasonJackson2JsonRedisSerializer);
		return redisTemplate;
	}
	
	@Bean //自动 对我们的对象object进行一个缓存的管理，而不需要显示的书写代码，就可以对缓存进行管理。（主要的练习点）
	public CacheManager cacheManager(RedisConnectionFactory factory){
		//序列化
		RedisSerializer<String> redisSerializer = new StringRedisSerializer();
		//引入json串的转换类
		Jackson2JsonRedisSerializer jasonJackson2JsonRedisSerializer = 
				new Jackson2JsonRedisSerializer(Object.class);
		
		ObjectMapper om = new ObjectMapper();
		//设置我们的objectMapper的访问权限
		om.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
		om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
		jasonJackson2JsonRedisSerializer.setObjectMapper(om);
		
		//序列化配置，乱码问题解决以及我们的缓存的时效性
		RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().
				entryTtl(Duration.ofSeconds(1000)).
				serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer)).
				serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jasonJackson2JsonRedisSerializer)).
				disableCachingNullValues();
				
		RedisCacheManager cacheManager = 
				RedisCacheManager.builder(factory).cacheDefaults(config).build();
		return cacheManager;
	}
}