RedisTemplate RedisConfig 序列化方式 fastjson2

目录

• Fastjson2 序列化
• Redis.config
• RedisUtil.java
• fastjson和fastjson2的区别

Spring Data Redis 为我们提供了下面的Serializer：GenericToStringSerializer、Jackson2JsonRedisSerializer、JacksonJsonRedisSerializer、JdkSerializationRedisSerializer、OxmSerializer、StringRedisSerializer。

序列化方式对比：

• JdkSerializationRedisSerializer: 使用JDK提供的序列化功能。 优点是反序列化时不需要提供类型信息(class)，但缺点是需要实现Serializable接口，还有序列化后的结果非常庞大，是JSON格式的5倍左右，这样就会消耗redis服务器的大量内存。
• Jackson2JsonRedisSerializer： 使用Jackson库将对象序列化为JSON字符串。优点是速度快，序列化后的字符串短小精悍，不需要实现Serializable接口。但缺点也非常致命，那就是此类的构造函数中有一个类型参数，必须提供要序列化对象的类型信息(.class对象)。 通过查看源代码，发现其只在反序列化过程中用到了类型信息。

使用 FastJson2 来做。重写一些序列化器，并实现RedisSerializer接口。源码如下：

<dependency>
    <groupId>com.alibaba.fastjson2</groupId>
    <artifactId>fastjson2</artifactId>
    <version>2.0.50</version>
</dependency>

Fastjson2 序列化

FastJson2JsonRedisSerializer

package com.vipsoft.base.util;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONReader;
import com.alibaba.fastjson2.JSONWriter;
import com.alibaba.fastjson2.filter.Filter;

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

import java.nio.charset.Charset;

/**
 * Redis使用FastJson序列化
 *
 * @author ruoyi
 */
