实战Redis序列化性能测试(Kryo和字符串)

最新推荐文章于 2024-09-25 08:01:04 发布
最新推荐文章于 2024-09-25 08:01:04 发布
阅读量9.1k 收藏 4
点赞数 5
分类专栏： java服务端 文章标签： kryo redis springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/boling_cavalry/article/details/80719683
版权

在Java应用的开发中，有时候需要将Java对象实例保存在Redis中，常用方法有两种：

  1. 将对象序列化成字符串后存入Redis；
  2. 将对象序列化成byte数组后存入Redis；

以上两种方式孰优孰劣？字符串方式来存取的好处是编码和调试更简单容易，而byte数组的优势又在哪里呢，今天我们针对这两种存储方式做一次对比试验，用数据来得出结论；

原文地址：https://blog.csdn.net/boling_cavalry/article/details/80719683

测试方法简述

本次做的是对比测试，写Redis和读Redis都会测试到，测试一共有以下四种：

  1. 并发场景下对象通过fastjson转字符串，然后存入Redis；
  2. 并发场景下对象通过Kyro序列化成byte数组，然后存入Redis；
  3. 并发场景下从Redis取出字符串，通过fastjson转成对象；
  4. 并发场景下从Redis取出byte数组，然后通过Kyro反序列化成对象；

测试环境简介

本次测试需要以下三台电脑，全部是Linux：

  1. Redis服务器；
  2. Web应用服务器；
  3. 安装有Apache bench，用于发起性能测试，并统计出测试结果；

整体部署情况如下：
这里写图片描述

测试步骤梳理

在正式开始前，先将所有步骤整理好以免遗漏，接下来一步一步进行就可以了：

  1. 部署Redis；
  2. 开发基于字符串存取的web应用redis-performance-demo-string；
  3. 开发基于Kyro序列化存取的web应用redis-performance-demo-kryo；
  4. web应用编译构建；
  5. 在测试端机器上安装Apache bench；
  6. 部署应用redis-performance-demo-string；
  7. 用Apache bench先web server发起请求，然后丢弃测试结果，这次请求中部分处理是在JIT之前完成的，不算数；
  8. 清理Redis数据，用Apache bench先web server再次发起请求，保存测试结果；
  9. 清理Redis数据，部署应用redis-performance-demo-kryo；
  10. 用Apache bench先web server发起请求，然后丢弃测试结果，这次请求中部分处理是在JIT之前完成的，不算数；
  11. 清理Redis数据，用Apache bench先web server再次发起请求，保存测试结果；
  12. 对比结果，得出测试结论；

本章源码下载

本章实战的源码可以在github下载，地址和链接信息如下表所示：

名称链接备注
项目主页https://github.com/zq2599/blog_demos该项目在GitHub上的主页
git仓库地址(https)https://github.com/zq2599/blog_demos.git该项目源码的仓库地址，https协议
git仓库地址(ssh)git@github.com:zq2599/blog_demos.git该项目源码的仓库地址，ssh协议

这个git项目中有多个文件夹，本章源码在以下两个文件夹中：

  1. redis-performance-demo-string：对应字符串存取对象的应用；
  2. redis-performance-demo-kryo：对应kryo序列化对象的应用；

如下图所示：
这里写图片描述

应用版本

  1. JDK：1.8.0_161；
  2. Maven：3.5.0；
  3. SpringBoot：1.4.1.RELEASE；
  4. Redis：3.2.12.；
  5. Fastjson：1.2.47；
  6. Kryo：4.0.0；
  7. Apache bench：2.3；
  8. Ubuntu：16.04.3 LTS；

接下来我们开始实战吧；

部署Redis

Redis的安装和部署就不在本章展开了，以下两点请注意：

  1. 关闭redis远程保护：config set protected-mode “no”；
  2. 修改conf文件，关闭持久化；

开发基于字符串存取的web应用redis-performance-demo-string

