2. 程式人生 > >java 常用序列化和反序列化框架使用demo

java 常用序列化和反序列化框架使用demo

阿新 • • 發佈：2019-01-13 
package com.baidu.test;

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

import org.msgpack.annotation.MessagePackMessage;

//Msgpack需要註釋
@MessagePackMessage
public class Student implements Serializable{

	private static final long serialVersionUID = -2060550357305407661L;

	private Integer id;
	
	private String name;
	
	private String city;
	
	private List<Student> lovers;

	public Student(){}
	
	
	public Student(Integer id, String name, String city) {
		super();
		this.id = id;
		this.name = name;
		this.city = city;
	}
	
	
	

	public Student(Integer id, String name, String city, List<Student> lovers) {
		super();
		this.id = id;
		this.name = name;
		this.city = city;
		this.lovers = lovers;
	}


	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public String getCity() {
		return city;
	}

	public void setCity(String city) {
		this.city = city;
	}


	public List<Student> getLovers() {
		return lovers;
	}


	public void setLovers(List<Student> lovers) {
		this.lovers = lovers;
	}

	@Override
	public String toString() {
		return "Student [city=" + city + ", id=" + id + ", lovers=" + lovers
				+ ", name=" + name + "]";
	}
	
}

 
package com.baidu.test.other;

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

import org.msgpack.annotation.MessagePackMessage;

@MessagePackMessage
public class Teacher implements Serializable{

	private static final long serialVersionUID = -2060550357305407661L;

	private Integer id;
	
	private String name;
	
	private String city;
	
	private List<Teacher> lovers;

	public Teacher(){}
	
	
	public Teacher(Integer id, String name, String city) {
		super();
		this.id = id;
		this.name = name;
		this.city = city;
	}
	
	
	

	public Teacher(Integer id, String name, String city, List<Teacher> lovers) {
		super();
		this.id = id;
		this.name = name;
		this.city = city;
		this.lovers = lovers;
	}


	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public String getCity() {
		return city;
	}

	public void setCity(String city) {
		this.city = city;
	}


	public List<Teacher> getLovers() {
		return lovers;
	}


	public void setLovers(List<Teacher> lovers) {
		this.lovers = lovers;
	}


	@Override
	public String toString() {
		return "Teacher [city=" + city + ", id=" + id + ", lovers=" + lovers
				+ ", name=" + name + "]";
	}



	
	
	
	
	
	
}

 
package com.baidu.test;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.baidu.test.other.Teacher;

/*


 一個JSON庫涉及的最基本功能就是序列化和反序列化。Fastjson支援java bean的直接序列化。
 使用com.alibaba.fastjson.JSON這個類進行序列化和反序列化。

 http://blog.csdn.net/yuanjian19900610/article/details/37737087
 */

public class TestFastJson {

	@SuppressWarnings("unchecked")
	public static void test002() {

		HashMap<String, Object> map = new HashMap<String, Object>();
		map.put("username", "zhangsan");
		map.put("age", 24);
		map.put("sex", "男");

		// map集合
		HashMap<String, Object> temp = new HashMap<String, Object>();
		temp.put("name", "xiaohong");
		temp.put("age", "23");
		map.put("girlInfo", temp);

		// list集合
		List<String> list = new ArrayList<String>();
		list.add("爬山");
		list.add("騎車");
		list.add("旅遊");
		map.put("hobby", list);

		/*
		 * JSON 序列化，預設序列化出的JSON字串中鍵值對是使用雙引號，如果需要單引號的JSON字串， [eg:String
		 * jsonString =
		 * JSON.toJSONString(map,SerializerFeature.UseSingleQuotes);]
		 * fastjson序列化時可以選擇的SerializerFeature有十幾個屬性，你可以按照自己的需要去選擇使用。
		 */
		String jsonString = JSON.toJSONString(map);
		System.out.println("JSON=" + jsonString);

		// 反序列化
		HashMap<String, Object> map_unserial = JSON.parseObject(jsonString,
				HashMap.class);

		System.out.println(map_unserial);

	}

	public static void main(String[] args) {

		test001();
		 test002();
		test003();
		test004();

	}

