• • • 说明

      • SpringBoot操作数据使用spring-data
      • 在springboot2.x之后，原来使用的jedis被替换为了lettuce
      • jedis：采用的是直连，多个线程操作的话，是不安全的，想要避免不安全，使用jedis pool连接池，更像BIO模式
      • lettuce：采用netty，实例可以在多个线程*享，不存在线程不安全的情况，可以减少线程的数量，更像Nio模式

      源码分析

      @Bean
      //我们可以自己定义一个RedisTemplate来替换默认的RedisTemplate
      @ConditionalOnMissingBean(name = "redisTemplate") 
      @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
      public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
          //默认的RedisTemplate 没有过多的设置，redis对象都是需要序列化的
          //两个泛型都是Object, Object类型，我们后续使用都需要强制转换
      	RedisTemplate<Object, Object> template = new RedisTemplate<>();
      	template.setConnectionFactory(redisConnectionFactory);
      	return template;
      }
      
      @Bean
      //由于String是我们最常使用的类型，所以说单独提出了一个Bean
      @ConditionalOnMissingBean
      @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
      public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
      	return new StringRedisTemplate(redisConnectionFactory);
      }
      

      •  

      整合测试

      1. 导入依赖

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

      •  
      2. 配置连接

      # SpringBoot的所有配置类，都有一个自动配置类
      # 自动配置类都会绑定一个properties类
      spring.redis.host = 180.76.150.213
      spring.redis.port = 6379
      spring.redis.password = 123
      

      •  
      3. 测试连接

      @SpringBootTest
      class Redis02SpringbootApplicationTests {
      
          @Autowired
          private RedisTemplate redisTemplate;
      
          @Test
          void contextLoads() {
              //redisTemplate，操作不同的数据类型，api和我们的指令是一样的
              //操作字符串，类似String
              redisTemplate.opsForValue();
              //操作List
              redisTemplate.opsForList();
              //......
              redisTemplate.opsForHash();
              //......
      
              //除了基本的操作，我们常用的方法都可以直接redisTemplate来操作，比如事务和基本的增删改查
              //获取连接对象
              RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
              connection.flushDb();
              connection.flushAll();
      
              //测试
              redisTemplate.opsForValue().set("key","zzysy");
              System.out.println(redisTemplate.opsForValue().get("key"));
          }
      }
      

      •  

      关于序列化问题：

      

      关于对象的保存：

      @Component
      @AllArgsConstructor
      @NoArgsConstructor
      @Data
      //此时没有进行序列化
      public class User {
          private String name;
          private int age;
      }
      

      •  

      @Test
      public void test() throws JsonProcessingException {
          User zzy = new User("zzy", 20);
          redisTemplate.opsForValue().set("user",zzy);
          System.out.println(redisTemplate.opsForValue().get("user"));
      }
      

      •  

      报错，提示无法序列化
      
      对User序列化

      @Component
      @AllArgsConstructor
      @NoArgsConstructor
      @Data
      //进行序列化
      //在企业中，所有的pojo类都需要序列化
      public class User implements Serializable {
          private String name;
          private int age;
      }
      

      •  

      这次序列化成功
      
      但是如果使用默认的序列化，添加的key前面有转义字符，不方便我们的操作，这时我们应当使用其他的序列化方法，下面来讲解
      

      重新编写自己的RedisTemplate：

      @Configuration
      public class RedisConfig {
          //编写我们自己的RedisTemplate
          @Bean
          @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
          public RedisTemplate<String, Object> redisTemplates(RedisConnectionFactory redisConnectionFactory) {
              //我们为了开发方便，一般直接使用<String, Object>
              RedisTemplate<String, Object> template = new RedisTemplate<>();
              template.setConnectionFactory(redisConnectionFactory);
              //Jackson序列化配置
              Jackson2JsonRedisSerializer objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
              ObjectMapper om = new ObjectMapper();
              om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
              om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL,JsonTypeInfo.As.PROPERTY);
              objectJackson2JsonRedisSerializer.setObjectMapper(om);
              //String的序列化
              StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
              //key采用String的序列化方式
              template.setKeySerializer(stringRedisSerializer);
              //hash的key也采用String的序列化方式
              template.setHashKeySerializer(stringRedisSerializer);
              //value序列化方式采用Jackson
              template.setValueSerializer(objectJackson2JsonRedisSerializer);
              //hash序列化方式采用Jackson
              template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
              template.afterPropertiesSet();
              return template;
          }
      }
      

      •  

      重新测试：

      @SpringBootTest
      class Redis02SpringbootApplicationTests {
      	
          //对象名要和RedisConfig中的一致，要不然还是用的默认的RedisTemplate
          @Autowired
          private RedisTemplate redisTemplates;
      
          @Test
          public void test() throws JsonProcessingException {
              User zzy = new User("zzy", 20);
              redisTemplates.opsForValue().set("user",zzy);
              System.out.println(redisTemplates.opsForValue().get("user"));
          }
      }
      

      •  

      这是我们就可以使用我们自己设置的序列化将key添加进去了
      

      在企业开发中，80%情况下都不会使用原生的方式编写代码：

      
      我们来编写一个工具类RedisUtils

      import org.springframework.beans.factory.annotation.Autowired;
      import org.springframework.data.redis.core.RedisTemplate;
      import org.springframework.stereotype.Component;
      import org.springframework.util.CollectionUtils;
      
      import java.util.List;
      import java.util.Map;
      import java.util.Set;
      import java.util.concurrent.TimeUnit;
      
      // 在我们真实的分发中，或者你们在公司，一般都可以看到一个公司自己封装RedisUtil
      @Component
      public final class RedisUtil {
      
          @Autowired
          private RedisTemplate<String, Object> redisTemplate;
          
          // =============================common============================
          /**
           * 指定缓存失效时间
           * @param key  键
           * @param time 时间(秒)
           */
          public boolean expire(String key, long time) {
              try {
                  if (time > 0) {
                      redisTemplate.expire(key, time, TimeUnit.SECONDS);
                  }
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 根据key 获取过期时间
           * @param key 键 不能为null
           * @return 时间(秒) 返回0代表为永久有效
           */
          public long getExpire(String key) {
              return redisTemplate.getExpire(key, TimeUnit.SECONDS);
          }
      
      
          /**
           * 判断key是否存在
           * @param key 键
           * @return true 存在 false不存在
           */
          public boolean hasKey(String key) {
              try {
                  return redisTemplate.hasKey(key);
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
      
          /**
           * 删除缓存
           * @param key 可以传一个值 或多个
           */
          @SuppressWarnings("unchecked")
          public void del(String... key) {
              if (key != null && key.length > 0) {
                  if (key.length == 1) {
                      redisTemplate.delete(key[0]);
                  } else {
                      redisTemplate.delete(CollectionUtils.arrayToList(key));
                  }
              }
          }
      
      
          // ============================String=============================
      
          /**
           * 普通缓存获取
           * @param key 键
           * @return 值
           */
          public Object get(String key) {
              return key == null ? null : redisTemplate.opsForValue().get(key);
          }
          
          /**
           * 普通缓存放入
           * @param key   键
           * @param value 值
           * @return true成功 false失败
           */
      
          public boolean set(String key, Object value) {
              try {
                  redisTemplate.opsForValue().set(key, value);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
      
          /**
           * 普通缓存放入并设置时间
           * @param key   键
           * @param value 值
           * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
           * @return true成功 false 失败
           */
      
          public boolean set(String key, Object value, long time) {
              try {
                  if (time > 0) {
                      redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                  } else {
                      set(key, value);
                  }
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
      
          /**
           * 递增
           * @param key   键
           * @param delta 要增加几(大于0)
           */
          public long incr(String key, long delta) {
              if (delta < 0) {
                  throw new RuntimeException("递增因子必须大于0");
              }
              return redisTemplate.opsForValue().increment(key, delta);
          }
      
      
          /**
           * 递减
           * @param key   键
           * @param delta 要减少几(小于0)
           */
          public long decr(String key, long delta) {
              if (delta < 0) {
                  throw new RuntimeException("递减因子必须大于0");
              }
              return redisTemplate.opsForValue().increment(key, -delta);
          }
      
      
          // ================================Map=================================
      
          /**
           * HashGet
           * @param key  键 不能为null
           * @param item 项 不能为null
           */
          public Object hget(String key, String item) {
              return redisTemplate.opsForHash().get(key, item);
          }
          
          /**
           * 获取hashKey对应的所有键值
           * @param key 键
           * @return 对应的多个键值
           */
          public Map<Object, Object> hmget(String key) {
              return redisTemplate.opsForHash().entries(key);
          }
          
          /**
           * HashSet
           * @param key 键
           * @param map 对应多个键值
           */
          public boolean hmset(String key, Map<String, Object> map) {
              try {
                  redisTemplate.opsForHash().putAll(key, map);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
      
          /**
           * HashSet 并设置时间
           * @param key  键
           * @param map  对应多个键值
           * @param time 时间(秒)
           * @return true成功 false失败
           */
          public boolean hmset(String key, Map<String, Object> map, long time) {
              try {
                  redisTemplate.opsForHash().putAll(key, map);
                  if (time > 0) {
                      expire(key, time);
                  }
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
      
          /**
           * 向一张hash表中放入数据,如果不存在将创建
           *
           * @param key   键
           * @param item  项
           * @param value 值
           * @return true 成功 false失败
           */
          public boolean hset(String key, String item, Object value) {
              try {
                  redisTemplate.opsForHash().put(key, item, value);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 向一张hash表中放入数据,如果不存在将创建
           *
           * @param key   键
           * @param item  项
           * @param value 值
           * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
           * @return true 成功 false失败
           */
          public boolean hset(String key, String item, Object value, long time) {
              try {
                  redisTemplate.opsForHash().put(key, item, value);
                  if (time > 0) {
                      expire(key, time);
                  }
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
      
          /**
           * 删除hash表中的值
           *
           * @param key  键 不能为null
           * @param item 项 可以使多个 不能为null
           */
          public void hdel(String key, Object... item) {
              redisTemplate.opsForHash().delete(key, item);
          }
      
      
          /**
           * 判断hash表中是否有该项的值
           *
           * @param key  键 不能为null
           * @param item 项 不能为null
           * @return true 存在 false不存在
           */
          public boolean hHasKey(String key, String item) {
              return redisTemplate.opsForHash().hasKey(key, item);
          }
      
      
          /**
           * hash递增 如果不存在,就会创建一个 并把新增后的值返回
           *
           * @param key  键
           * @param item 项
           * @param by   要增加几(大于0)
           */
          public double hincr(String key, String item, double by) {
              return redisTemplate.opsForHash().increment(key, item, by);
          }
      
      
          /**
           * hash递减
           *
           * @param key  键
           * @param item 项
           * @param by   要减少记(小于0)
           */
          public double hdecr(String key, String item, double by) {
              return redisTemplate.opsForHash().increment(key, item, -by);
          }
      
      
          // ============================set=============================
      
          /**
           * 根据key获取Set中的所有值
           * @param key 键
           */
          public Set<Object> sGet(String key) {
              try {
                  return redisTemplate.opsForSet().members(key);
              } catch (Exception e) {
                  e.printStackTrace();
                  return null;
              }
          }
      
      
          /**
           * 根据value从一个set中查询,是否存在
           *
           * @param key   键
           * @param value 值
           * @return true 存在 false不存在
           */
          public boolean sHasKey(String key, Object value) {
              try {
                  return redisTemplate.opsForSet().isMember(key, value);
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
      
          /**
           * 将数据放入set缓存
           *
           * @param key    键
           * @param values 值 可以是多个
           * @return 成功个数
           */
          public long sSet(String key, Object... values) {
              try {
                  return redisTemplate.opsForSet().add(key, values);
              } catch (Exception e) {
                  e.printStackTrace();
                  return 0;
              }
          }
      
      
          /**
           * 将set数据放入缓存
           *
           * @param key    键
           * @param time   时间(秒)
           * @param values 值 可以是多个
           * @return 成功个数
           */
          public long sSetAndTime(String key, long time, Object... values) {
              try {
                  Long count = redisTemplate.opsForSet().add(key, values);
                  if (time > 0)
                      expire(key, time);
                  return count;
              } catch (Exception e) {
                  e.printStackTrace();
                  return 0;
              }
          }
      
      
          /**
           * 获取set缓存的长度
           *
           * @param key 键
           */
          public long sGetSetSize(String key) {
              try {
                  return redisTemplate.opsForSet().size(key);
              } catch (Exception e) {
                  e.printStackTrace();
                  return 0;
              }
          }
      
      
          /**
           * 移除值为value的
           *
           * @param key    键
           * @param values 值 可以是多个
           * @return 移除的个数
           */
      
          public long setRemove(String key, Object... values) {
              try {
                  Long count = redisTemplate.opsForSet().remove(key, values);
                  return count;
              } catch (Exception e) {
                  e.printStackTrace();
                  return 0;
              }
          }
      
          // ===============================list=================================
          
          /**
           * 获取list缓存的内容
           *
           * @param key   键
           * @param start 开始
           * @param end   结束 0 到 -1代表所有值
           */
          public List<Object> lGet(String key, long start, long end) {
              try {
                  return redisTemplate.opsForList().range(key, start, end);
              } catch (Exception e) {
                  e.printStackTrace();
                  return null;
              }
          }
      
      
          /**
           * 获取list缓存的长度
           *
           * @param key 键
           */
          public long lGetListSize(String key) {
              try {
                  return redisTemplate.opsForList().size(key);
              } catch (Exception e) {
                  e.printStackTrace();
                  return 0;
              }
          }
      
      
          /**
           * 通过索引 获取list中的值
           *
           * @param key   键
           * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
           */
          public Object lGetIndex(String key, long index) {
              try {
                  return redisTemplate.opsForList().index(key, index);
              } catch (Exception e) {
                  e.printStackTrace();
                  return null;
              }
          }
      
      
          /**
           * 将list放入缓存
           *
           * @param key   键
           * @param value 值
           */
          public boolean lSet(String key, Object value) {
              try {
                  redisTemplate.opsForList().rightPush(key, value);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
      
          /**
           * 将list放入缓存
           * @param key   键
           * @param value 值
           * @param time  时间(秒)
           */
          public boolean lSet(String key, Object value, long time) {
              try {
                  redisTemplate.opsForList().rightPush(key, value);
                  if (time > 0)
                      expire(key, time);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
      
          }
      
      
          /**
           * 将list放入缓存
           *
           * @param key   键
           * @param value 值
           * @return
           */
          public boolean lSet(String key, List<Object> value) {
              try {
                  redisTemplate.opsForList().rightPushAll(key, value);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
      
          }
      
      
          /**
           * 将list放入缓存
           *
           * @param key   键
           * @param value 值
           * @param time  时间(秒)
           * @return
           */
          public boolean lSet(String key, List<Object> value, long time) {
              try {
                  redisTemplate.opsForList().rightPushAll(key, value);
                  if (time > 0)
                      expire(key, time);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 根据索引修改list中的某条数据
           *
           * @param key   键
           * @param index 索引
           * @param value 值
           * @return
           */
      
          public boolean lUpdateIndex(String key, long index, Object value) {
              try {
                  redisTemplate.opsForList().set(key, index, value);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 移除N个值为value
           *
           * @param key   键
           * @param count 移除多少个
           * @param value 值
           * @return 移除的个数
           */
      
          public long lRemove(String key, long count, Object value) {
              try {
                  Long remove = redisTemplate.opsForList().remove(key, count, value);
                  return remove;
              } catch (Exception e) {
                  e.printStackTrace();
                  return 0;
              }
      
          }
      
      }
      

      •  

      使用工具类：

      @Autowired
      private RedisUtil redisUtil;
      
      @Test
      public void test() throws JsonProcessingException {
          redisUtil.set("name","zzy");
          System.out.println(redisUtil.get("name"));
      }
      

      •  

      

 

原文链接:https://blog.csdn.net/weixin_46116099/article/details/122893281