这是个基于SpringBoot的简单web应用，将几处重点列举出来：
首先是application.properties文件中有Redis配置信息，请将IP和端口替换为您的Redis服务器的IP和端口：

spring.redis.database=0
spring.redis.host=192.168.31.104
spring.redis.port=6379
spring.redis.pool.maxActive=8    
spring.redis.pool.maxWait=-1    
spring.redis.pool.maxIdle=8    
spring.redis.pool.minIdle=0    
spring.redis.timeout=0

其次，是web接口对应的controller类RedisController.java：

@Controller
public class RedisController {

    private static final Logger logger = LoggerFactory.getLogger(RedisController.class);

    private static AtomicInteger addPersionIdGenerator = new AtomicInteger(0);

    private static AtomicInteger checkPersionIdGenerator = new AtomicInteger(0);

    private static final String PREFIX = "person_";

    private static final int TIMES = 100;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @RequestMapping(value = "/save/{key}/{value}", method = RequestMethod.GET)
    @ResponseBody
    public String save(@PathVariable("key") final String key, @PathVariable("value") final String value) {
        try{
            stringRedisTemplate.opsForValue().set(key, value);
        }catch(Exception e){
            e.printStackTrace();
        }
        return "1. success";
    }

    @RequestMapping(value = "/checksingle/{id}", method = RequestMethod.GET)
    public void check(@PathVariable("id") final int id, HttpServletResponse response) {
        checkPerson(id, response);
    }

    @RequestMapping(value = "/check", method = RequestMethod.GET)
    public void check(HttpServletResponse response) {
        boolean hasError = false;
        for(int i=0;i<TIMES;i++) {
            boolean rlt = checkPerson(checkPersionIdGenerator.incrementAndGet(), response);
            if(!rlt){
                hasError = true;
                break;
            }
        }

        if(!hasError){
            Helper.success(response, "check success");
        }
    }

    @RequestMapping(value = "/add", method = RequestMethod.GET)
    public void add(HttpServletResponse response) {
        boolean isSuccess;
        for(int i=0;i<TIMES;i++) {
            Person person = Helper.buildPerson(addPersionIdGenerator);

            while (true) {
                isSuccess = false;
                try {
                    stringRedisTemplate.opsForValue().set(PREFIX + person.getId(), JSONObject.toJSONString(person));
                    isSuccess = true;
                } catch (Exception e) {
                    logger.error("save redis error");
                    return;
                }

                if (isSuccess) {
                    break;
                } else {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        logger.error("1. sleep error, ", e);
                    }
                }
            }
        }

        Helper.success(response, "save success");
    }

    @RequestMapping(value = "/reset", method = RequestMethod.GET)
    public void reset(HttpServletResponse response){
          addPersionIdGenerator.set(0);
          checkPersionIdGenerator.set(0);
          Helper.success(response, "id generator reset success!");
    }

    /**
     * 检查指定id的数据是否正常
     * @param id
     * @param response
     */
    private boolean checkPerson(int id, HttpServletResponse response){
        String raw = null;

        boolean isSuccess;

        while (true) {
            isSuccess = false;
            try {
                raw = stringRedisTemplate.opsForValue().get(PREFIX + id);
                isSuccess = true;
            } catch (Exception e) {
                logger.error("get from redis error");
            }

            if (isSuccess) {
                break;
            } else {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    logger.error("1. sleep error, ", e);
                }
            }
        }

        if(null==raw){
            Helper.error( response, "[" + id + "] not exist!");
            return false;
        }

        Person person = JSONObject.parseObject(raw, Person.class);

        String error = Helper.checkPerson(person);

        if(null==error){
            //Helper.success(response, "[" + id + "] check success!");
            return true;
        }else {
            Helper.error(response, "[" + id + "] " + error);
            return false;
        }
    }
}

