Java wsdl soap 自定义xml

转载

mob64ca140d61c6 2024-07-06 15:58:32

生成和解析XML

1. 什么是XML，XML的作用是什么，如何编写XML文件?
XML就是可扩展标记语言。与HTML相似都是标记语言。
XML提供的标记都是自定义的；HTML提供的标记都是预先定义好的。
XML用来存储数据的文本格式；HTML是同来设计网页。
XML是一种简单的数据存储语言。
如何编写XML文件?

一个简单的XML文件格式
<?xml version="1.0"  encoding=”utf-8”?>
<students>
<student  id=”1001” >
    	<name>zhangsan</name>
    	<age>23</age>
    	<sex>男</sex>
</student>
<student  id=”1002”>
    	<name>lisi</name>
    	<age>24</age>
    	<sex>女</sex>
</student>
</students>

说明:

<?xml version="1.0"  encoding=”utf-8”?>---xml的文件头,表示xml文档开始。与html中的“<!DOCTYPE html>”作用相似。【土地】
<students></students>----自定义的xml标记，表示一个xml文件的根元素。【树根】
<student  id=”1001” ></student>---自定义的xml标记，表示一个xml文件的根元素中的子元素。【树枝】
id=”1001”， id=”1002”----元素的属性，是一个键值对。
<name></name>，<age></age>，<sex></sex>---自定义的xml标记，表示一个xml文件的根元素中的子子元素。【树叶】
zhangsan，23，男...---都是被存储的具体数据值。【果实】

Java wsdl soap 自定义xml_XML

注意：

1.标记都是自定义的，成对出现“”
2.元素可以携带属性，属性是一个键值对，可以出现多个
例如：<小狗 id=”1001” color=”黑色”></小狗>
3.保存文件的时候，文件的后缀名是以“.xml”结尾

例如：

public class Person{
  private int  perid;
  private String  pername;
  private int perage;
  private String peraddress;
   ......
   getXXXX()/setXXXX();
}
Person  person1=new Person();
person1.setPerid(1001);
person1.setPername(“张三”);
person1.setPernage(23);
person1.setPernaddress(“西安”);
Person  person2=new Person();
person2.setPerid(1002);
person2.setPername(“李四”);
person2.setPernage(24);
person2.setPernaddress(“北京”);
List<Person>  personlist=new ArrayList<Person>();
personlist.add(person1);
personlist.add(person2);

请将上面的personlist集合转换成xml文件？

<?xml version="1.0"  encoding=”utf-8”?>
<personlist>
<person perid=”1001” >
    	<pername>张三</pername>
    	<perage>23</perage>
    	<peraddress>西安</peraddress>
</person>
<person perid=”1002” >
    	<pername>李四</pername>
    	<perage>24</perage>
    	<peraddress>北京</peraddress>
</person>
</personlist>

2. 常见的XML文件的生成方式和解析方式
2.1 XML文件的生成【Dom生成】
1.java默认的dom生成方式

package com.wangxing.XMLdemo1;

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

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

public class Help {
	/**
	 * XML解析
	 */
	public static void creatXMLByjavaDom(List<Person>Personlist)throws Exception{
		//得到DOM解析器工厂
		DocumentBuilderFactory  builderFactory=DocumentBuilderFactory.newInstance();
		//从解析器工厂的解析器
		DocumentBuilder documentBuilder=builderFactory.newDocumentBuilder();
		//得到Document对象
		Document document=documentBuilder.newDocument();
		//设置文件头
		document.setXmlStandalone(true);
		//得到根元素
		Element rootElement=document.createElement("personlist");
		//循环遍历集合，创建子元素，将子元素添加到根元素
		 for(Person person:Personlist){
			 //创建子元素
			 Element personElement=document.createElement("person");
			 //给子元素添加属性
			 personElement.setAttribute("perid",String.valueOf(person.getPerid()));
			 //创建子子元素
			 Element nameElement=document.createElement("pername");
			 Element ageElement=document.createElement("perage");
        	 Element addressElement=document.createElement("peraddress");
        	 //为子子元素添加数据值
        	 nameElement.setTextContent(person.getPername());
        	 ageElement.setTextContent(String.valueOf(person.getPerage()));
        	 addressElement.setTextContent(person.getPeraddress());
        	 //将子子元素添加到子元素
        	 personElement.appendChild(nameElement);
        	 personElement.appendChild(ageElement);
        	 personElement.appendChild(addressElement);
        	 //将子元素添加到根元素中
        	 rootElement.appendChild(personElement);
		 }
		 //将根元素添加到Document对象中
		 document.appendChild(rootElement);
         // 创建TransformerFactory对象
         TransformerFactory tff = TransformerFactory.newInstance();
         // 创建 Transformer对象
         Transformer tf = tff.newTransformer();
         // 输出内容是否使用换行
         tf.setOutputProperty(OutputKeys.INDENT, "yes");
         // 创建xml文件并写入内容
         tf.transform(new DOMSource(document), new StreamResult(new File("person1.xml")));

	} 
}

