webservice（四）有关xml的操作（基于JAXBContext 的xml和对象的转换）

最新推荐文章于 2024-07-12 14:46:37 发布
最新推荐文章于 2024-07-12 14:46:37 发布
阅读量885 收藏
点赞数
分类专栏： webservice 文章标签： xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/devilzy2656/article/details/8362740
版权 
<span>JAXBContext 来完成xml和对象的转换操作
</span>
package org.xml;

public class Classroom {

	private int id;
	private String name;
	private int grade;
	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 int getGrade() {
		return grade;
	}
	public void setGrade(int grade) {
		this.grade = grade;
	}
	public Classroom() {
		super();
	}
	public Classroom(int id, String name, int grade) {
		super();
		this.id = id;
		this.name = name;
		this.grade = grade;
	}
}


package org.xml;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Student {

	private int id;
	private String name;
	private int age;
	private Classroom classroom;
	
	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 int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Classroom getClassroom() {
		return classroom;
	}
	public void setClassroom(Classroom classroom) {
		this.classroom = classroom;
	}
	public Student(int id, String name, int age, Classroom classroom) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.classroom = classroom;
	}
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
}


package org.xml;

import java.io.StringReader;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

import org.junit.Test;

public class TestJaxb {
	@Test
	public void test01(){
		try {
			JAXBContext ctx = JAXBContext.newInstance(Student.class);
			//编排：把对象转换成xml
			Marshaller marshaller = ctx.createMarshaller();
			Student stu = new Student(1, "zhangsan", 21, new Classroom(1, "计算机", 2010));
			marshaller.marshal(stu, System.out);
		} catch (JAXBException e) {
			e.printStackTrace();
		}
	}
	@Test
	public void test02(){
		try {
			JAXBContext ctx = JAXBContext.newInstance(Student.class);
			String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><student><age>21</age><classroom><grade>2010</grade><id>1</id><name>计算机</name></classroom><id>1</id><name>zhangsan</name></student>";
			//编排：把对象转换成xml
			Unmarshaller unmarshaller = ctx.createUnmarshaller();
			Student stu = (Student) unmarshaller.unmarshal(new StringReader(xml));
			System.out.println(stu.getName()+stu.getClassroom().getName());;
		} catch (JAXBException e) {
			e.printStackTrace();
		}
	}
}


基于Stax的对xml文件进行读取和更改操作

<?xml version="1.0" encoding="UTF-8"?>

<bookstore>

<book category="COOKING">
  <title lang="en">Everyday Italian</title>
  <author>Giada De Laurentiis</author>
  <year>2005</year>
  <price>30.00</price>
</book>

<book category="CHILDREN">
  <title lang="en">Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>

<book category="WEB">
  <title lang="en">XQuery Kick Start</title>
  <author>James McGovern</author>
  <author>Per Bothner</author>
  <author>Kurt Cagle</author>
  <author>James Linn</author>
  <author>Vaidyanathan Nagarajan</author>
  <year>2003</year>
  <price>49.99</price>
</book>

<book category="WEB">
  <title lang="en">Learning XML</title>
  <author>Erik T. Ray</author>
  <year>2003</year>
  <price>39.95</price>
</book>

</bookstore>

package org.xml.stax;

import java.io.IOException;
import java.io.InputStream;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.EventFilter;
import javax.xml.stream.FactoryConfigurationError;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.stream.events.XMLEvent;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;

import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
 * 基于光标的
 * 都是java的api提供的
 */
public class TestStax {
	
