Redis和Mysql一样是数据库,Mysql有对应的JDBC连接,Redis也有对应的Java客户端开发包,集成了Redis的一些命令操作,封装了Redis的java客户端,类似与redis-cli
前面:SpringBoot - 整合Redis:使用Jedis客户端通过Jedis、JedisPool使SpringBoot连接Redis
SpringBoot1.x的版本时默认使用的Jedis客户端,在SpringBoot2.x后,默认使用Lettuce
Lettuce与Jedis有什么区别?
Lettuce虽然更复杂,但更强(能被Spring生态承认)
就如同JDBC可以连接Mysql数据库一样,通过Lettuce也可以连接操作Redis,通过调用lettuce-core核心jar包可以进行操作
<dependency>
<groupId>io.lettuce</groupId>
<artifactId>lettuce-core</artifactId>
</dependency>
关于Lettuce操作Redis可以看这位大佬的文章:Redis高级客户端Lettuce详解
但可以实现是一回事,方便又是一回事,用Lettuce操作Redis实际上是够呛的
Spring框架提供了对Lettuce的封装RedisTemplate,它让Spring框架体系可以更方便的操作Redis
RedisTemplate位于spring-data-redis:Spring官网相关,是一个高度封装的对象
相关配置:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--redis依赖commons-pool-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
spring:
redis:
host: IP地址
password: Redis密码
port: 6379
timeout: 10000
lettuce:
pool:
# 连接池最大连接数
max-active: 8
# 连接池中的最大空闲连接
max-idle: 8
# 连接池中的最小空闲连接
min-idle: 2
# 连接池最大阻塞等待时间
max-wait: 1000
没有配置的话存的数据是:1111:RedisTemplate => lettuce
,实际上Redis中键值对是这样的
package com.lettuce.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* Author : zfk
* Data : 16:27
*/
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String,Object> redisTemplate(LettuceConnectionFactory factory){
RedisTemplate<String,Object> template = new RedisTemplate<>();
template.setConnectionFactory(factory);
Jackson2JsonRedisSerializer jacksonSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jacksonSerializer.setObjectMapper(objectMapper);
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
//使用注解@Bean返回RedisTemplate时,同时配置hashKey与HashValue的序列化方式
//key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
//value序列化方式采用Jackson
template.setValueSerializer(jacksonSerializer);
//hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
//hash的vlaue序列化采用Jackson
template.setHashValueSerializer(jacksonSerializer);
template.afterPropertiesSet();
return template;
}
}
使用服务层即可:
UserService接口:
package com.lettuce.service;
import com.lettuce.po.User;
/**
* Author : zfk
* Data : 17:01
*/
public interface UserService {
public String getString(String key);
}
实现类:UserServiceImpl
package com.lettuce.service;
import com.lettuce.po.User;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
/**
* Author : zfk
* Data : 16:56
*/
@Service
@Slf4j
public class UserServiceImpl implements UserService{
@Autowired
private RedisTemplate<String,Object> redisTemplate;
/**
* Redis命令 ==》 Lettuce => RedisTemplate进一步的封装
* redis String类型
* 用户输入一个key,先判断Redis是否存在数据,存在就在Redis中查询,
* 不存在就在Mysql数据库查询(模拟)。将结果返回给Redis
*/
@Override
public String getString(String key){
log.info("RedisTemplate ==> 测试");
String value = null;
//hasKey 相当于 exist
if (redisTemplate.hasKey(key)){
log.info("=== Redis查询到数据 ===");
return (String) redisTemplate.opsForValue().get(key);
}else {
value = "RedisTemplate => lettuce";
log.info("Redis没有查询到,存入:"+value);
redisTemplate.opsForValue().set(key,value);
}
return value;
}
}
测试类:LettuceApplicationTests
package com.lettuce;
import com.lettuce.po.User;
import com.lettuce.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class LettuceApplicationTests {
@Autowired
private UserService userService;
@Test
void contextLoads() {
String string = userService.getString("1111");
System.out.println(string);
}
}
再测试一次:Redis查找的了数据
RedisSerializer
前面我们自定义了配置类,当value为Object对象时的处理方法
JdkSerializationRedisSerializer:POJO对象的存取场景,使用JDK本身序列化机制,将pojo类通过ObjectInputStream/ObjectOutputStream进行序列化操作,最终redis-server中将存储字节序列。是目前最常用的序列化策略。
StringRedisSerializer:Key或者value为字符串的场景,根据指定的charset对数据的字节序列编码成string,是“new String(bytes, charset)”和“string.getBytes(charset)”的直接封装。是最轻量级和高效的策略。
Jackson2JsonRedisSerializer:jackson-json工具提供了javabean与json之间的转换能力,可以将pojo实例序列化成json格式存储在redis中,也可以将json格式的数据转换成pojo实例。因为jackson工具在序列化和反序列化时,需要明确指定Class类型,因此此策略封装起来稍微复杂。【需要jackson-mapper-asl工具支持】
OxmSerializer:提供了将javabean与xml之间的转换能力,目前可用的三方支持包括jaxb,apache-xmlbeans;redis存储的数据将是xml工具。不过使用此策略,编程将会有些难度,而且效率最低;不建议使用。【需要spring-oxm模块的支持】
我们来解读一下编写的RedisConfig:
在RedisTemplate类中可以看到:默认StringRedisSerializer序列化策略
内置了keySerializer、hashKeySerializer4个属性
Spring针对Lettuce/Jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口
这些Operation对象对应Redis的数据类型:
我们使用RedisTemplate操作:
redisTemplate.opsForValue().get(key);
所以如果不喜欢这种方式,可以直接用Operation操作:改造上面的getString方法
public class UserServiceImpl implements UserService{
@Autowired
private RedisTemplate<String,Object> redisTemplate;
@Resource(name = "redisTemplate")
private ValueOperations<String,Object> valueOps;
/**
* Redis命令 ==》 Lettuce => RedisTemplate进一步的封装
* redis String类型
* 用户输入一个key,先判断Redis是否存在数据,存在就在Redis中查询,
* 不存在就在Mysql数据库查询(模拟)。将结果返回给Redis
*/
@Override
public String getString(String key){
log.info("RedisTemplate ==> 测试");
String value = null;
//hasKey 相当于 exist
if (redisTemplate.hasKey(key)){
log.info("=== Redis查询到数据 ===");
return (String) valueOps.get(key);
}else {
value = "RedisTemplate => lettuce";
log.info("Redis没有查询到,存入:"+value);
valueOps.set(key,value);
}
return value;
}
}
取值时会报错:Json解析错误
Caused by: com.fasterxml.jackson.core.JsonParseException:
Unrecognized token 'RedisTemplate': was expecting (JSON String, Number, Array, Object or token 'null', 'true' or 'false')
at [Source: (byte[])"RedisTemplate => lettuce"; line: 1, column: 15]
因为我们的配置template.setValueSerializer(jacksonSerializer);
,value序列化方式采用Jackson
而Jackson将字符串转为json会带上双引号,我们取值时没有双引号就会报错
把数据修改一下:带上双引号就ok了
码云