1. JAX-WS (Java API for XML Web Services)：这是 Java 官方、标准的 WebService 技术，非常成熟，广泛用于企业级应用，它通常基于 SOAP (Simple Object Access Protocol) 协议，对于新手来说，使用 JAX-WS 的注解方式是最简单快捷的。
2. JAX-RS (Java API for RESTful Web Services)：这是用于创建 RESTful Web 服务的标准，它使用 HTTP 协议（GET, POST, PUT, DELETE 等）和像 JSON 或 XML 这样的数据格式，是目前更轻量、更流行的方式，尤其适合移动端和前后端分离的项目。

下面我将分别详细介绍如何使用这两种方式创建一个简单的 WebService。

使用 JAX-WS (基于 SOAP)

JAX-WS 是 Java EE 的一部分，现在也包含在 Jakarta EE 中，我们将使用注解来简化开发。

步骤 1：创建 Maven 项目并添加依赖

创建一个普通的 Maven Java 项目，在 pom.xml 文件中添加 JAX-WS 的核心依赖，如果你使用的是较新的 Jakarta EE，请使用 jakarta.xml.ws 命名空间。

<dependencies>
    <!-- JAX-WS API 核心依赖 -->
    <dependency>
        <groupId>jakarta.xml.ws</groupId>
        <artifactId>jakarta.xml.ws-api</artifactId>
        <version>3.0.1</version>
    </dependency>
    <!-- JAX-WS 实现依赖 (通常由应用服务器提供，如 Tomcat, JBoss) -->
    <!-- 如果使用内嵌服务器或独立运行，需要添加这个 -->
    <dependency>
        <groupId>com.sun.xml.ws</groupId>
        <artifactId>jaxws-rt</artifactId>
        <version>3.0.2</version>
    </dependency>
</dependencies>

步骤 2：创建 WebService 接口（Endpoint Interface）

这个接口定义了 WebService 提供的公开方法，客户端将调用这些方法。

import jakarta.jws.WebMethod;
import jakarta.jws.WebParam;
import jakarta.jws.WebService;
import jakarta.jws.soap.SOAPBinding;
// @WebService 声明这是一个 WebService 接口
@WebService
// @SOAPBinding 指定 SOAP 消息风格，默认是 DOCUMENT，这里明确指定
@SOAPBinding(style = SOAPBinding.Style.DOCUMENT)
public interface HelloWorld {
    // @WebMethod 声明这是一个 WebService 方法
    // @WebParam 指定方法的参数名
    @WebMethod
    String sayHello(@WebParam(name = "name") String name);
}

步骤 3：创建 WebService 实现类

这个类实现了上面定义的接口,并提供具体的业务逻辑。

import jakarta.jws.WebService;
// @WebService 注解在实现类上，并指定 endpointInterface 指向接口
@WebService(endpointInterface = "com.example.webservice.HelloWorld")
public class HelloWorldImpl implements HelloWorld {
    @Override
    public String sayHello(String name) {
        return "Hello, " + name + "!";
    }
}

步骤 4：发布 WebService

你需要一个主类来将你的实现发布到一个 URL 地址，使其成为一个可访问的端点。

import jakarta.xml.ws.Endpoint;
public class WSPublisher {
    public static void main(String[] args) {
        // 创建实现类的实例
        HelloWorldImpl helloWorldImpl = new HelloWorldImpl();
        // 发布 WebService
        // 第一个参数是访问的 URL，第二个参数是 WebService 的实现实例
        Endpoint.publish("http://localhost:8888/ws/hello", helloWorldImpl);
        System.out.println("WebService is published successfully!");
        System.out.println("You can access the WSDL at: http://localhost:8888/ws/hello?wsdl");
    }
}

步骤 5：运行和测试

1. 运行：直接运行 WSPublisher 的 main 方法。

2. 验证 WSDL：打开浏览器，访问 http://localhost:8888/ws/hello?wsdl，如果看到一个 XML 文件（WSDL 描述文件），说明你的 WebService 已经成功发布。

3. 客户端测试：你可以使用 Java 自带的 wsimport 工具来生成客户端代码进行测试。

   • 打开命令行,进入你的项目根目录。
   • 执行命令：wsimport -keep http://localhost:8888/ws/hello?wsdl
   • 这会在 src 目录下生成一堆客户端代码（.java 文件）。
   • 创建一个客户端测试类：

   // 生成的客户端代码中会有一个 Service 类，名字可能类似 Hello_Service
   import com.example.webservice.HelloWorld;
   import com.example.webservice.Hello_Service;
   public class WSClientTest {
       public static void main(String[] args) {
           // 创建 Service 实例，WSDL 地址
           Hello_Service service = new Hello_Service();
           // 获取 WebService 端口，即 HelloWorld 接口的代理对象
           HelloWorld helloPort = service.getHelloPort();
           // 调用方法
           String response = helloPort.sayHello("WebService Client");
           System.out.println("Response from server: " + response);
       }
   }

   运行这个客户端测试类,你将看到输出：Response from server: Hello, WebService Client!

