EJB3 - obtaining bean via injection vs lookup - what are the differences, implications, gotchas?

Question

There are two ways I know of to obtain an EJB instance:

• dependency injection in servlets and EJBs via the @EJB annotation
• JNDI lookup via Context.lookup anywhere

What are the differences, implications and gotchas in using either of these approaches? Are they the same? Is dependency injection faster than lookup? What about transaction handling and object lifecycle management?

Things I'm aware of include:

annotation

• works with servlets and and EJBs only
• convenient syntax
• container independent

lookup

• can instantiate different implementations of the EJB interface programatically at run time.
• works from anywhere - e.g. POJOs.
• depends on naming convention of container

Clisthenes

Answer 1

Both achieve the same result. It's more a matter of coupling. With annotation, you achieve loose coupling and it's easier to mock and test. With direct lookup, you depend on the initial context which may be unconvenient sometimes.

IMHO lookup does not work everywhere. For instance in Glassfish, a lookup on a local EJB from a POJO will work only if has been "imported" previously with @EJBs(...) on one of the session beans that uses the POJO. See this discussion. You need to understand the difference between the local and global JNDI for that.

My advice would be: use annotation as much as possible. If a POJO need a reference to an EJB, pass it as parameter (e.g. in the constructor). That's called dependency inversion and is anyway a good practice.

Perfectible

Answer 2

Lookup depends on presence of JNDI implementation, that is, you have to configure JNDI implementation in order to run unit tests, then annotated fields can be configured manually.

Coats

Answer 3

I think it's kind a hard to mock annotated EJBs. When using lookup you are able to build some switch according to your environment (test -> LoginMockBean, production -> LoginBean).

Eristic

That's just wrong. If it's injected by the container, it means you can easier inject it yourself in the tests, e.g MyBean bean = new MyBean(); bean.injectedBean = new Mock(). Hooking in the lookup is more complicated, especially if code depends on new InitialContext(). How do you return a special version of the context for your tests? – Perfectible