Spring Boot整合Redis

迷南。 2022-02-02 12:23 305阅读 0赞

一、Spring Boot对Redis的支持

Spring对Redis的支持是使用Spring Data Redis来实现的，一般使用Jedis或者lettuce（默认），Java客户端在 org.springframework.boot.autoconfigure.data.redis（Spring Boot 2.x） 中redis的自动配置 AutoConfigureDataRedis

　　　　　　　　　　　　　　　　　　1352849-20190508160938048-1486735555.png

RedisAutoConfiguration提供了RedisTemplate与StringRedisTemplate（只针对键值都是字符型的数据）模板，其中注解 @ConditionalOnMissingBean 是关键，表明该Bean如果在Spring中已经存在，则忽略，如果没有存在则在此处注册由Spring管理，也就是说我们可以“重写”该bean，实现自己的RedisTemplate与StringRedisTemplate，事实上，是要需要重写的，理由如下：

  • 没有实现我们所需要的序列化；

  • 泛型总是，大部分场景我们更需要。

    @Bean

    1. @ConditionalOnMissingBean(
    2.     name = {"redisTemplate"}
    3. )
    4. public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
    5.     RedisTemplate<Object, Object> template = new RedisTemplate();
    6.     template.setConnectionFactory(redisConnectionFactory);
    7.     return template;
    8. }
    10. @Bean
    11. @ConditionalOnMissingBean
    12. public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
    13.     StringRedisTemplate template = new StringRedisTemplate();
    14.     template.setConnectionFactory(redisConnectionFactory);
    15.     return template;
    16. }

二、实战

1、添加依赖

1）需要spring-boot-starter-cache依赖，管理缓存

  1. <!-- Spring Boot Cache -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-cache</artifactId>
  5. </dependency>

2）需要spring-boot-starter-data-redis依赖（注：spring boot 2.x改为在data下），支持redis：主要以为Jedis客户端为主，排除默认的lettuce作为客户端的依赖

  1. <!-- Redis Cache -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-data-redis</artifactId>
  5.     <!-- 排除lettuce包，使用jedis代替-->
  6.     <exclusions>
  7.         <exclusion>
  8.             <groupId>io.lettuce</groupId>
  9.             <artifactId>lettuce-core</artifactId>
  10.         </exclusion>
  11.     </exclusions>
  12. </dependency>

3）需要jedis-client依赖（注：Redis Client 3版本以上会报错与spring-boot-starter-data-redis冲突，最好使用2.9.x），使用jedis作为客户端

  1. <!-- Redis Client 3版本以上会报错与spring-boot-starter-data-redis冲突 -->
  2. <dependency>
  3.     <groupId>redis.clients</groupId>
  4.     <artifactId>jedis</artifactId>
  5.     <version>2.9.0</version>
  6. </dependency>

2、redis配置

创建RedisConfig配置类，增加@Configuration注解，同时开启缓存管理支持（添加注解@EnableCaching），继承CachingConfigurerSupport重写key生成策略

  1. @Configuration
  2. @EnableCaching
  3. public class RedisConfig extends CachingConfigurerSupport {
  4.      /**
  5.      * 生成key的策略:根据类名+方法名+所有参数的值生成唯一的一个key
  6.      * @return
  7.      */
  8.     @Bean
  9.     @Override
  10.     public KeyGenerator keyGenerator() {
  11.         return (Object target, Method method, Object... params) -> {
  12.             StringBuilder sb = new StringBuilder();
  13.             sb.append(target.getClass().getName());
  14.             sb.append(method.getName());
  15.             for (Object obj : params) {
  16.                 sb.append(obj.toString());
  17.             }
  18.             return sb.toString();
  19.         };
  20.     }
  22. }

之后使用的application.yml配置文件，其中这里已经选择jedis作为客户端。

  1. # redis 配置
  2.   redis:
  3.       port: 6379
  4.       # Redis服务器连接密码（默认为空）
  5.       password:
  6.       host: xxx.xxx.xxx.xxx
  7.       database: 0
  8.       jedis:
  9.         pool:
  10.           #连接池最大连接数（使用负值表示没有限制）
  11.           max-active: 300
  12.           # 连接池中的最小空闲连接
  13.           max-idle: 100
  14.            # 连接池最大阻塞等待时间（使用负值表示没有限制）
  15.           max-wait: 10000
  16.           # 连接超时时间（毫秒）
  17.           timeout: 5000

