之前系统中使用到了webservice进行第三方通信，这里总结一下常见的5种客户端调用方式。

在此之前我们先简单搭建一个webservice服务端项目，发布一个webservice服务。我这里使用springboot快速搭建一个，项目结构如下：

创建一个springboot项目，导入maven依赖：

<dependency>
     <groupId>org.projectlombok</groupId>
     <artifactId>lombok</artifactId>
     <optional>true</optional>
</dependency>
<dependency>
     <groupId>org.apache.cxf</groupId>
     <artifactId>cxf-spring-boot-starter-jaxws</artifactId>
     <version>3.3.5</version>
</dependency>

创建一个数据传输对象：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserDto {
    
    private String name;
    private int age;
    private Sex sex;
}

这里声明一个性别的枚举类型：

public enum Sex {
    
    MALE("male"), FEMALE("female");
    String value;
    private Sex(String value) {
    
        this.value = value;
    }
    public String value() {
    
        return value;
    }
}

创建一个接口，作为服务发布的接口类，为了简单只声明一个方法：

/**
 * 创建webservice服务接口
 */
@WebService(targetNamespace = "http://webservice.simplewebserviceserver.learn.com"/*一般把包名倒着写*/,
        name = "userService")
public interface UserService {
    

    /**
     * 通过用户名获取用户
     *
     * @param userName
     * @return
     */
    @WebMethod(operationName = "getUserByName")
    UserDto getUserByName(@WebParam(name = "userName") String userName);

}

创建接口的实现类：

@WebService(targetNamespace = "http://webservice.simplewebserviceserver.learn.com"/*wsdl命名空间*/,
        name = "UserService"/*portType名称 客户端生成代码时 为接口名称*/,
        serviceName = "userService"/*服务name名称*/,
        portName = "userPortName"/*port名称*/,
        endpointInterface = "com.learn.simplewebserviceserver.webservice.UserService"/*指定发布webservcie的接口类，此类也需要接入@WebService注解*/)
public class UserServiceImpl implements UserService {
    

    @Override
    public UserDto getUserByName(String userName) {
    
        return new UserDto(userName, 23, Sex.MALE);
    }
}

增加一个webservice的配置类：

@Configuration
public class CxfWebServiceConfig {
    

    // 这里需要注意 若beanName命名不是 cxfServletRegistration 时，会创建两个CXFServlet的。
    // 具体可查看下自动配置类：Declaration
    // org.apache.cxf.spring.boot.autoconfigure.CxfAutoConfiguration
    // 也可以不设置此bean 直接通过配置项 cxf.path 来修改访问路径的
    @Bean("cxfServletRegistration")
    public ServletRegistrationBean<CXFServlet> cxfServletRegistration() {
    
        // 注册servlet 拦截/ws 开头的请求 不设置 默认为：/services/*
        return new ServletRegistrationBean<CXFServlet>(new CXFServlet(), "/ws/*");
    }

    /**
     * 申明业务处理类 当然也可以直接 在实现类上标注 @Service
     *
     */
    @Bean
    public UserService userService() {
    
        return new UserServiceImpl();
    }

    /*
     * 非必要项
     */
    @Bean(name = Bus.DEFAULT_BUS_ID)
    public SpringBus springBus() {
    
        SpringBus springBus = new SpringBus();
        return springBus;
    }

    /*
     * 发布endpoint
     */
    @Bean
    public Endpoint endpoint(UserService userService) {
    
        EndpointImpl endpoint = new EndpointImpl(springBus(), userService);
        endpoint.publish("/user");// 发布地址
        return endpoint;
    }
}

到此一个简单的webservice服务端项目就搭建完成了，这里我在application.properties文件中把端口改成8081：

server.port=8081

启动项目，访问http://127.0.0.1:8081/ws/user?wsdl，如果出现以下内容则表示启动成功了：

下面介绍一下webservice客户端如何调用服务端发布的服务：

方式一：使用jdk原生代码实现调用
必要条件：
1.webservice服务端发布地址
2.webservice服务发布的接口类
3.参数和返回值实体类
创建一个maven项目，结构如下：

其中Sex，UserDto,UserService同服务端的代码，导入maven依赖：

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.12</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-core</artifactId>
			<version>3.3.5</version>
		</dependency>

核心调用代码：

public class UserClient {
    

