Jakarta EE Project Setup: What Actually Works?

Backed by IBM, Open Liberty is a lightweight, modular, and blazing-fast server. Its killer feature for developers is dev mode, which provides instantaneous hot reloading of code changes without restarting the server. This feature alone will save you countless hours. It starts in seconds, has fantastic documentation, and integrates beautifully with our chosen toolset.

The Step-by-Step Guide: From Zero to "Hello World"

Alright, let's put it all together. Here’s how you go from an empty folder to a running Jakarta EE application.

Prerequisites:

• A Java Development Kit (JDK), version 11 or newer.
• Apache Maven installed and configured on your system's PATH.
• Visual Studio Code installed.

Step 1: Generate Your Project with a Maven Archetype

A Maven Archetype is a project template. We'll use one specifically created for a basic Jakarta EE 10 web application. Open your terminal or command prompt and run the following command. It will ask you for a groupId (like com.mycompany), artifactId (your project name, e.g., my-jakarta-app), and a few other details. You can accept the defaults for most of them.

mvn archetype:generate \
    -DarchetypeGroupId=io.github.jakartaee-starters \
    -DarchetypeArtifactId=jakartaee10-starter-archetype \
    -DarchetypeVersion=1.0.0

This command downloads the template and creates a new project folder with the artifactId you specified. It includes a basic pom.xml with the necessary Jakarta EE 10 API dependencies, a sample JAX-RS endpoint, and the correct project structure.

Step 2: Open in VS Code & Install Extensions

Now, open the newly created project folder in VS Code.

1. Go to File > Open Folder... and select your project directory (e.g., my-jakarta-app).
2. VS Code's Java extension will automatically detect the pom.xml and set up the project.
3. If you haven't already, go to the Extensions view (Ctrl+Shift+X) and install:
   • Extension Pack for Java (by Microsoft)
   • Community Server Connectors (by Red Hat) - This is key for managing our server.

Step 3: Configure Open Liberty

Thanks to the Community Server Connectors extension, we can do this entirely within the IDE.

1. Look for the SERVERS view in the bottom panel of the Explorer sidebar. If it's not there, open the Command Palette (Ctrl+Shift+P) and search for "Servers: Focus on Servers View".
2. Click the + icon in the SERVERS view to add a new server.
3. Select Download server from servertools.com.
4. In the list that appears, find and select Open Liberty. Let it download and install; it's very quick.
5. Once installed, the server will appear in your SERVERS view. Right-click on it and select Start. It should start up in just a few seconds!

Step 4: Deploy and Verify Your Application

The final step is to build and deploy your application to the running server.

1. Open the built-in VS Code terminal (Ctrl+`).
2. Run the Maven build command to package your application into a .war file:

   mvn clean package

3. This creates a file at target/my-jakarta-app.war (the name will match your artifactId).
4. In the SERVERS view, right-click your Open Liberty server and choose Add Deployment. Select the .war file from your target directory.
5. The server will automatically deploy your application.

Now for the moment of truth! The starter archetype includes a simple JAX-RS resource. You can find it at src/main/java/com/mycompany/HelloResource.java. It looks like this:

@Path("/hello")
public class HelloResource {
    @GET
    public String hello() {
        return "Hello, Jakarta EE!";
    }
}

Open your web browser and navigate to the endpoint. The default URL will be something like this:

http://localhost:9080/my-jakarta-app/api/hello

You should see the message: "Hello, Jakarta EE!"

Congratulations! You have a fully functional, modern Jakarta EE development environment.

What's Next? Building on Your Foundation

This setup is your starting line, not the finish. From here, you can begin adding the features your application needs. Your next steps will likely involve adding more dependencies to your pom.xml to explore other parts of the Jakarta EE platform, such as:

• Jakarta Persistence (JPA): For database interaction. You'll add a provider like Hibernate.
• Jakarta Contexts and Dependency Injection (CDI): For managing beans and application lifecycle.
• Jakarta Bean Validation: For validating data models.
• Testing: Add JUnit 5 for unit tests and consider Arquillian for integration tests that run inside the server.

Conclusion

Setting up a Jakarta EE project doesn't have to be a chore. By making smart, modern choices—Maven for build management, VS Code for a lightweight IDE, and Open Liberty for a fast development server—you can create a productive and enjoyable workflow. This "golden path" gets you from zero to a running application quickly, letting you focus on what really matters: building great software.

Now go build something amazing!