我们将主要围绕当前最主流和推荐的 JAX-RS (Jakarta RESTful Web Services) 和 Spring Boot 技术栈来展开。

目录

1. 第一步：选择技术栈
   • 1. 核心框架 (JAX-RS vs. Spring Boot)
   • 2. Web 容器/服务器
   • 3. 打包工具
2. 第二步：开发 Web 服务
   • 1. 使用 JAX-RS (如 Jersey, RESTEasy)
   • 2. 使用 Spring Boot (更推荐)
3. 第三步：打包应用
   • 1. 打包成 WAR 文件
   • 2. 打包成可执行的 JAR 文件 (Spring Boot 常用)
4. 第四步：选择部署模式
   • 1. 传统部署：部署到外部 Web 容器 (如 Tomcat)
   • 2. 内嵌部署：运行独立的 Java 应用 (Spring Boot 常用)
5. 第五步：执行部署
   • 1. 部署 WAR 到 Tomcat
   • 2. 运行 Spring Boot JAR
6. 第六步：验证与监控
7. 第七步：高级部署选项 (容器化与云原生)
   • 1. 使用 Docker
   • 2. 部署到云平台

第一步：选择技术栈

在开始之前,你需要明确你的技术选型。

1. 核心框架

这是实现 Web 服务的核心。

• JAX-RS (Java API for RESTful Web Services):

  • 标准规范：Java EE（现为 Jakarta EE）的一部分，是 Java 官方的 REST API 标准。
  • 实现框架：你需要选择一个具体的实现库。
    • Jersey: 参考 JAX-RS 规范的参考实现，功能强大，社区活跃。
    • RESTEasy: JBoss (Red Hat) 提供的实现，与 JBoss/WildFly 集成度高。
  • 特点: 轻量级，规范驱动，如果你不想被某个框架绑定，这是一个好选择。

• Spring Boot:

  
  （图片来源网络，侵删）
  • 框架: 一个“约定优于配置”的框架，极大地简化了 Spring 应用的创建和部署。
  • 特点:
    • 开箱即用: 内嵌了 Tomcat, Jetty 或 Undertow 等 Web 服务器，无需额外安装。
    • 快速开发: 通过 @RestController 等注解，可以快速创建 RESTful 服务。
    • 生态强大: 拥有庞大的社区和丰富的“Starter”依赖，整合各种技术非常方便。
    • 当前主流: 在企业级应用中是绝对的主流选择。

推荐: 对于新项目，强烈推荐使用 Spring Boot，因为它能极大地简化开发和部署流程。

2. Web 容器/服务器

这是运行 Java Web 应用的环境。

• 传统 Web 容器 (用于部署 WAR):

  • Apache Tomcat: 最流行、轻量级的 Web 容器，支持 Servlet, JSP, JAX-RS。
  • Jetty: 另一个轻量级、高性能的 Web 服务器和容器。
  • WildFly/JBoss: 功能更全面的 Java EE 应用服务器，重量级。

• 内嵌服务器 (Spring Boot 常用):

  
  （图片来源网络，侵删）
  • Tomcat: Spring Boot 的默认内嵌服务器。
  • Jetty: 另一个流行的选择，尤其适合需要快速启动的场景。
  • Undertow: 极其轻量和高性能的服务器，也是 Spring Boot 的一个选项。

3. 打包工具

• Maven: 项目管理和构建工具，通过 pom.xml 管理依赖和构建生命周期。
• Gradle: 另一个流行的构建工具，使用 Groovy/Kotlin DSL，配置更灵活。

推荐: Maven 仍然是 Java 生态中最广泛使用的工具。

第二步：开发 Web 服务

这里我们展示两种最常见方式的代码示例。

1. 使用 Spring Boot (推荐)

创建一个 Spring Boot 项目，添加 spring-boot-starter-web 依赖。

依赖 (pom.xml):

<dependencies>
    <!-- Spring Boot Web Starter, 包含了 Tomcat 和 REST 支持 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Spring Boot Starter for testing (optional) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

代码 (src/main/java/com/example/demo/HelloController.java):