使用 JAX-RS (创建 RESTful WebService)

JAX-RS 是创建 RESTful 服务的标准，最流行的实现是 Jersey 和 RESTEasy，这里我们以 Jersey 为例。

步骤 1：创建 Maven 项目并添加依赖

在 pom.xml 中添加 Jersey 的核心依赖。

<dependencies>
    <!-- Jersey 核心依赖 -->
    <dependency>
        <groupId>org.glassfish.jersey.containers</groupId>
        <artifactId>jersey-container-grizzly2-http</artifactId>
        <version>3.1.1</version>
    </dependency>
    <!-- 如果需要支持 JSON (通常需要) -->
    <dependency>
        <groupId>org.glassfish.jersey.media</groupId>
        <artifactId>jersey-media-json-binding</artifactId>
        <version>3.1.1</version>
    </dependency>
</dependencies>

步骤 2：创建资源类

在 JAX-RS 中，资源类就是你的 WebService，使用 @Path 注解来定义 URL 路径。

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.PathParam;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
// @Path 注解定义了该资源的基路径
@Path("/api")
public class MessageResource {
    // @GET 注解表示这个方法处理 HTTP GET 请求
    // @Path 定义了相对于类路径的子路径
    // @Produces 注解指定该方法能生成的媒体类型，这里是纯文本
    @GET
    @Path("/message/{text}")
    @Produces(MediaType.TEXT_PLAIN)
    public String getMessage(@PathParam("text") String text) {
        return "You said: " + text;
    }
    // 另一个例子，返回 JSON 格式的数据
    @GET
    @Path("/user/{username}")
    @Produces(MediaType.APPLICATION_JSON)
    public User getUser(@PathParam("username") String username) {
        // 创建一个 User 对象并返回
        // Jersey 会自动将其转换为 JSON
        User user = new User();
        user.setName(username);
        user.setEmail(username + "@example.com");
        return user;
    }
}
// 一个简单的 POJO (Plain Old Java Object)，用于 JSON 序列化
class User {
    private String name;
    private String email;
    // Getters and Setters are required for JSON conversion
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

步骤 3：创建应用并启动服务器

JAX-RS 应用需要一个 Application 子类来配置资源，然后我们使用内嵌的 Grizzly 服务器来启动它。

import jakarta.ws.rs.ApplicationPath;
import jakarta.ws.rs.core.Application;
import java.util.HashSet;
import java.util.Set;
// @ApplicationPath 注解定义了整个应用的根路径
@ApplicationPath("/rest")
public class MyApplication extends Application {
    // 返回所有需要注册的 Resource 类
    @Override
    public Set<Class<?>> getClasses() {
        Set<Class<?>> classes = new HashSet<>();
        classes.add(MessageResource.class);
        return classes;
    }
}

创建主类来启动服务器：

import org.glassfish.grizzly.http.server.HttpServer;
import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory;
import org.glassfish.jersey.server.ResourceConfig;
import java.net.URI;
public class RESTServer {
    // 定义服务器基础 URI
    public static final String BASE_URI = "http://localhost:8080/";
    public static void main(String[] args) {
        // 创建一个 ResourceConfig 实例，并注册应用
        ResourceConfig config = new ResourceConfig(MyApplication.class);
        // 创建并启动 Grizzly HTTP 服务器
        HttpServer server = GrizzlyHttpServerFactory.createHttpServer(URI.create(BASE_URI), config);
        System.out.println("Jersey app started with WADL available at "
                + BASE_URI + "application.wadl\nHit enter to stop it...");
        try {
            System.in.read();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            server.shutdownNow();
        }
    }
}

步骤 4：运行和测试

1. 运行：直接运行 RESTServer 的 main 方法。
2. 测试：
   • 打开浏览器或使用 Postman/curl 等工具。
   • 访问 http://localhost:8080/rest/api/message/HelloWorld，你将看到页面显示：You said: HelloWorld。
   • 访问 http://localhost:8080/rest/api/user/Alice，你将看到返回的 JSON 数据：{"name":"Alice","email":"Alice@example.com"}。

总结与对比

如何选择？

• 如果你正在开发一个传统的企业级应用,需要与 .NET 等其他平台深度集成，并且对安全性、事务有严格要求，选择 JAX-WS。
• 如果你正在构建一个现代化的 Web 应用或移动后端 API，追求开发效率、灵活性和性能，强烈推荐选择 JAX-RS (REST)，绝大多数新的 Java WebService 项目都采用 RESTful 风格。