RedisTemplate出现\xac\xed\x00\x05t\x00\x0f前缀解决

已于 2024-06-21 13:05:57 修改
阅读量1k 收藏 1
点赞数
分类专栏： Java 文章标签： java redis 开发语言
于 2023-09-25 10:31:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hudeyong926/article/details/133267963
版权

问题描叙

出现这种乱码前缀的原因是没有进行序列化，因此导致在传输过程出现乱码问题，存到数据库，发现 key,hash key/value 都有 \xAC\xED\x00\x05t\x00 前缀。RedisTemplate类中默认是没有设置序列化的。

解决方法

设置RedisTemplate的序列化方式

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
 
public class RedisConfig {
    @Bean(name = "redisTemplate")
    //配置redisTemplate
    //默认情况下redisTemplate只能支持redisTemplate<String,String>
    //需要自定义 RedisTemplate,设置序列化
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String,Object> template = new RedisTemplate <>();
        template.setConnectionFactory(factory);
 
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
 
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

注意：用了StringRedisSerializer之后，redis库的数据都是以String类型保存，所以int类型的整数，在保存时，会类型上升， 先变成double，然后再存成String，也就是1会存成"1.0"，所以如果保存int数据时，需要自己在代码中单独处理下。上面修改全局配置不能兼容新老数据，新增配置可以兼容。

修改序列化方式后，数据不兼容报错

org.springframework.data.redis.serializer.SerializationException: Cannot deserialize; nested exception is org.springframework.core.serializer.support.SerializationFailedException: Failed to deserialize payload. Is the byte array a result of corresponding serialization for DefaultDeserializer?; nested exception is java.io.StreamCorruptedException: invalid stream header: E5A487E6

使用多个redisTemplate配置

@Configuration
public class RedisConfig {

    @Bean
    @Primary
    public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        return redisTemplate;
    }

    @Bean(name = "ByteRedisTemplate")
    public RedisTemplate ByteRedisTemplate(
            RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(RedisSerializer.byteArray());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(RedisSerializer.byteArray());
        return redisTemplate;
    }
}

使用方法 

@RestController
public class PublishDemo {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    @Qualifier("ByteRedisTemplate")
    private RedisTemplate byteRedisTemplate;

    @RequestMapping("set")
    public void set() {
        String key1 = "t1";
        String value = "12345";
        String key2 = "t2";
        String value2 = "54321";
        redisTemplate.opsForValue().set(key1, value);
        byteRedisTemplate.opsForValue().set(key2, value2.getBytes());
    }

    @RequestMapping("get")
    public void get() {
        Object t1 = redisTemplate.opsForValue().get("t1");
        System.out.println("t1:" + t1.toString());
        Object o = byteRedisTemplate.opsForValue().get("t2");
        System.out.println("t2:" + Arrays.toString((byte[]) o));
    }
}

对象存hash

entityMap.forEach((field, value) -> redisTemplate.opsForHash().put(String.format(REDIS_CONN_KEY, entity.getId()), field, value != null ? String.valueOf(value) : ""));

redis判断连接状态，重连机制

if (!isset($this->redis) || !$this->redis->isConnected()) {
  $this->setRedis();
}
$this->redis->exists($key);

/**
 * 连接redis.
 */
private function setRedis()
{
    if (isset($this->redis) && $this->redis->isConnected()) {
        $this->redis->disconnect();
    }
    $this->redis = new RedisClient($this->container->getParameter('redis_mq')); //重连redis;
}

Redis工具类

/**
 * Redis工具类，提供了一系列操作Redis缓存的方法。
 */

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;

public class RedisUtil {

  /**
   * Redis模板对象，用于执行Redis操作。
   */
  private RedisTemplate<String, Object> redisTemplate;

