Question

I have deployed an enterprise app in an EAR and a standalone web app in WAR (out side of the EAR) to the same Java EE server.

Question is can I access the local interface of the session bean in the EAR from the standalone WAR? if so can I use dependency injection (DI)?

Answer 1

The answer anyway to both your questions is yes.

Since both the ear and war are in the same JVM, a local interface can be used. To get an instance of the session bean, you would use the global JNDI name of said bean to do either a JNDI lookup or use with the mappedName property on the @EJB annotation. Those names are standardized via the following pattern:

java:global[/<app-name>]/<module-name>/<bean-name>[!<fully-qualified-interface-name>]

Lookup would thus be if the name of your ear is my_app, your bean is MyBean.java and its local interface is com.foo.SomeBeanLocal:

InitialContext ctx = InitialContext();
SomeBeanLocal someBean = (SomeBeanLocal) ctx.lookup("java:global/my_ear/SomeBean/com.foo.SomeBeanLocal");

Injection would be:

public SomeManagedClass {

    @EJB(mappedName="java:global/my_ear/SomeBean/com.foo.SomeBeanLocal")
    SomeBeanLocal someBean;
}

There are two catches however:

Non-standard naming

Older Java EE implementations (e.g. JBoss AS 5.1, Glassfish 2, Websphere) used their own naming pattern. E.g. JBoss AS 5.x would use:

<app-name>/<bean-name>/local|global

E.g. with the same names as the previous example, the global JNDI name of that bean in JBoss AS 5.1 would be:

my_app/MyBean/local

As said, other old application servers might use other names.

Startup-order

Especially with injection you have to assure somehow that the application you want to inject from has been started before the application you want to inject into. I.e. in your case that the EAR has been started before the standalone WAR. There are no standard mechanisms for this. You might be just lucky that it happens to be in the right order for you. This order might be influenced by time-stamps, alphabetical order of application names, or something else entirely.

JBoss AS for example uses <depends> tags in many of its proprietary configuration files, which is perfectly suited for this although it can be hard to find out what exactly you need to depend on (the syntax can be very cryptic).