Java序列化

最新推荐文章于 2024-01-12 23:00:28 发布

萝卜阿咕咕

最新推荐文章于 2024-01-12 23:00:28 发布

阅读量531

点赞数

分类专栏： Java基础文章标签： java

原文链接：https://blog.youkuaiyun.com/qq_24313635/article/details/80761762

版权

Java基础专栏收录该内容

28 篇文章

订阅专栏

本文详细介绍了Java序列化的作用，如何通过FastJson、Gson和Jackson实现对象的序列化与反序列化，并对比了三种库的性能和适用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、什么是序列化？为什么要序列化？

Java 序列化就是指将对象转换为字节序列的过程，而反序列化则是只将字节序列转换成目标对象的过程。

我们都知道，在进行浏览器访问的时候，我们看到的文本、图片、音频、视频等都是通过二进制序列进行传输的，那么如果我们需要将Java对象进行传输的时候，是不是也应该先将对象进行序列化？答案是肯定的，我们需要先将Java对象进行序列化，然后通过网络，IO进行传输，当到达目的地之后，再进行反序列化获取到我们想要的对象，最后完成通信。

二、实现序列化

搭建项目

①User文件：

package com.yj.serializable.model;
 
import java.io.Serializable;
import java.util.List;
 
public class User implements Serializable{
	private static final long serialVersionUID = -3000940236094862245L;
	private Integer id;
	private List<Order> orderList;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public List<Order> getOrderList() {
		return orderList;
	}
	public void setOrderList(List<Order> orderList) {
		this.orderList = orderList;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", orderList=" + orderList + "]";
	}
}

②Order文件：

package com.yj.serializable.model;
 
import java.io.Serializable;
import java.util.Date;
import java.util.Map;
 
public class Order implements Serializable{
	private static final long serialVersionUID = 8904663608115454685L;
	private Integer id;
	private Date createTime;
	private Map<String,Item> itemMap;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public Date getCreateTime() {
		return createTime;
	}
	public void setCreateTime(Date createTime) {
		this.createTime = createTime;
	}
	public Map<String, Item> getItemMap() {
		return itemMap;
	}
	public void setItemMap(Map<String, Item> itemMap) {
		this.itemMap = itemMap;
	}
	@Override
	public String toString() {
		return "Order [id=" + id + ", createTime=" + createTime + ", itemMap=" + itemMap + "]";
	}
}

③Item文件：

package com.yj.serializable.model;
 
import java.io.Serializable;
 
public class Item  implements Serializable{
	private static final long serialVersionUID = -2190699842275360433L;
	private Integer id;
	private String itemName;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getItemName() {
		return itemName;
	}
	public void setItemName(String itemName) {
		this.itemName = itemName;
	}
	@Override
	public String toString() {
		return "Item [id=" + id + ", itemName=" + itemName + "]";
	}
}

④UserUtil文件：

package com.yj.serializable.util;
 
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
 
import com.yj.serializable.model.Item;
import com.yj.serializable.model.Order;
import com.yj.serializable.model.User;
 
public class UserUtil {
	public static User createUser() {
		User user = new User();
		user.setId((new Random().nextInt(10)));
		List<Order> orderList = new ArrayList<Order>();
		for (int j = 1; j <= 2; j++) {
			Order order = new Order();
			order.setId(j);
			order.setCreateTime(new Date());
			Map<String, Item> itemMap = new HashMap<String, Item>();
			for (int z = 1; z <= 2; z++) {
				Item item = new Item();
				item.setId(z);
				item.setItemName("item_" + z);
				itemMap.put("item_" + z, item);
			}
			order.setItemMap(itemMap);
			orderList.add(order);
		}
		user.setOrderList(orderList);
		return user;
	}
 
	public static List<User> createUserList() {
		List<User> userList = new ArrayList<User>();
		for (int i = 1; i <= 2; i++) {
			User user = createUser();
			userList.add(user);
		}
		return userList;
	}
}

⑤pom.xml文件：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
 
	<groupId>com.yj</groupId>
	<artifactId>Serializable</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
 
	<name>Serializable</name>
	<url>http://maven.apache.org</url>
 
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>
 
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.2.RELEASE</version>
		<relativePath />
	</parent>
 
	<dependencies>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.16</version>
		</dependency>
		<dependency>
			<groupId>com.google.code.gson</groupId>
			<artifactId>gson</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
	</dependencies>
</project>

二.验证

①FastJson：

package com.yj.serializable;
 
import java.util.List;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.yj.serializable.model.User;
import com.yj.serializable.util.UserUtil;
 
public class FastJson {
	private final static Logger logger = LoggerFactory.getLogger(FastJson.class);
	