  /**
   * 设置Redis模板对象。
   *
   * @param redisTemplate Redis模板对象。
   */
  public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
    this.redisTemplate = redisTemplate;
  }

  //=============================common============================

  /**
   * 为给定的键设置缓存失效时间。
   *
   * @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;
    }
  }

  /**
   * 获取给定键的缓存失效时间。
   *
   * @param key 键
   * @return 失效时间（秒），如果为0表示永不过期
   */
  public long getExpire(String key) {
    return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  }

  /**
   * 检查给定键是否存在。
   *
   * @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 值，如果键不存在则返回null
   */
  public Object get(String key) {
    return key == null ? null : redisTemplate.opsForValue().get(key);
  }

  /**
   * 保存数字到Redis中，以字符串形式存储。
   *
   * @param key   Redis中键的名称。
   * @param value 要保存的数字值。
   */
  public void saveNumber(String key, int value) {
    redisTemplate.opsForValue().set(key, String.valueOf(value));
  }

  /**
   * 从Redis中获取保存的数字。
   *
   * @param key Redis中键的名称。
   * @return 如果键存在，则返回对应的数字值；如果键不存在，返回0。
   */
  public int getNumber(String key) {
    int number = 0;
    Object value = get(key);
    if (value != null) {
      number = Integer.parseInt((String) value);
    }
    return number;
  }

  /**
   * 将值存储到缓存中。
   *
   * @param key   键
   * @param value 值
   * @return 存储是否成功
   */
  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 存储是否成功
   */
  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;
    }
  }

  /**
   * 尝试在Redis中设置给定的键值对，如果键不存在。redis的过期机制和分布式锁
   * <p>
   * 此方法尝试为给定的键设置一个值，只有在键当前不存在的情况下才成功。
   *
   * @param key   要设置的键，不能为null。
   * @param value 要设置的值，不能为null。
   * @param time  设置值的过期时间，单位为秒。
   * @return 如果设置成功（或键已存在），则返回true；如果发生异常，则返回false。
   */
  public boolean setIfAbsent(String key, Object value, long time) {
    try {
      // 检查键和值是否为null，如果是，则抛出运行时异常。
      if (key == null || value == null) {
        throw new RuntimeException("key/value不能为null");
      }
      // 如果键不存在，则设置键的值，并指定过期时间。
      return redisTemplate.opsForValue().setIfAbsent(key, value, time, TimeUnit.SECONDS);
    } catch (Exception e) {
      // 捕获任何异常，打印堆栈跟踪，并返回false。
      e.printStackTrace();
      return false;
    }
  }

  /**
   * 对给定键的值进行递增操作。
   *
   * @param key   键
   * @param delta 递增值，必须大于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 delta 递减值，必须大于0
   * @return 减少后的值
   */
  public long decr(String key, long delta) {
    if (delta < 0) {
      throw new RuntimeException("递减因子必须大于0");
    }
    return redisTemplate.opsForValue().increment(key, -delta);
  }

  //================================Map=================================

  /**
   * 从Hash中获取指定字段的值。
   *
   * @param key  键
   * @param item 字段
   * @return 值
   */
  public Object hget(String key, String item) {
    return redisTemplate.opsForHash().get(key, item);
  }

  /**
   * 获取Hash中所有字段和值。
   *
   * @param key 键
   * @return 字段-值的映射
   */
  public Map<Object, Object> hmget(String key) {
    return redisTemplate.opsForHash().entries(key);
  }

  /**
   * 向Hash中设置多个字段和值。
   *
   * @param key 键
   * @param map 字段-值的映射
   * @return 设置是否成功
   */
  public boolean hmset(String key, Map<String, Object> map) {
    try {
      redisTemplate.opsForHash().putAll(key, map);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }

  /**
   * 向Hash中设置多个字段和值，并设置过期时间。
   *
   * @param key  键
   * @param map  字段-值的映射
   * @param time 过期时间（秒）
   * @return 设置是否成功
   */
  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 设置是否成功
   */
  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中添加数据，如果key不存在则创建。
   *
   * @param key   Redis中的键。
   * @param item  Hash中的字段。
   * @param value Hash中字段对应的值。
   * @param time  过期时间，单位为秒。如果大于0，则设置过期时间；否则，不设置过期时间。
   * @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  Redis中的键。
   * @param item 要删除的字段，可以是多个。
   */
  public void hdel(String key, Object... item) {
    redisTemplate.opsForHash().delete(key, item);
  }

  /**
   * 检查hash中是否存在指定字段。
   *
   * @param key  Redis中的键。
   * @param item 要检查的字段。
   * @return 如果字段存在返回true，否则返回false。
   */
  public boolean hHasKey(String key, String item) {
    return redisTemplate.opsForHash().hasKey(key, item);
  }

  /**
   * 为hash中的指定字段增加指定数值。
   *
   * @param key  Redis中的键。
   * @param item Hash中的字段。
   * @param by   要增加的数值。
   * @return 增加后的值。
   */
  public double hincr(String key, String item, double by) {
    return redisTemplate.opsForHash().increment(key, item, by);
  }

  /**
   * 为hash中的指定字段减少指定数值。
   *
   * @param key  Redis中的键。
   * @param item Hash中的字段。
   * @param by   要减少的数值。
   * @return 减少后的值。
   */
  public double hdecr(String key, String item, double by) {
    return redisTemplate.opsForHash().increment(key, item, -by);
  }

  //============================set=============================

  /**
   * 获取set中的所有成员。
   *
   * @param key Redis中的键。
   * @return set中的所有成员。
   */
  public Set<Object> sGet(String key) {
    try {
      return redisTemplate.opsForSet().members(key);
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }

  /**
   * 检查set中是否包含指定成员。
   *
   * @param key   Redis中的键。
   * @param value 要检查的成员。
   * @return 如果set包含指定成员返回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    Redis中的键。
   * @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    Redis中的键。
   * @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 Set集合的键。
   * @return Set集合的大小。
   */
  public long sGetSetSize(String key) {
    try {
      return redisTemplate.opsForSet().size(key);
    } catch (Exception e) {
      e.printStackTrace();
      return 0;
    }
  }

  /**
   * 从Set集合中移除指定的值。
   *
   * @param key    Set集合的键。
   * @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   List集合的键。
   * @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 List集合的键。
   * @return List集合的大小。
   */
  public long lGetListSize(String key) {
    try {
      return redisTemplate.opsForList().size(key);
    } catch (Exception e) {
      e.printStackTrace();
      return 0;
    }
  }

  /**
   * 获取List集合中指定索引的元素。
   *
   * @param key   List集合的键。
   * @param index 索引，index>=0时，0表示列表第一个元素，依次类推；index<0时，-1表示列表最后一个元素，依次类推。
   * @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   List集合的键。
   * @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   List集合的键。
   * @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;
    }
  }

  /**
   * 将给定的列表值添加到指定键的列表末尾。如果列表不存在，会创建一个空列表。
   *
   * @param key   键
   * @param value 列表值
   * @return 如果操作成功返回true，否则返回false。
   */
  public boolean lSet(String key, List<Object> value) {
    try {
      redisTemplate.opsForList().rightPushAll(key, value);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }

  /**
   * 将给定的列表值添加到指定键的列表末尾，并设置过期时间。如果列表不存在，会创建一个空列表。
   *
   * @param key   键
   * @param value 列表值
   * @param time  过期时间，单位为秒
   * @return 如果操作成功返回true，否则返回false。
   */
  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;
    }
  }

  /**
   * 更新列表中指定索引位置的元素值。
   *
   * @param key   键
   * @param index 索引位置
   * @param value 新的元素值
   * @return 如果操作成功返回true，否则返回false。
   */
  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;
    }
  }

  /**
   * 从列表中移除指定数量与给定值相等的元素。
   *
   * @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;
    }
  }
  /**
   * 添加一个元素, zset与set最大的区别就是每个元素都有一个score，因此有个排序的辅助功能;  zadd
   *
   * @param key
   * @param value
   * @param score
   */
  public boolean zsetAdd(String key, Object value, Double score) {
    try {
      redisTemplate.opsForZSet().add(key, value, score);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }

  /**
   * 删除元素 zrem
   *
   * @param key
   * @param value
   */
  public void remove(String key, String value) {
    redisTemplate.opsForZSet().remove(key, value);
  }

  /**
   * 删除zSet 中过期元素
   *
   * @param key
   * @param v1
   * @param v2
   */
  public void removeRangeByScore(String key, Double v1, Double v2) {
    redisTemplate.opsForZSet().removeRangeByScore(key, v1, v2);
  }

  /**
   * @param key
   * @param value
   * @param score
   */
  public Double incrScore(String key, String value, double score) {
    return redisTemplate.opsForZSet().incrementScore(key, value, score);
  }

  /**
   * 查询value对应的score   zscore
   *
   * @param key
   * @param value
   * @return
   */
  public Double score(String key, String value) {
    return redisTemplate.opsForZSet().score(key, value);
  }

  /**
   * 判断value在zset中的排名  zrank
   *
   * @param key
   * @param value
   * @return
   */
  public Long rank(String key, String value) {
    return redisTemplate.opsForZSet().rank(key, value);
  }

  /**
   * 返回集合的长度
   *
   * @param key
   * @return
   */
  public Long size(String key) {
    return redisTemplate.opsForZSet().zCard(key);
  }

  /**
   * 查询集合中指定顺序的值， 0 -1 表示获取全部的集合内容  zrange
   * <p>
   * 返回有序的集合，score小的在前面
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public Set<Object> range(String key, int start, int end) {
    return redisTemplate.opsForZSet().range(key, start, end);
  }

  /**
   * 获取字符串类型
   *
   * @param key
   * @return
   */
  public String getString(String key) {
    Object value = redisTemplate.opsForValue().get(key);
    if (null != value) {
      return key == null ? null : String.valueOf(value);
    } else {
      return null;
    }
  }
}

