JavaRush /Blog Java /Random-FR /Présentation des EJB

Niveau 31

Санкт-Петербург

28 février 2021
38 views
0 comments

Présentation des EJB

Dans cet article, nous examinerons les EJB - Enterprise JavaBeans. Cette technologie fait partie de la spécification Java EE. Nous aborderons des questions telles que :

qu'est-ce qu'EJB ;
quelle est l'histoire des EJB ;
Quels types d'EJB existe-t-il ?

Nous allons également écrire une petite application HelloWorld utilisant des EJB et des servlets. Présentation d'EJB-1

Cet article sera utile aux lecteurs qui se sont familiarisés avec Java SE et qui commencent à apprendre Java EE. Pour bien comprendre la partie pratique de cet article, il est recommandé de lire au préalable l'article « Mise en place de l'environnement local ».

Une brève histoire des EJB

En 1996, lorsque l'auteur de cet article avait 5 ans, Java était déjà populaire parmi les développeurs. La raison en était l'API conviviale, le garbage collection automatique, etc. Java était largement utilisé dans les systèmes responsables du backend. Cependant, malgré tous les plaisirs du langage, les programmeurs de l'époque avaient besoin de certaines fonctionnalités qui n'étaient pas encore implémentées dans le JDK. Ces besoins étaient :

assurer la persistance des données ;
intégrité des transactions
accès compétitif aux données (contrôle multi-thread) ;
et très probablement autre chose.

Tout cela a conduit à une croissance naturelle de la population des bibliothèques fermées, auto-écrites et créées localement. En d’autres termes, chacun a répondu à ses besoins du mieux qu’il pouvait. Jusqu'à ce qu'IBM lance le slogan « Tout le monde devrait répondre à ses besoins de la même manière » et publie la spécification Enterprise Java Bean (EJB) en 1997. C'est cela qui a permis d'unifier le processus de développement et de prendre la solution aux problèmes typiques (décrits ci-dessus comme des besoins) dans le cadre. Sun adapte l'idée d'IBM depuis 2 ans et a publié en 1999 la spécification EJB 1.0. C’est ainsi qu’est née la technologie, dont nous parlerons plus loin dans une veine plus appliquée.

Qu'est-ce qu'un EJB ?

EJB, dans un certain sens, est un terme collectif qui, selon le contexte, peut désigner soit la technologie Enterprise JavaBeans elle-même en général, soit un composant logiciel Enterprise JavaBean spécifique (bean) qui fait partie de la technologie EJB. La définition d'EJB en tant que technologie est donnée sur Wikipédia : Enterprise JavaBeans (également souvent utilisé comme abréviation EJB) est une spécification d'une technologie permettant d'écrire et de prendre en charge des composants de serveur contenant une logique métier. Il fait partie de Java EE. Cette technologie est généralement utilisée lorsque la logique métier nécessite au moins un des services suivants, et souvent la totalité :

prise en charge de la persistance des données : les données doivent être en sécurité même après l'arrêt du programme. Le plus souvent réalisé à l’aide d’une base de données ;
prise en charge des transactions distribuées ;
prise en charge de la modification des données parallèles et du multithreading ;
soutien aux événements ;
prise en charge des noms et des répertoires (JNDI) ;
sécurité et restriction de l'accès aux données ;
prise en charge de l'installation automatisée sur le serveur d'applications ;
accès à distance.

Les services répertoriés ci-dessus constituent un avantage incontestable de la technologie EJB. Un autre avantage est que tout ce qui est énuméré ci-dessus fonctionne immédiatement. Ceux. le programmeur n'a pas besoin de penser à la prise en charge des transactions distribuées. Le programmeur n'a qu'à penser à la logique métier qu'il essaie actuellement de mettre en œuvre. Un EJB en tant que composant logiciel spécifique est une classe Java avec une ou plusieurs annotations de la spécification EJB qui contient une partie de la logique métier de l'application. Les annotations de la spécification EJB donnent à la classe balisée certains pouvoirs, pouvoirs et super pouvoirs. En savoir plus à ce sujet ci-dessous.

Types d'EJB

Résumons. Un EJB est une classe Java standard marquée par l'une des annotations spéciales. Ces classes sont appelées haricots. Selon l'annotation avec laquelle la classe est marquée, elle sera représentative de l'un ou l'autre type d'EJB (beans). Il existe trois principaux types de haricots :

Beans pilotés par message (haricots pilotés par message) ;
Entity Beans - définis dans la spécification JPA (Java Persistence API) et utilisés pour stocker des données ;
Haricots de session.

Ces derniers (haricots session) sont divisés en plusieurs sous-types :

