单数据源版

1.引入依赖

  1. <!--Web组件-->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-web</artifactId>
  5. </dependency>
  7. <!--Redis-->
  8. <dependency>
  9.     <groupId>org.springframework.boot</groupId>
  10.     <artifactId>spring-boot-starter-data-redis</artifactId>
  11. </dependency>
  13. <!--Redis连接池-->
  14. <dependency>
  15.     <groupId>org.apache.commons</groupId>
  16.     <artifactId>commons-pool2</artifactId>
  17.     <version>2.9.0</version>
  18. </dependency>

2.yml文件增加配置

  1. #Spring配 置
  2. spring:
  4.   #Redis配置
  5.   redis:
  6.     host: 8.142.132.135
  7.     port: 6379
  8.     password:
  9.     database: 0
  10.     jedis:
  11.       pool:
  12.         max-active: 150
  13.         max-wait: 100
  14.         max-idle: 100
  15.         min-idle: 50
  16.     timeout: 5000ms
  1. max-active：最大激活连接数
  2. max-wait：连接最大等待时间
  3. max-idle：最大空闲连接数量
  4. min-idle：最小空闲连接数

    3.增加配置类

    ```java import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.databind.ObjectMapper; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; 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;

/**

  • @author 冯铁城 [17615007230@163.com]
  • @date 2022-05-06 16:18:18

  • @describe: Redis配置类 */ @Configuration public class RedisConfig {

    @Bean @ConditionalOnMissingBean(name = “redisTemplate”) public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {

    1.  //1.创建序列化类
    2.  Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
    3.  ObjectMapper om = new ObjectMapper();
    4.  om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    5.  jackson2JsonRedisSerializer.setObjectMapper(om);
    7.  //2.设置序列化规则
    8.  RedisTemplate<String, Object> template = new RedisTemplate<>();
    9.  template.setConnectionFactory(redisConnectionFactory);
    10.  template.setKeySerializer(jackson2JsonRedisSerializer);
    11.  template.setValueSerializer(jackson2JsonRedisSerializer);
    12.  template.setHashKeySerializer(jackson2JsonRedisSerializer);
    13.  template.setHashValueSerializer(jackson2JsonRedisSerializer);
    14.  template.afterPropertiesSet();
    16.  //3.返回模板
    17.  return template;

    } } ```

    4.编写单元测试验证

    ```java import org.junit.Assert; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest class RedistryApplicationTests {

  1. @Autowired
  2. private RedisTemplate<String, Object> redisTemplate;
  4. @Test
  5. void testRedis() {
  6.     redisTemplate.opsForValue().set("key", "value");
  7.     Object key = redisTemplate.opsForValue().get("key");
  8.     Assert.assertNotNull(key);
  9.     Assert.assertEquals("value", key);
  10. }

}

  1. <a name="EH8UY"></a>
  2. ## 多数据源版
  3. <a name="TTfJR"></a>
  4. ### 1.引入依赖
  5. ```xml
  6. <!--Web组件-->
  7. <dependency>
  8.   <groupId>org.springframework.boot</groupId>
  9.   <artifactId>spring-boot-starter-web</artifactId>
  10. </dependency>
  12. <!--Redis-->
  13. <dependency>
  14.   <groupId>org.springframework.boot</groupId>
  15.   <artifactId>spring-boot-starter-data-redis</artifactId>
  16. </dependency>
  18. <!--Redis连接池-->
  19. <dependency>
  20.   <groupId>org.apache.commons</groupId>
  21.   <artifactId>commons-pool2</artifactId>
  22.   <version>2.9.0</version>
  23. </dependency>

2.yml文件增加配置

  1. #配置Redis数据源(支持多数据源)
  2. redis:
  4.   #默认Redis连接
  5.   default-redis:
  6.     host: 8.142.132.135
  7.     port: 6379
  8.     password:
  9.     database: 0
  10.     timeout: 6000
  11.     max-active: 150
  12.     max-wait: 100
  13.     max-idle: 100
  14.     min-idle: 50
  16.   #其他Redis连接
  17.   other-redis:
  18.     host: 8.142.132.135
  19.     port: 6379
  20.     password:
  21.     database: 1
  22.     timeout: 6000
  23.     max-active: 150
  24.     max-wait: 100
  25.     max-idle: 100
  26.     min-idle: 50

