我们之所以要学习Redis，是要令我们Java程序更加有效率，我们在使用数据库的时候给它加上一个缓存中间件，就是用来提高我们程序的效率的，那么当然，Redis还是要集成到我们SpringBoot项目里面的！！
整合也非常简单，新建一个SpringBoot项目，导入相关依赖
只要把这些选项勾起来，那么SpringBoot在创建项目的时候就会自动帮我们导入所需要的依赖！
<!-- redis依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- web依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 热部署依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<!-- lombok依赖-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>到我们SpringBoot2.x版本，其内置的Redis中间件再也不是Jedis了，而是换成了lettuce。我们点进redis依赖就可以发现
那么lettuce是什么呢，其与Jedis有什么区别呢？
-
lettuce： Lettuce 是 一种可伸缩，线程安全，完全非阻塞的Redis客户端，多个线程可以共享一个RedisConnection,它利用Netty NIO 框架来高效地管理多个连接，从而提供了异步和同步数据访问方式，用于构建非阻塞的反应性应用程序。
-
Jedis： Jedis 在实现上是直连 redis server，多线程环境下非线程安全，除非使用连接池，为每个 redis实例增加 物理连接。 这种方式更加类似于我们 BIO 一条线程连一个客户端，并且是阻塞式的，会一直连接着客户端等待客户端的命令
那么导入这个redis，根据我们之前学习SpringBoot，我们知道一定有一个Properties配置类去配置我们的Redis的
那么我们在IDEA中双击shift查看
点进这个类中查看可以配置什么
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class,JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {
// redis的模板实例，可以帮助我们快速操作redis
@Bean
// 如果这个名为redisTemplate实例不存在的话，该bean生效，那么我们可以代替SpringBoot，自定义我们的redis模板实例！！！
@ConditionalOnMissingBean(name = "redisTemplate")
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<Object,Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
// 因为我们很多情况都是操作String类型的数据，那么这个类帮我们也配置了String的redis模板供我们使用！
// 其方法与上面的redisTemplate一样
@Bean
@ConditionalOnMissingBean
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
{
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
}我们点进这个RedisProperties类中查看相关配置！
可以看到我们可以在SpringBoot配置文件中配置以下东西
@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {
/**
* 可以配置使用的db下标
*/
private int database = 0;
/**
* 这个配置可以让我们连接到远程的redis中。例如：
* redis://user:password@example.com:6379
*/
private String url;
/**
* Redis服务端的主机名
*/
private String host = "localhost";
/**
* Login username of the redis server.
*/
private String username;
/**
* Login password of the redis server.
*/
private String password;
/**
* Redis的端口号
*/
private int port = 6379;
/**
* 是否开启安全认证
*/
private boolean ssl;
/**
* Read timeout.
*/
private Duration timeout;
/**
* Connection timeout.
*/
private Duration connectTimeout;
/**
* Client name to be set on connections with CLIENT SETNAME.
*/
private String clientName;
/**
* Type of client to use. By default,auto-detected according to the classpath.
*/
private ClientType clientType;
private Sentinel sentinel;
private Cluster cluster;
}其中主机名和端口号都有默认值，如果我们连自己的电脑，那么这两个配置都可以不用修改！
我们这里不用修改配置文件，就使用默认的即可！
测试连接
那么从我们导入redis的依赖，就可以使用了，我们现在来测试一下连接！
//自动注入redisTemplate
@Autowired
private RedisTemplate redisTemplate;
@Test
void contextLoads() {
//获取redis数据库连接对象
RedisConnectionFactory connectionFactory = redisTemplate.getConnectionFactory();
RedisConnection connection = connectionFactory.getConnection();
// 往Redis服务端中设置一个String类型的key，值为zhangsan
redisTemplate.opsForValue().set("name","zhangsan");
// 获取并打印这个key的值
System.out.println(redisTemplate.opsForValue().get("name"));
}我们还需要在window系统中开启我们的Redis服务端！
测试结果
zhangsan # 控制台成功打印出key的值我们连接Redis客户端，再获取这个key
127.0.0.1:6379> ping # 测试连接
PONG
127.0.0.1:6379> get name # 获取key中的value
"zhangsan" # 返回zhangsan，测试成功！那么现在我们能在SpringBoot项目中使用Redis了，但是我们如果存中文的话会发生乱码！例如
redisTemplate.opsForValue().set("name","张三"); //往value中添加中文
System.out.println(redisTemplate.opsForValue().get("name"));那么再次测试Redis
张三 # 控制台可以输出中文Redis客户端获取key
127.0.0.1:6379> keys *
1) "\xac\xed\x00\x05t\x00\x04name" # key乱码了我们在分析Redis配置文件中也发现了我们的RedisTemplate时可以让我们配置的，那么默认的RedisTemplate给我们配置了什么？
点进这个类中看一下
public class RedisTemplate<K,V> extends RedisAccessor implements RedisOperations<K,V>,BeanClassLoaderAware {
.......
@SuppressWarnings("rawtypes") private @Nullable RedisSerializer keySerializer = null;
@SuppressWarnings("rawtypes") private @Nullable RedisSerializer valueSerializer = null;
@SuppressWarnings("rawtypes") private @Nullable RedisSerializer hashKeySerializer = null;
@SuppressWarnings("rawtypes") private @Nullable RedisSerializer hashValueSerializer = null;
public void afterPropertiesSet() {
super.afterPropertiesSet();
boolean defaultUsed = false;
if (defaultSerializer == null) {
// 默认的序列化方式为JDK中自带的序列化
defaultSerializer = new JdkSerializationRedisSerializer(
classLoader != null ? classLoader : this.getClass().getClassLoader());
}
if (enableDefaultSerializer) {
// 因为我们并没有设置其序列化的实例，那么在创建这个RedisTemplate实例的时候，全部都默认成了JDK的序列化方式！
if (keySerializer == null) {
keySerializer = defaultSerializer;
defaultUsed = true;
}
if (valueSerializer == null) {
valueSerializer = defaultSerializer;
defaultUsed = true;
}
if (hashKeySerializer == null) {
hashKeySerializer = defaultSerializer;
defaultUsed = true;
}
if (hashValueSerializer == null) {
hashValueSerializer = defaultSerializer;
defaultUsed = true;
}
}
if (enableDefaultSerializer && defaultUsed) {
Assert.notNull(defaultSerializer,"default serializer null and not all serializers initialized");
}
if (scriptExecutor == null) {
this.scriptExecutor = new DefaultScriptExecutor<>(this);
}
initialized = true;
}
........
}我们可以知道，如果我们不配置RedisTemplate的序列化方式，默认的是使用JDK中的序列化方式，那么我们点进这个JdkSerializationRedisSerializer类中看看
点进深层我们发现，里面其实创建了一个序列化转换器，而转换器默认的构造方法是JDK默认的序列化工具，其实现了Serializer接口
void serialize(T object,OutputStream outputStream) throws IOException;因为我们java使用ISO-8859-1编码进行传输数据的，那么我们传输字符串的话，那么编解码会不一致，一定会出现乱码！！！
所以我们得自己重写一个RedisTemplate来修改默认的序列化方式！
我们从上面分析可以知道，当我们的类中出现以redisTemplate命名的bean的时候，SpringBoot的配置将不会生效！
那我们来接管一下这个redisTemplate类
// 标志为配置类
@Configuration
public class RedisConfig {
// 把这个bean的name设置为redisTemplate，这样我们才能全面接管redisTemplate！
@Bean(name = "redisTemplate")
public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String,Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
// jackson序列化所有的类
Jackson2JsonRedisSerializer Jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
// jackson序列化的一些配置
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance);
Jackson2JsonRedisSerializer.setObjectMapper(om);
// String的序列化
StringRedisSerializer stringSerializer = new StringRedisSerializer();
//将我们的key采用String的序列化方式
template.setKeySerializer(stringSerializer);
//将我们的hash的key也采用String的序列化方式
template.setHashKeySerializer(stringSerializer);
//value采用jackson序列化方式
template.setValueSerializer(Jackson2JsonRedisSerializer);
//hash的value也采用jackson序列化方式
template.setHashValueSerializer(Jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}我们继续来编写一个简单的实体类，其中这个类必须要实现序列化！！！！不然直接报错，因为这个类不能序列化
@Component
@AllArgsConstructor
@NoArgsConstructor
@Data
//我们的实体类全部需要序列化！
public class User implements Serializable {
private String name;
private int age;
}我们测试一下
User user = new User("李四",3);
redisTemplate.opsForValue().set("lisi",user);我们这里使用Redis Desktop Manager可视化工具来查看结果
我们看到，key和value不再乱码了，乱码问题解决！！！
我们这里不使用cmd命令行去查看结果的原因是，其编码格式是使用GBK编码的，value还是会乱码！
Redis工具类
我们在SpringBoot中去操作Redis总是要写这么几个方法
redisTemplate.opsForValue().set();那么当我们频繁操作Redis的时候，这就会显得代码很冗余，加大了维护成本！
所以我们要编写自己的工具类去封装Redis中的方法！
这里只截取一部分，只要注入我们的redisTemplate，封装里面常用的的方法即可
@Service
public class RedisUtil {
@Autowired
private RedisTemplate redisTemplate;
/**
* 写入缓存
*
* @param key
* @param value
* @return
*/
public boolean set(final String key,Object value) {
boolean result = false;
try {
ValueOperations<Serializable,Object> operations = redisTemplate.opsForValue();
operations.set(key,value);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 写入缓存设置时效时间
*
* @param key
* @param value
* @return
*/
public boolean set(final String key,Object value,Long expireTime,TimeUnit timeUnit) {
boolean result = false;
try {
ValueOperations<Serializable,value);
redisTemplate.expire(key,expireTime,timeUnit);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}原文地址：https://blog.csdn.net/weixin_56395837
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。