同时读取配置属性，注入JedisPoolConfig

  1. 　　/**
  2.      * redis配置属性读取
  3.      */
  4.     @Value("${spring.redis.host}")
  5.     private  String host;
  6.     @Value("${spring.redis.port}")
  7.     private  int port;
  8.     @Value("${spring.redis.database}")
  9.     private  int database;
  10.     @Value("${spring.redis.jedis.pool.max-idle}")
  11.     private int maxIdle;
  12.     @Value("${spring.redis.jedis.pool.max-wait}")
  13.     private long maxWaitMillis;
  14.     @Value("${spring.redis.jedis.pool.max-active}")
  15.     private int maxActive;
  18.     /**
  19.      * JedisPoolConfig配置
  20.      * @return
  21.      */
  22.     @Bean
  23.     public JedisPoolConfig jedisPoolConfig() {
  24.         log.info("初始化JedisPoolConfig");
  25.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
  26.         jedisPoolConfig.setMaxTotal(maxActive);
  27.         jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
  28.         jedisPoolConfig.setMaxIdle(maxIdle);
  29.         return jedisPoolConfig;
  30.     }

3、实现序列化

针对RedisTemplate或StringRedisTemplate进行序列化，同时重写注册Bean

RedisTemplate默认使用JdkSerializationRedisSerializer，StringRedisTmeplate默认使用的是StringRedisSerializer。但都是不符合实际要求的

  1. 　/**
  2.      * 重新实现RedisTemplate：解决序列化问题
  3.      * @param redisConnectionFactory
  4.      * @return
  5.      */
  6.     @Bean
  7.     @SuppressWarnings({"rawtype", "unchecked"})
  8.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
  9.         RedisTemplate<String, Object> template = new RedisTemplate();
  10.         template.setConnectionFactory(redisConnectionFactory);
  11.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  12.         ObjectMapper om = new ObjectMapper();
  13.         // 设置任何字段可见
  14.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  15.         // 设置不是final的属性可以转换
  16.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  17.         log.info("objectMapper: {}", om);
  18.         jackson2JsonRedisSerializer.setObjectMapper(om);
  19.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  20.         // key采用String的序列化方式
  21.         template.setKeySerializer(stringRedisSerializer);
  22.         // hash的key采用String的序列化方式
  23.         template.setHashKeySerializer(stringRedisSerializer);
  24.         // value序列化方式采用jackson序列化方式
  25.         template.setValueSerializer(jackson2JsonRedisSerializer);
  26.         // hash的value序列化方式采用jackson序列化方式
  27.         template.setHashValueSerializer(jackson2JsonRedisSerializer);
  28.         template.afterPropertiesSet();
  29.         template.setEnableTransactionSupport(true);
  30.         return template;
  31.     }
  33.     /**
  34.      * 重新实现StringRedisTmeplate：键值都是String的的数据
  35.      * @param redisConnectionFactory
  36.      * @return
  37.      */
  38.     @Bean
  39.     public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
  40.         StringRedisTemplate template = new StringRedisTemplate();
  41.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  42.         template.setConnectionFactory(redisConnectionFactory);
  43.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  44.         // key采用String的序列化方式
  45.         template.setKeySerializer(stringRedisSerializer);
  46.         // hash的key采用String的序列化方式
  47.         template.setHashKeySerializer(stringRedisSerializer);
  48.         // value序列化方式采用jackson序列化方式
  49.         template.setValueSerializer(jackson2JsonRedisSerializer);
  50.         // hash的value序列化方式采用jackson序列化方式
  51.         template.setHashValueSerializer(jackson2JsonRedisSerializer);
  52.         return template;
  53.     }

4、创建Redis连接工厂，同时注册Bean

