SpringBoot整合Redis

添加相关依赖，在创建Springboot项目时添加。

我们可以去看以下spring-boot-starter-data-redis的源码

<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <!-- This module was also published with a richer model, Gradle metadata,  -->
  <!-- which should be used instead. Do not delete the following line which  -->
  <!-- is to indicate to Gradle or any Gradle module metadata file consumer  -->
  <!-- that they should prefer consuming it instead. -->
  <!-- do_not_remove: published-with-gradle-metadata -->
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
  <version>2.4.1</version>
  <name>spring-boot-starter-data-redis</name>
  <description>Starter for using Redis key-value data store with Spring Data Redis and the Lettuce client</description>
  <url>https://spring.io/projects/spring-boot</url>
  <organization>
    <name>Pivotal Software, Inc.</name>
    <url>https://spring.io</url>
  </organization>
  <licenses>
    <license>
      <name>Apache License, Version 2.0</name>
      <url>https://www.apache.org/licenses/LICENSE-2.0</url>
    </license>
  </licenses>
  <developers>
    <developer>
      <name>Pivotal</name>
      <email>info@pivotal.io</email>
      <organization>Pivotal Software, Inc.</organization>
      <organizationUrl>https://www.spring.io</organizationUrl>
    </developer>
  </developers>
  <scm>
    <connection>scm:git:git://github.com/spring-projects/spring-boot.git</connection>
    <developerConnection>scm:git:ssh://git@github.com/spring-projects/spring-boot.git</developerConnection>
    <url>https://github.com/spring-projects/spring-boot</url>
  </scm>
  <issueManagement>
    <system>GitHub</system>
    <url>https://github.com/spring-projects/spring-boot/issues</url>
  </issueManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
      <version>2.4.1</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-redis</artifactId>
      <version>2.4.2</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>io.lettuce</groupId>
      <artifactId>lettuce-core</artifactId>
      <version>6.0.1.RELEASE</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>
</project>

说明：
在Springboot 2.X之后Jedis被替换成了lettuce。
Jedis和lettuce的比较？

jedis：采用直连的方式，多线程的情况下是不安全的，如果想要避免，需要使用jedis pool连接池，更像BIO模式。
lettuce：采用的是netty，实例可以在多个线程下共享，不存在线程不安全的现象，可以减少线程，更像NIO模式。

解释下BIO和NIO

BIO：同步阻塞式IO，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
NIO：同步非阻塞式IO，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
AIO(NIO.2)：异步非阻塞式IO，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

码源分析：

	@Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )//我们可以自己定义一个redisTemplate，如果没有就是使用封装好。
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    //默认的RedisTemplate没有过多的设置，redis的对象是需要序列化的
    //我们所需要的泛型为<String, Object>而这里是<Object, Object>我们还需要去进行强转。
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    //因为stringReids经常被使用，所以被单独的注册了bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

我们可以去看下redis的配置文件

我们可以去看一下里面的属性：

默认给我们定义了本机的连接属性。

这个的意思是告诉我们在配置redis的时候用spring.redis。

---

接下来就是我们的测试：

• 导入依赖

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

• 配置连接

spring.redis.host=127.0.0.1
spring.redis.port=6379

可以操作redis的各种数据结构，String类型的为opsForValue()

• 测试结果

测试成功，这里使用的是英文，如果使用中文的话需要序列化操作。

我们可以去看看源码

可以看初如果我们没有去序列化对象，底层会给我们通过JDK的序列化方式进行序列化操作。

---

接下来我们自定义RedisTemplate
自定义的类可以参照RedisAutoConfiguration这个自动配置类。
我们操作一个user对象来测试以下：

这个时候会报错，原因给出的是没有序列化：

我们给user对象进行序列化操作试试：

再次测试结果，成功：

但是我们不会去直接用new一个对象进行测试，常常使用的是json数据

实现的序列化方式有以上几种。我们可以来做一个序列化的配置：

package com.zz.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.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Redis的配置类,这是一个模板以后都可以直接去用。
 */
@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);

        //Json序列化配置
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        //String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        //key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        //Hash的key采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        //value采用Json的序列化方式
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //Hash的value采用Json的序列化方式
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        
        return template;
    }

}

序列化做完以后测试成功。

---

为了提高代码的复用性，减少重复代码的出现，我们将对redis的操作封装为一个工具类，方便我们对redis的操作。

Redis工具类的代码参考的文章-Redis工具类—RedisUtil

测试

结果取到