我会从最经典、最基础的 JAX-WS 开始，然后介绍更现代、更灵活的 JAX-RS (RESTful)，最后介绍当前主流的 Spring Boot 集成方案，这三种方式覆盖了绝大多数 Java Web 服务的开发场景。

概览：三种主要方式

使用 JAX-WS 发布 SOAP Web 服务

JAX-WS (Java API for XML Web Services) 是 Java 官方发布的用于创建 SOAP Web 服务的标准，它通常与 XML 消息绑定。

核心概念

• 服务端点: 一个 Java 类，通过注解 @WebService 标记，其中包含一个或多个作为 Web 服务方法公开的业务方法。
• 发布: 使用 javax.xml.ws.Endpoint 类将一个服务端点实例发布到一个 URL。

示例代码

步骤 1: 创建服务端点接口

这是一个可选但推荐的做法，定义了服务的“契约”。

// IMyWebService.java
import javax.jws.WebMethod;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
// @WebService: 将此接口标记为 Web Service 接口
@WebService
// @SOAPBinding: 指定 SOAP 消息风格为 DOCUMENT，使用 LITERAL 编码
@SOAPBinding(style = SOAPBinding.Style.DOCUMENT, use = SOAPBinding.Use.LITERAL)
public interface IMyWebService {
    @WebMethod
    String sayHello(String name);
}

步骤 2: 实现服务端点

// MyWebServiceImpl.java
import javax.jws.WebService;
// @WebService: 实现类必须实现 SEI，并指定 endpointInterface
@WebService(endpointInterface = "com.example.webservice.IMyWebService")
public class MyWebServiceImpl implements IMyWebService {
    @Override
    public String sayHello(String name) {
        System.out.println("Server received request for: " + name);
        return "Hello, " + name + " from JAX-WS Service!";
    }
}

步骤 3: 发布服务

// Publisher.java
import javax.xml.ws.Endpoint;
public class Publisher {
    public static void main(String[] args) {
        // 1. 创建服务实现类的实例
        IMyWebService implementor = new MyWebServiceImpl();
        // 2. 发布服务到指定地址
        //    发布后，可以通过 http://localhost:8888/ws/hello?wsdl 访问 WSDL 文件
        String address = "http://localhost:8888/ws/hello";
        Endpoint.publish(address, implementor);
        System.out.println("JAX-WS Service is published at: " + address);
        System.out.println("WSDL is available at: " + address + "?wsdl");
    }
}

步骤 4: 运行和测试

1. 运行 Publisher 的 main 方法。
2. 打开浏览器，访问 http://localhost:8888/ws/hello?wsdl，如果看到一个 XML 文件（WSDL）,说明服务发布成功。
3. 测试工具:
   • SoapUI: 非常流行的 SOAP 测试工具。
   • IDE 插件: 如 IDEA 的 SoapUI 插件。
   • 命令行工具: wsimport (JDK自带) 可以根据 WSDL 生成客户端代码进行调用。

使用 JAX-RS 发布 RESTful Web 服务

JAX-RS (Java API for RESTful Web Services) 是 Java 官方发布的用于创建 RESTful Web 服务的标准，它更轻量级，通常与 JSON 数据格式配合使用。

核心概念

• 资源类: 一个 Java 类，通过 @Path 注解标记其 URL 路径。
• HTTP 方法: 使用 @GET, @POST, @PUT, @DELETE 等注解标记方法，对应 HTTP 请求方法。
• 提供者: 用于处理输入和输出，如将 Java 对象序列化为 JSON (@Produces("application/json")) 和反序列化 (@Consumes("application/json"))。
• 实现: 常见的 JAX-RS 实现有 Jersey (由 Oracle 主导) 和 RESTEasy (JBoss 主导)。

示例代码 (使用 Jersey)

步骤 1: 添加依赖

如果你使用 Maven，在 pom.xml 中添加 Jersey 核心依赖：

<dependency>
    <groupId>org.glassfish.jersey.containers</groupId>
    <artifactId>jersey-container-simple-http</artifactId>
    <version>2.39</version>
</dependency>

步骤 2: 创建资源类

// MyResource.java
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
// @Path: 定义资源的基础路径
@Path("/api")
public class MyResource {
    // @GET: 响应 HTTP GET 请求
    // @Path: 定义相对于类路径的子路径
    // @Produces: 指定该方法返回的 MIME 类型 (这里返回 JSON)
    @GET
    @Path("/greet/{name}")
    @Produces(MediaType.APPLICATION_JSON)
    public Greeting getGreeting(@PathParam("name") String name) {
        // 创建一个简单的 Java 对象，Jersey 会自动将其序列化为 JSON
        Greeting greeting = new Greeting();
        greeting.setMessage("Hello, " + name + " from JAX-RS Service!");
        return greeting;
    }
}
// 一个简单的 POJO (Plain Old Java Object)，用于映射 JSON
class Greeting {
    private String message;
    // 必须有无参构造函数，并且属性有 getter/setter
    public Greeting() {}
    public String getMessage() { return message; }
    public void setMessage(String message) { this.message = message; }
}

