EJB in Java

Ejb wird als Enterprise Java Bean Component bezeichnet, auch serverseitige Softwarekomponenten genannt; Es wird hauptsächlich als Geschäftslogik der Anwendungen verwendet. Die für Laufzeitumgebungen verwendeten Webcontainer umfassen die Softwarekomponenten, Computersicherheit, Servlet-Lebenszyklusverwaltung, Transaktionsverarbeitung und Webdienste. EJb ist der in den Java-Programmiersprachen geschriebene Architekturstil, der auf der Serverseite des Computernetzwerks ausgeführt wird ist bei den Anwendungen dem Client-Server-Modell gefolgt. Und außerdem ist ejb die Java-Bean-Technologie zur Verteilung der Webkomponenten auf der Clientseite. Sie verfügt über die Funktion „wiederverwendbare Komponenten“ in mehreren Webanwendungen.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax:

Die grundlegende Syntax des EJB-Modells in der Java-Programmierung wie folgt.

import javax.ejb.*;
import java packages;
class classname
{
Main  method()
{
-----Some programming logics----
}
}

Die oben genannten Codes sind grundlegende Schritte zum Entwickeln der Anwendung mithilfe von EJB-Paketen.

Wie verwende ich EJB in Java Works?

• In EJB verwendet die Java-Bean-Klasse mehr als eine Annotation für die EJB-Spezifikationen, was hilfreich ist, um die Benutzeranforderungen basierend auf dem Geschäftszweck zu erfüllen. EJB verfügt über einen anderen Satz von Versionen und folgt der Funktion wie JNDI (Java-Benennungsverzeichnisschnittstelle). Eine der Ressourcen im JNDI-Server ist der Verzeichnisdienst, der zum Auffinden oder Zuweisen der Ressource verwendet wird, z. B. EJB-, Datenquellen- und JMS-Warteschlangendienste. Die Server haben einen Standardschemanamen für die JNDI-Ressourcen, dieser sollte jedoch überschrieben werden, wenn wir den Namen des Konfigurationsteils ändern.
• EJB funktioniert mit Java Beans; Es gibt zwei verschiedene Typen: 1. Session Beans und 2. Message Driven BeansSession Beans. Session-Beans werden für Client-Server-Interaktionen verwendet; Es kapselt die Geschäftslogik der Anwendung programmgesteuert, indem der Client-Aufruf entweder von einem lokalen Computer oder einem Remote-Computer ausgeführt wird. Die Bean wird vom Client mithilfe von Webdiensten verwendet. Session-Beans gibt es in drei verschiedenen Kategorien: 1. Stateless, 2.Stateful und 3.Singleton.Stateless Beans. Wenn der Client diese Art von Beans verwendet, gibt es in Webcontainern keinen permanenten Zustand, sodass sie im Vergleich sehr schnell threadsicher und leistungsmäßig sind zu Stateful Beans. Diese Beans werden gleichzeitig mit mehreren Clients geteilt.
• Stateful Beans können die Zustände in Containern speichern; Sobald der Client die Sitzung beendet, werden diese Zustände auch auf dem Server zerstört. Bei Singelton Beans gibt es eine einzelne Instanzsitzung für den gesamten Lebenszyklus dieser Anwendung. Diese Beans teilten auch die Zustände mit mehreren Clients. Diese Beans sind Thread-sicher, sodass Entwickler sie einfacher verwenden können und die Leistung im Vergleich zu Stateful Beans auch schneller ist.
• Message Driven Beans (MDB) ist der Bean-Typ, der wie JMS-Nachrichten-Listener als asynchroner Nachrichtentyp verwendet wird, die Nachrichtenantwort jedoch als JMS-Nachrichten anstelle der Ereignisse empfängt. Wir können die Nachrichten mithilfe von JNDI-Diensten zuordnen, wenn die Nachricht empfangen wird. Der Container ruft die MDB-Beans mithilfe der Methode onMessage() zur weiteren Verarbeitung auf. Der gesamte Prozess der MDB unter Verwendung der onMessage()-Methode ist eine einzige Transaktion. Wenn es sich beim Nachrichtenprozess um einen Rollback handelt, wird die Empfängernachricht erneut zugestellt.

Beispiele zur Implementierung von EJB in Java

Im Folgenden finden Sie die genannten Beispiele:

Beispiel #1

Schnittstelle:

package JPAEJB;
import java.util.List;
import javax.ejb.Remote;
@Remote
public interface CustomerInterface {
void addBooks(String name);
List getBooks();
}

Umsetzung:

import java.util.ArrayList;
import java.util.List;
import javax.ejb.Stateless;
import JPAEJB.CustomerInterface;
@Stateless
public class CustomerClass implements CustomerInterface {
List<String>books;
public CustomerClass() {
books = new ArrayList<String>();
}
public void addBooks(String name) {
books.add(name);
}
public List<String> getBooks() {
return books;
}
}

