Jakarta EE verständlich erklärt – mit diesen APIs baust du moderne Enterprise-Anwendungen: Teil 2

23. Juni 2025

Im zweiten Teil unserer Serie über Jakarta EE-Bibliotheken setzen wir unseren Überblick fort und widmen uns einer weiteren Auswahl an Schlüsseltechnologien. Wir werden die Funktionen und Anwendungsmöglichkeiten dieser Bibliotheken beleuchten und zeigen, wie sie zur Entwicklung moderner Unternehmensanwendungen beitragen.

Im zweiten Teil unserer Serie über Jakarta EE-Bibliotheken setzen wir unseren Überblick fort und widmen uns einer weiteren Auswahl an Schlüsseltechnologien. Du erfährst, wann du welche API einsetzt – und wie sie dir helfen, robuste und moderne Java-Anwendungen zu entwickeln.

Entkoppelte Business-Logik durch Jakarta Enterprise Beans (EJB)

Mit Jakarta EJB entwickelst du verteilte, transaktionssichere und sichere Komponenten. Die bekanntesten Varianten sind Session Beans (stateless/stateful) und Message-Driven Beans – ideal für deine Geschäftslogik oder Ereignisverarbeitung.

<dependency>
<groupId>jakarta.ejb</groupId>
<artifactId>jakarta.ejb-api</artifactId>
</dependency>

import jakarta.ejb.Stateless;
import jakarta.ejb.TransactionAttribute;
import jakarta.ejb.TransactionAttributeType;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;

@Stateless
public class ProductService {

@PersistenceContext
private EntityManager entityManager;

@TransactionAttribute(TransactionAttributeType.REQUIRED)
public Product createProduct(String name, Double price) {
Product product = new Product();
product.setName(name);
product.setPrice(price);

entityManager.persist(product);
return product;
}
}

Dynamische Inhalte einbinden – mit Jakarta Expression Language (EL)

Jakarta EL ist die Brücke zwischen Backend-Logik und UI: Über Ausdrücke wie ${user.name} greifst du in JSF oder JSP direkt auf Java-Beans zu – ideal für dynamische Formulare und Webinhalte.

<dependency>
<groupId>jakarta.el</groupId>
<artifactId>jakarta.el-api</artifactId>
</dependency>

import jakarta.enterprise.context.RequestScoped;
import jakarta.inject.Named;

@Named
@RequestScoped
public class UserBean {

private User user;

public String getUser() {
return user;
}

public void setUser(User user) {
this.user = user;
}

public String getFirstName() {
return user.firstName();
}

public void getLastName() {
return user.lastName();
}
}

<!DOCTYPE html>
<html xmlns=“http://www.w3.org/1999/xhtml“
xmlns:h=“http://xmlns.jcp.org/jsf/html“>
<h:head>
<title>User Information</title>
</h:head>
<h:body>
<h:form>
<h:outputLabel value=“First Name:“ for=“firstName“ />
<h:inputText id=“firstName“ value=“#{userBean.firstName}“ />

<h:outputLabel value=“Last Name:“ for=“lastName“ />
<h:inputText id=“lastName“ value=“#{userBean.lastName}“ />
</h:form>
</h:body>
</html>

Querschnittsfunktionen wie aus dem Baukasten – mit Interceptors

Mit Jakarta Interceptors trennst du z. B. Logging, Auditing oder Security vom Kern deiner Geschäftslogik. Über @AroundInvoke greifst du Methodenaufrufe ab – zentral und wiederverwendbar.

<dependency>
<groupId>jakarta.interceptor</groupId>
<artifactId>jakarta.interceptor-api</artifactId>
</dependency>

import jakarta.interceptor.AroundInvoke;
import jakarta.interceptor.Interceptor;
import jakarta.interceptor.InvocationContext;

@Logging
@Interceptor
public class LoggingInterceptor {

@AroundInvoke
public Object logMethodEntry(InvocationContext context) throws Exception {
String className = context.getTarget().getClass().getSimpleName();
String methodName = context.getMethod().getName();
System.out.println(„Entering method: “ + className + „.“ + methodName);

try {
return context.proceed();
} finally {
System.out.println(„Exiting method: “ + className + „.“ + methodName);
}
}
}

Objekte einfach in JSON übersetzen – mit Jakarta JSON Binding

Mit Jakarta JSON Binding wandelst du POJOs bidirektional in JSON um und zurück – mit Typprüfung, Konfiguration und automatischer Serialisierung.

<dependency>
<groupId>jakarta.json.bind</groupId>
<artifactId>jakarta.json.bind-api</artifactId>
</dependency>

import jakarta.json.bind.Jsonb;
import jakarta.json.bind.JsonbBuilder;
import jakarta.json.bind.JsonbConfig;

public class JsonbExample {
public static void main(String[] args) {
JsonbConfig config = new JsonbConfig().withFormatting(true);
Jsonb jsonb = JsonbBuilder.create(config);

// Java-Objekt zu JSON
Person person = new Person(„John“, „Doe“, 30);
String json = jsonb.toJson(person);
System.out.println(„Serialized JSON: “ + json);

// JSON zu Java-Objekt
String jsonInput = „{„firstName“:“Jane“,“lastName“:“Doe“,“age“:25}“;
Person deserializedPerson = jsonb.fromJson(jsonInput, Person.class);
System.out.println(„Deserialized: “ + deserializedPerson.getFirstName() + “ “ + deserializedPerson.getLastName());
}
}

Flexibles JSON-Handling – mit Jakarta JSON Processing

Mit Jakarta JSON Processing (JSON-P) baust oder analysierst du JSON-Strukturen objektbasiert – ganz ohne zusätzliche Bibliothek: ideal für REST-Endpunkte, Konfigurationen oder Logs.

<dependency>
<groupId>jakarta.json</groupId>
<artifactId>jakarta.json-api</artifactId>
</dependency>

import jakarta.json.Json;
import jakarta.json.JsonObject;

public class JsonpCreateExample {
public static void main(String[] args) {
JsonObject personJson = Json.createObjectBuilder()
.add(„firstName“, „John“)
.add(„lastName“, „Doe“)
.add(„age“, 30)
.add(„email“, „[email protected]“)
.build();

System.out.println(„Created JSON: “ + personJson);
}
}

import jakarta.json.*;
import java.io.StringReader;

public class JsonpParseExample {
public static void main(String[] args) {
String jsonInput = „{„firstName“:“Jane“,“lastName“:“Doe“,“age“:25,“email“:“[email protected]“}“;

try (JsonReader jsonReader = Json.createReader(new StringReader(jsonInput))) {
JsonObject jsonObject = jsonReader.readObject();

String firstName = jsonObject.getString(„firstName“);
int age = jsonObject.getInt(„age“);

System.out.println(„Parsed: “ + firstName + „, age “ + age);
}
}
}

E-Mails senden leicht gemacht – mit Jakarta Mail

Mit Jakarta Mail stellst du ganz einfach systemseitige E-Mails aus deiner Anwendung zu – z. B. für Bestellbestätigungen, Systemnotifikationen oder Passwort-Resets.

<dependency>
<groupId>com.sun.mail</groupId>
<artifactId>jakarta.mail</artifactId>
</dependency>

import jakarta.mail.*;
import jakarta.mail.internet.*;
import java.util.Properties;

public class MailExample {

public static void main(String[] args) {
Properties props = new Properties();
props.put(„mail.smtp.host“, „smtp.example.com“);
props.put(„mail.smtp.port“, „587“);

Session session = Session.getInstance(props);

try {
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(„[email protected]“));
message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(„[email protected]“));
message.setSubject(„Deine erste Jakarta-Mail“);
message.setText(„Diese E-Mail wurde per Jakarta Mail API verschickt.“);

Transport.send(message);
System.out.println(„E-Mail erfolgreich versendet.“);
} catch (MessagingException e) {
e.printStackTrace();
}
}
}

Leichtgewichtige Komponenten mit Jakarta Managed Beans

Simple Verwaltung, Lifecycle und Dependency Injection: Managed Beans sind ideal, wenn du kleine, konfigurierbare Komponenten mit wenig Overhead brauchst.

<dependency>
<groupId>jakarta.annotation</groupId>
<artifactId>jakarta.annotation-api</artifactId>
</dependency>

import jakarta.annotation.PostConstruct;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Named;
import java.io.InputStream;
import java.util.Properties;

@Named
@ApplicationScoped
public class ConfigBean {

private Properties configProperties;

@PostConstruct
public void init() {
configProperties = new Properties();
try (InputStream input = getClass().getClassLoader().getResourceAsStream(„config.properties“)) {
configProperties.load(input);
} catch (Exception e) {
e.printStackTrace();
}
}

public String getConfigProperty(String key) {
return configProperties.getProperty(key);
}
}

Monitoring mit JMX – durch Jakarta Management