	// 日期格式化
	public static void test003() {

		Date date = new Date();
		// 輸出毫秒值
		System.out.println(JSON.toJSONString(date));
		// 預設格式為yyyy-MM-dd HH:mm:ss
		System.out.println(JSON.toJSONString(date,
				SerializerFeature.WriteDateUseDateFormat));
		// 根據自定義格式輸出日期
		System.out.println(JSON.toJSONStringWithDateFormat(date, "yyyy-MM-dd",
				SerializerFeature.WriteDateUseDateFormat));

	}

	/** 泛型的反序列化 */
	public static void test004() {
		String json = "{\"user\":{\"city\":\"來自北京\",\"name\":\"zhangsan\",\"id\":25}}";
		Map<String, Student> map = JSON.parseObject(json,
				new TypeReference<Map<String, Student>>() {
				});
		System.out.println(map.get("user"));

	}

	private static void test001() {
		Student studentLover = new Student(11, "name_wjh", "beijing");

		List<Student> lovers = new ArrayList<Student>();
		lovers.add(studentLover);
		lovers.add(new Student(12, "name_wjh", "北京"));
		lovers.add(new Student(13, "name_wjh", "上海"));

		Student student = new Student(1, "name_xx", "南寧", lovers);
		// System.out.println(JSON.toJSONString(student,
		// SerializerFeature.QuoteFieldNames));
		// 序列化
		String result = JSON.toJSONString(student);
		System.out.println(result);
		// 反序列化
		Student student2 = JSON.parseObject(result, Student.class);
		System.out.println(student2);

		// fastjson 強大，可以直接反序列化為其他類,只要屬性名對應
		Teacher teacher = JSON.parseObject(result, Teacher.class);

		System.out.println(teacher);
	}

}

 
package com.baidu.test;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import android.util.Base64;

import com.baidu.test.other.Teacher;
import com.caucho.hessian.io.HessianInput;
import com.caucho.hessian.io.HessianOutput;

/*

 注意：

 1. 在Hessian遠端呼叫方法中，客戶端中的介面類必須和伺服器中的介面類一樣，方法名稱也一樣

 2. 在介面類中，不要寫重構的方法，Hessian不能識別重構的方法。

 3. 方法引數中，如果有自定義實體物件entity，則有以下幾注意點：

 a  entity的package名必須同伺服器上的package，否則會在服務端上報找不到此類

 b  entity必須是可序列化的，如果是組合物件，則可序列化應該可遞迴下去，除非不需要組合

 4. 方法返回值中，如果有自定義物件，同2，如果是集合物件，則為List(lists and arrays) & map(maps and dictionaries)

 5. Hessian 不支援檔案傳輸，如需要檔案傳輸，則傳遞資料流實現（下一文件說明）


 */
public class TestHessian {

	public static byte[] serialize(Object obj) throws IOException {
		if (obj == null)
			throw new NullPointerException();

		ByteArrayOutputStream os = new ByteArrayOutputStream();
		HessianOutput ho = new HessianOutput(os);
		ho.writeObject(obj);
		return os.toByteArray();
	}

	public static Object deserialize(byte[] by) throws IOException {
		if (by == null)
			throw new NullPointerException();

		ByteArrayInputStream is = new ByteArrayInputStream(by);
		HessianInput hi = new HessianInput(is);
		return hi.readObject();
	}

	public static void main(String[] args) throws Exception {

		List<Student> students = new ArrayList<Student>();
		students.add(new Student(11, "name_wjh", "北京11"));
		students.add(new Student(12, "name_wjh", "北京"));
		students.add(new Student(13, "name_wjh", "上海"));
		Student myStudent = new Student(10, "xx", "xxx", students);
		System.out.println(myStudent);
		byte[] buffer = serialize(myStudent);
		String str = Base64.encodeToString(buffer, Base64.DEFAULT);
		System.out.println(str);
		Student student = (Student) deserialize(Base64.decode(str,
				Base64.DEFAULT));
		System.out.println(student);

		// 不能轉換為其他類
		Teacher teacher = (Teacher) deserialize(Base64.decode(str,
				Base64.DEFAULT));
		System.out.println(teacher);

	}
}

package com.baidu.test;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import org.codehaus.jackson.map.ObjectMapper;

import com.baidu.test.other.Teacher;

