repositoryclassloader.java

jsr170接口的java实现。是个apache的开源项目。

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.jackrabbit.classloader;

import java.beans.Introspector;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.security.AccessController;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.jar.Attributes;
import java.util.jar.Manifest;

import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.apache.jackrabbit.net.JCRURLConnection;
import org.apache.jackrabbit.net.URLFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * The <code>RepositoryClassLoader</code> class extends the
 * <code>URLClassLoader</code> and provides the functionality to load classes
 * and resources from JCR Repository.
 * <p>
 * This class loader supports loading classes from the Repository hierarchy,
 * such as a <em>classes</em> 'folder', but also from Jar and Zip files stored
 * in the Repository.
 * <p>
 * For enhanced performance, this class loader keeps a list of resources and
 * classes which have already been loaded through this class loader. If later
 * requests ask for already cached resources, these are returned without
 * checking whether the underlying repository actually still exists.
 * <p>
 * This class is not intended to be extended by clients.
 *
 * @author Felix Meschberger
 */
public class RepositoryClassLoader extends URLClassLoader {

    /** default log category */
    private static final Logger log =
        LoggerFactory.getLogger(RepositoryClassLoader.class);

    /** An empty list of url paths to call superclass constructor */
    private static final URL[] NULL_PATH = {};

    /**
     * The special resource representing a resource which could not be
     * found in the class path.
     *
     * @see #cache
     * @see #findClassLoaderResource(String)
     */
    /* package */ static final ClassLoaderResource NOT_FOUND_RESOURCE =
        new ClassLoaderResource(null, "[sentinel]", null) {
            public boolean isExpired() {
                return false;
            }
        };

    /**
     * The classpath which this classloader searches for class definitions.
     * Each element of the vector should be either a directory, a .zip
     * file, or a .jar file.
     * <p>
     * It may be empty when only system classes are controlled.
     */
    private ClassPathEntry[] repository;

    /**
     * The list of handles to use as a classpath. These is the unprocessed
     * list of handles given to the constructor.
     */
    private PatternPath handles;

    /**
     * The <code>Session</code> grants access to the Repository to access the
     * resources.
     * <p>
     * This field is not final such that it may be cleared when the class loader
     * is destroyed.
     */
    private Session session;

    /**
     * Cache of resources found or not found in the class path. The map is
     * indexed by resource name and contains mappings to instances of the
     * {@link ClassLoaderResource} class. If a resource has been tried to be
     * loaded, which could not be found, the resource is cached with the
     * special mapping to {@link #NOT_FOUND_RESOURCE}.
     *
     * @see #NOT_FOUND_RESOURCE
     * @see #findClassLoaderResource(String)
     */
    private Map cache;

    /**
     * Flag indicating whether the {@link #destroy()} method has already been
     * called (<code>true</code>) or not (<code>false</code>)
     */
    private boolean destroyed;

    /**
     * Creates a <code>RepositoryClassLoader</code> from a list of item path
     * strings containing globbing pattens for the paths defining the class
     * path.
     *
     * @param session The <code>Session</code> to use to access the class items.
     * @param classPath The list of path strings making up the (initial) class
     *      path of this class loader. The strings may contain globbing
     *      characters which will be resolved to build the actual class path.
     * @param parent The parent <code>ClassLoader</code>, which may be
     *            <code>null</code>.
     *
     * @throws NullPointerException if either the session or the handles list is
     *             <code>null</code>.
     */
    public RepositoryClassLoader(Session session, String[] classPath,
        ClassLoader parent) {
        this(session, new DynamicPatternPath(session, classPath), parent);
    }

    /**
     * Creates a <code>RepositoryClassLoader</code> from a
     * {@link PatternPath} containing globbing pattens for the handles
     * defining the class path.
     *
     * @param session The <code>Session</code> to use to access the class items.
     * @param handles The {@link PatternPath} of handles.
     * @param parent The parent <code>ClassLoader</code>, which may be
     *            <code>null</code>.
     *
     * @throws NullPointerException if either the session or the handles list is
     *             <code>null</code>.
     */
    /* package */ RepositoryClassLoader(Session session, PatternPath handles,
            ClassLoader parent) {

        // initialize the super class with an empty class path
        super(NULL_PATH, parent);

        // check session and handles
        if (session == null) {
            throw new NullPointerException("session");
        }
        if (handles == null) {
            throw new NullPointerException("handles");
        }

        // set fields
        this.session = session;
        this.setHandles(handles);
        this.cache = new HashMap();
        this.destroyed = false;

        // build the class repositories list
        buildRepository();

        log.debug("RepositoryClassLoader: {} ready", this);
    }

    /**
     * Returns <code>true</code> if this class loader has already been destroyed
     * by calling {@link #destroy()}.
     */
    protected boolean isDestroyed() {
        return destroyed;
    }

    /**
     * Destroys this class loader. This process encompasses all steps needed
     * to remove as much references to this class loader as possible.
     * <p>
     * <em>NOTE</em>: This method just clears all internal fields and especially
     * the class path to render this class loader unusable.
     * <p>
     * This implementation does not throw any exceptions.
     */
    public void destroy() {
        // we expect to be called only once, so we stop destroyal here
        if (isDestroyed()) {
            log.debug("Instance is already destroyed");
            return;
        }

        // set destroyal guard
        destroyed = true;

        // clear caches and references
        setRepository(null);
        setHandles(null);
        session = null;

        // clear the cache of loaded resources and flush cached class
        // introspections of the JavaBean framework
        if (cache != null) {
            for (Iterator ci=cache.values().iterator(); ci.hasNext(); ) {
                ClassLoaderResource res = (ClassLoaderResource) ci.next();
                if (res.getLoadedClass() != null) {
                    Introspector.flushFromCaches(res.getLoadedClass());
                    res.setLoadedClass(null);
                }
                ci.remove();
            }
        }
    }

    //---------- URLClassLoader overwrites -------------------------------------

    /**
     * Finds and loads the class with the specified name from the class path.
     *
     * @param name the name of the class
     * @return the resulting class
     *
     * @throws ClassNotFoundException If the named class could not be found or
     *      if this class loader has already been destroyed.
     */
    protected Class findClass(final String name) throws ClassNotFoundException {

        if (isDestroyed()) {
            throw new ClassNotFoundException(name + " (Classloader destroyed)");
        }

        log.debug("findClass: Try to find class {}", name);

        try {
            return (Class) AccessController
                .doPrivileged(new PrivilegedExceptionAction() {

                    public Object run() throws ClassNotFoundException {
                        return findClassPrivileged(name);
                    }
                });
        } catch (java.security.PrivilegedActionException pae) {
            throw (ClassNotFoundException) pae.getException();
        }
    }

    /**
     * Finds the resource with the specified name on the search path.
     *
     * @param name the name of the resource
     *
     * @return a <code>URL</code> for the resource, or <code>null</code>
     *      if the resource could not be found or if the class loader has
     *      already been destroyed.
     */
    public URL findResource(String name) {

        if (isDestroyed()) {
            log.warn("Destroyed class loader cannot find a resource");
            return null;
        }

        log.debug("findResource: Try to find resource {}", name);

        ClassLoaderResource res = findClassLoaderResource(name);
        if (res != null) {
            log.debug("findResource: Getting resource from {}, created {}",
                res, new Date(res.getLastModificationTime()));
            return res.getURL();