　注意Spring Boot 1.x与Spring Boot 2.x的区别，已在代码中注释表明，Spring Boot 1.x使用的是JedisConnectionFactory 。而Spring Boot 2.x使用的是RedisStandaloneConfiguration ，之后传入JedisConnectionFactory返回Bean

  1. 　　/**
  2.      * 注入RedisConnectionFactory
  3.      * @return
  4.      */
  5.     @Bean
  6.     public RedisConnectionFactory redisConnectionFactory(JedisPoolConfig jedisPoolConfig) {
  7.         log.info("初始化JedisConnectionFactory");
  8.         /* 在Spring Boot 1.x中已经过时，采用RedisStandaloneConfiguration配置
  9.         JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);
  10.         jedisConnectionFactory.setHostName(host);
  11.         jedisConnectionFactory.setDatabase(database);*/
  13.         // JedisConnectionFactory配置hsot、database、password等参数
  14.         RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
  15.         redisStandaloneConfiguration.setHostName(host);
  16.         redisStandaloneConfiguration.setPort(port);
  17.         redisStandaloneConfiguration.setDatabase(database);
  18.         // JedisConnectionFactory配置jedisPoolConfig
  19.         JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jedisPoolConfigBuilder =
  20.                 (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder)JedisClientConfiguration.builder();
  21.         jedisPoolConfigBuilder.poolConfig(jedisPoolConfig);
  22.         return new JedisConnectionFactory(redisStandaloneConfiguration);
  24.     }

