原

WebService如何封装XML请求以及解析接口返回的XML

置顶
2019年08月16日 15:00:47
童子泛舟
阅读数 28

个人分类：
JavaWeb

本文链接：https://blog.csdn.net/qq_24818689/article/details/99677155

1、封装XML报文对象

博主在调第三方接口时，经常需要封装XML去请求第三方的数据，在Web开发时，需要经常用到，因此也打算写篇文章记录下本人在思考和寻求答案的过程。

1-1 XML的一些基本常识

一般在参考一些API的文档时，JAVA开发一般是根据特定的API要求去对数据进行封装，在此，我将采用举例的方式来说明，已经应用场景。在封装XML对象时，首先我们得了解封装XML对象试用方式，一般采取Class类注解的形式去实现。如@XmlType、@XmlAccessorType、@XmlRootElement、 @XmlElement等。

@XmlType(propOrder ={ "Header", "MessageType", "Message" }) // 指定序列成的xml节点顺序

@XmlAccessorType(value = XmlAccessType.FIELD) // 访问类型改为字段

@XmlRootElement(name = "AmazonEnvelope")//封装XML对象的根节点

1-2 封装XML针对某些特定API请求参数。这里以对接亚马逊的某些接口举例

以下为我举例加入某接口需要对参数封装XML：






/*





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





*	<AmazonEnvelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="amzn-envelope.xsd">





*		<Header>





*			<DocumentVersion>1.02</DocumentVersion>





*			<MerchantIdentifier>A23G8Q8ZIKBK8C</MerchantIdentifier>





*		</Header>





*		<MessageType>ProcessingReport</MessageType>





*		<Message>





*			<MessageID>1</MessageID>





*			<ProcessingReport>





*				<DocumentTransactionID>57320017876</DocumentTransactionID>





*				<StatusCode>Complete</StatusCode>





*				<ProcessingSummary>





*					<MessagesProcessed>15</MessagesProcessed>





*					<MessagesSuccessful>13</MessagesSuccessful>





*					<MessagesWithError>2</MessagesWithError>





*					<MessagesWithWarning>0</MessagesWithWarning>





*				</ProcessingSummary>





*				<Result>





*					<MessageID>3</MessageID>





*					<ResultCode>Error</ResultCode>





*					<ResultMessageCode>25</ResultMessageCode>





*					<ResultDescription>We are unable to process the XML feed because one or more items are invalid. Please re-submit the feed.</ResultDescription>





*				</Result>





*				<Result>





*					<MessageID>4</MessageID>





*					<ResultCode>Error</ResultCode>





*					<ResultMessageCode>25</ResultMessageCode>





*					<ResultDescription>We are unable to process the XML feed because one or more items are invalid. Please re-submit the feed.</ResultDescription>





*				</Result>





*			</ProcessingReport>





*		</Message>





*	</AmazonEnvelope>





 





*/

如果看到这种XML格式，去封装请求对象如何封装呢？

我们如果有了解过XML这种语言就知道，XML可以理解为一颗树，有父子根节点构成。其实Spring 内部去解析XML时，也是根据这种特性去解析的。因为我们最原始MVC 需要大量的配置XML 注入bean。以及配置事物等等。我们通过分析可以发现，外部根节点为AmazonEnvelope，子节点Header、MessageType、Message，然后Message节点下又有子节点MessageID、ProcessingReport。依次类推，可以构造AmazonEnvelope大对象，然后以此为根节点建造子节点对象，这里举例两个如下：






package com.aukey.supply.chain.domain.test;





 





import javax.xml.bind.annotation.XmlAccessType;





import javax.xml.bind.annotation.XmlAccessorType;





import javax.xml.bind.annotation.XmlElement;





import javax.xml.bind.annotation.XmlRootElement;





import javax.xml.bind.annotation.XmlType;





 





@XmlType(propOrder =





{ "Header", "MessageType", "Message" }) // 指定序列成的xml节点顺序





@XmlAccessorType(value = XmlAccessType.FIELD) // 访问类型改为字段





@XmlRootElement(name = "AmazonEnvelope")





public class AmazonEnvelope {





	 @XmlElement





