CDI：在“注入链”中生成正确的EntityManager的好方法

Question

I have a number of servlets that I'm rewriting from using PersistenceContext to using @Injected DAOs.

In JSF I could grab a reference to the FacesContext in my @Produces method and return the correct EM based on the logged in user (or use a default if logged in, valid user was available).

How do I do this in a clean way when I have to produce different EMs for the same DAOs that are injected into different servlets and where the EM to be injected is dependent on the Servlet who started the "injection chain"?

Expected outcome:

  Servlet 1                 DaoA                   EntityM. x
+-----------+            +-----------+            +-----------+
| @Inject   | Inject into|  @Inject  | Inject into|           |
| DaoA daoA <-----+------+  E.M. em  <------------+           |
| etc       |     |      |  //em x   |            |           |
+-----------+     |      +-----------+            +-----------+
                  |         DaoB                   EntityM. x
                  |      +-----------+            +-----------+
                  |      |  @Inject  | Inject into|           |
                  +------+  E.M. em  <------------+           |
                         |  //em x   |            |           |
                         +-----------+            +-----------+

  Servlet 2                 DaoA                   EntityM. y
+-----------+            +-----------+            +-----------+
| @Inject   | Inject into|  @Inject  | Inject into|           |
| DaoA daoA <------------+  E.M. em  <------------+           |
|           |            |  //em y   |            |           |
+-----------+            +-----------+            +-----------+

Edit:

I technically can get away with something like this I think but it is a huge mess when the DAOs are used otherwise as well and there are number of servlets to upgrade:

//In Servlet 1
@PersistenceContext(unitName="x")
EntityManager em;

@Inject
DaoA daoA;

@Inject
DaoB daoB;

@Postconstruct
public void postConstruct() {
  daoA.setEm(em);
  daoB.setEm(em);
}

//In Servlet 2
@PersistenceContext(unitName="y")
EntityManage r em;

@Inject
DaoA daoA;

@Postconstruct
public void postConstruct() {
  daoA.setEm(em);
}

Answer 1

I assume that when you want to decide in servlet, your DAOs are supposed to use the same entity manager through whole request, as requests start and end in a servlet. In other words, while serving a http request, only one entity manager should be used.

In this case, you may use built-in request scope and CDI event mechanism . Create a producer for EM, which is request scoped, so that it is recreated each time with a new request. Then you may fire an event with particular entityManager as parameter, which is observed by your producer. When the event is received by the producer, it will store the EM and return it as produced value.

Schema of execution:

1. appropriate EntityManager em is injected into servlet
2. A CDI event emEvent is injected into the servlet
3. either in @PostConstruct or at the beginning of serving method, fire the event by emEvent.fire(em)
4. EM producer with request scope observes events of type EntityManager, when received, stores the em
5. all DAOs simply require injection of EntityManager
   • producer returns stored instance EntityManager , received in the observed event
6. remember , that you must inject DAOs only after the event is fired, therefore all dependencies of the servlet, that rely on DAOs, must be injected dynamically using Instance , or must have a proxying scope (eg @RequestScoped , @SessionScoped ). Otherwise the producer for the entity manager will be called before any event is received. But I believe that this also applies to your simple solution in your question.

Code example:

//In Servlet 1
@PersistenceContext(unitName="x")
EntityManager em;

@Inject
Event<EntityManager> emEvent;

@Inject
Instance<DaoA> daoAInstance;

@Postconstruct
public void postConstruct() {
  emEvent.fire(em);
  daoAInstance.get().find(...);  /* at this point, proper EM will be injected into DaoA. 
                 You should access daoA only after emEvent is fired*/
}

---

// in producer
@RequestScoped (producer will be recreated for every request)
public class DynamicEMProducer {

  EntityManager em; /* not injected, but set in observer method. 
        You may inject a default em if you wish using @PersistenceContext */

  // this is handler of event fired in the servlet
  public void emChanged(@Observes EntityManager em) {
    this.em = em;
  }

  @Produces
  public EntityManager produce() {
    return em;
  }
}