Einführung in EJB

In diesem Artikel befassen wir uns mit EJB – Enterprise JavaBeans. Diese Technologie ist Teil der Java EE-Spezifikation. Wir werden Themen ansprechen wie:

• Was ist EJB?
• Was ist die Geschichte von EJB?
• Welche Arten von EJB gibt es?

Wir werden auch eine kleine HelloWorld-Anwendung mit EJB und Servlets schreiben. Dieser Artikel wird für Leser nützlich sein, die sich mit Java SE vertraut gemacht haben und beginnen, Java EE zu erlernen. Um den praktischen Teil dieses Artikels vollständig zu verstehen, wird empfohlen, zunächst den Artikel „ Einrichten der lokalen Umgebung “ zu lesen.

Eine kurze Geschichte von EJB

Bereits 1996, als der Autor dieses Artikels 5 Jahre alt war, war Java bei Entwicklern beliebt. Der Grund dafür war die benutzerfreundliche API, die automatische Speicherbereinigung usw. Java wurde häufig in Systemen verwendet, die für das Backend verantwortlich sind. Trotz aller Vorzüge der Sprache benötigten die damaligen Programmierer jedoch bestimmte Funktionen, die im JDK noch nicht implementiert waren. Diese Bedürfnisse waren:

• Gewährleistung der Datenpersistenz;
• Transaktionsintegrität
• wettbewerbsfähiger Zugriff auf Daten (Multithreading-Kontrolle);
• und höchstwahrscheinlich etwas anderes.

All dies führte zu einem natürlichen Wachstum der Bevölkerung einheimischer, selbstgeschriebener, geschlossener Bibliotheken. Mit anderen Worten: Jeder erfüllte seine Bedürfnisse so gut er konnte. Bis IBM 1997 den Slogan „Jeder sollte seine Bedürfnisse auf die gleiche Weise erfüllen“ herausbrachte und die Enterprise Java Bean (EJB)-Spezifikation veröffentlichte. Dadurch war es möglich, den Entwicklungsprozess zu vereinheitlichen und die Lösung typischer Probleme (oben als Bedürfnisse beschrieben) in das Framework zu übertragen. Sun hat die Idee von IBM zwei Jahre lang angepasst und 1999 die EJB 1.0-Spezifikation veröffentlicht. So entstand die Technologie, die im weiteren Verlauf in einem eher angewandten Sinne besprochen wird.

Was ist EJB?

EJB ist gewissermaßen ein Sammelbegriff, der je nach Kontext entweder die Enterprise JavaBeans-Technologie selbst im Allgemeinen oder eine bestimmte Enterprise JavaBean-Softwarekomponente (Bean) bezeichnen kann, die Teil der EJB-Technologie ist. Die Definition von EJB als Technologie finden Sie auf Wikipedia: Enterprise JavaBeans (oft auch als Abkürzung EJB verwendet) ist eine Spezifikation einer Technologie zum Schreiben und Unterstützen von Serverkomponenten, die Geschäftslogik enthalten. Es ist Teil von Java EE. Diese Technologie wird typischerweise verwendet, wenn die Geschäftslogik mindestens einen der folgenden Dienste erfordert, oft sogar alle:

• Unterstützung für Datenpersistenz: Daten sollten auch nach dem Stoppen des Programms sicher sein. Am häufigsten mithilfe einer Datenbank erreicht;
• Unterstützung für verteilte Transaktionen;
• Unterstützung für parallele Datenänderung und Multithreading;
• Veranstaltungsunterstützung;
• Namens- und Verzeichnisunterstützung (JNDI);
• Sicherheit und Einschränkung des Zugriffs auf Daten;
• Unterstützung für die automatisierte Installation auf dem Anwendungsserver;
• Fernzugriff.