	 private Header Header;//构造头部





	 





	 @XmlElement





	 private String MessageType;





	 





	 





	 @XmlElement





	 private Message Message;





 





 





	public Header getHeader() {





		return Header;





	}





 





 





	public void setHeader(Header header) {





		Header = header;





	}





 





 





	public String getMessageType() {





		return MessageType;





	}





 





 





	public void setMessageType(String messageType) {





		MessageType = messageType;





	}





 





 





	public Message getMessage() {





		return Message;





	}





 





 





	public void setMessage(Message message) {





		Message = message;





	}





}






package com.aukey.supply.chain.domain.test;





 





import javax.xml.bind.annotation.XmlAccessType;





import javax.xml.bind.annotation.XmlAccessorType;





import javax.xml.bind.annotation.XmlElement;





import javax.xml.bind.annotation.XmlType;





 





@XmlType(propOrder =





{ "MessageID", "ProcessingReport"}) // 指定序列成的xml节点顺序





@XmlAccessorType(value = XmlAccessType.FIELD) // 访问类型改为字段





public class Message {





	





	@XmlElement





	private String MessageID;





	





	@XmlElement





	private ProcessingReport ProcessingReport;





 





	public String getMessageID() {





		return MessageID;





	}





 





	public void setMessageID(String messageID) {





		MessageID = messageID;





	}





 





	public ProcessingReport getProcessingReport() {





		return ProcessingReport;





	}





 





	public void setProcessingReport(ProcessingReport processingReport) {





		ProcessingReport = processingReport;





	}





	





}

对象封装完成之后，API一般需要请求参数，因此我们建完实体对象后，需要按照不同节点要求赋值，示例如下：






/**





	 * 构造XML对象 将节点数据组装成一个XML大对象





	 * @return





	 */





	public static AmazonEnvelope createXmlObject() 





	{





		AmazonEnvelope amazonEnvelope =new AmazonEnvelope();





		





		//子级节点1





		Header header =new Header();





		header.setDocumentVersion("1.02");





		header.setMerchantIdentifier("A23G8Q8ZIKBK8C");





		//赋值子级节点1





		amazonEnvelope.setHeader(header);





		





		//子级节点1





		String messageType="ProcessingReport";





		//赋值子级节点1





		amazonEnvelope.setMessageType(messageType);





		





		//子级节点1





		Message message =new Message();





		//赋值子级节点2





		message.setMessageID("1");





		





		//子级节点2





		ProcessingReport processingReport=new ProcessingReport();





		





		//赋值子级节点2





		processingReport.setDocumentTransactionID("57320017876");





		//赋值子级节点2





		processingReport.setStatusCode("Complete");





		





		//子级节点3





		ProcessingSummary processingSummary =new ProcessingSummary();





		//赋值子级节点3





		processingSummary.setMessagesProcessed("15");





		//赋值子级节点3





		processingSummary.setMessagesSuccessful("13");





		//赋值子级节点3





		processingSummary.setMessagesWithError("2");





		//赋值子级节点3





		processingSummary.setMessagesWithWarning("0");





		





		//子级节点3





		List<Result> results=new ArrayList<>();





		Result result =new Result();





		//赋值子级节点4





		result.setMessageID("3");





		//赋值子级节点4





		result.setResultCode("Error");





		//赋值子级节点4





		result.setResultDescription("25");





		//赋值子级节点4





		result.setResultMessageCode("We are unable to process the XML feed because one or more items are invalid. Please re-submit the feed.");





		





		//赋值子级节点3





		results.add(result);





		





		





		//赋值子级节点2





		processingReport.setResult(results);





		





		//赋值子级节点2





		processingReport.setProcessingSummary(processingSummary);





		





		//赋值子级节点2





		message.setProcessingReport(processingReport);





		





		//赋值子级节点1





		amazonEnvelope.setMessage(message);





		





		return amazonEnvelope;





	}

对象赋值完成后，需要把当前的XML对象封装整个XML，一般设置字符编码等。并且组装成一个String 这里JAXBContext文本对象来完成：






