Tomcat（五）类加载器机制

private ClassLoader createClassLoader(String name, ClassLoader parent)
    throws Exception {

    String value = CatalinaProperties.getProperty(name + ".loader");
    // 1 
    if ((value == null) || (value.equals("")))
        return parent;
    // 2
    value = replace(value);

    List<Repository> repositories = new ArrayList<Repository>();

    StringTokenizer tokenizer = new StringTokenizer(value, ",");
    while (tokenizer.hasMoreElements()) {
        String repository = tokenizer.nextToken().trim();
        if (repository.length() == 0) {
            continue;
        }

        // Check for a JAR URL repository
        try {
            @SuppressWarnings("unused")
            URL url = new URL(repository);
            repositories.add(
                    new Repository(repository, RepositoryType.URL));
            continue;
        } catch (MalformedURLException e) {
            // Ignore
        }

        // Local repository
        if (repository.endsWith("*.jar")) {
            repository = repository.substring
                (0, repository.length() - "*.jar".length());
            repositories.add(
                    new Repository(repository, RepositoryType.GLOB));
        } else if (repository.endsWith(".jar")) {
            repositories.add(
                    new Repository(repository, RepositoryType.JAR));
        } else {
            repositories.add(
                    new Repository(repository, RepositoryType.DIR));
        }
    }
    // 3
    ClassLoader classLoader = ClassLoaderFactory.createClassLoader
        (repositories, parent);

    // Retrieving MBean server
    MBeanServer mBeanServer = null;
    if (MBeanServerFactory.findMBeanServer(null).size() > 0) {
        mBeanServer = MBeanServerFactory.findMBeanServer(null).get(0);
    } else {
        mBeanServer = ManagementFactory.getPlatformMBeanServer();
    }

    // Register the server classloader
    ObjectName objectName =
        new ObjectName("Catalina:type=ServerClassLoader,name=" + name);
    mBeanServer.registerMBean(classLoader, objectName);

    return classLoader;

}

