通过webservice提交xml数据

通过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

	<!-- wsdl webService包 -->
		<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;
	    	
	    }
	
	
	
	
	/**
     * <p>Description: 根据目标节点名获取值</p>
     * @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方法。获取目标子节点的值 </span>
       Map<String,Object> resultmap=getChildAllText(doc, root,map);   
       String result=(String)resultmap.get(finalNodeName);
       return result;
    }
    
    
    
    /**
	 * <p>Description: 递归获得子节点的值</p>
	 * @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