Introduction to Jakarta EE and Enterprise Java Technologies

Course: Advanced Java Training

Topic: Introduction to Jakarta EE and Enterprise Java Technologies

Course Link: Advanced Java Training Course

Demo Link: Register for a Course Demo

Website: JustAcademy Official Website

1. Introduction to Jakarta EE

Jakarta EE, formerly known as Java Platform, Enterprise Edition (Java EE), is a collection of standardized APIs and specifications for developing enterprise-level Java applications. It provides common infrastructure for building web applications, REST APIs, business services, database-driven systems, messaging applications, and distributed enterprise software.

Enterprise applications often require authentication, authorization, transaction management, database connectivity, request processing, validation, messaging, and reliable communication between multiple systems. Jakarta EE provides standardized APIs that help developers implement these requirements without having to build every infrastructure feature from scratch.

Jakarta EE specifications are developed through an open, vendor-neutral process under the Eclipse Foundation. Compatible application server implementations provide the runtime services required by Jakarta EE applications. Explore the official Jakarta EE website.

Learning Objectives

• Understand the meaning and purpose of Jakarta EE.
• Learn the relationship between Java SE, Java EE, and Jakarta EE.
• Identify the major enterprise Java technologies.
• Understand Jakarta EE architecture, containers, and application servers.
• Explore Servlets, Jakarta REST, CDI, Persistence, and Enterprise Beans.
• Understand dependency injection, transactions, and enterprise security.
• Learn about Jakarta EE profiles and deployment environments.
• Develop a foundation for building enterprise Java applications.

2. What Is Enterprise Java?

Enterprise Java refers to Java technologies, APIs, frameworks, and development practices used to build applications that support organizational and business operations.

Unlike a simple standalone program, an enterprise application may serve thousands of users, manage large volumes of information, communicate with external services, and enforce complex business rules.

Examples of Enterprise Applications

• Banking systems: Account management, payments, transactions, and financial reporting.
• E-commerce platforms: Product catalogs, shopping carts, inventory, orders, and payments.
• Healthcare systems: Appointment scheduling, patient administration, and authorized access to records.
• Enterprise resource planning: Finance, inventory, procurement, and employee management.
• Education systems: Student registration, course management, examination, and reporting.
• Logistics applications: Shipment tracking, warehouse operations, and delivery management.
• Customer relationship management: Customer profiles, sales activities, support tickets, and reporting.

Characteristics of Enterprise Applications

• Scalability: The ability to handle growing workloads and users.
• Security: Protection of application data and operations.
• Reliability: Consistent behavior and appropriate failure handling.
• Maintainability: Code organization that supports future changes.
• Transaction management: Consistent execution of related business operations.
• Integration: Communication with databases, external APIs, and other systems.
• Availability: Infrastructure and application design that reduce unnecessary service interruptions.

3. Evolution from Java EE to Jakarta EE

Java EE was developed as an enterprise extension of the Java platform, providing standardized technologies for web and business applications. The enterprise Java specifications later moved to the Eclipse Foundation and became Jakarta EE.

This transition continued the development of enterprise Java standards while supporting open collaboration, multiple compatible implementations, and modern application deployment approaches.

Important Package Namespace Change

One important migration consideration is the change from the javax.* namespace to the jakarta.* namespace for many enterprise APIs. Jakarta EE 9 introduced this namespace transition.

For example, older Java EE applications commonly import javax.servlet.http.HttpServlet, while newer Jakarta Servlet applications import jakarta.servlet.http.HttpServlet.

// Older Java EE namespace
import javax.servlet.http.HttpServlet;

// Jakarta EE namespace
import jakarta.servlet.http.HttpServlet;

These types are not interchangeable simply by changing an import. The application's API dependencies, framework versions, build configuration, and runtime must be compatible with one another.

4. Difference Between Java SE and Jakarta EE

5. Jakarta EE Architecture

