As a new Java developer or a student preparing for a career in enterprise software, understanding Jakarta EE is essential. Evolving from Java EE, it provides a reliable platform with APIs for building scalable, secure, and portable applications. Jakarta EE is used across industries such as banking, e-commerce, healthcare, and government.
Jakarta EE is a set of specifications used for building Java products and frameworks for building large-scale enterprise applications. It powers systems like banks, e-commerce sites, and corporate platforms. It builds on Java SE with additional APIs for web development, database access, messaging, and security. If your goal is to create production-grade Java applications, Jakarta EE provides the tools and standards to get there.
The Jakarta EE Get Started quickly creates a ready-to-run Jakarta EE application, removing the usual setup hassle. Instead of starting with an empty folder, you get a complete, working project that’s ready to build on, like starting with a pre-built LEGO set you can customize right away. It includes proper Maven configuration, standard directory structures, and example code that demonstrates key Jakarta EE concepts.
The starter interface presents a clean, intuitive design that guides you through the configuration process step by step. Head to start.jakarta.ee and you’ll see a clean, simple form.
Let’s walk through each option:
The first dropdown lets you choose the Jakarta EE version. By default, it’s set to Jakarta EE 11, the latest long-term support release. Each version adds new features and improvements.
javax.* changed to jakarta.*. If you see old tutorials using javax.servlet, you’ll need to change it to jakarta.servletjavax.* names. Good to recognize, but don’t start new projects with thisThe version you pick determines which features are available and the minimum Java version you need. For a new project, choosing the latest release gives you modern features and a longer support window.
The profile selection is crucial as it determines the scope of APIs available in your application. Think of profiles like pizza sizes: Core (personal) = basics only, Web (medium) = perfect for learning, Platform (party size) = everything included.
Let’s learn a little more about them.
Web Profile: This lightweight profile is designed for web application development. It includes key APIs like Jakarta Servlets, Jakarta Pages, Jakarta Faces, CDI (Contexts and Dependency Injection), EJB Lite, Jakarta Persistence, and Jakarta RESTful Web Services. The Web Profile is a good fit for most modern web apps and microservices because it keeps the runtime small while still providing the core enterprise features you need.
Core Profile: Introduced in Jakarta EE 10, this is an even lighter profile designed for microservices and cloud-native applications. It includes only the most essential APIs needed for building modern services, making it ideal for containerized deployments where resource efficiency is paramount.
Platform: The full Jakarta EE platform includes every specification and API. Choose this option if you’re building large, complex applications that need advanced features like full EJB support, Jakarta Messaging, batch processing, or comprehensive web services.
Your Java version selection must align with your Jakarta EE version requirements. The starter clearly indicates compatibility:
Here’s what each version offers:
What’s LTS? Long-term support versions get security updates for years. Non-LTS versions (such as 19 and 20) only receive 6 months of updates. If you use these for major projects and need a security fix later, you’ll have to upgrade to a newer Java version to obtain it. That’s why companies prefer LTS versions!
The runtime dropdown offers several application server options, each with distinct characteristics:
WildFly, developed by Red Hat, is recognized for its rapid startup times and minimal memory usage, making it a popular choice in production environments, supported by a robust community and comprehensive documentation.
GlassFish serves as the reference implementation, where new Jakarta EE features appear first, ensuring 100% specification compliance, making it an excellent choice for learning and testing portability.
Payara builds upon GlassFish by adding enterprise features, commercial support options, and cloud deployment optimizations, thereby bridging the gap between open-source flexibility and business requirements.
TomEE: Apache’s lightweight option that extends the familiar Apache Tomcat with Jakarta EE capabilities, making it a natural choice if you’ve used Tomcat before or have applications that started simple and grew to need enterprise features.
Open Liberty: IBM’s open-source runtime, optimized for cloud-native deployments with features like instant startup and efficient memory usage. It offers excellent Kubernetes integration and sophisticated configuration management.
Now you might ask, why are there so many runtime options? Jakarta EE is a specification (like a blueprint), and different companies create their own implementations. This competition drives innovation and offers a choice tailored to your needs. The good news is that your Jakarta EE application will run on any of these servers without requiring code changes, so you’re never locked in.
Docker is like a shipping container for your application. Just as shipping containers allow goods to be transported consistently across different ships, trucks, and trains, Docker containers enable your application to run consistently across different computers, servers, and cloud platforms.
While not essential for learning Jakarta EE basics, Docker is increasingly important in real-world jobs where applications are deployed to cloud platforms, run in Kubernetes clusters, or utilize CI/CD pipelines.
The Group and Artifact IDs follow Maven naming conventions:
Group ID (org.eclipse in the example): Typically, your organization’s
reverse domain name. This ensures global uniqueness and helps organize
dependencies. In a corporate setting, this is com.yourcompany.department.
Artifact ID (jakartaee-hello-world): Your project’s name. Choose something descriptive that follows Java naming conventions (lowercase, hyphen-separated). This becomes your WAR file name and application context root.
What’s Maven? Maven is Java’s build tool - it
downloads libraries your app needs, compiles your code, and packages everything
into a deployable file. Think of it like npm for JavaScript or pip for Python.
The good news is that the starter includes a Maven wrapper (mvnw), so you
don’t even need to install Maven separately.
When you click Generate Project, the starter creates a ready-to-use application packaged as a ZIP file. It is more than just a template; it is a working project that shows REST services, dependency injection, and proper Jakarta EE configuration. Inside, you will find source code, configuration files, build scripts, and documentation so you can start coding right away.
Unzip your downloaded project and open it in your IDE. Here’s what you got:
jakartaee-hello-world/
├── 📄 README.md → Instructions (start here!)
├── 📄 pom.xml → Maven config (defines dependencies)
├── 🔧 mvnw & mvnw.cmd → Maven wrapper (builds without installing Maven)
├── 📁 src/
│ ├── 📁 main/
│ │ ├── 📁 java/ → Your Java code goes here
│ │ │ └── 📁 com/yourname/
│ │ │ ├── 📄 HelloApplication.java → Starts REST services
│ │ │ ├── 📄 HelloWorldResource.java → Your first REST endpoint
│ │ │ └── 📄 Hello.java → A simple data class
│ │ └── 📁 webapp/ → Web files (HTML, CSS, etc.)
│ │ ├── 📄 index.html → Welcome page
│ │ └── 📁 WEB-INF/
│ │ └── 📄 web.xml → Config file (mostly empty now!)
└── 📁 target/ → Build output (appears after compiling)
After extracting the generated ZIP file, you’ll see a well-organized project that follows Maven’s standard directory layout. This is a key convention that every Java developer should be familiar with.
README.md: This Markdown file serves as the primary documentation for your project. It contains quick-start instructions and build commands. In a professional setting, maintaining clear README documentation is crucial for team collaboration. The generated README includes everything a new team member needs to get started.
pom.xml: The Maven Project Object Model file is your project’s cornerstone. This XML file manages:
Understanding POM files is essential for enterprise Java development. The generated POM adheres to best practices, including property-based version management and accurate scope declarations.
Dockerfile: When Docker support is enabled, this file defines your container image:
FROM quay.io/wildfly/wildfly:latest-jdk21
COPY target/jakartaee-hello-world.war /opt/jboss/wildfly/standalone/deployments/
This simple yet effective Dockerfile uses WildFly’s official image and leverages its automatic deployment scanner.
Maven Wrapper Files (mvnw, mvnw.cmd, .mvn/): These ensure build
reproducibility across different environments. Team members don’t need Maven
installed because the wrapper automatically downloads the correct version of
Maven.
This is where your application logic lives. The package structure
org/eclipse/jakarta/hello/ follows Java naming conventions.
HelloApplication.java: This class bootstraps Jakarta RESTful Web Services:
@ApplicationPath("rest")
public class HelloApplication extends Application {
// This empty class is sufficient to enable JAX-RS
}
This class is like the front desk of a hotel - it tells Jakarta EE where to
find your REST endpoints.
@ApplicationPath("rest") means all your API endpoints will start with
/rest/
For example, if your app runs on http://localhost:8080/myapp, your APIs will be
available at http://localhost:8080/myapp/rest/....
You don’t need to write any code in this class; the annotation does all the work!
HelloWorldResource.java: This is where the magic happens! This class defines what happens when someone visits your API URLs. It handles incoming web requests (such as when someone types a URL in their browser), processes the request, and decides what to send back. It also automatically converts Java objects to JSON for web responses. Let’s think about the specific annotations.
@Path: Defines the URL pattern (e.g., @Path("/hello") creates endpoint /rest/hello)@GET: Responds to GET requests (like clicking a link or typing a URL in a browser)@POST: Responds to POST requests (like submitting a form)@Produces: Tells the browser what type of content you’re sending back@PathParam: Captures parts of the URL as variablespackage org.eclipse.jakarta.hello;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.QueryParam;
import jakarta.ws.rs.core.MediaType;
@Path("hello")
public class HelloWorldResource {
@GET
@Produces({ MediaType.APPLICATION_JSON })
public Hello hello(@QueryParam("name") String name) {
if ((name == null) || name.trim().isEmpty()) {
name = "world";
}
return new Hello(name);
}
}
Hello.java: This is a simple Java class that represents the data your API sends and receives. In real-world applications, these are commonly referred to as POJOs (Plain Old Java Objects) or DTOs (Data Transfer Objects). Jakarta EE automatically converts these objects to JSON when sending responses.
package org.eclipse.jakarta.hello;
public class Hello {
private String name;
public Hello(String name) {
this.name = name;
}
public String getHello(){
return name;
}
}
The above Hello.java will produce JSON:
{
"message": "Hello, World!"
}
Web Application Resources (src/main/webapp/)
This folder contains all content that is served directly to web browsers.
index.html: This is the first page visitors see when they go to your application’s main URL.
WEB-INF/web.xml: This is your application’s configuration file, also known as the “deployment descriptor.” It tells the server how to run your application. In modern Jakarta EE, most configuration is done with annotations, so this file is often minimal
target/: This folder is created automatically when you build your project. It contains:
This directory is typically excluded from version control (via .gitignore) as it contains only generated artifacts.
Before working with the generated project, you need a properly configured development environment. This setup process is a one-time investment that prepares you for professional Jakarta EE development.
I prefer using SDKMAN for installing Java, as it makes version management extremely easy and handles environment variables for me. Visit the SDKMAN website and follow the instructions; it’s a fairly simple process.
If you prefer a traditional approach, visit Adoptium.net or your preferred Java distribution website to download the installer. Just make sure to set JAVA_HOME properly - SDKMAN handles this automatically, but manual installations require manual configuration.
Verify installation with:
java —version\
javac —version
Both commands should report version 21 (or your selected version).
While not strictly required, an Integrated Development Environment (IDE) significantly improves productivity:
IntelliJ IDEA offers excellent Jakarta EE support with its Ultimate Edition. Features include intelligent code completion, automatic deployment, and integrated application server management.
Eclipse IDE for Enterprise Java Developers: Free and open-source with comprehensive Jakarta EE tooling. Natural choice given Jakarta EE’s Eclipse Foundation ownership.
Visual Studio Code: Lightweight option with Java extensions. While not as feature-rich for enterprise Java, it’s increasingly popular among developers.
Now that you understand your project structure, let’s get your application up and running! Our project uses Maven to build and run the application.
If you’re on Mac, Linux, or Unix, you need to make the Maven wrapper executable:
chmod +x mvnw
It makes the mvnw script runnable on your system.
Now for the exciting part - let’s start your application! If you choose a different runtime, refer to your README.md file, where you will find instructions on how to run it.
./mvnw clean package wildfly:run
The windows equivalent would be:
mvnw.cmd clean package wildfly:run
The Maven command performs several operations:
clean: Removes previous build artifactspackage: Compiles code and creates the WAR filewildfly:run: Downloads WildFly (if needed) and deploys your
applicationAccess your application at http://localhost:8080/jakartaee-hello-world.
The welcome page provides links to explore the REST endpoint.
Try http://localhost:8080/jakartaee-hello-world/rest/hello?name=YourName
to see JSON response generation in action.
That senior developer at your dream company? They started with a “Hello World” just like this. The difference between you and them is just time and practice. You’ve already taken the first step, and keep going!