首页 > 软件编程 > Java > 如何使用axis调用WebService及Java WebService调用工具类

如何使用axis调用WebService及Java WebService调用工具类

福牛 4月 26, 2023 22 0

WebService 简介

概述

能使得运行在不同机器上的不同应用无须借助附加的、专门的第三方软件或硬件，就可相互交换数据或集成。依据 WebService 规范实施的应用之间，无论它们所使用的语言、平台或内部协议是什么，都可以相互交换数据。

也就是说可以实现多语言、跨平台数据交互。

使用 axis 调用 WebService

引入依赖

pom.XML 依赖如下：

  1. <dependency>
  2.      <groupId>org.apache.axis</groupId>
  3.      <artifactId>axis</artifactId>
  4.      <version>1.4</version>
  5. </dependency>
  6. <dependency>
  7.      <groupId>org.apache.axis</groupId>
  8.      <artifactId>axis-jaxrpc</artifactId>
  9.      <version>1.4</version>
  10. </dependency>
  11. <dependency>
  12.      <groupId>axis</groupId>
  13.      <artifactId>axis-wsdl4j</artifactId>
  14.      <version>1.5.1</version>
  15. </dependency>
  16. <dependency>
  17.      <groupId>commons-discovery</groupId>
  18.      <artifactId>commons-discovery</artifactId>
  19.      <version>0.2</version>
  20. </dependency>