/**
  * Start this component and implement the requirements
  * of {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
  *
  * @exception LifecycleException if this component detects a fatal error
  *  that prevents this component from being used
  */
 @Override
 protected synchronized void startInternal() throws LifecycleException {

     if(log.isDebugEnabled())
         log.debug("Starting " + getBaseName());

     // Send j2ee.state.starting notification 
     if (this.getObjectName() != null) {
         Notification notification = new Notification("j2ee.state.starting",
                 this.getObjectName(), sequenceNumber.getAndIncrement());
         broadcaster.sendNotification(notification);
     }

     setConfigured(false);
     boolean ok = true;

     // Currently this is effectively a NO-OP but needs to be called to
     // ensure the NamingResources follows the correct lifecycle
     if (namingResources != null) {
         namingResources.start();
     }
     
     // Add missing components as necessary
     if (webappResources == null) {   // (1) Required by Loader
         if (log.isDebugEnabled())
             log.debug("Configuring default Resources");
         try {
             if ((getDocBase() != null) && (getDocBase().endsWith(".war")) &&
                     (!(new File(getBasePath())).isDirectory()))
                 setResources(new WARDirContext());
             else
                 setResources(new FileDirContext());
         } catch (IllegalArgumentException e) {
             log.error("Error initializing resources: " + e.getMessage());
             ok = false;
         }
     }
     if (ok) {
         if (!resourcesStart()) {
             log.error( "Error in resourceStart()");
             ok = false;
         }
     }
     // 1
     if (getLoader() == null) {
         WebappLoader webappLoader = new WebappLoader(getParentClassLoader());
         webappLoader.setDelegate(getDelegate());
         setLoader(webappLoader);
     }

     // Initialize character set mapper
     getCharsetMapper();

     // Post work directory
     postWorkDirectory();

     // Validate required extensions
     boolean dependencyCheck = true;
     try {
         dependencyCheck = ExtensionValidator.validateApplication
             (getResources(), this);
     } catch (IOException ioe) {
         log.error("Error in dependencyCheck", ioe);
         dependencyCheck = false;
     }

     if (!dependencyCheck) {
         // do not make application available if depency check fails
         ok = false;
     }

     // Reading the "catalina.useNaming" environment variable
     String useNamingProperty = System.getProperty("catalina.useNaming");
     if ((useNamingProperty != null)
         && (useNamingProperty.equals("false"))) {
         useNaming = false;
     }

     if (ok && isUseNaming()) {
         if (getNamingContextListener() == null) {
             NamingContextListener ncl = new NamingContextListener();
             ncl.setName(getNamingContextName());
             ncl.setExceptionOnFailedWrite(getJndiExceptionOnFailedWrite());
             addLifecycleListener(ncl);
             setNamingContextListener(ncl);
         }
     }
     
     // Standard container startup
     if (log.isDebugEnabled())
         log.debug("Processing standard container startup");

     
     // Binding thread
     ClassLoader oldCCL = bindThread();

     try {

         if (ok) {
             // 2
             // Start our subordinate components, if any
             if ((loader != null) && (loader instanceof Lifecycle))
                 ((Lifecycle) loader).start();

             // since the loader just started, the webapp classloader is now
             // created.
             // By calling unbindThread and bindThread in a row, we setup the
             // current Thread CCL to be the webapp classloader
             unbindThread(oldCCL);
             oldCCL = bindThread();

             // Initialize logger again. Other components might have used it
             // too early, so it should be reset.
             logger = null;
             getLogger();
             
             if ((cluster != null) && (cluster instanceof Lifecycle))
                 ((Lifecycle) cluster).start();
             Realm realm = getRealmInternal();
             if ((realm != null) && (realm instanceof Lifecycle))
                 ((Lifecycle) realm).start();
             if ((resources != null) && (resources instanceof Lifecycle))
                 ((Lifecycle) resources).start();

             // Notify our interested LifecycleListeners
             fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT, null);
             
             // Start our child containers, if not already started
             for (Container child : findChildren()) {
                 if (!child.getState().isAvailable()) {
                     child.start();
                 }
             }

             // Start the Valves in our pipeline (including the basic),
             // if any
             if (pipeline instanceof Lifecycle) {
                 ((Lifecycle) pipeline).start();
             }
             
             // Acquire clustered manager
             Manager contextManager = null;
             if (manager == null) {
                 if (log.isDebugEnabled()) {
                     log.debug(sm.getString("standardContext.cluster.noManager",
                             Boolean.valueOf((getCluster() != null)),
                             Boolean.valueOf(distributable)));
                 }
                 if ( (getCluster() != null) && distributable) {
                     try {
                         contextManager = getCluster().createManager(getName());
                     } catch (Exception ex) {
                         log.error("standardContext.clusterFail", ex);
                         ok = false;
                     }
                 } else {
                     contextManager = new StandardManager();
                 }
             } 
             
             // Configure default manager if none was specified
             if (contextManager != null) {
                 if (log.isDebugEnabled()) {
                     log.debug(sm.getString("standardContext.manager",
                             contextManager.getClass().getName()));
                 }
                 setManager(contextManager);
             }

             if (manager!=null && (getCluster() != null) && distributable) {
                 //let the cluster know that there is a context that is distributable
                 //and that it has its own manager
                 getCluster().registerManager(manager);
             }
         }

     } finally {
         // Unbinding thread
         unbindThread(oldCCL);
     }

     if (!getConfigured()) {
         log.error( "Error getConfigured");
         ok = false;
     }

     // We put the resources into the servlet context
     if (ok)
         getServletContext().setAttribute
             (Globals.RESOURCES_ATTR, getResources());

     // Initialize associated mapper
     mapper.setContext(getPath(), welcomeFiles, resources);

     // Binding thread
     oldCCL = bindThread();

     if (ok ) {
         if (getInstanceManager() == null) {
             javax.naming.Context context = null;
             if (isUseNaming() && getNamingContextListener() != null) {
                 context = getNamingContextListener().getEnvContext();
             }
             Map<String, Map<String, String>> injectionMap = buildInjectionMap(
                     getIgnoreAnnotations() ? new NamingResources(): getNamingResources());
             setInstanceManager(new DefaultInstanceManager(context,
                     injectionMap, this, this.getClass().getClassLoader()));
             getServletContext().setAttribute(
                     InstanceManager.class.getName(), getInstanceManager());
         }
     }

     try {
         // Create context attributes that will be required
         if (ok) {
             getServletContext().setAttribute(
                     JarScanner.class.getName(), getJarScanner());
         }

         // Set up the context init params
         mergeParameters();

         // Call ServletContainerInitializers
         for (Map.Entry<ServletContainerInitializer, Set<Class<?>>> entry :
             initializers.entrySet()) {
             try {
                 entry.getKey().onStartup(entry.getValue(),
                         getServletContext());
             } catch (ServletException e) {
                 log.error(sm.getString("standardContext.sciFail"), e);
                 ok = false;
                 break;
             }
         }

         // Configure and call application event listeners
         if (ok) {
             if (!listenerStart()) {
                 log.error( "Error listenerStart");
                 ok = false;
             }
         }
         
         try {
             // Start manager
             if ((manager != null) && (manager instanceof Lifecycle)) {
                 ((Lifecycle) getManager()).start();
             }
         } catch(Exception e) {
             log.error("Error manager.start()", e);
             ok = false;
         }

         // Configure and call application filters
         if (ok) {
             if (!filterStart()) {
                 log.error("Error filterStart");
                 ok = false;
             }
         }
         
         // Load and initialize all "load on startup" servlets
         if (ok) {
             loadOnStartup(findChildren());
         }
         
         // Start ContainerBackgroundProcessor thread
         super.threadStart();
     } finally {
         // Unbinding thread
         unbindThread(oldCCL);
     }

     // Set available status depending upon startup success
     if (ok) {
         if (log.isDebugEnabled())
             log.debug("Starting completed");
     } else {
         log.error(sm.getString("standardContext.startFailed", getName()));
     }

     startTime=System.currentTimeMillis();
     
     // Send j2ee.state.running notification 
     if (ok && (this.getObjectName() != null)) {
         Notification notification = 
             new Notification("j2ee.state.running", this.getObjectName(),
                              sequenceNumber.getAndIncrement());
         broadcaster.sendNotification(notification);
     }

     // Close all JARs right away to avoid always opening a peak number 
     // of files on startup
     if (getLoader() instanceof WebappLoader) {
         ((WebappLoader) getLoader()).closeJARs(true);
     }

     // Reinitializing if something went wrong
     if (!ok) {
         setState(LifecycleState.FAILED);
     } else {
         setState(LifecycleState.STARTING);
     }
 }

