import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * Bind current thread, both for CL purposes and for JNDI ENC support
 * during : startup, shutdown and realoading of the context.
 *
 * @return the previous context class loader
 */
private ClassLoader bindThread() {

    ClassLoader oldContextClassLoader =
        Thread.currentThread().getContextClassLoader();

    if (getResources() == null)
        return oldContextClassLoader;

    Thread.currentThread().setContextClassLoader
        (getLoader().getClassLoader());

    DirContextURLStreamHandler.bind(getResources());

    if (isUseNaming()) {
        try {
            ContextBindings.bindThread(this, this);
        } catch (NamingException e) {
            // Silent catch, as this is a normal case during the early
            // startup stages
        }
    }

    return oldContextClassLoader;

}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * Bind current thread, both for CL purposes and for JNDI ENC support during
 * : startup, shutdown and realoading of the context.
 *
 * @return the previous context class loader
 */
protected ClassLoader bindThread() {

	ClassLoader oldContextClassLoader = Thread.currentThread().getContextClassLoader();

	if (getResources() == null)
		return oldContextClassLoader;

	if (getLoader() != null && getLoader().getClassLoader() != null) {
		Thread.currentThread().setContextClassLoader(getLoader().getClassLoader());
	}

	DirContextURLStreamHandler.bindThread(getResources());

	if (isUseNaming()) {
		try {
			ContextBindings.bindThread(this, this);
		} catch (NamingException e) {
			// Silent catch, as this is a normal case during the early
			// startup stages
		}
	}

	return oldContextClassLoader;

}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * Open the specified database connection.
 *
 * @return Connection to the database
 */
protected Connection open() {

    try {
        Context context = null;
        if (localDataSource) {
            context = ContextBindings.getClassLoader();
            context = (Context) context.lookup("comp/env");
        } else {
            context = getServer().getGlobalNamingContext();
        }
        DataSource dataSource = (DataSource)context.lookup(dataSourceName);
    return dataSource.getConnection();
    } catch (Exception e) {
        // Log the problem for posterity
        containerLog.error(sm.getString("dataSourceRealm.exception"), e);
    }  
    return null;
}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
public synchronized DataSource lookupDataSource(final Context context, String resourceName) throws NamingException {
    if (context != null) {
        ContextBindings.bindClassLoader(context, null, Thread.currentThread().getContextClassLoader());
    }
    try {
        String jndiName = resolveJndiName(resourceName, (context == null));
        Object o = new InitialContext().lookup(jndiName);

        if (o instanceof DataSource) {
            return (DataSource) o;
        } else {
            return null;
        }
    } finally {
        if (context != null) {
            ContextBindings.unbindClassLoader(context, null, Thread.currentThread().getContextClassLoader());
        }
    }
}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public void contextEntered(final ThreadContext oldContext, final ThreadContext newContext) {
    // save off the old context if possible
    try {
        final Data data = new Data(getThreadName());
        newContext.set(Data.class, data);
    } catch (final NamingException ignored) {
        // no-op
    }

    // set the new context
    try {
        ContextBindings.bindThread(OPENEJB_CONTEXT, null);
    } catch (final NamingException e) {
        ContextBindings.unbindContext(OPENEJB_CONTEXT, null);
        throw new IllegalArgumentException("Unable to bind OpenEJB enc");
    }
}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * Bind current thread, both for CL purposes and for JNDI ENC support
 * during : startup, shutdown and realoading of the context.
 *
 * @return the previous context class loader
 */
protected ClassLoader bindThread() {

    ClassLoader oldContextClassLoader =
        Thread.currentThread().getContextClassLoader();

    if (getResources() == null)
        return oldContextClassLoader;

    if (getLoader() != null && getLoader().getClassLoader() != null) {
        Thread.currentThread().setContextClassLoader
            (getLoader().getClassLoader());
    }

    DirContextURLStreamHandler.bindThread(getResources());

    if (isUseNaming()) {
        try {
            ContextBindings.bindThread(this, this);
        } catch (NamingException e) {
            // Silent catch, as this is a normal case during the early
            // startup stages
        }
    }

    return oldContextClassLoader;

}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * Unbind thread.
 */
protected void unbindThread(ClassLoader oldContextClassLoader) {

    if (isUseNaming()) {
        ContextBindings.unbindThread(this, this);
    }

    DirContextURLStreamHandler.unbindThread();

    Thread.currentThread().setContextClassLoader(oldContextClassLoader);
}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * Crete a new Context's instance.
 */