关于该类有以下几处需要注意：

  1. 字符串转对象、对象转字符串的操作都是通过Fastjson实现的；
  2. add方法是用于写性能测试的主要方法，每次请求该接口，都会连续执行100次对象到字符串的转换，然后写入Redis；
  3. check方法是用于读性能测试的主要方法，每次请求该接口，都会连续执行100次读取Redis，然后将字符串转换成对象；
  4. add和check方法中获取Redis连接时都有可能获取失败，所以如果发生异常就sleep后再重试；
  5. 成员变量addPersionIdGenerator、checkPersionIdGenerator都是用于id增长的AtomicInteger实例，这样性能测试时就不用输入id了，用这两个对象生成连续的id；
  6. Helper.success和Helper.error方法会设置Response的返回码，Apache bench是根据Response的返回码是否位200来判定请求是成功还是失败；

开发基于Kyro序列化存取的web应用redis-performance-demo-kryo

在SpringBoot框架使用Kyro作为Redis序列化工具的详细过程请参考《
SpringBoot下用Kyro作为Redis序列化工具》，这里就不多说了，同样是类需要关注：

@Controller
public class RedisController {

    private static final Logger logger = LoggerFactory.getLogger(RedisController.class);

    private static AtomicInteger addPersionIdGenerator = new AtomicInteger(0);

    private static AtomicInteger checkPersionIdGenerator = new AtomicInteger(0);

    private static final String PREFIX = "person_";

    private static final int TIMES = 100;

    @Autowired
    private RedisClient redisClient;

    /**
     * 检查指定id的记录
     * @param id
     * @param response
     */
    @RequestMapping(value = "/checksingle/{id}", method = RequestMethod.GET)
    public void check(@PathVariable("id") final int id, HttpServletResponse response) {
        checkPerson(id, response);
    }

    /**
     * 将最后一次检查的id加一，然后根据最新id检查记录
     * @param response
     */
    @RequestMapping(value = "/check", method = RequestMethod.GET)
    public void check(HttpServletResponse response) {
        boolean hasError = false;
        for(int i=0;i<TIMES;i++) {
            boolean rlt = checkPerson(checkPersionIdGenerator.incrementAndGet(), response);
            if(!rlt){
                hasError = true;
                break;
            }
        }

        if(!hasError){
            Helper.success(response, "check success");
        }
    }

    /**
     * 向redis增加一条记录
     * @param response
     */
    @RequestMapping(value = "/add", method = RequestMethod.GET)
    public void add(HttpServletResponse response) {
        boolean isSuccess;

        for(int i=0;i<TIMES;i++) {
            Person person = Helper.buildPerson(addPersionIdGenerator);

            isSuccess = false;

            while (true){
                try {
                    redisClient.set(PREFIX + person.getId(), person);
                    isSuccess = true;
                } catch (Exception e) {
                    logger.error("save redis error, ", e);
                }

                if(isSuccess){
                    break;
                }else{
                    try{
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        logger.error("1. sleep error, ", e);
                    }
                }
            }
        }

        Helper.success(response, "save success");
    }

    /**
     * 将id清零
     * @param response
     */
    @RequestMapping(value = "/reset", method = RequestMethod.GET)
    public void reset(HttpServletResponse response){
          addPersionIdGenerator.set(0);
          checkPersionIdGenerator.set(0);
          Helper.success(response, "id generator reset success!");
    }

    /**
     * 检查指定id的数据是否正常
     * @param id
     * @param response
     */
    private boolean checkPerson(int id, HttpServletResponse response){
        Person person = null;
        boolean isSuccess;

        while (true) {
            isSuccess = false;
            try {
                person = redisClient.getObject(PREFIX + id);
                isSuccess = true;
            } catch (Exception e) {
                logger.error("get from redis error");
            }

            if(isSuccess){
                break;
            }else{
                try{
                    Thread.sleep(100);
                }catch(InterruptedException e){
                    logger.error("2. sleep error, ", e);
                }
            }
        }

        if(null==person){
            Helper.error( response, "[" + id + "] not exist!");
            return false;
        }

        String error = Helper.checkPerson(person);

        if(null==error){
            //Helper.success(response, "[" + id + "] check success, object :\n" + JSONObject.toJSONString(person));
            return true;
        }else {
            Helper.error(response, "[" + id + "] " + error);
            return false;
        }
    }
}

