EJB en Java

Ejb est désigné sous le nom de Enterprise Java Bean Component, également appelé composants logiciels côté serveur ; il sera principalement utilisé comme logique métier des applications. Les conteneurs Web utilisés pour les environnements d'exécution incluent les composants logiciels, la sécurité informatique, la gestion du cycle de vie des servlets, le traitement des transactions et les services Web. EJb est le style d'architecture écrit dans les langages de programmation Java exécutés côté serveur du réseau informatique. a suivi le modèle client-serveur dans les applications. De plus, ejb est la technologie du bean Java permettant de distribuer les composants Web côté client. Il possède la fonctionnalité appelée composants réutilisables dans plusieurs applications Web.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe :

La syntaxe de base du modèle EJB dans la programmation Java comme suit.

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

Les codes ci-dessus sont des étapes de base pour développer l'application à l'aide de packages ejb.

Comment utiliser les EJB dans Java Works ?

• Dans EJB, la classe du bean Java utilisera plus d'une annotation pour les spécifications ejb, ce qui sera utile pour satisfaire les exigences des utilisateurs en fonction de l'objectif commercial. EJB a un ensemble de versions différent et a suivi des fonctionnalités telles que JNDI. (interface de répertoire de noms Java). L'une des ressources des serveurs jndi est le service d'annuaire utilisé pour localiser ou allouer la ressource, comme les services ejb, source de données et file d'attente JMS. Les serveurs ont un nom de schéma par défaut pour les ressources jndi, mais il doit être remplacé si nous modifions le nom de la partie configuration.
• EJB fonctionnera sur les beans Java ; il a deux types différents 1. Beans de session et 2. Beans pilotés par message Beans de session. Les beans session seront utilisés pour les interactions client-serveur ; il encapsule la logique métier de l'application via un programme par lequel l'invocation du client sera effectuée soit par une machine locale, soit par un bean de machine distante qui sera utilisé par le client à l'aide de services Web. Les beans de session seront trois catégories différentes : 1. Beans Stateless, 2.Stateful et 3.Singleton.Stateless. Lorsque le client utilise ce type de beans, il n'y a pas d'état permanent dans les conteneurs Web, ils sont donc très rapides en termes de performances thread-safe par rapport aux beans avec état. Ces beans sont partagés avec plusieurs clients en même temps.
• Les beans avec état peuvent stocker les états dans des conteneurs ; une fois que le client termine la session, ces états sont également détruits dans le serveur. Beans Singleton, il dispose d'une session d'instance unique pour tout le cycle de vie de cette application ; ces beans partageaient également les états avec plusieurs clients. Ces beans sont thread-safe, les développeurs les utiliseront donc plus facilement et leurs performances seront également plus rapides que celles des beans avec état.
• Message Driven Beans (MDB) est le type de bean qui est utilisé comme type de message asynchrone comme les écouteurs de message JMS, mais il recevra la réponse au message sous forme de messages JMS au lieu d'événements. Nous pouvons mapper les messages à l'aide des services jndi chaque fois que le message reçoit le conteneur appelle les beans MDB en utilisant la méthode onMessage() pour un processus ultérieur. L'ensemble du processus du MDB utilisant la méthode onMessage() sera une seule transaction. Si supposons que le processus de message soit une restauration, le message du destinataire est à nouveau délivré.

Exemples d'implémentation d'EJB en Java

Voici les exemples mentionnés :

Exemple n°1

Interface :

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

Mise en œuvre :

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;
}
}

Interface client :

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());
}
}
}
}

Exemple de sortie :

Exemple n°2

EJB dans les services Web :

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();
}
}

Exemple #3

Sécurité des EJB :

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");
}
}

XML de sécurité :

<?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>

Explication : Les trois exemples ci-dessus sont le même résultat. Nous avons utilisé différentes fonctionnalités de l'ejb. Premier exemple que nous utilisons, le client ajoutera et supprimera les livres en utilisant jndi (interface de répertoire de noms Java) deuxième exemple que nous utilisons. le service Web pour le client a effectué les opérations via le Web. Dans le dernier exemple, nous avons utilisé la sécurité supplémentaire.

Conclusion

Généralement, les EJB agissent comme une interface en dehors des applications de logique métier ; il offre davantage de fonctionnalités de compatibilité avec les navigateurs en termes de sécurité par rapport à d'autres frameworks de logique métier. Il gère également les transactions au niveau du système.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!