5、完整的RedisConfig配置类

  1. /**
  2.  *
  3.  * @author jian
  4.  * @date 2019/4/14
  5.  * @description
  6.  *  1) RedisTemplate（或StringRedisTemplate）虽然已经自动配置，但是不灵活（第一没有序列化，第二泛型为<Object, Object>不是我们想要的类型）
  7.  * 所以自己实现RedisTemplate或StringRedisTemplate）
  8.  *  2) 采用RedisCacheManager作为缓存管理器
  9.  *
  10.  */
  12. @Configuration
  13. @EnableCaching
  14. public class RedisConfig extends CachingConfigurerSupport {
  16.     private static final Logger log = LoggerFactory.getLogger(RedisConfig.class);
  18.     /**
  19.      * redis配置属性读取
  20.      */
  21.     @Value("${spring.redis.host}")
  22.     private  String host;
  23.     @Value("${spring.redis.port}")
  24.     private  int port;
  25.     @Value("${spring.redis.database}")
  26.     private  int database;
  27.     @Value("${spring.redis.jedis.pool.max-idle}")
  28.     private int maxIdle;
  29.     @Value("${spring.redis.jedis.pool.max-wait}")
  30.     private long maxWaitMillis;
  31.     @Value("${spring.redis.jedis.pool.max-active}")
  32.     private int maxActive;
  35.     /**
  36.      * JedisPoolConfig配置
  37.      * @return
  38.      */
  39.     @Bean
  40.     public JedisPoolConfig jedisPoolConfig() {
  41.         log.info("初始化JedisPoolConfig");
  42.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
  43.         jedisPoolConfig.setMaxTotal(maxActive);
  44.         jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
  45.         jedisPoolConfig.setMaxIdle(maxIdle);
  46.         return jedisPoolConfig;
  47.     }
  49.     /**
  50.      * 注入RedisConnectionFactory
  51.      * @return
  52.      */
  53.     @Bean
  54.     public RedisConnectionFactory redisConnectionFactory(JedisPoolConfig jedisPoolConfig) {
  55.         log.info("初始化JedisConnectionFactory");
  56.         /* 在Spring Boot 1.x中已经过时，采用RedisStandaloneConfiguration配置
  57.         JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);
  58.         jedisConnectionFactory.setHostName(host);
  59.         jedisConnectionFactory.setDatabase(database);*/
  61.         // JedisConnectionFactory配置hsot、database、password等参数
  62.         RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
  63.         redisStandaloneConfiguration.setHostName(host);
  64.         redisStandaloneConfiguration.setPort(port);
  65.         redisStandaloneConfiguration.setDatabase(database);
  66.         // JedisConnectionFactory配置jedisPoolConfig
  67.         JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jedisPoolConfigBuilder =
  68.                 (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder)JedisClientConfiguration.builder();
  69.         jedisPoolConfigBuilder.poolConfig(jedisPoolConfig);
  70.         return new JedisConnectionFactory(redisStandaloneConfiguration);
  72.     }
  74.     /**
  75.      * 采用RedisCacheManager作为缓存管理器
  76.      * @param connectionFactory
  77.      */
  78.     @Bean
  79.     public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
  80.         RedisCacheManager redisCacheManager = RedisCacheManager.create(connectionFactory);
  81.         return  redisCacheManager;
  82.     }
  85.     /**
  86.      * 生成key的策略:根据类名+方法名+所有参数的值生成唯一的一个key
  87.      * @return
  88.      */
  89.     @Bean
  90.     @Override
  91.     public KeyGenerator keyGenerator() {
  92.         return (Object target, Method method, Object... params) -> {
  93.             StringBuilder sb = new StringBuilder();
  94.             sb.append(target.getClass().getName());
  95.             sb.append(method.getName());
  96.             for (Object obj : params) {
  97.                 sb.append(obj.toString());
  98.             }
  99.             return sb.toString();
  100.         };
  101.     }
  103.     /**
  104.      * 重新实现RedisTemplate：解决序列化问题
  105.      * @param redisConnectionFactory
  106.      * @return
  107.      */
  108.     @Bean
  109.     @SuppressWarnings({"rawtype", "unchecked"})
  110.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
  111.         RedisTemplate<String, Object> template = new RedisTemplate();
  112.         template.setConnectionFactory(redisConnectionFactory);
  113.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  114.         ObjectMapper om = new ObjectMapper();
  115.         // 设置任何字段可见
  116.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  117.         // 设置不是final的属性可以转换
  118.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  119.         log.info("objectMapper: {}", om);
  120.         jackson2JsonRedisSerializer.setObjectMapper(om);
  121.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  122.         // key采用String的序列化方式
  123.         template.setKeySerializer(stringRedisSerializer);
  124.         // hash的key采用String的序列化方式
  125.         template.setHashKeySerializer(stringRedisSerializer);
  126.         // value序列化方式采用jackson序列化方式
  127.         template.setValueSerializer(jackson2JsonRedisSerializer);
  128.         // hash的value序列化方式采用jackson序列化方式
  129.         template.setHashValueSerializer(jackson2JsonRedisSerializer);
  130.         template.afterPropertiesSet();
  131.         template.setEnableTransactionSupport(true);
  132.         return template;
  133.     }
  135.     /**
  136.      * 重新实现StringRedisTmeplate：键值都是String的的数据
  137.      * @param redisConnectionFactory
  138.      * @return
  139.      */
  140.     @Bean
  141.     public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
  142.         StringRedisTemplate template = new StringRedisTemplate();
  143.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  144.         template.setConnectionFactory(redisConnectionFactory);
  145.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  146.         // key采用String的序列化方式
  147.         template.setKeySerializer(stringRedisSerializer);
  148.         // hash的key采用String的序列化方式
  149.         template.setHashKeySerializer(stringRedisSerializer);
  150.         // value序列化方式采用jackson序列化方式
  151.         template.setValueSerializer(jackson2JsonRedisSerializer);
  152.         // hash的value序列化方式采用jackson序列化方式
  153.         template.setHashValueSerializer(jackson2JsonRedisSerializer);
  154.         return template;
  155.     }
  157. }

三、测试

1、编写redis工具类

虽然RedisTemplate与StringRedisTemplate模板有提供的主要数据访问方法：

  • opsForValue()：操作只有简单属性的数据
  • opsForList()：操作含有List的数据
  • opsForSet()：操作含有set的数据
  • opsForHash()：操作含有hash的数据
  • opsForZSet()：操作含有有序set类型ZSet的数据

但是相关比较抽象，实现起来比较复杂，有必要进一步封装，比如使用redisTmeplate中的简单value的get操作：

  1. Object result = null;
  2. ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  3. result = operations.get(key);

但是封装之后，相对客户端用户来说比较明了

  1. 　　/**
  2.      * 读取缓存
  3.      *
  4.      * @param key
  5.      * @return
  6.      */
  7.     public Object get(final String key) {
  8.         Object result = null;
  9.         ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  10.         result = operations.get(key);
  11.         return result;
  12.     }