//http://blog.csdn.net/subuser/article/details/19127003
public class TestJackson {

	public static void main(String[] args) throws Exception {

		List<Student> students = new ArrayList<Student>();

		students.add(new Student(11, "name_wjh", "北京11"));
		students.add(new Student(12, "name_wjh", "北京"));
		students.add(new Student(13, "name_wjh", "上海"));

		Student myStudent = new Student(10, "xx", "xxx", students);

		ObjectMapper mapper = new ObjectMapper();

		// convert user object to json string, and save to a file
		mapper.writeValue(new File("user.json"), myStudent);

	
		// read from file, convert it to user class
		Student student = mapper
				.readValue(new File("user.json"), Student.class);
		System.out.println(student);

		Teacher teacher = mapper
				.readValue(new File("user.json"), Teacher.class);
		System.out.println(teacher);
		
		//
		String data=mapper.writeValueAsString(myStudent);
		System.out.println(data);
		Student student2=mapper.readValue(data.getBytes(), Student.class);
		System.out.println(student2);
		
		Teacher teacher2=mapper.readValue(data.getBytes(), Teacher.class);
		System.out.println(teacher2);


	}
}

package com.baidu.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.baidu.test.other.Teacher;

import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;

// http://json-lib.sourceforge.net/
public class testJsonlib {

	public static void main(String[] args) {
		

		List<Student> students = new ArrayList<Student>();
		students.add(new Student(11, "name_wjh", "北京11"));
		students.add(new Student(12, "name_wjh", "北京"));
		students.add(new Student(13, "name_wjh", "上海"));
		Student myStudent = new Student(10, "xx", "xxx", students);
		
		JSONObject js = JSONObject.fromObject(myStudent);  
		String str=js.toString();
        System.out.println(str);  
        
        JSONObject jsonObject = JSONObject.fromObject(str);  
        
        /*
        JsonConfig jsonConfig = new JsonConfig();  
  
        jsonConfig.setRootClass(Student.class);  
        Map<String, Class> classMap = new HashMap<String, Class>();  
        classMap.put("lovers", Student.class); // 指定JsonRpcRequest的request欄位的內部型別  
        jsonConfig.setClassMap(classMap);  
          */
        Student student = (Student) JSONObject.toBean(jsonObject, Student.class);         
        System.out.println(student); 
        //不好用
        Teacher teacher = (Teacher) JSONObject.toBean(jsonObject, Teacher.class);         
        System.out.println(teacher); 
        
        
	}
}

package com.baidu.test;


import java.util.ArrayList;
import java.util.List;

import android.util.Base64;

import com.baidu.test.other.Teacher;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.Registration;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;

public class TestKryo {

	private static void test001() {
		
		Kryo kryo = new Kryo();
		// kryo.setReferences(true);
		// kryo.setRegistrationRequired(true);
		// kryo.setInstantiatorStrategy(new StdInstantiatorStrategy());
		// 註冊類
		Registration registration = kryo.register(Student.class);
		long time = System.currentTimeMillis();
		for (int i = 0; i < 2; i++) {
			// 序列化
			Output output = null;
			// ByteArrayOutputStream outStream = new ByteArrayOutputStream();
			// output = new Output( outStream , 4096);
			output = new Output(1, 4096);
			List<Student> students = new ArrayList<Student>();

			students.add(new Student(11, "name_wjh", "北京11"));
			students.add(new Student(12, "name_wjh", "北京"));
			students.add(new Student(13, "name_wjh", "上海"));

			Student myStudent = new Student(10, "xx", "xxx", students);

			kryo.writeObject(output, myStudent);
			byte[] bb = output.toBytes();
			output.flush();

			String str=Base64.encodeToString(bb, Base64.DEFAULT);
			System.out.println(str);
			
			// 反序列化
			Input input = new Input(Base64.decode(str, Base64.DEFAULT));
			Student s = (Student) kryo.readObject(input, registration.getType());
			System.out.println(s);
			input.close();
			// 反序列化為其他類
			input = new Input(Base64.decode(str, Base64.DEFAULT));
			Teacher teacher = (Teacher) kryo.readObject(input, Teacher.class);
			System.out.println(teacher);
			input.close();
		}
		time = System.currentTimeMillis() - time;
		System.out.println("time:" + time);
	}

