关于Redis不同序列化压缩性能的对比

一、背景介绍

为了核心业务更好的安全性,部分业务服务和核心业务做了redis分离,项目中初始化多个redis的链接,负责的一个业务系统,就存在redis的配置不太够,内存比较吃紧,于是乎,就想到了通过引入更加优秀的序列化方式,在牺牲redis中value的可读性,获取更低的内存占用(如果切换不同的redis序列化方式,同一个key切换前后会有不兼容的情况)。

二、解决方案

有了初期的思路,解决这个问题,相对也比较简单,通过调研,选择了几种比较常用的序列化方式,采用简单直接的方式,通过不同序列化将对象设置到redis中,对比一下他们的value占用空间大小。

三、环境声明:

JDK:17

Maven配置:

XML 复制代码
        <!--redisson-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.45.1</version>
        </dependency>

        <!--JSON序列化-->
        <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-jsr310</artifactId>
            <version>2.18.4</version>
        </dependency>

        <!--fury序列化,可能会和项目中的guava包有依赖冲突,需要排除一下-->
        <dependency>
            <groupId>org.apache.fury</groupId>
            <artifactId>fury-core</artifactId>
            <version>0.9.0</version>
            <exclusions>
                <exclusion>
                    <artifactId>guava</artifactId>
                    <groupId>com.google.guava</groupId>
                </exclusion>
            </exclusions>
        </dependency>

Redisson配置:

java 复制代码
    public RedissonAutoConfigurationCustomizer redissonCustomizer() {
        return config -> {
// 指定序列化输入的类型,类必须是非final修饰的。序列化时将对象全类名一起保存下来
//            JavaTimeModule javaTimeModule = new JavaTimeModule();
//            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//            javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(formatter));
//            javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(formatter));
//            ObjectMapper om = new ObjectMapper();
//            om.registerModule(javaTimeModule);
//            om.setTimeZone(TimeZone.getDefault());
//            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//            om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
//            LoggerFactory.useSlf4jLogging(true);
//            TypedJsonJacksonCodec jsonCodec = new TypedJsonJacksonCodec(Object.class, om);
            // 组合序列化 key 使用 String 内容使用通用 json 格式
//            CompositeCodec codec = new CompositeCodec(StringCodec.INSTANCE, jsonCodec, jsonCodec);
//            CompositeCodec codec = new CompositeCodec(StringCodec.INSTANCE, StringCodec.INSTANCE, StringCodec.INSTANCE);
//            CompositeCodec codec = new CompositeCodec(StringCodec.INSTANCE, new Kryo5Codec(), new Kryo5Codec());

            CustomFuryCodec furyCodec = new CustomFuryCodec();
            CompositeCodec codec = new CompositeCodec(StringCodec.INSTANCE, furyCodec, furyCodec);
            config.setThreads(redissonProperties.getThreads())
                .setNettyThreads(redissonProperties.getNettyThreads())
                // 缓存 Lua 脚本 减少网络传输(redisson 大部分的功能都是基于 Lua 脚本实现)
                .setUseScriptCache(true)
                .setCodec(codec);
            if (SpringUtils.isVirtual()) {
                config.setNettyExecutor(new VirtualThreadTaskExecutor("redisson-"));
            }
            RedissonProperties.SingleServerConfig singleServerConfig = redissonProperties.getSingleServerConfig();
            if (ObjectUtil.isNotNull(singleServerConfig)) {
                // 使用单机模式
                config.useSingleServer()
                    //设置redis key前缀
                    .setNameMapper(new KeyPrefixHandler(redissonProperties.getKeyPrefix()))
                    .setTimeout(singleServerConfig.getTimeout())
                    .setClientName(singleServerConfig.getClientName())
                    .setIdleConnectionTimeout(singleServerConfig.getIdleConnectionTimeout())
                    .setSubscriptionConnectionPoolSize(singleServerConfig.getSubscriptionConnectionPoolSize())
                    .setConnectionMinimumIdleSize(singleServerConfig.getConnectionMinimumIdleSize())
                    .setConnectionPoolSize(singleServerConfig.getConnectionPoolSize());
            }
            // 集群配置方式 参考下方注释
            RedissonProperties.ClusterServersConfig clusterServersConfig = redissonProperties.getClusterServersConfig();
            if (ObjectUtil.isNotNull(clusterServersConfig)) {
                config.useClusterServers()
                    //设置redis key前缀
                    .setNameMapper(new KeyPrefixHandler(redissonProperties.getKeyPrefix()))
                    .setTimeout(clusterServersConfig.getTimeout())
                    .setClientName(clusterServersConfig.getClientName())
                    .setIdleConnectionTimeout(clusterServersConfig.getIdleConnectionTimeout())
                    .setSubscriptionConnectionPoolSize(clusterServersConfig.getSubscriptionConnectionPoolSize())
                    .setMasterConnectionMinimumIdleSize(clusterServersConfig.getMasterConnectionMinimumIdleSize())
                    .setMasterConnectionPoolSize(clusterServersConfig.getMasterConnectionPoolSize())
                    .setSlaveConnectionMinimumIdleSize(clusterServersConfig.getSlaveConnectionMinimumIdleSize())
                    .setSlaveConnectionPoolSize(clusterServersConfig.getSlaveConnectionPoolSize())
                    .setReadMode(clusterServersConfig.getReadMode())
                    .setSubscriptionMode(clusterServersConfig.getSubscriptionMode());
            }
            log.info("初始化 redis 配置");
        };
    }