Jakarta EE supports a multi-tier architecture in which different layers have separate responsibilities. This approach helps developers organize user interaction, business logic, and data access into maintainable components.

Main Architectural Layers

1. Client tier: A browser, mobile application, or other client sends requests to the backend.
2. Web tier: Servlets, Jakarta REST resources, and other web components handle incoming requests.
3. Business tier: Application services implement business rules and coordinate operations.
4. Data tier: Persistence components communicate with databases and other data sources.

Architecture Diagram

+--------------------------------+
|          Client Tier            |
| Browser / Mobile Application    |
+---------------+----------------+
                |
                | HTTP / HTTPS
                v
+--------------------------------+
|            Web Tier             |
| Servlet / Jakarta REST / Faces  |
+---------------+----------------+
                |
                v
+--------------------------------+
|          Business Tier          |
| CDI Beans / Enterprise Beans    |
| Business Rules / Transactions   |
+---------------+----------------+
                |
                v
+--------------------------------+
|            Data Tier            |
| Jakarta Persistence / JDBC      |
| Relational Database             |
+--------------------------------+

These are logical layers, not necessarily separate physical servers. A small application may run all layers within one deployment, while a larger system may distribute components across multiple services and infrastructure resources.

6. Jakarta EE Containers and Application Servers

A Jakarta EE container is a runtime environment that manages application components and provides infrastructure services. Depending on the component type, these services can include lifecycle management, dependency injection, HTTP request processing, security integration, and transaction management.

A Jakarta EE application server provides the required runtime implementations and deployment facilities for the Jakarta EE specifications it supports.

Responsibilities of a Container

• Manage the lifecycle of supported application components.
• Provide dependency injection and component integration.
• Process web requests for deployed applications.
• Support configured transaction and security services.
• Provide access to configured resources such as database connections.
• Apply deployment configuration and runtime settings.

Examples of Runtimes and Servers

• WildFly: An application server supporting a range of Jakarta EE technologies.
• Eclipse GlassFish: An implementation associated with Jakarta EE specifications.
• Open Liberty: A modular runtime for enterprise Java applications.
• Payara Server: An enterprise Java application server.
• Apache Tomcat: A Servlet container that supports web technologies such as Jakarta Servlet and Jakarta Pages, but is not by itself a full Jakarta EE Platform implementation.

Always check the exact server version and supported specifications before choosing dependencies for a project.

7. Important Jakarta EE Technologies

Jakarta EE is a collection of specifications rather than a single framework. Developers choose the technologies required by their application architecture.

8. Jakarta Servlet Technology

Jakarta Servlet is a server-side API for processing HTTP requests and creating HTTP responses. It is commonly used in traditional Java web applications and forms part of the foundation for many Java web frameworks.

Important Servlet Concepts

• HttpServlet: A base class for implementing HTTP handlers.
• HttpServletRequest: Provides access to request parameters, headers, and other request information.
• HttpServletResponse: Provides methods for setting response headers, status codes, and content.
• Servlet lifecycle: Covers initialization, request processing, and destruction.
• URL mapping: Connects request paths to servlet components.

Servlet Example

import java.io.IOException;
import java.io.PrintWriter;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

@WebServlet("/welcome")
public class WelcomeServlet extends HttpServlet {

    @Override
    protected void doGet(
            HttpServletRequest request,
            HttpServletResponse response)
            throws ServletException, IOException {

        response.setContentType("text/plain;charset=UTF-8");

        try (PrintWriter out = response.getWriter()) {
            out.println("Welcome to Jakarta EE!");
        }
    }
}

Explanation: The servlet maps the URL path /welcome to a Java handler. When a client sends a GET request, the server responds with a welcome message.

This example requires a compatible Jakarta Servlet container and correctly configured project dependencies. It demonstrates request handling only; a complete enterprise application would typically include validation, business services, logging, and other required components.

9. Jakarta RESTful Web Services

Jakarta REST, historically known as JAX-RS, is a standard API for developing RESTful web services in Java. It allows applications to expose resources through HTTP endpoints and exchange data with browsers, mobile apps, and other services.