apatride (sans état);
avec état (avec prise en charge de l'état de la session actuelle) ;
singleton (un objet pour l'ensemble de l'application ; à partir de l'EJB 3.1).

Ci-dessous, nous examinerons chaque type de haricot plus en détail.

Beans de session

Les Session Beans, ou beans session, sont un type spécifique de bean. Ils encapsulent la logique métier que le client peut invoquer par programme en appelant les méthodes du bean. Un appel de méthode peut faire :

localement, par une autre classe dans la même JVM que le bean session ;
à distance, sur le réseau, depuis une autre JVM, grâce à la technologie Java RMI (Remote Method Invocation).

Le mot « session » implique que le bean n'est disponible que pendant que le serveur exécute une tâche spécifique et qu'il est irrémédiablement détruit en cas de panne ou d'arrêt du serveur. Le cycle de vie d'une instance de bean session est contrôlé par un conteneur EJB (vous pouvez en savoir plus sur les conteneurs EJB dans la première leçon de la série ). Les beans session sans état ne stockent pas d'informations sur leur état. Ce type de composant peut être utilisé par différents clients. Les beans sans état sont utilisés pour implémenter des processus métier qui peuvent être exécutés en une seule opération. Par exemple, vérifier les antécédents de crédit des clients. Étant donné qu'une seule instance de bean peut être utilisée par plusieurs clients, le développeur doit fournir un accès thread-safe aux données du bean. Créer un bean de ce type (ainsi que tous les autres beans session) est assez simple. Il s'agit d'une classe Java standard avec une annotation @Stateless. Donnons un exemple ci-dessous :

import javax.ejb.Stateless;

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

Les beans session qui prennent en charge l'état de session actuel (Stateful) conservent des informations sur leur état entre les appels du même client et mettent fin à leur existence sur une demande explicite du client. Ceci est obtenu grâce au fait que les beans avec état sont uniques pour chaque client. Un exemple de tâche dont ce type de bean peut être responsable est de maintenir à jour le panier d'achat d'une boutique en ligne pour chaque utilisateur. Le cycle de vie de ces beans est géré par le conteneur EJB. Ces beans sont également détruits lorsque le client quitte. De tels haricots sont également assez faciles à créer. Il s'agit d'une classe Java marquée de l'annotation Stateful. Exemple ci-dessous :

import javax.ejb.Stateful;

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

Les beans de session Singleton sont lancés une fois pendant la durée de vie de l'application et existent pendant toute la durée de vie de l'application. De tels beans sont conçus pour les situations dans lesquelles un état doit être partagé entre tous les clients. Comme pour les beans sans état, dans les beans autonomes, le développeur doit s'assurer que l'environnement à l'intérieur du bean est organisé de manière thread-safe. Donnons un exemple de bean Singleton, qui est aussi simple à créer que ses homologues évoqués ci-dessus. Il est facile de deviner qu'il s'agit d'une classe Java avec l'annotation @Singleton. Cependant, dans ce cas, il faut être prudent. Il existe deux annotations, de syntaxe identique, mais d'objectif différent et situées dans des packages différents :

javax.ejb.Singleton
javax.inject.Singleton

Pour créer un EJB, vous devez utiliser l'annotation du javax.ejb. Exemple ci-dessous :

import javax.ejb.Singleton;

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

Beans pilotés par messages

Les Message Driven Beans, ou MDB, ou beans gérés par message, implémentent une certaine logique métier, comme les beans session. Mais contrairement à ses proches, MDB présente une différence importante. Les clients n'appellent jamais directement les méthodes MDB. Ces beans agissent le plus souvent comme des écouteurs pour les messages JMS (Java Message Service) et servent à organiser l'échange de messages asynchrone entre les parties du système. Un exemple d'un tel message serait une demande de livraison de stock d'un système de vente au détail automatisé vers un système de gestion des approvisionnements. Vous trouverez ci-dessous un exemple de bean MDB. Contrairement aux beans session, sa création est un peu plus intéressante :

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

}

L'annotation MessageDrivenfait de notre classe MDB un bean. À l'intérieur de l'annotation, à l'aide de JNDI (lire à propos de JNDI ici ), le nom de la distribution JMS est déterminé, dont notre classe devient un auditeur. De plus, notre classe implémente l'interface MessageListeneret sa méthode onMessage. Cette méthode sera appelée lorsqu'un message arrive de la file d'attente/distribution avec le nom défini dans l'annotation MessageDriven.

Haricots d'entité

Une partie de la technologie EJB est la spécification JPA. JPA, ou Java Persistence API, est une spécification qui fournit un mappage objet-relationnel (ORM) d'objets Java (beans Entity) et fournit une API pour stocker, récupérer et gérer ces objets. JPA vous permet de représenter les données d'une base de données sous forme d'objets Java, ainsi que d'enregistrer des objets Java sous forme d'enregistrements dans la base de données. Toutes les classes ne peuvent pas agir comme un tel objet, à l'exception des beans Entity. Entity Bean est une classe Java qui représente une table dans une base de données. L'affichage (cartographie) est réalisé grâce à l'utilisation d'annotations spéciales. Avec leur aide, une classe Java est comparée à une table de la base de données, ainsi que les champs d'une classe Java sont comparés aux champs d'une table de base de données. Voici un exemple de bean Entity, avec des commentaires dans le 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...
}

