通过webservice提交xml数据

偏执的太偏执、 2023-02-14 15:45 60阅读 0赞

# 通过webservice提交xml数据**加粗样式** #

更新啦！！！！

地址：https://www.jianshu.com/p/81430f69d666

//这里调用
 
 
 public static void main(String[] args) { 
 LinkedHashMap<String, String> objectObjectHashMap = new LinkedHashMap<>();
 objectObjectHashMap.put("areaCode", "1309");
 objectObjectHashMap.put("cityId", "0");
 objectObjectHashMap.put("townId", "0");
 String getHosInfo = WebServiceUtil.callWebService("https://aaa.aaa.aaa.cn/BabyAppVipSer.asmx", "GetHosInfos", 				objectObjectHashMap);
 System.out.println(getHosInfo);
 }
 
 
 
 
 /** * 调用webService 接口返回字符串 * @param asmxUrl 提供接口的地址 * @param waysName 设置要调用哪个方法 * @param params 请求的参数 * @return */
 public static String callWebService(String asmxUrl, String waysName, LinkedHashMap<String,String> params){ 
 String soapaction = "http://tempuri.org/"; // 域名，这是在server定义的--不知道的可以问接口提供方，他们一并提供这个
 Service service = new Service();
 Object[] obj = new Object[params.size()];
 try{ 
 Call call = (Call) service.createCall();
 call.setTargetEndpointAddress(asmxUrl);
 call.setOperationName(new QName(soapaction, waysName)); // 设置要调用哪个方法
 //设置变量每次循环完成+1
 int flag = 0;
 for (String param : params.keySet()) { 
 call.addParameter(new QName(soapaction, param), // 设置要传递的参数--要和接口方提供的参数名一致
 org.apache.axis.encoding.XMLType.XSD_STRING,
 javax.xml.rpc.ParameterMode.IN);
 obj[flag] = params.get(param);
 flag++;
 }
 call.setReturnType(new QName(soapaction, waysName), String.class); // 要返回的数据类型（自定义类型，我这边接口提供方给我返回的是json字符串，所以我用string类型接收。这个地方一定要设置好，不然各种报错很崩溃）
 call.setUseSOAPAction(true);
 call.setSOAPActionURI(soapaction + waysName);
 return (String)call.invoke(obj);// 调用方法并传递参数-传递的参数和设置的参数要对应，顺序不能搞错了
 }catch (Exception ex){ 
 ex.printStackTrace();
 }
 return null;
 }
 
 
 
 //pom
 
 <dependency>
 <groupId>org.apache.axis</groupId>
 <artifactId>axis</artifactId>
 <version>1.4</version>
 </dependency>
 
 <dependency>
 <groupId>javax.xml.rpc</groupId>
 <artifactId>javax.xml.rpc-api</artifactId>
 <version>1.1.1</version>
 </dependency>
 
 <dependency>
 <groupId>commons-discovery</groupId>
 <artifactId>commons-discovery</artifactId>
 <version>0.4</version>
 </dependency>
 
 <dependency>
 <groupId>wsdl4j</groupId>
 <artifactId>wsdl4j</artifactId>
 <version>1.6.3</version>
 </dependency>

/下面是旧的，看上面就可以、、、、、、、、、、、、、、、、、、、

原创1 ： https://blog.csdn.net/qq\_24505127/article/details/53057099  
原创2 ： https://blog.csdn.net/qq\_28779071/article/details/82714460  
所需maven

<dependency>
 <groupId>org.apache.axis</groupId>
 <artifactId>axis</artifactId>
 <version>1.4</version>
 </dependency>
 <dependency>
 <groupId>commons-discovery</groupId>
 <artifactId>commons-discovery</artifactId>
 <version>0.2</version>
 <exclusions>
 <exclusion>
 <groupId>commons-logging</groupId>
 <artifactId>commons-logging</artifactId>
 </exclusion>
 </exclusions>
 </dependency>
 <dependency>
 <groupId>org.apache.axis</groupId>
 <artifactId>axis-jaxrpc</artifactId>
 <version>1.4</version>
 </dependency>
 <dependency>
 <groupId>org.apache.axis</groupId>
 <artifactId>axis-saaj</artifactId>
 <version>1.4</version>
 </dependency>
 <dependency>
 <groupId>wsdl4j</groupId>
 <artifactId>wsdl4j</artifactId>
 <version>1.4</version>
 </dependency>
 
 <dependency>
 		<groupId>commons-httpclient</groupId>
 		<artifactId>commons-httpclient</artifactId>
 		<version>3.1</version>
 		</dependency>
 
 <dependency>
 <groupId>org.jdom</groupId>
 <artifactId>jdom</artifactId>
 <version>2.0.2</version>
 </dependency>

## 调用 ##