/**
  * Start associated {@link ClassLoader} and implement the requirements
  * of {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
  *
  * @exception LifecycleException if this component detects a fatal error
  *  that prevents this component from being used
  */
 @Override
 protected void startInternal() throws LifecycleException {

     if (log.isDebugEnabled())
         log.debug(sm.getString("webappLoader.starting"));

     if (container.getResources() == null) {
         log.info("No resources for " + container);
         setState(LifecycleState.STARTING);
         return;
     }

     // Register a stream handler factory for the JNDI protocol
     URLStreamHandlerFactory streamHandlerFactory =
             DirContextURLStreamHandlerFactory.getInstance();
     if (first) {
         first = false;
         try {
             URL.setURLStreamHandlerFactory(streamHandlerFactory);
         } catch (Exception e) {
             // Log and continue anyway, this is not critical
             log.error("Error registering jndi stream handler", e);
         } catch (Throwable t) {
             ExceptionUtils.handleThrowable(t);
             // This is likely a dual registration
             log.info("Dual registration of jndi stream handler: "
                      + t.getMessage());
         }
     }

     // Construct a class loader based on our current repositories list
     try {
         // 1
         classLoader = createClassLoader();
         classLoader.setResources(container.getResources());
         classLoader.setDelegate(this.delegate);
         classLoader.setSearchExternalFirst(searchExternalFirst);
         if (container instanceof StandardContext) {
             classLoader.setAntiJARLocking(
                     ((StandardContext) container).getAntiJARLocking());
             classLoader.setClearReferencesStatic(
                     ((StandardContext) container).getClearReferencesStatic());
             classLoader.setClearReferencesStopThreads(
                     ((StandardContext) container).getClearReferencesStopThreads());
             classLoader.setClearReferencesStopTimerThreads(
                     ((StandardContext) container).getClearReferencesStopTimerThreads());
             classLoader.setClearReferencesHttpClientKeepAliveThread(
                     ((StandardContext) container).getClearReferencesHttpClientKeepAliveThread());
         }

         for (int i = 0; i < repositories.length; i++) {
             classLoader.addRepository(repositories[i]);
         }

         // Configure our repositories
         setRepositories();
         setClassPath();

         setPermissions();

         ((Lifecycle) classLoader).start();

         // Binding the Webapp class loader to the directory context
         DirContextURLStreamHandler.bind(classLoader,
                 this.container.getResources());

         StandardContext ctx=(StandardContext)container;
         String contextName = ctx.getName();
         if (!contextName.startsWith("/")) {
             contextName = "/" + contextName;
         }
         ObjectName cloname = new ObjectName
             (MBeanUtils.getDomain(ctx) + ":type=WebappClassLoader,context="
              + contextName + ",host=" + ctx.getParent().getName());
         Registry.getRegistry(null, null)
             .registerComponent(classLoader, cloname, null);

     } catch (Throwable t) {
         t = ExceptionUtils.unwrapInvocationTargetException(t);
         ExceptionUtils.handleThrowable(t);
         log.error( "LifecycleException ", t );
         throw new LifecycleException("start: ", t);
     }

     setState(LifecycleState.STARTING);
 }