Il convient de noter qu'il est logique d'étudier ce type de bean uniquement dans le contexte de l'étude de la spécification JPA.

Ecrire une application : EJB HelloWorld

Dans cette section, nous allons écrire une petite application Java EE HelloWorld, que nous déploierons sur le serveur GlassFish. Avant de lire cet article, il est fortement recommandé de lire l'article sur la configuration de votre environnement local .

Créez un nouveau projet Maven dans IntelliJ IDEA.

Fichier -> Nouveau -> Projet...
Cliquez sur Suivant .
Remplissez les paramètres du projet Maven :
Cliquez sur Terminer
Le projet a été créé et a la structure suivante :

Le fichier pom.xml ressemble à ceci : Présentation des EJB-6

Tout d'abord, nous devons ajouter une dépendance sur l'API Java EE, et également préciser le packaging de notre projet sous la forme d'une archive d'application web (war). Pour ce faire, vous devez modifier le code pom.xml sous la forme suivante :

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

Ensuite, vous pouvez passer au code Java. Notre application sera la plus simple. Nous aurons 1 servlet et 1 EJB. Ce sera un bean session sans état. À l'intérieur de l'EJB, nous définirons une seule méthode qui renverra la chaîne « Hello World ». Tout d'abord, créons un package com.javarush.lectures. Ensuite, à l'intérieur du package com.javarush.lectures, nous créerons notre bean - DemoEJB. Le code du bean est donné ci-dessous :

import javax.ejb.Stateless;

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

Comme dit précédemment, tout est assez simple. Notre prochaine étape consiste à créer un servlet qui transmettra la valeur de l'EJB en réponse à la requête HTTP. Il convient de noter que les servlets ne sont pas le sujet de cet article, mais vous devrez quand même les utiliser pour démontrer les EJB. Pour ce faire, créons un nouveau servlet DemoServletdans le même package que l'EJB. Son code est ci-dessous :

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

Voici quelques brefs commentaires sur le code. Abstract @WebServlet("/helloWorld")- définit notre classe comme une servlet qui traitera les requêtes HTTP vers le point de terminaison /helloWorld. Notre classe a un champ - DemoEJB ejb. C'est notre bean défini plus tôt. Une annotation sur un champ de classe : @EJBeffectue une injection de dépendances (DI). Ceux. La variable ejb est automatiquement initialisée avec une nouvelle instance lorsque cela est nécessaire. Notre classe est un descendant de HttpServlet et remplace l'une des méthodes de la superclasse - doGet. Cette méthode traite les requêtes HTTP GET et prend deux paramètres - HttpServletRequestet HttpServletResponse. HttpServletRequestsert à obtenir des informations sur une requête HTTP entrante. HttpServletResponsenécessaire pour générer une réponse à une demande. À l'intérieur de la méthode, nous récupérons l'objet PrintWriterde l'objet de réponse ( HttpServletResponse), en utilisant le getWriter(). Ensuite, nous pouvons écrire une valeur dans l'objet résultant en utilisant le write. C'est en fait ce que nous utilisons en écrivant dans l' PrintWriterobjet -a la valeur obtenue à partir de l'EJB que nous avons défini (la valeur est la chaîne « Hello World ! »). Le client qui a envoyé la requête HTTP recevra cette valeur en réponse à sa requête. L'étape suivante consiste à lancer l'application sur le serveur GlassFish Java EE. Pour ce faire, nous allons créer une nouvelle configuration, comme décrit dans l'article sur la configuration de l'environnement local . Vous trouverez ci-dessous une capture d'écran de la configuration terminée pour le projet en cours. Assurez-vous que le serveur GlassFish est installé avant de démarrer : Présentation des EJB-7

Après avoir créé la configuration de lancement, lancez l'application en utilisant le menu Exécuter -> Exécuter 'ejb_demo' ou en utilisant le raccourci clavier Shift+F10 . Après le lancement, vous pouvez voir ses logs : Présentation des EJB-8

Et aussi le navigateur qui s'ouvre : Présentation des EJB-9

Tout cela indique que l'application fonctionne comme prévu.

Conclusion

Dans cet article, nous avons fait connaissance avec EJB - Enterprise JavaBeans. Nous avons examiné des questions telles que :

Qu’est-ce qu’EJB ?
Historique des EJB
Différents types d'EJB

Rappelez-vous que les EJB sont des types suivants :

Beans pilotés par message (haricots pilotés par message) ;
Entity Beans - définis dans la spécification des entités JPA (Java Persistence API) et utilisés pour stocker des données ;
Beans de session :
- apatride (sans état)
- avec état (avec prise en charge de l'état de la session actuelle)
- singleton (un objet pour l'ensemble de l'application ; à partir d'EJB 3.1)

Nous avons également écrit une petite application HelloWorld utilisant EJB. En tant que PD, vous pouvez répéter vous-même la partie pratique de cet article. Et puis ajoutez deux autres servlets à votre application qui utiliseront des beans avec état et singleton pour recevoir la valeur.

Commentaires

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION