redis序列化二

电玩女神 2022-12-22 11:23 126阅读 0赞

1，   LZ4SerializerNew implements RedisSerializer<Object>  
       LZ4SerializerNew实现RedisSerializer是为了覆盖redis序列化接口的序列化，反序列化方法，  
       在模板设置序列化方式后，redis可以自动选用自定义的序列化方法

package com.mcd.cn.rdc.pcm.product.manager.util;
    
    import net.jpountz.lz4.LZ4BlockInputStream;
    import net.jpountz.lz4.LZ4BlockOutputStream;
    import net.jpountz.lz4.LZ4Compressor;
    import net.jpountz.lz4.LZ4Factory;
    import net.jpountz.lz4.LZ4FastDecompressor;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.SerializationException;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    
    /**
     * LZ4 压缩 Serializer
     *
     * @author shenyanchao
     */
    public class LZ4SerializerNew implements RedisSerializer<Object> {
    
        private static final int BUFFER_SIZE = 4096;
    
        private LZ4FastDecompressor decompresser;
        private LZ4Compressor compressor;
    
        public LZ4SerializerNew() {
            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];
            }
            try (
                    ByteArrayOutputStream byteOutput = new ByteArrayOutputStream();
                    LZ4BlockOutputStream compressedOutput = new LZ4BlockOutputStream(byteOutput, BUFFER_SIZE, compressor)
            ) {
                byte[] bytes = SerializableUtil.serializable(graph);
                compressedOutput.write(bytes);
                compressedOutput.finish();
                byte[] compressBytes = byteOutput.toByteArray();
                return compressBytes;
            } catch (Exception e) {
                throw new SerializationException("LZ4 Serialization Error", e);
            }
        }
    
        @Override
        public Object deserialize(byte[] bytes) throws SerializationException {
    
            if (bytes == null || bytes.length == 0) {
                return null;
            }
    
            try (
                    ByteArrayOutputStream baos = new ByteArrayOutputStream(BUFFER_SIZE);
                    LZ4BlockInputStream 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 = SerializableUtil.unserializable(baos.toByteArray());
                return result;
            } catch (Exception e) {
                throw new SerializationException("LZ4 deserizelie error", e);
            }
        }
    }

2，当然jredis没有显示设置模板的序列化方式的时候就需要手动调用自定义序列化，反序列化方法，手动存字节码