Common HTTP Methods

REST Resource Example

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@Path("/hello")
public class HelloResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hello from Jakarta REST!";
    }
}

Explanation: The @Path annotation defines the resource path, @GET maps the method to GET requests, and @Produces declares the response media type.

This resource must be deployed in a runtime configured with a compatible Jakarta REST implementation. The application's base URL and resource path depend on its deployment configuration.

10. Contexts and Dependency Injection (CDI)

Jakarta CDI is a specification for dependency injection and contextual lifecycle management. It helps developers build loosely coupled components and allows the runtime to manage object creation and injection.

What Is Dependency Injection?

Dependency injection is a technique in which an object receives the components it requires instead of creating all of them directly. This makes software easier to maintain, test, and extend.

Benefits of CDI

• Reduces tight coupling between classes.
• Supports modular application design.
• Allows components to be replaced or tested more easily.
• Supports lifecycle and scope management.
• Encourages reusable business services.

Example Using CDI

import jakarta.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class GreetingService {

    public String getMessage() {
        return "Welcome to Enterprise Java!";
    }
}

import jakarta.enterprise.context.RequestScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@Path("/greeting")
@RequestScoped
public class GreetingResource {

    @Inject
    private GreetingService greetingService;

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String greeting() {
        return greetingService.getMessage();
    }
}

Explanation: The runtime manages the greeting service and injects it into the resource class. The endpoint uses the injected service to obtain its response.

These examples require a compatible Jakarta EE runtime with CDI and Jakarta REST support. The selected scope determines how the runtime manages the component's lifecycle.

11. Jakarta Persistence and ORM

Jakarta Persistence is a standard API for object-relational mapping (ORM) and persistence in Java applications. It allows developers to represent database records as Java entities and perform persistence operations through an entity manager.

ORM frameworks map Java objects to relational tables and help manage relationships, queries, and entity lifecycle operations. Hibernate is a widely used implementation of Jakarta Persistence.

Important Concepts

• Entity: A Java class mapped to persistent data.
• Primary key: Uniquely identifies an entity record.
• EntityManager: Provides operations for managing entity persistence.
• Persistence context: Tracks managed entities during a unit of work.
• JPQL: A query language that works with entities and their attributes.
• Relationships: Define associations between entities.

Entity Example

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String department;

    public Employee() {
    }

    public Employee(String name, String department) {
        this.name = name;
        this.department = department;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }
}

Explanation: The @Entity annotation marks the class as a persistent entity, while @Id identifies its primary key. The generated identifier strategy and database schema must be supported by the chosen database and provider configuration.

12. Enterprise Beans and Business Components

Jakarta Enterprise Beans, commonly called EJB, is a technology for implementing server-side business components with selected container-managed capabilities.

Enterprise Beans can support features such as declarative transaction management, security, asynchronous execution, and messaging-driven processing, depending on the bean type and runtime support.

Types of Enterprise Beans

• Stateless session beans: Perform business operations without maintaining conversational state for a particular client between method calls.
• Stateful session beans: Maintain conversational state associated with a client interaction.
• Singleton session beans: Provide a shared singleton component within the relevant application runtime.
• Message-driven beans: Process messages asynchronously through supported messaging infrastructure.

Example of a Stateless Session Bean

import jakarta.ejb.Stateless;

@Stateless
public class TaxService {

    public double calculateTax(double amount, double rate) {
        if (amount < 0 || rate < 0) {
            throw new IllegalArgumentException(
                "Amount and rate must be non-negative.");
        }

        return amount * rate / 100.0;
    }
}

Explanation: The @Stateless annotation identifies a stateless session bean. The container manages the bean according to the supported Enterprise Beans specification and deployment configuration.

Not every application needs Enterprise Beans. CDI-managed components are appropriate for many business services, while Enterprise Beans remain useful when their specific container-managed capabilities are required.