	public static void main(String[] args) throws Exception {

		test001();
	}

}

package com.baidu.test;


import java.util.ArrayList;
import java.util.List;

import org.msgpack.MessagePack;

import com.baidu.test.other.Teacher;

import android.util.Base64;

public class TestMsgpack {

	public static void main(String[] args) throws Exception {

		List<Student> students = new ArrayList<Student>();

		students.add(new Student(11, "name_wjh", "北京11"));
		students.add(new Student(12, "name_wjh", "北京"));
		students.add(new Student(13, "name_wjh", "上海"));

		Student myStudent = new Student(10, "xx", "xxx", students);

		// Serialize
		byte[] raw = MessagePack.pack(myStudent);

		String str = Base64.encodeToString(raw, Base64.DEFAULT);
		System.out.println(str);

		// Deserialize
		Student student = MessagePack.unpack(
				Base64.decode(str, Base64.DEFAULT), Student.class);
		System.out.println(student);
		
		// Deserialize other class
		Teacher teacher = MessagePack.unpack(
				Base64.decode(str, Base64.DEFAULT), Teacher.class);
		System.out.println(teacher);
		
		
	}

}

package com.baidu.test;

import java.util.ArrayList;
import java.util.List;

import org.msgpack.MessagePack;

import android.util.Base64;

import com.github.xsonorg.XSON;

public class TestXson {
	
	public static void main(String[] args) {
		
		List<Student> students = new ArrayList<Student>();

		students.add(new Student(11, "name_wjh", "北京11"));
		students.add(new Student(12, "name_wjh", "北京"));
		students.add(new Student(13, "name_wjh", "上海"));

		Student myStudent = new Student(10, "xx", "xxx", students);
		byte[] buffer=XSON.write(myStudent);
		//失敗
		String str = Base64.encodeToString(buffer, Base64.DEFAULT);
		System.out.println(str);

		Student student=XSON.parse(Base64.decode(str, Base64.DEFAULT));
		System.out.println(student);
		
		
		
	}

}

相關推薦

java 常用序列化和反序列化框架使用-json，kyro，jdk

不知道為什麼部落格不能收藏了，只好轉載過來。 轉載地址：http://blog.csdn.net/earbao/article/details/46914407 package com.baidu.test;   import java.io

java 常用序列化和反序列化框架使用demo

package com.baidu.test; import java.io.Serializable; import java.util.List; import org.msgpack.annotation.MessagePackMessage; //Msgpac

java中什麽是序列化和反序列化

zab question .com 程序 還原 破壞 ans 但我 實現 序列化:能夠把一個對象用二進制的表示出來。 類似我第一個字節表示什麽屬性名詞，第二個字節表示什麽屬性值，第幾個字段表示有幾個屬性等。 而且這個二進制可以寫到硬

java中的序列化和反序列化學習筆記

