web-dev-qa-db-fra.com

Qu'est-ce qu'un EJB et que fait-il?

Vous essayez de savoir ce que sont les beans EJB, comment cela se passe-t-il que leurs instances soient gérées dans un pool, bla blah. Je ne peux vraiment pas les saisir.

Pouvez-vous m'expliquer ce qu'ils sont réellement (pratiquement pour un Java)? Que font-ils? Quels sont leurs objectifs? Pourquoi les utiliser réellement? ( Pourquoi ne pas simplement s'en tenir à POJO?) Peut-être un exemple d'application?

Veuillez vous reporter uniquement aux informations mises à jour, à savoir EJB 3.1. Les informations datées sur EJB peuvent être trompeuses.

Pour les débutants en apprentissage EJB, veuillez noter:

Les EJB sont basés sur objets distribués, il s’agit de logiciels s'exécutant sur plusieurs machines (virtuelles ou physiques) liées par un résea.

java-eeejbejb-3.1
144
jacktrades

Pourquoi vraiment les utiliser? (Pourquoi ne pas s'en tenir à POJO?)

SI vous avez besoin d’un composant qui accède à la base de données, ou à d’autres ressources de connectivité/répertoire, auquel plusieurs clients ont accès, ou qui est conçu comme un service SOA), les EJB sont aujourd’hui "plus gros, plus forts" , plus rapides (ou du moins plus évolutifs) et plus simples que les POJO. Ils sont particulièrement utiles pour servir un grand nombre d’utilisateurs via le Web ou un réseau d’entreprise et un peu moins pour les petites applications d’un département.

  1. Réutilisation/partage de la logique sur plusieurs applications/clients avec Loose Coupling.
    Les EJB peuvent être emballés dans leurs propres fichiers JAR, déployés et invoqués à partir de nombreux emplacements. Ce sont des composants communs. Certes, les POJO peuvent être (soigneusement!) Conçus comme des bibliothèques et conditionnés sous forme de bocaux. Mais les EJB prennent en charge les accès réseau local et distant, y compris via l’interface locale Java, RMI transparent, message async. JMS et service Web SOAP/REST), en enregistrant les dépendances de jar coupées et collées avec plusieurs ( incohérents?) déploiements.
    Ils sont très utiles pour créer des services SOA. Utilisés pour l'accès local, ils sont des POJO (avec services de conteneur gratuits ajoutés). Le fait de concevoir une couche distincte d'EJB favorise une prudence accrue. pour maximiser l'encapsulation, le couplage lâche et la cohésion, et favorise une interface propre (façade), protégeant les appelants des modèles de traitement et de données complexes.

  2. Évolutivité et fiabilité Si vous appliquez un grand nombre de demandes provenant de divers messages/processus/threads appelants, celles-ci sont d'abord distribuées sur les instances d'EJB disponibles dans le pool, puis mises en file d'attente. Cela signifie que si le nombre de demandes entrantes par seconde est supérieur à ce que le serveur peut gérer, nous nous dégradons progressivement. Certaines demandes sont toujours traitées efficacement et les demandes excédentaires sont mises en attente. Nous n'atteignons pas la "fusion" du serveur - où TOUTES les demandes subissent simultanément un temps de réponse très pénible, plus le serveur tente d'accéder à plus de ressources que le matériel et le système d'exploitation ne peuvent en gérer, ce qui provoque des pannes. Les EJB peuvent être déployés sur un niveau distinct pouvant être mis en cluster. Cela confère une fiabilité accrue grâce au basculement d'un serveur à un autre. Il est également possible d'ajouter du matériel à la mise à l'échelle de manière linéaire.

  3. Gestion de la concurrence. Le conteneur veille à ce que plusieurs clients accèdent automatiquement en toute sécurité (en série) aux instances d'EJB. Le conteneur gère le pool EJB, le pool de threads, la file d'attente des appels et procède automatiquement au verrouillage en écriture au niveau de la méthode (par défaut) ou au verrouillage en lecture (via @Lock (READ)). Cela protège les données contre la corruption par des conflits d'écriture-écriture simultanés et permet une lecture cohérente des données en empêchant les conflits de lecture-écriture.
    Ceci est principalement utile pour les beans de session @ Singleton, où le bean manipule et partage un état commun entre les appelants du client. Cela peut facilement être évité pour configurer manuellement ou contrôler par programme des scénarios avancés pour l'exécution simultanée de code et l'accès aux données.

  4. Traitement automatisé des transactions.
    Ne faites rien du tout et toutes vos méthodes EJB sont exécutées dans une transaction JTA. Si vous accédez à une base de données à l'aide de JPA ou JDBC, celle-ci est automatiquement inscrite dans la transaction. Même chose pour les invocations JMS et JCA. Spécifiez @TransactionAttribute (someTransactionMode) avant une méthode pour spécifier si/comment cette méthode particulière participe à la transaction JTA, en remplaçant le mode par défaut: "Obligatoire".

  5. Très simple accès ressource/dépendance par injection.
    Le conteneur recherchera des ressources et définira des références de ressources en tant que champs d'instance dans l'EJB: telles que connexions JDBC JNDI stockées, connexions/sujets/files d'attente JMS, autres EJB, JTA Transactions, contextes de persistance du gestionnaire d'entités JPA, gestionnaire d'entités JPA unités de persistance usine et ressources de l’adaptateur JCA. par exemple. pour configurer une référence à un autre EJB, une transaction JTA, un gestionnaire d'entités JPA, une fabrique de connexions JMS et une file d'attente:

    @Stateless
