zoukankan      html  css  js  c++  java

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

    原

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

    置顶 2019年08月16日 15:00:47 阅读数 28 标签： XML解析 WebService 第三方API 更多
    个人分类： JavaWeb
    版权声明：本文为博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。
    本文链接：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：

    1. /*
    2. * 	<?xml version="1.0" encoding="UTF-8"?>
    3. *	<AmazonEnvelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="amzn-envelope.xsd">
    4. *		<Header>
    5. *			<DocumentVersion>1.02</DocumentVersion>
    6. *			<MerchantIdentifier>A23G8Q8ZIKBK8C</MerchantIdentifier>
    7. *		</Header>
    8. *		<MessageType>ProcessingReport</MessageType>
    9. *		<Message>
    10. *			<MessageID>1</MessageID>
    11. *			<ProcessingReport>
    12. *				<DocumentTransactionID>57320017876</DocumentTransactionID>
    13. *				<StatusCode>Complete</StatusCode>
    14. *				<ProcessingSummary>
    15. *					<MessagesProcessed>15</MessagesProcessed>
    16. *					<MessagesSuccessful>13</MessagesSuccessful>
    17. *					<MessagesWithError>2</MessagesWithError>
    18. *					<MessagesWithWarning>0</MessagesWithWarning>
    19. *				</ProcessingSummary>
    20. *				<Result>
    21. *					<MessageID>3</MessageID>
    22. *					<ResultCode>Error</ResultCode>
    23. *					<ResultMessageCode>25</ResultMessageCode>
    24. *					<ResultDescription>We are unable to process the XML feed because one or more items are invalid. Please re-submit the feed.</ResultDescription>
    25. *				</Result>
    26. *				<Result>
    27. *					<MessageID>4</MessageID>
    28. *					<ResultCode>Error</ResultCode>
    29. *					<ResultMessageCode>25</ResultMessageCode>
    30. *					<ResultDescription>We are unable to process the XML feed because one or more items are invalid. Please re-submit the feed.</ResultDescription>
    31. *				</Result>
    32. *			</ProcessingReport>
    33. *		</Message>
    34. *	</AmazonEnvelope>
    35.  
    36. */

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

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

    1. package com.aukey.supply.chain.domain.test;
    2.  
    3. import javax.xml.bind.annotation.XmlAccessType;
    4. import javax.xml.bind.annotation.XmlAccessorType;
    5. import javax.xml.bind.annotation.XmlElement;
    6. import javax.xml.bind.annotation.XmlRootElement;
    7. import javax.xml.bind.annotation.XmlType;
    8.  
    9. @XmlType(propOrder =
    10. { "Header", "MessageType", "Message" }) // 指定序列成的xml节点顺序
    11. @XmlAccessorType(value = XmlAccessType.FIELD) // 访问类型改为字段
    12. @XmlRootElement(name = "AmazonEnvelope")
    13. public class AmazonEnvelope {
    14. 	 @XmlElement
    15. 	 private Header Header;//构造头部
    16. 	 
    17. 	 @XmlElement
    18. 	 private String MessageType;
    19. 	 
    20. 	 
    21. 	 @XmlElement
    22. 	 private Message Message;
    23.  
    24.  
    25. 	public Header getHeader() {
    26. 		return Header;
    27. 	}
    28.  
    29.  
    30. 	public void setHeader(Header header) {
    31. 		Header = header;
    32. 	}
    33.  
    34.  
    35. 	public String getMessageType() {
    36. 		return MessageType;
    37. 	}
    38.  
    39.  
    40. 	public void setMessageType(String messageType) {
    41. 		MessageType = messageType;
    42. 	}
    43.  
    44.  
    45. 	public Message getMessage() {
    46. 		return Message;
    47. 	}
    48.  
    49.  
    50. 	public void setMessage(Message message) {
    51. 		Message = message;
    52. 	}
    53. }
    1. package com.aukey.supply.chain.domain.test;
    2.  
    3. import javax.xml.bind.annotation.XmlAccessType;
    4. import javax.xml.bind.annotation.XmlAccessorType;
    5. import javax.xml.bind.annotation.XmlElement;
    6. import javax.xml.bind.annotation.XmlType;
    7.  
    8. @XmlType(propOrder =
    9. { "MessageID", "ProcessingReport"}) // 指定序列成的xml节点顺序
    10. @XmlAccessorType(value = XmlAccessType.FIELD) // 访问类型改为字段
    11. public class Message {
    12. 	
    13. 	@XmlElement
    14. 	private String MessageID;
    15. 	
    16. 	@XmlElement
    17. 	private ProcessingReport ProcessingReport;
    18.  
    19. 	public String getMessageID() {
    20. 		return MessageID;
    21. 	}
    22.  
    23. 	public void setMessageID(String messageID) {
    24. 		MessageID = messageID;
    25. 	}
    26.  
    27. 	public ProcessingReport getProcessingReport() {
    28. 		return ProcessingReport;
    29. 	}
    30.  
    31. 	public void setProcessingReport(ProcessingReport processingReport) {
    32. 		ProcessingReport = processingReport;
    33. 	}
    34. 	
    35. }

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

    1. /**
    2. 	 * 构造XML对象 将节点数据组装成一个XML大对象
    3. 	 * @return
    4. 	 */
    5. 	public static AmazonEnvelope createXmlObject() 
    6. 	{
    7. 		AmazonEnvelope amazonEnvelope =new AmazonEnvelope();
    8. 		
    9. 		//子级节点1
    10. 		Header header =new Header();
    11. 		header.setDocumentVersion("1.02");
    12. 		header.setMerchantIdentifier("A23G8Q8ZIKBK8C");
    13. 		//赋值子级节点1
    14. 		amazonEnvelope.setHeader(header);
    15. 		
    16. 		//子级节点1
    17. 		String messageType="ProcessingReport";
    18. 		//赋值子级节点1
    19. 		amazonEnvelope.setMessageType(messageType);
    20. 		
    21. 		//子级节点1
    22. 		Message message =new Message();
    23. 		//赋值子级节点2
    24. 		message.setMessageID("1");
    25. 		
    26. 		//子级节点2
    27. 		ProcessingReport processingReport=new ProcessingReport();
    28. 		
    29. 		//赋值子级节点2
    30. 		processingReport.setDocumentTransactionID("57320017876");
    31. 		//赋值子级节点2
    32. 		processingReport.setStatusCode("Complete");
    33. 		
    34. 		//子级节点3
    35. 		ProcessingSummary processingSummary =new ProcessingSummary();
    36. 		//赋值子级节点3
    37. 		processingSummary.setMessagesProcessed("15");
    38. 		//赋值子级节点3
    39. 		processingSummary.setMessagesSuccessful("13");
    40. 		//赋值子级节点3
    41. 		processingSummary.setMessagesWithError("2");
    42. 		//赋值子级节点3
    43. 		processingSummary.setMessagesWithWarning("0");
    44. 		
    45. 		//子级节点3
    46. 		List<Result> results=new ArrayList<>();
    47. 		Result result =new Result();
    48. 		//赋值子级节点4
    49. 		result.setMessageID("3");
    50. 		//赋值子级节点4
    51. 		result.setResultCode("Error");
    52. 		//赋值子级节点4
    53. 		result.setResultDescription("25");
    54. 		//赋值子级节点4
    55. 		result.setResultMessageCode("We are unable to process the XML feed because one or more items are invalid. Please re-submit the feed.");
    56. 		
    57. 		//赋值子级节点3
    58. 		results.add(result);
    59. 		
    60. 		
    61. 		//赋值子级节点2
    62. 		processingReport.setResult(results);
    63. 		
    64. 		//赋值子级节点2
    65. 		processingReport.setProcessingSummary(processingSummary);
    66. 		
    67. 		//赋值子级节点2
    68. 		message.setProcessingReport(processingReport);
    69. 		
    70. 		//赋值子级节点1
    71. 		amazonEnvelope.setMessage(message);
    72. 		
    73. 		return amazonEnvelope;
    74. 	}

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

    1. /**
    2. 	 * 构造XML 报文对象
    3. 	 * @param amazonEnvelope
    4. 	 * @return
    5. 	 */
    6. 	public static String createXml(AmazonEnvelope amazonEnvelope) 
    7. 	{
    8. 		JAXBContext context;
    9. 		try {
    10. 			context = JAXBContext.newInstance(amazonEnvelope.getClass());
    11. 			Marshaller marshaller = context.createMarshaller();
    12. 			marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
    13. 			marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
    14. 			StringWriter writer = new StringWriter();
    15. 			marshaller.marshal(amazonEnvelope, writer);
    16. 			String xml = writer.toString();
    17. 			return xml;
    18. 		} catch (JAXBException e) {
    19. 			e.printStackTrace();
    20. 		}
    21. 		return "";
    22. 	}

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

    1. package com.aukey.supply.chain.web.test;
    2.  
    3. import java.io.StringReader;
    4. import java.io.StringWriter;
    5. import java.util.ArrayList;
    6. import java.util.HashMap;
    7. import java.util.List;
    8. import java.util.Map;
    9.  
    10. import javax.xml.bind.JAXBContext;
    11. import javax.xml.bind.JAXBException;
    12. import javax.xml.bind.Marshaller;
    13. import javax.xml.bind.Unmarshaller;
    14.  
    15. import org.dom4j.Document;
    16. import org.dom4j.DocumentException;
    17. import org.dom4j.DocumentHelper;
    18. import org.dom4j.Element;
    19.  
    20. import com.alibaba.fastjson.JSON;
    21. import com.aukey.supply.chain.domain.test.AmazonEnvelope;
    22. import com.aukey.supply.chain.domain.test.Header;
    23. import com.aukey.supply.chain.domain.test.Message;
    24. import com.aukey.supply.chain.domain.test.ProcessingReport;
    25. import com.aukey.supply.chain.domain.test.ProcessingSummary;
    26. import com.aukey.supply.chain.domain.test.Result;
    27. import com.aukey.supply.chain.utils.Md5Utils;
    28. import com.aukey.supply.chain.utils.XMLPostUtils;
    29.  
    30. public class TestAnalyzeXml {
    31. 	public static void main(String[] args) 
    32. 	{
    33. 		//组装请求报文XML对象
    34. 		AmazonEnvelope amazonEnvelope =createXmlObject();
    35. 		
    36. 		//构造XML文本
    37. 		String xml= createXml(amazonEnvelope);
    38. 		
    39.         try 
    40.         {
    41.         	//封装请求报文 然后发送HTTP请求 然后将返回XML字符串 进行解析对应XML格式的节点对象 然后获取对应的节点数据
    42.         	String urlStr = "http://info.edaeu.com/Api/";
    43.         	String token="";
    44.         	String md5;
    45.             try {
    46.                 md5 = Md5Utils.ChangeMd5(token.substring(0, 16) + xml + token.substring(16, 32));
    47.             } catch (Exception e) {
    48.                 md5 = "";
    49.             }
    50.             String httpPost = XMLPostUtils.httpPost(xml, urlStr+"/"+md5);
    51.             JAXBContext getcontext = JAXBContext.newInstance(amazonEnvelope.getClass());
    52.             Unmarshaller unmarshaller = getcontext.createUnmarshaller();
    53.             StringReader reader = new StringReader(httpPost);
    54. 			Object object=(AmazonEnvelope)unmarshaller.unmarshal(reader);
    55. 		} catch (JAXBException e1) {
    56. 			e1.printStackTrace();
    57. 		}
    58. 		
    59. 		try{
    60. 			Document document = DocumentHelper.parseText(xml);
    61. 			// 通过document对象获取根节点
    62. 		    Element root = document.getRootElement();
    63. 		    Element message = root.element("Message");
    64. 		    Element processingReport = message.element("ProcessingReport");
    65. 		    @SuppressWarnings("unchecked")
    66. 		    List<Element> results = processingReport.elements("Result");
    67. 		    List<Map<String, Object>> mapResultList=new ArrayList<Map<String,Object>>();
    68. 		    for (Element element : results) 
    69. 		    {
    70. 				Map<String, Object> map =new HashMap<String, Object>();
    71. 				map.put("MessageID",element.element("MessageID").getTextTrim());
    72. 				map.put("ResultCode", element.element("ResultCode").getTextTrim());
    73. 				map.put("ResultMessageCode",element.element("ResultMessageCode").getTextTrim());
    74. 				map.put("ResultDescription", element.element("ResultDescription").getTextTrim());
    75. 				mapResultList.add(map);
    76. 			}
    77. 		    System.out.println(JSON.toJSONString(mapResultList));
    78. 		    
    79. 		} catch (DocumentException e) {
    80. 			e.printStackTrace();
    81. 		}
    82. 		
    83. 		
    84. 		
    85. 	}
    86. 	
    87. 	
    88. 	
    89. }

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

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

    1. package com.aukey.supply.chain.utils;
    2.  
    3. import java.io.ByteArrayOutputStream;
    4. import java.io.InputStream;
    5. import java.io.OutputStream;
    6. import java.io.StringReader;
    7. import java.net.HttpURLConnection;
    8. import java.net.URL;
    9.  
    10. import javax.xml.bind.JAXBContext;
    11. import javax.xml.bind.Unmarshaller;
    12. import javax.xml.parsers.SAXParserFactory;
    13. import javax.xml.transform.Source;
    14. import javax.xml.transform.sax.SAXSource;
    15.  
    16. import org.xml.sax.InputSource;
    17. import org.xml.sax.XMLReader;
    18.  
    19. public class XMLPostUtils
    20. {
    21.  
    22.     public static String httpPost(String xml, String urlStr)
    23.     {
    24.         try
    25.         {
    26.             URL url = new URL(urlStr);
    27.             // 建立http连接
    28.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    29.             // 设置允许输出
    30.             conn.setDoOutput(true);
    31.  
    32.             conn.setDoInput(true);
    33.  
    34.             // 设置不用缓存
    35.             conn.setUseCaches(false);
    36.             // 设置传递方式
    37.             conn.setRequestMethod("POST");
    38.             // 设置维持长连接
    39.             conn.setRequestProperty("Connection", "Keep-Alive");
    40.             // 设置文件字符集:
    41.             conn.setRequestProperty("Charset", "UTF-8");
    42.             // 转换为字节数组
    43.             byte[] data = xml.getBytes();
    44.             // 设置文件长度
    45.             conn.setRequestProperty("Content-Length", String.valueOf(data.length));
    46.             // 设置文件类型:
    47.             conn.setRequestProperty("contentType", "text/xml");
    48.             // 开始连接请求
    49.             conn.connect();
    50.             OutputStream out = conn.getOutputStream();
    51.             // 写入请求的字符串
    52.             out.write(data);
    53.             out.flush();
    54.             out.close();
    55.  
    56.             // 请求返回的状态
    57.             if (conn.getResponseCode() == 200)
    58.             {
    59.                 // 请求返回的数据
    60.                 InputStream in = conn.getInputStream();
    61.                 try
    62.                 {
    63.                     ByteArrayOutputStream s = new ByteArrayOutputStream();
    64.                     int length = 0;
    65.                     byte[] buffer = new byte[1024 * 1024];
    66.                     while ((length = in.read(buffer)) != -1)
    67.                     {
    68.                         s.write(buffer, 0, length);
    69.                     }
    70.                     return s.toString("UTF-8");
    71.  
    72.                 }
    73.                 catch (Exception e1)
    74.                 {
    75.                     e1.printStackTrace();
    76.                 }
    77.                 finally
    78.                 {
    79.                     in.close();
    80.                 }
    81.             }
    82.             else
    83.             {
    84.             }
    85.  
    86.         }
    87.         catch (Exception e)
    88.         {
    89.             e.printStackTrace();
    90.  
    91.         }
    92.         return null;
    93.     }
    94.  
    95.     public static <T> T convertXmlToJavaBean(String xml, Class<T> t) throws Exception
    96.     {
    97.         T obj;
    98.         JAXBContext context = JAXBContext.newInstance(t);
    99.         StringReader stringReader = new StringReader(xml);
    100.         SAXParserFactory sax = SAXParserFactory.newInstance();
    101.         sax.setNamespaceAware(false);// 设置忽略明明空间
    102.         XMLReader xmlReader = sax.newSAXParser().getXMLReader();
    103.         Source source = new SAXSource(xmlReader, new InputSource(stringReader));
    104.         Unmarshaller unmarshaller = context.createUnmarshaller();
    105.         obj = (T) unmarshaller.unmarshal(source);
    106.         return obj;
    107.     }
    108.  
    109. }
    1. package com.aukey.task.centerwarehouse.utils;
    2.  
    3. import java.security.MessageDigest;
    4. import java.security.NoSuchAlgorithmException;
    5.  
    6. public class Md5Utils
    7. {
    8.     public static String ChangeMd5(String password)
    9.     {
    10.  
    11.         try
    12.         {
    13.             // 得到一个信息摘要器
    14.             MessageDigest digest = MessageDigest.getInstance("md5");
    15.             byte[] result = digest.digest(password.getBytes());
    16.             StringBuffer buffer = new StringBuffer();
    17.             // 把每一个byte 做一个与运算 0xff;
    18.             for (byte b : result)
    19.             {
    20.                 // 与运算
    21.                 int number = b & 0xff;// 加盐
    22.                 String str = Integer.toHexString(number);
    23.                 if (str.length() == 1)
    24.                 {
    25.                     buffer.append("0");
    26.                 }
    27.                 buffer.append(str);
    28.             }
    29.  
    30.             // 标准的md5加密后的结果
    31.             return buffer.toString();
    32.         }
    33.         catch (NoSuchAlgorithmException e)
    34.         {
    35.             e.printStackTrace();
    36.             return "";
    37.         }
    38.  
    39.     }
    40. }
  • 相关阅读:
    html5的离线缓存
    html5的本地存储
    html5的地理位置定位
    html5新添加的表单类型和属性
    html5的鼠标拖拽
    win下svn常用操作笔记
    git常用命令笔记
    centos7下NFS使用与配置
    centos7下mysql5.6的主从复制
    centos7下创建mysql5.6多实例
  • 原文地址：https://www.cnblogs.com/LoveShare/p/11388708.html
Copyright © 2011-2022 走看看