Die oben aufgeführten Dienste sind zweifellos ein Vorteil der EJB-Technologie. Ein weiterer Vorteil besteht darin, dass alles, was oben aufgeführt ist, sofort funktioniert. Diese. Der Programmierer muss nicht über die Unterstützung verteilter Transaktionen nachdenken. Der Programmierer muss nur über die Geschäftslogik nachdenken, die er gerade zu implementieren versucht. Ein EJB als spezifische Softwarekomponente ist eine Java-Klasse mit einer oder mehreren Annotationen aus der EJB-Spezifikation, die einen Teil der Geschäftslogik der Anwendung enthält. Anmerkungen aus der EJB-Spezifikation verleihen der getaggten Klasse bestimmte Befugnisse, Befugnisse und Superkräfte. Lesen Sie weiter unten mehr darüber.

EJB-Typen

Fassen wir zusammen. Ein EJB ist eine reguläre Java-Klasse, die mit einer der speziellen Annotationen gekennzeichnet ist. Solche Klassen werden Beans genannt. Abhängig davon, mit welcher Annotation die Klasse markiert ist, ist sie ein Vertreter des einen oder anderen EJB-Typs (Beans). Es gibt drei Hauptarten von Bohnen:

• Message Driven Beans (nachrichtengesteuerte Beans);
• Entity Beans – definiert in der JPA-Spezifikation (Java Persistence API) und werden zum Speichern von Daten verwendet;
• Sitzungsbohnen.

Letztere (Session Beans) sind in mehrere Untertypen unterteilt:

• staatenlos (ohne Staat);
• zustandsbehaftet (mit Unterstützung für den aktuellen Sitzungsstatus);
• Singleton (ein Objekt für die gesamte Anwendung; ab EJB 3.1).

Im Folgenden werden wir uns die einzelnen Bohnensorten genauer ansehen.

Sitzungsbohnen

Session Beans oder Session Beans sind eine spezielle Art von Beans. Sie kapseln Geschäftslogik, die der Client programmgesteuert aufrufen kann, indem er die Methoden der Bean aufruft. Ein Methodenaufruf kann Folgendes bewirken:

• lokal, von einer anderen Klasse in derselben JVM wie die Session-Bean;
• remote, über das Netzwerk, von einer anderen JVM unter Verwendung der Java RMI-Technologie (Remote Method Invocation).

Das Wort „Sitzung“ impliziert, dass die Bean nur verfügbar ist, während der Server eine bestimmte Aufgabe ausführt, und im Falle eines Serverausfalls oder -herunterfahrens unwiederbringlich zerstört wird. Der Lebenszyklus einer Session-Bean-Instanz wird durch einen EJB-Container gesteuert (mehr über EJB-Container erfahren Sie im ersten Vortrag der Reihe ). Statuslose Session-Beans speichern keine Informationen über ihren Status. Diese Art von Komponente kann von verschiedenen Clients verwendet werden. Stateless Beans werden zur Implementierung von Geschäftsprozessen verwendet, die in einem Vorgang abgeschlossen werden können. Zum Beispiel die Überprüfung der Bonitätshistorie der Kunden. Da eine einzelne Bean-Instanz von mehreren Clients verwendet werden kann, muss der Entwickler threadsicheren Zugriff auf die Daten der Bean bereitstellen. Das Erstellen einer Bean dieses Typs (wie auch aller anderen Session-Beans) ist recht einfach. Dies ist eine reguläre Java-Klasse mit einer Annotation @Stateless. Lassen Sie uns unten ein Beispiel geben:

import javax.ejb.Stateless;

@Stateless
public class StatelessEjbExample {
    public String sayHi() {
        return "Hi, I'm Stateless EJB!";
    }
}

Session-Beans, die den aktuellen Sitzungsstatus (Stateful) unterstützen, behalten Informationen über ihren Status zwischen Aufrufen desselben Clients und beenden ihre Existenz auf eine ausdrückliche Anfrage des Clients. Dies wird dadurch erreicht, dass Stateful Beans für jeden Client einzigartig sind. Ein Beispiel für eine Aufgabe, die diese Art von Bean übernehmen kann, ist die Aktualisierung des Warenkorbs in einem Online-Shop für jeden Benutzer. Der Lebenszyklus dieser Beans wird vom EJB-Container verwaltet. Diese Beans werden auch zerstört, wenn der Client beendet wird. Solche Bohnen lassen sich auch ganz einfach herstellen. Dies ist eine Java-Klasse, die mit der Annotation gekennzeichnet ist Stateful. Beispiel unten:

import javax.ejb.Stateful;

@Stateful
public class StatefulEjbExample {
    public String sayHi() {
        return "Hi, I,m Stateful EJB";
    }
}

Singleton-Session-Beans werden einmal während der Lebensdauer der Anwendung initiiert und bleiben für die gesamte Lebensdauer der Anwendung bestehen. Solche Beans sind für Situationen konzipiert, in denen ein Zustand von allen Clients gemeinsam genutzt werden muss. Wie bei zustandslosen Beans muss der Entwickler bei Standalone-Beans sicherstellen, dass die Umgebung innerhalb der Bean threadsicher organisiert ist. Lassen Sie uns ein Beispiel für eine Singleton-Bean geben, die genauso einfach zu erstellen ist wie ihre oben besprochenen Gegenstücke. Es ist leicht zu erraten, dass es sich hierbei um eine Java-Klasse mit der Annotation handelt @Singleton. Allerdings ist in diesem Fall Vorsicht geboten. Es gibt zwei Anmerkungen, die in der Syntax identisch, aber unterschiedlich im Zweck sind und sich in unterschiedlichen Paketen befinden:

• javax.ejb.Singleton
• javax.inject.Singleton

Um ein EJB zu erstellen, müssen Sie die Annotation aus der verwenden javax.ejb. Beispiel unten:

import javax.ejb.Singleton;

@Singleton
public class SingletonEjbExample {
    public String sayHi() {
        return "Hi, I'm Singleton EJB!";
    }
}

Nachrichtengesteuerte Beans

Message Driven Beans oder MDBs oder Message Driven Beans implementieren eine Geschäftslogik, wie Session Beans. Im Gegensatz zu seinen Verwandten weist MDB jedoch einen wichtigen Unterschied auf. Clients rufen MDB-Methoden niemals direkt auf. Solche Beans fungieren meist als Listener für JMS-Nachrichten (Java Message Service) und dienen der Organisation des asynchronen Nachrichtenaustauschs zwischen Teilen des Systems. Ein Beispiel für eine solche Nachricht wäre eine Anfrage zur Lieferung von Lagerbeständen von einem automatisierten Einzelhandelssystem an ein Versorgungsmanagementsystem. Unten sehen Sie ein Beispiel für eine MDB-Bean. Im Gegensatz zu Session Beans ist seine Erstellung etwas interessanter:

import javax.annotation.Resource;
import javax.ejb.MessageDriven;
import javax.ejb.MessageDrivenContext;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

@MessageDriven(mappedName = "jms/TestQueue")
public class MessageDrivenEjbExample implements MessageListener {

    @Resource
    private MessageDrivenContext messageDrivenContext;

    public void onMessage(Message message) {
        try {
            if (message instanceof TextMessage) {
                TextMessage msg = (TextMessage) message;
                msg.getText();
            }
        } catch (JMSException e) {
            messageDrivenContext.setRollbackOnly();
        }
    }

}

Die Annotation MessageDrivenmacht unsere MDB-Klasse zu einer Bean. Innerhalb der Annotation wird mithilfe von JNDI (lesen Sie hier mehr über JNDI ) der Name der JMS-Distribution bestimmt, für die unsere Klasse zum Listener wird. Darüber hinaus implementiert unsere Klasse die Schnittstelle MessageListenerund ihre Methode onMessage. Diese Methode wird aufgerufen, wenn eine Nachricht aus der Warteschlange/Verteilung mit dem in der Annotation definierten Namen eintrifft MessageDriven.

Entity-Bohnen

