Examples of javax.naming.Context

javax.naming.Context
The Context interface describes a naming context comprising a collection of bindings (see javax.naming.Binding) and methods for manipulating them. This interface is extended by interfaces javax.naming.directory.DirContext and javax.naming.event.EventContext. The class javax.naming.InitialContext implements the Context interface.
Any of the methods may throw a NamingException or one of its subclasses. The specifications for those exceptions explain the circumstances in which they may be thrown.

Name parameters to context methods are each relative to the context. Name parameters cannot be null. The empty name, whether of type Name or String, is the name of the initial context. Names may be composed of multiple components; for example, in the filesystem name "usr/include/stdio.h", each of the components "usr", "include", "stdio.h" is an atomic component, but only "stdio.h" is the terminal atomic component. The example name may be used in context operations providing the intervening parent contexts for "usr" and "include" already exist. Finally, if the current context has name "usr/include", then the example name could be the result of composeName("stdio.h","usr/include").

Depending on whether a naming system supports federation, that is, names that may include components from different naming systems, name parameters to context methods may be considered differently as described below.

In systems supporting federation, String name parameters are treated as composite names. When Name parameters are not instances of CompositeName, they are deemed to be compound names (CompoundName instances or subclasses of them). Also, when using list() or listBindings() to obtain a NamingEnumeration, all names in the enumeration are string representations of composite names.

Where systems do not support federation, a service provider may treat name parameters to context methods and names found using NamingEnumeration may either as composite names or as compound names. See service provider documentation for details.

Any Name parameter specified to a context method is owned by the caller and will remain unchanged, but applications should avoid modifying these Name objects while the operation has not completed. Any Name object returned by a context operation becomes owned by the caller.

JNDI applications can provide preferences and configuration information, such as security details for authentication to a service, using JNDI environment properties. JNDI environment properties nearly all begin with "java.naming." except for provider-specific properties (explained below). All specified JNDI environment properties together comprise the context environment and methods are available for examining and manipulating that environment. The environment of a context may not necessarily contain all possible JNDI properties; for example, one or more may remain unspecified.

The set of standard JNDI environment properties is:
```
 Property name                       Value type    Notes -------------                       ----------    ----- java.naming.applet                  F java.naming.authoritative           F java.naming.batchsize               F java.naming.dns.url                 F java.naming.factory.control         C             see LdapContext java.naming.factory.initial         F java.naming.factory.object          C java.naming.factory.state           C java.naming.factory.url.pkgs        C java.naming.language                F java.naming.provider.url            F java.naming.referral                F java.naming.security.authentication F java.naming.security.credentials    F java.naming.security.principal      F java.naming.security.protocol       F 
```
For each property above marked with "C" for "concatenate", when encountered while searching sources of environment properties, values are combined into a single list separated by colons and becomes the resulting value of that property.

For each property above marked with "F" for "first occurrence", when encountered while searching sources of environment properties, the first value encountered is the resulting value of that property. In the latter case, and with additional JNDI environment properties explained further below, the type and syntax of acceptable property values should be described in the corresponding documentation for the property. In particular, a property may accept a value consisting of several pieces of relevant information, but the search order and precedence for environment properties ensures that the entire value of the first occurrence of a given property is deemed the value to be used.

Additional JNDI environment properties may be defined according to the needs of the particular service and/or service providers and a few guidelines should be followed when choosing appropriate names for them. Such additional properties comprise service-specific, feature-specific, or provider-specific properties.

Service-specific JNDI properties may be used by all service providers that offer implementations for a given service and would include the service type in the property name prefix. For example, JNDI service providers for Java RMI should name their service-specific JNDI properties using prefix "java.naming.rmi.", or LDAP service providers should use prefix "java.naming.ldap.".

Feature-specific JNDI properties may be used by all service providers offering implementations using a particular flavour of a feature and would include the feature name and the particular flavour name in the property name prefix. A common example is SASL used by several service providers for security; appropriate SASL feature-specific properties would use prefix "java.naming.security.sasl.".

Provider-specific JNDI properties are used by only a single provider though a provider may offer more than one service provider implementation. The provider should ensure uniqueness of their provider properties, for example, an LDAP service provider from mycom might use a service provider package name such as "com.mycom.jndi.ldap." as their provider-specific prefix.

JNDI environment properties can be specified in a Hashtable and passed as the environment parameter when creating an initial context.

Two other important sources of JNDI environment properties are resource files provided by applications and applet parameters (each is considered as an application resource file) and by service provider implementations (provider resource files) in the format of Java properties files - see java.util.Properties class for details.

