下面是一个简单的socket通信demo。
通信数据类:
package com.zwx.serialize.demo;
public class SocketUser {
public SocketUser(String id, String name) {
this.id = id;
this.name = name;
}
private String id;
private String name;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
socket服务端:
package com.zwx.serialize.demo;
import com.alibaba.fastjson.JSONObject;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketServer {
public static void main(String[] args) {
ServerSocket serverSocket = null;
try {
serverSocket = new ServerSocket(8888);
Socket socket = serverSocket.accept();
ObjectInputStream input = new ObjectInputStream(socket.getInputStream());
SocketUser user = (SocketUser) input.readObject();
System.out.println(JSONObject.toJSONString(user));
}catch (Exception e){
e.printStackTrace();
}finally {
if (null != serverSocket){
try {
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
socket客户端:
package com.zwx.serialize.demo;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
public class SocketClient {
public static void main(String[] args) {
Socket socket = null;
ObjectOutputStream out = null;
try {
socket = new Socket("localhost",8888);
SocketUser user = new SocketUser("1","张三");
out = new ObjectOutputStream(socket.getOutputStream());
out.writeObject(user);
}catch (Exception e){
e.printStackTrace();
}finally {
if (null != out){
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != socket){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
接下来我们先启动socket服务端,然后再启动socket客户端,这时候客户端就会连接上服务端进行通讯数据传输。
运行时却发现,报错了,提示我们没有序列化:
这时候我们把类SocketUser改一下,实现序列化接口:
public class SocketUser implements Serializable{
再次运行,发现这时候服务端可以正常输出我们传入的SocketUser对象了:
所以我们可以知道,当我们在远程通信的时候,必须要序列化数据才能正常传输,那么到底什么是序列化,什么又是反序列化呢?
序列化的本质是为了进行网络数据传输,而数据又只能够以二进制的形式在网络中进行传输,所以我们就需要把对象转为二进制的形式,也就是需要序列化这么一个过程,而因为二进制形式对我们使用者来说是不方便的,所以就需要有一个反序列化的过程,将数据重新还原。
序列化的方式有很多种,比如Java自带的序列化方式,json序列化,xml序列化等。
文中开始的例子就是Java自带的序列化,其中SocketClient是序列化过程,SocketServer就是反序列化过程。
当我们在实现序列化接口Serializable时候,可以手动生成一个serialVersionUID,有两种表现形式:
private static final long serialVersionUID = -2426545572670767992L;
private static final long serialVersionUID = 1L;
那么这两种形式有什么区别?serialVersionUID 又到底有什么用呢?为了说明这两个问题,我们还是先来看一个例子:
SocketUser沿用上面的类,但是不要添加serialVersionUID属性
package com.zwx.serialize;
import com.alibaba.fastjson.JSONObject;
import com.zwx.serialize.demo.SocketUser;
import java.io.*;
public class TestJavaSerialize {
public static void main(String[] args) {
//代码片段A:序列化
SocketUser socketUser = new SocketUser("1","张三");
serialize(socketUser);
//代码片段B:反序列化
// SocketUser socketUser2 = deSerialize();
// System.out.println(JSONObject.toJSONString(socketUser2));
}
static void serialize(SocketUser user){
try {
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(new File("G:\\user")));
out.writeObject(user);
} catch (IOException e) {
e.printStackTrace();
}
}
static SocketUser deSerialize(){
try {
ObjectInputStream in = new ObjectInputStream(new FileInputStream(new File("G:\\user")));
return (SocketUser) in.readObject();
}catch (Exception e){
e.printStackTrace();
}
return null;
}
}
上面的例子中,我们把创建好的SocketUser对象初始化到了本地文件中,然后先不要反序列化,我们在SocketUser类中自动生成serialVersionUID = -2426545572670767992L;
然后把上面的代码片段A注释掉,把代码片段B打开注释,运行,发现反序列化成功,这个没有问题。好,那我们把serialVersionUID = -2426545572670767992L;换成serialVersionUID =1L,再去运行,这时候发现报错了:
这是因为如果我们没有生成serialVersionUID的话,那么当序列化的时候,会自动在序列化对象中自动生成serialVersionUID,而如果我们没有修改过类中的方法和属性,这个值是不会变的,所以我们序列化之后再去生成serialVersionUID,因为算法一直,所以两边的UID依然是相同的,但是我们改成了1L就不行了,会导致UID不相等,无法反序列化,当然,如果我们手动修改serialVersionUID值,也会导致匹配不上,或者说我们修改了类的属性和方法之后再去重新生成,也会导致匹配不上而无法反序列化。
serialVersionUID默认有两种表现方式:
如果我们没有手动生成serialVersionUID,则系统会默认采用第一种方式生成,如果我们此时又手动采用了第二种方式生成serialVersionUID,那么反序列化的时候就会发现两边的UID匹配不上,导致反序列化失败。
Transient 关键字的作用是控制变量的序列化,在变量声明前加上该关键字,可以阻止该变量被序列化到文件中,在被反序列化后,transient 变量的值被设为初始值,如 int 型的是 0,对象型的是null。
如我们把上面的name属性加上transient 关键字之后再去序列化,:
private transient String name;
然后反序列化可以看到name=null:
不过,我们有办法可以绕开transient 关键字,从而使得transient 关键字失效。这就是下面的两个方法:writeObject和readObject的作用了。
我们把上面的SocketUser类进行一下改写:
package com.zwx.serialize.demo;
import java.io.IOException;
import java.io.Serializable;
public class SocketUser implements Serializable{
public SocketUser(String id, String name) {
this.id = id;
this.name = name;
}
private String id;
private transient String name;
private void writeObject(java.io.ObjectOutputStream s) throws IOException {
s.defaultWriteObject();
s.writeObject(name);
}
private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
s.defaultReadObject();
name=(String)s.readObject();
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
然后再去序列化和反序列化,发现name属性已经可以被反序列化出来了:
如果会用Java序列化会有两个缺点:
package com.zwx.serialize;
public interface ISerializer {
<T> byte[] serialize(T obj);
<T> T deserialize(byte[] data,Class<T> clazz);
}
新建一个Java序列化类实现ISerializer接口:
package com.zwx.serialize;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class JavaSerialize implements ISerializer{
@Override
public <T> byte[] serialize(T obj) {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
try {
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(obj);
return byteArrayOutputStream.toByteArray();
}catch (Exception e){
e.printStackTrace();
}
return null;
}
@Override
public <T> T deserialize(byte[] data, Class<T> clazz) {
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(data);
try {
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
return (T)objectInputStream.readObject();
}catch (Exception e){
e.printStackTrace();
}
return null;
}
}
最后新建一个测试类来测试一下Java序列化之后的字节大小:
package com.zwx.serialize;
import com.zwx.serialize.demo.SocketUser;
public class TestSerialize {
public static void main(String[] args) {
SocketUser socketUser = new SocketUser("1","张三丰");
//Java序列化
JavaSerialize javaSerialize = new JavaSerialize();
byte[] byteArr = javaSerialize.serialize(socketUser);
System.out.println(byteArr.length);//108
}
}
输出之后大小为108,先记住这个数字,我们再来看看其他序列化方式在序列化之后的字节大小。
引入XML序列化依赖:
<dependency>
<groupId>com.thoughtworks.xstream</groupId>
<artifactId>xstream</artifactId>
<version>1.4.10</version>
</dependency>
新建一个XML序列化类实现ISerializer接口:
package com.zwx.serialize;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
public class XMLSerializer implements ISerializer {
XStream xStream=new XStream(new DomDriver());
@Override
public <T> byte[] serialize(T obj) {
return xStream.toXML(obj).getBytes();
}
@Override
public <T> T deserialize(byte[] data, Class<T> clazz) {
return (T)xStream.fromXML(new String(data));
}
}
最后在之前的测试类中测试一下XML序列化的大小为110:
//XML序列化
XMLSerializer xmlSerializer = new XMLSerializer();
System.out.println(xmlSerializer.serialize(socketUser).length);//110
JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,相对于XML来说,JSON 的字节流更小,而且可读性也非常好。现在JSON数据格式在企业运用是最普遍的 JSON序列化常用的开源工具有很多,如:Jackson,FastJson,GSON。
下面以FastJson来举例:
新建一个FastJson序列化类实现ISerializer接口:
package com.zwx.serialize;
import com.alibaba.fastjson.JSON;
public class FastJsonSerialize implements ISerializer {
@Override
public <T> byte[] serialize(T obj) {
return JSON.toJSONString(obj).getBytes();
}
@Override
public <T> T deserialize(byte[] data, Class<T> clazz) {
return (T)JSON.parseObject(new String(data),clazz);
}
}
最后在测试类中添加如下代码,测试结果大小为:29。
//FastJson序列化
FastJsonSerialize fastJsonSerialize = new FastJsonSerialize();
System.out.println(fastJsonSerialize.serialize(socketUser).length);//29
从上面的例子中我们可以看到,同样一个对象,序列化之后的大小FastJson是最小的,而XML最大。而数据包越大,相对来说通讯的性能就会越低。
如何选择一种合适的序列化方式,可以根据以下方面进行综合考虑:
最后 请关注我,和孤狼一起学习进步。