序列化与反序列化

分布式接口技术： webService，RMI，阿里json，谷歌msgpack

定义：
Serillization序列化 是一种对象按照一定规则生成出一连串的字符过程。
Deserialization反序列化 是一种将这些字符重新建成一个内存对象的过程。

场景：
当把内存中的对象保存到一个文件或者数据库的时候（持久化）。
当你需要在跨平台的环境下，通过网络传输对象的时候（webService soap）。
当你通过RMI传输对象的时候。

实现方式：
将要序列化的类实现Serializable接口就可以了。
Serializable没有任何方法，就是一个标记，表明这个类可以被实例化。

例子：
java默认的序列化规则：

package org.xdemo.example.SpringActivemq.service.consumer;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerialTest {

	public static void main(String[] args) throws ClassNotFoundException {
		
		String stuFileName = "student.out";
		
		Student serialStu = new Student("海龙", 11);
		serialize(serialStu, stuFileName);
		
		Student student = (Student)deserialize(stuFileName);
		System.out.println("name:" + student.getName() + ",age:"+ student.getAge());
		
	}

	/**
	 * 序列化
	 * @param obj
	 * @param outFile
	 */
	public static void serialize(Object obj, String outFile) {
		
		try {
			ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(outFile));
			
			//向磁盘中写入当前内存中对象的状态。
			oos.writeObject(obj);
			//清空
			oos.flush();
			//关闭
			oos.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * 反序列化
	 * @param obj
	 * @param outFile
	 * @throws ClassNotFoundException 
	 */
	public static Object deserialize(String readFile) throws ClassNotFoundException {
		
		ObjectInputStream ois;
		Object object;
		try {
			ois = new ObjectInputStream(new FileInputStream(readFile));
			object = ois.readObject();
			ois.close();
			return object;
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
}

package org.xdemo.example.SpringActivemq.service.consumer;

import java.io.Serializable;

public class Student implements Serializable{

	private String name;
	// transient static
	private int age;
	
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

//	public void setName(String name) {
//		this.name = name;
//	}

	public int getAge() {
		return age;
	}

//	public void setAge(int age) {
//		this.age = age;
//	}
	
	//jdk自动调用，扩展序列化规则的方法。
//	private void writeObject(ObjectOutputStream out) throws IOException{
//		out.defaultWriteObject();
//		out.writeInt(age);
//	}
//	
//	private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException{
//		in.defaultReadObject();
//		age = in.readInt();
//	}
}

序列化和反序列化的 序列化ID需要一样。
所以序列化ID在对跨平台，跨服务的时候设定一致。

如果我们想序列化一个对象，首先创建OutPutStream(如 FileOutPutStream等)；
这时候，只需要直接调用writeObject()方法就可以将对象实例化，并将其发送给OutputStream
序列化基于字节，不使用Reader和Writer等基于字符层次的IO。

而反序列化（将一个序列还原成一个对象），需要将一个InputStream封装在ObjectInputStream中。
然后调用readObject。

影响序列化：
1 加上transient 可以不被序列化，用于敏感信息不要序列化。
2 被static静态变量修饰，也不能序列化。
3 重写writeObject方法与readObject方法。
4 实现接口Externalizable(正常是实现接口Serializable)
jdk不会调用默认序列化接口，使用自定义writeExternal和readExternal
5.用readResolve()：当我们使用单例模式时，应该期望这个类实例是唯一的。
但是该类是可序列化的，那么情况可能不一样了，此时可以增加readResolve方法来实现，
确保在同一个jvm只有一个单例对象的引用。

两种数据类型，引用类型，值类型。
== 比 引用地址是否相同 浅克隆   序列化和反序列化后 == 是false
equals 比值是否相同 比如字符串内容 深克隆 序列化和反序列化后 equals 是true

在网络下的序列化：
1.java环境RMI（Remote Method Invoker）
仅限java平台，序列化效率低
2.webServer SOAP 简单对象传出协议
跨语言 跨平台 php .net
效率低 可读性差 基于xml传递
3.json（javaScript Object Notation javaScript 对象交换）
跨语言 跨平台
可读性强 序列化效率有所提高，但效率不是最高
阿里巴巴的fastjson1.2.4.jar

//序列化
String json = JSON.toJSONString(msgPack);
// {"age":8,"name":"海龙"}键值对存储 存储大小比msgPack大点
// msgPack是org.xdemo.example.SpringActivemq.service.consumer.MsgPack@69ac44c2
System.out.println(json);
// 反序列化
MsgPack msgPack3 =  JSON.parseObject(json, MsgPack.class);
System.out.println("name:" + msgPack3.name + ",age:"+ msgPack3.age + "_json");

<!-- 阿里巴巴https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>fastjson</artifactId>
	<version>1.2.4</version>
</dependency>

4.新的序列类库MessagePack(谷歌)
效率高，序列化后文件小
需要jar：msgpack-0.6.12.jar，javassist-3.18.2-GA.jar

	 
<!-- 序列化msgpack -->
		<!-- https://mvnrepository.com/artifact/org.msgpack/msgpack -->
		<dependency>
		    <groupId>org.msgpack</groupId>
		    <artifactId>msgpack</artifactId>
		    <version>0.6.12</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.javassist/javassist -->
		<dependency>
		    <groupId>org.javassist</groupId>
		    <artifactId>javassist</artifactId>
		    <version>3.18.1-GA</version>
		</dependency>

	    
MsgPack msgPack = new MsgPack();
msgPack.name = "海龙";
msgPack.age= 8;
try {
	    	// 序列化
			byte[] arr = MessagePack.pack(msgPack);
			// 反序列化
			MsgPack msgPack2 =  MessagePack.unpack(arr, MsgPack.class);
			System.out.println("name:" + msgPack2.name + ",age:"+ msgPack2.age + "_msgPack");
			System.out.println(msgPack == msgPack2);
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

package org.xdemo.example.SpringActivemq.service.consumer;

import org.msgpack.annotation.Message;

//redis2.6也支持MsgPack
@Message
public class MsgPack {

	public String name;
	
	public int age;
}

//用此方式测试时间
long msgpackStart = System.currentTimeMillis();
long msgpackEnd = System.currentTimeMillis();
System.out.println(msgpackEnd - msgpackStart);