Gérer plusieurs EntityManager dans l'application Java EE

J'ai d'application Java EE avec environ 10 EntityManagers (nombre d'EMs va probablement augmenter). Mon application contient également de nombreux apatrides, statefull et le message driven beans.

Plutôt que de l'injecter dans chaque haricot mon EMs avec @PersistenceContext (et 2 méthodes pour détecter les EM à utiliser pour l'utilisateur), j'ai probablement stocker tout cela à l'intérieur d'un singleton de haricot et de l'accès avec d'autres haricots. Comme ça, pas de soucis à propos de la maintenabilité.

Néanmoins, il est thread-safe pour stocker des EMs à l'intérieur d'un singleton bean? Peut un goulot d'étranglement apparaissent?

Une autre solution est de créer une classe abstraite et tous les haricots de l'étendre.

Quelle est la meilleure solution?

OriginalL'auteur Olivier J. | 2012-12-04

  1. 2

    Gérée par le conteneur gestionnaires de l'entité sont automatiquement propagées avec le courant de transaction JTA et EntityManager références qui sont associés à la même unité de persistance de fournir l'accès au contexte de persistance au sein de cette transaction. Il n'est donc pas une bonne pratique pour partager une entité gestionnaire d'un singleton, en dehors de problèmes de concurrence d'accès, en utilisant le même contexte de transaction pour chaque méthode que vous appelez sur votre haricots.

    Une solution simple à votre besoin, consiste à injecter de EntityManagerFactory références dans votre haricots et de créer EntityManager objets de l'appel de la createEntityManager() méthode.
    L'inconvénient est que vous devez gérer les transactions manuellement, pas de plus en s'appuyant sur le conteneur.

    Sinon, une autre approche pourrait être d'injecter l'ensemble de vos gestionnaires de l'entité au sein d'une grande entreprise de haricots et de mettre en œuvre une logique d'entreprise au service de haricots avec des méthodes que vous passez des gestionnaires responsables.
    Un exemple de cette dernière solution:

    @Stateless
class MainBean {
    @PersistenceContext EntityManager em1;
    @PersistenceContext EntityManager em2;
    ...
    @EJB WorkerBean1 workerBean1;
    @EJB WorkerBean2 workerBean2;
    ...
    void method1(Object param1, Object param2) {
        workerBean1.method1(em1, param1, param2);
    }

    void method2(Object param1, Object param2, Object param3) {
        workerBean2.method2(em2, param1, param2, param3);
    }
    ...
}

@Stateless
class WorkerBean1 {
    void method1(EntityManager em, Object param1, Object param2) {
        ...
    }
    ...
}

@Stateless
class WorkerBean2 {
    void method2(EntityManager em, Object param1, Object param2, Object param3) {
        ...
    }
    ...
}
    je vous remercie. Ok, donc j'ai oublié de singleton et l'injection de EntityManagerFactory parce que je veux conserver le récipient opérations de base. Donc vous me conseiller de copier tous mes EMs dans chaque fève de cacao, si je comprends bien ? C'est tout ce que je veux éviter pour la maintenabilité des problèmes. Je vous remercie pour mieux expliquer si ce n'est pas le cas.
    Oui, si vous souhaitez utiliser gérée par le conteneur des transactions c'est la seule façon. C'est pas vraiment différent de déclarer les gestionnaires de l'entité dans un singleton. Vous pouvez appliquer l'adaptateur modèle de conception, de développement d'une entreprise unique de haricot, pas un singleton, avec tous les gestionnaires de l'entité (si vous avez un seul point à modifier lorsque vous ajoutez ou supprimez des gestionnaires); ce bean implémente toutes les interfaces et achemine les appels de méthode à l'autre de l'entreprise les haricots, les passer à la appropriée de l'entité gestionnaire. Malheureusement, l'inconvénient est que le dernier d'entreprise haricots méthodes doivent inclure les gestionnaires en tant que paramètres.
    ok, donc d'autres haricots prolonger mon unique bean dans lequel tous les EMs sont stockés ? Je veux juste avoir 1 place unique dans lequel les EMs sont codés en dur. L'anglais n'est pas ma langue, j'ai parfois des problèmes pour comprendre les termes techniques, pardonnez-moi.
    J'ai édité ma réponse fournissant un exemple
    Ok merci à vous. Donc, toutes les méthodes appelées passant par la unique de haricot qui est une sorte de répartiteur. Ingénieuse, mais je n'aime pas vraiment parce que c'est probablement plus difficile de se "souvenir" de la méthode à appeler en MainBean car il contient toutes les méthodes combinées pour tous les haricots. Je pense que je vais stockés tous les EM dans statefull de haricots et de l'inclure dans d'autres haricots en cas de besoin. En tout cas, merci pour les précisions.

    OriginalL'auteur remigio

  2. 5

    Un gestionnaire d'entité n'est pas censé être thread-safe, vous ne devriez pas partager vos proches via un Singleton. C'est la même raison pourquoi vous ne devriez pas injecter un gestionnaire d'entité dans une Servlet, et pourquoi une recherche de JNDI dans un composant web -doit - retour d'une autre instance de l'entité gestionnaire de jamais le temps.

    Dans la pratique, certaines implémentations peuvent fournir un gestionnaire d'entité qui est thread-safe, pendant les tests, il peut sembler à travailler. Cependant, pour des raisons de portabilité et de vous protéger contre les malheurs de la mise à niveau, vous ne devez jamais compter sur cette.

    Au lieu d'hériter d'une classe de base commune, vous pouvez définir tous vos gestionnaires de l'entité dans un haricot, et injecter que partout où vous avez besoin d'un gestionnaire d'entités.

    E. g.

    @Stateless
