Java Doc for InitialContext.java in  » 6.0-JDK-Core » naming » javax » naming » Java Source Code / Java DocumentationJava Source Code and Java Documentation

All naming operations are relative to a context. The initial context implements the Context interface and provides the starting point for resolution of names.

When the initial context is constructed, its environment is initialized with properties defined in the environment parameter passed to the constructor, and in any application resource files. In addition, a small number of standard JNDI properties may be specified as system properties or as applet parameters (through the use of Context.APPLET ). These special properties are listed in the field detail sections of the Context and LdapContext interface documentation.

JNDI determines each property's value by merging the values from the following two sources, in order:

1. The first occurrence of the property from the constructor's environment parameter and (for appropriate properties) the applet parameters and system properties.
2. The application resource files (jndi.properties).

The initial context implementation is determined at runtime. The default policy uses the environment property " Context.INITIAL_CONTEXT_FACTORY java.naming.factory.initial ", which contains the class name of the initial context factory. An exception to this policy is made when resolving URL strings, as described below.

When a URL string (a String of the form scheme_id:rest_of_name) is passed as a name parameter to any method, a URL context factory for handling that scheme is located and used to resolve the URL. If no such factory is found, the initial context specified by "java.naming.factory.initial" is used. Similarly, when a CompositeName object whose first component is a URL string is passed as a name parameter to any method, a URL context factory is located and used to resolve the first name component. See NamingManager.getURLContextNamingManager.getURLContext() for a description of how URL context factories are located.

This default policy of locating the initial context and URL context factories may be overridden by calling NamingManager.setInitialContextFactoryBuilder().

NoInitialContextException is thrown when an initial context cannot be instantiated. This exception can be thrown during any interaction with the InitialContext, not only when the InitialContext is constructed. For example, the implementation of the initial context might lazily retrieve the context only when actual methods are invoked on it. The application should not have any dependency on when the existence of an initial context is determined.

When the environment property "java.naming.factory.initial" is non-null, the InitialContext constructor will attempt to create the initial context specified therein. At that time, the initial context factory involved might throw an exception if a problem is encountered. However, it is provider implementation-dependent when it verifies and indicates to the users of the initial context any environment property- or connection- related problems. It can do so lazily--delaying until an operation is performed on the context, or eagerly, at the time the context is constructed.

An InitialContext instance is not synchronized against concurrent access by multiple threads. Multiple threads each manipulating a different InitialContext instance need not synchronize. Threads that need to access a single InitialContext instance concurrently should synchronize amongst themselves and provide the necessary locking.
author:
   Rosanna Lee
author:
   Scott Seligman
version:
   1.21 07/05/05
See Also:   Context
See Also:   NamingManager.setInitialContextFactoryBuilder
See Also:   NamingManager.setInitialContextFactoryBuilder
since:
   JNDI 1.1 / Java 2 Platform, Standard Edition, v 1.3

This method will modify environment and save a reference to it.

This constructor will not modify environment or save a reference to it, but may save a clone.
Parameters:
  environment - environment used to create the initial context.Null indicates an empty environment.
throws:
  NamingException - if a naming exception is encountered

InitialContext ic = new InitialContext(); Object obj = ic.lookup();

If name is empty, returns a new instance of this context (which represents the same naming context as this context, but its environment may be modified independently and it may be accessed concurrently).
Parameters:
  name - the name of the object to look up the object bound to name
throws:
  NamingException - if a naming exception is encountered
See Also:   InitialContext.doLookup(String)
See Also:   InitialContext.lookup(Name)
since:
   1.6

See getURLOrDefaultInitCtx(Name) for description of how a subclass should use this method.
Parameters:
  name - The non-null name for which to get the context. A URL context for name or the cached initial context. The result cannot be null.
exception:
  NoInitialContextException - If cannot find an initial context.
exception:
  NamingException - In a naming exception is encountered.
See Also:   javax.naming.spi.NamingManager.getURLContext

When creating a subclass of InitialContext, use this method as follows. Define a new method that uses this method to get an initial context of the desired subclass.

 protected XXXContext getURLOrDefaultInitXXXCtx(Name name) 
 throws NamingException {
 Context answer = getURLOrDefaultInitCtx(name);
 if (!(answer instanceof XXXContext)) {
 if (answer == null) {
 throw new NoInitialContextException();
 } else {
 throw new NotContextException("Not an XXXContext");
 }
 }
 return (XXXContext)answer;
 }
 

 public Object XXXMethod1(Name name, ...) {
 throws NamingException {
 return getURLOrDefaultInitXXXCtx(name).XXXMethod1(name, ...);
 }
 

This method will modify environment and save a reference to it. The caller may no longer modify it.
Parameters:
  environment - environment used to create the initial context.Null indicates an empty environment.
throws:
  NamingException - if a naming exception is encountered
See Also:   InitialContext.InitialContext(boolean)
since:
   1.3