以上代码，同样需要关注的是add和check方法，它们是性能测试时被调用的接口；

web应用编译构建

  1. 在应用redis-performance-demo-string的pom.xml所在目录执行命令mvn clean package -U -DskipTests，编译构架成功后，在target目录下得到文件redis-performance-demo-string-0.0.1-SNAPSHOT.jar；
  2. 在应用redis-performance-demo-kryo的pom.xml所在目录执行命令mvn clean package -U -DskipTests，编译构架成功后，在target目录下得到文件redis-performance-demo-kryo-0.0.1-SNAPSHOT.jar；

redis-performance-demo-string-0.0.1-SNAPSHOT.jar和redis-performance-demo-kryo-0.0.1-SNAPSHOT.jar这两个文件留在稍后部署web应用的时候使用；

在测试端机器上安装Apache bench

准备一台Linux机器作为执行性能测试的机器，在上面安装Apache bench，对于ubuntu执行以下命令即可完成安装：

apt-get install -y apache2-utils

本次性能测试，我在一台树莓派3B上安装了Apache bench，作为性能测试的执行机器，如果您手里有这类设备也可以尝试，先安装64位Linux操作系统，详情参照《树莓派3B安装64位操作系统(树莓派无需连接显示器键盘鼠标)》；

部署应用redis-performance-demo-string

将前面生成的redis-performance-demo-string-0.0.1-SNAPSHOT.jar文件复制到web应用服务器上，执行命令java -jar >redis-performance-demo-string-0.0.1-SNAPSHOT.jar，即可启动应用；

redis-performance-demo-string应用预热

用Apache bench先web server发起请求，然后丢弃测试结果，因为这次请求中部分处理是在JIT之前完成的，不算数；
在Apache bench所在机器上执行如下命令即可发起序列化和写入Redis的性能测试：

ab -n 5000 -c 200 http://192.168.31.104:8080/add

以上是序列化和写入Redis的测试，执行完毕后再执行下面的读Redis和反序列化的性能测试：

ab -n 5000 -c 200 http://192.168.31.104:8080/check

192.168.31.104是部署redis-performance-demo-string应用的应用服务器IP地址，8080是应用启动后监听的端口；

正式压测redis-performance-demo-string并保存结果

  1. 先清理预热时残留的数据，在Redis服务器上执行redis-cli进入命令行，然后执行flushall清除该Redis所有数据，注意：该命令会删除Redis上全部数据，请慎用！！！；
  2. 通过浏览器访问地址：http://192.168.31.104:8080/reset，将生成id的全局变量重新设置为0；
  3. 测试序列化和写入，在Apache bench所在机器再次执行ab -n 150000 -c 200 http://192.168.31.104:8080/add，等测试结束后，记录测试结果中的三个关键信息如下：
名称数值含义
Requests per second399.18每秒吞吐率，单位时间内能处理的最大请求数
Time per request501.033用户平均请求等待时间，毫秒
Time per request
(mean, across all concurrent requests)		2.505服务器平均请求等待时间；
它是吞吐率的倒数；
它也等于"用户平均请求等待时间"除以"并发用户数"
  1. 去Redis服务器执行命令info，得到Redis内存使用大小为3.30G(used_memory_human)；
  2. 去Redis服务器执行命令dbsize，得到记录数为15000000，符合预期；
  3. 测试反序列化和读取，在Apache bench所在机器执行ab -n 150000 -c 200 http://192.168.31.104:8080/check，等测试结束后，记录测试结果中的三个关键信息如下：
名称数值含义
Requests per second425.22每秒吞吐率，单位时间内能处理的最大请求数
Time per request470.341用户平均请求等待时间，毫秒
Time per request
(mean, across all concurrent requests)		2.352服务器平均请求等待时间；
它是吞吐率的倒数；
它也等于"用户平均请求等待时间"除以"并发用户数"