步骤 3: 发布服务

JAX-RS 的发布通常需要一个“应用”类来注册资源。

// MyApplication.java
import org.glassfish.jersey.server.ResourceConfig;
import javax.ws.rs.ApplicationPath;
// @ApplicationPath: 定义整个 JAX-RS 应用的根路径
@ApplicationPath("/rest")
public class MyApplication extends ResourceConfig {
    public MyApplication() {
        // 注册资源类
        registerClasses(MyResource.class);
    }
}

你需要一个启动类来引导 Jersey 服务器。

// Publisher.java
import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory;
import org.glassfish.jersey.server.ResourceConfig;
import java.net.URI;
public class Publisher {
    public static final String BASE_URI = "http://localhost:8080/";
    public static void main(String[] args) {
        // 创建 ResourceConfig 实例，并注册应用类
        final ResourceConfig rc = new MyApplication();
        // 创建并启动 Grizzly HTTP 服务器
        GrizzlyHttpServerFactory.createHttpServer(URI.create(BASE_URI), rc);
        System.out.println("JAX-RS (Jersey) Service is running at: " + BASE_URI + "rest");
        System.out.println("Try accessing: " + BASE_URI + "rest/api/greet/World");
    }
}

步骤 4: 运行和测试

1. 运行 Publisher 的 main 方法。
2. 打开浏览器或使用 Postman/curl 访问 http://localhost:8080/rest/api/greet/World。
3. 你应该会看到类似 {"message":"Hello, World from JAX-RS Service!"} 的 JSON 响应。

使用 Spring Boot 发布 Web 服务 (推荐)

这是目前最流行、最高效的方式，Spring Boot 通过“约定优于配置”和“自动配置”极大地简化了 Web 服务的发布过程。

核心概念

• Spring Boot Starter: 提供开箱即用的依赖和配置。
• @RestController: Spring 提供的注解，是 @Controller 和 @ResponseBody 的组合，专门用于创建 REST 控制器。
• 自动配置: Spring Boot 会自动检测类路径下的库（如 Jackson for JSON）并配置好它们。

示例代码

步骤 1: 创建 Spring Boot 项目

最简单的方式是使用 Spring Initializr。

• Project: Maven Project
• Language: Java
• Spring Boot: 选择一个稳定版本 (如 2.7.x 或 3.x.x)
• Project Metadata: Group, Artifact, Name 等。
• Dependencies: 添加 Spring Web 依赖，这个依赖包含了 Tomcat 服务器、Spring MVC 和 Jackson (用于 JSON)。

步骤 2: 创建 REST 控制器

// GreetingController.java
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
// @RestController: 标记这是一个 RESTful 控制器
@RestController
// @RequestMapping: 定义控制器的基础路径
@RequestMapping("/api")
public class GreetingController {
    // @GetMapping: 响应 HTTP GET 请求
    // @PathVariable: 从 URL 路径中提取变量
    @GetMapping("/greet/{name}")
    public Greeting getGreeting(@PathVariable String name) {
        // 直接返回对象，Spring Boot 会自动使用 Jackson 序列化为 JSON
        return new Greeting("Hello, " + name + " from Spring Boot Service!");
    }
}
// Greeting.java
// 一个简单的 POJO，不需要任何 JAX-RS 注解
public class Greeting {
    private String message;
    public Greeting() {}
    public Greeting(String message) {
        this.message = message;
    }
    public String getMessage() { return message; }
    public void setMessage(String message) { this.message = message; }
}

步骤 3: 运行和测试

1. 找到主应用程序类（通常带有 @SpringBootApplication 注解的类），右键运行其 main 方法，Spring Boot 会自动内嵌一个 Tomcat 服务器并启动应用。
2. 打开浏览器或使用 Postman/curl 访问 http://localhost:8080/api/greet/Everyone。
3. 你会得到 JSON 响应：{"message":"Hello, Everyone from Spring Boot Service!"}。

发布 SOAP 服务 (Spring Boot)

Spring Boot 也可以轻松发布 JAX-WS 服务，但通常不推荐在同一个项目中混用，如果必须使用，可以通过配置 CXF 或 Metro 等提供者来实现，过程比纯 JAX-WS 稍复杂,但仍然比手动配置简单。

总结与建议

对于绝大多数新的 Java Web 服务项目，Spring Boot 是最佳实践，它极大地提高了开发效率,让你能更专注于业务逻辑而不是繁琐的配置。