@航空母舰
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RedisKey值出现\xAC\xED\x00\x05t\x00\x19原因及解决方案。
weixin_45799289的博客
03-21 3933
解决的办法就是手动定义序列化的方法，spring-data-redis中还提供了一个序列化的类专门针对string类型的序列化org.springframework.data.redis.serializer.StringRedisSerializer这个类, 我们在带有@Configuration注解的类中覆盖自动配置的RedisTemplate，如下：
【学习Redis】使用RedisTemplate设置值后出现\xac\xed\x00\x05t\x00\x02的问题解决方法
AlanLee97的博客
08-11 6477
最近在学习Redis，学到加减运算部分，遇到一个问题，使用RedisTemplate设置值后出现\xac\xed\x00\x05t\x00\x02的问题 控制台报错： org.springframework.dao.InvalidDataAccessApiUsageException: ERR value is not an integer or out of range; nested e...
RedisTemplate写入Redis数据出现乱码补充
hunger_wang的博客
10-21 363
上篇RedisTemplate写入Redis数据出现无意义乱码前缀\xac\xed\x00\x05，我在排查问题及给同事分享过程中，获得了一些收获，这里补充记录下。 关于中文 Java里中文采用UTF8编码，占3个字节。如粤，UTF8编码为\xE7\xB2\xA4。所以按上篇文章计算数据长度时，1个汉字占3个字节。 关于乱码显示 乱码显示并不影响用实际数据去直接查询。 如上一篇样例\xac\xed\x00\x05t\x00-abcd:abc:xxxxxx:passport:associated:key:29
Redis中键值出现 \xAC\xED\x00\x05t\x00\x11的原因和解决方法
m0_49692893的博客
11-01 5415
Redis中键值出现 \xAC\xED\x00\x05t\x00\x11的原因和解决方法。
解决Redis的键值前出现类似\xAC\xED\x00\x05t\x00*这样的字符序列
最新发布
云泽野の编程日记
05-01 969
StringRedisTemplate 虽然继承自 RedisTemplate，但在实际应用中，它通常被限制为处理 String 类型的 key 和 value，因此在只需要处理字符串数据时更为方便和高效。RedisTemplate 是一个泛型类，允许你操作任何类型（包括但不限于字符串）的键值对，因此它更加灵活，能够适应更复杂的数据存储需求。如果你的应用主要处理字符串类型的数据，使用 StringRedisTemplate 可能会更合适，因为它提供了更好的性能和易读性。虽说不影响使用,但是听影响观感的。
Spring整合redis的key时出现\xac\xed\x00\x05t\前缀问题
张晨光老师的播客
11-13 2052
是转化后的ASCII码值对应字符，对应16进制是0x2d（10进制是45，样例abcd🔤xxxxxx:passport:associated🔑29708的字符数就是45，1个字符1个字节，字节数也是45）。由上面的描述可知，乱码前缀中\xac\xed\x00\x05是固定的，t在String类型情况是不变的，后面2个位（样例\x00-）是数据的字节数，是随key动态变化的。key长度65545时，乱码为\xac\xed\x00\x05|\x00\x00\x00\x00\x00\x01\x00\x09。
Redis键值:\xac\xed\x00\x05t\x00的解决
我的博客
03-09 1010
默认的JdkSerializationRedisSerializerJDKRedis序列化器的序列化方式，使用了JDK自带的ObjectOutPutStream将我们的String对象序列化成了byte[]。springboot使用redisTemplate存放键值对时，发现存放的key和value多了\xac\xed\x00\x05t\x00&的非预期的前缀。：redisTemplate向redis存放使用java对象序列化的值，序列化方式和string的一般方式不同。
springboot保存redis键值对出现乱码\xac\xed\x00\x05t\x00
weixin_44464046的博客
05-30 843
通过上述方式保存key就会生成带有 \xac\xed\x00\x05t\x00的key，只要把redisTemplate类型改为StringRedisTemplate就行了。
redis-template存放key时出现 \xac\xed\x00\x05t\x00
松松的博客
12-03 300
spring 中使用reidstemplat的时候，所有的key前面都出现了一段诡异的\xac\xed\x00\x05t\x00 问题的产生是 spring-data-redis的RedisTemplate<K, V>模板类在操作redis时默认使用JdkSerializationRedisSerializer来进行序列化，如下 private boolean enableDefau...
redis 解决key的乱码问题,并清理详解
01-19
1) “\xac\xed\x00\x05t\x00!report:flag:phone_156464” 2) “\xac\xed\x00\x05t\x00!report:flag:phone_198946” 3) “\xac\xed\x00\x05t\x00!report:flag:phone_183302” 解决key乱码 private RedisTemplate ...
dos命令dos命令dos命令
03-19
dos命令dos命令dos命令dos命令dos命令dos命令dos命令dos命令dos命令dos命令dos命令dos命令
学习python处理python编码问题
12-24
概括、从python1.6开始就可以处理unicode字符了。 一、几种常见的编码格式。 1.1、ascii，用1个字节表示。 1.2、UTF-8,用1个至三个字节表示，表示ascii码时只占用1个字节，ascii编码是UTF-8的子集。...
电源技术中的Aw，XAc计算式的推导
11-16
式（6－100）说明，磁心窗口面积Aw和磁心截面积Ac的乘积Aw·Ac与可以储能的值LI2成正比，与工作磁通密度BW、电流密度j、...在合理的Bw、J、L、X，选值条件下，电流I会产生合适的温升。因此可以利用Aw·Ac来设计电感器。
解决 redis 的 key 出现的 \xac\xed\x00\x05t\x00 乱码问题
热门推荐
阿鹏的博客
08-19 2万+
今天在使用redis进行token的存取的时候，发现了一个严重的问题，那便是根据键获取值的时候一直拿不到，其实已经set进去了。 然后使用redis客户端，遍历所有的键的时候，发现键中有类似\xac\xed\x00\x05t\x00 的乱码，如下图 原因分析： spring-data-redis 的 RedisTemplate<K, V>模板类 在操作redis时默认使用JdkSerializationRedisSerializer 来进行序列化。spring操作redis是在je.
解决Spring Boot 使用RedisTemplate 存储键值出现乱码 xacxedx00x05tx00
Matea's Record
11-21 812
需要序列化 private RedisTemplate redisTemplate; @Autowired(required = false) public void setRedisTemplate(RedisTemplate redisTemplate) { RedisSerializer stringSerializer = new StringRedisSerializer();...
redis键值出现 \xac\xed\x00\x05t\x00&的解决方法
qq_16159433的博客
11-23 1万+
笔者在使用redis存放键值对时，发现存放的key和value多了\xac\xed\x00\x05t\x00&的前缀，笔者存放的是字符串，结果如下图所示，出现非预期的前缀。 出现该问题的原因是， redis template向redis存放使用java对象序列化的值，序列化方式和string的一般方式不同。 明明指定的另一个引文字符串作为key，但是实际存储后却多出来一串奇异字符串，这让笔者好奇心顿时升起来了，决定debug调试一下 从set()方法进入一路对execute()的重载方法向下跟
RedisTemplate写入Redis数据出现无意义乱码前缀\xac\xed\x00\x05
hunger_wang的博客
07-13 7764
背景 项目使用Spring的RedisTemplate进行Redis数据存取操作，实际应用中发现Redis中key和value会出现“无意义”乱码前缀\xac\xed\x00\x05t\x00-（样例\xac\xed\x00\x05t\x00-abcd:abc:xxxxxx:passport:associated:key:29708）。 这个乱码前缀是怎么产生的呢？有什么含义？是不是固定的？带着这三个问题，我们一探究竟。 疑问探究 怎么产生的 org.springframework.data.redis.c
redis键值出现 \xac\xed\x00\x05t\x00&的解决方法！！
achaojava的博客
02-02 1528
redis键值出现 \xac\xed\x00\x05t\x00&的解决方法
\xac\xed\x00\x05t\x00 转译
03-26
您提到的"\xac\xed\x00\x05t\x00"看起来像是一个十六进制数。十六进制数是一种常用的数据表示方法，它由两个字符组成，分别代表数字的16进制表示。在这个情况下，"\xac\xed\x00\x05t\x00"可能是一个特定的字节序列或数据块的十六进制表示。 要将这个十六进制数转译（或解码）为可读的文本或二进制数据，您需要知道这个十六进制数所代表的具体含义。如果您能提供更多的上下文信息，例如这个十六进制数是在哪种编程语言中使用的，或者它是在哪种特定的应用或协议中出现的，我可能能够提供更具体的帮助。 请提供更多关于这个问题的详细信息，我将很乐意为您提供帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值