Java EE Session Beans

1. Einleitung

Enterprise Session Beans können grob klassifiziert werden in:

  1. Zustandslose Sitzungsbohnen
  2. Stateful Session Beans

In diesem kurzen Artikel werden wir diese beiden Haupttypen von Session Beans diskutieren.

2. Setup

Um Enterprise Beans 3.2 zu verwenden , müssen Sie die neueste Version zum Abschnitt " Abhängigkeiten " der Datei " pom.xml" hinzufügen :

 javax javaee-api 7.0 provided 
Die neueste Abhängigkeit finden Sie im Maven Repository. Diese Abhängigkeit stellt sicher, dass alle Java EE 7-APIs während der Kompilierungszeit verfügbar sind. Der bereitgestellte Bereich stellt sicher, dass nach der Bereitstellung; Die Abhängigkeit wird von dem Container bereitgestellt, in dem sie bereitgestellt wurde.

3. Staatenlose Bohnen

Eine zustandslose Session-Bean ist eine Art Enterprise-Bean, die üblicherweise für unabhängige Vorgänge verwendet wird. Es ist kein Client-Status zugeordnet, der Instanzstatus wird jedoch möglicherweise beibehalten.

Schauen wir uns ein Beispiel an, um zu demonstrieren, wie eine zustandslose Bean funktioniert.

3.1 Erstellen der zustandslosen Bean

Zuerst erstellen wir die StatelessEJB- Bean. Wir verwenden die Annotation @Stateless , um die Bean als zustandslos zu markieren:

@Stateless public class StatelessEJB { public String name; }

Dann erstellen wir den ersten Client der obigen zustandslosen Bean namens EJBClient1 :

public class EJBClient1 { @EJB public StatelessEJB statelessEJB; }

Wir deklarieren dann einen anderen Client namens EJBClient2, der auf dieselbe zustandslose Bean zugreift:

public class EJBClient2 { @EJB public StatelessEJB statelessEJB; }

3.2 Testen der zustandslosen Bean

Um die Staatenlosigkeit des EJB zu testen, können wir die beiden oben deklarierten Clients folgendermaßen verwenden:

@RunWith(Arquillian.class) public class StatelessEJBTest { @Inject private EJBClient1 ejbClient1; @Inject private EJBClient2 ejbClient2; @Test public void givenOneStatelessBean_whenStateIsSetInOneBean _secondBeanShouldHaveSameState() { ejbClient1.statelessEJB.name = "Client 1"; assertEquals("Client 1", ejbClient1.statelessEJB.name); assertEquals("Client 1", ejbClient2.statelessEJB.name); } @Test public void givenOneStatelessBean_whenStateIsSetInBothBeans _secondBeanShouldHaveSecondBeanState() { ejbClient1.statelessEJB.name = "Client 1"; ejbClient2.statelessEJB.name = "Client 2"; assertEquals("Client 2", ejbClient2.statelessEJB.name); } // Arquillian setup code removed for brevity }

Wir beginnen damit, die beiden EBJ-Clients in den Unit-Test einzubeziehen.

Dann wird in der ersten Testmethode, wir die eingestellte Namen Variable in der EJB, die in injiziert wurde EJBClient1 auf den Wert 1. Client Nun, wenn wir den Wert der Vergleichs Namen Variable in beiden Clients, sollten wir sehen , dass der Wert gleich . Dies zeigt, dass der Status in zustandslosen Beans nicht erhalten bleibt .

Lassen Sie uns zeigen, dass dies auf andere Weise zutrifft. Im zweiten Testverfahren sehen wir , dass , wenn wir setzen Sie den Namen Variable in dem zweiten Client es Überschreibungen " , was auch immer Wert darauf über gegeben wurde ejbClient1 .

4. Stateful Beans

Stateful Session Beans behalten den Status sowohl innerhalb als auch zwischen Transaktionen bei. Aus diesem Grund ist jede Stateful Session Bean einem bestimmten Client zugeordnet. Container können den Status einer Bean automatisch speichern und abrufen, während Instanzpools von Stateful Session Beans verwaltet werden.

4.1 Erstellen der Stateful Bean

Eine Stateful Session Bean ist mit der Annotation @Stateful gekennzeichnet . Der Code für die Stateful Bean lautet wie folgt:

@Stateful public class StatefulEJB { public String name; }

Der erste lokale Client für unsere Stateful Bean lautet wie folgt:

public class EJBClient1 { @EJB public StatefulEJB statefulEJB; }

Ein zweiter Client namens EJBClient2 wird ebenso wie der EJBClient1 erstellt :

public class EJBClient2 { @EJB public StatefulEJB statefulEJB; }

4.2 Testen der Stateful Bean

Die Funktionalität der Stateful Bean wird im EJBStatefulBeanTest- Unit-Test folgendermaßen getestet :

@RunWith(Arquillian.class) public class StatefulEJBTest { @Inject private EJBClient1 ejbClient1; @Inject private EJBClient2 ejbClient2; @Test public void givenOneStatefulBean_whenTwoClientsSetValueOnBean _thenClientStateIsMaintained() { ejbClient1.statefulEJB.name = "Client 1"; ejbClient2.statefulEJB.name = "Client 2"; assertNotEquals(ejbClient1.statefulEJB.name, ejbClient2.statefulEJB.name); assertEquals("Client 1", ejbClient1.statefulEJB.name); assertEquals("Client 2", ejbClient2.statefulEJB.name); } // Arquillian setup code removed for brevity }

Nach wie vor werden die beiden EJB-Clients in den Unit-Test eingespeist. In dem Testverfahren können wir den Wert der sehen , dass Namen über die variabel eingestellt ejbClient1 Client und wird beibehalten , auch wenn der Wert des Namens Satz über den ejbClient2 unterscheidet. Dies zeigt, dass der Zustand des EJB erhalten bleibt .

5. Stateless vs. Stateful Session Bean

Schauen wir uns nun den Hauptunterschied zwischen den beiden Arten von Session Beans an.

5.1 Staatenlose Bohnen

  • Statuslose Session Beans behalten keinen Status mit dem Client bei. Aus diesem Grund können sie verwendet werden, um einen Pool von Objekten zu erstellen, die mit mehreren Clients interagieren
  • Da zustandslose Beans keinen Status pro Client haben, sind sie leistungsmäßig besser
  • Sie können mehrere Anforderungen von mehreren Clients parallel und verarbeiten
  • Kann zum Abrufen von Objekten aus Datenbanken verwendet werden

5.2 Stateful Beans

  • Stateful Session Beans können den Status für mehrere Clients beibehalten, und die Aufgabe wird nicht von Clients gemeinsam genutzt
  • Der Status gilt für die Dauer der Sitzung. Nachdem die Sitzung zerstört wurde, bleibt der Status nicht erhalten
  • Der Container kann den Status serialisieren und als veralteten Status für die zukünftige Verwendung speichern. Dies geschieht, um Anwendungsserverressourcen zu sparen und Bean-Fehler zu unterstützen, und dient der Passivierung
  • Kann verwendet werden, um Probleme vom Typ Produzent-Verbraucher zu lösen

6. Fazit

Daher haben wir zwei Arten von Session-Beans und entsprechende Clients erstellt, um die Methoden aus den Beans aufzurufen. Das Projekt demonstriert das Verhalten der beiden Haupttypen von Session Beans.

Wie immer ist der Quellcode für den Artikel auf GitHub verfügbar.