Best Way to Use and Instantiate Entitymanagerfactory

Question

My project has the following structure:

Within the package br.mandacaru.DAO are the controllers. To instantiate an object JPAController I need an object EntityManagerFactory and for that reason I created a class EntityManagerProvider which has a method getEntityManagerFactory that returns an object EntityManagerFactory. Whenever I’m instantiating one controller, instancio the class EntityManagerProvider within the view to perform any of the CRUD actions. Staying as follows:

It turns out that way, for each View i will need to instantiate in the class the object EntityManagerFactory which according to what the project is growing will become expensive and I think not very efficient. What would be the best way to instantiate this object EntityManagerFactory in the main class and pass it to the views?

Answer 1

Entitymanagerfactory can and should be static:

1. The specification says it’s multi-threaded
2. Cost 'too loud' for you to instill it all the time

In the class you created, leave the Entitymanagerfactory as private static EntityManagerFactory emf. Then create a static method like:

public static EntityManager getEntityManager() {
    return emf.createEntityManager();
}

Entitymanager is not thread safe:

1. The specification says it should not be reused
2. Ideally, open one when the request arrives and then finish.
3. If you leave it open, resources with the database may run out

Answer 2

Here are the golden rules:

1. You must have a EntityManager by interaction with the database¹.
2. You must have a EntityManagerFactory by database in the application (persistence Unit) and for ClassLoader.

Most applications do not deal with ClassLoaders directly and does not need to handle multiple versions of the same class in memory at the same time. Therefore in 99.9% of cases, rule number 2 can be simplified to:

2. You must have a EntityManagerFactory by database in the application (persistence Unit).

Also, in about 98% of cases, the application only works with a single database. And therefore, rule number 2 can be simplified to:

2. You must have a single EntityManagerFactory in the application.

And this suggests that you can use the design pattern Singleton:

public final class EntityManagerProvider {

    private static final EntityManagerProvider INSTANCE = new EntityManagerProvider();

    private final EntityManagerFactory factory;

    private EntityManagerProvider() {
        this.factory = Persistence.createEntityManagerFactory("SUA_BASE_DE_DADOS");
    }

    public static EntityManagerProvider getInstance() {
        return INSTANCE;
    }

    public EntityManagerFactory getFactory() {
        return factory;
    }

    public EntityManager createManager() {
        return factory.createEntityManager();
    }
}

This class above takes care of rule 2 perfectly. I suggest you implement rule number 1 in it as well, using a ThreadLocal to maintain references to EntityManagers and taking care not to reuse EntityManagerdifferent requests, which can happen if your threads are in a pool and can be reused between different requests.

Also, the above code is easy to be modified to handle the case where there is more than one database. Just that each EntityManagerFactory is in a class field EntityManagerProvider and that each one is accessed by a different set of methods, or that you add a parameter to the relevant methods specifying which is the relevant database.

---

^{1 - In this context, a sequence of operations related to running consecutively in the database is defined by interaction with the database, possibly in a single transaction scope.}