欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java对象的XML序列化与反序列化实例解析

程序员文章站 2024-04-02 07:58:52
上一篇文章我们介绍了,本文我们看看java对象的xml序列化与反序列化的相关内容,具体如下。 xml是一种标准的数据交换规范,可以方便地用于在应用之间交换各类数据。如果能...

上一篇文章我们介绍了,本文我们看看java对象的xml序列化与反序列化的相关内容,具体如下。

xml是一种标准的数据交换规范,可以方便地用于在应用之间交换各类数据。如果能在java对象和xml文档之间建立某种映射,例如java对象的xml序列化和反序列化,那么就可以使java的对象方便地与其他应用进行交换。

java.beans包里面有两个类xmlencoder和decoder,分别用于将符合jababeans规范的java对象以xml方式序列化和反序列化。以下代码显示了如何使用这两个类实现java对象的xml编码和解码。

待序列化的java类:

import java.io.serializable;
public class serialableobject implements serializable 
{
	private static final long serialversionuid = 8745578444312339136l;
	public serialableobject() 
	  {
	}
	public serialableobject(int id, string name, double value) 
	  {
		this.id = id;
		this.name = name;
		this.value = value;
	}
	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 double getvalue() 
	  {
		return value;
	}
	public void setvalue(double value) 
	  {
		this.value = value;
	}
	private int id;
	private string name;
	private double value;
}

xml序列化和反序列化用法演示类:

import java.beans.xmldecoder;
import java.beans.xmlencoder;
import java.io.file;
import java.io.fileinputstream;
import java.io.filenotfoundexception;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.io.outputstream;
import java.util.list;
import java.util.vector;
public class xmlserialize 
{
	public xmlserialize() 
	  {
	}
	public void serializesingleobject(outputstream os, object obj)    // 序列化单个java对象 
	{
		// xmlencoder xe = new xmlencoder(os); 
		xmlencoder xe = new xmlencoder(os, "gbk", true, 0);
		// 仅用于java se 7 
		xe.writeobject(obj);
		// 序列化成xml字符串 
		xe.close();
	}
	public object deserializesingleobject(inputstream is)    // 反序列化单个java对象 
	{
		xmldecoder xd = new xmldecoder(is);
		object obj = xd.readobject();
		// 从xml序列中解码为java对象 
		xd.close();
		return obj;
	}
	public void serializemultipleobject(outputstream os, list<object> objs)    // 序列化多个java对象 
	{
		xmlencoder xe = new xmlencoder(os);
		xe.writeobject(objs);
		// 序列化成xml字符串 
		xe.close();
	}
	public list<object> deserializemultipleobject(inputstream is)    // 反序列化多个java对象 
	{
		xmldecoder xd = new xmldecoder(is);
		@suppresswarnings("unchecked") 
		   list<object> objs = (list<object>)xd.readobject();
		// 从xml序列中解码为java对象列表 
		xd.close();
		return objs;
	}
	public void runsingleobject() 
	  {
		file xmlfile = new file("object.xml");
		serialableobject jo4out = new serialableobject(1, "java序列化为xml", 3.14159265359);
		// 创建待序列化的对象 
		try 
		   {
			fileoutputstream ofs = new fileoutputstream(xmlfile);
			// 创建文件输出流对象 
			serializesingleobject(ofs, jo4out);
			ofs.close();
		}
		catch (filenotfoundexception e) 
		   {
			e.printstacktrace();
		}
		catch (ioexception e) 
		   {
			e.printstacktrace();
		}
		try 
		   {
			fileinputstream ifs = new fileinputstream(xmlfile);
			serialableobject jo4in = (serialableobject)deserializesingleobject(ifs);
			system.out.println("id: " + jo4in.getid());
			system.out.println("name: " + jo4in.getname());
			system.out.println("value: " + jo4in.getvalue());
		}
		catch (filenotfoundexception e) 
		   {
			e.printstacktrace();
		}
	}
	public void runmultipleobject() 
	  {
		file xmlfile = new file("objects.xml");
		list<serialableobject> sos4out = new vector<serialableobject>();
		sos4out.add(new serialableobject(1, "java序列化为xml - 1", 3.14));
		// 创建待序列化的对象 
		sos4out.add(new serialableobject(2, "java序列化为xml - 2", 3.14159));
		// 创建待序列化的对象 
		sos4out.add(new serialableobject(3, "java序列化为xml - 3", 3.1415926));
		// 创建待序列化的对象 
		sos4out.add(new serialableobject(4, "java序列化为xml - 4", 3.141592653));
		// 创建待序列化的对象 
		sos4out.add(new serialableobject(5, "java序列化为xml - 5", 3.14159265359));
		// 创建待序列化的对象 
		try 
		   {
			fileoutputstream ofs = new fileoutputstream(xmlfile);
			// 创建文件输出流对象 
			serializesingleobject(ofs, sos4out);
			ofs.close();
		}
		catch (filenotfoundexception e) 
		   {
			e.printstacktrace();
		}
		catch (ioexception e) 
		   {
			e.printstacktrace();
		}
		try 
		   {
			fileinputstream ifs = new fileinputstream(xmlfile);
			@suppresswarnings("unchecked") 
			     list<serialableobject> sos4in = (list<serialableobject>)deserializesingleobject(ifs);
			for (serialableobject jo4in : sos4in) 
			     {
				system.out.println("id: " + jo4in.getid());
				system.out.println("name: " + jo4in.getname());
				system.out.println("value: " + jo4in.getvalue());
			}
		}
		catch (filenotfoundexception e) 
		   {
			e.printstacktrace();
		}
	}
	public static void main(string[] args) 
	  {
		xmlserialize xs = new xmlserialize();
		xs.runsingleobject();
		xs.runmultipleobject();
	}
}