13. Transaction Management with Jakarta Transactions

Transactions help ensure that a group of related database operations is treated as one logical unit. If an operation fails, transaction management can roll back changes to preserve data consistency.

ACID Properties

• Atomicity: The transaction succeeds as a unit or its changes are rolled back.
• Consistency: Valid transactions preserve defined data rules.
• Isolation: Concurrent transactions are controlled according to the selected isolation level.
• Durability: Committed changes are preserved according to the database's durability guarantees.

Jakarta Transactions defines APIs and mechanisms for transaction management. Compatible runtimes can also provide container-managed transactions for supported components.

Example: Transaction Attribute

import jakarta.ejb.Stateless;
import jakarta.ejb.TransactionAttribute;
import jakarta.ejb.TransactionAttributeType;

@Stateless
public class PaymentService {

    @TransactionAttribute(
        TransactionAttributeType.REQUIRED)
    public void processPayment() {
        // Perform operations that must participate
        // in the configured transaction.
    }
}

Explanation: The REQUIRED transaction attribute specifies that the method should use an existing transaction or have the container start one when needed. The example demonstrates configuration only; a real payment operation must implement the required business rules, persistence changes, and failure handling.

14. Security in Jakarta EE

Enterprise applications often handle sensitive data and operations. Jakarta EE provides security-related specifications and integration points for protecting application resources.

Key Security Concepts

• Authentication: Verifies the identity of a user or client.
• Authorization: Determines whether an identity may access a resource or perform an operation.
• Role-based access: Assigns permissions according to application roles.
• Transport security: Uses HTTPS and appropriate TLS configuration to protect data in transit.
• Input validation: Rejects invalid or unexpected data.
• Secure persistence: Uses parameterized database operations and appropriate access permissions.

Security Best Practices

• Protect sensitive endpoints with authentication and authorization.
• Never trust client-side validation alone.
• Use parameterized SQL statements.
• Keep secrets out of source code and public configuration files.
• Apply the principle of least privilege.
• Configure secure session and cookie behavior.
• Avoid exposing stack traces, passwords, or confidential information in error responses.
• Log security events without unnecessarily recording sensitive data.

15. Jakarta Validation

Jakarta Validation defines a standard mechanism for declaring and performing validation rules on Java objects. It is useful for checking incoming request data, form submissions, and business data before processing.

Example

import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Positive;

public class EmployeeRequest {

    @NotBlank
    private String name;

    @Email
    @NotBlank
    private String email;