2.使用第三方开发包
A.dom4j

package com.wangxing.XMLdemo2;

import java.io.File;
import java.io.FileOutputStream;
import java.util.List;
import org.dom4j.*;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
public class Help {
	 /**
	  * 使用第三方开发包Dom4j
	  */
	public static void creatXMLByDom4j(List<Person> personlist)throws Exception {
		//得到Document对象
		Document document=DocumentHelper.createDocument();
		//创建根元素
		Element rootElement=document.addElement("personlist");
		//循环遍历集合，创建子元素，将子元素添加到根元素
		for(Person person:personlist){
			//创建子元素
			Element personElement=rootElement.addElement("person");
			//添加属性
			personElement.addAttribute("perid", String.valueOf(person.getPerid()));
			//创建子子元素
			Element nameElement=personElement.addElement("pername");
			Element ageElement=personElement.addElement("perage");
			Element addressElement=personElement.addElement("peraddress");
			//为子子元素设置数据值
			nameElement.setText(person.getPername());
			ageElement.setText(String.valueOf(person.getPerage()));
			addressElement.setText(person.getPeraddress());
		}
		//设置生成xml的格式
        OutputFormat format = OutputFormat.createPrettyPrint();
        // 设置编码格式
        format.setEncoding("UTF-8");
        //创建XML字符输出流
        XMLWriter writer = new XMLWriter(new FileOutputStream(new File("person2.xml")), format);
        //设置是否转义，默认使用转义字符
        writer.setEscapeText(false);
        //写出Document对象
        writer.write(document);
        //关闭流
        writer.close();

	}
}

B.jdom

package com.wangxing.XMLdemo3;

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

import org.jdom.*;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

public class Help {
	/**
	 * 使用第三方开发包.jdom
	 */
	public static void creatXMLByJdom(List<Person> personlist) throws Exception {
		// 创建根元素
		Element rootElement = new Element("personlist");
		for (Person person : personlist) {
			// 创建子元素
			Element personElement = new Element("person");
			// 设置属性
			personElement.setAttribute("perid", String.valueOf(person.getPerid()));
			// 创建子子元素
			Element nameElement = new Element("pername");
			Element ageElement = new Element("perage");
			Element addressElement = new Element("peraddress");
			// 为子子元素设置数据值
			nameElement.setText(person.getPername());
			ageElement.setText(String.valueOf(person.getPerage()));
			addressElement.setText(person.getPeraddress());
			// 将子子元素添加到子元素
			personElement.addContent(nameElement);
			personElement.addContent(ageElement);
			personElement.addContent(addressElement);
			// 将子元素添加到根元素
			rootElement.addContent(personElement);
		}
		// 依赖根元素创建Document
		Document document = new Document(rootElement);
		// 输出Document对象
		Format format = Format.getCompactFormat();
		// 设置换行Tab或空格
		format.setIndent("  ");
		format.setEncoding("UTF-8");
		// 创建XMLOutputter的对象
		XMLOutputter outputer = new XMLOutputter(format);
		// 写出Document
		outputer.output(document, new FileOutputStream(new File("person3.xml")));
	}
}

c.通过拼接字符串的方式创建一个xml文件

package com.wangxing.XMLdemo4;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.util.List;

public class Help {
	/**
	 * 使用拼接字符串的方式创建一个xml文件
	 */
	public  static void createXML4(List<Person>  personlist)throws Exception{
		//定义一个保存拼接好的字符串变量
		String  xmlcontent=null;
		//为了拼接字符串更加方便我们使用stringbuilder类拼接字符串
		StringBuilder  stringBuilder=new StringBuilder();
		stringBuilder.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
		stringBuilder.append("\r\n");
		stringBuilder.append("<personlist>");
		stringBuilder.append("\r\n");
		//遍历需要被生成成xml文件的集合
		for(Person  person:personlist){
			stringBuilder.append("\t<person  perid=\""+person.getPerid()+"\">");
			stringBuilder.append("\r\n");
			stringBuilder.append("\t\t<pername>"+person.getPername()+"</pername>");
			stringBuilder.append("\r\n");
			stringBuilder.append("\t\t<perage>"+person.getPerage()+"</perage>");
			stringBuilder.append("\r\n");
			stringBuilder.append("\t\t<peraddress>"+person.getPeraddress()+"</peraddress>");
			stringBuilder.append("\r\n");
			stringBuilder.append("\t</person>");
			stringBuilder.append("\r\n");
		}
		stringBuilder.append("<personlist>");
		xmlcontent=stringBuilder.toString();
		System.out.println(xmlcontent);
		//创建输出流对象，将创建好的xml，保存到文件中
		File file=new File("F:"+File.separator+"personlist.xml");
		BufferedWriter  out=new BufferedWriter(new FileWriter(file));
		out.write(xmlcontent);
		out.close();
	}
}