FuryCodec配置类:

java 复制代码
public class CustomFuryCodec extends BaseCodec {


    // 使用 ThreadLocal 确保每个线程有独立的 Fury 实例
    private final ThreadLocal<Fury> furyThreadLocal;

    public CustomFuryCodec() {
        this.furyThreadLocal = ThreadLocal.withInitial(() ->
                Fury.builder()
                        .withLanguage(Language.JAVA)  // 纯 Java 模式,性能最佳
                        .requireClassRegistration(false)  // 强制注册类,避免写入类名(前提:预注册所有类)
                        .withMetaShare(false)  // 启用 MetaContext 共享,减少 schema 重复(如果需要;否则 false 以进一步提速)
                        .withRefTracking(false)  // 无循环引用时关闭,提升性能
                        .withCodegen(true)  // 启用 ASM 代码生成,接近手写代码速度
                        .withAsyncCompilation(true)  // 启用异步编译,长期使用下更快
                        .withCompatibleMode(CompatibleMode.SCHEMA_CONSISTENT)  // 非兼容模式,纯性能优化
                        .withNumberCompressed(true)  // 启用 int/long 压缩,减少大小
                        .withStringCompressed(true)  // 启用字符串压缩,适合大对象
                        .build()
        );
    }

    // 供 Redisson 复制 codec 时调用的构造方法
    public CustomFuryCodec(ClassLoader classLoader, CustomFuryCodec codec) {
        this(); // 调用默认构造,重新创建 ThreadLocal<Fury>
    }

    private Fury getFury() {
        return furyThreadLocal.get();
    }

    @Override
    public Decoder<Object> getValueDecoder() {
        return (ByteBuf buf, State state) -> {
            byte[] bytes = new byte[buf.readableBytes()];
            buf.readBytes(bytes);
            return getFury().deserialize(MemoryBuffer.fromByteArray(bytes));
        };
    }

    @Override
    public Encoder getValueEncoder() {
        return in -> {
            byte[] bytes = getFury().serialize(in);
            return Unpooled.wrappedBuffer(bytes);
        };
    }
}
四、结果对比

Kryo5Codec:

Java/JVM 上很成熟的二进制序列化库,用于对象图(object graph)序列化,高效但需要配置(注册类、Serializer等);快速、紧凑、支持复杂对象图,但在某些场景下(比如跨语言、零拷贝、元数据开销)会有劣势;

字节码序列化,通常比 Java Serialization/JSON 那些格式小很多,相对的字节码也不可直接阅读。通过注册类可以进一步减少类名、类型 tag 等元数据开销,可变长编码也有助于压缩整型等,对于某些类型(字符串、多余空值、nulls、共享引用等)大小可能较大。kryo5-gitHub链接https://github.com/EsotericSoftware/kryo最终的Redis Key Size(1):

JSONCodec:

较为常见的序列化方式,拥有较好的可读性;

最终的Redis Key Size(2):

FuryCodec:

较新的序列化框架/项目,目标是"多语言支持 + 零拷贝 + JIT 代码生成 + 高吞吐 + 简单易用";较新的序列化框架/项目,目标是"多语言支持 + 零拷贝 + JIT 代码生成 + 高吞吐 + 简单易用";

动态生成序列化代码、支持跨语言、兼容 JDK 序列化 API、支持零拷贝、大量优化(元数据共享、长整型压缩等);多语言支持"------Java+Python+CPP+Golang+Rust+JavaScript 等。

Fury官方也有和其他序列化方式的性能对比,链接如下:

fury-gitHub官方对比各方序列化https://github.com/chaokunyang/fory-benchmarks最终的Redis Key Size(3):

StringCodec:

作为基础对比项;

最终的Redis Key Size(4):

五、总结:

Fury序列化对比与kryo5的压缩比例,对于序列化和反序列化性能有较大提升,但是本身的配置可选项较多,学习成本和使用成本较高,内存大小压缩没有特别机制,对于速度要求比较极致的可以选择。

Kryo5在压缩比,以及性能方面都有不错的表现,综合来说还是非常不错的选择。

相关推荐
程序员麻辣烫7 分钟前
Redis过期策略与内存淘汰策略
redis
卷Java28 分钟前
用户权限控制功能实现说明
java·服务器·开发语言·数据库·servlet·微信小程序·uni-app
从零开始学习人工智能33 分钟前
Spring Security 实战:彻底解决 CORS 跨域凭据问题与 WebSocket 连接失败
java·websocket·spring
winrisef44 分钟前
删除无限递归文件夹
java·ide·python·pycharm·系统安全
悦悦子a啊1 小时前
Java面向对象练习:Person类继承与排序
java·开发语言·python
不会算法的小灰1 小时前
Spring Boot 实现邮件发送功能:整合 JavaMailSender 与 FreeMarker 模板
java·spring boot·后端
come112342 小时前
深入理解 Java和Go语法和使用场景(指南十一)
java·开发语言·golang
李贺梖梖8 小时前
DAY23 单例设计模式、多例设计模式、枚举、工厂设计模式、动态代理
java
武昌库里写JAVA8 小时前
Java设计模式之工厂模式
java·vue.js·spring boot·后端·sql
赛姐在努力.10 小时前
SpringMVC中的常用注解及使用方法
java·spring