部署应用redis-performance-demo-kryo

将前面生成的redis-performance-demo-kryo-0.0.1-SNAPSHOT.jar文件复制到web应用服务器上，执行命令java -jar >redis-performance-demo-kryo-0.0.1-SNAPSHOT.jar，即可启动应用；

redis-performance-demo-kryo应用预热

用Apache bench先web server发起请求，然后丢弃测试结果，因为这次请求中部分处理是在JIT之前完成的，不算数；
在Apache bench所在机器上执行如下命令即可发起序列化和写入Redis的性能测试：

ab -n 5000 -c 200 http://192.168.31.104:18080/add

以上是序列化和写入Redis的测试，执行完毕后再执行下面的读Redis和反序列化的性能测试：

ab -n 5000 -c 200 http://192.168.31.104:18080/check

192.168.31.104是部署redis-performance-demo-kryo应用的应用服务器IP地址，18080是应用启动后监听的端口；

正式压测redis-performance-demo-kryo并保存结果

  1. 先清理预热时残留的数据，在Redis服务器上执行redis-cli进入命令行，然后执行flushall清除该Redis所有数据，注意：该命令会删除Redis上全部数据，请慎用！！！；
  2. 通过浏览器访问地址：http://192.168.31.104:18080/reset，将生成id的全局变量重新设置为0；
  3. 测试序列化和写入，在Apache bench所在机器再次执行ab -n 150000 -c 200 http://192.168.31.104:18080/add，等测试结束后，记录测试结果中的三个关键信息如下：
名称数值含义
Requests per second381.06每秒吞吐率，单位时间内能处理的最大请求数
Time per request524.851用户平均请求等待时间，毫秒
Time per request
(mean, across all concurrent requests)		2.624服务器平均请求等待时间；
它是吞吐率的倒数；
它也等于"用户平均请求等待时间"除以"并发用户数"
  1. 去Redis服务器执行命令info，得到Redis内存使用大小为3.20G：
  2. 去Redis服务器执行命令dbsize，得到记录数为15000000，符合预期；
  3. 测试反序列化和读取，在Apache bench所在机器执行ab -n 50000 -c 500 http://192.168.31.104:18080/check，等测试结束后，记录测试结果中的三个关键信息如下：
名称数值含义
Requests per second386.49每秒吞吐率，单位时间内能处理的最大请求数
Time per request517.484用户平均请求等待时间，毫秒
Time per request
(mean, across all concurrent requests)		2.587服务器平均请求等待时间；
它是吞吐率的倒数；
它也等于"用户平均请求等待时间"除以"并发用户数"

至此，性能测试已经完毕，我们把关键的QPS和内存大小拿来对比一下，如下表所示：

名称stringKryo
每秒吞吐率（序列化和写入Reids）399.18381.06
每秒吞吐率（反序列化和读取Reids）425.22386.49
所占内存大小3.30G3.20G

从以上对比可以发现：

  1. 两种序列化方案的数据存入Redis后，kryo占用内存小于string，但是优势并不明显；
  2. 不论是读还是写，kryo方案的吞吐率低于sting方案，这和之前预期的不同，但是网上已经有很多实践证明kryo方案的速度优于字符串方案，所以除了kryo本身的优势，对于kryo方案的集成以及redis连接管理等因素对吞吐率都有影响，SpringBoot的StringRedisTemplate看来是个优秀的处理工具；

测试的硬件环境与生产环境有着不小差别，所以数据仅供参考，也可能是我的测试代码质量堪忧所致（囧），如果您发现其中的问题，期待您的及时指正；