/**
  * Create associated classLoader.
  */
 private WebappClassLoader createClassLoader()
     throws Exception {

     Class<?> clazz = Class.forName(loaderClass);
     WebappClassLoader classLoader = null;

     if (parentClassLoader == null) {
         parentClassLoader = container.getParentClassLoader();
     }
     Class<?>[] argTypes = { ClassLoader.class };
     Object[] args = { parentClassLoader };
     Constructor<?> constr = clazz.getConstructor(argTypes);
     classLoader = (WebappClassLoader) constr.newInstance(args);

     return classLoader;
 }

/**
  * Load the class with the specified name, searching using the following
  * algorithm until it finds and returns the class.  If the class cannot
  * be found, returns <code>ClassNotFoundException</code>.
  * <ul>
  * <li>Call <code>findLoadedClass(String)</code> to check if the
  *     class has already been loaded.  If it has, the same
  *     <code>Class</code> object is returned.</li>
  * <li>If the <code>delegate</code> property is set to <code>true</code>,
  *     call the <code>loadClass()</code> method of the parent class
  *     loader, if any.</li>
  * <li>Call <code>findClass()</code> to find this class in our locally
  *     defined repositories.</li>
  * <li>Call the <code>loadClass()</code> method of our parent
  *     class loader, if any.</li>
  * </ul>
  * If the class was found using the above steps, and the
  * <code>resolve</code> flag is <code>true</code>, this method will then
  * call <code>resolveClass(Class)</code> on the resulting Class object.
  *
  * @param name Name of the class to be loaded
  * @param resolve If <code>true</code> then resolve the class
  *
  * @exception ClassNotFoundException if the class was not found
  */
 @Override
 public synchronized Class<?> loadClass(String name, boolean resolve)
     throws ClassNotFoundException {

     if (log.isDebugEnabled())
         log.debug("loadClass(" + name + ", " + resolve + ")");
     Class<?> clazz = null;

     // Log access to stopped classloader
     if (!started) {
         try {
             throw new IllegalStateException();
         } catch (IllegalStateException e) {
             log.info(sm.getString("webappClassLoader.stopped", name), e);
         }
     }

     // (0) Check our previously loaded local class cache
     // 1 
     clazz = findLoadedClass0(name);
     if (clazz != null) {
         if (log.isDebugEnabled())
             log.debug("  Returning class from cache");
         if (resolve)
             resolveClass(clazz);
         return (clazz);
     }

     // (0.1) Check our previously loaded class cache
     // 2
     clazz = findLoadedClass(name);
     if (clazz != null) {
         if (log.isDebugEnabled())
             log.debug("  Returning class from cache");
         if (resolve)
             resolveClass(clazz);
         return (clazz);
     }

     // (0.2) Try loading the class with the system class loader, to prevent
     //       the webapp from overriding J2SE classes
     try {
         // 3   
         clazz = system.loadClass(name);
         if (clazz != null) {
             if (resolve)
                 resolveClass(clazz);
             return (clazz);
         }
     } catch (ClassNotFoundException e) {
         // Ignore
     }

     // (0.5) Permission to access this class when using a SecurityManager
     if (securityManager != null) {
         int i = name.lastIndexOf('.');
         if (i >= 0) {
             try {
                 securityManager.checkPackageAccess(name.substring(0,i));
             } catch (SecurityException se) {
                 String error = "Security Violation, attempt to use " +
                     "Restricted Class: " + name;
                 log.info(error, se);
                 throw new ClassNotFoundException(error, se);
             }
         }
     }
     // 4
     boolean delegateLoad = delegate || filter(name);
     // 5
     // (1) Delegate to our parent if requested
     if (delegateLoad) {
         if (log.isDebugEnabled())
             log.debug("  Delegating to parent classloader1 " + parent);
         ClassLoader loader = parent;
         if (loader == null)
             loader = system;
         try {
             clazz = Class.forName(name, false, loader);
             if (clazz != null) {
                 if (log.isDebugEnabled())
                     log.debug("  Loading class from parent");
                 if (resolve)
                     resolveClass(clazz);
                 return (clazz);
             }
         } catch (ClassNotFoundException e) {
             // Ignore
         }
     }

     // (2) Search local repositories
     if (log.isDebugEnabled())
         log.debug("  Searching local repositories");
     // 6
     try {
         clazz = findClass(name);
         if (clazz != null) {
             if (log.isDebugEnabled())
                 log.debug("  Loading class from local repository");
             if (resolve)
                 resolveClass(clazz);
             return (clazz);
         }
     } catch (ClassNotFoundException e) {
         // Ignore
     }

     // (3) Delegate to parent unconditionally
     // 7
     if (!delegateLoad) {
         if (log.isDebugEnabled())
             log.debug("  Delegating to parent classloader at end: " + parent);
         ClassLoader loader = parent;
         if (loader == null)
             loader = system;
         try {
             clazz = Class.forName(name, false, loader);
             if (clazz != null) {
                 if (log.isDebugEnabled())
                     log.debug("  Loading class from parent");
                 if (resolve)
                     resolveClass(clazz);
                 return (clazz);
             }
         } catch (ClassNotFoundException e) {
             // Ignore
         }
     }
     throw new ClassNotFoundException(name);
 }