package com.mcd.cn.rdc.pcm.product.manager.util;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    
    import java.util.Map;
    import java.util.Set;
    
    /**
     * JedisUtil(推荐存Byte数组，存Json字符串效率更慢)
     * @author dolyw.com
     * @date 2018/9/4 15:45
     */
    @Component
    public class JedisUtil {
    
        /**
         * 静态注入JedisPool连接池
         * 本来是正常注入JedisUtil，可以在Controller和Service层使用，但是重写Shiro的CustomCache无法注入JedisUtil
         * 现在改为静态注入JedisPool连接池，JedisUtil直接调用静态方法即可
         * https://blog.csdn.net/W_Z_W_888/article/details/79979103
         */
        private static JedisPool jedisPool;
    
        @Autowired
        public void setJedisPool(JedisPool jedisPool) {
            JedisUtil.jedisPool = jedisPool;
        }
    
        /**
         * 获取Jedis实例
         * @param 
         * @return redis.clients.jedis.Jedis
         * @author dolyw.com
         * @date 2018/9/4 15:47
         */
        public static synchronized Jedis getJedis() {
            try {
                if (jedisPool != null) {
                    return jedisPool.getResource();
                } else {
                    return null;
                }
            } catch (Exception e) {
                throw new CustomException("获取Jedis资源异常:" + e.getMessage());
            }
        }
    
        /**
         * 释放Jedis资源
         * @param
         * @return void
         * @author dolyw.com
         * @date 2018/9/5 9:16
         */
        public static void closePool() {
            try {
                jedisPool.close();
            } catch (Exception e) {
                throw new CustomException("释放Jedis资源异常:" + e.getMessage());
            }
        }
    
        /**
         * 获取redis键值-object
         * @param key
         * @return java.lang.Object
         * @author dolyw.com
         * @date 2018/9/4 15:47
         */
        public static Object getObject(String key) {
            try (Jedis jedis = jedisPool.getResource()) {
                byte[] bytes = jedis.get(key.getBytes());
                if (StringUtil.isNotNull(bytes)) {
                    return SerializableUtil.unserializable(bytes);
                }
            } catch (Exception e) {
                throw new CustomException("获取Redis键值getObject方法异常:key=" + key + " cause=" + e.getMessage());
            }
            return null;
        }
    
        /**
         * 设置redis键值-object
         * @param key
        * @param value
         * @return java.lang.String
         * @author dolyw.com
         * @date 2018/9/4 15:49
         */
        public static String setObject(String key, Object value) {
            try (Jedis jedis = jedisPool.getResource()) {
                return jedis.set(key.getBytes(), SerializableUtil.serializable(value));
            } catch (Exception e) {
                throw new CustomException("设置Redis键值setObject方法异常:key=" + key + " value=" + value + " cause=" + e.getMessage());
            }
        }
    
        /**
         * 设置redis键值-object-expiretime
         * @param key
        * @param value
        * @param expiretime
         * @return java.lang.String
         * @author dolyw.com
         * @date 2018/9/4 15:50
         */
        public static String setObject(String key, Object value, int expiretime) {
            String result;
            try (Jedis jedis = jedisPool.getResource()) {
                result = jedis.set(key.getBytes(), SerializableUtil.serializable(value));
                if (Constant.OK.equals(result)) {
                    jedis.expire(key.getBytes(), expiretime);
                }
                return result;
            } catch (Exception e) {
                throw new CustomException("设置Redis键值setObject方法异常:key=" + key + " value=" + value + " cause=" + e.getMessage());
            }
        }
    
        /**
         * 获取redis键值-Json
         * @param key
         * @return java.lang.Object
         * @author dolyw.com
         * @date 2018/9/4 15:47
         */
        public static String getJson(String key) {
            try (Jedis jedis = jedisPool.getResource()) {
                return jedis.get(key);
            } catch (Exception e) {
                throw new CustomException("获取Redis键值getJson方法异常:key=" + key + " cause=" + e.getMessage());
            }
        }
    
        /**
         * 设置redis键值-Json
         * @param key
         * @param value
         * @return java.lang.String
         * @author Wang926454
         * @date 2018/9/4 15:49
         */
        public static String setJson(String key, String value) {
            try (Jedis jedis = jedisPool.getResource()) {
                return jedis.set(key, value);
            } catch (Exception e) {
                throw new CustomException("设置Redis键值setJson方法异常:key=" + key + " value=" + value + " cause=" + e.getMessage());
            }
        }
    
        /**
         * 设置redis键值-Json-expiretime
         * @param key
         * @param value
         * @param expiretime
         * @return java.lang.String
         * @author Wang926454
         * @date 2018/9/4 15:50
         */
        public static String setJson(String key, String value, int expiretime) {
            String result;
            try (Jedis jedis = jedisPool.getResource()) {
                result = jedis.set(key, value);
                if (Constant.OK.equals(result)) {
                    jedis.expire(key, expiretime);
                }
                return result;
            } catch (Exception e) {
                throw new CustomException("设置Redis键值setJson方法异常:key=" + key + " value=" + value + " cause=" + e.getMessage());
            }
        }
    
        /**
         * 删除key
         * @param key
         * @return java.lang.Long
         * @author Wang926454
         * @date 2018/9/4 15:50
         */
        public static Long delKey(String key) {
            try (Jedis jedis = jedisPool.getResource()) {
                return jedis.del(key.getBytes());
            } catch (Exception e) {
                throw new CustomException("删除Redis的键delKey方法异常:key=" + key + " cause=" + e.getMessage());
            }
        }
    
        /**
         * key是否存在
         * @param key
         * @return java.lang.Boolean
         * @author Wang926454
         * @date 2018/9/4 15:51
         */
        public static Boolean exists(String key) {
            try (Jedis jedis = jedisPool.getResource()) {
                return jedis.exists(key.getBytes());
            } catch (Exception e) {
                throw new CustomException("查询Redis的键是否存在exists方法异常:key=" + key + " cause=" + e.getMessage());
            }
        }
    
        /**
         * 模糊查询获取key集合(keys的速度非常快，但在一个大的数据库中使用它仍然可能造成性能问题，生产不推荐使用)
         * @param key
         * @return java.util.Set<java.lang.String>
         * @author Wang926454
         * @date 2018/9/6 9:43
         */
        public static Set<String> keysS(String key) {
            try (Jedis jedis = jedisPool.getResource()) {
                return jedis.keys(key);
            } catch (Exception e) {
                throw new CustomException("模糊查询Redis的键集合keysS方法异常:key=" + key + " cause=" + e.getMessage());
            }
        }
    
        /**
         * 模糊查询获取key集合(keys的速度非常快，但在一个大的数据库中使用它仍然可能造成性能问题，生产不推荐使用)
         * @param key
         * @return java.util.Set<java.lang.String>
         * @author Wang926454
         * @date 2018/9/6 9:43
         */
        public static Set<byte[]> keysB(String key) {
            try (Jedis jedis = jedisPool.getResource()) {
                return jedis.keys(key.getBytes());
            } catch (Exception e) {
                throw new CustomException("模糊查询Redis的键集合keysB方法异常:key=" + key + " cause=" + e.getMessage());
            }
        }
    
        /**
         * 获取过期剩余时间
         * @param key
         * @return java.lang.String
         * @author Wang926454
         * @date 2018/9/11 16:26
         */
        public static Long ttl(String key) {
            Long result = -2L;
            try (Jedis jedis = jedisPool.getResource()) {
                result = jedis.ttl(key);
                return result;
            } catch (Exception e) {
                throw new CustomException("获取Redis键过期剩余时间ttl方法异常:key=" + key + " cause=" + e.getMessage());
            }
        }
    
        public static void cacheDimessionStatus(String key, String status) {
            try (Jedis jedis = jedisPool.getResource()) {
                jedis.set(key, status);
    //            jedis.close();
            } catch (Exception e) {
                throw new CustomException("设置Redis键值setJson方法异常:key=" + key + " value=" + status + " cause=" + e.getMessage());
            }
        }
        public static String getDimessionStatus(String key) {
            try (Jedis jedis = jedisPool.getResource()) {
                return jedis.get(key);
    //            jedis.close();
            } catch (Exception e) {
                throw new CustomException("设置Redis键值setJson方法异常:key=" + key  + " cause=" + e.getMessage());
            }
        }
    //    public static void cacheMenuStoreParam(String key, Map<String, Object> map) {
    //        hmset(key, map);
    //        redisTemplateBinary.expire(key, 24, TimeUnit.HOURS);
    //        redisTemplateBinary.getConnectionFactory().getConnection().close();
    //    }
        /**
         * 逐对依次设置参数中给出的Field/Value对。如果其中某个Field已经存在，则用新值覆盖原有值。
         * 如果Key不存在，则创建新Key，同时设定参数中的Field/Value。
         * @Author:      yangxinxin
         * @UpdateUser:
         * @Version:     0.0.1
         * @param key
         * @param hash
         * @return
         * @throws
         */
        public void hmset(String key, Map<String, Object> hash) {
    
            if(null==key||null==hash){
                return;
            }
            try (Jedis jedis = jedisPool.getResource()) {
    //            jedisPool.getResource().
    //            jedis.close();
            } catch (Exception e) {
                throw new CustomException("设置Redis键值setJson方法异常:key=" + key + " value=" + hash + " cause=" + e.getMessage());
            }
    //        redisTemplateBinary.opsForHash().putAll(key,hash);
        }
    
        public static String setObjectZip(String key, Object value) {
            try (Jedis jedis = jedisPool.getResource()) {
                LZ4SerializerNew lz=   new LZ4SerializerNew();
                return jedis.set(key.getBytes(), lz.serialize(value));
            } catch (Exception e) {
                throw new CustomException("设置Redis键值setObject方法异常:key=" + key + " value=" + value + " cause=" + e.getMessage());
            }
        }
        public static Object getObjectZip(String key) {
            try (Jedis jedis = jedisPool.getResource()) {
                byte[] bytes = jedis.get(key.getBytes());
                LZ4SerializerNew lz=   new LZ4SerializerNew();
                if (StringUtil.isNotNull(bytes)) {
                    return lz.deserialize(bytes);
                }
            } catch (Exception e) {
                throw new CustomException("获取Redis键值getObject方法异常:key=" + key + " cause=" + e.getMessage());
            }
            return null;
        }
    }