完整的简单工具类如下：

  1. @Component
  2. public class RedisUtils {
  5.     @Autowired
  6.     private RedisTemplate redisTemplate;
  8.     /**
  9.      * 批量删除对应的value
  10.      *
  11.      * @param keys
  12.      */
  13.     public void remove(final String... keys) {
  14.         for (String key : keys) {
  15.             remove(key);
  16.         }
  17.     }
  19.     /**
  20.      * 批量删除key
  21.      *
  22.      * @param pattern
  23.      */
  24.     public void removePattern(final String pattern) {
  25.         Set<Serializable> keys = redisTemplate.keys(pattern);
  26.         if (keys.size() > 0) {
  27.             redisTemplate.delete(keys);
  28.         }
  29.     }
  31.     /**
  32.      * 删除对应的value
  33.      *
  34.      * @param key
  35.      */
  36.     public void remove(final String key) {
  37.         if (exists(key)) {
  38.             redisTemplate.delete(key);
  39.         }
  40.     }
  42.     /**
  43.      * 判断缓存中是否有对应的value
  44.      *
  45.      * @param key
  46.      * @return
  47.      */
  48.     public boolean exists(final String key) {
  49.         return redisTemplate.hasKey(key);
  50.     }
  52.     /**
  53.      * 读取缓存
  54.      *
  55.      * @param key
  56.      * @return
  57.      */
  58.     public Object get(final String key) {
  59.         Object result = null;
  60.         ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  61.         result = operations.get(key);
  62.         return result;
  63.     }
  65.     /**
  66.      * 写入缓存
  67.      *
  68.      * @param key
  69.      * @param value
  70.      * @return
  71.      */
  72.     public boolean set(final String key, Object value) {
  73.         boolean result = false;
  74.         try {
  75.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  76.             operations.set(key, value);
  77.             result = true;
  78.         } catch (Exception e) {
  79.             e.printStackTrace();
  80.         }
  81.         return result;
  82.     }
  84.     /**
  85.      * 写入缓存
  86.      *
  87.      * @param key
  88.      * @param value
  89.      * @return
  90.      */
  91.     public boolean set(final String key, Object value, Long expireTime) {
  92.         boolean result = false;
  93.         try {
  94.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  95.             operations.set(key, value);
  96.             redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
  97.             result = true;
  98.         } catch (Exception e) {
  99.             e.printStackTrace();
  100.         }
  101.         return result;
  102.     }
  103. }

2、Person实体类

需要注意的是一定要实现序列化，并且有序列化版本ID

  1. public class Person implements Serializable {
  2.     private final long serialVersionUID = 1L;
  4.     private String id;
  5.     private String name;
  6.     private int age;
  7.     private String gender;
  9.     public String getId() {
  10.         return id;
  11.     }
  13.     public void setId(String id) {
  14.         this.id = id;
  15.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  25.     public int getAge() {
  26.         return age;
  27.     }
  29.     public void setAge(int age) {
  30.         this.age = age;
  31.     }
  33.     public String getGender() {
  34.         return gender;
  35.     }
  37.     public void setGender(String gender) {
  38.         this.gender = gender;
  39.     }
  41.     @Override
  42.     public String toString() {
  43.         return "Person{" +
  44.                 "id='" + id + '\'' +
  45.                 ", name='" + name + '\'' +
  46.                 ", age=" + age +
  47.                 ", gender='" + gender + '\'' +
  48.                 '}';
  49.     }
  50. }

3、编写测试类

Redis工具类Spring已经做了管理（增加@Compent注解），使用很简单，只需要注入RedisUtils即可

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class RedisTest {
  5.     @Autowired
  6.     private RedisUtils redisUtils;
  8.     @Test
  9.     public void test(){
  10.         Person person = new Person();
  11.         person.setAge(23);
  12.         person.setId("001");
  13.         person.setName("Zhangsan");
  14.         redisUtils.set("person-001", person);
  15.         System.out.println(redisUtils.get("person-001"));
  16.     }
  18. }

4、测试结果

在IDE控制台中：

1352849-20190508170544288-456874393.png

在登录客户端后查看value值

1352849-20190508170714657-1416109984.png

发表评论

表情：
评论列表 （有 0 条评论，305人围观）

还没有评论，来说两句吧...

相关阅读