WebService 调用工具类

  1. package com.micromaple.common.utils;
  2.  
  3. import com.google.common.collect.Lists;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.apache.axis.client.Call;
  6. import org.apache.axis.client.Service;
  7. import org.apache.axis.encoding.XMLType;
  8. import org.apache.axis.encoding.ser.BeanDeserializerFactory;
  9. import org.apache.axis.encoding.ser.BeanSerializerFactory;
  10. import org.apache.axis.message.SOAPHeaderElement;
  11. import org.apache.axis.types.Schema;
  12. import org.apache.commons.collections.MapUtils;
  13.  
  14. import Javax.xml.namespace.QName;
  15. import javax.xml.rpc.ParameterMode;
  16. import java.util.List;
  17. import java.util.Map;
  18. import java.util.Set;
  19.  
  20. /**
  21.      * WebService – 工具类
  22.      * Title: WebServiceUtils
  23.      * Description:
  24.      *
  25.      * @author Micromaple
  26.      * @version 1.0.0
  27.      * @date 2022/7/1 12:14
  28.      */
  29. @Slf4j
  30. public class WebServiceUtils {
  31.      // 接口调用地址
  32.      private static String url = “http://127.0.0.1:8080/webservice.asmx”;
  33.      // 命名空间
  34.      private static String namespace = “http://tempuri.org/”;
  36.      /**
  37.          * WebService – 调用接口
  38.          *
  39.          * @param methodName 函数名
  40.          * @param params 参数
  41.          * @param clazz 返回对象class
  42.          * @return 返回结果(Object)
  43.          */
  44.      public static <T> T call(String methodName, Map<String, String> params, Class<T> clazz) {
  45.          // log.info(“调用 WebService 发送参数==>” + MapperUtils.mapTojson(params));
  46.          String soapActionURI = namespace + methodName;
  47.          try {
  48.              Service service = new Service();
  49.  
  50.              SOAPHeaderElement header = new SOAPHeaderElement(namespace, methodName);
  51.              header.setNamespaceURI(namespace);
  52.  
  53.              Call call = (Call) service.createCall();
  54.              call.setTargetEndpointAddress(url);
  55.  
  56.              call.setOperationName(new QName(namespace, methodName));
  57.  
  58.              // 添加参数
  59.              List<String> parameterList = Lists.newArrayList();
  60.              if (params != null) {
  61.                  Set<String> paramsKey = params.keySet();
  62.                  for (String key : paramsKey) {
  63.                      call.addParameter(new QName(namespace, key), XMLType.XSD_STRING, ParameterMode.IN);
  64.                      String pValue = MapUtils.getString(params, key);
  65.                      header.addChildElement(key).setValue(pValue);
  66.                      parameterList.add(pValue);
  67.                  }
  68.              }
  69.              call.setUseSOAPAction(true);
  70.              call.setSOAPActionURI(soapActionURI);
  71.              call.addHeader(header);
  72.  
  73.              // 进行序列化 实体类也要序列化 implements Serializable
  74.              call.registerTypeMapping(clazz, new QName(namespace, soapActionURI),
  75.                      new BeanSerializerFactory(clazz, new QName(namespace, soapActionURI)),
  76.                      new BeanDeserializerFactory(clazz, new QName(namespace, soapActionURI)));
  77.              // 设置输出的类
  78.              call.setReturnClass(clazz);
  79.              // 接口返回结果
  80.              T result = (T) call.invoke(parameterList.toArray());
  81.              log.info(“调用 WebService 接口返回===>” + result);
  82.              return result;
  83.          } catch (Exception e) {
  84.              log.error(“调用 WebService 接口错误信息==>” + e.getMessage());
  85.          }
  86.          return null;
  87.      }
  88.  
  89.      /**
  90.          * WebService – 接口调用
  91.          *
  92.          * @param methodName 函数名
  93.          * @param params 参数
  94.          * @return 返回结果(String)
  95.          */
  96.      public static String call(String methodName, Map<String, String> params) {
  97.          // log.info(“调用 WebService 发送参数==>” + MapperUtils.mapToJson(params));
  98.          String soapActionURI = namespace + methodName;
  99.          try {
  100.              Service service = new Service();
  101.  
  102.              SOAPHeaderElement header = new SOAPHeaderElement(namespace, methodName);
  103.              header.setNamespaceURI(namespace);
  104.  
  105.              Call call = (Call) service.createCall();
  106.              call.setTargetEndpointAddress(url);
  107.  
  108.              call.setOperationName(new QName(namespace, methodName));
  109.  
  110.              // 添加参数
  111.              List<String> parameterList = Lists.newArrayList();
  112.              if (params != null) {
  113.                  Set<String> paramsKey = params.keySet();
  114.                  for (String key : paramsKey) {
  115.                      call.addParameter(new QName(namespace, key), XMLType.XSD_STRING, ParameterMode.IN);
  116.                      String pValue = MapUtils.getString(params, key);
  117.                      header.addChildElement(key).setValue(pValue);
  118.                      parameterList.add(pValue);
  119.                  }
  120.              }
  121.              call.setUseSOAPAction(true);
  122.              call.setSOAPActionURI(soapActionURI);
  123.              call.addHeader(header);
  124.              // 设置返回类型
  125.              call.setReturnType(new QName(namespace, methodName), String.class);
  126.              // 接口返回结果
  127.              String result = (String) call.invoke(parameterList.toArray());
  128.              log.info(“调用 WebService 接口返回===>” + result);
  129.              return result;
  130.          } catch (Exception e) {
  131.              log.error(“调用 WebService 接口错误信息==>” + e.getMessage());
  132.          }
  133.          return null;
  134.      }
  135.  
  136.      /**
  137.          * WebService – 调用接口
  138.          *
  139.          * @param methodName 函数名
  140.          * @param params 参数
  141.          * @return 返回结果(String)
  142.          */
  143.      public static String call2(String methodName, Map<String, String> params) {
  144.          // log.info(“调用 WebService 发送参数==>” + MapperUtils.mapToJson(params));
  145.          String soapActionURI = namespace + methodName;
  146.          try {
  147.              Service service = new Service();
  148.  
  149.              SOAPHeaderElement header = new SOAPHeaderElement(namespace, methodName);
  150.              header.setNamespaceURI(namespace);
  151.  
  152.              Call call = (Call) service.createCall();
  153.              call.setTargetEndpointAddress(url);
  154.  
  155.              call.setOperationName(new QName(namespace, methodName));
  156.  
  157.              // 添加参数
  158.              List<String> parameterList = Lists.newArrayList();
  159.              if (params != null) {
  160.                  Set<String> paramsKey = params.keySet();
  161.                  for (String key : paramsKey) {
  162.                      call.addParameter(new QName(namespace, key), XMLType.XSD_STRING, ParameterMode.IN);
  163.                      String pValue = MapUtils.getString(params, key);
  164.                      header.addChildElement(key).setValue(pValue);
  165.                      parameterList.add(pValue);
  166.                  }
  167.      }
  168.              call.setUseSOAPAction(true);
  169.              call.setSOAPActionURI(soapActionURI);
  170.              call.addHeader(header);
  171.              // 设置返回类型
  172.              call.setReturnType(XMLType.XSD_SCHEMA);
  173.              // 接口返回结果
  174.              Schema schemaResult = (Schema)call.invoke(parameterList.toArray());
  175.              String result = “”;
  176.              for(int i = 0; i<schemaResult.get_any().length; i++){
  177.                  result = result + schemaResult.get_any()[i];
  178.              }
  179.              log.error(“调用 WebService 接口返回===>” + result);
  180.              return result;
  181.          } catch (Exception e) {
  182.              log.error(“调用 WebService 接口错误信息==>” + e.getMessage());
  183.          }
  184.          return null;
  185.      }
  186. }
  • 第一个方法为返回对象的方式，区别在于需要定义返回对象，属性值需要跟 WebService 中的返回对象保持一致。
  • 第二个方法适用于调用 WebService后，返回的值为 String 类型。

参数详解：

  • methodName：函数名。需要调用的 WebService 的函数名称。
  • params：参数。调用 WebService 时需传入的参数。

总结

到此这篇关于如何使用axis调用WebService及Java WebService调用工具类的文章就介绍到这了,更多相关axis调用WebService内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论