Redis 工具类

m0_37957698

已于 2023-03-03 18:04:18 修改

阅读量196

点赞数

文章标签： redis java

于 2022-09-27 16:10:49 首次发布

本文链接：https://blog.csdn.net/m0_37957698/article/details/127072937

版权

分享一个好用的Redis 工具类

Rredis 工具类

//package 


import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

import javax.annotation.Nonnull;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * Redis工具类
 * 缓存时间 -1表示不过期
 * @author Wang
 * @date 2022/9/22 14:50
 */
@Component
@Slf4j
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 缓存时间 60S
     */
    public final static int CACHE_TIME = 60;
    /**
     * 缓存时间 1小时
     */
    public final static int CACHE_HOUR = 60 * 60;
    /**
     * 默认缓存时间 1天
     */
    public final static int CACHE_DAY = 60 * 60 * 24;
    /**
     * 缓存时间 1星期
     */
    public final static int CACHE_WEEK = 60 * 60 * 24 * 7;
    /**
     * 缓存时间 1个月
     */
    public final static int CACHE_MONTH = 60 * 60 * 24 * 7 * 30;


    /**
     * 精确删除key
     * @param key key
     */
    public void deleteCache(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 模糊删除key
     * @param pattern 模糊key
     */
    public void deleteCacheWithPattern(String pattern) {
        Set<String> keys = redisTemplate.keys(pattern);
        if (!ObjectUtils.isEmpty(keys)) {
            redisTemplate.delete(keys);
        }
    }

    /**
     *
     * 模糊获取key
     * @param pattern 模糊key
     * @return Set
     */
    public Set<String> keys(String pattern) {
        return redisTemplate.keys(pattern);
    }

    /**
     * 判断一个key是否存在
     * @param key key
     * @return Boolean
     */
    public Boolean exists(final String key) {
        final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
        return redisTemplate.execute((RedisCallback<Boolean>) connection -> connection.exists(bKey));
    }


    /**
     * 存放一个值
     * @param key 存入redis时的对应key  唯一
     * @param obj 需要存入的T
     * @return boolean
     */
    public <T> Boolean putCache(String key, T obj) {
        return putCache(key, obj, -1);
    }

    /**
     * 存放一个值
     * @param key        存入redis时的对应key  唯一
     * @param obj        需要存入的 T
     * @param timeoutOfSecond 缓存时长
     */
    public <T> Boolean putCache(String key, T obj, final long timeoutOfSecond) {
        final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
        final byte[] bValue = ProtoStuffSerializerUtil.serialize(obj);
        return redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            connection.set(bKey, bValue, Expiration.seconds(timeoutOfSecond), RedisStringCommands.SetOption.UPSERT);
            return true;
        });
    }

    /**
     * @param key     存入redis时的对应key  唯一``
     * @param objList 需要存入的List<T>
     * @return Long  list.size()
     */
    public <T> Long putListCache(String key, Collection<T> objList) {
        final List<byte[]> collect = ProtoStuffSerializerUtil.serializeList(objList);
        return redisTemplate.execute(new RedisCallback<Long>() {
            final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
            @Override
            public Long doInRedis(@Nonnull RedisConnection connection) throws DataAccessException {
                return connection.lPush(bKey, collect.toArray(new byte[0][0]));
            }
        });
    }

    /**
     * 获取一个集合
     * @param key         key
     * @param targetClass 需要返回类型的class
     * @return List<T>
     */
    public <T> List<T> getListCache(final String key, Class<T> targetClass) {
            return lRange(key, 0, Integer.MAX_VALUE, targetClass);
    }

    /**
     * 向list前面添加value
     * @param key   key
     * @param value value
     * @return Boolean
     */
    public Long lPush(final String key, final Object value) {
        return putListCache(key, Collections.singletonList(value));
    }

    /**
     * 向list前面添加value
     * @param key   key
     * @param value value
     * @return Boolean
     */
    public <T> Long lPush(final String key, final Collection<T> value) {
        return putListCache(key, value);
    }

    /**
     * 向list中后面添加value
     * @param key   key
     * @param value value
     * @return Boolean
     */
    public Long rPush(final String key, final Object value) {
        return redisTemplate.execute(new RedisCallback<Long>() {
            final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
            final byte[] bValue = ProtoStuffSerializerUtil.serialize(value);
            @Override
            public Long doInRedis(@Nonnull RedisConnection connection) throws DataAccessException {
                return connection.rPush(bKey, bValue);
            }
        });
    }

    /**
     * 向list中删除指定value
     * @param key   key
     * @param value value
     * @param count 大于 0 : 从表头开始向表尾搜索   小于 0 : 从表尾开始向表头搜索   等于0 : 移除表中所有与 VALUE 相等的值。
     * @return Boolean
     */
    public Long lRem(final String key, final Object value, final int count) {
        return redisTemplate.execute(new RedisCallback<Long>() {
            final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
            final byte[] bValue = ProtoStuffSerializerUtil.serialize(value);
            @Override
            public Long doInRedis(@Nonnull RedisConnection connection) throws DataAccessException {
                return connection.lRem(bKey, count, bValue);
            }
        });
    }


    /**
     * 清除list中的数据,不包括当前范围内清单
     * @param key   key
     * @param start 开始
     * @param stop  结束
     * @return Boolean
     */
    public Boolean lTrim(final String key, final int start, final int stop) {
        if (start > stop) {
            return false;
        }
        return redisTemplate.execute(new RedisCallback<Boolean>() {
            final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
            @Override
            public Boolean doInRedis(@Nonnull RedisConnection connection) throws DataAccessException {
                connection.lTrim(bKey, start, stop);
                return true;
            }
        });
    }

    /**
     * 从 list 中获取指定元素
     * @param key   key
     * @param start 开始
     * @param stop  结束
     * @param targetClass  需要返回类型的class
     * @return List
     */
    public <T> List<T> lRange(final String key, final int start, final int stop, Class<T> targetClass) {
        if (start > stop) {
            return null;
        }
        List<byte[]> result = redisTemplate.execute(new RedisCallback<List<byte[]>>() {
            final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
            @Override
            public List<byte[]> doInRedis(@Nonnull RedisConnection connection) throws DataAccessException {
                return connection.lRange(bKey, start, stop);
            }
        });
        if (result == null || result.size() < 1) {
            return new ArrayList<>();
        }
        return ProtoStuffSerializerUtil.deserializeList(result, targetClass);
    }

    /**
     * 存入Hash
     * @param key key
     * @param hashKey hashKey
     * @param value value
     * @return Boolean
     */
    public <T> Boolean hSet(String key, String hashKey, T value) {
        final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
        final byte[] field = ProtoStuffSerializerUtil.serializeKey(hashKey);
        final byte[] bValue = ProtoStuffSerializerUtil.serialize(value);
        return redisTemplate.execute((RedisCallback<Boolean>) connection -> connection.hSet(bKey, field, bValue));
    }


    /**
     * 存入Hash map指定多个
     * @param key key
     * @param map map
     */
    public <T> void hMSet(String key, Map<String, T> map) {
        final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
        final Map<byte[], byte[]> bHashMap = new HashMap<>(map.size());
        for (Map.Entry<String, T> entry : map.entrySet()) {
            byte[] bField = ProtoStuffSerializerUtil.serializeKey(entry.getKey());
            byte[] bv = ProtoStuffSerializerUtil.serialize(entry.getValue());
            bHashMap.put(bField, bv);
        }
        redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            connection.hMSet(bKey, bHashMap);
            return true;
        });

    }

    /**
     * 获取HASH哈希表中字段
     * @param key key
     * @param hashKey hashKey
     * @param valueClass  需要返回类型的class
     * @return T
     */
    public <T> T hGet(String key, String hashKey, Class<T> valueClass) {
        final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
        final byte[] bHashKey = ProtoStuffSerializerUtil.serialize(hashKey);
        byte[] execute = redisTemplate.execute((RedisCallback<byte[]>) connection -> connection.hGet(bKey, bHashKey));
        if (execute == null) {
            return null;
        }
        return ProtoStuffSerializerUtil.deserialize(execute, valueClass);
    }


    /**
     * 获取HASH哈希表中字段
     * @param key key
     * @param hashKey hashKey
     * @param valueClass  需要返回类型的class
     * @return List
     */
    public <T> List<T> hHGet(String key, List<String> hashKey, Class<T> valueClass) {
        final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
        List<byte[]> bHashKey = ProtoStuffSerializerUtil.serializeList(hashKey);
        List<byte[]> execute = redisTemplate.execute((RedisCallback<List<byte[]>>) connection -> connection.hMGet(bKey, bHashKey.toArray(new byte[0][0])));
        if (execute == null) {
            return new ArrayList<>();
        }
        return ProtoStuffSerializerUtil.deserializeList(execute, valueClass);
    }

    /**
     * 获取HASH哈希表中所有的的字段
     * @param key key
     * @param valueClass  需要返回类型的class
     * @return Map
     */
    public <T> Map<String, T> hGetAll(final String key, Class<T> valueClass) {
        final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
        Map<byte[], byte[]> hashMap = redisTemplate.execute((RedisCallback<Map<byte[], byte[]>>) connection -> connection.hGetAll(bKey));
        if (hashMap == null || hashMap.keySet().size() < 1) {
            return new HashMap<>();
        }
        Map<String, T> hashValue = new HashMap<>(hashMap.size());
        for (Map.Entry<byte[], byte[]> entry : hashMap.entrySet()) {
            String entryKey = ProtoStuffSerializerUtil.deserializeKey(entry.getKey());
            T entryValue = ProtoStuffSerializerUtil.deserialize(entry.getValue(), valueClass);
            hashValue.put(entryKey, entryValue);
        }
        return hashValue;
    }

    /**
     * 删除Hash哈希中的指定一个或者多个value
     * @param key key
     * @param hashKey hashKey
     * @return Long
     */
    public <T> Long hDel(String key, String... hashKey) {
        final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
        List<byte[]> bytes = ProtoStuffSerializerUtil.serializeList(Arrays.asList(hashKey));
        return redisTemplate.execute((RedisCallback<Long>) connection -> connection.hDel(bKey, bytes.toArray(new byte[0][0])));
    }

    /**
     * 查看哈希表 key否存在
     * @param key key
     * @param hashKey hashKey
     * @return Boolean
     */
    public <T> Boolean hExists(String key, String hashKey) {
        final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
        final byte[] bHashKey = ProtoStuffSerializerUtil.serialize(hashKey);
        return redisTemplate.execute((RedisCallback<Boolean>) connection -> connection.hExists(bKey, bHashKey));
    }

    /**
     * 获取一个Long值
     * @param key key
     * @return Long
     */
    public Long getLong(final String key) {
        return redisTemplate.execute((RedisCallback<Long>) connection -> {
            final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
            //使用自定义的序列化对象[StringSerializer],而不是spring-redis.xml中配置的默认序列化对象
            String result = redisTemplate.getStringSerializer().deserialize(bKey);
            return result == null ? null : new Long(result);
        });
    }


    /**
     * 获取一个字符串值
     * @param key key
     * @return String
     */
    public String getString(final String key) {
        return redisTemplate.execute((RedisCallback<String>) connection -> {
            final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
            //使用自定义的序列化对象[StringSerializer],而不是spring-redis.xml中配置的默认序列化对象
            return ProtoStuffSerializerUtil.deserialize(connection.get(bKey), String.class);
        });
    }

    /**
     * 存放一个字符串
     * @param key   key
     * @param value value
     * @param timeoutOfSecond key过期时间
     */
    public Boolean setString(final String key, final String value, long timeoutOfSecond) {
        final byte[] bKey = ProtoStuffSerializerUtil.serializeKey(key);
        return redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            byte[] byteValue = ProtoStuffSerializerUtil.serialize(value);
            if (byteValue != null) {
                return connection.set(bKey, byteValue, Expiration.seconds(timeoutOfSecond), RedisStringCommands.SetOption.UPSERT);
            }
            return false;
        });
    }

    /**
     * 存放一个字符串
     * @param key   key
     * @param value value
     */
    public Boolean setString(final String key, final String value) {
        return setString(key, value, -1);
    }

    /**
     * 根据key获取一个整数,匹配：
     * @param key key
     * @return Integer
     */
    public Integer getInteger(final String key) {
        String value = getString(key);
        return new Integer(value);
    }

    /**
     * 存放一个整数
     * @param key   key
     * @param value value
     */
    public Boolean setInteger(final String key, final Integer value) {
        return setInteger(key, value, -1);
    }


    /**
     * 存放一个整数
     * @param key   key
     * @param value value
     * @param timeoutOfSecond key过期时间
     */
    public Boolean setInteger(final String key, final int value, long timeoutOfSecond) {
        return setString(key, String.valueOf(value), timeoutOfSecond);
    }

    /**
     * 存放一个Float
     *
     * @param key   key
     * @param value value
     */
    public Boolean setFloat(final String key, final float value) {
        return setFloat(key, value, -1);
    }

    /**
     * 存放一个Float
     * @param key   key
     * @param value value
     * @param timeoutOfSecond key过期时间
     */
    public Boolean setFloat(final String key, final float value, long timeoutOfSecond) {
        return setString(key, String.valueOf(value), timeoutOfSecond);
    }

    /**
     * 根一个Float值
     * @param key key
     * @return Float
     */
    public Float getFloat(final String key) {
        String value = getString(key);
        return new Float(value);
    }


    /**
     * 存放一个Double值
     * @param key   key
     * @param value value
     */
    public Boolean setDouble(final String key, final Double value) {
        return setDouble(key, value, -1);
    }

    /**
     * 存放一个Double值
     * @param key   key
     * @param value value
     * @param timeoutOfSecond key过期时间
     */
    public Boolean setDouble(final String key, final double value, long timeoutOfSecond) {
        return setString(key, String.valueOf(value), timeoutOfSecond);
    }


    /**
     * 获取一个Double值
     * @param key key
     * @return Double
     */
    public Double getDouble(final String key) {
        String result = getString(key);
        return new Double(result);
    }


    /**
     * increment(增量)
     * @param key   key
     * @param delta 增量变量
     * @return Long
     */
    public Long increment(final String key, final long delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 增量
     * @param key   key
     * @param delta 增量变量
     * @return Long
     */
    public Double increment(final String key, final double delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * append(在原来的key对应的value上面追加内容)
     * @param key          key
     * @param append_value 要追加的内容
     * @return Long
     */
    public Integer append(final String key, final String append_value) {
        return redisTemplate.opsForValue().append(key, append_value);
    }

    /**
     * 设置key过期时间
     * @param key               key
     * @param timeoutOfSecond key过期时间
     */
    public void expire(final String key, final long timeoutOfSecond) {
        if (key != null && timeoutOfSecond > 0) {
            long currentTimeMillis = System.currentTimeMillis();
            long timeoutMillis = timeoutOfSecond * 1000;
            Date expireDate = new Date(currentTimeMillis + timeoutMillis);
            redisTemplate.expireAt(key, expireDate);
        }
    }

    /**
     * 设置key的生存时间
     * @param key     key
     * @param timeout timeout
     * @param unit    unit
     */
    public void expire(final String key, final long timeout, final TimeUnit unit) {
        redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 哈希表中的字段值加上指定增量值。
     * @param key     key
     * @param hashKey hashKey
     * @param delta   delta
     */
    public Long increment(String key, String hashKey, long delta) {
        return redisTemplate.opsForHash().increment(key, hashKey, delta);
    }

    /**
     * 获取key的生存时间
     * @param key      Key
     * @param timeUnit timeUnit
     * @return Long
     */
    public Long getExpire(final String key, final TimeUnit timeUnit) {
        if (timeUnit == null) {
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
        return redisTemplate.getExpire(key, timeUnit);
    }

    /**
     * 返回缓存中长度
     * @param key key
     * @return Long
     */
    public Long getCacheLong(String key) {
        if (StringUtils.isEmpty(key)) {
            return null;
        }
        return redisTemplate.opsForList().size(key);
    }

}

序列化工具类(数据压缩版)

//package 

import cn.hutool.core.util.ReflectUtil;
import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
import lombok.extern.slf4j.Slf4j;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 序列化工具类(数据压缩版)
 * @author Wang
 * @date 2022/9/22 14:50
 */
@Slf4j
public class ProtoStuffSerializerUtil {
    /**
     * 序列化key
     * @param key key
     * @return byte[]
     */
    public static <T> byte[] serializeKey(String key) {
        if (key == null) {
            throw new RuntimeException("key 不能为空");
        }
        return key.getBytes();
    }

    /**
     * 反序列化key
     * @param bKey bKey
     * @return String
     */
    public static String deserializeKey(byte[] bKey) {
        if (bKey == null) {
            throw new RuntimeException("key 不能为空");
        }
        return new String(bKey);
    }

    /**
     * 序列化
     * @param obj objList
     * @return byte
     */
    public static <T> byte[] serialize(T obj) {
        if (obj == null) {
            throw new RuntimeException("序列化对象( null )!");
        }
        @SuppressWarnings("unchecked")
        Schema<T> schema = (Schema<T>) RuntimeSchema.getSchema(obj.getClass());
        LinkedBuffer buffer = LinkedBuffer.allocate(1024 * 1024);
        byte[] protostuff;
        try {
            protostuff = ProtostuffIOUtil.toByteArray(obj, schema, buffer);
        } catch (Exception e) {
            throw new RuntimeException("序列化(" + obj.getClass() + ")对象(" + obj + ")发生异常!", e);
        } finally {
            buffer.clear();
        }
        return protostuff;
    }


    /**
     * 反序列化
     * @param paramArrayOfByte paramArrayOfByte
     * @param targetClass targetClass
     * @return List
     */
    public static <T> T deserialize(byte[] paramArrayOfByte, Class<T> targetClass) {
        if (paramArrayOfByte == null || paramArrayOfByte.length == 0) {
            throw new RuntimeException("反序列化对象发生异常,byte序列为空!");
        }
        T instance = ReflectUtil.newInstanceIfPossible(targetClass);
        Schema<T> schema = RuntimeSchema.getSchema(targetClass);
        ProtostuffIOUtil.mergeFrom(paramArrayOfByte, instance, schema);
        return instance;
    }

    /**
     * 序列化
     * @param objList objList
     * @return byte
     */
    public static <T> byte[] serializeListForObject(List<T> objList) {
        if (objList == null || objList.isEmpty()) {
            throw new RuntimeException("序列化对象列表(" + objList + ")参数异常!");
        }
        @SuppressWarnings("unchecked")
        Schema<T> schema = (Schema<T>) RuntimeSchema.getSchema(objList.get(0).getClass());
        LinkedBuffer buffer = LinkedBuffer.allocate(1024 * 1024);
        byte[] protostuff;
        ByteArrayOutputStream bos = null;
        try {
            bos = new ByteArrayOutputStream();
            ProtostuffIOUtil.writeListTo(bos, objList, schema, buffer);
            protostuff = bos.toByteArray();
        } catch (Exception e) {
            throw new RuntimeException("序列化对象列表(" + objList + ")发生异常!", e);
        } finally {
            buffer.clear();
            try {
                if (bos != null) {
                    bos.close();
                }
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }

        return protostuff;
    }

    /**
     * 反序列化
     * @param paramArrayOfByte paramArrayOfByte
     * @param targetClass targetClass
     * @return List
     */
    public static <T> List<T> deserializeListForObject(byte[] paramArrayOfByte, Class<T> targetClass) {
        if (paramArrayOfByte == null || paramArrayOfByte.length == 0) {
            throw new RuntimeException("反序列化对象发生异常,byte序列为空!");
        }

        Schema<T> schema = RuntimeSchema.getSchema(targetClass);
        List<T> result;
        try {
            result = ProtostuffIOUtil.parseListFrom(new ByteArrayInputStream(paramArrayOfByte), schema);
        } catch (IOException e) {
            throw new RuntimeException("反序列化对象列表发生异常!", e);
        }
        return result;
    }

    /**
     * 序列化
     * @param objList objList
     * @return byte
     */
    public static <T> List<byte[]> serializeList(Collection<T> objList) {
        if (objList == null || objList.isEmpty()) {
            throw new RuntimeException("序列化对象列表(" + objList + ")参数异常!");
        }
        return objList.parallelStream().map(ProtoStuffSerializerUtil::serialize).collect(Collectors.toList());
    }

    /**
     * 反序列化
     * @param paramArrayOfByte paramArrayOfByte
     * @param targetClass targetClass
     * @return List
     */
    public static <T> List<T> deserializeList(Collection<byte[]> paramArrayOfByte, Class<T> targetClass) {
        if (paramArrayOfByte == null) {
            return null;
        }
        return paramArrayOfByte.parallelStream().map(str -> deserialize(str, targetClass)).collect(Collectors.toList());
    }
}

序列化工具类(数据清晰版)

//package

import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;

import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 序列化工具类(数据清晰版)
 * @author Wang
 * @date 2022/9/22 14:50
 */
@Slf4j
public class ProtoStuffSerializerUtil {

    /**
     * 序列化key
     * @param key key
     * @return byte[]
     */
    public static <T> byte[] serializeKey(String key) {
        if (key == null) {
            throw new RuntimeException("key 不能为空");
        }
        return key.getBytes();
    }

    /**
     * 反序列化key
     * @param bKey bKey
     * @return String
     */
    public static String deserializeKey(byte[] bKey) {
        if (bKey == null) {
            throw new RuntimeException("key 不能为空");
        }
        return new String(bKey);
    }

    /**
     * 序列化
     * @param obj obj
     * @return byte
     */
    public static <T> byte[] serialize(T obj) {
        if (obj == null) {
            throw new RuntimeException("序列化对象( null )!");
        }
        if(obj instanceof String){
            return serializeKey((String)obj);
        }
        return JSON.toJSONString(obj).getBytes();
    }

    /**
     * 反序列化
     * @param paramArrayOfByte paramArrayOfByte
     * @param targetClass targetClass
     * @return T
     */
    public static <T> T deserialize(byte[] paramArrayOfByte, Class<T> targetClass) {
        if (paramArrayOfByte == null || paramArrayOfByte.length == 0) {
            return null;
        }
        String str = new String(paramArrayOfByte);
        try {
            return JSON.parseObject(str, targetClass);
        } catch (Exception e) {
            //
        }
        return BeanUtil.toBean(str, targetClass);
    }

    /**
     * 序列化
     * @param objList objList
     * @return byte
     */
    public static <T> byte[] serializeListForObject(Collection<T> objList) {
        if (objList == null || objList.isEmpty()) {
            throw new RuntimeException("序列化对象列表(" + objList + ")参数异常!");
        }
        return JSON.toJSONString(objList).getBytes();
    }

    /**
     * 反序列化
     * @param paramArrayOfByte paramArrayOfByte
     * @param targetClass targetClass
     * @return List
     */
    public static <T> List<T> deserializeListForObject(byte[] paramArrayOfByte, Class<T> targetClass) {
        if (paramArrayOfByte == null || paramArrayOfByte.length == 0) {
            return null;
        }
        String str = new String(paramArrayOfByte);
        Object parse = JSON.parse(str);
        if(parse instanceof JSONObject){
            throw new RuntimeException("反序列化对象发生异常, paramArrayOfByte为对象!非集合");
        }
        return JSON.parseArray(str, targetClass);
    }



    /**
     * 序列化
     * @param objList objList
     * @return byte
     */
    public static <T> List<byte[]> serializeList(Collection<T> objList) {
        if (objList == null || objList.isEmpty()) {
            throw new RuntimeException("序列化对象列表(" + objList + ")参数异常!");
        }
        return objList.parallelStream().map(ProtoStuffSerializerUtil::serialize).collect(Collectors.toList());
    }


    /**
     * 反序列化
     * @param paramArrayOfByte paramArrayOfByte
     * @param targetClass targetClass
     * @return List
     */
    public static <T> List<T> deserializeList(Collection<byte[]> paramArrayOfByte, Class<T> targetClass) {
        if (paramArrayOfByte == null) {
            return null;
        }
        return paramArrayOfByte.parallelStream().map(str -> deserialize(str, targetClass)).collect(Collectors.toList());
    }
}

补充一下引包的jar包

<dependency>
            <groupId>com.dyuproject.protostuff</groupId>
            <artifactId>protostuff-core</artifactId>
            <version>1.2.1</version>
        </dependency>
        <dependency>
            <groupId>com.dyuproject.protostuff</groupId>
            <artifactId>protostuff-runtime</artifactId>
            <version>1.2.1</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.4.M1</version>
        </dependency>