最佳实践实例化EntityManager

Question

I faced a problem in another topic ( Empty List (not Table) at ManyToMany-Relation ) and wonder if my Usage of EntityManager is correct. So what should be the best way to use EntityManager? A few years ago i read something about the DAO-Pattern (like http://www.oracle.com/technetwork/java/dataaccessobject-138824.html ) which i used since that. But now when i want to join the class for WebServices i thought a "Service-Layer" would be better, so i build a class like

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;

@Path("role")
public class RoleService {

@GET
@Path("ping")
@Produces(MediaType.TEXT_PLAIN)
public String helloWorld() {
    return "REST-Web-Service ready for Role.class!";
}

public static void create(Role object) {
    EntityManager em = PersistenceUtil.getEntityManagerFactory().createEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    em.persist(object);
    tx.commit();
    em.close();
}

public static void update(Role object) {
    EntityManager em = PersistenceUtil.getEntityManagerFactory().createEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    em.merge(object);
    tx.commit();
    em.close();
}

@GET
@Produces(MediaType.APPLICATION_JSON)
@Path("id/{id}")
public static Role getRole(@PathParam("id") Integer id) {
    return load(id);
}

@GET
@Produces(MediaType.APPLICATION_JSON)
@Path("name")
public static String getName(@QueryParam("id") Integer id) {
    Role role = findById(id);
    if (role != null) {
        return "[\n   {\n      \"id\":"+id+",\n      \"type\":\"role\",\n      \"name\": \"" + role.getName() + "\",\n      \"query\":\"success\"\n   }\n]";
    }
    return "[\n   {\n      \"id\":"+id+",\n      \"type\":\"role\",\n      \"query\":\"failed\"\n   }\n]";
}

public static Role findById(Integer id) {
    EntityManager em = PersistenceUtil.getEntityManagerFactory().createEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    Role object = em.find(Role.class, id);
    tx.commit();
    em.close();
    return object;
}

public static Role load(Integer id) {
    EntityManager em = PersistenceUtil.getEntityManagerFactory().createEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    Role objectResult = em.find(Role.class, id);
    tx.commit();
    em.close();
    return objectResult;
}

public static Role load(Role object) {
    EntityManager em = PersistenceUtil.getEntityManagerFactory().createEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    Role objectResult = em.find(Role.class, object.getId());
    tx.commit();
    em.close();
    return objectResult;
}

public static void deleteById(Integer id) {
    EntityManager em = PersistenceUtil.getEntityManagerFactory().createEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    em.remove(em.find(Role.class, id));
    tx.commit();
    em.close();
}

// @DELETE
// @Path("{id}")
public static void delete(Role object) {
    EntityManager em = PersistenceUtil.getEntityManagerFactory().createEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    em.remove(em.find(Object.class, object.getId()));
    tx.commit();
    em.close();
}

public static List<Role> findByName(String name) {
    EntityManager em = PersistenceUtil.getEntityManagerFactory().createEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    List<Role> list = em.createQuery("SELECT r FROM Role r WHERE r.name LIKE :name").setParameter("name", "%" + name + "%").getResultList();
    tx.commit();
    em.close();
    return list;
}

}

The PersistenceUtil is

import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class PersistenceUtil {

/*
 * Name of persistence unit which MUST correlate to persistence-unit name in persistence.xml
 */
private static final String PERSISTENCE_UNIT_NAME = "RoleModel";


private static final EntityManagerFactory entityManagerFactory;
static {
    try {
        entityManagerFactory = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME);
    } catch (Throwable ex) {
        System.err.println("EntityManagerFactory creation failed." + ex);
        throw new ExceptionInInitializerError(ex);
    }
}

public static EntityManagerFactory getEntityManagerFactory() {
    return entityManagerFactory;
}

}

But in the article Entity manager best practices it seems different. Se where should i instantiate EntityManager? Should i use better Annotation? Better a Sigleton-Class? Is it ok when i use it in every method?

What do you think?

Answer 1

I think the most common way is using CDI (context and dependency injection) in first place.

Using CDI your DAO gets the EntityManager injected by the application container (Java app server, eg Glassfish). It could look something like this:

@Dependent
public class FooDAO {

    @PersistenceContext
    private EntityManager em;

    public FooEntity find(final Number id) throws NoResultException {
        return em.find(FooEntity.class, id);
    }

    public List<FooEntity> findAll() {
        return em.createNamedQuery("FooEntity.findAll", FooEntity.class).getResultList();
    }

    // ...
}

The CDI container takes note of the @PersistenceContext annotation and the Entity Manager gets instantiated, so you don't need to worry about anything related to it. The transactions are also managed by the application server. You probably already have a persistence.xml, where you set all your DB related settings. For the server-managed persistence it needs to define transaction-type="JTA" , by the way. See the tons of examples on the web.

In your service or business logic classes (depending on how many layers you want), you would use your DAO class like this:

@Stateless
public class FooManager {

    @Inject
    private FooDAO fooDAO;


    public List<FooEntity> getFoos() {
        return fooDAO.findAll();
    }

    // ...
}

The annotations @Dependent , @Stateless are two of many CDI offers . Depending on this the CDI manager creates one or many instances of your classes. Popular choices include @ViewScoped , @SessionScoped and @ApplicationScoped . When searching the web, don't get confused by JSF's or Seam's annotations. You do not want to use those! The only thing you want to use of JSF is the @Named annotation, and you apply that one only to the backing beans (java classes which are responsible for view). EJB annotations are okay, too. They're mostly compatible with CDI.

The code and suggestions above are about Java EE. Some frameworks are using their own annotations and patterns. Most notable ones are Spring and the Play framework. For these, please refer to the fine docs.

Answer 2

No matter what Pattern you are using there is one rule that is always valid.

Create the EntityManagerFactory only onces. EntityManager can be created on each transaction as it is a cheap object.

In terms of patterns, yes DAO and Repository patterns and their variations are most common.

Answer 3

I fully agree that the CDI method is best. The inversion of control reduces the coupling but maintains cohesion of the system. You also needn't worry about allocation/deallocating the manager.

You can also have N number of persistence-unit's in your persistence.xml and you can assign the EntityManager directly to that unit. Further you can set the Context Type which I have set here as Transaction.

@PersistenceContext(unitName = PersistenceStartupService.BJOND_STORE, type=PersistenceContextType.TRANSACTION)
private EntityManager entityManager;

I encourage folks to break-up large schemas into separate persistence units which also helps with fire-walling access to certain tables. I usually have my IdentityManager (PicketLink) as a separate persistence unit.