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", "john.doe@example.com")
.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\":\"jane.doe@example.com\"}";
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("team@example.com"));
message.setRecipients(Message.RecipientType.TO, InternetAddress.parse("user@example.com"));
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.
Weiterführende Links
Jakarta EE ist ein Projekt der Eclipse Foundation. Das Logo ist ein eingetragenes Markenzeichen.
