spring-boot整合redis（多数据源）

Dear 丶 2021-09-07 13:42 807阅读 0赞

官网：[https://spring.io/projects/spring-data-redis][https_spring.io_projects_spring-data-redis]

Spring Data Redis是Spring Data系列的一部分，可轻松配置并从Spring应用程序访问Redis，并支持low-level和hight-level的抽象接口。可以看到spring data下面共提供了如下技术方案：

![20210429102923578.png][]

市面上已经有 Redis、Redisson、Lettuce 等优秀的 Java Redis 工具库，为什么还要有 Spring Data Redis 呢？

*  对于下层，Spring Data Redis 提供了统一的操作模板（RedisTemplate 类），封装了 Jedis、Lettuce 客户端库的 API 操作，来访问 Redis 数据（Spring Data Redis 底层使用的是 Jedis、Lettuce 库）。
 *  对于上层，开发者学习如何使用 Spring Data Redis 即可，而无需关心 Jedis、Lettuce 的 API 操作。甚至，未来如果我们想将 Redis 访问从 Jedis 迁移成 Lettuce 来，无需做任何的变动。
 *  springboot 2.X 版本使用Lettce作为默认连接池，可以切换到jedis。

**注意**：目前Spring Data Redis 暂时只支持 Jedis、Lettuce 的内部封装，而 Redisson 是由 [redisson-spring-data][] 来提供。

说明：jedis的使用见 [https://blog.csdn.net/liuxiao723846/article/details/86724124][https_blog.csdn.net_liuxiao723846_article_details_86724124]

接下来，我们主要介绍spring-data-redis的使用（redis单机情况），对于redis cluster、redis sentinel的情况后续介绍。

### 1、单数据源（springboot） ###

**1）maven：**

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
    </parent>
    
    <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>
            <exclusions>
                
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
    </dependencies>

说明：spring-boot-starter-data-redis中默认使用lettuce，若使用jedis库，需要将其exclude，然后手动引入jedis。

**2）redis.properties:**

redis.host=localhost
    redis.port=7395
    redis.password=123
    redis.timeout=600000
    #  Redis 数据库号，默认为 0 
    redis.database=0
    
    #最大空闲数  
    redis.maxIdle=300  
    #连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal  
    #redis.maxActive=600  
    #控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性  
    redis.maxTotal=1000  
    #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。  
    redis.maxWaitMillis=1000  
    #连接的最小空闲时间 默认1800000毫秒(30分钟)  
    redis.minEvictableIdleTimeMillis=300000  
    #每次释放连接的最大数目,默认3  
    redis.numTestsPerEvictionRun=1024  
    #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1  
    redis.timeBetweenEvictionRunsMillis=30000  
    #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个  
    redis.testOnBorrow=true  
    #在空闲时检查有效性, 默认false  
    redis.testWhileIdle=true

**3）RedisConfig.java**

说明：

*  如果代码中需要自己设置value的序列化方式，在RedisConfig中就无需指定。（比如：业务代码中有的按照json，有的按照pb序列化）
 *  spring-data-redis中字带了string、jackson等方式的序列化

**注意**：如果没有指定key的序列化方式，使用时发现在redis中的key会多出来类似\\xac\\xed\\x00\\x05t\\x00这种字符串，所以，最好指定key的序列化方式为string。

说明：新的spring-data-redis中，上面的方式创建JedisConnectionFactory已经被废弃了，如下：

![20210507181306292.png][]

新的api中引入了RedisStandaloneConfiguration和JedisClientConfiguration，可以使用如下方式创建：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70][]

**4）使用：**

@Service
    public class TestService {
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
        
        public String test1(String value) {
            redisTemplate.opsForValue().set("test_1",value);
            
            return (String)redisTemplate.opsForValue().get("test_1");
        }
        
        public String test2(String value) {
            User user = new User(99,value);
            byte[] serialize = SerializeUtil.serialize(user);
            
            redisTemplate.opsForValue().set("test_9",serialize);
            
            byte[] bytes = (byte[])redisTemplate.opsForValue().get("test_9");
            User obj = (User) SerializeUtil.unserialize(bytes);
    
            return obj.toString();
        }
    }
    
    
    //序列化工具
    public class SerializeUtil {
        public static byte[] serialize(Object object) {//序列化
            ObjectOutputStream oos = null;
            ByteArrayOutputStream baos = null;
            try {
                baos = new ByteArrayOutputStream();
                oos = new ObjectOutputStream(baos);
                oos.writeObject(object);
                byte[] bytes = baos.toByteArray();
                return bytes;
            } catch (Exception e) {
                System.out.println(e);
            }
            return null;
        }
     
        public static Object unserialize(byte[] bytes) {//反序列化
            ByteArrayInputStream bais = null;
            try {
                bais = new ByteArrayInputStream(bytes);
                ObjectInputStream ois = new ObjectInputStream(bais);
                return ois.readObject();
            } catch (Exception e) {
                System.out.println(e);
            }
            return null;
        }
    }

### 2、单数据源2（spring） ###

上面使用的是注解方式（springboot默认采用config注解，来代替application.xml中各种bean的声明），接下来我们采用原始的spring application.xml配置的方式来实现一遍。

**1）maven：**

<properties>
      <org.springframework.version>5.0.8.RELEASE</org.springframework.version>
    </properties>
    
    <dependencies>
      
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${org.springframework.version}</version>
      </dependency>
      
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${org.springframework.version}</version>
      </dependency>
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${org.springframework.version}</version>
      </dependency>
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${org.springframework.version}</version>
      </dependency>
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>${org.springframework.version}</version>
      </dependency>
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${org.springframework.version}</version>
      </dependency>
      <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.2</version>
      </dependency>
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${org.springframework.version}</version>
      </dependency>
      
      
      <dependency>
          <groupId>org.springframework.data</groupId>
          <artifactId>spring-data-redis</artifactId>
          <version>2.0.9.RELEASE</version>
          <exclusions>
                  <exclusion>
                      <groupId>io.lettuce</groupId>
                      <artifactId>lettuce-core</artifactId>
                  </exclusion>
          </exclusions>
      </dependency>
      
      <dependency>
              <groupId>redis.clients</groupId>
              <artifactId>jedis</artifactId>
              <version>2.9.0</version>
      </dependency>
      
      <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.9.6</version>
      </dependency>
      <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.6</version>
      </dependency>
      <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>2.9.0</version>
      </dependency>
      
      <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.5</version>
      </dependency>
    </dependencies>

**注**：spring的版本要和spring-data-redis的版本对应，否则在启动应用时会报java.lang.NoSuchMethodError（spring应用报该类错误，一般来说都是版本冲突导致）；其次，由于springmvc中依赖了jackson，所以jackson的版本也要对应。由于springboot简化了spring 项目的配置，所以我们可以在springboot项目中找到一份相匹配的spring、springmvc、spring-data-\*、jackson等版本信息。

**2）spring配置文件：**

a、springMVC.xml

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
         xmlns:context="http://www.springframework.org/schema/context"
         xmlns:mvc="http://www.springframework.org/schema/mvc"
         xmlns:tx="http://www.springframework.org/schema/tx"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.2.xsd
         http://www.springframework.org/schema/mvc
         http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
         http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">
      
      
       <mvc:annotation-driven>
            <mvc:message-converters register-defaults="true">
                <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                    <constructor-arg value="UTF-8"/>
                </bean>
            </mvc:message-converters>
        </mvc:annotation-driven>
    
      
      <context:component-scan base-package="cn.edu.nuc.springmvc_test" >
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>  
          <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>  
      </context:component-scan>
      
      
      <mvc:resources mapping="/images/**" location="/images/"/>
      <mvc:resources mapping="/html/**" location="/html/"/>
      <mvc:resources mapping="/js/**" location="/js/"/>
      <mvc:resources mapping="/css/**" location="/css/"/>
    
      
      <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"></property>
        <property name="suffix" value=".jsp"></property>
      </bean>
    </beans>

b、application.xml：

c、redis.xml配置：

**注**：多个spring配置文件中只能配置一个PropertyPlaceholderConfigurer，见：[https://blog.csdn.net/liuxiao723846/article/details/116493944][https_blog.csdn.net_liuxiao723846_article_details_116493944]

**说明**：在spring项目中，使用了各种xml配置代替了springboot中的各种Config类。

**3）redis.properties：**

在classpath下创建redis.properties文件，同上。

**4）测试类：**同上

### 3、单数据源（springboot中使用xml配置文件） ###

上面分别介绍了在springboot和spring项目中使用spring-data-redis组件。都知道springboot是用来简化spring应用的一个框架，我们可以把spring项目中的redis.xml 放到springboot项目中，并且在main方法上通过@ImportResource注解来指定redis.xml配置文件，同时在项目中去掉对应的RedisConfig类。如下：

**1）main方法：**

@SpringBootApplication
    @ImportResource(value = {"classpath:redis.xml"})
    @ComponentScan(basePackages = {"cn.edu.nuc.springboot_test.*"})
    public class App {
    
        public static void main(String[] args) {
            ApplicationContext applicationContext = SpringApplication.run(App.class, args);
    
        }
    }

**2）redis.xml文件：**

把上面的redis.xml放到springboot项目的classpath下，在redis.xml中通过<context:property-placeholder>标签来指定redis.properties文件，同时将RedisConfig类删掉，即可。

### 4、多数据源 ###

在实际项目中，一个应用往往会从多个redis数据源中获取数据，接下来，我们介绍如何在springboot项目中配置多个redis数据源。

**4.1）springboot中通过spring-data-redis配置多个redis数据源：**

1）RedisConfig.java：

import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    import redis.clients.jedis.JedisPoolConfig;
    
    @Configuration
    @PropertySource("classpath:redis.properties")
    public class RedisConfig {
        //数据源1
        @Value("${redis.host}")
        private String host;
        @Value("${redis.port}")
        private Integer port;
        @Value("${redis.password}")
        private String pwd;
        @Value("${redis.timeout}")
        private Integer timeout;
        //数据源2
        @Value("${demo.redis.host}")
        private String demoHost;
        @Value("${demo.redis.port}")
        private Integer demoPort;
        @Value("${demo.redis.password}")
        private String demoPwd;
        @Value("${demo.redis.database}")
        private Integer demoDatabase;
        @Value("${demo.redis.timeout}")
        private Integer demoTimeout;
        //连接池配置信息
        @Value("${redis.maxIdle}")
        private Integer maxIdle;
        @Value("${redis.maxTotal}")
        private Integer maxTotal;
        @Value("${redis.maxWaitMillis}")
        private Integer maxWaitMillis;
        @Value("${redis.minEvictableIdleTimeMillis}")
        private Integer minEvictableIdleTimeMillis;
        @Value("${redis.numTestsPerEvictionRun}")
        private Integer numTestsPerEvictionRun;
        @Value("${redis.timeBetweenEvictionRunsMillis}")
        private long timeBetweenEvictionRunsMillis;
        @Value("${redis.testOnBorrow}")
        private boolean testOnBorrow;
        @Value("${redis.testWhileIdle}")
        private boolean testWhileIdle;
        
        //JedisPoolConfig 连接池
        @Bean(name="jedisPoolConfig")
        public JedisPoolConfig jedisPoolConfig() {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxIdle(maxIdle);// 最大空闲数
            jedisPoolConfig.setMaxTotal(maxTotal);// 连接池的最大数据库连接数
            jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);// 最大建立连接等待时间
            jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);//逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
            jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);//每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
            jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);//逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1        
            jedisPoolConfig.setTestOnBorrow(testOnBorrow);//是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
            jedisPoolConfig.setTestWhileIdle(testWhileIdle);//在空闲时检查有效性, 默认false
            return jedisPoolConfig;
        }
        
        //数据源1的链接工厂
        @Bean(name="jedisConnectionFactory")
        @Primary
        public JedisConnectionFactory jedisConnectionFactory(@Qualifier("jedisPoolConfig") JedisPoolConfig jedisPoolConfig){
            JedisConnectionFactory JedisConnectionFactory = new JedisConnectionFactory();
            JedisConnectionFactory.setPoolConfig(jedisPoolConfig);  
            JedisConnectionFactory.setHostName(host);  
            JedisConnectionFactory.setPort(port);  
            if (pwd != null && !pwd.equals("")) {
                JedisConnectionFactory.setPassword(pwd);  
            }
            JedisConnectionFactory.setTimeout(timeout);  
            return JedisConnectionFactory; 
        }
    
        //数据源2的连接工厂
        @Bean(name="demoJedisConnectionFactory")
        public JedisConnectionFactory demoJedisConnectionFactory(@Qualifier("jedisPoolConfig") JedisPoolConfig jedisPoolConfig){
            //设置host、port等
            RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration();
            redisConfig.setHostName(demoHost);
            redisConfig.setPort(demoPort);
            if (demoPwd != null && !demoPwd.equals("")) {
                redisConfig.setPassword(RedisPassword.of(demoPwd));
            }
            redisConfig.setDatabase(demoDatabase);
            
            //设置连接池、timeout等
            JedisClientConfiguration jedisClientConfiguration = JedisClientConfiguration.builder()
                    .connectTimeout(Duration.ofMillis(demoTimeout))
                    .usePooling().poolConfig(jedisPoolConfig).build();
            
            return new JedisConnectionFactory(redisConfig,jedisClientConfiguration);
        }
    
        //数据源1的redisTemplate
        @Bean(name="redisTemplate")
        public RedisTemplate<String, Object> redisTemplate(@Qualifier("jedisConnectionFactory") RedisConnectionFactory factory) {
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            template.setKeySerializer(stringRedisSerializer);// key采用String的序列化方式
            template.setHashKeySerializer(stringRedisSerializer);// hash的key采用String的序列化方式
            template.setEnableTransactionSupport(true);// 开启事务
            template.setConnectionFactory(factory);// 设置链接工厂
            
            return template;
        }
    
        //数据源2的redisTemplate
        @Bean(name="demoRedisTemplate")
        public RedisTemplate<String, Object> demoRedisTemplate(@Qualifier("demoJedisConnectionFactory") RedisConnectionFactory demoJedisConnectionFactory) {
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            template.setKeySerializer(stringRedisSerializer);// key采用String的序列化方式
            template.setHashKeySerializer(stringRedisSerializer);// hash的key采用String的序列化方式
            
            template.setEnableTransactionSupport(true);// 开启事务
            template.setConnectionFactory(demoJedisConnectionFactory);// 设置链接工厂
            
            return template;
        }
    }