public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T>
{
    /**
     * 自动识别json对象白名单配置（仅允许解析的包名，范围越小越安全）
     */
    public static final String[] JSON_WHITELIST_STR = { "org.springframework", "com.vipsoft" };

    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    static final Filter AUTO_TYPE_FILTER = JSONReader.autoTypeFilter(JSON_WHITELIST_STR);

    private Class<T> clazz;

    public FastJson2JsonRedisSerializer(Class<T> clazz)
    {
        super();
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException
    {
        if (t == null)
        {
            return new byte[0];
        }
        return JSON.toJSONString(t, JSONWriter.Feature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException
    {
        if (bytes == null || bytes.length <= 0)
        {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);
        return (T)JSON.parseObject(str, clazz, AUTO_TYPE_FILTER);
    }
}

Redis.config

package com.vipsoft.base.config;

import com.cuwor.base.util.FastJson2JsonRedisSerializer;
import org.springframework.cache.annotation.EnableCaching;
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;

@EnableCaching   //开启缓存功能，作用于缓存配置类上或者作用于springboot启动类上
@Configuration
public class RedisConfig {

    /**
     * 创建一个RedisTemplate实例，用于操作Redis数据库。
     * 其中，redisTemplate是一个泛型为<String, Object>的模板对象，可以存储键值对数据；
     * @param factory   factory是一个Redis连接工厂对象，用于建立与Redis服务器的连接
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);

        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);

        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);

        template.afterPropertiesSet();
        return template;
    }
}

RedisUtil.java

package com.vipsoft.base.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     */
    public boolean expire(String key, long time) {
        try {
            redisTemplate.expire(key, time, TimeUnit.MINUTES);
            return true;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return false;
    }

    /**
     * 获取 Keys
     *
     * @param key 键
     */
    public Set<String> keys(String key) {
        Set<String> result = new HashSet();
        try {
            result = redisTemplate.keys(key);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return result;
    }

    /**
     * 删除缓存
     */
    public boolean del(String key) {
        try {
            redisTemplate.delete(key);
            return true;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return false;
    }

    /**
     * 删除缓存
     */
    public boolean del(Collection<String> keys) {
        try {
            redisTemplate.delete(keys);
            return true;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return false;
    }

    //region String

    public <T> T get(String key) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    public <T> boolean set(String key, T value) {
        try {

            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return false;
    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(分种) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.MINUTES);
            return true;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return false;
    }

    //endregion

    //region Hash

    public <T> T hget(String key, String hashKey) {
        HashOperations<String, String, T> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    public <T> Map<String, T> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key     键
     * @param hashKey 项
     * @param value   值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
        return true;
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key     键
     * @param hashKey 项
     * @param value   值
     * @param time    时间(分钟) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String hashKey, Object value, long time) {
        redisTemplate.opsForHash().put(key, hashKey, value);
        if (time > 0) {
            redisTemplate.expire(key, time, TimeUnit.MINUTES);
        }
        return true;
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
        redisTemplate.opsForHash().putAll(key, map);
        return true;
    }

    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        redisTemplate.opsForHash().putAll(key, map);
        if (time > 0) {
            redisTemplate.expire(key, time, TimeUnit.MINUTES);
        }
        return true;
    }

    /**
     * 删除hash表中的值
     *
     * @param key     键 不能为null
     * @param hashKey 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... hashKey) {
        redisTemplate.opsForHash().delete(key, hashKey);
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key     键 不能为null
     * @param hashKey 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param hashKey 项
     * @param by   要增加几(大于0)
     * @return
     */
    public double hincr(String key, String hashKey, double by) {
        return redisTemplate.opsForHash().increment(key, hashKey, by);
    }

    /**
     * hash递减
     *
     * @param key  键
     * @param hashKey 项
     * @param by   要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String hashKey, double by) {
        return redisTemplate.opsForHash().increment(key, hashKey, -by);
    }

    //endregion

    //region List

    /**
	 * 获取list缓存的内容
	 * @param key 键
	 * @param start 开始
	 * @param end 结束 0 到 -1代表所有值
	 * @return
	 */
	public <T> List<T> lrange(String key, long start, long end) {
		return redisTemplate.opsForList().range(key, start, end);
	}

	/**
	 * 获取list缓存的长度
	 * @param key 键
	 * @return
	 */
	public long llen(String key) {
		return redisTemplate.opsForList().size(key);
	}

	/**
	 * 通过索引 获取list中的值
	 * @param key 键
	 * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
	 * @return
	 */
	public Object lindex(String key, long index) {
		return redisTemplate.opsForList().index(key, index);
	}

	/**
	 * 将一个或多个值插入到列表的尾部(最右边)。
	 * @param key 键
	 * @param value 值
	 * @return
	 */
	public boolean lrpush(String key, Object value) {
		redisTemplate.opsForList().rightPush(key, value);
		return true;
	}

	/**
	 * 将一个或多个值插入到列表的尾部(最右边)。
	 * @param key 键
	 * @param value 值
	 * @param time 时间(秒)
	 * @return
	 */
	public boolean lrpush(String key, Object value, long time) {
		redisTemplate.opsForList().rightPush(key, value);
		if (time > 0) {
			expire(key, time);
		}
		return true;
	}

	/**
	 * 将一个或多个值插入到列表的尾部(最右边)。
	 * @param key 键
	 * @param value 值
	 * @return
	 */
	public boolean lrpush(String key, List<Object> value) {
		redisTemplate.opsForList().rightPushAll(key, value);
		return true;
	}

	/**
	 * 将list放入缓存
	 * @param key 键
	 * @param value 值
	 * @param time 时间(秒)
	 * @return
	 */
	public boolean lrpush(String key, List<Object> value, long time) {
		redisTemplate.opsForList().rightPushAll(key, value);
		if (time > 0) {
			expire(key, time);
		}
		return true;
	}

	/**
	 * 通过索引来设置元素的值
	 * @param key 键
	 * @param index 索引
	 * @param value 值
	 * @return /
	 */
	public boolean lset(String key, long index, Object value) {
		redisTemplate.opsForList().set(key, index, value);
		return true;
	}

	/**
	 * 删除指定key集合中值等于value的元素(count=0, 删除所有值等于value的元素; count>0, 从头部开始删除第一个值等于value的元素; count<0, 从尾部开始删除第一个值等于value的元素)
	 * @param key 键
	 * @param count  count>0, 从头部开始删除第一个值等于value的元素; count<0, 从尾部开始删除第一个值等于value的元素
	 * @param value 值
	 * @return 移除的个数
	 */
	public long lremove(String key, long count, Object value) {
		return redisTemplate.opsForList().remove(key, count, value);
	}

    //endregion
}

fastjson和fastjson2的区别

FastJSON是一种广泛使用的JSON解析库，其高性能和简单易用的特点受到开发者的喜爱。然而，随着应用场景的复杂化和安全要求的提高，FastJSON逐渐暴露出一些问题。为了解决这些问题并进一步提升性能和安全性，阿里巴巴推出了FastJSON2。以下是FastJSON和FastJSON2的详细对比：

一、性能

FastJSON： 以其快速高效著称，可以快速地将Java对象转换为JSON字符串，也可以将JSON字符串转换为Java对象。

FastJSON2： 在性能上进行了多方面的优化，通过优化序列化算法和数据结构，提高了序列化的效率，减少了不必要的对象创建和复制操作，从而降低了CPU和内存的开销。同时，对解析器进行了重构，使其能够更快速地处理大规模JSON数据。根据官方提供的性能测试数据，FastJSON2的性能远超其他流行的JSON库，如Jackson、Gson和org.json。

二、安全性

FastJSON： 在安全性方面存在一些漏洞，特别是其AutoType功能的安全性问题较为突出。该功能在序列化的JSON字符串中带上类型信息，在反序列化时不需要传入类型，实现自动类型识别，但这也为恶意攻击提供了可能。

FastJSON2： 在安全性方面做了显著改进，针对之前版本中暴露的一些安全漏洞进行了修复。为了防止反序列化漏洞，FastJSON2引入了更严格的黑名单机制，默认禁止了某些危险类型的反序列化操作。同时，增强了类型检测机制，可以更好地防止恶意数据的注入，确保数据解析的安全性。此外，FastJSON2的AutoType功能必须显式打开才能使用，且没有任何白名单，也不包括任何Exception类的白名单，这进一步提高了其安全性。

三、功能特性

FastJSON： 支持复杂对象的处理，包括嵌套对象、集合、Map等；支持注解来指定Java对象与JSON字符串之间的映射关系；允许用户自定义实现对象的序列化和反序列化过程；提供了流式的API，可以在处理大量JSON数据时提供更好的性能。

FastJSON2： 在FastJSON的基础上增加了一系列新的功能特性。例如，对JSONPath的支持更加全面和高效，允许开发者使用JSONPath表达式方便地访问和操作JSON数据；改进了对日期和时间的处理，提供了更多的配置选项和更好的性能，支持多种日期格式和时区处理；提供了对JSON Schema的支持，增强了数据验证的能力；新增加对二进制格式JSONB的支持，进一步提升了数据处理的效率和灵活性。

四、兼容性

FastJSON： 作为早期版本的JSON处理库，已经被广泛应用于各种Java项目中。

FastJSON2： 在保持与FastJSON兼容性的同时，也进行了一些必要的改进和优化。例如，FastJSON2支持最新的JDK特性，包括JDK 11和JDK 17等；同时提供了对Kotlin语言的优化支持，使得Kotlin开发者能够更加便捷地使用FastJSON2。此外，FastJSON2还支持跨平台兼容性，包括Android 8+等平台。

五、易用性

FastJSON： 提供了简单明了的API，使用起来非常方便。

FastJSON2： 对部分API进行了调整和优化，使其更加直观和易用。同时提供了更详细和友好的错误提示信息，帮助开发者更快地定位和解决问题。

综上所述，FastJSON2在性能、安全性、功能特性、兼容性和易用性等方面相比FastJSON都有显著的提升。对于需要高性能JSON解析和序列化的应用场景，特别是在安全性要求较高的情况下，FastJSON2是一个更好的选择。