程序员欣宸
关注
专栏目录
Redis自定义序列化
xycxycooo的博客
07-30 455
在使用RedisTemplate时，默认情况下，Java对象会被序列化为字节形式并存储在Redis中。默认的序列化方式是JDK序列化，这种方式存在一些缺点，如可读性差和内存占用较大。为了解决这些问题，我们可以自定义RedisTemplate的序列化方式，通常采用JSON序列化来替代默认的JDK序列化方式。可读性好：采用JSON序列化后，数据以JSON字符串形式存储，易于阅读和理解。内存占用较小：JSON序列化后的数据体积相对较小，节省内存空间。跨语言支持。
spring redis 缓存使用kryo做序列化
Tashan_shi的博客
10-08 978
import java.nio.ByteBuffer; import org.springframework.data.redis.serializer.RedisElementReader; import org.springframework.data.redis.serializer.RedisElementWriter; import org.springframework.data...
redis序列化器的性能比较测试
qq_36032901的博客
04-13 694
/*springboot-version 2.4.4 */ @SpringBootTest public class MybatiscacheApplicationTests { //注意stringRedisTemplate是api存储的值,不能使用redisTemplate的api取值 //除非指定了 redisTemplate.setKeySerializer(new StringRedisSerializer()); @Autowired private Str
Redis 序列化详解及高性能实践
最新发布
fastboot
09-25 968
Redis 是一种高性能的内存数据库，广泛应用于缓存、消息队列等场景。在使用 Redis 存储数据时，我们常常需要将各种类型的对象存储到 Redis 中，而这就涉及到序列化和反序列化问题。本文将深入探讨 Redis 的序列化技术，并提供在高性能场景下的最佳实践。1. 什么是序列化？序列化是指将对象转换为字节流，以便存储或传输的过程。在 Redis 中，所有数据都是以字节的形式存储的，因此当我们将对...
测试Java操纵Redis序列化性能。
weixin_43201629的博客
12-10 447
测试Java操纵Redis序列化性能。 spring-data-redis的序列化类如下: GenericToStringSerializer: 可以将任何对象泛化为字符串并序列化 Jackson2JsonRedisSerializer: 跟JacksonJsonRedisSerializer实际上是一样的 JacksonJsonRedisSerializer: 序列化object对象为json字...
redis不同序列化方式性能对比
gc都收不走的咸鱼
12-15 2411
Redis的value序列化方式一般有两种：JSON方式和JDK方式 有以下几个序列化工具类: 第一次使用的是JDK方式进行测试 使用jdk方式需要pojo类实现Serializable接口 public void addByJDK() { //随机生五万条消息的一个方法 List<User> list = randomUser(); ...
redis 序列化方式改为kryo
weixin_40905584的博客
07-05 97
如何将Redis序列化方式改为Kryo 概述 在Redis中，我们可以使用不同的序列化方式来存储数据，其中包括默认的序列化方式和第三方库提供的序列化方式。本文将介绍如何将Redis的序列化方式改为Kryo，Kryo是一个高性能的Java序列化库。 流程 下面是实现将Redis序列化方式改为Kryo的步骤： 步骤 操作...
深入理解 RPC 之序列化篇 --Kryo
ylx1066863710的博客
12-17 809
一年前，笔者刚刚接触 RPC 框架，从单体式应用向分布式应用的变革无疑是让人兴奋的，同时也对 RPC 背后到底做了哪些工作产生了兴趣，但其底层的设计对新手而言并不是很友好，其涉及的一些常用技术点都有一定的门槛。如传输层常常使用的 netty，之前完全没听过，想要学习它，需要掌握前置知识点 nio；协议层，包括了很多自定义的协议，而每个 RPC 框架的实现都有差异；代理层的动态代理技术，如 jdk 动态代理，虽然实战经验不多，但至少还算会用，而 cglib 则又有一个盲区；序列化层倒还算是众多层次中相对简单的
StandardWebSocketSession 怎么用redis序列化
07-24
在上述示例中，我们创建了一个自定义的RedisTemplate，并设置了它的默认序列化器为GenericJackson2JsonRedisSerializer，这样就可以使用Jackson将StandardWebSocketSession对象序列化为JSON字符串存储到Redis中。...
Kryo 序列化
yrlzmm的专栏
05-16 6815
基于Java的快速高效的对象序列化框架，旨在提供快速、高效和易用的API。无论文件、数据库或网络数据Kryo都可以随时完成序列化。Kryo还可以执行自动深拷贝（克隆）、浅拷贝（克隆），这是对象到对象的直接拷贝，非对象→字节→对象的拷贝。支持互相引用，比如类A引用类B，类B引用类A，可以正确地反序列化。目前已有很多使用Kryo的项目https://github.com/EsotericSoftwar...
Redis——Redis性能优化与技术选型原理
庄小焱
03-15 794
redis的拥有众多优点，但是的技术有利有弊，所以只有在redis最擅长的场景中才能让redis的作用发挥到最大的作用。同样的redis一样存在很多优化和改进的点。
Kryo序列化介绍以及在Springboot Redis中的使用
逆水行舟
08-28 3458
1、Kryo的简介 （摘自：https://www.cnblogs.com/hntyzgn/p/7122709.html） Kryo 是一个快速序列化/反序列化工具，其使用了字节码生成机制（底层依赖了 ASM 库），因此具有比较好的运行速度。 Kryo 序列化出来的结果，是其自定义的、独有的一种格式，不再是 JSON 或者其他现有的通用格式；而且，其序列化出来的结果是二进制的（即byte[]；而 JSON 本质上是字符串String）；二进制数据显然体积更小，序列化、反序列化时的速度也更快。 ...
RedisTemplate使用
Only寒暄
07-28 2372
RedisTemplate使用
Redis中系列化方式及其比较
LightBreezes的博客
12-15 207
Redis系列化方式有JDK系列化、JSON系列化、XML系列化等多种。我专门测试过，在我的电脑上保存5万条User对象到Redis，JDK系列化方式平均要15秒，JSON系列化方式只要13秒多点，JSON效率高，而且它点的内存空间少，但是我们在使用的时候还是应该根据实际情况去选择使用。 ...
【Java进阶营】Java技术指南「序列化机制」采用protostuff和kryo高性能序列化框架实现RestTemplate的序列化组件
m0_60721514的博客
04-25 1559
序列化 序列化可以简单理解为对象–>字节的过程，同理，反序列化则是相反的过程。为什么需要序列化？因为网络传输只认字节。所以互信的过程依赖于序列化。 网络传输的性能等诸多因素，通常会支持多种序列化方式以供使用者插拔使用，一些常用的序列化方案hessian，kryo，Protostuff、FST等，其中最快、效果最好的要数Kryo和Protostuff RedisConfiguration的配置 创建Redis连接工厂对象（RedisConnectionFactory） 创建RestT
Redis配置Kryo序列化和Snappy压缩
后厂村老司机
07-22 554
前言 redis自带的StringSerializer性能相对较差，redis官方推荐kryo来提高序列化和反序列化速度，推荐snappy来节约redis内存和网络带宽，在springboot中可以通过配置快速实现这个功能 maven配置 <dependency> <groupId>com.esotericsoftware</groupId&g...
Redis的jdk和json序列化性能对比
weixin_44065695的博客
08-12 4222
redis默认采用的序列化策略有两种，一种是String的序列化策略，一种是JDK的序列化策略. 有一下几个序列化工具类: 1. GenericToStringSerializer: 可以将任何对象泛化为字符串并序列化 2. Jackson2Json...
Spring Data redis序列化的比较
WYFAIXIAOYU的博客
10-14 750
redis虽然提供了对list set hash等数据类型的支持，但是没有提供对POJO对象的支持，底层都是把对象序列化后再以字符串的方式存储的。因此，Spring data提供了若干个Serializer，主要包括： JacksonJsonRedisSerializer JdkSerializationRedisSerializer OxmSerializer
Redis SDS模块详解：动态字符串教程与性能优化
sds（Simple Dynamic String）是Redis为了提高字符串处理性能和灵活性而设计的一种数据结构。在Redis中，字符串对象是数据库的基本元素之一，sds被用于存储字符串值，尤其是当字符串对象需要同时支持字符串和long...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员欣宸

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值