**说明**：每个数据源都配置一个连接工厂。在配置JedisConnectionFactory bean时，需要指定primary，否则会报如下错误：

Parameter 0 of method redisTemplate in org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration required a single bean, but 2 were found:

2）使用：

@Service
    public class TestService {
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;//数据源1
        @Autowired
        private RedisTemplate<String, Object> demoRedisTemplate;//数据源 2

**4.2）源码解读：**

通过spring-data-redis使用redis，通常需要配置以下三个bean：

*  JedisPoolConfig：连接池相关的配置；
 *  JedisConnectionFactory：redis连接工厂，依赖JedisPoolConfig对象；
 *  RedisTemplate：redis模版，依赖JedisConnectionFactory对象；

我们知道，在spring中默认bean都是单例（除非指定bean的Scope="prototype"），在上面的多数据源配置中，JedisPoolConfig bean只配置了一个，每个数据源都配置了一个JedisConnectionFactory bean，这样会不会造成不同数据源的连接工厂使用的是一个连接池对象？先给答案：不会！！！

启动上面多数据源的应用，使用JvisualVM连接上去，通过MBean可以看到，系统中一共有两个对象池，这说明每个redis数据源的连接工厂使用了一个连接池：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70 1][]

通过源码发现：

前面我们知道，spring-data-redis底层使用的是jedis或者lettuce库，这两个库都提供了redis连接池的功能。这里我们一jedis为例子：