/**
  * Find the specified class in our local repositories, if possible.  If
  * not found, throw <code>ClassNotFoundException</code>.
  *
  * @param name Name of the class to be loaded
  *
  * @exception ClassNotFoundException if the class was not found
  */
 @Override
 public Class<?> findClass(String name) throws ClassNotFoundException {

     if (log.isDebugEnabled())
         log.debug("    findClass(" + name + ")");

     // Cannot load anything from local repositories if class loader is stopped
     if (!started) {
         throw new ClassNotFoundException(name);
     }

     // (1) Permission to define this class when using a SecurityManager
     if (securityManager != null) {
         int i = name.lastIndexOf('.');
         if (i >= 0) {
             try {
                 if (log.isTraceEnabled())
                     log.trace("      securityManager.checkPackageDefinition");
                 securityManager.checkPackageDefinition(name.substring(0,i));
             } catch (Exception se) {
                 if (log.isTraceEnabled())
                     log.trace("      -->Exception-->ClassNotFoundException", se);
                 throw new ClassNotFoundException(name, se);
             }
         }
     }

     // Ask our superclass to locate this class, if possible
     // (throws ClassNotFoundException if it is not found)
     Class<?> clazz = null;
     try {
         if (log.isTraceEnabled())
             log.trace("      findClassInternal(" + name + ")");
         if (hasExternalRepositories && searchExternalFirst) {
             try {
                 clazz = super.findClass(name);
             } catch(ClassNotFoundException cnfe) {
                 // Ignore - will search internal repositories next
             } catch(AccessControlException ace) {
                 log.warn("WebappClassLoader.findClassInternal(" + name
                         + ") security exception: " + ace.getMessage(), ace);
                 throw new ClassNotFoundException(name, ace);
             } catch (RuntimeException e) {
                 if (log.isTraceEnabled())
                     log.trace("      -->RuntimeException Rethrown", e);
                 throw e;
             }
         }
         if ((clazz == null)) {
             try {
                 clazz = findClassInternal(name);
             } catch(ClassNotFoundException cnfe) {
                 if (!hasExternalRepositories || searchExternalFirst) {
                     throw cnfe;
                 }
             } catch(AccessControlException ace) {
                 log.warn("WebappClassLoader.findClassInternal(" + name
                         + ") security exception: " + ace.getMessage(), ace);
                 throw new ClassNotFoundException(name, ace);
             } catch (RuntimeException e) {
                 if (log.isTraceEnabled())
                     log.trace("      -->RuntimeException Rethrown", e);
                 throw e;
             }
         }
         if ((clazz == null) && hasExternalRepositories && !searchExternalFirst) {
             try {
                 clazz = super.findClass(name);
             } catch(AccessControlException ace) {
                 log.warn("WebappClassLoader.findClassInternal(" + name
                         + ") security exception: " + ace.getMessage(), ace);
                 throw new ClassNotFoundException(name, ace);
             } catch (RuntimeException e) {
                 if (log.isTraceEnabled())
                     log.trace("      -->RuntimeException Rethrown", e);
                 throw e;
             }
         }
         if (clazz == null) {
             if (log.isDebugEnabled())
                 log.debug("    --> Returning ClassNotFoundException");
             throw new ClassNotFoundException(name);
         }
     } catch (ClassNotFoundException e) {
         if (log.isTraceEnabled())
             log.trace("    --> Passing on ClassNotFoundException");
         throw e;
     }

     // Return the class we have located
     if (log.isTraceEnabled())
         log.debug("      Returning class " + clazz);

     if (log.isTraceEnabled()) {
         ClassLoader cl;
         if (Globals.IS_SECURITY_ENABLED){
             cl = AccessController.doPrivileged(
                 new PrivilegedGetClassLoader(clazz));
         } else {
             cl = clazz.getClassLoader();
         }
         log.debug("      Loaded by " + cl.toString());
     }
     return (clazz);
 }