// 调用接口
 		// 方法一:直接AXIS调用远程的web service
 		try { 
 			Map<String, Object> map = new LinkedHashMap<>();
 			// String endpoint =
 			// "http://www.webxml.com.cn/WebServices/TranslatorWebService.asmx";
 			// String endpoint =
 			// "http://10.110.113.101:8088/ZK_WebService.asmx";
 			//String endpoint = "http://10.110.113.101:8088/ZK_WebService.asmx";
 			String endpoint = "http://10.110.113.101:8088/ZK_WebService.asmx";
 
 			 map.put("ID", "");
 			 map.put("XM", "");
 			 map.put("XB", "");
 			 map.put("CSNY", "");
 			 map.put("SFZH", "");
 			 map.put("HF", "");
 			 map.put("LXDH", "");
 			 map.put("DWDM", "");
 			 map.put("PROJECTID", "");
 			 map.put("JCRQ", "2020-01-01^2020-01-02");
 			//
 // StringBuffer sb = new StringBuffer();
 // sb.append(" <ID></ID> <XM></XM><XB></XB><CSNY></CSNY><SFZH></SFZH> <HF></HF><LXDH></LXDH><DWDM></DWDM><PROJECTID></PROJECTID>");
 // sb.append("<ZJRQ>");
 // sb.append("2020-01-01^2020-01-02");
 // sb.append("</ZJRQ>\n");
 			String resultXml = this.invokeByAxis(map, endpoint, "http://tempuri.org/", "ZK_GetStudyID");
 			System.err.println(resultXml);
 		} catch (Exception e) { 
 			System.err.println(e.toString());
 			e.printStackTrace();
 		}

## 第一种 axis 方式 ##

/** * axis方式访问webservice * * @param dataMap * 请求的xml的报文 * @param endPoint * webservice的wsdl地址,例如：http://localhost:8080/project/services/ * mainName?wsdl * @param namespace * 调用方法的命名空间 * @param method * 调用的方法名 * @return 返回调用的报文(xml) * @throws IOException * */
 	public static String invokeByAxis(Map dataMap, String endPoint, String namespace, String method)
 			throws IOException { 
 		// 拼接好xml
 		 String responseXML = "";
 		 Service service = new Service();
 		 try { 
 		 Call call = (Call) service.createCall();
 		 //设置请求超时时间
 		 call.setTimeout(5000);
 		 //webservice接口地址
 		 call.setTargetEndpointAddress(endPoint);
 		 //请求方法
 		 call.setOperationName(method);
 		 //请求命名空间
 		 call.setOperationName(new javax.xml.namespace.QName(namespace,
 		 method));
 		 call.setReturnType(org.apache.axis.encoding.XMLType.XSD_STRING);//
 		 设置返回类型
 		 //是否是soapaction
 		// call.setUseSOAPAction(true);
 		 call.setSOAPActionURI(namespace + "ZK_GetPerson");
 		 //封装请求参数
 		 Set<String> set = dataMap.keySet();
 		 List<Object> objParams = new ArrayList<>();
 		 for(Iterator<String> it=set.iterator(); it.hasNext();){ 
 			 String key = it.next();
 			 Object value = dataMap.get(key);
 			 objParams.add(value);
 			 call.addParameter(key,
 			 org.apache.axis.encoding.XMLType.XSD_STRING,javax.xml.rpc.ParameterMode.IN);
 			 System.err.println("------------------key ===============" + key);
 		 }
 		 call.setReturnType(XMLType.XSD_STRING);
 		 System.err.println(objParams.toArray());
 		 System.err.println(call.getTargetEndpointAddress());
 		 System.err.println(call.getOperationName());
 		 System.err.println(call.getSOAPActionURI());
 		
 		 responseXML = (String) call.invoke(objParams.toArray());
 		 } catch (Exception e) { 
 		 System.err.println("WebService请求异常！原因: "+e.fillInStackTrace());
 		 }
 		return responseXML;
 	}

## 第二种方法 ##