2.2 XML文件的解析
实际上就是将xml文件中保存的数据取出，转换成java对象

DOM（Document Object Model)解析
Java默认的Dom / dom4j / jdom
将整个xml文件读取成一个Document对象，然后从Document对象中得到根元素，再从根元素中得到子元素，接着从子元素中得到子子元素，最后从子子元素中得到数据值。

package com.wangxing.XMLdemo1;

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

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class util {
	/**
	 * java默认的dom
	 * 解析xml
	 */
	public static List<Person> parseXMLByDom()throws Exception {
		//定义保存对象的集合
		List<Person> personlist=new ArrayList<Person>();
		//得到解析器工厂发
		DocumentBuilderFactory builderFactory=DocumentBuilderFactory.newInstance();
		//得到解析器对象
		DocumentBuilder documentBuilder=builderFactory.newDocumentBuilder();
		//将需要被解析的xml文件读取成Document对象
		Document document=documentBuilder.parse(new File("person1.xml"));
		//从Document对象中取出一组子元素
		NodeList personNodeList=document.getElementsByTagName("person");;
		for(int i=0;i<personNodeList.getLength();i++){
			//创建Person对象用来保存解析出的数据值
    		Person  person=new Person();
	    	//得到子元素
	    	Node  personNode=personNodeList.item(i);
	    	//得到默认的属性值
	    	String perid=personNode.getAttributes().item(0).getNodeValue();
	    	person.setPerid(Integer.parseInt(perid));
	    	//从子元素中得到包含有子子元素的一组集合
	    	NodeList nodeList=personNode.getChildNodes();
	    	for(int j=0;j<nodeList.getLength();j++) {
	    		//得到子子元素
	    		Node  node=nodeList.item(j);
	    		//得到子子元素的文本值
	    		if(node.getNodeName().equals("pername")) {
	    			String pername=node.getTextContent();
	    			person.setPername(pername);
	    		}
	    		if(node.getNodeName().equals("perage")) {
	    			String perage=node.getTextContent();
	    			person.setPerage(Integer.parseInt(perage));
	    		}
	    		if(node.getNodeName().equals("peraddress")) {
	    			String peraddress=node.getTextContent();
	    			person.setPeraddress(peraddress);
	    		}
	    	}
	    	//将解析好的person对象装入集合
	    	personlist.add(person);
	    }
		return personlist;
	}
}

使用dom4j解析xml

package com.wangxing.XMLdemo3;

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

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;

public class util {
	/**
	 * 使用jdom解析xml
	 */
	public static List<Person> parseXMLByJdome()throws Exception {
		//定义保存对象的集合
		List<Person> personlist=new ArrayList<Person>();
		//得到解析器对象
		SAXBuilder saxBuilder=new SAXBuilder();
		//读取被解析的xml文件成document
		Document  document=saxBuilder.build(new File("person3.xml"));
		//得到根元素
		Element  rootElement= document.getRootElement();
		//从根元素中得到一组person的子元素
		List<Element>  elementList=rootElement.getChildren("person");
		for(Element personElement:elementList){
			Person  person=new Person();
			//得到属性
			int perid=Integer.parseInt(personElement.getAttributeValue("perid"));
			person.setPerid(perid);
			String pername=personElement.getChild("pername").getText();
			person.setPername(pername);
			int perage=Integer.parseInt(personElement.getChild("perage").getText());
			person.setPerage(perage);
			String peraddress=personElement.getChild("peraddress").getText();
			person.setPeraddress(peraddress);
			personlist.add(person);
		}
		return 	personlist;
	}
}

使用jdom解析xml

package com.wangxing.XMLdemo3;

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

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;

public class util {
	/**
	 * 使用jdom解析xml
	 */
	public static List<Person> parseXMLByJdome()throws Exception {
		//定义保存对象的集合
		List<Person> personlist=new ArrayList<Person>();
		//得到解析器对象
		SAXBuilder saxBuilder=new SAXBuilder();
		//读取被解析的xml文件成document
		Document  document=saxBuilder.build(new File("person3.xml"));
		//得到根元素
		Element  rootElement= document.getRootElement();
		//从根元素中得到一组person的子元素
		List<Element>  elementList=rootElement.getChildren("person");
		for(Element personElement:elementList){
			Person  person=new Person();
			//得到属性
			int perid=Integer.parseInt(personElement.getAttributeValue("perid"));
			person.setPerid(perid);
			String pername=personElement.getChild("pername").getText();
			person.setPername(pername);
			int perage=Integer.parseInt(personElement.getChild("perage").getText());
			person.setPerage(perage);
			String peraddress=personElement.getChild("peraddress").getText();
			person.setPeraddress(peraddress);
			personlist.add(person);
		}
		return 	personlist;
	}
}