3.添加Redis配置接口

  1. /**
  2.  * @author 冯铁城 [fengtiecheng@cyou-inc.com]
  3.  * @date 2022-01-07 16:53:28
  4.  * @describe:
  5.  */
  6. public interface RedisConfig {
  8.     /**
  9.      * 获取主机信息
  10.      *
  11.      * @return
  12.      */
  13.     String getHost();
  15.     /**
  16.      * 获取端口
  17.      *
  18.      * @return
  19.      */
  20.     int getPort();
  22.     /**
  23.      * 获取密码
  24.      *
  25.      * @return
  26.      */
  27.     String getPassword();
  29.     /**
  30.      * 获取数据库信息
  31.      *
  32.      * @return
  33.      */
  34.     int getDatabase();
  36.     /**
  37.      * 获取连接超时时间
  38.      *
  39.      * @return
  40.      */
  41.     long getTimeOut();
  43.     /**
  44.      * 获取最大激活连接数
  45.      *
  46.      * @return
  47.      */
  48.     int getMaxActive();
  50.     /**
  51.      * 获取最大等待时间
  52.      *
  53.      * @return
  54.      */
  55.     int getMaxWait();
  57.     /**
  58.      * 获取最大等待连接中的数量
  59.      *
  60.      * @return
  61.      */
  62.     int getMaxIdle();
  64.     /**
  65.      * 获取最小等待连接中的数量
  66.      *
  67.      * @return
  68.      */
  69.     int getMinIdle();
  70. }

4.添加Redis配置实现类

  1. import lombok.Setter;
  2. import org.springframework.boot.context.properties.ConfigurationProperties;
  3. import org.springframework.stereotype.Component;
  5. /**
  6.  * @author 冯铁城 [fengtiecheng@cyou-inc.com]
  7.  * @date 2022-01-07 16:59:24
  8.  * @describe: 平台默认Redis配置
  9.  */
  10. @Component
  11. @ConfigurationProperties(prefix = "redis.default-redis")
  12. @Setter
  13. public class DefaultRedisConfig implements RedisConfig {
  15.     /**
  16.      * 主机信息
  17.      */
  18.     private String host;
  20.     /**
  21.      * 端口
  22.      */
  23.     private int port;
  25.     /**
  26.      * 密码
  27.      */
  28.     private String password;
  30.     /**
  31.      * 数据库
  32.      */
  33.     private int database;
  35.     /**
  36.      * 连接超时时间
  37.      */
  38.     private long timeOut;
  40.     /**
  41.      * 最大激活连接数
  42.      */
  43.     private int maxActive;
  45.     /**
  46.      * 最大等待时间
  47.      */
  48.     private int maxWait;
  50.     /**
  51.      * 最大等待连接中的数量
  52.      */
  53.     private int maxIdle;
  55.     /**
  56.      * 最小等待连接中的数量
  57.      */
  58.     private int minIdle;
  60.     @Override
  61.     public String getHost() {
  62.         return this.host;
  63.     }
  65.     @Override
  66.     public int getPort() {
  67.         return this.port;
  68.     }
  70.     @Override
  71.     public String getPassword() {
  72.         return this.password;
  73.     }
  75.     @Override
  76.     public int getDatabase() {
  77.         return this.database;
  78.     }
  80.     @Override
  81.     public long getTimeOut() {
  82.         return this.timeOut;
  83.     }
  85.     @Override
  86.     public int getMaxActive() {
  87.         return this.maxActive;
  88.     }
  90.     @Override
  91.     public int getMaxWait() {
  92.         return this.maxWait;
  93.     }
  95.     @Override
  96.     public int getMaxIdle() {
  97.         return this.maxIdle;
  98.     }
  100.     @Override
  101.     public int getMinIdle() {
  102.         return this.minIdle;
  103.     }
  104. }
  1. import lombok.Setter;
  2. import org.springframework.boot.context.properties.ConfigurationProperties;
  3. import org.springframework.stereotype.Component;
  5. /**
  6.  * @author 冯铁城 [fengtiecheng@cyou-inc.com]
  7.  * @date 2022-01-07 16:59:24
  8.  * @describe: 其他Redis配置
  9.  */
  10. @Component
  11. @ConfigurationProperties(prefix = "redis.other-redis")
  12. @Setter
  13. public class OtherRedisConfig implements RedisConfig {
  15.     /**
  16.      * 主机信息
  17.      */
  18.     private String host;
  20.     /**
  21.      * 端口
  22.      */
  23.     private int port;
  25.     /**
  26.      * 密码
  27.      */
  28.     private String password;
  30.     /**
  31.      * 数据库
  32.      */
  33.     private int database;
  35.     /**
  36.      * 连接超时时间
  37.      */
  38.     private long timeOut;
  40.     /**
  41.      * 最大激活连接数
  42.      */
  43.     private int maxActive;
  45.     /**
  46.      * 最大等待时间
  47.      */
  48.     private int maxWait;
  50.     /**
  51.      * 最大等待连接中的数量
  52.      */
  53.     private int maxIdle;
  55.     /**
  56.      * 最小等待连接中的数量
  57.      */
  58.     private int minIdle;
  60.     @Override
  61.     public String getHost() {
  62.         return this.host;
  63.     }
  65.     @Override
  66.     public int getPort() {
  67.         return this.port;
  68.     }
  70.     @Override
  71.     public String getPassword() {
  72.         return this.password;
  73.     }
  75.     @Override
  76.     public int getDatabase() {
  77.         return this.database;
  78.     }
  80.     @Override
  81.     public long getTimeOut() {
  82.         return this.timeOut;
  83.     }
  85.     @Override
  86.     public int getMaxActive() {
  87.         return this.maxActive;
  88.     }
  90.     @Override
  91.     public int getMaxWait() {
  92.         return this.maxWait;
  93.     }
  95.     @Override
  96.     public int getMaxIdle() {
  97.         return this.maxIdle;
  98.     }
  100.     @Override
  101.     public int getMinIdle() {
  102.         return this.minIdle;
  103.     }
  104. }