文件 track 反序列化 out val nts 鼠標 main version 須要序列化的Person類： package cn.itcast_07; import java.io.Serializable; /* * NotSerializableE

java對象的序列化和反序列化

底層 修飾 我們 puts nbsp tostring read one asics 一，對象的序列化，反序列化1.對象的序列化，就是將Object轉換成byte序列，反之叫對象的反序列化2.做序列化需要有流類，序列化流(ObjectOutputStream),是(字節的)

java基礎序--列化和反序列化

color tran public png gin jdk style 硬盤 brush 一、什麽是序列化和反序列化: 　　序列化：是指把java堆內存中的對象轉換成字節（二進制流）的過程。也就是通過某種方式將java對象存儲在磁盤內存中，這個過程稱為序列化 　　反序列化：

2018-07-25期 Java序列化和反序列化編程小案例

測試 product set pri get sof serial span not package cn.sjq.Serializable.java;import java.io.FileInputStream;import java.io.FileOutputStrea

Java 之 Serializable 序列化和反序列化的概念,作用的通俗易懂的解釋

計算 transient 全部 序列化對象 語義 meta person int 較高的 遇到這個 Java Serializable 序列化這個接口，我們可能會有如下的問題a，什麽叫序列化和反序列化b，作用。為啥要實現這個 Serializable 接口，也就是為啥要序列

Java-裝飾流-物件流 - 序列化和反序列化

ObjectInputStream(反序列化) & ObjectOutputStream（序列化） 1.先寫出後讀取 2.讀取的順序必須保持一致 3.不是所有的物件都能序列化，要加上serializable接口才行 當不想對物件中的某個屬性序列化時，在屬性中新增transie

java序列化和反序列化物件

import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; impo

Java 之 Serializable 序列化和反序列化的概念 通俗易懂！！！

轉自： https://blog.csdn.net/qq_27093465/article/details/78544505 遇到這個 Java Serializable 序列化這個介面，我們可能會有如下的問題a，什麼叫序列化和反序列化 b，作用。為啥要實現這個 Serializable

Java中使用FastJSON進行物件的序列化和反序列化

Java中使用FastJSON進行物件的序列化和反序列化 1.新增依賴，maven的pom.xml檔案中新增以下依賴 <dependency> <groupId>com.alibaba</groupId> <arti

記一次使用Jackson對Java物件序列化和反序列化的踩坑經歷

背景大概是這樣，專案中的兩個服務A和B依賴了同一個common包的Java類，A對該類json序列化，而B對其反序列化。在一次common包升級過程中，這個Java類中增加了一個屬性，由於B其實用不到這個屬性，就只把A給升級打包了，這就導致B在反序列化時出現了一個異常：com.fasterxml.j

Think In Java——序列化和反序列化

1）Java中的Serializable介面和Externalizable介面有什麼區別？ 這個是面試中關於Java序列化問的最多的問題。我的回答是，Externalizable介面提供了兩個方法writeExternal()和readExternal()。這兩個方法給我們

java物件的序列化和反序列化

引言： 　　序列化是將物件的狀態資訊轉換為可以儲存或傳輸的形式的過程，在序列化期間，物件將其帶你過去的狀態寫入到臨時或持儲存區，反序列化就是重新建立物件的過程，此物件來自於臨時或持久儲存區。 序列化的作用： 　　就好比如儲存資料到資料庫，將一些資料持久化到資料庫中，而有時候需要將物件持久化，雖然說將物件狀態持

【修真院java小課堂】什麼是序列化和反序列化，在RMI中是否要實現 SERIALIZABLE 介面， SERIALVERSIONUID的用處是什麼？

8.更多討論 1、serialVersionUID實際作用 假設本地資料庫中儲存了大量的user物件，後來由於需求，要修改User類中的屬性；如果不設定SerialVersionUID，根據屬性方法等自動生成，就會出現程式碼演示中的錯誤，造

Java序列化和反序列化存在的意義

文章來源: 一 javabean為什麼要實現序列化? 所謂的Serializable,就是java提供的通用資料儲存和讀取的介面。至於從什麼地方讀出來和儲存到哪裡去都被隱藏在函式引數的背後了。這樣子，任何型別只要實現了Serializable介面，就可以被儲存

在Java中進行序列化和反序列化

物件序列化的目標是將物件儲存在磁碟中，或者允許在網路中直接傳輸物件。     物件序列化允許把記憶體中的Java物件轉換成平臺無關的二進位制流，從而允許把這種二進位制流持久儲存在磁碟上或者通過網路將這種二進位制流傳輸到另外一個網路節點。     其他程式一旦

《程式設計師程式碼面試指南》二叉樹的序列化和反序列化——java實現

二叉樹的序列化和反序列化 題目描述： 二叉樹被記錄成檔案的過程叫作二叉樹的序列化，通過檔案內容重建原來二叉樹的過程叫作二叉樹的反序列化。 給定一棵二叉樹的頭節點head，並已知二叉樹節點值的型別為32位整型。請設計一種二叉樹序列化和反序列化的方案，並用程式碼實現

java的序列化和反序列化

java提供了兩種物件持久化的方式,分別是序列化和反序列化 序列化 當進行遠端通訊時,無論是何種型別的資料,都會以二進位制的形式在網路上傳輸.序列化是將物件描述為一連串位元組的過程,用來解決物件流的讀寫問題.序列化可以將物件的狀態寫在流裡進行網路傳輸,或者儲存在檔案.資料