JAVA && Spring && SpringBoot2.x — 学习目录
Springboot抛弃了繁杂的xml配置，采用了自动装配的原理，所以我们看上去，只是配置了yml文件，就完成了繁杂bean的创建。
1. 为什么要自定义RedisTemplate
我们在代码中，可以完成RedisTemplate的注入，而实际上，我们只是单纯的配置了yml文件，在哪里创建了redisTemplate这个bean对象呢？
redisTemplate自动装配的源码：
@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {
@Bean
@ConditionalOnMissingBean(name = "redisTemplate")
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
throws UnknownHostException {
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
@Bean
@ConditionalOnMissingBean
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
throws UnknownHostException {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
}
通过源码可以看出，SpringBoot自动帮我们在容器中生成了一个RedisTemplate和一个StringRedisTemplate。
- RedisTemplate的泛型是<Object,Object>，写代码不是很方便，一般我们的key是String类型，我们需要一个<String,Object>的泛型。
- RedisTemplate没有设置数据存储在Redis时，Key和Value的序列化方式。（采用默认的JDK序列化方式）
如何优雅的解决上述两个问题呢？
@ConditionalOnMissing注解：如果Spring容器中已经定义了id为redisTemplate的Bean，那么自动装配的RedisTemplate不会实例化。因此我们可以写一个配置类，配置Redisemplate。
若未自定义RedisTemplate，默认会对key进行jdk序列化。
2. 如何自定义RedisTemplate
2.1 Redis数据的序列化问题
针对StringRedisSerializer，Jackson2JsonRedisSerializer和JdkSerializationRedisSerializer进行测试
| 数据结构 | 序列化类 | 序列化前 | 序列化后 |
|---|---|---|---|
| Key/Value | StringRedisSerializer | test_value | test_value |
| Key/Value | Jackson2JsonRedisSerializer | test_value | "test_value" |
| Key/Value | JdkSerializationRedisSerializer | test_value | 乱码 |
| Hash | StringRedisSerializer | 2016-08-18 | 2016-08-18 |
| Hash | Jackson2JsonRedisSerializer | 2016-08-18 | "2016-08-18" |
| Hash | JdkSerializationRedisSerializer | 2016-08-18 | \xAC\xED\x00\x05t |
由此可以得到结论：
- StringRedisSerializer进行序列化后的值，在Java和Redis中保存的内容时一致的。
- 用Jackson2JsonRedisSerializer序列化后，在Redis中保存的内容，比Java中多一对逗号。
- 用JdkSerializationRedisSerializer序列化后，对于Key-Value结构来说，在Redis中不可读；对于Hash的Value来说，比Java的内容多了一些字符。
自定义的redisTemplate实例：
@Configuration
public class RedisConfig {
/**
* 由于原生的redis自动装配，在存储key和value时，没有设置序列化方式，故自己创建redisTemplate实例
* @param factory
* @return
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(factory);
Jackson2JsonRedisSerializer 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);
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// value序列化方式采用jackson
template.setValueSerializer(jackson2JsonRedisSerializer);
// hash的value序列化方式采用jackson
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
对于Key来说，我们采用stringRedisSerializer。而对于Value来我们采用jackson2JsonRedisSerializer的序列化方式。
Jackson进行序列化
复习盘点-Java序列化方式（1）JSON序列化（温故知新-泛型）（jdk8-LocalDate序列化）
ObjectMapper是Jackson操作的核心，Jackson所有的json操作都是在ObjectMapper中实现的。
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
设置所有访问权限以及所有的实际类型都可序列化和反序列化om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
Jackson的ObjectMapper.DefaultTyping.NON_FINAL属性的作用
2.2 Jackson序列化特性
1. 对于jdk1.8新时间API的序列化
在JDK1.8中的时间类，采用了一套了新的API。但是在反序列化中，会出现异常。
com.fasterxml.jackson.databind.exc.InvalidDefinitionException:
Cannot construct instance of java.time.LocalDate (no Creators, like default construct, exist):
cannot deserialize from Object value (no delegate- or property-based Creator)
在SpringBoot中的解决方案：
- 在MAVEN中加入
ckson-datatype-jsr310依赖。
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jsr310</artifactId>
</dependency>
- 配置Configuration中的ObjectMapper。
@Bean
public ObjectMapper serializingObjectMapper() {
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
objectMapper.registerModule(new JavaTimeModule());
return objectMapper;
}
2. 常用注解
- @JsonIgnore 此注解用于属性上，作用是Json操作时，忽略该属性。
- @JsonFormat 此注解用于属性上， 作用是把Date类型转化成为想要的格式。
- @JsonProperty 此注解用于属性上，作用是把改属性的名称序列化成另一个名称。
- @JsonSerialize 此注解用于属性上，作用是指定属性序列化的类型。
- @JsonDeserialize 此注解用于属性上，作用是指定属性反序列化的类型。
- @JsonInclude 属性值为null的不参与序列化。
- @JsonInclude(Include.NON_NULL)属性为null，则不参与序列化。
JsonSerialize与 JsonDeserialize使用
3. 常用的redis序列化工具类
灵活的获取Spring Bean对象
@Service
public class SpringContextUtil implements ApplicationContextAware {
private static ApplicationContext context;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringContextUtil.context=applicationContext;
}
public static <T> T getBean(String name, Class<T> requiredType){
return context.getBean(name, requiredType);
}
}
Redis常用API
@Slf4j
public class RedisUtil {
private static final RedisTemplate<String, Object> redisTemplate = SpringContextUtil.getBean("redisTemplate", RedisTemplate.class);
/**********************************************************************************
* redis-公共操作
**********************************************************************************/
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @return
*/
public static boolean expire(String key, long time) {
try {
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
log.error("【redis：指定缓存失效时间-异常】", e);
return false;
}
}
/**
* 根据key 获取过期时间
*
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效;如果该key已经过期,将返回"-2";
*/
public static long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public static boolean exists(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
log.error("【redis：判断{}是否存在-异常】", key, e);
return false;
}
}
/**********************************************************************************
* redis-String类型的操作
**********************************************************************************/
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public static boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
log.error("【redis：普通缓存放入-异常】", e);
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public static boolean set(String key, Object value, long time) {
try {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
log.error("【redis：普通缓存放入并设置时间-异常】", e);
return false;
}
}
/**
* 递增
*
* @param key 键
* @param delta 要增加几(大于0)
* @return
*/
public static long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @param delta 要减少几(小于0)
* @return
*/
public static long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public static void del(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
/**
* 获取缓存
*
* @param key redis的key
* @param clazz value的class类型
* @param <T>
* @return value的实际对象
*/
public static <T> T get(String key, Class<T> clazz) {
Object obj = key == null ? null : redisTemplate.opsForValue().get(key);
if (!obj.getClass().isAssignableFrom(clazz)) {
throw new ClassCastException("类转化异常");
}
return (T) obj;
}
/**
* 获取泛型
*
* @param key 键
* @return 值
*/
public static Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
}
4. jedis客户端与lettuce客户端
SpringBoot集成Redis主要是使用RedisTemplate类进行操作，但是在SpringBoot2.0以后，底层访问的不再是Jedis而是lettuce。
jedis客户端和lettuce客户端的区别
jedis采用的是直连redis server，在多线程之间公用一个jedis实例，是线程不安全的，想要避免线程不安全，可以使用连接池pool，这样每个线程单独使用一个jedis实例，但是线程过多时，带来的是redis server的负载较大。有点类似BIO模式。
lettuce采用netty连接redis server，实例在多个线程间共享，不存在线程不安全的情况，这样可以减少线程数量。当然在特殊情况下，lettuce也可以使用多个实例，有点类似NIO模式。
<!--redis默认使用的Lettuce客户端-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--使用默认的Lettuce时，若配置spring.redis.lettuce.pool则必须配置该依赖-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
需要注意的是，若是在配置中配置了pool属性，那么必须在pom.xml文件中加入commons-pool2的依赖。
image.png
SpringBoot2集成redis，使用lettuce客户端
如果使用lettuce客户端每隔一段时间连接断开怎么办
将lettuce客户端换成jedis客户端
<!-- Redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<exclusions>
<exclusion>
<groupId>io.lettuce</groupId>
<artifactId>lettuce-core</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>
<!--使用redis连接池-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