5.添加Redis连接生成工厂

  1. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  2. import com.fasterxml.jackson.annotation.PropertyAccessor;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.beans.factory.annotation.Qualifier;
  7. import org.springframework.context.annotation.Bean;
  8. import org.springframework.context.annotation.Configuration;
  9. import org.springframework.context.annotation.Primary;
  10. import org.springframework.data.redis.connection.RedisConnectionFactory;
  11. import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
  12. import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
  13. import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
  14. import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
  15. import org.springframework.data.redis.core.RedisTemplate;
  16. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  17. import org.springframework.data.redis.serializer.StringRedisSerializer;
  19. import java.time.Duration;
  21. /**
  22.  * @author 冯铁城 [fengtiecheng@cyou-inc.com]
  23.  * @date 2022-01-07 17:33:43
  24.  * @describe: 多数据源Redis工厂
  25.  */
  26. @Configuration
  27. public class RedisTemplateConstructor {
  29.     @Autowired
  30.     @Qualifier("defaultRedisConfig")
  31.     private RedisConfig defaultRedisConfig;
  33.     @Autowired
  34.     @Qualifier("otherRedisConfig")
  35.     private RedisConfig otherRedisConfig;
  37.     /**
  38.      * 创建默认RedisTemplate
  39.      *
  40.      * @return 默认RedisTemplate
  41.      */
  42.     @Bean(name = "defaultRedis")
  43.     @Primary
  44.     public RedisTemplate<String, Object> defaultRedisTemplate() {
  46.         //1.创建连接工厂
  47.         LettuceConnectionFactory connectionFactory = this.lettuceConnectionFactory(defaultRedisConfig);
  49.         //2.创建RedisTemplate返回
  50.         return this.createRedisTemplate(connectionFactory);
  51.     }
  53.     /**
  54.      * 创建其他RedisTemplate
  55.      *
  56.      * @return 默认RedisTemplate
  57.      */
  58.     @Bean(name = "otherRedis")
  59.     public RedisTemplate<String, Object> otherRedisTemplate() {
  61.         //1.创建连接工厂
  62.         LettuceConnectionFactory connectionFactory = this.lettuceConnectionFactory(otherRedisConfig);
  64.         //2.创建RedisTemplate返回
  65.         return this.createRedisTemplate(connectionFactory);
  66.     }
  68.     /**
  69.      * 创建lettuce连接池工厂
  70.      *
  71.      * @param redisConfig Redis配置
  72.      * @return lettuce 连接池工厂
  73.      */
  74.     private LettuceConnectionFactory lettuceConnectionFactory(RedisConfig redisConfig) {
  76.         //1.线程池设置
  77.         GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
  78.         poolConfig.setMaxTotal(redisConfig.getMaxActive());
  79.         poolConfig.setMaxWaitMillis(redisConfig.getMaxWait());
  80.         poolConfig.setMaxIdle(redisConfig.getMaxIdle());
  81.         poolConfig.setMinIdle(redisConfig.getMinIdle());
  83.         //2.线程池客户端设置
  84.         LettuceClientConfiguration clientConfiguration = LettucePoolingClientConfiguration
  85.                 .builder()
  86.                 .commandTimeout(Duration.ofSeconds(redisConfig.getTimeOut()))
  87.                 .poolConfig(poolConfig)
  88.                 .build();
  90.         //3.Redis基础设置
  91.         RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
  92.         configuration.setHostName(redisConfig.getHost());
  93.         configuration.setDatabase(redisConfig.getDatabase());
  94.         configuration.setPassword(redisConfig.getPassword());
  95.         configuration.setPort(redisConfig.getPort());
  97.         //4.返回连接池工厂
  98.         LettuceConnectionFactory lettuceConnectionFactory = new LettuceConnectionFactory(configuration, clientConfiguration);
  99.         lettuceConnectionFactory.setShareNativeConnection(true);
  100.         lettuceConnectionFactory.afterPropertiesSet();
  101.         return lettuceConnectionFactory;
  102.     }
  104.     /**
  105.      * 创建RedisTemplate并设置序列化规则
  106.      *
  107.      * @param redisConnectionFactory redis连接池
  108.      */
  109.     private RedisTemplate<String, Object> createRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
  111.         //1.创建Redis连接模板
  112.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
  114.         //2.设置连接工厂
  115.         redisTemplate.setConnectionFactory(redisConnectionFactory);
  117.         //3.设置keyValue序列化规则
  118.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  119.         redisTemplate.setValueSerializer(new StringRedisSerializer());
  121.         //4.创建Hash序列化规则
  122.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  123.         ObjectMapper om = new ObjectMapper();
  124.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  125.         jackson2JsonRedisSerializer.setObjectMapper(om);
  127.         //5.设置HashKeyValue序列化规则
  128.         redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer);
  129.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
  131.         //6.返回
  132.         redisTemplate.afterPropertiesSet();
  133.         return redisTemplate;
  134.     }
  135. }

6.编写单元测试验证

  1. import org.junit.Assert;
  2. import org.junit.jupiter.api.Test;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.beans.factory.annotation.Qualifier;
  5. import org.springframework.boot.test.context.SpringBootTest;
  6. import org.springframework.data.redis.core.RedisTemplate;
  8. @SpringBootTest
  9. class RedistryApplicationTests {
  11.     @Autowired
  12.     @Qualifier("defaultRedis")
  13.     private RedisTemplate<String, Object> defaultRedis;
  15.     @Autowired
  16.     @Qualifier("otherRedis")
  17.     private RedisTemplate<String, Object> otherRedis;
  19.     @Test
  20.     void testRedis() {
  21.         defaultRedis.opsForValue().set("defaultKey", "defaultValue");
  22.         Object defaultKey = defaultRedis.opsForValue().get("defaultKey");
  23.         Assert.assertNotNull(defaultKey);
  24.         Assert.assertEquals("defaultValue", defaultKey);
  26.         otherRedis.opsForValue().set("otherKey", "otherValue");
  27.         Object otherKey = otherRedis.opsForValue().get("otherKey");
  28.         Assert.assertNotNull(otherKey);
  29.         Assert.assertEquals("otherValue", otherKey);
  30.     }
  31. }