public class EntityManagerProviderBean {

    @PersistenceContext(unitName="foo")
    private EntityManager entityManagerFoo;

    @PersistenceContext(unitName="bar")
    private EntityManager entityManagerBar;

    public EntityManager getEntityManager() {
        return ...? entityManagerFoo : entityManagerBar;
    }
}

    (où ... est la logique que vous utilisez pour sélectionner le gestionnaire d'entité)

    Injecter ce une fève dans le besoin d'un gestionnaire d'entité:

    @Stateless
public class MyService {

    @EJB
    private EntityManagerProviderBean entityManagerProvider;

    public void doStuff(MyEntity myEntity) {
        entityManagerProvider.getEntityManager().update(myEntity);
    }

}

    Sinon, la suite serait peut-être encore plus net:

    @Stateless
@PersistenceContexts({ 
    @PersistenceContext(unitName="foo", name = "fooENC"),
    @PersistenceContext(unitName="bar", name = "barENC") }
)
public class EntityManagerProviderBean {

    @Resource
    private EJBContext context;

    public EntityManager getEntityManager() {
        return (EntityManager) context.lookup(... ? "fooENC" : "barENC");
    }
}

    Le dernier exemple des cartes de tous les contextes de persistance dans l'ENC de la fève, où ils peuvent être facilement récupérés par programme.

    Malheureusement, les gens ont oublié à ajouter des tests pour la dernière syntaxe de la TCK et par la suite les principaux fournisseurs oublié de le mettre en œuvre (voir http://java.net/jira/browse/JPA_SPEC-38 et https://issues.jboss.org/browse/AS7-5549), afin de tester si cela fonctionne sur votre serveur.

    Savez-vous comment IBM A des poignées (EntityManager) contexte.lookup("bla") ? Est l'EntityManager renvoyé un nouveau à chaque fois (1 FEM par PU), ou est-ce le même EM à chaque fois (1 EM par PU)? La première serait génial, deuxième serait terrible. Mais je ne peux pas trouver une réponse, n'importe où.

    OriginalL'auteur Arjan Tijms

  3. 1

    Composite unités de persistance Java EE

    La façon de gérer plusieurs gestionnaires d'entités, à savoir plusieurs unités de persistance en Java EE est d'utiliser des composites unités de persistance (Cpu). Un tel composite unité de persistance peut être évaluée à partir d'un seul point de l'EE d'applications web, un datalayer. Ce doit être un @Stateless EE bean mais dans le but de travailler avec les @PersistenceContext.

    Composite unités de persistance ont été introduites pour rendre possible la réutilisation de classes d'entité, parmi les diverses applications Java. Les processeurs sont une caractéristique de l'architecture d'Entreprise. Je choisis d'utiliser EclipseLink de vitrine, comme j'ai de l'expérience positive de l'exécution d'un logiciel de production.

    Introduction

    Dans certains cas, les entités contiennent des données générales qui est nécessaire dans plus de services web dans un serveur paysage. Prenez par exemple un général du nom de l'adresse’ entité, un "utilisateur-mot de passe-le rôle" de l'entité, un " document-clé à l'indice de l'entité, etc. Un composite unité de persistance de la mise en œuvre facilite la source de chaque définition de l'entité est spécifié dans un seul lieu ("single point de définition"). Ces définitions d'entités peuvent par la suite être inclus dans chaque Java application web qui a besoin de cette entité d'accès.

    De travail du composite à l'unité de persistance

    Le travail d'un composite unité de persistance est illustré par le tutoriel suivant: EclipseLink composite unités de persistance

    Le concept de composite unités de persistance d'abord la définition de membre de l'unité de persistance. Chaque membre de l'unité de persistance peut être associé à une base de données différente, mais le membre de l'unité de persistance peut également se réfèrent tous à la même base de données réelle. J'ai de l'expérience avec ce dernier, où EclipseLink (version 2.6.4) a été utilisé en combinaison avec un Postgress base de données.

    Maven est nécessaire pour rendre possible la nécessaire approche modulaire.

    Paramètres dans persistence.xml

    Un composite persistance membre de l'unité est définie comme suit: Programme d'un groupe d'entités apparentées (Java @Entity classes), un par un, dans un module Maven. Définir dans ce module Maven également un composite membre de l'unité de persistance (important!). Le composite membre de l'unité de PuPersonData se réfère à cet ensemble d'entités liées qui caractérise la personne de données. Définir le membre de l'unité de persistance PuPersonData comme ( 

    <persistence-unit name="PuPersonData" transaction-type="JTA">
...
    <jta-data-source>jdbc/PostgresDs</jta-data-source>
...

    ).

    Dans un deuxième module Maven, définir un autre composite unité de persistance membre, PuWebTraffic ( 

    <persistence-unit name="PuWebTraffic" transaction-type="JTA">
...
    <jta-data-source>jdbc/PostgresDs</jta-data-source>
...

    ). Indiquez ici les autres entités (classes Java notée avec @Entity) qui stockent des données sur le web des transactions, l'ouverture de session, sessions, etc.
    Inutile de l'état, les deux composites persistance membres de l'unité doivent être disjoints à l'égard d'entités, pas de chevauchement est autorisé dans l'entité noms.

    À la fois la persistance membres de l'unité ont dans leur XML-définitions de la propriété:

    <properties>
    <property name="eclipselink.composite-unit.member" value="true"/>
    ...
</properties>

    Composite unité de persistance

    Nous avons maintenant de définir, dans une troisième Maven module composite de l'unité de persistance CPuPersonSessionData qui inclut à la fois la persistance des unités membres PuPersonData et PuWebTraffic.

    <persistence-unit name="CPuPersonSessionData" transaction-type="JTA">

    Ce composite unité de persistance CPuPersonSessionData se réfère aux deux membres de l'unité de persistance, PuPersonData et PuWebTraffic, par le biais de l', y compris les pots qui sont le résultat de la compilation des deux concernent Maven modules.

    ...
    <jar-file>PuPersonData.jar</jar-file>
    <jar-file>PuWebTraffic.jar</jar-file>
...

    Dans le fichier XML de définition du composite unité de persistance, la propriété suivante doit être mis en

    <properties>
    <property name="eclipselink.composite-unit" value="true"/>
    ...
</properties>

    Ce paramètre garantit que le composite de l'unité de persistance est traitée différemment par Java EE que sa persistance membres de l'unité.

    Utilisation de l'unité de persistance en Java

    Dans le Java web-application qui va stocker et de récupérer des entités à la fois la personne-données et de trafic de données, seul le composite de l'unité de persistance est inclus

    @Stateless
public class DataLayer {

    @PersistenceUnit(unitName="CPuPersonSessionData")
    EntityManager em; 
    ...

    La normale 'em' opérations telles que persist, find et merge peut désormais être effectuée sur chaque entité, contenue dans un de l'entité composite membres.

    Sous Payara, pas de XA-opérations ont été nécessaires pour ce composite unité de persistance à l'adresse entités relativement à chacun des membres de l'unité de persistance.

    Maven

    Le Maven parent POM fichier doit contenir le cahier des charges pour la concernant modules.

    ...
    <modules>
            <module>PersonData</module>
            <module>WebTraffic</module>
            <module>PersonSessionData</module>
    </modules>
...

    La POM-fichier de chaque module doit être configuré comme une normale Maven-projet, en se référant à la mère POM-fichier.

    Pièges:

    • Vous avez besoin pour configurer le Maven multi-projet de module correctement, ce qui peut être un peu délicat. Chaque composite membre de l'unité de persistance est constitutif d'un autre module Maven. Aussi le composite de l'unité de persistance est séparé Maven module. Les membres ont besoin d'être compilé, dans Maven séquence.
    • Les "pots" dans le composite unité de persistance doivent être trouvées lors de la compilation du module du composite unité de persistance.
    • Les entités de chaque composite persistance membre de l'unité doivent être disponibles dans le ‘pot’, directement dans les "classes" directory (ajout de chemins d'accès aux entités, via Maven, est possible mais complexe).
    • Les "pots" de la persistance des membres de l'unité doivent être disponibles dans les "classes" répertoire pour le composite de l'unité de persistance pour les trouver.

    Le bénéfice acquis est soigné de données de l'Entreprise-couche qui fonctionne avec réutilisables entités, chacune avec une définition centrale. En outre, il est possible d'effectuer de la croix-unité natif de requêtes SQL. J'ai eu cela fonctionne aussi.

    Documentation, de la croix-unité natif requêtes ne fonctionnera pas lorsque le composite persistance membres de l'unité de fonctionner sur différentes, bases de données réelles. Cela devrait toujours être vérifiée.

    OriginalL'auteur Flying Dutchman