@SuppressWarnings("unchecked")
@Override
public Object getObjectInstance(Object obj, Name name, Context nameCtx,
                                Hashtable<?,?> environment)
    throws NamingException {
    if ((ContextBindings.isThreadBound()) || 
        (ContextBindings.isClassLoaderBound())) {
        return new SelectorContext((Hashtable<String,Object>)environment);
    }
    return null;
}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * Bind current thread, both for CL purposes and for JNDI ENC support
 * during : startup, shutdown and realoading of the context.
 *
 * @return the previous context class loader
 */
private ClassLoader bindThread() {

    ClassLoader oldContextClassLoader =
        Thread.currentThread().getContextClassLoader();

    if (getResources() == null)
        return oldContextClassLoader;

    if (getLoader().getClassLoader() != null) {
        Thread.currentThread().setContextClassLoader
            (getLoader().getClassLoader());
    }

    DirContextURLStreamHandler.bind(getResources());

    if (isUseNaming()) {
        try {
            ContextBindings.bindThread(this, this);
        } catch (NamingException e) {
            // Silent catch, as this is a normal case during the early
            // startup stages
        }
    }

    return oldContextClassLoader;

}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * Crete a new Context's instance.
 */
public Object getObjectInstance(Object obj, Name name, Context nameCtx,
                                Hashtable environment)
    throws NamingException {
    if ((ContextBindings.isThreadBound()) || 
        (ContextBindings.isClassLoaderBound())) {
        return new SelectorContext(environment);
    } else {
        return null;
    }
}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * Unbind thread.
 */
protected void unbindThread(ClassLoader oldContextClassLoader) {

	if (isUseNaming()) {
		ContextBindings.unbindThread(this, this);
	}

	DirContextURLStreamHandler.unbindThread();

	Thread.currentThread().setContextClassLoader(oldContextClassLoader);
}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * Crete a new Context's instance.
 */
@SuppressWarnings("unchecked")
@Override
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment)
		throws NamingException {
	if ((ContextBindings.isThreadBound()) || (ContextBindings.isClassLoaderBound())) {
		return new SelectorContext((Hashtable<String, Object>) environment);
	}
	return null;
}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * Change context binding.
 *
 * @param context the context
 * @param bind the bind
 * @throws NamingException the naming exception
 */
private void changeContextBinding(Context context, boolean bind) throws NamingException {
  Object token = getNamingToken(context);
  ClassLoader loader = Thread.currentThread().getContextClassLoader();
  if (bind) {
    ContextBindings.bindClassLoader(context, token, loader);
  } else {
    ContextBindings.unbindClassLoader(context, token, loader);
  }
}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
public synchronized List getApplicationResources(Context context, ContainerWrapperBean containerWrapper) throws NamingException {

        List resourceList = new ArrayList();

        boolean contextAvailable = containerWrapper.getTomcatContainer().getAvailable(context);
        if (contextAvailable) {

            logger.info("Reading CONTEXT " + context.getName());

            boolean contextBound = false;

            try {
                ContextBindings.bindClassLoader(context, null, Thread.currentThread().getContextClassLoader());
                contextBound = true;
            } catch (NamingException e) {
                logger.error("Cannot bind to context. useNaming=false ?");
                logger.debug("  Stack trace:", e);
            }

            try {
            	containerWrapper.getTomcatContainer().addContextResource(context, resourceList, contextBound);

            	containerWrapper.getTomcatContainer().addContextResourceLink(context, resourceList, contextBound);
            	for (int i = 0 ; i < resourceList.size() ; i++) {
            		lookupResource((ApplicationResource) resourceList.get(i), contextBound, false);
            	}
            	
            } finally {
                if (contextBound) {
                    ContextBindings.unbindClassLoader(context, null, Thread.currentThread().getContextClassLoader());
                }
            }
        }

        return resourceList;
    }
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
public synchronized boolean resetResource(final Context context, String resourceName) throws NamingException {
    if (context != null) {
        ContextBindings.bindClassLoader(context, null, Thread.currentThread().getContextClassLoader());
    }
    try {
        String jndiName = resolveJndiName(resourceName, (context == null));
        Object o = new InitialContext().lookup(jndiName);
        try {
            for (Iterator it = datasourceMappers.iterator(); it.hasNext();) {
                DatasourceAccessor accessor = (DatasourceAccessor) it.next();
                if (accessor.reset(o)) {
                    return true;
                }
            }
            return false;
        } catch (Throwable e) {
            //
            // make sure we always re-throw ThreadDeath
            //
            if (e instanceof ThreadDeath) {
                throw (ThreadDeath) e;
            }
            return false;
        }
    } finally {
        if (context != null) {
            ContextBindings.unbindClassLoader(context, null, Thread.currentThread().getContextClassLoader());
        }
    }
}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * Bind current thread, both for CL purposes and for JNDI ENC support
 * during : startup, shutdown and realoading of the context.
 *
 * @return the previous context class loader
 */
