JPA 2 - à l'Aide de l'EntityManager dans JavaSE - un couple de questions

J'ai quelques questions concernant l'utilisation de l'entité gestionnaire dans un JavaSE environnement.

Je suis en utilisant le modèle de référentiel pour effectuer mes opérations CRUD sur la base de données. Il y aura une base de dépôt de la classe comme ceci:

public class Repository<T> implements IRepository<T> {

    private EntityManager em;
    private String persistenceUnitName;

    public Repository(String persistenceUnitName) {
        this.persistenceUnitName = persistenceUnitName;
    }

    @Override
    public T find(Class<T> type, Object id) {
        return em.find(type, id);
    }

    private EntityManager getEntityManager() {
        if (this.em == null) {
            EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnitName);

            em = emf.createEntityManager();
        }

        return em;
    }
    ...
    ...
}

Je vais avoir des cours comme EmployeeRepository, qui va hériter de Référentiel. Ces classes de dépôt sera créé dans ma couche de service.

Est-ce une bonne façon de l'initialisation de l'entité gestionnaire? Je commence à croire qu'il ne l'est pas - il semble que vous devez avoir un seul gestionnaire d'entité par unité de persistance? Où, comme dans ce cas, vous disposez d'un gestionnaire d'entités pour chaque dépôt que vous créez... Comment feriez-vous pour vous assurer avoir une seule entité gestionnaire par unité de persistance? J'ai également remarqué que le gestionnaire de l'entité et l'entité gestionnaire de l'usine méthodes de la méthode close - quand faut-il les appeler? Sur un serveur de mettre fin à l'événement?

Si vous connaissez des bonnes sources sur l'utilisation de JPA dans JavaSE j'aimerais avoir de l'info.

Merci!

OriginalL'auteur Brian DiCasa | 2010-11-01

  1. 3

    Presque. Vous avez juste besoin d'un EntityManagerFactory par unité de persistance.

    Comment feriez-vous assurer vous avez seulement un EntityManagerFactory par unité de persistance ?

    Généralement aux développeurs de créer une classe d'aide avec un singleton EntityManagerFactory comme

    public class EntityManagerFactoryHelper {

    private static EntityManagerFactory factory;

    static {
        try {
           //Set up factory right here
        } catch(ExceptionInInitializerError e) {
            throw e;
        }
    }

    public static EntityManagerFactory getFactory() {
        return this.factory;
    }

}

    L'EntityManager, en revanche, est utilisé pour interagir avec un ensemble de la gestion des instances d'entité appelée le contexte de persistance.

    Si vous voulez savoir pourquoi j'utilise ErrorInInitializerError, son API est clair

    Signale qu'une exception inattendue s'est produite dans un initialiseur statique

    ...

    Est-ce une bonne façon de l'initialisation de l'entité gestionnaire ?

    Bien, la couche de service est utilisé pour délimiter des Transactions limite. Donc pour chaque cas d'utilisation, vous pouvez créer votre EntityManager et passage par référence pour chaque colaborator nécessaire pour vous aider à exécuter votre cas d'utilisation.

    public static br.com.helper.EntityManagerFactoryHelper.getFactory;

public EmployeeService {

    public void doSomething() {
        EntityManager eManager = getFactory().createEntityManager();
        eManager.getTransaction().begin();

        EmployeeRepository repository = new EmployeeRepository(eManager);

        eManager.getTransaction().commit();
    }

}

    Maintenant, imaginez que vous avez besoin du code réutilisable ci-dessus pour chaque cas d'utilisation.

        public void forEachUseCase() {
        //Create an EntityManager
        //Begin a Transaction

        EmployeeRepository repository = new EmployeeRepository(eManager);

        //And finally, commit
    }

    Vous pouvez compter sur Printemps pour vous aider à vous débarrasser de ce code réutilisable.

    Je suis un peu en retard sur ce sujet, mais savez-vous, si vous êtes en utilisant un container managed persistence, et vous recherchez une unité de persistance par son nom JNDI donné dans le <persistance-contexte-ref>: (c'est à dire l'EntityManager manager = (EntityManager) contexte.recherche(jndiName); ), c'est que EM retournés en fait une nouvelle EM à chaque fois? Est-il un EMF derrière la scène du pompage de l'EMs, ou est-ce juste un mondial EM lié à un seul fil?

    OriginalL'auteur Arthur Ronald

  2. 1

    Brian,

    Il est bon de partager EntityManagerFactory, mais il n'est pas d'accord pour partager l'EntityManager. Voir la Persistance Java wikibook.

    Une approche plus moderne serait de faire des singletons avec des enums. Donc, en supposant que vous ne vous attendez pas à aller autour de la modification de votre unité de persistance des noms (je m'attends à ce que de ne pas se produire de toute façon)...

    Donc, idéalement...

    1. Utiliser un singleton pour l'EntityManagerFactory exemple, par unité de persistance.
    2. Créer une nouvelle entité gestionnaire à chaque appel afin de récupérer un, et ne les partagez pas.

    À l'aide d'un enum pour le singleton mécanisme prévoit... (Efficace Java Deuxième édition)

    1. Être concis
    2. Fournit la sérialisation des machines gratuitement
    3. Empêche plusieurs instanciation de EntityManagerFactory avec aucun des problèmes de synchronisation. Cela se produit parce que enum les constructeurs sont appelés à la classe des temps de chargement, et ne peut pas être appelé par votre code.
    4. Assure l'EntityManager est pas partagée à moins que le programmeur fait le mauvais choix à faire.
    public enum PersistenceUnitFactory
{
    PERSISTENCE_UNIT_1("persistenceUnit1"),
    PERSISTENCE_UNIT_2("persistenceUnit2");

    private final EntityManagerFactory emf;
    /**
     * Maps the persistence unit name to this instance of the enum.
     *
     * @param persistenceUnitName the name of the peristence unit in
     *                            persistence.xml
     *
     * @see #getPersistenceUnitName()
     */
    PersistenceUnitFactory(final String persistenceUnitName)
    {
        emf = Persistence.createEntityManagerFactory(persistenceUnitName);
    }

    /**
     * Creates a new {@link EntityManager}.  NEVER share this across threads.
     * 
     * @return a new {@link EntityManager}
     */
    EntityManager createEntityManager()
    {
        return emf.createEntityManager();
    }
}

    Puis c'est aussi simple que de demander pour un EntityManager...

    PersistenceUnitFactory.PERSISTENCE_UNIT_1.createEntityManager();

    Vous pouvez ajouter d'autres unités de persistance que vous en avez besoin.

    OriginalL'auteur Trenton D. Adams