Spring Data操作Redis时，发现key值出现 \xac\xed\x00\x05t\x00\tb

最近在研究redis，以及spring data对redis的支持发现了一个奇怪的现象

先说现象吧，通过redisTemplate下的opsForHash方法存储hash类型的值，操作成功以后，去redis控制台显示keys * 的时候，发现一个奇怪的现象，插入的hash类型的key前面会有一堆的\xac\xed\x00\x05t\x00\tb 这种东西，见图1

看见了吗？就是第二行那一串自己冒出来的东西，分析spring-data的org.springframework.data.redis.core.RedisTemplate源代码以后发现：

 private RedisSerializer<?> defaultSerializer = new JdkSerializationRedisSerializer();
 
    private RedisSerializer keySerializer = null;
    private RedisSerializer valueSerializer = null;
    private RedisSerializer hashKeySerializer = null;
    private RedisSerializer hashValueSerializer = null;
    private RedisSerializer<String> stringSerializer = new StringRedisSerializer();

发现了一个：

private RedisSerializer<?> defaultSerializer = new JdkSerializationRedisSerializer();
因为spring操作redis是在jedis客户端基础上进行的，而jedis客户端与redis交互的时候协议中定义是用byte类型交互，jedis中提供了string类型转为byte[]类型，但是看到spring-data-redis中RedisTemplate<K, V>在操作的时候k，v是泛型的，所以RedisTemplate中有了上面那段代码，在没有特殊定义的情况下，spring默认采用defaultSerializer = new JdkSerializationRedisSerializer();来对key，value进行序列化操作，在经过查看JdkSerializationRedisSerializer中对序列化的一系列操作，发现如下代码：

private Converter<Object, byte[]> serializer = new SerializingConverter();
    public byte[] serialize(Object object) {
        if (object == null) {
            return SerializationUtils.EMPTY_ARRAY;
        }
        try {
            return serializer.convert(object);
        } catch (Exception ex) {
            throw new SerializationException("Cannot serialize", ex);
        }
    }

序列化支持的是Object对象，调用了SerializingConverter类下的convert方法转换对象，转换对象的方法是：

 private final Serializer<Object> serializer;
    /**
     * Serializes the source object and returns the byte array result.
     */
    public byte[] convert(Object source) {
        ByteArrayOutputStream byteStream = new ByteArrayOutputStream(128);
        try  {
            this.serializer.serialize(source, byteStream);
            return byteStream.toByteArray();
        }
        catch (Throwable ex) {
            throw new SerializationFailedException("Failed to serialize object using " +
                    this.serializer.getClass().getSimpleName(), ex);
        }
    }

原因其实就出现在这里，解决的办法就是手动定义序列化的方法，spring-data-redis中还提供了一个序列化的类专门针对string类型的序列化org.springframework.data.redis.serializer.StringRedisSerializer这个类，可以在xml里面指定：

 <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
        p:connection-factory-ref="jedisConnectionFactory">
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
    </bean>

其中我将redis中基础类型的key，value和hash类型的key，value都指定为StringRedisSerializer类来进行序列化，然后发现又报错了，找了一会发现我的代码中：

public void setBank(final Bank bank) {
        // TODO setBank
        final String key = String.format("bank:%s", bank.getId());
        final Map<String, Object> properties = new HashMap<String, Object>();
        
        properties.put("id", bank.getId());
        properties.put("name", bank.getBank_name());
        
        redisTemplate.opsForHash().putAll(key, properties);
    }

bank.getId是Integer类型的，因为Hashmap中的key和value也会进行序列化操作，而StringRedisSerializer中的serialize方法只接收String类型的值，如下：

   public byte[] serialize(String string) {
        return (string == null ? null : string.getBytes(charset));
    }

所以这里的类型转换报错了，二话不说直接bank.getId().toString()，执行成功，然后进入redis控制台打开查看发现那堆恶心巴拉的\xac\xed\x00\x05t\x00\tb没有了，大功告成了

         

（红色部分）

其实redis在使用中，必须要提前考虑的就是内存的占用问题（博客中另外一篇文章很经典，阐述了一个外国人做的测试，同样的存储可以节约几十G的内存【Redis 内存优化】节约内存：Instagram的Redis实践），在设计的时候使用hash可以节约很多的内存，而存储的时候如果每条数据就放一堆\xac\xed\x00\x05t\x00\tb这个东西，肯定是无法直视的

原文：https://blog.csdn.net/yunhaibin/article/details/9001198 
 

这里的序列化方法也可以自己定义，参考https://www.cnblogs.com/cuglkb/p/6895423.html

定制我们的序列化工具

为了不实现序列化接口，并且缓存到redis中不是难看的字节数据，我定制了自己的序列化工具。

序列化类需要实现 RedisSerializer<Object> 接口，并注册到Spring中。

原理很简单，序列化的时候将对象转换为JSONObject，然后将JSONObject转换为String，最后转化为byte数组。

反序列化的时候，则是将byte数组转化为JSONObject，RedisTemplate从redis中get的对象就是JSONObject类型。

下面是我的代码。

package com.zkxl.fep.redis;

import java.nio.charset.Charset;

import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.util.Assert;

import net.sf.json.JSONObject;


public class SerializeUtil implements RedisSerializer<Object>{

    static final byte[] EMPTY_ARRAY = new byte[0];
    private final Charset charset;
    
    public SerializeUtil() {
        // TODO Auto-generated constructor stub
        this(Charset.forName("UTF8"));
    }
    
    public SerializeUtil(Charset charset) {
        // TODO Auto-generated constructor stub
        Assert.notNull(charset);
        this.charset = charset;
    }

    @Override
    public byte[] serialize(Object object){  //序列化方法
        // TODO Auto-generated method stub
        try {
            JSONObject jsonObject = JSONObject.fromObject(object);
            String jsonString = jsonObject.toString();
            return (jsonString == null ? EMPTY_ARRAY : jsonString.getBytes(charset));
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        return null;
        
    }

    @Override
    public Object deserialize(byte[] bytes) throws SerializationException { //反序列化
        // TODO Auto-generated method stub
        String objectStr = null;
        Object object = null;
        if (bytes == null) {
            return object;
        }
        try {
            objectStr = new String(bytes,charset); //byte数组转换为String
            JSONObject jsonObject = JSONObject.fromObject(objectStr); //String转化为JSONObject
            object = jsonObject;  //返回的是JSONObject类型  取数据时候需要再次转换一下
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        return object;
    }
        
}

最后如果要在Spring中使用这个序列化方法我们还需要咋redis的配置文件中注册一下。

<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="connectionFactory" />
<!--         键序列化方式 -->
        <property name="keySerializer">
            <bean
                class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
<!--         值序列化方式 -->
        <property name="valueSerializer">
<!--             <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" /> -->
<!--             <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" /> -->
            <bean class="com.zkxl.fep.redis.SerializeUtil"/>
        </property>
    </bean>

大功告成！这样就自定义序列化方式了。