protected ClassLoader bindThread() {

    ClassLoader oldContextClassLoader =
        Thread.currentThread().getContextClassLoader();

    if (getResources() == null)
        return oldContextClassLoader;

    if (getLoader().getClassLoader() != null) {
        Thread.currentThread().setContextClassLoader
            (getLoader().getClassLoader());
    }

    DirContextURLStreamHandler.bindThread(getResources());

    if (isUseNaming()) {
        try {
            ContextBindings.bindThread(this, this);
        } catch (NamingException e) {
            // Silent catch, as this is a normal case during the early
            // startup stages
        }
    }

    return oldContextClassLoader;

}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * Creates a new instance.
 */
public TomcatThreadContextListener() {
    ContextBindings.bindContext(OPENEJB_CONTEXT, new OpenEJBContext());
    try {
        // someone decided to make the getThreadName package protected so we have to use reflection
        method = ContextBindings.class.getDeclaredMethod("getThreadName");
        method.setAccessible(true);

        final Field threadNameBindingsField = ContextBindings.class.getDeclaredField("threadObjectBindings");
        threadNameBindingsField.setAccessible(true);
        threadNameBindings = (Hashtable<Thread, Object>) threadNameBindingsField.get(null);
    } catch (final Exception e) {
        logger.error("Expected ContextBinding to have the method getThreadName()");
    }
}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public void contextExited(final ThreadContext exitedContext, final ThreadContext reenteredContext) {
    // unbind the new context
    ContextBindings.unbindThread(OPENEJB_CONTEXT, null);

    // attempt to restore the old context
    final Data data = exitedContext.get(Data.class);
    if (data != null && data.oldContextName != null) {
        try {
            ContextBindings.bindThread(data.oldContextName, null);
        } catch (final NamingException e) {
            logger.error("Exception in method contextExited", e);
        }
    }
}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
@Override
protected Connection open() {
    try { // parent behavior
        final Context context;
        if (fullName != null) {
            return DataSource.class.cast(openejbContext().lookup(fullName)).getConnection();
        }

        // parent behavior
        if (localDataSource) {
            context = Context.class.cast(ContextBindings.getClassLoader().lookup("comp/env"));
        } else {
            context = getServer().getGlobalNamingContext();
        }
        return DataSource.class.cast(context.lookup(dataSourceName)).getConnection();
    } catch (final Exception e) {
        try { // try globally
            return getConnection(dataSourceName);
        } catch (final Exception e2) {
            try { // try globally but with custom subspace
                return getConnection(OPENEJB_RESOURCE_PREFIX + dataSourceName);
            } catch (final Exception e3) {
                // try to guess the real name
                final Collection<String> ids = new ConfigurationFactory(true).getResourceIds(DataSource.class.getName(), new Properties());
                final String id = AutoConfig.findResourceId(ids, dataSourceName);

                if (id != null) {
                    try {
                        return getConnection(OPENEJB_RESOURCE_PREFIX + id);
                    } catch (final Exception e4) {
                        containerLog.error(sm.getString("dataSourceRealm.exception"), e);
                    }
                } else {
                    containerLog.error(sm.getString("dataSourceRealm.exception"), e);
                }
            }
        }
    }
    return null;
}
 

import org.apache.naming.ContextBindings; //导入依赖的package包/类
/**
 * Gets current context deployment context.
 *
 * @return context of deployment
 * @throws NamingException for exception
 */
private Context getThreadContext() throws NamingException {
    final ThreadContext threadContext = ThreadContext.getThreadContext();
    if (skipEjbContext(threadContext)) {
        return ContextBindings.getClassLoader();
    }
    final Context context = threadContext.getBeanContext().getJndiEnc();
    return context;
}