Kundenschnittstelle:

import JPAEJB.CustomerInterface;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.List;
import java.util.Properties;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class CustomerInterfaceImplem {
BufferedReader brConsoleReader = null;
Properties p;
InitialContext c;
{
p = new Properties();
try {
p.load(new FileInputStream("jndi.properties"));
} catch (IOException ex) {
ex.printStackTrace();
}
try {
c = new InitialContext(p);
} catch (NamingException ex) {
ex.printStackTrace();
}
brConsoleReader =
new BufferedReader(new InputStreamReader(System.in));
}
public static void main(String[] args) {
CustomerInterfaceImplem cust = new CustomerInterfaceImplem();
cust.testStatelessEjb();
}
private void show() {
System.out.println("Welcome to my domain");
System.out.print("Options \n1. Add the Books\n2. Exit \nEnter your Choice: ");
}
private void StatelessEjb() {
try {
intc = 1;
CustomerInterface cust =
(CustomerInterface)ctx.lookup("CustomerInterface/remote");
while (c != 2) {
String books;
show();
String str = brConsoleReader.readLine();
c = Integer.parseInt(str);
if (c == 1) {
books = brConsoleReader.readLine();
cust.addBooks(books);
}elseif (c == 2) {
break;
}
}
List<String>books1 = cust.getBooks();
System.out.println(books1.size());
for (inti = 0; i<books1.size(); ++i) {
System.out.println((i+1)+". " + books1.get(i));
}
CustomerInterface cust1 =
(CustomerInterface)ctx.lookup("cust/remote");
List<String>books2 = cust.getBooks();
System.out.println(books2.size());
for (inti = 0; i<books2.size(); ++i) {
System.out.println((i+1)+". " + books2.get(i));
}
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
} finally {
try {
if(brConsoleReader !=null) {
brConsoleReader.close();
}
} catch (IOException ex) {
System.out.println(ex.getMessage());
}
}
}
}

Beispielausgabe:

Beispiel #2

EJB in Webdiensten:

package JPAEJB;
import java.util.List;
import Customers.CustomerInterfaceImplem;
public class Ejbclients{
public static void main(String[] args) {
for(CustomerInterface cust:getBooks()) {
System.out.println(cust.getBooks());
}
}
private static List
<CustomerInterface> getBooks() {
CustomerInterfaceImplem s =
new CustomerInterfaceImplem();
CustomerInterface c =
s.getCustomerInterfacePort();
return c.getBooks();
}
}

Beispiel #3

EJB-Sicherheit:

import javax.ejb.*
@Stateless
@DeclareRoles({"customer""books"})
public class CustSecurity implements CustomerInterface {
@RolesAllowed({"books"})
public void delete(CustomerInterface cust) {
System.out.println("customer delete the books");
}
@PermitAll
public void showBooks(CustomerInterface cust) {
System.out.println("customer viewed the books");
}
@DenyAll
public void deleteAll() {
System.out.println("customer delete all the books in libraries");
}
}

Sicherheits-XML:

<?xml version="1.0"encoding="UTF-8"?>
<!DOCTYPE sun-ejb-jar PUBLIC "-//Sun Microsystems, Inc.//DTD Application Server 9.0 EJB 3.0//EN""http://www.sun.com/software/appserver/dtds/sun-ejb-jar_3_0-0.dtd">
<ejb-jar>
<security-role-mapping>
<role-name>customer</role-name>
<group-name>customer-groups</group-name>
</security-role-mapping>
<security-role-mapping>
<role-name>Books</role-name>
<group-name>Books-group</group-name>
</security-role-mapping>
<enterprise-beans/>
</ejb-jar>

Erklärung: Die obigen drei Beispiele sind die gleiche Ausgabe, wir haben verschiedene Funktionen des EJB verwendet. Das erste Beispiel, das wir verwenden, der Kunde wird die Bücher mit jndi (Java Naming Directory Interface) hinzufügen und löschen. Das zweite Beispiel, das wir verwenden Der Webdienst für den Kunden hat die Vorgänge über das Web erledigt. Letztes Beispiel haben wir die zusätzliche Sicherheit genutzt.

Fazit

Im Allgemeinen fungiert EJB als Schnittstelle außerhalb von Geschäftslogikanwendungen. Im Vergleich zu anderen Geschäftslogik-Frameworks verfügt es über eine Browserkompatibilitätsfunktion, die hinsichtlich der Sicherheit besser ist. Außerdem werden die Transaktionen auf Systemebene verwaltet.

Das obige ist der detaillierte Inhalt vonEJB in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!