/**





	 * 构造XML 报文对象





	 * @param amazonEnvelope





	 * @return





	 */





	public static String createXml(AmazonEnvelope amazonEnvelope) 





	{





		JAXBContext context;





		try {





			context = JAXBContext.newInstance(amazonEnvelope.getClass());





			Marshaller marshaller = context.createMarshaller();





			marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);





			marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");





			StringWriter writer = new StringWriter();





			marshaller.marshal(amazonEnvelope, writer);





			String xml = writer.toString();





			return xml;





		} catch (JAXBException e) {





			e.printStackTrace();





		}





		return "";





	}

封装XML完成之后，就可以调取第三方的API并DOM解析返回了，这里说明为了方便，将请求对象和解析对象置为同一个。下面看主类全套调用逻辑：






package com.aukey.supply.chain.web.test;





 





import java.io.StringReader;





import java.io.StringWriter;





import java.util.ArrayList;





import java.util.HashMap;





import java.util.List;





import java.util.Map;





 





import javax.xml.bind.JAXBContext;





import javax.xml.bind.JAXBException;





import javax.xml.bind.Marshaller;





import javax.xml.bind.Unmarshaller;





 





import org.dom4j.Document;





import org.dom4j.DocumentException;





import org.dom4j.DocumentHelper;





import org.dom4j.Element;





 





import com.alibaba.fastjson.JSON;





import com.aukey.supply.chain.domain.test.AmazonEnvelope;





import com.aukey.supply.chain.domain.test.Header;





import com.aukey.supply.chain.domain.test.Message;





import com.aukey.supply.chain.domain.test.ProcessingReport;





import com.aukey.supply.chain.domain.test.ProcessingSummary;





import com.aukey.supply.chain.domain.test.Result;





import com.aukey.supply.chain.utils.Md5Utils;





import com.aukey.supply.chain.utils.XMLPostUtils;





 





public class TestAnalyzeXml {





	public static void main(String[] args) 





	{





		//组装请求报文XML对象





		AmazonEnvelope amazonEnvelope =createXmlObject();





		





		//构造XML文本





		String xml= createXml(amazonEnvelope);





		





        try 





        {





        	//封装请求报文 然后发送HTTP请求 然后将返回XML字符串 进行解析对应XML格式的节点对象 然后获取对应的节点数据





        	String urlStr = "http://info.edaeu.com/Api/";





        	String token="";





        	String md5;





            try {





                md5 = Md5Utils.ChangeMd5(token.substring(0, 16) + xml + token.substring(16, 32));





            } catch (Exception e) {





                md5 = "";





            }





            String httpPost = XMLPostUtils.httpPost(xml, urlStr+"/"+md5);





            JAXBContext getcontext = JAXBContext.newInstance(amazonEnvelope.getClass());





            Unmarshaller unmarshaller = getcontext.createUnmarshaller();





            StringReader reader = new StringReader(httpPost);





			Object object=(AmazonEnvelope)unmarshaller.unmarshal(reader);





		} catch (JAXBException e1) {





			e1.printStackTrace();





		}





		





		try{





			Document document = DocumentHelper.parseText(xml);





			// 通过document对象获取根节点





		    Element root = document.getRootElement();





		    Element message = root.element("Message");





		    Element processingReport = message.element("ProcessingReport");





		    @SuppressWarnings("unchecked")





		    List<Element> results = processingReport.elements("Result");





		    List<Map<String, Object>> mapResultList=new ArrayList<Map<String,Object>>();





		    for (Element element : results) 





		    {





				Map<String, Object> map =new HashMap<String, Object>();





				map.put("MessageID",element.element("MessageID").getTextTrim());





				map.put("ResultCode", element.element("ResultCode").getTextTrim());





				map.put("ResultMessageCode",element.element("ResultMessageCode").getTextTrim());





				map.put("ResultDescription", element.element("ResultDescription").getTextTrim());





				mapResultList.add(map);





			}





		    System.out.println(JSON.toJSONString(mapResultList));





		    





		} catch (DocumentException e) {





			e.printStackTrace();





		}





		





		





		





	}





	





	





	





}

以上获取完数据，差不多解析调用就完成了。整个封装XML并调用API，以及返回解析API返回的XML就完成了！