DOM（Document Object Model)解析的原理就是需要被解析的xml文件，读取成一个文档树【Document 对象】，依据提供的开发类库和方法从文档树中得到根元素，再从根元素中得到子元素，从子元素中的到子子元素，再得到具体的数据值。
优点:结构清晰明了。
缺点:通常需要加载整个XML文档来构造层次结构，消耗资源大.
2. SAX（Simple API for XML)解析
解析类：

package com.wangxing.XMLdemo4;

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

import javax.management.remote.TargetedNotification;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

/**
 * sax解析类
 * @author Administrator
 *
 */
public class MyDefaultHandler extends DefaultHandler{
	//定义一个保存对象的集合
	private List<Person> personList=null;
	private Person person=null;
	private  String tagName="";
	/**
	 * 文档开始的解析方法
	 */
	@Override
	public void startDocument() throws SAXException {
		personList=new ArrayList<Person>();
	}

	@Override
	public void endDocument() throws SAXException {
		// TODO Auto-generated method stub
		super.endDocument();
	}
	/**
	 * 元素开始的解析方法
	 */
	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		if(qName.equals("Person")){
			person=new Person();
			//得到属性值
			int perid =Integer.parseInt(attributes.getValue("perid"));
			person.setPerid(perid);
		}
		if(qName.equals("pername")){
			//保存当前开始元素名称
			tagName=qName;
		}
		if(qName.equals("perage")){
			//保存当前开始元素名称
			tagName=qName;
		}
		if(qName.equals("peraddress")){
			//保存当前开始元素名称
			tagName=qName;
		}
	}
	
	/**
	 * 文本元素对应的解析方法
	 */
	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		String value =new String(ch,start,length);
		if(tagName.equals("pername")){
			person.setPername(value);
		}
		if(tagName.equals("perage")){
			person.setPerage(Integer.valueOf(value));
		}
		if(tagName.equals("peraddress")){
			person.setPeraddress(value);
		}
	}
	/**
	 * 元素结束的解析方法
	 */
	@Override
	public void endElement(String uri, String localName, String qName) throws SAXException {
		if(qName.equals("person")){
			personList.add(person);
			person=null;
			tagName="";
		}else {
			tagName="";
		}
	}
	public  List<Person> getPersonList(){
		return personList;
	}
}

使用sax解析xml

package com.wangxing.XMLdemo4;

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

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import com.wangxing.XMLdemo1.*;

public class util {
	/**
	 * 4. 使用sax解析xml
	 */
	public static List<Person> parseXMLBySax()throws Exception {
		//定义保存对象的集合
		List<Person> personlist=new ArrayList<Person>();
		//得到SAX解析器工厂
		SAXParserFactory saxfac = SAXParserFactory.newInstance();
		//从工厂中得到解析器对象
		SAXParser   saxParser=saxfac.newSAXParser();
		MyDefaultHandler  myDefaultHandler=new MyDefaultHandler();
		saxParser.parse(new File("person1.xml"), myDefaultHandler);
		return  myDefaultHandler.getPersonList();
	}
}

SAX（Simple API for XML)解析xml文件的原理是基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，当发现给定的标签的时候，它可以激活一个回调方法，告诉该方法指定的标签已经找到，如果这个指定的标记中中有我们需要数据值就解析，没有就不用处理。
读取一个元素，判断这一个元素属于xml文件的哪一个元素【文档开始/文档结束/标记开始/标记结束/文本元素】，不同的元素触发不同的方法来执行解析数据，如果当前元素中没有数据值就跳过读取下一个元素。

优点:
1.只在读取数据时检查数据，不需要保存在内存中
2.可以在某个条件得到满足时停止解析，不必解析整个文档。
3.效率和性能较高，能解析大于系统内存的文档。
缺点:没有清晰的解析结构
pull解析方式？？？？？？？？？？？？
3.XML文件解析方式的区别

SAX（Simple API for XML)解析xml文件的原理是基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，当发现给定的标签的时候，它可以激活一个回调方法，告诉该方法指定的标签已经找到，如果这个指定的标记中中有我们需要数据值就解析，没有就不用处理。
优点:1.只在读取数据时检查数据，不需要保存在内存中
2.可以在某个条件得到满足时停止解析，不必解析整个文档。
3.效率和性能较高，能解析大于系统内存的文档。
缺点:没有清晰的解析结构

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。