At runtime, the application classpath and, where appropriate, the applet codebase attribute is used to locate the classes to run; when creating the first initial context, the JNDI also searches the same path for all files (application resource files) called "jndi.properties"; it is the classpath associated with the context ClassLoader (for example, the return value from Thread.getContextClassLoader() or from ClassLoader.getSystemClassLoader()) which is searched to get the resource files. Further, a path comprising the value of the "java.home" system property followed by "lib/jndi.properties" is checked for a readable file; if one exists, then that file is used as another application resource file. All application resource files found in the application classpath are examined, but JNDI properties set in a file found early will override the same properties also set in a file found later in the classpath.

Provider resource files are located according to the package prefix for the service provider's initial context factory and context implementation class in which dot separator characters are converted into slash path separator characters to construct a filepath appended with "jndiprovider.properties". Consider the example where you have a service provider which supplies a context org.apache.harmony.jndi.example.exampleCtx. In this case the package prefix is org.apache.harmony.jndi.example. Substituting slash chars for dots & appending "jndiprovider.properties" gives you org/apache/harmony/jndi/example/jndiprovider.properties.

An important part of service provider implementation is to specify certain standard JNDI properties that are using to locate any of the various factory classes needed for the implementation; these are:
```
 java.naming.factory.control java.naming.factory.object java.naming.factory.state java.naming.factory.url.pkgs - package prefixes used for URL contexts 
```
When searching for the above 4 properties only provider resource files should be examined. Although other properties may be specified in them for use by the service provider implementation, the JNDI ignores properties from these files other than those related to factories.

It should be noted that a provider resource file's properties differ from those in application resource files in that their values are not incorporated into the environment. Instead, they are read when the following methods are invoked with Context and Hashtable parameters:
```
 ControlFactory.getControlInstance    - uses java.naming.factory.control DirectoryManager.getObjectInstance   - uses java.naming.factory.object DirectoryManager.getStateToBind      - uses java.naming.factory.state NamingManager.getObjectInstance      - uses java.naming.factory.object NamingManager.getStateToBind         - uses java.naming.factory.state 
```
These methods use their Hashtable parameter to get the environment properties. Then they use the class loader of the Context parameter to look for the provider resource file. If the file is found, then the value of the required property is appended to the value of the required property in the environment. Note that it is appended for use by this method but the environment itself is unaffected.

The jndiprovider.properties files may specify additional properties, but documentation for the service provider should clearly describe which properties are valid in this file and under what circumstances.

To summarize the search order and precedence for JNDI environment properties, the earliest having highest precedence:
```
 1. environment parameter used to initialize an initial context, 2. applet parameters, (only used if that environment param does not exist) 3. system properties, (only used if that environment and applet parameter  do not exist) 4. application resource files. 
```
It should be noted that in the case of applet parameters and system properties only a subset of the properties are read. These are the following 7:
```
 java.naming.dns.url java.naming.factory.control java.naming.factory.initial java.naming.factory.object java.naming.factory.state java.naming.factory.url.pkgs java.naming.provider.url 
```
For a JNDI property found in more than one of those sources, if it is one of the JNDI factory list properties then values are joined into a colon-separated list, otherwise the first instance of a property defines the value to be used.

The above search order and precedence applies when creating contexts for any class implementing the Context interface.

Although a subcontext inherits the environment of its parent context, subsequent changes to either's environment has no direct effect on the other. However, applications should avoid dependency on when JNDI properties are used or verified as this depends on the service provider implementation. As the environment of a context can be examined by any object that has a reference to the context, care should be taken to assess the risk to any security details stored in the environment.

Multithreaded access to a single Context instance is only safe when client code uses appropriate synchronization and locking.