/** * axis方式访问webservice * * @param dataMap * 请求的xml的报文 * @param endPoint * webservice的wsdl地址,例如：http://localhost:8080/project/services/ * mainName?wsdl * @param namespace * 调用方法的命名空间 * @param method * 调用的方法名 * @return 返回调用的报文(xml) * @throws IOException * */
 	public static String invokeByAxis(String dataMap, String endPoint, String namespace, String method)
 			throws IOException { 
 		// 拼接好xml
 		String xmlStr = getXml(method, dataMap, namespace);
 		System.out.println(xmlStr);
 		String serviceAddress = endPoint; // 服务地址(将XXXX替换成自己项目的地址)
 		String charSet = "utf-8";
 		String contentType = "text/xml; charset=utf-8";
 		String result = "";
 		Map<String, Object> responseSoapMap = SoapUtil.responseSoap(xmlStr, serviceAddress, charSet, contentType);
 		Integer statusCode = (Integer) responseSoapMap.get("statusCode");
 		if (statusCode == 200) { 
 			String responseSoap = (String) responseSoapMap.get("responseSoap");
 			String targetNodeName = "isSuccess";
 			Document doc = XMLUtil.strXmlToDocument(responseSoap);
 			result = XMLUtil.getValueByElementName(doc, targetNodeName);
 			if (!StringUtils.isEmpty(result)) { 
 				System.out.println(result);
 			} else { 
 				System.out.println("没有此节点或者没有值！");
 			}
 		} else { 
 			System.out.println("请求失败！");
 		}
 
 		return result;
 }
 
 
 
 /** * 设置xml * * @param method * 方法名称 * @param paramXml * 参数的xml * @param targetNameSpace * 命名空间 * @return */
 	private static String getXml(String method, String paramXml,String targetNameSpace) { 
 		// 拼接好xml
 		StringBuffer sb = new StringBuffer();
 		sb.append(
 				"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" +
 				"<soap:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n" +
 				"<soap:Body>\n" +
 				"<ZK_GetPerson xmlns=\"http://tempuri.org/\">" +
 				"<Request>" + paramXml +"</Request>\n" + 
 				"</ZK_GetPerson>" +
 				"</soap:Body>" +
 				"</soap:Envelope>"
 				);
 				
 		String xmlStr = sb.toString();
 		System.out.println(xmlStr);
 		return xmlStr;

第二种方法相关工具

package com.ruoyi.quartz.util;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.LinkedList;
 import java.util.List;
 import com.ruoyi.common.utils.StringUtils;
 import com.ruoyi.common.utils.spring.SpringUtils;
 import com.ruoyi.quartz.domain.SysJob;
 
 /** * 任务执行工具 * * @author ruoyi */
 public class JobInvokeUtil
 { 
 /** * 执行方法 * * @param sysJob 系统任务 */
 public static void invokeMethod(SysJob sysJob) throws Exception
 { 
 String invokeTarget = sysJob.getInvokeTarget();
 String beanName = getBeanName(invokeTarget);
 String methodName = getMethodName(invokeTarget);
 List<Object[]> methodParams = getMethodParams(invokeTarget);
 
 if (!isValidClassName(beanName))
 { 
 Object bean = SpringUtils.getBean(beanName);
 invokeMethod(bean, methodName, methodParams);
 }
 else
 { 
 Object bean = Class.forName(beanName).newInstance();
 invokeMethod(bean, methodName, methodParams);
 }
 }
 /** * 调用任务方法 * * @param bean 目标对象 * @param methodName 方法名称 * @param methodParams 方法参数 */
 private static void invokeMethod(Object bean, String methodName, List<Object[]> methodParams)
 throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException,
 InvocationTargetException
 { 
 if (StringUtils.isNotNull(methodParams) && methodParams.size() > 0)
 { 
 Method method = bean.getClass().getDeclaredMethod(methodName, getMethodParamsType(methodParams));
 method.invoke(bean, getMethodParamsValue(methodParams));
 }
 else
 { 
 Method method = bean.getClass().getDeclaredMethod(methodName);
 method.invoke(bean);
 }
 }
 
 /** * 校验是否为为class包名 * * @param invokeTarget 名称 * @return true是 false否 */
 public static boolean isValidClassName(String invokeTarget)
 { 
 return StringUtils.countMatches(invokeTarget, ".") > 1;
 }
 
 /** * 获取bean名称 * * @param invokeTarget 目标字符串 * @return bean名称 */
 public static String getBeanName(String invokeTarget)
 { 
 String beanName = StringUtils.substringBefore(invokeTarget, "(");
 return StringUtils.substringBeforeLast(beanName, ".");
 }
 
 /** * 获取bean方法 * * @param invokeTarget 目标字符串 * @return method方法 */
 public static String getMethodName(String invokeTarget)
 { 
 String methodName = StringUtils.substringBefore(invokeTarget, "(");
 return StringUtils.substringAfterLast(methodName, ".");
 }
 
 /** * 获取method方法参数相关列表 * * @param invokeTarget 目标字符串 * @return method方法相关参数列表 */
 public static List<Object[]> getMethodParams(String invokeTarget)
 { 
 String methodStr = StringUtils.substringBetween(invokeTarget, "(", ")");
 if (StringUtils.isEmpty(methodStr))
 { 
 return null;
 }
 String[] methodParams = methodStr.split(",");
 List<Object[]> classs = new LinkedList<>();
 for (int i = 0; i < methodParams.length; i++)
 { 
 String str = StringUtils.trimToEmpty(methodParams[i]);
 // String字符串类型，包含'
 if (StringUtils.contains(str, "'"))
 { 
 classs.add(new Object[] { StringUtils.replace(str, "'", ""), String.class });
 }
 // boolean布尔类型，等于true或者false
 else if (StringUtils.equals(str, "true") || StringUtils.equalsIgnoreCase(str, "false"))
 { 
 classs.add(new Object[] { Boolean.valueOf(str), Boolean.class });
 }
 // long长整形，包含L
 else if (StringUtils.containsIgnoreCase(str, "L"))
 { 
 classs.add(new Object[] { Long.valueOf(StringUtils.replaceIgnoreCase(str, "L", "")), Long.class });
 }
 // double浮点类型，包含D
 else if (StringUtils.containsIgnoreCase(str, "D"))
 { 
 classs.add(new Object[] { Double.valueOf(StringUtils.replaceIgnoreCase(str, "D", "")), Double.class });
 }
 // 其他类型归类为整形
 else
 { 
 classs.add(new Object[] { Integer.valueOf(str), Integer.class });
 }
 }
 return classs;
 }
 
 1.11111111111111111111111111
 /** * 获取参数类型 * * @param methodParams 参数相关列表 * @return 参数类型列表 */
 public static Class<?>[] getMethodParamsType(List<Object[]> methodParams)
 { 
 Class<?>[] classs = new Class<?>[methodParams.size()];
 int index = 0;
 for (Object[] os : methodParams)
 { 
 classs[index] = (Class<?>) os[1];
 index++;
 }
 return classs;
 }
 
 /** * 获取参数值 * * @param methodParams 参数相关列表 * @return 参数值列表 */
 public static Object[] getMethodParamsValue(List<Object[]> methodParams)
 { 
 Object[] classs = new Object[methodParams.size()];
 int index = 0;
 for (Object[] os : methodParams)
 { 
 classs[index] = (Object) os[0];
 index++;
 }
 return classs;
 }
 }

2.22222222222222222

package com.ruoyi.common.task;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.StringReader;
 import java.io.UnsupportedEncodingException;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 import org.apache.commons.httpclient.HttpClient;
 import org.apache.commons.httpclient.methods.InputStreamRequestEntity;
 import org.apache.commons.httpclient.methods.PostMethod;
 import org.apache.commons.httpclient.methods.RequestEntity;
 import org.jdom2.Document;
 import org.jdom2.Element;
 import org.jdom2.JDOMException;
 import org.jdom2.input.SAXBuilder;
 import org.xml.sax.InputSource;
 
 /** * soap 工具类 * * @author ruoyi */
 public class XMLUtil{ 
 	
 	/** * Description: 将字符串类型的XML 转化成Docunent文档结构 * @param parseStrXml 待转换的xml 字符串 * @return */
 	public static Document strXmlToDocument(String parseStrXml){ 
 	 	StringReader read = new StringReader(parseStrXml); 
 	 //创建新的输入源SAX 解析器将使用 InputSource 对象来确定如何读取 XML 输入 
 	 InputSource source = new InputSource(read); 
 	 //创建一个新的SAXBuilder 
 	 SAXBuilder sb = new SAXBuilder(); // 新建立构造器 
 	 Document doc = null;
 			try { 
 				doc = sb.build(source);
 			} catch (JDOMException e) { 
 				e.printStackTrace();
 			} catch (IOException e) { 
 				e.printStackTrace();
 			} 
 	 	return doc;
 	 	
 	 }
 	
 	
 	
 	
 	/** * Description: 根据目标节点名获取值 * @param doc 文档结构 * @param finalNodeName 最终节点名 * @return * * @author huoge */
 public static String getValueByElementName(Document doc,String finalNodeName){ 
 	 Element root = doc.getRootElement();
 HashMap<String,Object> map=new HashMap<String,Object>();
 //调用getChildAllText方法。获取目标子节点的值 
 Map<String,Object> resultmap=getChildAllText(doc, root,map); 
 String result=(String)resultmap.get(finalNodeName);
 return result;
 }
 
 
 
 /** * Description: 递归获得子节点的值 * @param doc 文档结构 * @param e 节点元素 * @param resultmap 递归将值压入map中 * @return * * @author huoge */
 public static Map<String ,Object> getChildAllText(Document doc, Element e,HashMap<String,Object> resultmap) 
 { 
 if (e != null) 
 { 
 if (e.getChildren() != null) //如果存在子节点
 { 
 List<Element> list = e.getChildren(); 
 for (Element el : list) //循环输出
 { 
 if(el.getChildren().size() > 0) //如果子节点还存在子节点，则递归获取
 { 
 getChildAllText(doc, el,resultmap); 
 } 
 else 
 { 
 	resultmap.put(el.getName(), el.getTextTrim()); //将叶子节点值压入map
 } 
 } 
 } 
 } 
 return resultmap; 
 } 
 }

第二种方法的原文链接 ： https://blog.csdn.net/walkcode/article/details/7871021