	/**
	 * 输出节点类型的表示数字
	 * 基于光标的方式
	 */
	@Test
	public void test01(){
		XMLInputFactory factory = XMLInputFactory.newInstance();
		InputStream is = null;
		try {
			is = TestStax.class.getResourceAsStream("books.xml");
			XMLStreamReader reader = factory.createXMLStreamReader(is);
			while (reader.hasNext()) {
				int type = reader.next();
				if (type == XMLStreamConstants.START_ELEMENT) {
					System.out.println(reader.getName());
				}else if (type == XMLStreamConstants.CHARACTERS) {
					System.out.println(reader.getText().trim());
				}else if (type == XMLStreamConstants.END_ELEMENT) {
					System.out.println(reader.getName());
				}
			}
		} catch (FactoryConfigurationError e) {
			e.printStackTrace();
		} catch (XMLStreamException e) {
			e.printStackTrace();
		}finally{
			if (is!=null) {
				try {
					is.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	/**
	 * 输出存在的书的类型
	 * 基于光标的方式
	 */
	@Test
	public void test02(){
		XMLInputFactory factory = XMLInputFactory.newInstance();
		InputStream is = null;
		try {
			is = TestStax.class.getResourceAsStream("books.xml");
			XMLStreamReader reader = factory.createXMLStreamReader(is);
			while (reader.hasNext()) {
				int type = reader.next();
				if (type == XMLStreamConstants.START_ELEMENT) {
					String name = reader.getName().toString();
					if (name.equals("book")) {
						System.out.println(reader.getAttributeName(0)+":"+reader.getAttributeValue(0));
					}
				}
			}
		} catch (FactoryConfigurationError e) {
			e.printStackTrace();
		} catch (XMLStreamException e) {
			e.printStackTrace();
		}finally{
			if (is!=null) {
				try {
					is.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	/**
	 * 输出存在的书的类型
	 * 基于光标的方式
	 */
	@Test
	public void test03(){
		XMLInputFactory factory = XMLInputFactory.newInstance();
		InputStream is = null;
		try {
			is = TestStax.class.getResourceAsStream("books.xml");
			XMLStreamReader reader = factory.createXMLStreamReader(is);
			while (reader.hasNext()) {
				int type = reader.next();
				//判断节点类型是否是开始或者结束或者文本节点，之后根据情况进行处理
				//基于光标的方式
				if (type == XMLStreamConstants.START_ELEMENT) {
					String name = reader.getName().toString();
					if (name.equals("title")) {
						System.out.println(reader.getAttributeName(0)+":"+reader.getAttributeValue(0));
						System.out.print(reader.getElementText()+":");
					}
					if (name.equals("price")) {
						System.out.println(reader.getElementText()+":");
					}
				}
			}
		} catch (FactoryConfigurationError e) {
			e.printStackTrace();
		} catch (XMLStreamException e) {
			e.printStackTrace();
		}finally{
			if (is!=null) {
				try {
					is.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	/**
	 * 输出存在的书的类型
	 * 基于迭代的方式
	 */
	@Test
	public void test04(){
		XMLInputFactory factory = XMLInputFactory.newInstance();
		InputStream is = null;
		try {
			is = TestStax.class.getResourceAsStream("books.xml");
			//基于迭代模型的操作方式
			XMLEventReader reader = factory.createXMLEventReader(is);
			int num = 0;
			while (reader.hasNext()) {
				//通过XMLEvent来获取是否是某种节点
				XMLEvent event = reader.nextEvent();
				if (event.isStartElement()) {
					//通过event.asXxxxx来转换节点
					String name = event.asStartElement().getName().toString();
					if (name.equals("title")) {
						System.out.print(reader.getElementText()+":");
					}
					if (name.equals("price")) {
						System.out.println(reader.getElementText()+":");
					}
				}
				num++;
			}
			System.out.println("遍历次数："+num);
		} catch (FactoryConfigurationError e) {
			e.printStackTrace();
		} catch (XMLStreamException e) {
			e.printStackTrace();
		}finally{
			if (is!=null) {
				try {
					is.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	/**
	 * 输出存在的书的类型
	 * 过滤器
	 * 效率高于直接上述方法
	 */
	@Test
	public void test05(){
		XMLInputFactory factory = XMLInputFactory.newInstance();
		InputStream is = null;
		try {
			is = TestStax.class.getResourceAsStream("books.xml");
			//基于Filter的过滤方式，可以有效的过滤掉不进行操作的节点，效率会高
			XMLEventReader reader = factory.createFilteredReader(factory.createXMLEventReader(is), 
									new EventFilter() {
										@Override
										public boolean accept(XMLEvent event) {
											//返回true表示会显示，返回false表示不会显示
											if (event.isStartElement()) {
												String name = event.asStartElement().getName().toString();
												if ("title".equals(name)||"price".equals(name)) {
													return true;
												}
											}
											return false;
										}
									});
			int num = 0;
			while (reader.hasNext()) {
				//通过XMLEvent来获取是否是某种节点
				XMLEvent event = reader.nextEvent();
				if (event.isStartElement()) {
					//通过event.asXxxxx来转换节点
					String name = event.asStartElement().getName().toString();
					if (name.equals("title")) {
						System.out.print(reader.getElementText()+":");
					}
					if (name.equals("price")) {
						System.out.println(reader.getElementText()+":");
					}
				}
				num++;
			}
			System.out.println("遍历次数："+num);
		} catch (FactoryConfigurationError e) {
			e.printStackTrace();
		} catch (XMLStreamException e) {
			e.printStackTrace();
		}finally{
			if (is!=null) {
				try {
					is.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	/**
	 * 输出存在的书的类型
	 * DocumentBuilderFactory
	 * 可以读取部分文档
	 * 效率高于直接全部读取
	 */
	@Test
	public void test06(){
		InputStream is = null;
		try {
			is = TestStax.class.getResourceAsStream("books.xml");
			//创建文档对象
			DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
			//通过DocumentBuilder创建Document的文档处理对象
			Document doc = db.parse(is);
			//创建xpath
			XPath xPath = XPathFactory.newInstance().newXPath();
			//第一个参数是xpath,第二个参数是文档
			NodeList list = (NodeList) xPath.evaluate("//book[@category='WEB']", doc,XPathConstants.NODESET);
			//遍历输出的结果
			int length = list.getLength();
			for (int i=0;i<length;i++) {
				Element e = (Element)list.item(i);
				System.out.println(e.getElementsByTagName("title").item(0).getTextContent());
			}
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (XPathExpressionException e) {
			e.printStackTrace();
		}finally{
			if (is!=null) {
				try {
					is.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	/**
	 * 创建xml
	 */
	@Test
	public void test07(){
		try {
			XMLStreamWriter xsw = XMLOutputFactory.newInstance().createXMLStreamWriter(System.out);
			//版本号
			xsw.writeStartDocument("UTF-8","1.0");
			xsw.writeEndDocument();
			String ns = "http://aa:dd";
			xsw.writeStartElement("test", "person", ns);
			xsw.writeStartElement(ns,"id");
			xsw.writeCharacters("1");
			xsw.writeEndElement();
			xsw.writeEndElement();
			xsw.flush();
			xsw.close();
		} catch (XMLStreamException e) {
			e.printStackTrace();
		} catch (FactoryConfigurationError e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 使用transform来修改节点
	 */
	@Test
	public void test08(){
		InputStream is = null;
		try {
			is = TestStax.class.getResourceAsStream("books.xml");
			//创建文档对象
			DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
			//通过DocumentBuilder创建Document的文档处理对象
			Document doc = db.parse(is);
			//创建xpath
			XPath xPath = XPathFactory.newInstance().newXPath();
			Transformer tran = TransformerFactory.newInstance().newTransformer();
			//设置输出属性
			tran.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
			tran.setOutputProperty(OutputKeys.INDENT, "yes");
			//第一个参数是xpath,第二个参数是文档
			NodeList list = (NodeList) xPath.evaluate("//book[title='Harry Potter']", doc,XPathConstants.NODESET);
			//获取price节点
			Element book = (Element) list.item(0);
			Element price = (Element) (book.getElementsByTagName("price").item(0));
			price.setTextContent("55555");
			Result result = new StreamResult(System.out);
			//通过transform来修改代码
			tran.transform(new DOMSource(doc), result);
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (XPathExpressionException e) {
			e.printStackTrace();
		} catch (TransformerConfigurationException e) {
			e.printStackTrace();
		} catch (TransformerFactoryConfigurationError e) {
			e.printStackTrace();
		} catch (TransformerException e) {
			e.printStackTrace();
		}finally{
			if (is!=null) {
				try {
					is.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

}


阳小良
关注
专栏目录
使用JAXBContext将Xml转换成对象
qq_43707921的博客
06-22 1022
@XmlAccessorType(XmlAccessType.FIELD) @XmlType(name="标签名称", propOrder={属性名称}) @XmlRootElement public class OrderRequestMsgHeader { /** *@XmlElement里面的name跟xml里面的标签对应 */ @XmlElement(name="msgHeader", required=true) private MsgHeader msgHeader; @
WebService(一) XML与Java转换两种方式
zhuzige521888的博客
11-02 438
webservice相关技术分享
cxf框架的webservice，传递json,xml
03-13
cxf框架的webservice,可以完美运行，生成了xml字符串并进行传递以及生成了json对象，然后传递给客户端
webservice接口数据封装java对象转换为xml格式数据，解析工具
最新发布
karlif的博客
07-12 306
java对象转xml格式。
C# XML与对象互相转换
weixin_33835690的博客
06-26 1237
https://www.cnblogs.com/servant/p/4462446.html using System;using System.Collections.Generic;using System.Text;using System.Xml.Serialization;using System.IO;using System.Xml;namespace Common{...
WebService CXF学习（进阶篇4）：JAXB剖析
xuzhfa123
01-06 126
前面几节我们讲解对象传递，但是通常情况下我们不直接传对象，因为直接传递对象安全性差，而且暴露了实体对象。所以我们选择传递XML文件，当然也可以传递JSON对象。这节我只针对传递XML，那么JAVA绑定成XML，服务端将XML解析成Java对象有什么工具可用吗，其实这样的工具多的是。这里我选择一个比较简单的JAXB工具来讲解一下。 JAXB（Java Architecture fo...
webservice调用获取xml，并转换为对象
bngdyz的博客
11-23 3757
webservice获取方法 org.apache.axis.client.Service sv = new org.apache.axis.client.Service(); // new 一个服务 Call call = (Call) sv.createCall(); // 创建一个call对象 call.setTargetEndpointAddress(n...
webservice之使用jaxb把xml转换Object或把对象转换成xml文件
04-24
3. WebService：在开发基于SOAP的WebService时，JAXB常用于XML与Java对象的转换，使得数据交换更加便捷。 五、JAXB与其它XML处理技术对比 JAXB与其他XML处理技术（如DOM、SAX、StAX）相比，更注重于对象模型与XML...
JAXB工具类 xml转为java对象 java对象转为xml
05-17
Java Architecture for XML Binding (JAXB) 是Java平台中用于处理XML和Java对象之间转换的一个标准API。它使得在Java应用程序中使用XML数据变得更加方便，无需手动编写大量的转换代码。本教程将详细介绍JAXB如何实现...
javabean和xml互相转换工具类以及jar包
12-02
下面我们将详细探讨如何实现JavaBean到XML以及XML到JavaBean的转换，并介绍一个用于此目的的工具类和相关的jar包。 首先，JavaBean是一种符合特定规范的Java类，它通常具有公共的getter和setter方法，用于封装属性...
WebService系列博客{九}[JAXBContext---java和xml的互相转换]
zhang6622056的专栏
01-10 1万+
java和xml的互相转换,依靠强大的JAXBContext可以轻松实现。 下面通过一个简单案例学习一下JAXBContext 首先准备好一个JavaBean供实验: 注意 1、类文件注解：@XmlRootElement不可缺少 2、2个Student的构造方法不能少 @XmlRootElement public class Student { private Strin
通过JAXB请求和解析WebService
Stay hungry, Stay foolish
09-20 3324
转：http://herbaceous.iteye.com/blog/2096897     以WeatherWebService的getWeatherbyCityName SOAP1.2为例需要两个对象： 请求对象（GetWeatherbyCityName）响应对象（GetWeatherbyCityNameResponse）     Java代码  
【WebService】使用jaxb完成对象和xml的转换
weixin_33937499的博客
02-26 131
1 package com.slp.jxmarshaller; 2 3 /** 4 * Created by sanglp on 2017/2/26. 5 */ 6 public class ClassName { 7 private int id; 8 private String name; 9 private int gra...
CXF webservice JAXB 处理复杂数据类型方法
Just Code
08-14 1154
CXF webservice JAXB 处理复杂数据类型方法
通过JDK的JAXBContext类来转换java实体类bean和xml格式字符串的一些问题和解决办法
lorickz的博客
04-18 3664
    这两天工作中用到web service来推送数据，涉及到xml的和java实体类的转换，总结一下理解和碰到的问题。    （一）、宝宝想得到下面这样的两个xml类型的字符串anth和args，来推送给第三方：&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;base&gt; &lt;root&gt; &lt;user&gt;...
在开发过程遇到xml与java对象相互转化的问题（调用三方webService接口）----JAXB
mango
10-28 854
一、关于JAXB JAXB是干什么的？ JAXB可以实现xml格式与对象之间的相互转换 JAXB相关知识点 1、JABX相关的类 XmlType类：用于绑定java实体与XML之间的信息 Marshaller接口：将Java实体序列化为XML数据 Unmarshaller接口：将XML数据反序列化为Java对象 java实体与XML之间的相互转换最重要的就是后面两个接口。 2、JAXB相关注解 @XmlType @XmlAccessorType @XmlAccessOrder @XmlJavaTyp
XML与JSON互相转化工具类
热门推荐
weixin_44248490的博客
10-20 2万+
xml与json互相转化。 尤其是xml转化为json时，可以完美支持。还可根据需要将xml的节点转为json数组，功能强大
Java调用WebService接口----使用JAXBContent转化Bean与Xml
hober的专栏
10-09 3231
上一节使用SOAPMessage调用WebService接口，但是比较麻烦的是参数的拼装需要一个一个add，比较麻烦。此次介绍使用JAXBContent转化Bean与Xml，然后利用http请求（如Okhttp）发送Xml组装的报文。 目标 先看一下请求与结果： 再看一下本demo最终的类结构 bean目录分为request和response，代表的分别是请求和相应。 由于Xml有多层结点，...
WebService案例分析：基于XML的软件反馈跟踪平台
"该资源是一份关于XML技术与Web服务（Webservice）的案例分析，主要探讨了一个软件反馈跟踪平台的应用。案例展示了如何利用Web服务来收集和处理用户对软件产品的反馈，包括BUG报告和性能参数。" XML（eXtensible ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值