Du willst Metriken erfassen oder Komponenten beobachten? Mit Jakarta Management nutzt du Java Management Extensions (JMX), um deine Anwendung zur Laufzeit zu überwachen.

<dependency>
<groupId>jakarta.management</groupId>
<artifactId>jakarta.management-api</artifactId>
</dependency>

public interface MemoryMonitorMBean {
long getUsedMemory();
long getMaxMemory();
}

public class MemoryMonitor implements MemoryMonitorMBean {
public long getUsedMemory() {
return Runtime.getRuntime().totalMemory() – Runtime.getRuntime().freeMemory();
}
public long getMaxMemory() {
return Runtime.getRuntime().maxMemory();
}
}

import javax.management.*;
import java.lang.management.ManagementFactory;

public class MemoryMonitorExample {
public static void main(String[] args) throws Exception {
MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
ObjectName objectName = new ObjectName(„com.example:type=MemoryMonitor“);
MemoryMonitor monitor = new MemoryMonitor();
mBeanServer.registerMBean(monitor, objectName);
}
}

Asynchrone Kommunikation – mit Jakarta Messaging (JMS)

Mit Jakarta Messaging integrierst du message-basierte Kommunikation – sei es im Point-to-Point- oder Publish/Subscribe-Modell.

<dependency>
<groupId>jakarta.jms</groupId>
<artifactId>jakarta.jms-api</artifactId>
</dependency>

import jakarta.jms.*;
import javax.naming.InitialContext;

public class SimpleJMSConsumer {

public static void main(String[] args) {
try {
InitialContext ctx = new InitialContext();
ConnectionFactory connectionFactory = (ConnectionFactory) ctx.lookup(„jms/ConnectionFactory“);
Queue queue = (Queue) ctx.lookup(„jms/MyQueue“);

try (JMSContext jmsContext = connectionFactory.createContext()) {
JMSConsumer consumer = jmsContext.createConsumer(queue);
String message = consumer.receiveBody(String.class);
System.out.println(„Nachricht empfangen: “ + message);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

Webanwendungen strukturieren – mit Jakarta MVC

Jakarta MVC ist das Frontend-Gegenstück zu REST: Du bekommst Model-View-Controller-Struktur inklusive JAX-RS-Integration für saubere HTML-Views.

<dependency>
<groupId>jakarta.mvc</groupId>
<artifactId>jakarta.mvc-api</artifactId>
</dependency>

import jakarta.mvc.Controller;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;

@Path(„greeting“)
@Controller
public class GreetingController {

@GET
@Produces(„text/html“)
public String sayHello() {
return „greeting.jsp“;
}
}

Objekte und Datenbanken verbinden – mit Jakarta Persistence (JPA)

Mit Jakarta JPA mapst du Objekte auf relationale Tabellen – inklusive Unit-of-Work und Transaktionsmanagement.

<dependency>
<groupId>jakarta.persistence</groupId>
<artifactId>jakarta.persistence-api</artifactId>
</dependency>

import jakarta.persistence.*;

@Entity
public class Person {

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

public Person() {}
public Person(String name) {
this.name = name;
}

// Getter / Setter
}

import jakarta.persistence.*;

public class JpaExample {
public static void main(String[] args) {
EntityManagerFactory emf = Persistence.createEntityManagerFactory(„my-pu“);
EntityManager em = emf.createEntityManager();

em.getTransaction().begin();
em.persist(new Person(„Alice“));
em.getTransaction().commit();

Person found = em.find(Person.class, 1L);
System.out.println(„Gefundene Person: “ + found.getName());

em.close();
emf.close();
}
}

REST-APIs einfach gebaut – mit Jakarta RESTful Web Services (JAX-RS)

REST in Enterprise-Qualität: Mit JAX-RS entwickelst du moderne HTTP-Endpunkte – mit JSON/XML, Content Negotiation und Integration in andere APIs.

<dependency>
<groupId>jakarta.ws.rs</groupId>
<artifactId>jakarta.ws.rs-api</artifactId>
</dependency>

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 HelloWorldService {

@GET
@Produces(MediaType.TEXT_PLAIN)
public String sayHello() {
return „Hello, JAX-RS!“;
}
}

Fazit: Noch mehr Jakarta EE? Na klar.

Auch dieser Teil zeigt: Jakarta EE ist modular, standardisiert und praxisnah. Du integrierst nur, was du brauchst – ohne das Rad neu zu erfinden.

Fortsetzung folgt …
Im dritten und letzten Teil schauen wir uns nochmal weitere APIs an – darunter Jakarta WebSocket, Security, Server Faces (JSF) und Co.