精华内容
下载资源
问答
  • spring java redis 乱码
    2021-03-11 13:45:45

    spring java redis 乱码作者:曾 彬

    我们使用redisTemplate去set一个value时,在redis里面用key * 去获取,会发现不是正常的字符串。

    例如:

    设置值:

    redisTemplate.opsForValue().set("key1", "value1");

    获取key:

    127.0.0.1:6379> keys *key1

    127.0.0.1:6379> "\xac\xed\x00\x05t\x00"

    问题:

    出现这个问题的原因是,java是一个基于对象的语言,redis是基于字符串存储的NoSql,对象是无法存储到Redis中的。

    解决方案:

    java提供了序列化机制,只要类实现了java.io.Serializable接口,就代表类的对象能够进行序列化,通过将类对象进行序列化,就能够得到二进制的字符的。

    这样Redis就能将这些类对象的字符串进行存储,java也可以将那些二进制的字符串进行反序列化转为对象。

    spring基于这个原理,spring提供类序列化机制,这里讨论2个常用的序列化器

    StringRedisSerializer和JdkSerializationRedisSerializer(默认序列化器)

    解决,这里为们使用String的序列化器去序列化就可以了

    RedisTemplate redisTemplate = new RedisTemplate<>();

    //获取一个序列化器

    RedisSerializer stringRedisSerializer = redisTemplate.getStringSerializer();

    //下面设置序列化器

    redisTemplate.setKeySerialiazer(stringRedisSerializer);

    redisTemplate.setValueSerialiazer(stringRedisSerializer);

    //初始化链接

    redisTemplate.setConnectionFactoru(initConnectionFactory());

    //设置值

    redisTemplate.opsForValue().set("key1", "value1");

    使用redis获取key

    127.0.0.1:6379> keys *key1

    127.0.0.1:6379>"key1"

    127.0.0.1:6379> get key1

    127.0.0.1:6379>"value1"

    更多相关内容
  • 多个不同语言(java/C#/C++)开发的系统共用同一个redis进行数据传输,redis数据的中文乱码问题

            今天做公司项目的时候遇到的问题,项目是由多个模块组成的,我负责的模块是用Java语言开发的,其他同事负责的模块是通过C#、C++等语言开发的,各个模块之间通过共用的 redis 的列表进行数据传输,数据的格式是提前约定好的json格式的数据。

     

            问题:我开发的模块,引用了 jedis 客户端的依赖,用来处理redis的相关操作。结果发现从约定的列表中 rpop 获取到的 json 中中文乱码。具体效果如下:

    {

    "uuid": "6a4640bf-2081-4e2a-9b63-11a03dfaae8f",

    "request": "{\"uuid\":\"9e7eafdsdf-fsdfsd-fdfs4\",\"type\":\"STATUS_REPORT\",\"device_class\":\"RFID\",\"err_cod\":\"OK\",\"err_str\":\"\",\"data\":[{\"device_id\":\"XXXxxdfsdxxxxx\",\"status\":\"ERR_NETWORK\",\"status_str\":\"�������ӹ���\"},{\"device_id\":\"88f9f630babdb5d1\",\"status\":\"ERR_NETWORK\",\"status_str\":\"�������ӹ���\"},{\"device_id\":\"XXXxxxxxxx\",\"status\":\"ERR_NETWORK\",\"status_str\":\"�������ӹ���\"}]}"

    }

    (PS:本来约定的json数据中 request字段也是个对象,结果转成了字符串 T_T )

            这中间为了检查错误,折腾了好久,好在最终解决了,下面我说一下解决的过程。

            先假设我负责的模块叫模块A,用C#开发的同事负责的模块叫模块B,用c++开发的同事负责的模块叫模块C,出现这个问题的原因是,模块C的同事封了个dll库,用来处理传输数据的json封装和解析,这样模块B的同事可以直接调用这个库,所以模块B和模块C之间相互传输数据的时候,封装解析json都没有问题。但是我负责的模块A是用Java开发的,对传输的数据的封装解析都是得自己写的,无法调用模块C同事提供的dll库。

            我之所以从共用的redis中获取的数据是乱码,有两个原因。

    1. 模块C的默认字符集是GB2312,而我这边Java的字符集是UTF-8,两边的编码不一致 T_T;
    2. 模块C的同事封装的dll库,向redis的列表中push的时候,不是push的字符串,而是byte数组(这又是一个悲伤的故事T_T);

    (PS:据说原因2是因为在C++中,字符串和byte数组是一回事,那边的同事在往redis中push的时候也没有处理一下,结果就存成了byte数组)

            在这里,给上两张用RedisDesktopManager的截图来区分一下往redis中存字符串和存byte数组的区别:

    存字符串的如下:

     存byte数组的如下:

    好了,知道了原因了,就好解决了,基本的思路是:用jedis不直接取字符串了,取byte数组;然后将取到的byte数组以 GB2312 的编码读出来,就会发现乱码问题解决了

    具体测试代码如下:

    @Test
    public void redisT1() {
        // 1. 设置IP地址和端口
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        // 2. 选择知道的redisDB
        jedis.select(0);
        // 3. 从redis 的 CLIENT_DEVICE_STATUS 列表中取byte数组
        try {
            byte[] json = jedis.rpop("CLIENT_DEVICE_STATUS".getBytes("gb2312"));// 此处可以不指定字符集
            String jsonStr = new String(json, "gb2312");
            System.out.println("jsonStr--" + jsonStr);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        // 4. 释放资源
        jedis.close();
    }
    

    打印出的结果如下:

    { "uuid": "fcbb1a40-3eaa-487f-84b9-6bxxxxx4a1", "request": "{\"uuid\":\"3375dbdd-dd6-49c7-b68a-305a562de1a3\",\"type\":\"STATUS_REPORT\",\"device_class\":\"CAMERA\",\"err_cod\":\"OK\",\"err_str\":\"\",\"data\":[{\"device_id\":\"topdamage-59d5-44fc-8bf3-e59c475c70ec\",\"status\":\"ERR_NETWORK\",\"status_str\":\"网络连接故障\"},{\"device_id\":\"leftdamage-039a-4e5f-8b91-44f9fa21b3e8\",\"status\":\"ERR_NETWORK\",\"status_str\":\"网络连接故障\"},{\"device_id\":\"rightdamge-e691-442d-b5dd-eae66cd855df\",\"status\":\"ERR_NETWORK\",\"status_str\":\"网络连接故障\"},{\"device_id\":\"27ff7b79-33ca-4662-a981-037b7c63ab7d\",\"status\":\"ERR_NETWORK\",\"status_str\":\"网络连接故障\"},{\"device_id\":\"a4107069-37fd-47b3-aa4b-91990a390f4a\",\"status\":\"ERR_NETWORK\",\"status_str\":\"网络连接故障\"},{\"device_id\":\"c0e28cbb-2b2e-4959-b821-fcd70395e1d7\",\"status\":\"ERR_NETWORK\",\"status_str\":\"网络连接故障\"}]}" }

    然后就可以解析这个json啦 ~_~   ^_^

    我的微信公众号:

    基本是年更的状态,感兴趣的同学可以关注一下 ~_~

    展开全文
  • 解决方法: 在redis工具类里加上下面一个方法 @Component public class RedisUtils { @Resource private RedisTemplate<String, Object> redisTemplate; @Autowired private StringRedisTemplate ...

    解决方法: 在redis工具类里加上下面一个方法

    @Component
    public class RedisUtils {
    
            @Resource
            private RedisTemplate<String, Object> redisTemplate;
            @Autowired
            private StringRedisTemplate stringRedisTemplate;
    
    
            @Bean
            public RedisTemplate redisTemplateInit() {
                //设置序列化Key的实例化对象
                redisTemplate.setKeySerializer(new StringRedisSerializer());
                //设置序列化Value的实例化对象
                redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
                return redisTemplate;
            }
    
            /**
             * 指定缓存失效时间
             *
             * @param key  键
             * @param time 时间(秒)
             * @return
             */
            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 by  要增加几(大于0)
             * @return
             */
            public long incr(String key, long delta) {
                if (delta < 0) {
                    throw new RuntimeException("递增因子必须大于0");
                }
                return redisTemplate.opsForValue().increment(key, delta);
            }
    
            /**
             * 递减
             *
             * @param key 键
             * @param by  要减少几(小于0)
             * @return
             */
            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
             * @return 值
             */
            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 对应多个键值
             * @return true 成功 false 失败
             */
            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)
             * @return
             */
            public double hincr(String key, String item, double by) {
                return redisTemplate.opsForHash().increment(key, item, by);
            }
    
            /**
             * hash递减
             *
             * @param key  键
             * @param item 项
             * @param by   要减少记(小于0)
             * @return
             */
            public double hdecr(String key, String item, double by) {
                return redisTemplate.opsForHash().increment(key, item, -by);
            }
    
            // ============================set=============================
            /**
             * 根据key获取Set中的所有值
             *
             * @param key 键
             * @return
             */
            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 键
             * @return
             */
            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代表所有值
             * @return
             */
            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 键
             * @return
             */
            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倒数第二个元素,依次类推
             * @return
             */
            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 值
             * @return
             */
            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  时间(秒)
             * @return
             */
            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;
                }
            }
    
            /**
             *  获取指定前缀的一系列key
             *  使用scan命令代替keys, Redis是单线程处理,keys命令在KEY数量较多时,
             *  操作效率极低【时间复杂度为O(N)】,该命令一旦执行会严重阻塞线上其它命令的正常请求
             * @param keyPrefix
             * @return
             */
            private Set<String> keys(String keyPrefix) {
                String realKey = keyPrefix + "*";
    
                try {
                    return redisTemplate.execute((RedisCallback<Set<String>>) connection -> {
                        Set<String> binaryKeys = new HashSet<>();
                        Cursor<byte[]> cursor = connection.scan(new ScanOptions.ScanOptionsBuilder().match(realKey).count(Integer.MAX_VALUE).build());
                        while (cursor.hasNext()) {
                            binaryKeys.add(new String(cursor.next()));
                        }
    
                        return binaryKeys;
                    });
                } catch (Throwable e) {
                    e.printStackTrace();
                }
    
                return null;
            }
    
            /**
             *  删除指定前缀的一系列key
             * @param keyPrefix
             */
            public void removeAll(String keyPrefix) {
                try {
                    Set<String> keys = keys(keyPrefix);
                    redisTemplate.delete(keys);
                } catch (Throwable e) {
                    e.printStackTrace();
                }
            }
    }
    

    展开全文
  • 前言: 我们在使用 Java 操作redis时,或许会遇到乱码问题。虽然这些乱码可能并不影响Java程序的正常运行,但是使用 RDM 查看时redis数据时会很影响查看。以下提供一些解决办法。

    前言:

    我们在使用 Java 操作redis时,或许会遇到乱码问题。虽然这些乱码可能并不影响Java程序的正常运行,但是使用 RDM 查看时redis数据时会很影响查看。以下提供一些解决办法。


    一、常规乱码问题:

    在这里插入图片描述
    一般如下进行序列化就可以解决:

    /**
         * retemplate相关配置
         * @param redisConnectionFactory
         * @return
         */
        @Primary
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            // 配置连接工厂
            template.setConnectionFactory(redisConnectionFactory);
            // System.out.println(template.getConnectionFactory());
    
            // json 序列化配置
            Jackson2JsonRedisSerializer jsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); // 识别所有字段 PropertyAccessor 识别任何字段 JsonAutoDetect
            // objectMapper.enableDefaultTyping();  // enableDefaultTyping 已过期
            objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
            jsonRedisSerializer.setObjectMapper(objectMapper);
    
    
            // String 的 序列化
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    
            // key 采用 String的序列化
            template.setKeySerializer(stringRedisSerializer);
            // hash 的key采用String的序列化
            template.setHashKeySerializer(stringRedisSerializer);
            // hash 的 value 采用 String 的序列化
            template.setHashValueSerializer(jsonRedisSerializer);
            // value 序列化方式采用 Jackson
            template.setValueSerializer(stringRedisSerializer);
    
            template.afterPropertiesSet();
    
            return template;
        };
    

    一、非常规乱码问题:

    我前段时间通过IO流读取一行数据存入byte数组,然后byte数组转String字符串并作为主键存入redis出现乱码问题,我当时明明设置了序列化,但是依旧乱码,网上找遍也没有找到解决方法,后来通过断点调试发现了问题所在。
    在这里插入图片描述


    乱码原因:

    一般我们操作IO流读取数据会创建一个 1024 容量大小的 byte[1024] 字节数组用于接收读取出来的数据。然而我们读取出来的数据可能无法填满1024个字节,这样就导致在转化成 String 类型的时候,空出的位置将会自动被填充为 \u0000 。
    在这里插入图片描述这就是导致存入redis 出现\x00乱码的罪魁祸首, 并不是没有设置序列化引起的乱码。那怎么解决上述问题呢?
    解决很简单,只要在转化成String 过后做一次 \u0000 全部替换空即可。

    new String(bytes, "utf-8").replaceAll("\\u0000", "")
    

    在这里插入图片描述

    展开全文
  • 添加如下配置类 重启微服务 import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation...import org.springframework.data.redis.core.RedisTemplate; import
  • redis乱码问题

    2021-10-19 16:20:48
    我在对redis进行存储数据的时候,存储到redis里面的数据为这样的 这里我并没有理会,然后我再获取其中的一个值的时候,在redis的客户端进行操作的时候能获取到里面的值 然后再用java的方式进行获取,发现...
  • 这个名称是从数据库获取再保存到redis的,于是修改了数据库的错别字,重启redis后发现还是没有修改成功。 在网页上直接调方法查询数据发现依旧是之前的错别字,估计是redis默认持久化保存了。 当我打开redis客户端,...
  • Jedis: 3.0.1Redis: docker - latest 5.0.5JDK: Amazon Corretto 11OS: Ubuntu 18.04/ Windows 10@Testpublic void test1() {//1.获取连接Jedis jedis = null;try {jedis = new Jedis("10.249.50.9", 6379);jedis....
  • 最近在学习 SpringBoot 和 Redis 的集成,使用的时候发现一个问题:通过RedisTemplate存储进去的键值都是16进制的乱码:127.0.0.1:6379> keys *1) "\xac\xed\x00\x05t\x00\x04name"通过查阅资料,找到两种解决...
  • 上篇RedisTemplate写入Redis数据出现无意义乱码前缀\xac\xed\x00\x05,我在排查问题及给同事分享过程中,获得了一些收获,这里补充记录下。 关于中文 Java里中文采用UTF8编码,占3个字节。如粤,UTF8编码为\xE7\xB2\...
  • Redis学习笔记 Java并发编程学习笔记 四部分,详细拆分并发编程——并发编程+模式篇+应用篇+原理篇 Java程序员必看书籍《深入理解 ava虚拟机第3版》(pdf版) 大厂面试必问——数据结构与算法汇集笔记 其他像Spring...
  • 乱码截图如下:解决方法:在你redisutil类里加入下图红框的的代码,代码请复制:@autowired(required = false)public void setredistemplate(redistemplate redistemplate) {redisserializer stringserializer = new...
  • @Autowired private RedisTemplate... * 解决redis中文乱码 * @return */ @Bean public RedisTemplate redisTemplateInit() { redisTemplate.setKeySerializer(new StringRedisSerializer()); redisTemplate....
  • 狂神说Java-Redis笔记

    2022-03-28 19:50:37
    什么是NosqlNosql特点阿里巴巴演进分析Nosql的四大分类二、Redis入门概述环境搭建Windows安装Linux安装测试性能基础知识三、五大数据类型Redis-keyString(字符串)List(列表)Set(集合)Hash(哈希)Zset(有序集合)四...
  • 问题背景在Java Web项目中,经常需要前端请求数据,后台从数据库中查询并计算最后返回json格式数据给前端。而每次请求都需要计算一次可能比较浪费时间,这时我们可以将计算好的结果保存在redis中,下次请求时先判断...
  • Java连接Redis集群

    千次阅读 2021-04-29 08:32:08
    Java连接Redis集群 一、导入POM.XML SpringBoot2.0 Redis相关Jar包 <!--默认是lettuce客户端--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-...
  • 本篇文章小编给大家分享一下Java实现Redis存储复杂json格式数据并返回给前端代码示例,文章代码介绍的很详细,小编觉得挺不错的,现在分享给大家供大家参考,有需要的小伙伴们可以来看看。问题背景在Java Web项目中...
  • springboot整合redis出现乱码解决方法

    千次阅读 2019-06-13 11:56:34
    第一种情况 通过redisTemplate 设置值时乱码RedisConfig中加入序列化 // key序列化 redisTemplate.setKeySerializer(STRING_SERIALIZER); // value序列化 redisTemplate.setValueSerializer(JACKSON__...
  • 而我在用ElasticJob进行数据化初始化到Redis数据库时发现这些key都出现了一段前缀“乱码”。 数据结构为Hash,可以观察到hashkey也带有前缀“乱码” 这究竟是怎么回事呢?原来问题出在这: 我是用的是...
  • 基础数据类型 具体详情可直接访问Redis官网,这里只做命令总结 String 二进制安全的字符串 Lists: 按插入顺序排序的字符串元素的集合。他们基本上就是链表(linked lists)。 Sets: 不重复且无序的字符串元素的集合...
  • 配置文件、发布订阅、Java连接RedisRedis篇2】

    多人点赞 热门讨论 2021-12-09 09:25:38
    2.2、图解发布和订阅2.3、发布订阅命令实现3、Jedis测试3.1、Jedis所需要的jar包3.2、连接时的注意事项3.3、测试3.4、测试相关的数据类型3.4.1、Key3.4.2、String3.4.3、List3.4.4、set3.4.5、hash3.4.6、zset4、...
  • redis 存储中文乱码问题解决方案

    千次阅读 2020-06-19 10:33:26
    在用java 语言操作redis过程中,需要在redis 中存储中文,最初没有注意redis存储中文会出现乱码问题,使用命令查看,发现出现乱码。具体如图片: redis数据库中的数据是程序写入的,这里是在客户端查看的结果,乱码...
  • Java整合Redis
  • java连接redis

    2021-07-03 14:13:58
    引入redis依赖---------->jedis <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId>...java代码操控redis public class TextRedis {
  • CentOS 7 中的Redis的安装 配置 以及 JAVA连接测试最近重新配置redis时产生了 一些链接问题,不过网络上大家分享的方法都没有解决。所以给大家分享一下。跟着我的流程操作 应该是不会再出现连不上的问题。Linux下...
  • 简单记录一下java处理redis的几种序列化策略,这里使用的环境是springboot 2.0.4springboot中提供了StringRedisTemplate和RedisTemplate两种序列化类,它们都只能读自己存的数据,即数据互不相通。主要区别如下:1、...
  • 解决存取值乱码(更改相关序列化,只是为了使得存储的key和value不出现乱码) 项目中新增 RedisConfig package cn.zzt.springboot.config; import org.springframework.context.annotation.Bean; import org.spring...
  • 命令 使用 ./redis-cli --raw 命令进入,即可查看正常中文
  • import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Service; @Service public class StudentServiceImpl implements StudentService { @Autowired private ...
  • 主要介绍了redis的hGetAll函数的性能问题,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,218
精华内容 2,487
关键字:

java读取redis数据乱码

java 订阅