	public static void main(String[] args) throws MalformedURLException {
    
		URL url = new URL("http://127.0.0.1:8081/ws/user?wsdl");
		// 指定命名空间和服务名称
		QName qName = new QName("http://webservice.simplewebserviceserver.learn.com", "userService");
		Service service = Service.create(url, qName);
		// 通过getPort方法返回指定接口
		UserService myServer = service.getPort(
				new QName("http://webservice.simplewebserviceserver.learn.com", "userPortName"), // 绑定端口名称
				UserService.class);
		// 调用方法 获取返回值
		UserDto userDto = myServer.getUserByName("张三");
		System.out.println(userDto);
	}
}

方式二：使用wsimport 命令，生成客户端代码然后再调用
wsimport -keep -d D:\temp\d -s D:\temp\s -p com.map -verbose http://127.0.0.1:8081/ws/user?wsdl
将生成的代码导入项目中正常使用即可，网上资料很多，这里不做赘述。

方法三：动态调用，根据发布地址动态生成客户端然后调用方法
必要条件：
1.webservice服务端发布地址
2.调用方法使用的参数和返回值
3.如果参数或返回值是实体类，需要根据指定的namespace创建实体类
创建一个maven项目，结构如下：

其中Sex，UserDto,UserService同服务端的代码，注意这里的实体类的包名是有限制的必须和服务端中的targetNamespace属性值一样，否则会报错，导入maven依赖：

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.12</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-core</artifactId>
			<version>3.3.5</version>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-transports-http</artifactId>
			<version>3.3.5</version>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-frontend-jaxws</artifactId>
			<version>3.3.5</version>
		</dependency>

核心调用代码：

public class UserClient {
    
	// 创建动态客户端
	private static Client client = null;
	static {
    
		JaxWsDynamicClientFactory factory = JaxWsDynamicClientFactory.newInstance();
		client = factory.createClient("http://127.0.0.1:8081/ws/user?wsdl");
		// 需要密码的情况需要加上用户名和密码
		// client.getOutInterceptors().add(new
		// ClientLoginInterceptor(USER_NAME,PASS_WORD));
		HTTPConduit conduit = (HTTPConduit) client.getConduit();
		HTTPClientPolicy httpClientPolicy = new HTTPClientPolicy();
		httpClientPolicy.setConnectionTimeout(2000); // 连接超时
		httpClientPolicy.setAllowChunking(false); // 取消块编码
		httpClientPolicy.setReceiveTimeout(120000); // 响应超时
		conduit.setClient(httpClientPolicy);
	}

	public static void main(String[] args) {
    
		// client.getOutInterceptors().addAll(interceptors);//设置拦截器
		try {
    
			Object[] objects = null;
			// invoke("方法名",参数1,参数2,参数3....);
			objects = client.invoke("getUserByName", "李四");
			System.out.println((UserDto) objects[0]);
		} catch (Exception e) {
    
			e.printStackTrace();
		}
		System.out.println(client);
	}
}

方式四：代理工厂的方式
必要条件：
1.webservice服务端发布地址
2.webservice服务发布的接口类
3.参数和返回值实体类
创建一个maven项目，结构如下：

其中Sex，UserDto,UserService同服务端的代码，导入maven依赖：

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.12</version>
			<scope>provided</scope>
		</dependency>

		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-core</artifactId>
			<version>3.3.5</version>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-transports-http</artifactId>
			<version>3.3.5</version>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-frontend-jaxws</artifactId>
			<version>3.3.5</version>
		</dependency>

核心调用代码：

public class UserClient {
    

	public static void main(String[] args) throws MalformedURLException {
    
		JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
		factory.setServiceClass(UserService.class);
		factory.setAddress("http://127.0.0.1:8081/ws/user?wsdl");
		UserService service = (UserService) factory.create();
		// 通过代理对象获取本地客户端
		Client client = ClientProxy.getClient(service);
		// 需要密码的情况需要加上用户名和密码
		// client.getOutInterceptors().add(new
		// ClientLoginInterceptor(USER_NAME,PASS_WORD));
		HTTPConduit conduit = (HTTPConduit) client.getConduit();
		HTTPClientPolicy httpClientPolicy = new HTTPClientPolicy();
		httpClientPolicy.setConnectionTimeout(2000); // 连接超时
		httpClientPolicy.setAllowChunking(false); // 取消块编码
		httpClientPolicy.setReceiveTimeout(120000); // 响应超时
		conduit.setClient(httpClientPolicy);
		// client.getOutInterceptors().addAll(interceptors);//设置拦截器
		try {
    
			UserDto user = service.getUserByName("王五");
			System.out.println("返回数据:" + user);
		} catch (Exception e) {
    
			e.printStackTrace();
		}
	}
}

方法五：使用httpClient的方式调用，需要借助第三方工具SoapUI获取请求xml数据格式的内容，同时请求响应内容是xml格式内容，需要自己解析。
创建一个maven项目，导入maven依赖：

		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
			<version>4.5.11</version>
		</dependency>

这里主要的是需要借助SoapUi工具，SoapUi的安装和使用网上教程有很多，这里不再赘述，总之我们借助SoapUi是为了得到请求的xml格式数据，核心调用代码：

public class UserClient {
    
	public static void main(String[] args) {
    
		// soap服务地址
		String url = "http://127.0.0.1:8081/ws/user?wsdl";

		StringBuilder soapBuilder = new StringBuilder(64);
		soapBuilder.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
		soapBuilder.append(
				"<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:web=\"http://webservice.simplewebserviceserver.learn.com\">");
		soapBuilder.append("   <soapenv:Header/>");
		soapBuilder.append("   <soapenv:Body>");
		soapBuilder.append("      <web:getUserByName>");
		soapBuilder.append("        <!--Optional:-->");
		soapBuilder.append("         <userName>").append("王大力").append("</userName>");
		soapBuilder.append("      </web:getUserByName>");
		soapBuilder.append("   </soapenv:Body>");
		soapBuilder.append("</soapenv:Envelope>");
		// 创建httpcleint对象
		CloseableHttpClient httpClient = HttpClients.createDefault();
		// 创建http Post请求
		HttpPost httpPost = new HttpPost(url);
		// 构建请求配置信息
		RequestConfig config = RequestConfig.custom().setConnectTimeout(1000) // 创建连接的最长时间
				.setConnectionRequestTimeout(500) // 从连接池中获取到连接的最长时间
				.setSocketTimeout(3 * 1000) // 数据传输的最长时间10s
				.build();
		httpPost.setConfig(config);
		CloseableHttpResponse response = null;
		try {
    
			// 采用SOAP1.1调用服务端，这种方式能调用服务端为soap1.1和soap1.2的服务
			httpPost.setHeader("Content-Type", "text/xml;charset=UTF-8");

			// 采用SOAP1.2调用服务端，这种方式只能调用服务端为soap1.2的服务
			// httpPost.setHeader("Content-Type", "application/soap+xml;charset=UTF-8");
			StringEntity stringEntity = new StringEntity(soapBuilder.toString(), Charset.forName("UTF-8"));
			httpPost.setEntity(stringEntity);
			response = httpClient.execute(httpPost);
			// 判断返回状态是否为200
			if (response.getStatusLine().getStatusCode() == 200) {
    
				String content = EntityUtils.toString(response.getEntity(), "UTF-8");
				System.out.println(content);
			} else {
    
				System.out.println("调用失败!");
			}
		} catch (Exception e) {
    
			e.printStackTrace();
		} finally {
    
			if (null != response) {
    
				try {
    
					response.close();
				} catch (IOException e) {
    
					e.printStackTrace();
				}
			}
			if (null != httpClient) {
    
				try {
    
					httpClient.close();
				} catch (IOException e) {
    
					e.printStackTrace();
				}
			}
		}
	}
}

返回内容：

<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
    <ns2:getUserByNameResponse xmlns:ns2="http://webservice.simplewebserviceserver.learn.com">
      <return>
        <age>23</age>
        <name>王大力</name>
        <sex>MALE</sex>
      </return>
    </ns2:getUserByNameResponse>
  </soap:Body>
</soap:Envelope>

到此，常用的webservice客户端调用方式就介绍完了，我自己还是比较建议使用代理工厂的方式方式进行webservice方法调用，这种方式简单快捷，也方便跟springboot项目整合，当然具体使用哪种方法应该根据实际工作出发。

经过测试发现，服务端和客户端的参数实体类中字段不必完全一样，只要保证任一接收端的参数实体中字段可以完全覆盖发送端的参数实体类中的有效字段即可。

例如，发送端实体类：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserDto {
    

	private String name;

	private Integer age;

	private Integer id;

	private String message;

}

接收端实体类：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserDto {
    

	private String name;

	// private Integer age;

	// private Integer id;

	// private String message;

}

调用：

		UserDto userDto = new UserDto();
		userDto.setName("张三");
		userDto.setAge(null);
		userDto.setId(null);
		objects = client.invoke("getUser", userDto);

由于此时有效字段只有name，所以这样调用，系统也可以正常运行。