一、测试未序列化的结果

  1. com.xxx目录下新建pojo文件夹用于保存实体类，并添加User用户类用于测试

    1. @Component  // 添加为组件，方便直接调用
    2. @AllArgsConstructor
    3. @NoArgsConstructor
    4. @Data
    5. public class User {
    6.  private String name;
    7.  private Integer age;
    8. }

  2. 在测试类中添加测试函数 ```java @Test // 表明此为测试函数 public void test() throws JsonProcessingException { // 真实开发一般使用 json 传递对象 User user = new User(“xiaohe”, 20); // 将对象转换成 json 字符串进行传值 String jsonUser = new ObjectMapper().writeValueAsString(user);

    // 创建一个键值对，key = user，value = jsonUser redisTemplate.opsForValue().set(“user”, jsonUser);

    // 获取加入 redis 中的数据 System.out.println(redisTemplate.opsForValue().get(“user”)); }

// 得到如下结果 {“name”:”xiaohe”, “age”:20}

  2. 3. 测试直接将对象传递给`redisTemplate.opsForValue().set(key, value);`
  3. ```java
  4. @Test  // 表明此为测试函数
  5. public void test() throws JsonProcessingException {
  6.     // 真实开发一般使用 json 传递对象
  7.     User user = new User("xiaohe", 20);
  9.     // 创建一个键值对，key = user，value = jsonUser
  10.     redisTemplate.opsForValue().set("user", user);
  12.     // 获取加入 redis 中的数据
  13.     System.out.println(redisTemplate.opsForValue().get("user"));
  14. }
  16. // 得到如下报错结果
  17. // Cannot serialize 表示没有序列化，对象无法进行传输
  18. org.springframework.data.redis.serializer.SerializationException: Cannot serialize; nested exception is org.springframework.core.serializer.support.SerializationFailedException: Failed to serialize object using DefaultSerializer; nested exception is java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload but received an object of type [com.hyh.pojo.User]
  20. at org.springframework.data.redis.serializer.JdkSerializationRedisSerializer.serialize(JdkSerializationRedisSerializer.java:96)
  21. at org.springframework.data.redis.core.AbstractOperations.rawValue(AbstractOperations.java:128)
  22. at org.springframework.data.redis.core.DefaultValueOperations.set(DefaultValueOperations.java:304)
  23. at com.hyh.SpringbootRedisApplicationTests.test(SpringbootRedisApplicationTests.java:67)
  24. at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
  25. at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
  26. at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
  27. at java.lang.reflect.Method.invoke(Method.java:498)
  28. ...

  1. 将实体类进行序列化

    1. // 实践中，一般所有的实体类都会序列化
    2. @Component  // 添加为组件，方便直接调用
    3. @AllArgsConstructor
    4. @NoArgsConstructor
    5. @Data
    6. public class User implements Serializable {
    7.  private String name;
    8.  private Integer age;
    9. }

  2. 序列化后再次测试直接传入对象 ```java @Test // 表明此为测试函数 public void test() throws JsonProcessingException { // 真实开发一般使用 json 传递对象 User user = new User(“xiaohe”, 20);

    // 创建一个键值对，key = user，value = jsonUser redisTemplate.opsForValue().set(“user”, user);

    // 获取加入 redis 中的数据 System.out.println(redisTemplate.opsForValue().get(“user”)); }

// 得到结果 User(name=xiaohe, age=20)

  1. <a name="cMI5U"></a>
  2. # 二、自定义`Redis`配置类用于序列化
  4. 1. 项目主文件夹下添加`config`目录，新增`RedisConfig`用于自定义`RedisTemplate`
  5.    1. `com.xxx`目录下新建`config`文件夹，并添加`RedisConfig`配置类
  6.    1. 添加自己的`RedisTemplate``myRedisTemplate`
  7. ```java
  8. @Bean
  9. @SuppressWarnings("all")
  10. public RedisTemplate<String, Object> myRedisTemplate(RedisConnectionFactory factory) {
  11.     // 为了自己开发方便，一般直接使用 <String, Object>
  12.     RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
  13.     template.setConnectionFactory(factory);
  15.     // 设置 Json 序列化配置
  16.     Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  17.     ObjectMapper om = new ObjectMapper();
  18.     om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  19.     om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  20.     jackson2JsonRedisSerializer.setObjectMapper(om);
  22.     // 设置 String 类型序列化
  23.     StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  25.     // 设置 key 采用 String 的序列化方式
  26.     template.setKeySerializer(stringRedisSerializer);
  28.     // 设置 hash 的 key 也采用 String 的序列化方式
  29.     template.setHashKeySerializer(stringRedisSerializer);
  31.     // 设置 value 序列化方式采用 jackson
  32.     template.setValueSerializer(jackson2JsonRedisSerializer);
  34.     // 设置 hash 的 value 序列化方式采用 jackson
  35.     template.setHashValueSerializer(jackson2JsonRedisSerializer);
  36.     template.afterPropertiesSet();
  38.     return template;
  39. }

  1. 添加自己的序列化myRedisTemplate后，重新执行test，此时的对象User user会被一个String类型接管 ```java @Test // 表明此为测试函数 public void test() throws JsonProcessingException { // 真实开发一般使用 json 传递对象 User user = new User(“xiaohe”, 20);

    // 创建一个键值对，key = user，value = jsonUser redisTemplate.opsForValue().set(“user”, user);

    // 获取加入 redis 中的数据 System.out.println(redisTemplate.opsForValue().get(“user”)); }

// 得到结果 User(name=xiaohe, age=20)

// cmd 查询结果 127.0.0.1:6379> keys * 1) “user” // 被String 类型接管

  1. <a name="Bej2X"></a>
  2. # 三、自定义`utils`工具类
  4. 1. `com.xxx`目录下新建`utils`文件夹，并添加`RedisUtil`工具类
  5. ```java
  6. /**
  7.  * Redis工具类
  8.  * @author ZENG.XIAO.YAN
  9.  * @date   2018年6月7日
  10.  */
  11. @Component
  12. public final class RedisUtil {
  14.     // 注入自定义的序列化配置类
  15.     @Autowired
  16.     @Qualifier("myRedisTemplate")
  17.     private RedisTemplate<String, Object> redisTemplate;
  19.     // =============================common============================
  20.     /**
  21.      * 指定缓存失效时间
  22.      * @param key 键
  23.      * @param time 时间(秒)
  24.      * @return
  25.      */
  26.     public boolean expire(String key, long time) {
  27.         try {
  28.             if (time > 0) {
  29.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  30.             }
  31.             return true;
  32.         } catch (Exception e) {
  33.             e.printStackTrace();
  34.             return false;
  35.         }
  36.     }
  38.     /**
  39.      * 根据 key 获取过期时间
  40.      * @param key 键 不能为 null
  41.      * @return 时间(秒) 返回 0 代表为永久有效
  42.      */
  43.     public long getExpire(String key) {
  44.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  45.     }
  47.     /**
  48.      * 判断 key 是否存在
  49.      * @param key 键
  50.      * @return true 存在 false 不存在
  51.      */
  52.     public boolean hasKey(String key) {
  53.         try {
  54.             return redisTemplate.hasKey(key);
  55.         } catch (Exception e) {
  56.             e.printStackTrace();
  57.             return false;
  58.         }
  59.     }
  61.     /**
  62.      * 删除缓存
  63.      * @param key 可以传一个值 或多个
  64.      */
  65.     @SuppressWarnings("unchecked")
  66.     public void del(String... key) {
  67.         if (key != null && key.length > 0) {
  68.             if (key.length == 1) {
  69.                 redisTemplate.delete(key[0]);
  70.             } else {
  71.                 redisTemplate.delete(CollectionUtils.arrayToList(key));
  72.             }
  73.         }
  74.     }
  76.     // ============================String=============================
  77.     /**
  78.      * 普通缓存 get
  79.      * @param key 键
  80.      * @return 值
  81.      */
  82.     public Object get(String key) {
  83.         return key == null ? null : redisTemplate.opsForValue().get(key);
  84.     }
  86.     /**
  87.      * 普通缓存 set
  88.      * @param key 键
  89.      * @param value 值
  90.      * @return true成功 false失败
  91.      */
  92.     public boolean set(String key, Object value) {
  93.         try {
  94.             redisTemplate.opsForValue().set(key, value);
  95.             return true;
  96.         } catch (Exception e) {
  97.             e.printStackTrace();
  98.             return false;
  99.         }
  101.     }
  103.     /**
  104.      * 普通缓存放入并设置时间
  105.      * @param key 键
  106.      * @param value 值
  107.      * @param time 时间(秒) time 要大于 0 如果 time 小于等于 0 将设置无限期
  108.      * @return true 成功 false 失败
  109.      */
  110.     public boolean set(String key, Object value, long time) {
  111.         try {
  112.             if (time > 0) {
  113.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  114.             } else {
  115.                 set(key, value);
  116.             }
  117.             return true;
  118.         } catch (Exception e) {
  119.             e.printStackTrace();
  120.             return false;
  121.         }
  122.     }
  124.     /**
  125.      * 递增
  126.      * @param key 键
  127.      * @param delta 要增加几(大于 0)
  128.      * @return
  129.      */
  130.     public long incr(String key, long delta) {
  131.         if (delta < 0) {
  132.             throw new RuntimeException("递增因子必须大于0");
  133.         }
  134.         return redisTemplate.opsForValue().increment(key, delta);
  135.     }
  137.     /**
  138.      * 递减
  139.      * @param key 键
  140.      * @param delta 要减少几(小于0)
  141.      * @return
  142.      */
  143.     public long decr(String key, long delta) {
  144.         if (delta < 0) {
  145.             throw new RuntimeException("递减因子必须大于0");
  146.         }
  147.         return redisTemplate.opsForValue().increment(key, -delta);
  148.     }
  150.     // ================================Map=================================
  151.     /**
  152.      * HashGet
  153.      * @param key 键 不能为null
  154.      * @param item 项 不能为null
  155.      * @return 值
  156.      */
  157.     public Object hget(String key, String item) {
  158.         return redisTemplate.opsForHash().get(key, item);
  159.     }
  161.     /**
  162.      * 获取 hashKey 对应的所有键值
  163.      * @param key 键
  164.      * @return 对应的多个键值
  165.      */
  166.     public Map<Object, Object> hmget(String key) {
  167.         return redisTemplate.opsForHash().entries(key);
  168.     }
  170.     /**
  171.      * HashSet
  172.      * @param key 键
  173.      * @param map 对应多个键值
  174.      * @return true 成功 false 失败
  175.      */
  176.     public boolean hmset(String key, Map<String, Object> map) {
  177.         try {
  178.             redisTemplate.opsForHash().putAll(key, map);
  179.             return true;
  180.         } catch (Exception e) {
  181.             e.printStackTrace();
  182.             return false;
  183.         }
  184.     }
  186.     /**
  187.      * HashSet 并设置时间
  188.      * @param key 键
  189.      * @param map 对应多个键值
  190.      * @param time 时间(秒)
  191.      * @return true成功 false 失败
  192.      */
  193.     public boolean hmset(String key, Map<String, Object> map, long time) {
  194.         try {
  195.             redisTemplate.opsForHash().putAll(key, map);
  196.             if (time > 0) {
  197.                 expire(key, time);
  198.             }
  199.             return true;
  200.         } catch (Exception e) {
  201.             e.printStackTrace();
  202.             return false;
  203.         }
  204.     }
  206.     /**
  207.      * 向一张 hash 表中放入数据,如果不存在将创建
  208.      * @param key 键
  209.      * @param item 项
  210.      * @param value 值
  211.      * @return true 成功 false 失败
  212.      */
  213.     public boolean hset(String key, String item, Object value) {
  214.         try {
  215.             redisTemplate.opsForHash().put(key, item, value);
  216.             return true;
  217.         } catch (Exception e) {
  218.             e.printStackTrace();
  219.             return false;
  220.         }
  221.     }
  223.     /**
  224.      * 向一张 hash 表中放入数据,如果不存在将创建
  225.      * @param key 键
  226.      * @param item 项
  227.      * @param value 值
  228.      * @param time 时间(秒) 注意:如果已存在的 hash 表有时间,这里将会替换原有的时间
  229.      * @return true 成功 false 失败
  230.      */
  231.     public boolean hset(String key, String item, Object value, long time) {
  232.         try {
  233.             redisTemplate.opsForHash().put(key, item, value);
  234.             if (time > 0) {
  235.                 expire(key, time);
  236.             }
  237.             return true;
  238.         } catch (Exception e) {
  239.             e.printStackTrace();
  240.             return false;
  241.         }
  242.     }
  244.     /**
  245.      * 删除 hash 表中的值
  246.      * @param key 键 不能为 null
  247.      * @param item 项 可以使多个 不能为 null
  248.      */
  249.     public void hdel(String key, Object... item) {
  250.         redisTemplate.opsForHash().delete(key, item);
  251.     }
  253.     /**
  254.      * 判断 hash 表中是否有该项的值
  255.      * @param key 键 不能为 null
  256.      * @param item 项 不能为 null
  257.      * @return true 存在 false 不存在
  258.      */
  259.     public boolean hHasKey(String key, String item) {
  260.         return redisTemplate.opsForHash().hasKey(key, item);
  261.     }
  263.     /**
  264.      * hash 递增 如果不存在,就会创建一个 并把新增后的值返回
  265.      * @param key 键
  266.      * @param item 项
  267.      * @param by 要增加几(大于 0)
  268.      * @return
  269.      */
  270.     public double hincr(String key, String item, double by) {
  271.         return redisTemplate.opsForHash().increment(key, item, by);
  272.     }
  274.     /**
  275.      * hash 递减
  276.      * @param key 键
  277.      * @param item 项
  278.      * @param by 要减少记(小于 0)
  279.      * @return
  280.      */
  281.     public double hdecr(String key, String item, double by) {
  282.         return redisTemplate.opsForHash().increment(key, item, -by);
  283.     }
  285.     // ============================set=============================
  286.     /**
  287.      * 根据 key 获取 Set 中的所有值
  288.      * @param key 键
  289.      * @return
  290.      */
  291.     public Set<Object> sGet(String key) {
  292.         try {
  293.             return redisTemplate.opsForSet().members(key);
  294.         } catch (Exception e) {
  295.             e.printStackTrace();
  296.             return null;
  297.         }
  298.     }
  300.     /**
  301.      * 根据 value 从一个 set 中查询,是否存在
  302.      * @param key 键
  303.      * @param value 值
  304.      * @return true 存在 false 不存在
  305.      */
  306.     public boolean sHasKey(String key, Object value) {
  307.         try {
  308.             return redisTemplate.opsForSet().isMember(key, value);
  309.         } catch (Exception e) {
  310.             e.printStackTrace();
  311.             return false;
  312.         }
  313.     }
  315.     /**
  316.      * 将数据放入 set 缓存
  317.      * @param key 键
  318.      * @param values 值 可以是多个
  319.      * @return 成功个数
  320.      */
  321.     public long sSet(String key, Object... values) {
  322.         try {
  323.             return redisTemplate.opsForSet().add(key, values);
  324.         } catch (Exception e) {
  325.             e.printStackTrace();
  326.             return 0;
  327.         }
  328.     }
  330.     /**
  331.      * 将 set 数据放入缓存
  332.      * @param key 键
  333.      * @param time 时间(秒)
  334.      * @param values 值 可以是多个
  335.      * @return 成功个数
  336.      */
  337.     public long sSetAndTime(String key, long time, Object... values) {
  338.         try {
  339.             Long count = redisTemplate.opsForSet().add(key, values);
  340.             if (time > 0)
  341.                 expire(key, time);
  342.             return count;
  343.         } catch (Exception e) {
  344.             e.printStackTrace();
  345.             return 0;
  346.         }
  347.     }
  349.     /**
  350.      * 获取 set 缓存的长度
  351.      * @param key 键
  352.      * @return
  353.      */
  354.     public long sGetSetSize(String key) {
  355.         try {
  356.             return redisTemplate.opsForSet().size(key);
  357.         } catch (Exception e) {
  358.             e.printStackTrace();
  359.             return 0;
  360.         }
  361.     }
  363.     /**
  364.      * 移除值为 value 的
  365.      * @param key 键
  366.      * @param values 值可以是多个
  367.      * @return 移除的个数
  368.      */
  369.     public long setRemove(String key, Object... values) {
  370.         try {
  371.             Long count = redisTemplate.opsForSet().remove(key, values);
  372.             return count;
  373.         } catch (Exception e) {
  374.             e.printStackTrace();
  375.             return 0;
  376.         }
  377.     }
  378.     // ===============================list=================================
  380.     /**
  381.      * 获取 list 缓存的内容
  382.      * @param key 键
  383.      * @param start 开始
  384.      * @param end 结束 0 到 -1 代表所有值
  385.      * @return
  386.      */
  387.     public List<Object> lGet(String key, long start, long end) {
  388.         try {
  389.             return redisTemplate.opsForList().range(key, start, end);
  390.         } catch (Exception e) {
  391.             e.printStackTrace();
  392.             return null;
  393.         }
  394.     }
  396.     /**
  397.      * 获取 list 缓存的长度
  398.      * @param key 键
  399.      * @return
  400.      */
  401.     public long lGetListSize(String key) {
  402.         try {
  403.             return redisTemplate.opsForList().size(key);
  404.         } catch (Exception e) {
  405.             e.printStackTrace();
  406.             return 0;
  407.         }
  408.     }
  410.     /**
  411.      * 通过索引 获取 list 中的值
  412.      * @param key 键
  413.      * @param index 索引 index>=0 时， 0 表头，1 第二个元素，依次类推；index<0 时，-1，表尾，-2 倒数第二个元素，依次类推
  414.      * @return
  415.      */
  416.     public Object lGetIndex(String key, long index) {
  417.         try {
  418.             return redisTemplate.opsForList().index(key, index);
  419.         } catch (Exception e) {
  420.             e.printStackTrace();
  421.             return null;
  422.         }
  423.     }
  425.     /**
  426.      * 将 list 放入缓存
  427.      * @param key 键
  428.      * @param value 值
  429.      * @return
  430.      */
  431.     public boolean lSet(String key, Object value) {
  432.         try {
  433.             redisTemplate.opsForList().rightPush(key, value);
  434.             return true;
  435.         } catch (Exception e) {
  436.             e.printStackTrace();
  437.             return false;
  438.         }
  439.     }
  441.     /**
  442.      * 将 list 放入缓存
  443.      * @param key 键
  444.      * @param value 值
  445.      * @param time 时间(秒)
  446.      * @return
  447.      */
  448.     public boolean lSet(String key, Object value, long time) {
  449.         try {
  450.             redisTemplate.opsForList().rightPush(key, value);
  451.             if (time > 0)
  452.                 expire(key, time);
  453.             return true;
  454.         } catch (Exception e) {
  455.             e.printStackTrace();
  456.             return false;
  457.         }
  458.     }
  460.     /**
  461.      * 将 list 放入缓存
  462.      * @param key 键
  463.      * @param value 值
  464.      * @return
  465.      */
  466.     public boolean lSet(String key, List<Object> value) {
  467.         try {
  468.             redisTemplate.opsForList().rightPushAll(key, value);
  469.             return true;
  470.         } catch (Exception e) {
  471.             e.printStackTrace();
  472.             return false;
  473.         }
  474.     }
  476.     /**
  477.      * 将 list 放入缓存
  478.      *
  479.      * @param key 键
  480.      * @param value 值
  481.      * @param time 时间(秒)
  482.      * @return
  483.      */
  484.     public boolean lSet(String key, List<Object> value, long time) {
  485.         try {
  486.             redisTemplate.opsForList().rightPushAll(key, value);
  487.             if (time > 0)
  488.                 expire(key, time);
  489.             return true;
  490.         } catch (Exception e) {
  491.             e.printStackTrace();
  492.             return false;
  493.         }
  494.     }
  496.     /**
  497.      * 根据索引修改 list 中的某条数据
  498.      * @param key 键
  499.      * @param index 索引
  500.      * @param value 值
  501.      * @return
  502.      */
  503.     public boolean lUpdateIndex(String key, long index, Object value) {
  504.         try {
  505.             redisTemplate.opsForList().set(key, index, value);
  506.             return true;
  507.         } catch (Exception e) {
  508.             e.printStackTrace();
  509.             return false;
  510.         }
  511.     }
  513.     /**
  514.      * 移除 N 个值为 value
  515.      * @param key 键
  516.      * @param count 移除多少个
  517.      * @param value 值
  518.      * @return 移除的个数
  519.      */
  520.     public long lRemove(String key, long count, Object value) {
  521.         try {
  522.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  523.             return remove;
  524.         } catch (Exception e) {
  525.             e.printStackTrace();
  526.             return 0;
  527.         }
  528.     }
  529. }

  1. 测试使用自定义的工具类RedisUtil

    1. 添加自定义工具类RedisUtil的注入

      1. @Autowired
      2. private RedisUtil redisUtil;

    2. 添加测试类testRedisUtil，然后就会发现使用redisUtil可以直接像在cmd窗口中一样使用各种熟悉的命令！简直妙啊！

image.png