	@Test
	public void testUser() {
		User user = UserUtil.createUser();
		logger.info("FastJson序列化前user:" + user);
		String userStr = JSON.toJSONString(user);
		logger.info("FastJson序列化后userStr:" + userStr);
		User user2 = JSONObject.parseObject(userStr,User.class);
		logger.info("FastJson反序列化后user:" + user2);
	}
	
	@Test
	public void testUserList() {
		List<User> userList = UserUtil.createUserList();
		logger.info("FastJson序列化前userList:" + userList);
		String userListStr = JSON.toJSONString(userList);
		logger.info("FastJson序列化后userListStr:" + userListStr);
		List<User> userList2 = JSONObject.parseArray(userListStr, User.class);
		logger.info("FastJson反序列化后userList:" + userList2);
	}
}

②GSON：

package com.yj.serializable;
 
import java.util.List;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.yj.serializable.model.User;
import com.yj.serializable.util.UserUtil;
 
public class GSON {
	private final static Logger logger = LoggerFactory.getLogger(GSON.class);
	public static Gson gson=new Gson();
	
	@Test
	public void testUser() {
		User user = UserUtil.createUser();
		logger.info("GSON序列化前user:" + user);
		String userStr = gson.toJson(user);
		logger.info("GSON序列化后userStr:" + userStr);
		User user2 = gson.fromJson(userStr,User.class);
		logger.info("GSON反序列化后user:" + user2);
	}
	
	@Test
	public void testUserList() {
		List<User> userList = UserUtil.createUserList();
		logger.info("GSON序列化前userList:" + userList);
		String userListStr = gson.toJson(userList);
		logger.info("GSON序列化后userListStr:" + userListStr);
		List<User> userList2 = gson.fromJson(userListStr,new TypeToken<List<User>>(){}.getType());
		logger.info("GSON反序列化后userList:" + userList2);
	}
}

③JackSon：

package com.yj.serializable;
 
import java.util.List;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yj.serializable.model.User;
import com.yj.serializable.util.UserUtil;
 
public class JackSon {
	private final static Logger logger = LoggerFactory.getLogger(JackSon.class);
	public static ObjectMapper mapper = new ObjectMapper();
 
	@Test
	public void testUser() {
		try {
			User user = UserUtil.createUser();
			logger.info("JackSon序列化前user:" + user);
			String userStr = mapper.writeValueAsString(user);
			logger.info("JackSon序列化后userStr:" + userStr);
			User user2 = mapper.readValue(userStr, User.class);
			logger.info("JackSon反序列化后user:" + user2);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
 
	@Test
	public void testUserList() {
		try {
			List<User> userList = UserUtil.createUserList();
			logger.info("JackSon序列化前userList:" + userList);
			String userListStr = mapper.writeValueAsString(userList);
			logger.info("JackSon序列化后userListStr:" + userListStr);
			List<User> userList2 = mapper.readValue(userListStr, new TypeReference<List<User>>() {
			});
			logger.info("JackSon反序列化后userList:" + userList2);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

三、对比

1.开源的Jackson

相比json-lib框架，Jackson所依赖的jar包较少，简单易用并且性能也要相对高些。而且Jackson社区相对比较活跃，更新速度也比较快。Jackson对于复杂类型的json转换bean会出现问题，一些集合Map，List的转换出现问题。Jackson对于复杂类型的bean转换Json，转换的json格式不是标准的Json格式
2.Google的Gson
Gson是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来，但自从在2008年五月公开发布第一版后已被许多公司或用户应用。Gson的应用主要为toJson与fromJson两个转换函数，无依赖，不需要例外额外的jar，能够直接跑在JDK上。而在使用这种对象转换之前需先创建好对象的类型以及其成员才能成功的将JSON字符串成功转换成相对应的对象。类里面只要有get和set方法，Gson完全可以将复杂类型的json到bean或bean到json的转换，是JSON解析的神器。Gson在功能上面无可挑剔，但是性能上面比FastJson有所差距。
3.阿里巴巴的FastJson
Fastjson是一个Java语言编写的高性能的JSON处理器,由阿里巴巴公司开发。无依赖，不需要例外额外的jar，能够直接跑在JDK上。FastJson在复杂类型的Bean转换Json上会出现一些问题，可能会出现引用的类型，导致Json转换出错，需要制定引用。FastJson采用独创的算法，将parse的速度提升到极致，超过所有json库。

综上3种Json技术的比较，在项目选型的时候可以使用Google的Gson和阿里巴巴的FastJson两种并行使用，如果只是功能要求，没有性能要求，可以使用google的Gson，如果有性能要求，可以使用阿里巴巴的FastJson。