Set up a Maven/Gradle project with JAX-RS dependencies like Jersey; 2. Create a REST resource using annotations such as @Path and @GET; 3. Configure the application via Application subclass or web.xml; 4. Add Jackson for JSON binding by including jersey-media-json-jackson; 5. Deploy to a Jakarta EE server or servlet container and test with tools like curl; Jakarta EE provides a standardized, enterprise-grade platform for building reliable and portable RESTful APIs using official Java specifications, making it ideal for environments prioritizing stability and long-term support.

Building RESTful APIs in Java with Jakarta EE is a solid choice for enterprise-grade applications that value stability, standards compliance, and integration with the broader Java ecosystem. Jakarta EE (formerly Java EE) provides a robust, specification-driven platform for developing scalable and maintainable REST services using JAX-RS (Jakarta RESTful Web Services).

Here’s how to build a RESTful API in Java using Jakarta EE:

1. Set Up Your Jakarta EE Project

Start by setting up a Maven or Gradle project with the necessary dependencies. If you're using Maven, include the JAX-RS API and a compatible runtime like Eclipse Jersey (reference implementation) or Apache CXF, or deploy on a full Jakarta EE server like Payara, WildFly, or Open Liberty.

Example pom.xml snippet using Jersey:

<dependencies>
    <dependency>
        <groupId>org.glassfish.jersey.core</groupId>
        <artifactId>jersey-server</artifactId>
        <version>3.1.3</version>
    </dependency>
    <dependency>
        <groupId>org.glassfish.jersey.containers</groupId>
        <artifactId>jersey-container-servlet</artifactId>
        <version>3.1.3</version>
    </dependency>
    <dependency>
        <groupId>org.glassfish.jersey.inject</groupId>
        <artifactId>jersey-hk2</artifactId>
        <version>3.1.3</version>
    </dependency>
</dependencies>

Or, if you're using a full Jakarta EE application server (like Payara), most APIs are already included.

2. Create a REST Resource Class

Use JAX-RS annotations to define endpoints. The @Path, @GET, @Produces, etc., make it easy to map HTTP methods to Java methods.

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

@Path("/users")
@Produces(MediaType.APPLICATION_JSON)
public class UserResource {

    @GET
    public Response getAllUsers() {
        // In practice, fetch from a service or database
        var users = java.util.List.of(
            new User(1L, "Alice"),
            new User(2L, "Bob")
        );
        return Response.ok(users).build();
    }

    @GET
    @Path("/{id}")
    public Response getUserById(@PathParam("id") Long id) {
        if (id == 1) {
            return Response.ok(new User(1L, "Alice")).build();
        } else {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
    }

    @POST
    @Consumes(MediaType.APPLICATION_JSON)
    public Response createUser(User user) {
        // Simulate creation
        user.setId(3L); // assign ID
        return Response.status(Response.Status.CREATED).entity(user).build();
    }
}

And a simple User record or class:

public record User(Long id, String name) {
    public void setId(Long id) {
        // needed for some JSON mappers if using mutable behavior
    }
}

3. Configure the Application

You can let JAX-RS auto-discover resources, or create an Application subclass to explicitly register them.

import jakarta.ws.rs.core.Application;
import java.util.Set;

public class RestApplication extends Application {
    @Override
    public Set<Class<?>> getClasses() {
        Set<Class<?>> classes = new java.util.HashSet<>();
        classes.add(UserResource.class);
        return classes;
    }
}

Then register this in web.xml (if using it):

<web-app>
    <servlet>
        <servlet-name>javax.ws.rs.core.Application</servlet-name>
        <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
        <init-param>
            <param-name>jakarta.ws.rs.Application</param-name>
            <param-value>com.example.RestApplication</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>javax.ws.rs.core.Application</servlet-name>
        <url-pattern>/api/*</url-pattern>
    </servlet-mapping>
</web-app>

Alternatively, modern Jakarta EE apps can omit web.xml and rely on annotations.

4. Add JSON Support (MOXy or Jackson)

By default, Jersey uses MOXy for JSON binding. You can switch to Jackson for more flexibility:

Add to pom.xml:

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

Then register the JacksonFeature in your Application class or via web.xml init parameters.

5. Deploy and Test

Deploy your WAR file to a Jakarta EE or servlet container:

• Standalone: Use embedded Jetty or Tomcat with Jersey.
• Full Platform: Deploy to Payara Micro, WildFly, or Open Liberty for full Jakarta EE features.

Test with curl:

curl http://localhost:8080/yourapp/api/users
# Returns: [{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]

Key Advantages of Jakarta EE for REST APIs

• Standardized: JAX-RS is a specification — portable across implementations.
• Dependency Injection: Use @Inject with CDI for clean service layer integration.
• Security: Integrate with Jakarta Security (@RolesAllowed, etc.).
• Validation: Use Bean Validation (@NotNull, @Size) on request bodies.
• Asynchronous Processing: Support for AsyncResponse for long-running tasks.

Example with CDI:

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

    @Inject
    UserService userService;

    @GET
    public Response getAll() {
        return Response.ok(userService.getAll()).build();
    }
}

Building RESTful APIs with Jakarta EE gives you a mature, enterprise-ready foundation. While newer frameworks like Spring Boot are more popular for microservices, Jakarta EE remains a strong, standards-based alternative — especially in environments where portability and long-term support matter.

Basically, if you want to build reliable, maintainable APIs using official Java standards, Jakarta EE with JAX-RS is a proven path. Just pick your runtime, define your resources, and go.

The above is the detailed content of Building RESTful APIs in Java with Jakarta EE. For more information, please follow other related articles on the PHP Chinese website!