package com.example.demo;
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 // 告诉 Spring 这是一个 RESTful 控制器
@RequestMapping("/api") // 为所有方法设置基础路径
public class HelloController {
    @GetMapping("/hello") // 映射 GET 请求到 /api/hello
    public String sayHello() {
        return "Hello from Spring Boot Web Service!";
    }
    @GetMapping("/hello/{name}") // 映射 GET 请求到 /api/hello/{name}
    public String sayHelloTo(@PathVariable String name) {
        return "Hello, " + name + "!";
    }
}

2. 使用 JAX-RS (Jersey)

创建一个 Maven 项目，添加 Jersey 依赖。

依赖 (pom.xml):

<dependencies>
    <dependency>
        <groupId>org.glassfish.jersey.containers</groupId>
        <artifactId>jersey-container-servlet</artifactId>
        <version>3.1.2</version> <!-- 使用最新版本 -->
    </dependency>
    <dependency>
        <groupId>org.glassfish.jersey.inject</groupId>
        <artifactId>jersey-hk2</artifactId>
        <version>3.1.2</version>
    </dependency>
</dependencies>

代码 (src/main/java/com/example/demo/HelloResource.java):

package com.example.demo;
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("/api") // 设置资源的基础路径
public class HelloResource {
    @GET
    @Path("/hello")
    @Produces(MediaType.TEXT_PLAIN) // 指定返回类型为纯文本
    public String sayHello() {
        return "Hello from JAX-RS (Jersey) Web Service!";
    }
    @GET
    @Path("/hello/{name}")
    @Produces(MediaType.TEXT_PLAIN)
    public String sayHelloTo(@PathParam("name") String name) {
        return "Hello, " + name + "!";
    }
}

第三步：打包应用

根据你选择的部署模式,打包方式不同。

1. 打包成 WAR (Web Application Archive)

适用于部署到外部 Tomcat 等容器。

• Spring Boot: 需要继承 spring-boot-starter-parent 并修改打包方式。

  <!-- 在 pom.xml 中 -->
  <packaging>war</packaging>
  <!-- 排除内嵌 Tomcat (因为会部署到外部 Tomcat) -->
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <scope>provided</scope>
  </dependency>

• JAX-RS: 默认就是打包成 WAR。

使用 mvn clean package 命令，会在 target 目录下生成 .war 文件。

2. 打包成可执行的 JAR

这是 Spring Boot 最常用的方式，包含了所有依赖和内嵌服务器。

• Spring Boot: 默认就是这种方式。

  <!-- 在 pom.xml 中 -->
  <packaging>jar</packaging>
  <!-- 添加 Spring Boot Maven 插件 -->
  <build>
      <plugins>
          <plugin>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
      </plugins>
  </build>

  使用 mvn clean package 命令，会在 target 目录下生成一个可执行的 .jar 文件。

第四步：选择部署模式

1. 传统部署：部署到外部 Web 容器 (如 Tomcat)

1. 下载并安装 Tomcat: 从 Apache Tomcat 官网 下载并解压。
2. 启动 Tomcat: 运行 bin/startup.sh (Linux/macOS) 或 bin/startup.bat (Windows)。
3. 部署 WAR:
   • 方法一 (手动): 将你的 .war 文件直接复制到 Tomcat 的 webapps 目录下，Tomcat 会自动检测并部署它。
   • 方法二 (管理界面): 访问 http://localhost:8080/manager/html，输入在 tomcat-users.xml 中配置的用户名和密码，选择 WAR 文件进行部署。

2. 内嵌部署：运行独立的 Java 应用 (Spring Boot 常用)

这种方式非常简单,因为你已经打包成了一个可执行的 JAR。

1. 确保你有 Java 环境: java -version。
2. 运行 JAR 文件:

   java -jar target/your-application-name-0.0.1-SNAPSHOT.jar

3. 应用启动: Spring Boot 会启动内嵌的 Tomcat 服务器，默认监听 8080 端口。

第五步：执行部署

1. 部署 WAR 到 Tomcat 示例

