Jakarta EE-Bibliotheken: Ein umfassender Überblick für leistungsstarke Unternehmensanwendungen (Teil 3)

Im abschließenden Teil unserer Serie über Jakarta EE-Bibliotheken runden wir unseren Überblick mit der letzten Gruppe essenzieller Technologien ab. Wir werden die einzigartigen Merkmale dieser Bibliotheken erkunden und ihre Bedeutung für die Entwicklung leistungsstarker Unternehmensanwendungen hervorheben.

In der Welt der Unternehmensanwendungen sind leistungsstarke Technologien unverzichtbar. Entdecke im abschließenden Teil unserer Serie, wie Jakarta EE-Bibliotheken die Entwicklung revolutionieren.

Fernsteuerung leicht gemacht: Jakarta RPC im Fokus

Jakarta RPC bietet Unterstützung für Remote Procedure Calls. Damit kannst du Funktionen oder Methoden auf einem entfernten Server ausführen. Diese Technologie erleichtert die Kommunikation zwischen verteilten Systemen.

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

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface MessageService extends Remote {
String sendMessage(String message) throws RemoteException;
}

import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;

public class MessageServiceImpl extends UnicastRemoteObject implements MessageService {

protected MessageServiceImpl() throws RemoteException {
super();
}

public String sendMessage(String message) throws RemoteException {
return „Server received: “ + message;
}

public static void main(String[] args) {
try {
MessageServiceImpl service = new MessageServiceImpl();
Registry registry = LocateRegistry.createRegistry(1099);
registry.bind(„MessageService“, service);
System.out.println(„MessageService bound in registry“);
} catch (Exception e) {
e.printStackTrace();
}
}
}

import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class MessageClient {
public static void main(String[] args) {
try {
Registry registry = LocateRegistry.getRegistry(„localhost“, 1099);
MessageService service = (MessageService) registry.lookup(„MessageService“);
String response = service.sendMessage(„Hello Server!“);
System.out.println(„Response: “ + response);
} catch (Exception e) {
e.printStackTrace();
}
}
}

Sicherheitslösungen für Unternehmen: Jakarta Security

Jakarta Security bietet ein umfassendes Sicherheitsframework für Jakarta EE-Anwendungen, das Authentifizierung, Autorisierung und Identitätsmanagement umfasst. Es sorgt für den Schutz und die Sicherheit von Anwendungen.

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

import jakarta.security.enterprise.authentication.mechanism.http.BasicAuthenticationMechanismDefinition;
import jakarta.security.enterprise.identitystore.annotation.EmbeddedIdentityStoreDefinition;

@BasicAuthenticationMechanismDefinition(realmName = „example realms“)
@EmbeddedIdentityStoreDefinition({
@EmbeddedIdentityStoreDefinition.User(name = „user“, password = „password“, roles = „USER“),
@EmbeddedIdentityStoreDefinition.User(name = „admin“, password = „admin“, roles = „ADMIN“)
})
public class SecurityConfig {
// Sicherheitskonfiguration in einer Anwendungsklasse
}

import jakarta.annotation.security.RolesAllowed;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@Path(„secure“)
public class SecureResource {

@GET
@RolesAllowed(„ADMIN“)
@Produces(MediaType.TEXT_PLAIN)
public String adminAccess() {
return „This is secured information accessible to ADMIN role.“;
}
}

Jakarta Servlet: Die Basis für Webanwendungen

Jakarta Servlet ist eine grundlegende Technologie für die Entwicklung von Webanwendungen, die HTTP-Anfragen verarbeiten und dynamische Inhalte generieren. Servlets bilden oft die Grundlage für andere Webtechnologien.

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

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

@WebServlet(„/hello“)
public class HelloServlet extends HttpServlet {

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType(„text/html“);
PrintWriter out = response.getWriter();
out.println(„<html><body>“);
out.println(„<h1>Hello, Jakarta Servlet!</h1>“);
out.println(„</body></html>“);
}
}