在JedisConnectionFactory中有一个redis.clients.util.Pool pool 属性，这个属性正是jedis库提供的连接池对象（底层是org.apach.commons.pool2），该属性的初始化是通过如下方法完成的：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70 2][]

从这里可以清晰的看到，我们配置的JedisPoolConfig bean只是保存了连接池相关的信息，在JedisConnectionFactory中会根据这个信息来真正创建redis的连接池。所以，JedisPoolConfig bean 是单例还是多实例，都无所谓！

**4.3）xml版本的配置：**

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
    	   http://www.springframework.org/schema/beans/spring-beans.xsd
    	   http://www.springframework.org/schema/context
    	   http://www.springframework.org/schema/context/spring-context.xsd">
    
        <context:property-placeholder location="classpath*:redis.properties" ignore-unresolvable="true" />
        
        
        <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig" primary="true">
            <property name="maxTotal" value="${redis.maxTotal}"></property>
            <property name="maxIdle" value="${redis.maxIdle}"/>
            <property name="maxWaitMillis" value="${redis.maxWaitMillis}"/>
            <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
        </bean>
    
        
        <bean id="redisConnectionFactory" primary="true" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
            <property name="hostName" value="${redis.host}"/>
            <property name="port" value="${redis.port}"/>
            <property name="password" value="${redis.password}"/>
            
            <property name="poolConfig" ref="poolConfig"/>
        </bean>
        
        <bean id="demoRedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
            <property name="hostName" value="${demo.redis.host}"/>
            <property name="port" value="${demo.redis.port}"/>
            <property name="password" value="${demo.redis.password}"/>
            
            <property name="poolConfig" ref="poolConfig"/>
        </bean>
    
        <bean id="stringReadisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
    
        
        <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
            <property name="connectionFactory" ref="redisConnectionFactory"/>
            <property name="keySerializer" ref="stringReadisSerializer"/>
        </bean>
        
        <bean id="demoRedisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
            <property name="connectionFactory" ref="demoRedisConnectionFactory"/>
            <property name="keySerializer" ref="stringReadisSerializer"/>
        </bean>
    </beans>

注意：在springboot中，多个数据源的JedisConnectionFactory bean需要配置primary，在springmvc项目中，就不需要指定primary。

[https_spring.io_projects_spring-data-redis]: https://spring.io/projects/spring-data-redis
[20210429102923578.png]: /images/20210511/b49ce9b962ee4867a15c7f34eed0df63.png
[redisson-spring-data]: https://github.com/redisson/redisson/tree/master/redisson-spring-data
[https_blog.csdn.net_liuxiao723846_article_details_86724124]: https://blog.csdn.net/liuxiao723846/article/details/86724124
[20210507181306292.png]: /images/20210511/d4b0bfa981fc4f358130f7aadb89d74c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70]: /images/20210511/be3729515a27497f90bba4fee68cb873.png
[https_blog.csdn.net_liuxiao723846_article_details_116493944]: https://blog.csdn.net/liuxiao723846/article/details/116493944
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70 1]: /images/20210511/d455b5b9ac27461792d316dbb5e01229.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70 2]: /images/20210511/5f9aab7edee94a4ea5120b3090c82526.png