用JAX-RS在Java建立靜止的API

JAX-RS 是一種用於在Java 中構建RESTful API 的標準化方法，通過註解簡化REST 服務開發。 1. JAX-RS 是Jakarta EE 的規範，需依賴Jersey、RESTEasy 或Apache CXF 等實現；2. 使用@Path、@GET、@POST 等註解將Java 方法映射為HTTP 端點；3. 通過@Produces 和@Consumes 定義數據格式，結合Jackson 等庫實現JSON 序列化；4. 可通過ResourceConfig 註冊資源類並使用嵌入式服務器（如Grizzly）啟動服務；5. 推薦使用POJO/DTO、異常映射、輸入驗證和OpenAPI 文檔等最佳實踐以提升可維護性。 JAX-RS 提供了可靠且廣泛支持的REST 開發方式，適合構建企業級Web 服務。

Building RESTful APIs in Java with JAX-RS is a straightforward and standardized way to create web services that follow REST principles. JAX-RS (Java API for RESTful Web Services) is part of Java EE (now Jakarta EE) and provides a set of annotations and interfaces to simplify the development of REST endpoints.

What is JAX-RS?

JAX-RS is a specification, not an implementation. It defines how Java classes and methods can be annotated to expose HTTP endpoints. Popular implementations include:

• Jersey (reference implementation by Eclipse Foundation)
• RESTEasy (by Red Hat, commonly used with WildFly)
• Apache CXF

You can use any of these with servlet containers like Tomcat or full Java EE application servers.

Setting Up a Basic JAX-RS Project

You can start with Maven or Gradle. Here's a minimal pom.xml snippet using Jersey and embedded Grizzly server:

 <dependencies>
    <dependency>
        <groupId>org.glassfish.jersey.core</groupId>
        <artifactId>jersey-server</artifactId>
        <version>3.1.0</version>
    </dependency>
    <dependency>
        <groupId>org.glassfish.jersey.containers</groupId>
        <artifactId>jersey-container-grizzly2-http</artifactId>
        <version>3.1.0</version>
    </dependency>
    <dependency>
        <groupId>org.glassfish.jersey.inject</groupId>
        <artifactId>jersey-hk2</artifactId>
        <version>3.1.0</version>
    </dependency>
</dependencies>

Creating a Simple REST Resource

Use annotations to map Java methods to HTTP operations.

 import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;

@Path("/users")
public class UserResource {

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public String getAllUsers() {
        return "[{\"id\": 1, \"name\": \"Alice\"}, {\"id\": 2, \"name\": \"Bob\"}]";
    }

    @GET
    @Path("/{id}")
    @Produces(MediaType.APPLICATION_JSON)
    public String getUserById(@PathParam("id") int id) {
        return String.format("{\"id\": %d, \"name\": \"User%d\"}", id, id);
    }

    @POST
    @Consumes(MediaType.APPLICATION_JSON)
    public void createUser(String userData) {
        System.out.println("Received: " userData);
    }
}

Key annotations:

• @Path – defines the URL path segment
• @GET , @POST , etc. – map to HTTP methods
• @PathParam , @QueryParam – extract values from URLs
• @Produces , @Consumes – declare MIME types

Registering Resources and Running the Server

With Jersey and Grizzly, you can bootstrap the server like this:

 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 Main {
    public static void main(String[] args) {
        ResourceConfig config = new ResourceConfig(UserResource.class);
        URI baseUri = URI.create("http://localhost:8080/api/");
        HttpServer server = GrizzlyHttpServerFactory.createHttpServer(baseUri, config);
        System.out.println("Server running at " baseUri);
        System.in.read(); // Keep server running
        server.shutdown();
    }
}

Now you can access:

• GET http://localhost:8080/api/users → returns list
• GET http://localhost:8080/api/users/1 → returns user 1

Handling JSON with POJOs

Instead of raw strings, use POJOs with JSON binding (via Jackson or JSON-B):

 public class User {
    private int id;
    private String name;

    // Constructors, getters, setters
    public User() {}

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    // getters and setters...
}

Update the resource:

 @GET
@Path("/{id}")
@Produces(MediaType.APPLICATION_JSON)
public User getUserById(@PathParam("id") int id) {
    return new User(id, "User" id);
}

Ensure you have a JSON provider in classpath:

 <dependency>
    <groupId>org.glassfish.jersey.media</groupId>
    <artifactId>jersey-media-json-jackson</artifactId>
    <version>3.1.0</version>
</dependency>

Additional Features

• Query Parameters : Use @QueryParam("name") String name
• Headers : Use @HeaderParam("Authorization") String auth
• Filters/Interceptors : Add logging, auth, CORS
• Exception Mapping : Implement ExceptionMapper<t></t> to handle errors gracefully
• Dependency Injection : Works with HK2 (default in Jersey)

Best Practices

• Keep resource classes focused (one per domain entity)
• Return proper HTTP status codes ( Response.status(201).entity(user).build() )
• Use DTOs instead of exposing internal models
• Validate input with Bean Validation ( @Valid , @NotNull )
• Document APIs with OpenAPI/Swagger (via extensions like Swagger-Jersey2)

Basically, JAX-RS gives you a clean, annotation-driven way to build REST APIs in Java. Once you understand the core annotations and choose a solid implementation like Jersey or RESTEasy, it becomes easy to scale and maintain. Not flashy, but reliable and widely supported.

以上是用JAX-RS在Java建立靜止的API的詳細內容。更多資訊請關注PHP中文網其他相關文章！