Java EE (Jakarta EE) is a set of specifications that define a standard for developing enterprise-level applications in Java. It provides a platform for building scalable, reliable, and secure applications, such as web applications, enterprise services, and microservices. Originally developed by Sun Microsystems and later maintained by Oracle, it was rebranded as Jakarta EE after being transferred to the Eclipse Foundation.
1. What is Java EE (Jakarta EE)?
Java EE (now Jakarta EE) is a collection of specifications that extend the Java SE (Standard Edition) to support enterprise features like distributed computing, messaging, transactions, and web services. It provides an API and runtime environment for building large-scale, multi-tiered, and mission-critical applications. Java EE is widely used for building web applications, business applications, and microservices.
2. Key Components of Jakarta EE
a) Enterprise JavaBeans (EJB)
EJB is a set of specifications that provides a managed environment for business logic. It is used for developing distributed, transactional, and secure business components. EJB supports:
- Stateless and stateful beans.
- Singleton beans.
- Message-driven beans.
b) JavaServer Pages (JSP)
JSP is a technology used to create dynamic web pages. It allows developers to embed Java code into HTML pages, making it easier to generate dynamic content. JSP is typically used in conjunction with Servlets for handling HTTP requests.
c) Java Servlets
Servlets are Java classes that extend the capabilities of servers to respond to requests from web clients (browsers). Servlets are used for handling HTTP requests, sessions, and cookies in a web application. They form the core of the web tier in a Jakarta EE application.
d) Java Persistence API (JPA)
JPA is a specification for object-relational mapping (ORM) and data persistence. It simplifies database interactions by allowing developers to work with Java objects instead of SQL queries. JPA provides features such as:
- Annotations for entity management.
- JPQL (Java Persistence Query Language) for querying data.
- EntityManager for managing entities.
e) Contexts and Dependency Injection (CDI)
CDI is a set of services for dependency injection and contextual lifecycle management. It allows developers to create loosely coupled components and manage their lifecycle in a Jakarta EE environment. CDI supports:
- Dependency Injection (DI).
- Interceptors and decorators.
- Events for communication between components.
f) Java Transaction API (JTA)
JTA is a specification for managing transactions in Java applications. It provides an abstraction for managing distributed transactions across multiple resources (e.g., databases, message queues). JTA ensures atomicity, consistency, isolation, and durability (ACID) properties for transactions.
g) Java Message Service (JMS)
JMS is a messaging API that allows Java applications to send and receive messages asynchronously. It supports two messaging models:
- Point-to-Point (Queues): A message is delivered to only one consumer.
- Publish-Subscribe (Topics): A message can be consumed by multiple consumers.
h) Java API for RESTful Web Services (JAX-RS)
JAX-RS is a specification for building RESTful web services in Java. It provides annotations and APIs for creating web services that use HTTP methods like GET, POST, PUT, and DELETE.
i) Java API for WebSockets (JWS)
WebSockets enable full-duplex communication channels over a single TCP connection. Jakarta EE provides APIs to create real-time, bidirectional communication between the client and server, which is useful for building interactive web applications like chat apps, live updates, and collaborative tools.
j) JavaServer Faces (JSF)
JSF is a framework for building web-based user interfaces. It simplifies the creation of user interfaces by allowing developers to work with UI components rather than manually handling HTML and JavaScript. JSF supports features like navigation, event handling, and data binding.
3. Jakarta EE vs Java EE
Java EE was rebranded to Jakarta EE after the Eclipse Foundation took over its development in 2017. The transition marked the start of a new chapter for Java EE under a more community-driven model. Despite the name change, the core features and specifications remain the same, but future developments and releases are now handled by the Eclipse Foundation.
4. Key Features of Jakarta EE
a) Platform Independence
Jakarta EE applications are platform-independent. They can run on any server that supports the Jakarta EE specifications, such as Payara, WildFly, GlassFish, Apache TomEE, and others. This ensures that applications can be deployed and executed across different environments without modification.
b) Enterprise-Grade Capabilities
Jakarta EE provides built-in support for enterprise-level features like:
- Distributed computing: Supports integration with message-driven beans (MDB) and JMS for distributed message processing.
- Transactions: Provides support for managing transactions across distributed systems with JTA.
- Security: Provides comprehensive security features for user authentication, authorization, and role-based access control (RBAC).
c) Simplified Development with Annotations
Jakarta EE makes use of annotations to simplify application development, reducing boilerplate code. For example:
- @Entity for JPA entities.
- @Inject for CDI dependency injection.
- @Path for RESTful web services with JAX-RS.
d) Microservices Support
Jakarta EE can be used to develop microservices. With the advent of Jakarta EE 9, the focus shifted toward lightweight, modular development and support for microservices. Jakarta EE also integrates with Eclipse MicroProfile to enhance microservices development with tools for health checks, metrics, and fault tolerance.
5. Example of Jakarta EE Application
Here is a simple example of a Jakarta EE application using JAX-RS for a RESTful web service:
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
@Path("/hello")
public class HelloWorldResource {
@GET
@Produces(MediaType.TEXT_PLAIN)
public String sayHello() {
return "Hello, Jakarta EE!";
}
}
This simple RESTful web service responds with “Hello, Jakarta EE!” when accessed via HTTP GET.