Java tutorial
/* * JBoss, Home of Professional Open Source. * Copyright 2008, Red Hat Middleware LLC, and individual contributors * as indicated by the @author tags. See the copyright.txt file in the * distribution for a full listing of individual contributors. * * This is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this software; if not, write to the Free * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA * 02110-1301 USA, or see the FSF site: http://www.fsf.org. */ package org.jboss.web.tomcat.service; import java.beans.PropertyChangeListener; import java.io.File; import java.lang.reflect.Method; import java.net.MalformedURLException; import java.net.URL; import java.net.URLClassLoader; import java.util.ArrayList; import java.util.List; import javax.servlet.ServletContext; import org.apache.catalina.Container; import org.apache.catalina.Context; import org.apache.catalina.Globals; import org.apache.catalina.Lifecycle; import org.apache.catalina.LifecycleException; import org.apache.catalina.LifecycleListener; import org.apache.catalina.Loader; import org.apache.naming.resources.DirContextURLStreamHandler; import org.jboss.logging.Logger; /** * Initial version of a JBoss implementation of the Tomcat Loader. * * @author Scott.Stark@jboss.org * @version $Revision: 85945 $ */ public class WebCtxLoader implements Lifecycle, Loader { private static final Logger log = Logger.getLogger(WebCtxLoader.class); /** * The ClassLoader used to scope the ENC */ protected ClassLoader encLoader; /** * The ClassLoader returned from getClassLoader */ protected ENCLoader ctxLoader; protected Container webContainer; protected URL warURL; protected TomcatInjectionContainer injectionContainer; /** * The set of repositories associated with this class loader. */ private ArrayList repositories = new ArrayList(); /** * Create a WebCtxLoader given the ENC scoping class loader. * * @param encLoader */ public WebCtxLoader(ClassLoader encLoader) { this(encLoader, null); } public WebCtxLoader(ClassLoader encLoader, TomcatInjectionContainer container) { this.encLoader = encLoader; this.ctxLoader = new ENCLoader(encLoader); injectionContainer = container; } /** * Use an explicit classpath * * @param classpath */ public void setClasspath(List<URL> classpath) { for (URL path : classpath) { ctxLoader.addURLInternal(path); } } /** * Build the classpath from the war url WEB-INF/{classes,lib}. * * @param warURL * @throws MalformedURLException */ public void setWarURL(URL warURL) throws MalformedURLException { this.warURL = warURL; String path = warURL.getFile(); File classesDir = new File(path, "WEB-INF/classes"); if (classesDir.exists()) { ctxLoader.addURLInternal(classesDir.toURL()); } File libDir = new File(path, "WEB-INF/lib"); if (libDir.exists()) { File[] jars = libDir.listFiles(); int length = jars != null ? jars.length : 0; for (int j = 0; j < length; j++) { File jar = jars[j]; if (jar.getAbsolutePath().endsWith(".jar")) { ctxLoader.addURLInternal(jar.toURL()); } } } } public void addLifecycleListener(LifecycleListener listener) { } public LifecycleListener[] findLifecycleListeners() { return new LifecycleListener[0]; } public void removeLifecycleListener(LifecycleListener listener) { } public void start() throws LifecycleException { // ctxLoader is set upon construction and nullified during stop if (this.ctxLoader == null) throw new LifecycleException("WebCtxLoader cannot be restarted"); setClassPath(); if (injectionContainer != null) { log.debug("injectionContainer enabled and processing beginning with JBoss WebCtxLoader"); // we need to do this because the classloader is initialize by the web container and // the injection container needs the classloader so that it can build up Injectors and ENC populators injectionContainer.setClassLoader(getClassLoader()); injectionContainer.processMetadata(); } ServletContext servletContext = ((Context) webContainer).getServletContext(); if (servletContext == null) return; } public void stop() throws LifecycleException { // Remove the ctxLoader mapping kept by the DirContextURLStreamHandler DirContextURLStreamHandler.unbind(ctxLoader); org.apache.commons.logging.LogFactory.release(ctxLoader); org.apache.commons.logging.LogFactory.release(encLoader); this.encLoader = null; this.ctxLoader = null; this.repositories.clear(); this.warURL = null; this.webContainer = null; } public void backgroundProcess() { //To change body of implemented methods use File | Settings | File Templates. } /** * We must pass the wrapped encLoader as tomcat needs to see a unique * class loader that is distinct from the thread context class loader seen * to be in effect when the web app is started. This is due to how it * binds contexts using the DirContextURLStreamHandler class. * * @return The ENC scoping class loader * @see org.apache.naming.resources.DirContextURLStreamHandler */ public ClassLoader getClassLoader() { return ctxLoader; } public Container getContainer() { return webContainer; } public void setContainer(Container container) { webContainer = container; } public boolean getDelegate() { return false; } public void setDelegate(boolean delegate) { } public String getInfo() { return null; } public boolean getReloadable() { return false; } public void setReloadable(boolean reloadable) { } public void addPropertyChangeListener(PropertyChangeListener listener) { } public void addRepository(String repository) { if (repositories.contains(repository) == true) return; repositories.add(repository); setClassPath(); } public String[] findRepositories() { String[] tmp = new String[repositories.size()]; repositories.toArray(tmp); return tmp; } public boolean modified() { return false; } public void removePropertyChangeListener(PropertyChangeListener listener) { } /** * Set the appropriate context attribute for our class path. This * is required only because Jasper depends on it. */ private void setClassPath() { // Validate our current state information if (!(webContainer instanceof Context)) return; ServletContext servletContext = ((Context) webContainer).getServletContext(); if (servletContext == null) return; try { Method method = webContainer.getClass().getMethod("getCompilerClasspath", (Class[]) null); Object baseClasspath = method.invoke(webContainer, (Object[]) null); if (baseClasspath != null) { servletContext.setAttribute(Globals.CLASS_PATH_ATTR, baseClasspath.toString()); return; } } catch (Exception e) { // Ignore e.printStackTrace(); } StringBuffer classpath = new StringBuffer(); // Assemble the class path information from our repositories for (int i = 0; i < repositories.size(); i++) { String repository = repositories.get(i).toString(); if (repository.startsWith("file://")) repository = repository.substring(7); else if (repository.startsWith("file:")) repository = repository.substring(5); else if (repository.startsWith("jndi:")) repository = servletContext.getRealPath(repository.substring(5)); else continue; if (repository == null) continue; if (i > 0) classpath.append(File.pathSeparator); classpath.append(repository); } // Store the assembled class path as a servlet context attribute servletContext.setAttribute(Globals.CLASS_PATH_ATTR, classpath.toString()); } /** * A trival extension of URLClassLoader that uses an empty URL[] as its * classpath so that all work is delegated to its parent. */ static class ENCLoader extends URLClassLoader { private URL[] urllist = new URL[0]; ENCLoader(ClassLoader parent) { super(new URL[0], parent); } void addURLInternal(URL url) { URL[] result = new URL[urllist.length + 1]; for (int i = 0; i < urllist.length; i++) result[i] = urllist[i]; result[urllist.length] = url; urllist = result; } public URL[] getURLs() { return urllist; } } }