Ein Teil der EJB-Technologie ist die JPA-Spezifikation. JPA oder Java Persistence API ist eine Spezifikation, die objektrelationale Zuordnung (ORM) von Java-Objekten (Entity Beans) bereitstellt und eine API zum Speichern, Abrufen und Verwalten solcher Objekte bereitstellt. Mit JPA können Sie Daten aus einer Datenbank als Java-Objekte darstellen und Java-Objekte als Datensätze in der Datenbank speichern. Nicht jede Klasse kann als solches Objekt fungieren, sondern Entity-Beans. Entity Bean ist eine Java-Klasse, die eine Tabelle in einer Datenbank darstellt. Die Darstellung (Zuordnung) erfolgt durch die Verwendung spezieller Anmerkungen. Mit ihrer Hilfe wird eine Java-Klasse mit einer Tabelle in der Datenbank verglichen, ebenso werden die Felder einer Java-Klasse mit den Feldern einer Datenbanktabelle verglichen. Hier ist ein Beispiel für eine Entity-Bean mit Kommentaren im Code:

@Entity // Делает данный класс Entity бином
@Table(name = "employee") // "Связывает" данный класс с таблицей employee в БД
public class Employee implements Serializable {

    @Id // Говорит о том, что поле ниже является первичным ключом
    @GeneratedValue(strategy = GenerationType.AUTO) // Определяет тип генерации значений первичного ключа
    private int id;

    @Column(name="name") // "Связывает" поле ниже с полем name в таблице employee в БД
    private String name;

    @Column (name="age") // "Связывает" поле ниже с полем age в таблице employee в БД
    private int age;

    // getters and setters...
}

Es ist erwähnenswert, dass das Studium dieser Bohnenart nur im Zusammenhang mit dem Studium der JPA-Spezifikation sinnvoll ist.

Eine Anwendung schreiben: EJB HelloWorld

In diesem Abschnitt schreiben wir eine kleine Java EE HelloWorld-Anwendung, die wir auf dem GlassFish-Server bereitstellen. Bevor Sie diesen Artikel lesen, wird dringend empfohlen, den Artikel zum Einrichten Ihrer lokalen Umgebung zu lesen .

1. Erstellen Sie ein neues Maven-Projekt in IntelliJ IDEA.

   Datei -> Neu -> Projekt...

2. Weiter klicken .

3. Geben Sie die Maven-Projektparameter ein:

4. Klicken Sie auf Fertig stellen

5. Das Projekt wurde erstellt und hat folgenden Aufbau:

Die pom.xml-Datei sieht so aus: Zunächst müssen wir eine Abhängigkeit von der Java EE-API hinzufügen und außerdem die Verpackung unseres Projekts in Form eines Webanwendungsarchivs (war) angeben. Dazu müssen Sie den pom.xml-Code in das folgende Format ändern:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.javarush.lectures</groupId>
    <artifactId>ejb_demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>7.0</version>
        </dependency>
    </dependencies>

</project>

Als nächstes können Sie mit dem Java-Code fortfahren. Unsere Anwendung wird die einfachste sein. Wir werden 1 Servlet und 1 EJB haben. Dies wird eine zustandslose Session-Bean sein. Innerhalb des EJB definieren wir nur eine Methode, die die Zeichenfolge „Hello World“ zurückgibt. Lassen Sie uns zunächst ein Paket erstellen com.javarush.lectures. Dann com.javarush.lectureserstellen wir innerhalb des Pakets unser Bean – DemoEJB. Der Bean-Code ist unten angegeben:

import javax.ejb.Stateless;

@Stateless
public class DemoEJB {
    public String helloWorld() {
        return "Hello world!";
    }
}

Wie bereits gesagt, ist alles ganz einfach. Unser nächster Schritt besteht darin, ein Servlet zu erstellen, das den Wert vom EJB als Antwort auf die HTTP-Anfrage weitergibt. Es ist erwähnenswert, dass Servlets nicht das Thema dieses Artikels sind, Sie sie jedoch dennoch zur Demonstration von EJB verwenden müssen. Dazu erstellen wir ein neues Servlet DemoServletim selben Paket wie das EJB. Der Code ist unten:

@WebServlet("/helloWorld")
public class DemoServlet extends HttpServlet {

    @EJB
    private DemoEJB ejb;

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write(ejb.helloWorld());
    }
}

Hier sind einige kurze Kommentare zum Code. Zusammenfassung @WebServlet("/helloWorld")– definiert unsere Klasse als Servlet, das HTTP-Anfragen an den Endpunkt verarbeitet /helloWorld. Unsere Klasse hat ein Feld - DemoEJB ejb. Dies ist unsere zuvor definierte Bean. Eine Annotation über einem Klassenfeld – @EJBführt eine Abhängigkeitsinjektion (DI) durch. Diese. Die EJB-Variable wird bei Bedarf automatisch mit einer neuen Instanz initialisiert. Unsere Klasse ist ein Nachkomme von HttpServlet und überschreibt eine der Superklassenmethoden – doGet. Diese Methode verarbeitet HTTP-GET-Anfragen und benötigt zwei Parameter – HttpServletRequestund HttpServletResponse. HttpServletRequestdient dazu, Informationen über eine eingehende HTTP-Anfrage zu erhalten. HttpServletResponsebenötigt, um eine Antwort auf eine Anfrage zu generieren. Innerhalb der Methode erhalten wir das Objekt PrintWritervom Antwortobjekt ( HttpServletResponse), indem wir die getWriter(). Als nächstes können wir mithilfe von einen Wert in das resultierende Objekt schreiben write. Was wir tatsächlich nutzen, indem wir PrintWriterden Wert, den wir aus dem von uns definierten EJB erhalten haben, in das -a-Objekt schreiben (der Wert ist die Zeichenfolge „Hello World!“). Der Client, der die HTTP-Anfrage gesendet hat, erhält diesen Wert als Antwort auf seine Anfrage. Der nächste Schritt besteht darin, die Anwendung auf dem GlassFish Java EE-Server zu starten. Dazu erstellen wir eine neue Konfiguration, wie im Artikel zum Einrichten der lokalen Umgebung beschrieben . Unten sehen Sie einen Screenshot der fertigen Konfiguration für das aktuelle Projekt. Stellen Sie sicher, dass Sie den GlassFish-Server installiert haben, bevor Sie beginnen: Nachdem Sie die Startkonfiguration erstellt haben, starten Sie die Anwendung über das Menü „Ausführen -> „Ejb_demo“ ausführen“ oder über die Tastenkombination Umschalt+F10 . Nach dem Start können Sie die Protokolle sehen: Und auch den Browser, der geöffnet wird: All dies zeigt an, dass die Anwendung wie vorgesehen funktioniert.

Abschluss

In diesem Artikel haben wir EJB – Enterprise JavaBeans kennengelernt. Wir haben Fragen berücksichtigt wie:

• Was ist EJB?
• EJB-Geschichte
• Verschiedene Arten von EJBs

Denken Sie daran, dass es EJBs in den folgenden Typen gibt:

• Message Driven Beans (nachrichtengesteuerte Beans);
• Entity Beans – definiert in der JPA-Entitätsspezifikation (Java Persistence API) und werden zum Speichern von Daten verwendet;
• Sitzungsbohnen:
  • staatenlos (ohne Staat)
  • Stateful (mit Unterstützung für den aktuellen Sitzungsstatus)
  • Singleton (ein Objekt für die gesamte Anwendung; ab EJB 3.1)

Wir haben auch eine kleine HelloWorld-Anwendung mit EJB geschrieben. Als PD können Sie den praktischen Teil dieses Artikels selbst wiederholen. Fügen Sie dann Ihrer Anwendung zwei weitere Servlets hinzu, die Stateful- und Singleton-Beans verwenden, um den Wert zu empfangen.