    @Positive
    private double salary;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

Explanation: The annotations declare validation constraints for an employee request. A compatible validation provider must be configured, and the application must invoke validation or integrate it into the request-processing mechanism. Additional business rules may be required beyond these basic constraints.

16. Jakarta Messaging and Asynchronous Processing

Jakarta Messaging, formerly known as JMS, provides APIs for sending and receiving messages through supported messaging providers. Messaging can help separate services and allow work to be processed asynchronously.

Example Use Cases

• Sending order confirmation messages.
• Processing background jobs.
• Publishing inventory update events.
• Sending notifications to other systems.
• Decoupling request processing from longer-running operations.

Basic Message Flow

Order Service
     |
     | Publish Message
     v
Messaging Provider
     |
     | Deliver Message
     v
Notification Consumer
     |
     v
Send Confirmation

Messaging can improve decoupling and throughput, but applications must also consider delivery guarantees, duplicate messages, retries, ordering, dead-letter handling, and monitoring.

17. Jakarta WebSocket

Jakarta WebSocket provides APIs for communication over WebSocket connections. Unlike a conventional request-response exchange, a WebSocket connection supports communication in both directions after the connection has been established.

Common Applications

• Live chat systems.
• Real-time dashboards.
• Collaborative applications.
• Live notifications.
• Real-time status monitoring.

For example, an enterprise monitoring dashboard may use WebSocket connections to receive updated system status without requiring the client to repeatedly poll the server.

18. Jakarta EE Profiles

Jakarta EE profiles group specifications into defined sets for different application requirements. The Core Profile provides a smaller set of services, the Web Profile focuses on web applications, and the Platform includes a broader collection of enterprise capabilities.

The exact specifications included in each profile depend on the Jakarta EE release. Check the target release and compatible runtime before selecting APIs.

19. Jakarta EE and Microservices

Microservices architecture organizes an application as a collection of independently deployable services. Each service focuses on a specific business capability and communicates with other services through defined interfaces.

Jakarta EE can be used to build microservices through technologies such as Jakarta REST, CDI, JSON processing, persistence, validation, and security. Eclipse MicroProfile provides additional specifications commonly used for cloud-native microservices, including capabilities related to configuration, fault tolerance, and observability.

Example Microservices Architecture

Frontend Application
        |
        v
API Gateway
        |
        +------------------+
        |                  |
        v                  v
Product Service      Order Service
        |                  |
        v                  v
Product Database     Order Database

Benefits

• Allows business capabilities to be developed and deployed independently.
• Can support independent scaling of services.
• Helps organize large systems around business responsibilities.
• Allows teams to evolve services separately when interfaces remain compatible.

Challenges

• Requires service-to-service communication and network failure handling.
• Introduces distributed monitoring and deployment complexity.
• Requires careful management of data consistency across services.
• May require API gateways, service discovery, and distributed tracing.

Microservices are not automatically better than a monolithic architecture. The appropriate choice depends on system complexity, deployment needs, team structure, and operational capability.

20. Development Tools and Environment Setup

Developers use a combination of development tools, build systems, databases, and application runtimes to create Jakarta EE applications.

Basic Setup Steps

1. Install a JDK version supported by your selected Jakarta EE runtime.
2. Install and configure an IDE.
3. Choose a compatible Jakarta EE application server or runtime.
4. Create a Maven or Gradle project.
5. Add the appropriate Jakarta EE API dependencies.
6. Configure database access and other required resources.
7. Implement the application's components.
8. Build, deploy, and test the application.
9. Inspect application logs and correct configuration or runtime errors.

When the application server provides Jakarta EE APIs, those dependencies are often declared with a provided scope because the runtime supplies them. Follow the instructions for the chosen server and project template.

21. Common Errors and Troubleshooting

22. Mini Project: Employee Management System

Project Objective: Develop an enterprise-style application that manages employee records using Jakarta EE technologies.

Functional Requirements

• Create employee records with name, email, department, and salary.
• Retrieve employee information through REST endpoints.
• Update employee records.
• Delete employee records when authorized.
• Validate incoming data.
• Store information in a relational database.
• Return appropriate HTTP status codes and error responses.
• Protect administrative operations through authentication and authorization.

Suggested Technology Stack

• Java for application logic.
• Jakarta REST for HTTP endpoints.
• Jakarta CDI for dependency injection.
• Jakarta Persistence for database operations.
• Jakarta Validation for request validation.
• Jakarta Security for application security where appropriate.
• PostgreSQL or MySQL for data storage.
• Maven for dependency management.
• A compatible Jakarta EE runtime for deployment.

Project Workflow

1. Create the project and configure the required Jakarta EE dependencies.
2. Define an Employee entity.
3. Implement the persistence and business service layers.
4. Create REST resource endpoints for employee operations.
5. Apply request validation and error handling.
6. Configure database access and transaction management.
7. Test endpoints using Postman or another HTTP client.
8. Implement authorization for restricted operations.
9. Write automated tests and document the API.

23. Interview Questions and Answers

Q1. What is Jakarta EE?

Answer: Jakarta EE is a set of open, standardized specifications for developing enterprise Java applications, including web services, persistence, security, and transaction management.

Q2. What is the difference between Java SE and Jakarta EE?

Answer: Java SE provides the core Java platform, while Jakarta EE adds standardized enterprise APIs and runtime services for web and business applications.

Q3. What is the difference between Java EE and Jakarta EE?

Answer: Jakarta EE is the continuation of the Java EE enterprise platform under the Eclipse Foundation, with evolving specifications and the modern Jakarta namespace for many APIs.

Q4. What is a Jakarta EE container?

Answer: It is a runtime environment that manages supported application components and provides services such as lifecycle management, dependency injection, and request processing.

Q5. What is Jakarta Servlet?

Answer: It is an API for handling HTTP requests and responses in server-side Java applications.

Q6. What is Jakarta REST?

Answer: It is a standard API for building RESTful web services in Java.

Q7. What is CDI?

Answer: Contexts and Dependency Injection provides dependency injection and contextual lifecycle management for application components.

Q8. What is Jakarta Persistence?

Answer: It is a standard API for mapping Java objects to relational data and managing entity persistence.

Q9. What is the purpose of Jakarta Transactions?

Answer: It defines transaction management mechanisms that help maintain consistency across related operations.

Q10. What is an Enterprise Bean?

Answer: It is a server-side business component that can use container-managed capabilities such as transactions, security, and asynchronous processing.

Q11. What is the difference between a Servlet container and a Jakarta EE application server?

Answer: A Servlet container supports servlet-based web applications. A Jakarta EE application server implements a broader set of Jakarta EE specifications according to its supported profile or platform version.

Q12. What is the purpose of Jakarta Validation?

Answer: It provides standardized validation constraints for checking data and enforcing declared validation rules.

Q13. What is the role of Jakarta Messaging?

Answer: It supports message-based communication between application components, often for asynchronous processing.

Q14. What is the difference between a monolith and microservices?

Answer: A monolith packages multiple application capabilities into one deployable application, whereas microservices organize capabilities into independently deployable services that communicate through defined interfaces.

Q15. Why is dependency injection useful?

Answer: It reduces tight coupling, improves testability, and allows the runtime to manage component creation and dependencies.

24. Practical Exercises and Quick Revision

Practice Exercises

1. Explain the evolution from Java EE to Jakarta EE.
2. Create a basic Servlet that returns a welcome message.
3. Build a Jakarta REST endpoint that returns JSON or plain text.
4. Create a CDI-managed service and inject it into a resource.
5. Define an Employee entity using Jakarta Persistence.
6. Add validation constraints to an employee request.
7. Explore transaction management for database operations.
8. Compare the Jakarta EE Core, Web, and Platform profiles.
9. Deploy an application to a compatible runtime.
10. Test endpoints and troubleshoot common deployment errors.

Quick Revision Checklist

• Jakarta EE is the continuation of enterprise Java standards.
• Java SE provides the core platform on which Jakarta EE applications run.
• Jakarta EE APIs are defined by specifications and supported by compatible implementations.
• Containers provide services for supported application components.
• Servlets process HTTP requests and responses.
• Jakarta REST provides APIs for RESTful web services.
• CDI supports dependency injection and component lifecycle management.
• Jakarta Persistence supports object-relational persistence.
• Jakarta Transactions supports transaction management.
• Jakarta Security and Jakarta Validation help implement secure, validated applications.
• Runtime and dependency versions must be compatible.
• Hands-on projects are essential for learning enterprise Java technologies.

25. Conclusion

Jakarta EE is an important foundation for enterprise Java development. It provides standardized APIs and runtime services that help developers build secure, maintainable, and scalable web applications, REST services, database-backed systems, and business applications.

By learning Servlets, Jakarta REST, CDI, Persistence, Validation, Security, Transactions, and related technologies, developers gain the skills needed to understand enterprise application architecture and build practical Java backend solutions.

Start with a small REST application, connect it to a database, add validation and security, and gradually explore more advanced enterprise capabilities.

Learn more through the JustAcademy Advanced Java Training Course. You can also register for a course demo or visit the JustAcademy official website.

Additional Learning Resource

For official platform concepts and API overviews, read the Jakarta EE Tutorial: Overview.