需要注意的是,待序列化的类必须要符合javabeans的格式规范,即:具有一个无参的public构造函数,所有数据成员的访问均采用getter/setter模式,此外,这个类必须是public的,并且实现了java.io.serializable接口。

程序运行之后,会产生两个文件:

object.xml是runsingleobject方法生成的,存放了单个的serialableobject的值:

<?xml version="1.0" encoding="gbk"?> 
<java version="1.7.0" class="java.beans.xmldecoder"> 
 <object class="serialableobject"> 
 <void property="id"> 
  <int>1</int> 
 </void> 
 <void property="name"> 
  <string>java序列化为xml</string> 
 </void> 
 <void property="value"> 
  <double>3.14159265359</double> 
 </void> 
 </object> 
</java>  

objects.xml是runmultipleobject方法产生的,存放了5个serializableobject的值:

<?xml version="1.0" encoding="gbk"?> 
<java version="1.7.0" class="java.beans.xmldecoder"> 
 <object class="java.util.vector"> 
 <void method="add"> 
  <object class="serialableobject"> 
  <void property="id"> 
   <int>1</int> 
  </void> 
  <void property="name"> 
   <string>java序列化为xml - 1</string> 
  </void> 
  <void property="value"> 
   <double>3.14</double> 
  </void> 
  </object> 
 </void> 
 <void method="add"> 
  <object class="serialableobject"> 
  <void property="id"> 
   <int>2</int> 
  </void> 
  <void property="name"> 
   <string>java序列化为xml - 2</string> 
  </void> 
  <void property="value"> 
   <double>3.14159</double> 
  </void> 
  </object> 
 </void> 
 <void method="add"> 
  <object class="serialableobject"> 
  <void property="id"> 
   <int>3</int> 
  </void> 
  <void property="name"> 
   <string>java序列化为xml - 3</string> 
  </void> 
  <void property="value"> 
   <double>3.1415926</double> 
  </void> 
  </object> 
 </void> 
 <void method="add"> 
  <object class="serialableobject"> 
  <void property="id"> 
   <int>4</int> 
  </void> 
  <void property="name"> 
   <string>java序列化为xml - 4</string> 
  </void> 
  <void property="value"> 
   <double>3.141592653</double> 
  </void> 
  </object> 
 </void> 
 <void method="add"> 
  <object class="serialableobject"> 
  <void property="id"> 
   <int>5</int> 
  </void> 
  <void property="name"> 
   <string>java序列化为xml - 5</string> 
  </void> 
  <void property="value"> 
   <double>3.14159265359</double> 
  </void> 
  </object> 
 </void> 
 </object> 
</java> 

总结

以上就是本文关于java对象的xml序列化与反序列化实例解析的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站:java编程redisson实现分布式锁代码示例java编程ssh整合常见错误解析等,有什么问题可以随时留言,小编会及时回复大家的。下面推荐几本java编程相关的书籍,供大家参考,免费下载哦:

写给大忙人看的java核心技术 ([美]凯·s·霍斯特曼) 中文pdf扫描版

java vector类源代码与分析 word版

希望大家能够喜欢,更多精彩内容尽在: