杰瑞科技汇

Java webservice调用如何实现?

目录

  1. 核心概念:SOAP vs REST
  2. 使用 JDK 内置的 JAX-WS (最传统,适合 SOAP)
    • 前提条件
    • 调用步骤
    • 代码示例
    • 优缺点
  3. 使用 Apache Axis2 / CXF (功能强大的 SOAP 框架)
    • 简介
    • 调用步骤 (以 Axis2 为例)
    • 优缺点
  4. 使用 Spring Boot + RestTemplate / WebClient (最现代,推荐,适合 RESTful API)
    • 简介
    • 使用 RestTemplate (同步)
    • 使用 WebClient (异步,响应式)
    • 优缺点
  5. 使用第三方库 OkHttp (轻量级,适合 RESTful API)
    • 简介
    • 代码示例
    • 优缺点
  6. 总结与如何选择

核心概念:SOAP vs REST

在开始之前,必须明确你要调用的 WebService 是哪种类型。

Java webservice调用如何实现?-图1
(图片来源网络,侵删)
  • SOAP (Simple Object Access Protocol)

    • 协议:它是一个协议,有严格的规范(如 WSDL - Web Services Description Language)。
    • 格式:默认使用 XML 进行数据交换。
    • 特点:重量级、标准化、安全性强、支持事务,通常用于企业级应用,如银行、电信等。
    • 识别:服务端通常会提供一个 .wsdl 文件来描述接口。
  • REST (Representational State Transfer)

    • 架构风格:它不是协议,而是一种软件架构风格
    • 格式:通常使用 JSON(轻量级),也支持 XML、HTML 等。
    • 特点:轻量级、无状态、基于 HTTP 协议(GET, POST, PUT, DELETE 等),是目前 Web API 的主流标准。
    • 识别:URL 通常像 https://api.example.com/users/123,返回的数据通常是 JSON。

注意:日常我们说的 "WebService" 有时泛指所有网络服务,但技术上 SOAP 和 REST 是两种不同的东西,选择哪种调用方式,取决于服务端提供的是哪种。


方法一:使用 JDK 内置的 JAX-WS (最传统,适合 SOAP)

这是 Java 标准库自带的方式,无需额外引入第三方库,非常适合调用简单的 SOAP 服务。

Java webservice调用如何实现?-图2
(图片来源网络,侵删)

前提条件

  • Java Development Kit (JDK) 1.6 或更高版本。
  • 你需要服务的 WSDL 文件地址。http://www.webxml.com.cn/WebServices/WeatherWebService.asmx?wsdl

调用步骤

  1. 生成客户端代码:使用 JDK 自带的 wsimport 工具,根据 WSDL 文件生成 Java 客户端代码。

    # 在命令行中执行
    # -p: 指定生成的包名
    # -keep: 保留生成的源文件
    # -d: 指定 class 文件输出目录
    wsimport -p com.example.client -keep http://www.webxml.com.cn/WebServices/WeatherWebService.asmx?wsdl

    执行后,会在 com.example.client 包下生成一堆 .java 文件(如 WeatherWebService.java, WeatherWebServiceSoap.java 等)。

  2. 编写调用代码:将生成的代码文件(.java.class)引入你的项目中,然后编写调用逻辑。

代码示例

假设我们调用了上面 wsimport 生成的代码,可以这样调用:

Java webservice调用如何实现?-图3
(图片来源网络,侵删)
import com.example.client.WeatherWebService;
import com.example.client.WeatherWebServiceSoap;
public class JaxWsClientExample {
    public static void main(String[] args) {
        // 1. 创建服务视图 (Service)
        WeatherWebService service = new WeatherWebService();
        // 2. 获取服务端点 (Port)
        WeatherWebServiceSoap port = service.getWeatherWebServiceSoap();
        try {
            // 3. 调用具体的方法,传入参数
            String result = port.getWeatherbyCityName("北京");
            // 4. 处理返回结果
            System.out.println("SOAP 调用返回结果:");
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

优缺点

  • 优点
    • 无需额外依赖,JDK 自带。
    • 标准化,代码生成后调用非常简单。
  • 缺点
    • 仅适用于 SOAP 服务。
    • wsimport 工具有时可能不稳定,处理复杂 WSDL 可能会出错。
    • 生成的代码可能比较冗余。

方法二:使用 Apache Axis2 / CXF (功能强大的 SOAP 框架)

JAX-WS 无法满足需求(如处理 WS-Security, WS-Addressing 等复杂 SOAP 头)时,可以使用这些功能更全面的框架。

简介

  • Apache Axis2:Apache 旗下的 SOAP 框架,功能强大,但配置相对复杂。
  • Apache CXF:同样是 Apache 旗下的,更易用,与 Spring 集成得更好,是目前更受欢迎的选择。

调用步骤 (以 Axis2 为例)

  1. 添加依赖:在你的项目中(如 Maven)添加 Axis2 依赖。
    <!-- Maven 依赖 -->
    <dependency>
        <groupId>org.apache.axis2</groupId>
        <artifactId>axis2</artifactId>
        <version>1.7.9</version> <!-- 使用较新的稳定版本 -->
    </dependency>
  2. 生成客户端代码:使用 Axis2 提供的 WSDL2Java 工具。
    # 在 Axis2 的 bin 目录下执行
    WSDL2Java -u -p com.example.axis2client http://www.webxml.com.cn/WebServices/WeatherWebService.asmx?wsdl
  3. 编写调用代码:与 JAX-WS 类似,生成代码后直接调用。

优缺点

  • 优点
    • 支持 SOAP 的高级特性。
    • 功能非常全面和灵活。
  • 缺点
    • 引入第三方库,增加项目体积。
    • 学习曲线比 JAX-WS 陡峭。
    • 项目配置相对复杂。

方法三:使用 Spring Boot + RestTemplate / WebClient (最现代,推荐,适合 RESTful API)

绝大多数新的 WebService 都是基于 REST 风格的,Spring Boot 提供了非常优雅和强大的方式来调用 RESTful API。

简介

  • RestTemplate:Spring 3.0 引入的同步 HTTP 客户端,非常成熟稳定,功能强大。
  • WebClient:Spring 5.0 引入的响应式、非阻塞 HTTP 客户端,是 RestTemplate 的现代替代品,性能更高,特别适合高并发场景。

使用 RestTemplate (同步)

  1. 添加依赖:在 Spring Boot 项目中,spring-boot-starter-web 已经包含了 RestTemplate 所需的依赖。

  2. 配置 RestTemplate Bean

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.client.RestTemplate;
    @Configuration
    public class RestTemplateConfig {
        @Bean
        public RestTemplate restTemplate() {
            return new RestTemplate();
        }
    }
  3. 编写调用代码

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.web.client.RestTemplate;
    @Service
    public class RestTemplateService {
        @Autowired
        private RestTemplate restTemplate;
        public String callGetApi() {
            // API 的 URL
            String url = "https://jsonplaceholder.typicode.com/posts/1";
            // 直接调用,GET 请求,并将返回的 JSON 自动映射为 String
            String response = restTemplate.getForObject(url, String.class);
            // 如果返回的是 JSON 对象,可以定义一个实体类来接收
            // Post post = restTemplate.getForObject(url, Post.class);
            System.out.println("RestTemplate GET 调用结果:");
            System.out.println(response);
            return response;
        }
        public void callPostApi() {
            String url = "https://jsonplaceholder.typicode.com/posts";
            // 准备请求体 (JSON)
            String jsonRequest = "{\"title\":\"foo\",\"body\":\"bar\",\"userId\":1}";
            // 发送 POST 请求
            String response = restTemplate.postForObject(url, jsonRequest, String.class);
            System.out.println("RestTemplate POST 调用结果:");
            System.out.println(response);
        }
    }

使用 WebClient (异步,响应式)

  1. 添加依赖:确保 spring-boot-starter-webflux 在你的项目中。

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>
  2. 配置 WebClient Bean

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.reactive.function.client.WebClient;
    @Configuration
    public class WebClientConfig {
        @Bean
        public WebClient webClient() {
            return WebClient.create();
        }
    }
  3. 编写调用代码

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.web.reactive.function.client.WebClient;
    import reactor.core.publisher.Mono;
    @Service
    public class WebClientService {
        @Autowired
        private WebClient webClient;
        public Mono<String> callGetApiAsync() {
            String url = "https://jsonplaceholder.typicode.com/posts/1";
            return webClient.get()
                    .uri(url)
                    .retrieve() // 获取响应
                    .bodyToMono(String.class); // 将响应体转换为 Mono<String>
        }
        public void callGetApiExample() {
            callGetApiAsync()
                    .subscribe(response -> { // 订阅 Mono,处理结果
                        System.out.println("WebClient GET 异步调用结果:");
                        System.out.println(response);
                    });
            System.out.println("请求已发送,等待响应...");
            // 为了让主线程不退出,能看到结果
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

优缺点

  • 优点
    • 现代标准:是 Java 调用 RESTful API 的首选方案。
    • 功能强大:支持同步、异步、流式处理、各种转换器(JSON, XML)。
    • 与 Spring 生态无缝集成
    • WebClient 性能优异,适合高并发。
  • 缺点
    • 仅适用于 RESTful API,不适用于 SOAP。
    • 需要构建 Spring Boot 项目。

方法四:使用第三方库 OkHttp (轻量级,适合 RESTful API)

OkHttp 是一个非常流行、高效且易用的 HTTP 客户端,尤其适用于 Android 和 Java 后端应用。

简介

它专注于 HTTP/2 和 SPDY 支持,连接池复用,性能很好。

调用步骤

  1. 添加依赖

    <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp</artifactId>
        <version>4.12.0</version> <!-- 使用最新版本 -->
    </dependency>
  2. 编写调用代码

    import okhttp3.OkHttpClient;
    import okhttp3.Request;
    import okhttp3.Response;
    public class OkHttpExample {
        public static void main(String[] args) throws Exception {
            OkHttpClient client = new OkHttpClient();
            String url = "https://jsonplaceholder.typicode.com/posts/1";
            // 1. 创建请求
            Request request = new Request.Builder()
                    .url(url)
                    .build();
            // 2. 同步执行请求
            try (Response response = client.newCall(request).execute()) {
                if (!response.isSuccessful()) {
                    throw new IOException("Unexpected code " + response);
                }
                // 3. 获取响应体
                String responseBody = response.body().string();
                System.out.println("OkHttp GET 调用结果:");
                System.out.println(responseBody);
            }
        }
    }

优缺点

  • 优点
    • 轻量级:API 简洁,易于上手。
    • 高性能:底层支持连接池等。
    • 社区活跃
  • 缺点
    • 功能相比 RestTemplate 稍显简单,需要自己处理 JSON 等转换(通常配合 GsonJackson)。
    • 仅适用于 RESTful API。

总结与如何选择

方法 适用场景 优点 缺点
JAX-WS 调用SOAP WebService 无需第三方库,标准 仅限SOAP,工具可能不稳定
Axis2 / CXF 调用复杂SOAP WebService (如含WS-Security) 功能强大,支持SOAP高级特性 依赖重,配置复杂,学习成本高
Spring Boot + RestTemplate 调用RESTful API (现代Java项目首选) 功能全面,与Spring生态集成好,同步调用简单 仅限RESTful,需要Spring Boot环境
Spring Boot + WebClient 调用RESTful API (高并发、异步场景) 异步非阻塞,性能高,现代响应式编程 仅限RESTful,学习响应式编程模型
OkHttp 调用RESTful API (轻量级、Android/Java通用) 轻量,高效,API简洁 功能相对基础,需配合JSON库

如何选择?

  1. 先看服务类型

    • 如果服务提供的是 WSDL 文件,那么你必须使用 SOAP 相关的方案 (JAX-WS, Axis2, CXF)。
    • 如果服务提供的是 URL 接口,返回的是 JSON 数据,那么你应该使用 REST 相关的方案。
  2. 再看项目环境

    • 如果你的项目已经是 Spring Boot 项目,毫无疑问选择 RestTemplate (同步) 或 WebClient (异步)。
    • 如果是传统的 Java SE 项目,或者一个轻量级项目,需要调用 REST API,OkHttp 是一个非常好的选择。
    • 如果是遗留的 Java EE 项目,且必须调用 SOAP,JAX-WS 是最快的选择,如果遇到复杂问题再考虑 CXF

对于新项目,尤其是基于 Spring Boot 的,强烈推荐使用 RestTemplateWebClient 来调用 RESTful API,这是业界的主流和最佳实践。

分享:
扫描分享到社交APP
上一篇
下一篇