在Tomcat上的java：comp / env之外查找JNDI名称？

Question

I am working with an application originally designed for IBM WebSphere, but I want to also host it on Tomcat. The application cannot be changed, and is doing a new InitialContext().lookup("servername") , which works on WebSphere.

But on Tomcat, when I specify <Environment> names in the application specific context xml they are prefixed with java:comp/env , and the names aren't found by the above lookup.

It will run in a container, so there's no problem to update server.xml if I have to, and of course, the application specific context xml.

How can I get Tomcat to return a string on lookup("servername") ?

Answer 1

It looks like Tomcat is hard-coded to behave in this way.

But it doesn't have to stay that way. Join the Tomcat user's mailing list and ask if there is a particular reason why things are the way they are. If there are no specific reasons to limit environment entries to the java:comp/env namespace, then I suspect a code change (probably involving a new configuration option) is definitely possible.

Answer 2

As a hack, I created this InitialContextFactory, which simply delegates the looking up of String names to System.getenv() (Environment variables). This is very insecure, and will break apps which use naming properly, so I wouldn't recommend this for Production or outside of specific use cases. Or to any one at all really.

Nevertheless, by using this, I was able to get (String) new InitialContext().lookup("servername") to return a specific value blah via set servername=blah at the command line.

import java.util.Hashtable;

import javax.naming.Binding;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.NameClassPair;
import javax.naming.NameParser;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.spi.InitialContextFactory;

public class EnvironmentInitialContextFactory implements InitialContextFactory {


    public Context getInitialContext(Hashtable<?,?> environment) throws NamingException {

        return new Context() {

            public Object lookup(String name) throws NamingException {

                return System.getenv(name);

            }

            public Object lookup(Name name) throws NamingException { return null; }
            public void bind(Name name, Object obj) throws NamingException {}
            public void bind(String name, Object obj) throws NamingException {}
            public void rebind(Name name, Object obj) throws NamingException {}
            public void rebind(String name, Object obj) throws NamingException {}
            public void unbind(Name name) throws NamingException {}
            public void unbind(String name) throws NamingException {}
            public void rename(Name oldName, Name newName) throws NamingException {}
            public void rename(String oldName, String newName) throws NamingException {}
            public NamingEnumeration<NameClassPair> list(Name name) throws NamingException { return null; }
            public NamingEnumeration<NameClassPair> list(String name) throws NamingException { return null; }
            public NamingEnumeration<Binding> listBindings(Name name) throws NamingException { return null; }
            public NamingEnumeration<Binding> listBindings(String name) throws NamingException { return null; }
            public void destroySubcontext(Name name) throws NamingException {}
            public void destroySubcontext(String name) throws NamingException {}
            public Context createSubcontext(Name name) throws NamingException { return null; }            
            public Context createSubcontext(String name) throws NamingException { return null; }
            public Object lookupLink(Name name) throws NamingException { return null; }
            public Object lookupLink(String name) throws NamingException { return null; }
            public NameParser getNameParser(Name name) throws NamingException { return null; }
            public NameParser getNameParser(String name) throws NamingException { return null; }
            public Name composeName(Name name, Name prefix) throws NamingException { return null; }
            public String composeName(String name, String prefix) throws NamingException { return null; }
            public Object addToEnvironment(String propName, Object propVal) throws NamingException { return null; }
            public Object removeFromEnvironment(String propName) throws NamingException { return null; }
            public Hashtable<?, ?> getEnvironment() throws NamingException { return null; }
            public void close() throws NamingException {}
            public String getNameInNamespace() throws NamingException { return null; }

        };

    }

}

Compile the class, and add it to the CLASSPATH and system properties, by adding these lines to setenv.bat (create in %CATALINA_HOME%/bin/ ):

set CLASSPATH=C:\path\to\compiled\class
set CATALINA_OPTS=-Djava.naming.factory.initial=EnvironmentInitialContextFactory

Answer 3

I'm revisiting this (I'm the asker). Inspired by this answer , I decided to implement a ServletContextListener instead.

In summary, you can't make Tomcat put the environment resources outside of java:comp/env/ but you can read them from there and reassign them "wherever".

When the ServletContext is initialized, my listener just rebinds them:

    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        Context ctx = new InitialContext();
        ctx.bind("servername", ctx.lookup("java:comp/env/servername"));
    }

This is a much better solution - it doesn't fiddle with anything outside of the deployment context.

It's probably also possible to just rebind all names in the comp/env/ namespace, to make a more generic listener. For now I am just binding the single names as there are few used by the app.