福利（附带Http请求XML封装工具类以及MD5加密类）：






package com.aukey.supply.chain.utils;





 





import java.io.ByteArrayOutputStream;





import java.io.InputStream;





import java.io.OutputStream;





import java.io.StringReader;





import java.net.HttpURLConnection;





import java.net.URL;





 





import javax.xml.bind.JAXBContext;





import javax.xml.bind.Unmarshaller;





import javax.xml.parsers.SAXParserFactory;





import javax.xml.transform.Source;





import javax.xml.transform.sax.SAXSource;





 





import org.xml.sax.InputSource;





import org.xml.sax.XMLReader;





 





public class XMLPostUtils





{





 





    public static String httpPost(String xml, String urlStr)





    {





        try





        {





            URL url = new URL(urlStr);





            // 建立http连接





            HttpURLConnection conn = (HttpURLConnection) url.openConnection();





            // 设置允许输出





            conn.setDoOutput(true);





 





            conn.setDoInput(true);





 





            // 设置不用缓存





            conn.setUseCaches(false);





            // 设置传递方式





            conn.setRequestMethod("POST");





            // 设置维持长连接





            conn.setRequestProperty("Connection", "Keep-Alive");





            // 设置文件字符集:





            conn.setRequestProperty("Charset", "UTF-8");





            // 转换为字节数组





            byte[] data = xml.getBytes();





            // 设置文件长度





            conn.setRequestProperty("Content-Length", String.valueOf(data.length));





            // 设置文件类型:





            conn.setRequestProperty("contentType", "text/xml");





            // 开始连接请求





            conn.connect();





            OutputStream out = conn.getOutputStream();





            // 写入请求的字符串





            out.write(data);





            out.flush();





            out.close();





 





            // 请求返回的状态





            if (conn.getResponseCode() == 200)





            {





                // 请求返回的数据





                InputStream in = conn.getInputStream();





                try





                {





                    ByteArrayOutputStream s = new ByteArrayOutputStream();





                    int length = 0;





                    byte[] buffer = new byte[1024 * 1024];





                    while ((length = in.read(buffer)) != -1)





                    {





                        s.write(buffer, 0, length);





                    }





                    return s.toString("UTF-8");





 





                }





                catch (Exception e1)





                {





                    e1.printStackTrace();





                }





                finally





                {





                    in.close();





                }





            }





            else





            {





            }





 





        }





        catch (Exception e)





        {





            e.printStackTrace();





 





        }





        return null;





    }





 





    public static <T> T convertXmlToJavaBean(String xml, Class<T> t) throws Exception





    {





        T obj;





        JAXBContext context = JAXBContext.newInstance(t);





        StringReader stringReader = new StringReader(xml);





        SAXParserFactory sax = SAXParserFactory.newInstance();





        sax.setNamespaceAware(false);// 设置忽略明明空间





        XMLReader xmlReader = sax.newSAXParser().getXMLReader();





        Source source = new SAXSource(xmlReader, new InputSource(stringReader));





        Unmarshaller unmarshaller = context.createUnmarshaller();





        obj = (T) unmarshaller.unmarshal(source);





        return obj;





    }





 





}






package com.aukey.task.centerwarehouse.utils;





 





import java.security.MessageDigest;





import java.security.NoSuchAlgorithmException;





 





public class Md5Utils





{





    public static String ChangeMd5(String password)





    {





 





        try





        {





            // 得到一个信息摘要器





            MessageDigest digest = MessageDigest.getInstance("md5");





            byte[] result = digest.digest(password.getBytes());





            StringBuffer buffer = new StringBuffer();





            // 把每一个byte 做一个与运算 0xff;





            for (byte b : result)





            {





                // 与运算





                int number = b & 0xff;// 加盐





                String str = Integer.toHexString(number);





                if (str.length() == 1)





                {





                    buffer.append("0");





                }





                buffer.append(str);





            }





 





            // 标准的md5加密后的结果





            return buffer.toString();





        }





        catch (NoSuchAlgorithmException e)





        {





            e.printStackTrace();





            return "";





        }





 





    }





}