redis的序列化

- 日理万妓 2022-11-22 00:18 138阅读 0赞

底层的框架设置了统一的序列化方式，比如jackson，如果还用此模板，所有的都会用此方式序列化  
                    ，如果想用字节码存储的话，存进前字节码就会被再次jackson序列化，此时字节码变了不可由原工具  
                    此时需要另外配置一个redis模板，指定想要的序列化工具

压缩存储：先普通的字节码上再压缩

字节码存储压缩：

package com.mcd.cn.rdc.pcm.product.manager.config;
    
    import com.mcd.cn.rdc.pcm.product.business.util.Lz4Serializer;
    import com.mcd.cn.rdc.pcm.product.business.util.MyStringRedisSerializer;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    /**
     * @program: product-online-service
     * @description: 自定义redis
     * @author: yuhui
     * @create: 2020-08-27 19:14
     * @version: 1.0.0
     **/
    @Configuration
    public class MyRedisConfig {
    
        @Bean
        public RedisTemplate<String,Object> redisTemplateBinary(RedisConnectionFactory redisConnectionFactory){
            RedisTemplate<String,Object>  redisTemplateBinary = new RedisTemplate<>();
            redisTemplateBinary.setConnectionFactory(redisConnectionFactory);
            redisTemplateBinary.setKeySerializer(new StringRedisSerializer());
            redisTemplateBinary.setHashKeySerializer(new StringRedisSerializer());
            redisTemplateBinary.setValueSerializer(new Lz4Serializer(new MyStringRedisSerializer()));
            redisTemplateBinary.setHashKeySerializer(new Lz4Serializer(new MyStringRedisSerializer()));
    //        redisTemplate.setValueSerializer(new MyStringRedisSerializer());
    //        redisTemplate.setHashKeySerializer(new MyStringRedisSerializer());
            return redisTemplateBinary;
         }
    }

package com.mcd.cn.rdc.pcm.product.business.util;
    
    import net.jpountz.lz4.*;
    import org.apache.commons.io.IOUtils;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.SerializationException;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    
    /**
     * @program: product-buiness-service
     * @description: 压缩
     * @author: yuhui
     * @create: 2020-9-22 16:35
     * @version: 1.0.0
     **/
    public class Lz4Serializer implements RedisSerializer<Object> {
    
        private static final int BUFFER_SIZE = 4096;
    
        private RedisSerializer<Object> innerSerializer;
        private LZ4FastDecompressor decompresser;
        private LZ4Compressor compressor;
    
        public Lz4Serializer(RedisSerializer<Object> innerSerializer) {
            this.innerSerializer = innerSerializer;
            LZ4Factory factory = LZ4Factory.fastestInstance();
            this.compressor = factory.fastCompressor();
            this.decompresser = factory.fastDecompressor();
        }
    
        @Override
        public byte[] serialize(Object graph) throws SerializationException {
            if (graph == null) {
                return new byte[0];
            }
            ByteArrayOutputStream byteOutput = null;
            LZ4BlockOutputStream compressedOutput = null;
            try {
                byte[] bytes = innerSerializer.serialize(graph);
                byteOutput = new ByteArrayOutputStream();
                compressedOutput = new LZ4BlockOutputStream(byteOutput, BUFFER_SIZE, compressor);
                compressedOutput.write(bytes);
                compressedOutput.finish();
                byte[] compressBytes = byteOutput.toByteArray();
                return compressBytes;
            } catch (Exception e) {
                throw new SerializationException("LZ4 Serialization Error", e);
            } finally {
                IOUtils.closeQuietly(compressedOutput);
                IOUtils.closeQuietly(byteOutput);
            }
        }
    
        @Override
        public Object deserialize(byte[] bytes) throws SerializationException {
    
            if (bytes == null || bytes.length == 0) {
                return null;
            }
    
            ByteArrayOutputStream baos = null;
            LZ4BlockInputStream lzis = null;
            try {
                baos = new ByteArrayOutputStream(BUFFER_SIZE);
                lzis = new LZ4BlockInputStream(new ByteArrayInputStream(bytes), decompresser);
                int count;
                byte[] buffer = new byte[BUFFER_SIZE];
                while ((count = lzis.read(buffer)) != -1) {
                    baos.write(buffer, 0, count);
                }
                Object result = innerSerializer.deserialize(baos.toByteArray());
                return result;
            } catch (Exception e) {
                throw new SerializationException("LZ4 deserizelie error", e);
            } finally {
                IOUtils.closeQuietly(lzis);
                IOUtils.closeQuietly(baos);
            }
        }
    }

package com.mcd.cn.rdc.pcm.product.business.util;
    import com.alibaba.fastjson.JSON;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.util.Assert;
    
    import java.nio.charset.Charset;
    import java.nio.charset.StandardCharsets;
    
    /** @Author yangxinxin
     * @Description //TODO
     * @Date 11:52 2020/2/21
     * @Param
     * @return
     **/
    public class MyStringRedisSerializer implements RedisSerializer<Object> {
        private final Charset charset;
    
        public MyStringRedisSerializer() {
            this(StandardCharsets.UTF_8);
        }
    
        public MyStringRedisSerializer(Charset charset) {
            Assert.notNull(charset, "Charset must not be null!");
            this.charset = charset;
        }
    
        @Override
        public String deserialize(byte[] bytes) {
            return (bytes == null ? null : new String(bytes, charset));
        }
    
        @Override
        public byte[] serialize(Object object) {
            if (object == null) {
                return new byte[0];
            }
            if(object instanceof String){
                return object.toString().getBytes(charset);
            }else {
                String string = JSON.toJSONString(object);
                return string.getBytes(charset);
            }
        }
    }