/**
  * Find specified class in local repositories.
  *
  * @return the loaded class, or null if the class isn't found
  */
 protected Class<?> findClassInternal(String name)
     throws ClassNotFoundException {

     if (!validate(name))
         throw new ClassNotFoundException(name);

     String tempPath = name.replace('.', '/');
     String classPath = tempPath + ".class";

     ResourceEntry entry = null;

     if (securityManager != null) {
         PrivilegedAction<ResourceEntry> dp =
             new PrivilegedFindResourceByName(name, classPath);
         entry = AccessController.doPrivileged(dp);
     } else {
         // 1 
         entry = findResourceInternal(name, classPath);
     }

     if (entry == null)
         throw new ClassNotFoundException(name);

     Class<?> clazz = entry.loadedClass;
     if (clazz != null)
         return clazz;

     synchronized (this) {
         clazz = entry.loadedClass;
         if (clazz != null)
             return clazz;

         if (entry.binaryContent == null)
             throw new ClassNotFoundException(name);

         // Looking up the package
         String packageName = null;
         int pos = name.lastIndexOf('.');
         if (pos != -1)
             packageName = name.substring(0, pos);

         Package pkg = null;

         if (packageName != null) {
             pkg = getPackage(packageName);
             // Define the package (if null)
             if (pkg == null) {
                 try {
                     if (entry.manifest == null) {
                         definePackage(packageName, null, null, null, null,
                                 null, null, null);
                     } else {
                         definePackage(packageName, entry.manifest,
                                 entry.codeBase);
                     }
                 } catch (IllegalArgumentException e) {
                     // Ignore: normal error due to dual definition of package
                 }
                 pkg = getPackage(packageName);
             }
         }

         if (securityManager != null) {

             // Checking sealing
             if (pkg != null) {
                 boolean sealCheck = true;
                 if (pkg.isSealed()) {
                     sealCheck = pkg.isSealed(entry.codeBase);
                 } else {
                     sealCheck = (entry.manifest == null)
                         || !isPackageSealed(packageName, entry.manifest);
                 }
                 if (!sealCheck)
                     throw new SecurityException
                         ("Sealing violation loading " + name + " : Package "
                          + packageName + " is sealed.");
             }

         }

         try {
             // 2
             clazz = defineClass(name, entry.binaryContent, 0,
                     entry.binaryContent.length,
                     new CodeSource(entry.codeBase, entry.certificates));
         } catch (UnsupportedClassVersionError ucve) {
             throw new UnsupportedClassVersionError(
                     ucve.getLocalizedMessage() + " " +
                     sm.getString("webappClassLoader.wrongVersion",
                             name));
         }
         entry.loadedClass = clazz;
         entry.binaryContent = null;
         entry.source = null;
         entry.codeBase = null;
         entry.manifest = null;
         entry.certificates = null;
     }
     return clazz;
 }