假设你的 WAR 文件是 demo-0.0.1-SNAPSHOT.war。

1. 将 demo-0.0.1-SNAPSHOT.war 复制到 /path/to/tomcat/webapps/ 目录。
2. 观察 Tomcat 的 logs/catalina.out 文件，你会看到部署和启动日志。
3. 访问你的服务,如果你的 WAR 文件名为 demo-0.0.1-SNAPSHOT.war，访问路径就是 http://localhost:8080/demo-0.0.1-SNAPSHOT/api/hello。
4. 为了方便,你可以将 WAR 文件重命名为 demo.war，这样访问路径就是 http://localhost:8080/demo/api/hello。

2. 运行 Spring Boot JAR 示例

1. 打开终端,进入 JAR 文件所在目录。
2. 执行命令：

   java -jar target/demo-0.0.1-SNAPSHOT.jar

3. 看到 Started DemoApplication in X seconds (X 是启动时间) 的日志，表示启动成功。
4. 访问服务：http://localhost:8080/api/hello。

第六步：验证与监控

部署完成后,必须验证服务是否正常运行。

1. 使用浏览器: 直接访问你的 API 端点。
2. 使用 curl (命令行工具):

   curl http://localhost:8080/api/hello
   # 预期输出: Hello from Spring Boot Web Service!

3. 使用 API 测试工具: 如 Postman, Insomnia 等。
4. 查看日志:
   • Tomcat: 查看 logs/catalina.out 或 logs/localhost.日期.log.x。
   • Spring Boot JAR: 日志会直接打印在控制台，你也可以配置日志输出到文件。
5. 监控: 对于生产环境，需要使用监控工具如 Prometheus + Grafana 或 Spring Boot Actuator 来监控应用的健康状态、性能指标等。

第七步：高级部署选项 (容器化与云原生)

1. 使用 Docker

Docker 可以将你的应用及其所有依赖打包到一个轻量级、可移植的容器中。

1. 创建 Dockerfile:

   # 使用官方的 OpenJDK 17 镜像作为基础镜像
   FROM openjdk:17-jdk-slim
   # 设置工作目录
   WORKDIR /app
   # 将 target 目录下的 JAR 文件复制到容器的工作目录
   # 请确保你的 JAR 文件名与此处一致
   COPY target/*.jar app.jar
   # 暴露 8080 端口
   EXPOSE 8080
   # 运行 JAR 文件
   # -Dserver.port=8080 确保应用监听容器暴露的端口
   ENTRYPOINT ["java", "-jar", "/app/app.jar", "--server.port=8080"]

2. 构建 Docker 镜像:

   # -t demo-web-service:latest 给镜像打上标签
   docker build -t demo-web-service:latest .

3. 运行 Docker 容器:

   # -d: 后台运行
   # -p 8080:8080: 将主机的 8080 端口映射到容器的 8080 端口
   docker run -d -p 8080:8080 demo-web-service:latest

4. 验证:

   curl http://localhost:8080/api/hello

2. 部署到云平台

云平台提供了更强大的部署、扩展和管理能力。

• Amazon Web Services (AWS):
  • Elastic Beanstalk: 可以轻松部署和扩展你的应用，你只需上传 JAR 或 WAR 文件，它会自动处理负载均衡、自动扩展等。
  • ECS (Elastic Container Service): 运行你的 Docker 容器。
• Microsoft Azure:
  • App Service: 类似于 AWS Elastic Beanstalk，支持多种语言和框架。
  • Container Instances: 运行 Docker 容器。
• Google Cloud Platform (GCP):
  • Cloud Run: 无服务器容器平台，按需计费，自动扩缩容。
  • App Engine: 类似于 App Service 和 Elastic Beanstalk。

这些平台通常提供简单的 Web 界面或命令行工具（如 AWS CLI, Azure CLI）来上传和部署你的应用。

对于新项目,Spring Boot + Docker 是目前最主流、最高效的组合，它结合了 Spring Boot 的快速开发和 Docker 的可移植性与一致性，完美契合了云原生和 DevOps 的趋势。