When a NamingEnumeration is returned by a Context method, the operation should not be considered complete, for concurrency purposes, if the NamingEnumeration is still being used or if any referrals are still being followed resulting from that operation.

        List<RARDeployable> rars = earDeployable.getRARDeployables();
        if (rars.size() > 0) {
            if (this.rarService == null) {
                logger.warn("There are RAR files in the EAR ''{0}'' but the resource service is not available", earDeployable);
            } else {
                Context ctx = new ContextImpl(earURL.toExternalForm());
                try {
                    ctx.rebind("earUrl", earURL);
                } catch (NamingException e) {
                    throw new DeployerException("Cannot add the EAR URL parameter '" + earURL + "'", e);
                }
                List<URL> urls = new ArrayList<URL>();
                for (RARDeployable rarDeployable : rars) {
                    try {
                        urls.add(rarDeployable.getArchive().getURL());
                    } catch (ArchiveException e) {
                        throw new DeployerException("Cannot get the URL for the archive '" + rarDeployable.getArchive() + "'",
                                e);
                    }
                }
                try {
                    ctx.rebind("urls", urls.toArray(new URL[urls.size()]));
                } catch (NamingException e) {
                    throw new DeployerException("Cannot add the urls parameter '" + urls + "'", e);
                }
                try {
                    ctx.rebind("earClassLoader", earClassLoader);
                } catch (NamingException e) {
                    throw new DeployerException("Cannot add the earClassLoader parameter '" + earClassLoader + "'", e);
                }
                try {
                    ctx.rebind("altDDs", new URL[urls.size()]);
                } catch (NamingException e) {
                    throw new DeployerException("Cannot add the altDDs parameter.'", e);
                }


                try {

View Full Code Here

                    }
                }




                // Deploy EJB 2.1 on JOnAS service
                Context ctx = new ContextImpl(earURL.toExternalForm());
                try {
                    ctx.rebind("earUrl", earURL);
                    ctx.rebind("earRootUrl", earURL);
                } catch (NamingException e) {
                    throw new DeployerException("Cannot add the EAR URL parameter '" + earURL + "'", e);
                }


                try {
                    ctx.rebind("jarURLs", urls.toArray(new URL[urls.size()]));
                } catch (NamingException e) {
                    throw new DeployerException("Cannot add the urls parameter '" + urls + "'", e);
                }
                try {
                    ctx.rebind("earClassLoader", earClassLoader);
                } catch (NamingException e) {
                    throw new DeployerException("Cannot add the earClassLoader parameter '" + earClassLoader + "'", e);
                }


                // Bind the EJB classloader
                try {
                    ctx.rebind("ejbClassLoader", ejbClassLoader);
                } catch (NamingException e) {
                    throw new DeployerException("Cannot add the ejbClassLoader parameter '" + ejbClassLoader + "'", e);
                }


                // Role names
                try {
                    ctx.rebind("roleNames", new String[0]);
                } catch (NamingException e) {
                    throw new DeployerException("Cannot add the altDDs parameter.'", e);
                }


                try {

View Full Code Here

     */
    public void handle(final IEvent event) {


        JavaContextNamingEvent cne = (JavaContextNamingEvent) event;
        Factory<?, ?> easyBeansFactory = cne.getFactory();
        Context javaCtx = cne.getJavaContext();
        Context compCtx = null;
        try {
            compCtx = (Context) javaCtx.lookup("comp");
        } catch (NamingException e) {
            throwException(cne, new IllegalStateException("Cannot get java:comp object", e));
        }


        // Unbind UserTransaction context if it is not a BMT bean
        // as specified in chapter 16.12 of EJB 3 spec.
        if (easyBeansFactory.getBeanInfo().getTransactionManagementType() == CONTAINER) {
            logger.debug("Bean is container managed so remove availability of java:comp/UserTransaction object");
            try {
                compCtx.unbind("UserTransaction");
            } catch (NamingException e) {
                throwException(cne, new IllegalStateException("Cannot remove java:comp/UserTransaction object", e));
            }
        }


        // bind EJBContext
        EasyBeansEJBContext<?> context = null;
        if (easyBeansFactory instanceof StatelessSessionFactory) {
            context = new EasyBeansSessionContext<StatelessSessionFactory>((StatelessSessionFactory) easyBeansFactory);
        } else if (easyBeansFactory instanceof StatefulSessionFactory) {
            context = new EasyBeansSessionContext<StatefulSessionFactory>((StatefulSessionFactory) easyBeansFactory);
        } else if (easyBeansFactory instanceof SingletonSessionFactory) {
                context = new EasyBeansSessionContext<SingletonSessionFactory>((SingletonSessionFactory) easyBeansFactory);
        } else if (easyBeansFactory instanceof MDBFactory) {
            context = new EasyBeansMessageDrivenContext((MDBFactory) easyBeansFactory);
        } else {
            throwException(cne, new IllegalStateException("Unable to detect factory type '" + easyBeansFactory + "'"));
        }




        try {
            compCtx.bind("EJBContext", context);
        } catch (NamingException e) {
            throwException(cne, new IllegalStateException("Cannot bind EJBContext", e));
        }


        // bind TimerService
        try {
            compCtx.bind("TimerService", context.getTimerService());
        } catch (NamingException e) {
            throwException(cne, new IllegalStateException("Cannot bind TimerService", e));
        }
    }

View Full Code Here

            // Sets writable mode
            ContextAccessController.setSecurityToken(getName(), this.container);
            ContextAccessController.setWritable(getName(), this.container);


            // Gets the java:comp/env context
            Context context = getNamingContext();
            Context envCtx;
            try {
                envCtx = (Context) context.lookup("comp/env");
            } catch (NamingException e) {
                throw new IllegalStateException("Unable to get comp/env subcontext", e);
            }


            // Needs to bind object


            // Persistence context
            EZBPersistenceUnitManager persistenceUnitManager = this.injectionHolder.getPersistenceUnitManager();
            for (IENCBinding<IJavaxPersistenceContext> binding : this.encBindingHolder.getPersistenceContextBindings()) {
                String encName = binding.getName();
                String unitName = binding.getValue().getUnitName();
                PersistenceContextType type = binding.getValue().getType();
                EntityManager em = persistenceUnitManager.getEntityManager(unitName, type);


                try {
                    createSubcontexts(envCtx, encName);
                    envCtx.rebind(encName, em);
                    if (this.logger.isDebugEnabled()) {
                        this.logger.debug("Adding persistence-context 'java:comp/env/" + encName + "'");
                    }
                } catch (NamingException e) {
                    this.logger.error("Unable to bind persistence-context in ENC", e);
                }
            }


            // Persistence unit
            for (IENCBinding<IJavaxPersistenceUnit> binding : this.encBindingHolder.getPersistenceUnitBindings()) {
                String encName = binding.getName();
                String unitName = binding.getValue().getUnitName();
                EntityManagerFactory emf = persistenceUnitManager.getEntityManagerFactory(unitName);


                try {
                    createSubcontexts(envCtx, encName);
                    envCtx.rebind(encName, emf);
                    if (this.logger.isDebugEnabled()) {
                        this.logger.debug("Adding persistence-unit 'java:comp/env/" + encName + "'");
                    }
                } catch (NamingException e) {
                    this.logger.error("Unable to bind persistence-unit in ENC", e);
                }
            }


            // EJBs
            EZBJNDIResolver jndiResolver = this.injectionHolder.getJNDIResolver();
            if (jndiResolver != null) {
                for (IENCBinding<IJEjbEJB> binding : this.encBindingHolder.getEJBBindings()) {
                    String encName = binding.getName();
                    IJEjbEJB jEjbEJB = binding.getValue();
                    String interfaceName = jEjbEJB.getBeanInterface();
                    String beanName = jEjbEJB.getBeanName();


                    String jndiName;
                    try {
                        jndiName = jndiResolver.getEJBJNDIUniqueName(interfaceName, beanName);


                        // Bind a link to this JNDI name
                        try {
                            createSubcontexts(envCtx, encName);
                            envCtx.rebind(encName, new LinkRef(jndiName));
                            if (this.logger.isDebugEnabled()) {
                                this.logger.debug("Adding ejb 'java:comp/env/" + encName + "' from JNDIName '" + jndiName
                                        + "'.");
                            }
                        } catch (NamingException e) {

View Full Code Here

    public void handle(final IEvent event) {


        JavaContextNamingEvent javaContextNamingEvent = (JavaContextNamingEvent) event;
        String beanName = javaContextNamingEvent.getFactory().getBeanInfo().getName();


        Context javaContext = javaContextNamingEvent.getJavaContext();
        Context javaCompEnvCtx = null;
        try {
            javaCompEnvCtx = (Context) javaContext.lookup("comp/env");
        } catch (NamingException e) {
            throwException(javaContextNamingEvent, new IllegalStateException("Cannot lookup java:comp/env element.", e));
        }


        Context javaModuleCtx = null;
        try {
            javaModuleCtx = (Context) javaContext.lookup("module");
        } catch (NamingException e) {
            throwException(javaContextNamingEvent, new IllegalStateException("Cannot lookup java:module element.", e));
        }


        Context javaAppCtx = null;
        try {
            javaAppCtx = (Context) javaContext.lookup("app");
        } catch (NamingException e) {
            throwException(javaContextNamingEvent, new IllegalStateException("Cannot lookup java:app element.", e));
        }


        Context javaGlobalCtx = null;
        try {
            javaGlobalCtx = (Context) javaContext.lookup("app");
        } catch (NamingException e) {
            throwException(javaContextNamingEvent, new IllegalStateException("Cannot lookup java:app element.", e));
        }


        for (IEnvEntry envEntry : javaContextNamingEvent.getBeanMetadata().getEnvEntryCollection()) {
            String name = envEntry.getName();
            Object value = getEnvEntryValue(envEntry, javaContextNamingEvent);
            // if null, no entry in java:comp/env as specified chapter 15.4.1
            if (value != null) {


                Context bindContext = javaCompEnvCtx;


                // if name starts with "java:" locates the correct namespace
                if (name != null && name.startsWith("java:")) {


                    // check authorized context
                    if (name.startsWith("java:module/")) {
                        bindContext = javaModuleCtx;
                        name = name.substring("java:module/".length());
                    } else if (name.startsWith("java:app/")) {
                        bindContext = javaAppCtx;
                        name = name.substring("java:app/".length());
                    } else if (name.startsWith("java:global/")) {
                        bindContext = javaGlobalCtx;
                        name = name.substring("java:global/".length());
                    } else if (name.startsWith("java:comp/")) {
                        bindContext = javaCompEnvCtx;
                        name = name.substring("java:comp/".length());
                    } else {
                        throwException(javaContextNamingEvent, new IllegalStateException("Invalid Env Entry name '" + name
                                + "' for bean '" + beanName + "'."));
                    }


                }


                try {
                    bindContext.rebind(name, value);
                } catch (NamingException e) {
                    throwException(javaContextNamingEvent, new IllegalStateException("Cannot bind element '" + name
                            + "' for bean '" + beanName + "'.", e));
                }
            }

View Full Code Here


        // Create a new environment
        ContextImpl ctx = new ContextImpl(namespace, true, null);


        // Create subContext
        Context compCtx = (Context) ctx.lookup("comp");


        // Bind java:comp/UserTransaction
        if (this.userTransaction == null) {
            try {
                this.userTransaction = (UserTransaction) this.ictx.lookup("javax.transaction.UserTransaction");
            } catch (NamingException e) {
                logger.error("Cannot lookup UserTransaction.", e);
            }
        }
        if (this.userTransaction != null) {
            compCtx.rebind("UserTransaction", this.userTransaction);
        }


        // bind ORB
        try {
            compCtx.rebind("ORB", ORBInitHelper.getORB());
        } catch (NamingException e) {
            logger.error("Cannot bind ORB", e);
        }


        return ctx;

View Full Code Here

     * @return Context the component context.
     * @throws NamingException When operation is not allowed
     */
    public Context getComponentContext() throws NamingException {


        Context ctx = null;


        // Check if there is a context to the local thread
        // For ejbs
        ctx = threadContext.get();
        if (ctx != null) {

View Full Code Here

     * After, resetComponentContext should be called to reset the context.
     * @param ctx the context to associate to the current thread.
     * @return Context the context of the thread
     */
    public Context setComponentContext(final Context ctx) {
        Context ret = threadContext.get();
        threadContext.set(ctx);
        return ret;
    }

View Full Code Here

     * Main method.
     * @param args the arguments (not required)
     * @throws Exception if exception is found.
     */
    public static void main(final String[] args) throws Exception {
        Context initialContext = getInitialContext();


        TimerBeanRemote timerBean = (TimerBeanRemote) initialContext.lookup("timerBean");


        System.out.println("Calling init method that will fire a new timer...");
        timerBean.init();
    }

View Full Code Here

     * @throws Exception needs for signature of interceptor.
     */
    @Override
    public Object intercept(final EasyBeansInvocationContext invocationContext) throws Exception {
        // Get the subcontext (comp)
        Context oldContext = (Context) setComponentContextMethod.invoke(null, invocationContext
                .getFactory().getJavaContext().lookup("comp"));
        try {
            return invocationContext.proceed();
        } finally {
            resetComponentContextMethod.invoke(null, oldContext);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of javax.naming.Context

ch.inftec.ju.ee.client.ServiceLocatorBuilder$RemoteServiceLocatorBuilder

com.sun.faces.config.WebConfiguration

com.vaadin.data.util.sqlcontainer.connection.J2EEConnectionPoolTest

connector.TestServlet

org.apache.aries.jndi.url.ServiceRegistryContextTest

org.apache.cxf.systest.jaxrs.JAXRSJmsTest

org.apache.geronimo.console.jndiview.JNDIViewHelper

org.apache.geronimo.gjndi.JavaCompContextTest

org.apache.geronimo.naming.deployment.EnvironmentEntryBuilderTest

org.apache.geronimo.openejb.OpenEjbSystemGBean

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.