public class MyAccountsBean {

    @EJB SomeOtherBeanClass someOtherBean;
    @Resource UserTransaction jtaTx;
    @PersistenceContext(unitName="AccountsPU") EntityManager em;
    @Resource QueueConnectionFactory accountsJMSfactory;
    @Resource Queue accountPaymentDestinationQueue;

    public List<Account> processAccounts(DepartmentId id) {
        // Use all of above instance variables with no additional setup.
        // They automatically partake in a (server coordinated) JTA transaction
    }
}

    Un servlet peut appeler ce bean localement, en déclarant simplement une variable d'instance:

    @EJB MyAccountsBean accountsBean;

    et ensuite simplement appeler ses méthodes comme vous le souhaitez.

  6. Interaction intelligente avec JPA. Par défaut, EntityManager injecté comme ci-dessus utilise un contexte de persistance soumis à transaction. C'est parfait pour les beans session sans état. Lorsqu'une méthode EJB (sans état) est appelée, un nouveau contexte de persistance est créé dans la nouvelle transaction. Toutes les instances d'objet d'entité extraites/écrites dans la base de données ne sont visibles que dans cet appel de méthode et sont isolées des autres méthodes. Mais si d'autres méthodes EJB sans état sont appelées par la méthode, le conteneur se propage et leur partage le même PC, de sorte que les mêmes entités sont automatiquement partagées de manière cohérente via le PC dans la même transaction.
    Si un bean de session @Stateful est déclaré, une affinité intelligente avec JPA est obtenue en déclarant que entityManager est une portée étendue: @PersistentContent (unitName = "AccountsPU, type = EXTENDED). Ceci existe pour la vie de la session de bean, à travers plusieurs appels et transactions de bean, en mettant en cache les copies en mémoire d'entités de base de données précédemment récupérées/écrites afin qu'elles n'aient pas besoin d'être extraites à nouveau.

  7. La gestion du cycle de vie. Le cycle de vie des EJB est géré par le conteneur. Selon les besoins, il crée des instances EJB, efface et initialise l’état du bean de session avec état, passive, active et appelle des méthodes de rappel de cycle de vie, afin que le code EJB puisse participer à des opérations de cycle de vie afin d’acquérir et de libérer des ressources, ou d’effectuer un autre comportement d’initialisation et d’arrêt. Il capture également toutes les exceptions, les enregistre, annule les transactions selon les besoins et lève les nouvelles exceptions EJB ou @ApplicationExceptions selon les besoins.

  8. Gestion de la sécurité. Le contrôle d'accès basé sur les rôles aux EJB peut être configuré via une simple annotation ou un paramètre XML. Le serveur transmet automatiquement les détails de l'utilisateur authentifié avec chaque appel en tant que contexte de sécurité (principal et rôle de l'appelant). Cela garantit que toutes les règles RBAC sont automatiquement appliquées, de sorte que les méthodes ne puissent pas être appelées illégalement par le mauvais rôle. Il permet aux EJB d'accéder facilement aux détails de l'utilisateur/du rôle pour une vérification par programme supplémentaire. Il permet de connecter de manière standard des traitements de sécurité supplémentaires (ou même des outils IAM) au conteneur.

  9. Normalisation et portabilité. Les implémentations EJB sont conformes à Java Normes EE et conventions de codage, favorisant la qualité et la facilité de compréhension et de maintenance. Il favorise également la portabilité du code vers les nouveaux serveurs d'applications des fournisseurs, en veillant à ce qu'ils prennent en charge les mêmes fonctionnalités standard. comportements, et en décourageant les développeurs d'adopter accidentellement des logiciels propriétaires
    caractéristiques du fournisseur non portables.

  10. Le vrai kicker: la simplicité. Tout ce qui précède peut être fait avec un code très rationalisé - en utilisant les paramètres par défaut pour les EJB dans Java EE 6, ou en ajoutant quelques annotations. Le codage des fonctionnalités d'entreprise/industrielle dans vos propres POJO serait way plus volumineux, complexe et sujet aux erreurs.Une fois que vous commencez à coder avec des EJB, ils sont plutôt faciles à développer et offrent un grand nombre d'avantages "gratuits".

Dans les spécifications EJB originales d'il y a 10 ans, les EJB constituaient un problème de productivité majeur. Ils étaient gonflés, avaient besoin de nombreux artefacts de code et de configuration et fournissaient environ les deux tiers des avantages ci-dessus. La plupart des projets Web ne les utilisaient pas réellement. Mais cela a considérablement changé avec 10 ans de peaufinage, de révision, d’amélioration fonctionnelle et de rationalisation du développement. Dans Java EE 6, ils offrent une puissance industrielle maximale et une simplicité d’utilisation.

Qu'est-ce qui ne pas aimer ?? :-) :-)

158
Glen Best

Un EJB est un composant Java, contenant une logique métier, que vous déployez dans un conteneur et qui bénéficie des services techniques fournis par le conteneur, généralement de manière déclarative, grâce à des annotations:

  • gestion des transactions: une transaction peut être lancée automatiquement avant qu'une méthode de l'EJB ne soit invoquée, puis validée ou restaurée une fois cette méthode renvoyée. Ce contexte transactionnel est propagé aux appels à d'autres EJB.
  • gestion de la sécurité: il est possible de vérifier que l'appelant a les rôles nécessaires pour exécuter la méthode.
  • injection de dépendance: d'autres EJB ou des ressources telles qu'un gestionnaire d'entités JPA, une source de données JDBC, etc. peuvent être injectés dans les EJB.
  • simultanéité: le conteneur s'assure qu'un seul thread à la fois appelle une méthode de votre instance EJB.
  • distribution: certains EJB peuvent être appelés à distance, à partir d'une autre machine virtuelle Java.
  • basculement et équilibrage de la charge: les clients distants de vos EJB peuvent automatiquement voir leur appel redirigé vers un autre serveur si nécessaire.
  • gestion des ressources: les beans stateful peuvent être automatiquement passivés sur le disque afin de limiter la consommation de mémoire de votre serveur.
  • ... J'ai probablement oublié certains points.
65
JB Nizet

J'espère que Oracle doc aidera quelqu'un comme moi à comprendre le sujet des EJB de manière simple.

Qu'est-ce qu'un bean entreprise? Ecrit dans le langage de programmation Java, un bean entreprise est un composant côté serveur qui encapsule la logique métier d'une application. La logique métier est le code qui remplit la fonction de l'application. application de contrôle des stocks, par exemple, les beans d'entreprise peuvent implémenter la logique métier dans des méthodes appelées checkInventoryLevel et orderProduct.En appelant ces méthodes, les clients peuvent accéder aux services d'inventaire fournis par l'application.

Avantages des beans entreprise Pour plusieurs raisons, les beans entreprise simplifient le développement d'applications volumineuses et distribuées. Premièrement, comme le conteneur EJB fournit des services de niveau système aux beans d'entreprise, le développeur de beans peut se concentrer sur la résolution des problèmes de l'entreprise. Le conteneur EJB, plutôt que le développeur du bean, est responsable des services au niveau du système, tels que la gestion des transactions et les autorisations de sécurité.

Deuxièmement, étant donné que les beans plutôt que les clients contiennent la logique métier de l’application, le développeur client peut se concentrer sur la présentation du client. Le développeur client n'a pas à coder les routines qui implémentent des règles métier ou accèdent à des bases de données. En conséquence, les clients sont plus minces, un avantage particulièrement important pour les clients utilisant de petits appareils.

Troisièmement, les beans entreprise étant des composants portables, l'assembleur d'applications peut créer de nouvelles applications à partir de beans existants. Ces applications peuvent s’exécuter sur n’importe quel serveur conforme Java EE, à condition qu’ils utilisent les API standard.

Quand utiliser les beans entreprise? Vous devriez envisager d'utiliser les beans entreprise si votre application présente l'une des conditions suivantes:

L'application doit être évolutive. Pour prendre en charge un nombre croissant d’utilisateurs, vous devrez peut-être répartir les composants d’une application sur plusieurs ordinateurs. Les beans entreprise d'une application peuvent non seulement s'exécuter sur des machines différentes, mais leur emplacement restera transparent pour les clients.

Les transactions doivent assurer l'intégrité des données. Les beans entreprise prennent en charge les transactions, les mécanismes qui gèrent l'accès simultané aux objets partagés.

L'application aura une variété de clients. Avec seulement quelques lignes de code, les clients distants peuvent facilement localiser des beans enterprise. Ces clients peuvent être minces, divers et nombreux.

21
Tesfa Zelalem

La question qui m'intéresse le plus est de savoir comment et où puis-je les utiliser. Pour comprendre cela, nous devons d’abord voir quels types d’EJB existent. Il y a 2 grandes catégories:

  1. Haricots de session
  2. Haricots à message

Considérons les Beans Session. Ils sont de 3 sortes:

  1. Stateful - ces composants conservent l'état et sont spécifiques à un client pour plusieurs requêtes. Voir comme une session. L’utilisation immédiate de celles-ci pourrait être: paniers ou un autre type de session (connexion, etc.)
  2. Stateless - il s'agit de composants autonomes qui ne conservent pas les informations entre les demandes, mais qui sont propres à l'utilisateur. Utilisation immédiate qui me vient à l’esprit - classes de service dans la couche service. Imaginez OrderService. Une autre grande utilisation de ceux-ci est d'exposer les services Web. Encore une fois, cela soit dans la couche Service ou totalement séparé.
  3. Singleton - Ce sont les beans existant par application, créés une fois et pouvant être réutilisés/consultés plusieurs fois. On pense immédiatement au composant Configuration - où vous pouvez stocker les configurations au niveau de l'application et y accéder lorsque vous en avez besoin, où que vous soyez.

Maintenant, le reste des fonctionnalités ou fonctionnalités peut être utilisé sur plusieurs couches dans de telles situations:

  • Sécurité - vous pouvez vérifier les autorisations avec une annotation sur la méthode appelée. Cela peut se produire dans la couche Service ainsi que dans le contrôleur si vous le souhaitez.
  • Gestion des transactions - il s'agit du candidat évident dans la couche service ou la couche persistance
  • Injection de dépendance - sera à nouveau utilisé partout

Une des grandes utilisations des temps modernes est ce que l’on appelle les architectures Microservices et Service Oriented. Vous pouvez conditionner certains composants de la logique métier sous forme d'EJB et les répartir dans toute l'entreprise, afin qu'ils soient utilisés par plusieurs clients (par client, j'entends d'autres applications dorsales).

Etc. Le gros inconvénient est que vous devenez très dépendant du conteneur EJB et bien que vous puissiez basculer entre deux implémentations de référence, vous ne pourrez pas passer à quelque chose de plus léger - Tomcat par exemple. Mais pourquoi voudriez-vous sacrifier tous les avantages?

3
ACV