Enterprise bean environment-declare simple env entry using annotation

[Amr Ouda]

Dears,
Per specs , "Bean provider may use java language annotations or deployment descriptor to declare entries that are needed in the naming context"

I tried to use DD for creating a simple env entry, and the container created the env entry in the JNDI context ["java:comp/env/trialNumber"]

However when i removed the entry from the DD, used the bean code only to declare the env entry using @resource annotation ,and tried to get the env entry via JNDI lookup ...it didn't work.

Is @Resource used only to inject in target ref (without creating entries in JNDI context)
Or it can be used to create entries in JNDI context?


Working DD example :

 <enterprise-beans>
        <session>  
            <ejb-name>NewSessionBean</ejb-name>  
            <ejb-class>com.NewSessionBean</ejb-class>  
            <session-type>Stateless</session-type>  
            <env-entry>  
                <env-entry-name>trialNumber</env-entry-name>  
                <env-entry-type>java.lang.String</env-entry-type>  
                <env-entry-value>Small</env-entry-value>  
            </env-entry>  
 
        </session>  
    </enterprise-beans>

@Stateless
public class NewSessionBean implements NewSessionBeanLocal {
@Resource
  SessionContext context;
  //   @Resource
    String trialNumber="XX";
    @Override
    public void play() {
        try {
              System.out.println(trialNumber);
            InitialContext ic=new InitialContext();
           Object o= ic.lookup("java:comp/env/trialNumber");
          System.out.println(o);
        } catch (NamingException ex) {
            Logger.getLogger(NewSessionBean.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

This is the code that doesn't get any object (after removing entries from DD)

 @Resource
    String trialNumber="XX";
  public void play() {
        try {
              System.out.println(trialNumber);
            InitialContext ic=new InitialContext();
//the below two JNDI lookups do not get any thing from JNDI context
          Object o= ic.lookup("java:comp/env/com.NewSessionBean/trialNumber");
     //    Object o= ic.lookup("java:comp/env/trialNumber");
          System.out.println(o);
        } catch (NamingException ex) {
            Logger.getLogger(NewSessionBean.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

[Himai Minh]

I guess java:comp/env is for the environment entries (String, Integer, Double....) defined in the DD or a bean via lookup method and SessionContext annotated with @Resource.
On Frits's notes, there is an example to inject a bean echo:

//For injecting a bean 
package n1.notes.ejb;
  public class InjectedBean{

     EchoBeanRemote echo;
    @Resource SessionContext context;

    public string getInjectedBean(String phrase){
            EchoBeanRemote g = (EchoBeanRemote) context.lookup("java:comp/env/n1.notes.ejb.InjectedBean/echo");
              ....

    }
 }

I guess injecting a field (eg. integer, String) won't work with @Resource and lookup without the environment entry defined in DD.
If you want to inject a field (eg integer) , you have to do the following just like Frits' example on p.70:

   @Stateless
   public class EchoBean implements EchoBeanRemote{

               @Resource (name="initNumber"
                  Integer init;
    }

The corresponding DD should have :

     <env-entry>
                     <env-entry>initNumber</env-entry-name>
                       ......
                        <env-entry>10</env-entry> 
                           .....
      <env-entry>

[Amr Ouda]

That's why i didn't get the object in the context tree.
Thanks Himai ,

[Frits Walraven]

Hi Amr Ouda,

Great question!

You are right it is a bit confusing in the EJB specs:

The environment entries are declared by the Bean Provider by means of annotations on the bean class or in the deployment descriptor.

This only declares the environment entry, but it doesn't say anything about the registration in the ENC.

There is a small sentence later on in the specs:

The env-entry-value element in the deployment descriptor is optional when an injection target is specified. If the element is not specified, no value will be injected. In addition, if the element is not specified, the named resource is not initialized in the naming context, and explicit lookups of the named resource will fail.

So the conclusion for simple environment entries is: The resource is only registered in the naming context if the env-entry is declared with a env-entry-value in the deployment descriptor.

You can easily list the Naming Context (ENC) entries inside your EJB method with this code snippet:

...
@Override  
public void play() {  
     Context context = (Context) new InitialContext().lookup("java:comp/env");
     listContext(context); 
}

private void listContext(Context ctx) {
  try {
         System.out.println("listContext");
         NamingEnumeration list = ctx.listBindings("");
         while (list.hasMore()) {
            Binding item = (Binding) list.next();
            System.out.println("--" + item.getName() + " -> " + item.getClassName());
            Object o = item.getObject();
            if (o instanceof javax.naming.Context) {
                listContext((Context) o);
            }
         }
    } catch (NamingException ex) {
         System.out.println("JNDI failure: ");
         ex.printStackTrace();
    }
    System.out.println("end listContext");
}

Regards,
Frits

[Charles O'Leary]

Hi Ranchers,

Given that the original code (or any similar) was not described as failing and with container implementations and (any partial or full) deployment descriptor aside , can (or perhaps more appropriately how) @Resource be used to declare (and/or create) entries in the JNDI context without need for any deployment descriptor entries (whether simple environmental entries or not)? (Are environmental entries somehow exceptional? And/or where does the spec "single out" simple annotation-based only environmental entries?)


Background:

Annotations and Deployment Descriptors
....
Environment entries may be declared by the use of annotations, without need for any deployment
descriptor entries. Environment entries may also be declared by deployment descriptor entries, without
need for any annotations.

Annotation of Instance Variables

The developer may annotate instance variables of the enterprise bean class to indicate dependencies

upon resources or other objects in the bean’s environment. The container automatically initializes these

annotated variables with the external references to the specified environment objects. This initialization

occurs before any business methods are invoked on the bean instance and after the time the the bean’s

EJBContext is set.

...
Examples

@EJB public ShoppingCart myShoppingCart;

@Resource public DataSource myDB;

@Resource public UserTransaction utx;

@Resource SessionContext ctx;