SOAP-Nachrichten mit Anhängen: Jakarta SOAP with Attachments

Jakarta SOAP with Attachments ermöglicht die Erstellung und Manipulation von SOAP-Nachrichten mit Anhängen, die in Webservice-Anwendungen zur Kommunikation zwischen Diensten verwendet werden.

<dependency>
<groupId>jakarta.xml.soap</groupId>
<artifactId>jakarta.xml.soap-api</artifactId>
</dependency>

import jakarta.jws.WebMethod;
import jakarta.jws.WebService;
import jakarta.jws.soap.SOAPBinding;

@WebService
@SOAPBinding(style = SOAPBinding.Style.DOCUMENT)
public interface CalculatorService {

@WebMethod
int add(int a, int b);

@WebMethod
int subtract(int a, int b);
}

import jakarta.jws.WebService;

@WebService(endpointInterface = „com.example.CalculatorService“)
public class CalculatorServiceImpl implements CalculatorService {

@Override
public int add(int a, int b) {
return a + b;
}

@Override
public int subtract(int a, int b) {
return a – b;
}
}

import jakarta.xml.ws.Endpoint;

public class CalculatorServicePublisher {

public static void main(String[] args) {
Endpoint.publish(„http://localhost:8080/ws/calculator“, new CalculatorServiceImpl());
System.out.println(„CalculatorService is published at http://localhost:8080/ws/calculator“);
}
}

Benutzerdefinierte JSP-Tags: Jakarta Standard Tag Library (JSTL)

Jakarta Standard Tag Library (JSTL) bietet eine Sammlung von benutzerdefinierten JSP-Tags, die häufige Aufgaben wie Schleifen und bedingte Logik vereinfachen und die Trennung von Präsentations- und Logikschicht fördern.

<dependency>
<groupId>jakarta.servlet.jsp.jstl</groupId>
<artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
</dependency>

<%@ taglib uri=“http://xmlns.jcp.org/jsp/jstl/core“ prefix=“c“ %>
<!DOCTYPE html>
<html>
<head>
<title>Benutzerliste</title>
</head>
<body>
<h2>Benutzerliste:</h2>
<ul>
<c:forEach var=“user“ items=“${userList}“>
<li>${user}</li>
</c:forEach>
</ul>
</body>
</html>

Benutzeroberflächen mit Komponenten: Jakarta Server Faces (JSF)

Jakarta Server Faces (JSF) ist ein komponentenbasiertes Framework für die Erstellung von Benutzeroberflächen in Webanwendungen, das eine Vielzahl von UI-Komponenten und eine einfache Zustandsverwaltung bietet.

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

import jakarta.enterprise.context.RequestScoped;
import jakarta.inject.Named;
import java.util.Arrays;
import java.util.List;

@Named
@RequestScoped
public class UserBean {

private List<String> users = Arrays.asList(„Alice“, „Bob“, „Charlie“);

public List<String> getUsers() {
return users;
}
}

<!DOCTYPE html>
<html xmlns=“http://www.w3.org/1999/xhtml“
xmlns:h=“http://xmlns.jcp.org/jsf/html“>
<h:head>
<title>Benutzerliste</title>
</h:head>
<h:body>
<h2>Benutzerliste:</h2>
<ul>
<h:repeat value=“#{userBean.users}“ var=“user“>
<li>#{user}</li>
</h:repeat>
</ul>
</h:body>
</html>

Dynamische Webinhalte: Jakarta Server Pages (JSP)

Jakarta Server Pages (JSP) ermöglicht die Erstellung dynamischer Webinhalte durch die Einbettung von Java-Code in HTML. Dadurch wird die Trennung von Präsentationslogik und Geschäftslogik unterstützt.

<dependency>
<groupId>jakarta.servlet.jsp</groupId>
<artifactId>jakarta.servlet.jsp-api</artifactId>
</dependency>

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;

@WebServlet(„/userList“)
public class UserServlet extends HttpServlet {

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
List<String> users = Arrays.asList(„Alice“, „Bob“, „Charlie“);
request.setAttribute(„userList“, users);
request.getRequestDispatcher(„/userList.jsp“).forward(request, response);
}
}

<%@ page contentType=“text/html;charset=UTF-8″ language=“java“ %>
<%@ taglib uri=“http://xmlns.jcp.org/jsp/jstl/core“ prefix=“c“ %>
<!DOCTYPE html>
<html>
<head>
<title>Benutzerliste</title>
</head>
<body>
<h2>Benutzerliste:</h2>
<ul>
<c:forEach var=“user“ items=“${userList}“>
<li>${user}</li>
</c:forEach>
</ul>
</body>
</html>

Konsistenz in Anwendungen: Jakarta Transactions (JTA)

Jakarta Transactions (JTA) definiert ein Transaktionsmanagement, das es ermöglicht, Transaktionen über mehrere Ressourcen hinweg zu koordinieren, um die Konsistenz in Anwendungen sicherzustellen.

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

import jakarta.annotation.Resource;
import jakarta.ejb.Stateless;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import jakarta.transaction.UserTransaction;

@Stateless
public class ProductService {

@PersistenceContext
private EntityManager em;

@Resource
private UserTransaction userTransaction;

public void createProduct(String name, double price) {
try {
userTransaction.begin();
Product product = new Product();
product.setName(name);
product.setPrice(price);
em.persist(product);
userTransaction.commit();
} catch (Exception e) {
e.printStackTrace();
try {
userTransaction.rollback();
} catch (Exception rollbackException) {
rollbackException.printStackTrace();
}
}
}
}

JavaBeans validieren: Jakarta Validation (Bean Validation)

Jakarta Validation bietet eine API zur Validierung von JavaBeans. Mithilfe von Annotationen können Validierungsregeln direkt in Bean-Klassen definiert werden.

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

import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.Max;

public class Product {

@NotNull
private Long id;

@NotNull
@Size(min = 2, max = 50)
private String name;

@Min(0)
private double price;

…

}

Metadaten für Webservices: Jakarta WebServices Metadata

Diese Spezifikation definiert Metadaten für Webservices, die die Beschreibung und Konfiguration von Webservice-Endpunkten erleichtern und eine Annotation-basierte Konfiguration unterstützen.

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

Bidirektionale Kommunikation: Jakarta WebSocket

Jakarta WebSocket bietet eine API zur Implementierung von WebSocket-Kommunikation. Diese ermöglicht eine bidirektionale, ereignisgesteuerte Kommunikation zwischen Client und Server.

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

import jakarta.websocket.OnMessage;
import jakarta.websocket.server.ServerEndpoint;
import jakarta.websocket.Session;
import java.io.IOException;

@ServerEndpoint(„/echo“)
public class EchoEndpoint {

@OnMessage
public void onMessage(String message, Session session) throws IOException {
System.out.println(„Received: “ + message);
session.getBasicRemote().sendText(„Echo: “ + message);
}
}

XML und Java verbinden: Jakarta XML Binding (JAXB)

Jakarta XML Binding (JAXB) bietet eine API zum Konvertieren von Java-Objekten in XML und umgekehrt.

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

import jakarta.xml.bind.annotation.XmlElement;
import jakarta.xml.bind.annotation.XmlRootElement;
import jakarta.xml.bind.*;

import java.io.StringReader;
import java.io.StringWriter;

@XmlRootElement
class Person {
private String name;
private int age;

@XmlElement
public String getName() { return name; }
public void setName(String name) { this.name = name; }

@XmlElement
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
}

public class JaxbExample {
public static void main(String[] args) throws Exception {
Person p = new Person();
p.setName(„Alice“);
p.setAge(30);

// Marshalling (Objekt → XML)
JAXBContext context = JAXBContext.newInstance(Person.class);
Marshaller marshaller = context.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

StringWriter writer = new StringWriter();
marshaller.marshal(p, writer);
String xml = writer.toString();
System.out.println(xml);

// Unmarshalling (XML → Objekt)
Unmarshaller unmarshaller = context.createUnmarshaller();
Person copy = (Person) unmarshaller.unmarshal(new StringReader(xml));
System.out.println(„Name: “ + copy.getName() + „, Age: “ + copy.getAge());
}
}

XML-basierte Registrierungen: Jakarta XML Registries

Diese Spezifikation bietet Zugriff auf XML-basierte Registrierungsdienste, die Informationen über verfügbare Webservices und andere Ressourcen bereitstellen. Dadurch wird die Entdeckung und Nutzung von Diensten erleichtert.

<dependency>
<groupId>jakarta.xml.registry</groupId>
<artifactId>jakarta.xml.registry-api</artifactId>
</dependency>

import jakarta.xml.registry.*;

import java.util.Properties;

public class JaxrHello {
public static void main(String[] args) throws Exception {
ConnectionFactory factory = ConnectionFactory.newInstance();

Properties props = new Properties();
props.setProperty(„javax.xml.registry.queryManagerURL“,
„http://localhost:8080/registry/uddi/inquiry“);

factory.setProperties(props);
Connection conn = factory.createConnection();

RegistryService service = conn.getRegistryService();
System.out.println(„Verbunden mit Registry: “ + service.getClass().getName());

conn.close();
}
}

XML-Nachrichten: Jakarta XML RPC

Jakarta XML RPC ist eine API, die es ermöglicht, Remote Procedure Calls (RPC) auf Basis von XML-Nachrichten zu implementieren. Sie wird häufig in verteilten Systemen eingesetzt, um entfernte Methodenaufrufe zu realisieren.

<dependency>
<groupId>jakarta.xml.rpc</groupId>
<artifactId>jakarta.xml.rpc-api</artifactId>
</dependency>

import org.apache.xmlrpc.client.XmlRpcClient;
import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;

import java.net.URL;
import java.util.Arrays;

public class XmlRpcClientExample {
public static void main(String[] args) throws Exception {
XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
config.setServerURL(new URL(„http://localhost:8080/xmlrpc“));

XmlRpcClient client = new XmlRpcClient();
client.setConfig(config);

Object result = client.execute(„Calculator.add“, Arrays.asList(5, 7));
System.out.println(„Ergebnis: “ + result);
}
}

Webservices mit SOAP: Jakarta XML Web Services (JAX-WS)

Jakarta XML Web Services (JAX-WS) stellt eine API bereit, die die Erstellung von Webservices ermöglicht, die auf SOAP-Nachrichten basieren. Im Gegensatz zur „jakarta.xml.soap-api“ befindet man sich hier auf einer höheren Abstraktionsebene.

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

import jakarta.xml.ws.Service;
import javax.xml.namespace.QName;
import java.net.URL;

public class HelloClient {
public static void main(String[] args) throws Exception {
URL wsdlURL = new URL(„http://localhost:8080/hello?wsdl“);
QName SERVICE_NAME = new QName(„http://“, „HelloService“);

Service service = Service.create(wsdlURL, SERVICE_NAME);
HelloService hello = service.getPort(HelloService.class);

String result = hello.sayHello(„Welt“);
System.out.println(result);
}
}

Damit schließen wir unseren Überblick über die vorgestellten Jakarta EE-Bibliotheken ab. Entwickle deine Anwendungen mit den vorgestellten Jakarta EE-Bibliotheken und hebe deine Projekte auf das nächste Level. Vielen Dank für dein Interesse an diesem Thema!

Jakarta EE ist ein Projekt der Eclipse Foundation. Das Logo ist ein eingetragenes Markenzeichen.

Der Beitrag Jakarta EE-Bibliotheken: Ein umfassender Überblick für leistungsstarke Unternehmensanwendungen (Teil 3) erschien zuerst auf Business -Software- und IT-Blog – Wir gestalten digitale Wertschöpfung.