repositoryclassloader.java

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

        // create new array and copy old and new contents
        ClassPathEntry[] newList = new ClassPathEntry[list.length+1];
        System.arraycopy(list, 0, newList, 0, list.length);
        newList[list.length] = newEntry;
        return newList;
    }

    //---------- Object overwrite ---------------------------------------------

    /**
     * Returns a string representation of this instance.
     */
    public String toString() {
        StringBuffer buf = new StringBuffer(getClass().getName());

        if (isDestroyed()) {
            buf.append(" - destroyed");
        } else {
            buf.append(": parent: { ");
            buf.append(getParent());
            buf.append(" }, user: ");
            buf.append(session.getUserID());
        }

        return buf.toString();
    }

    //---------- internal ------------------------------------------------------

    /**
     * Builds the repository list from the list of path patterns and appends
     * the path entries from any added handles. This method may be used multiple
     * times, each time replacing the currently defined repository list.
     *
     * @throws NullPointerException If this class loader has already been
     *      destroyed.
     */
    protected synchronized void buildRepository() {

        // build new repository
        List handles;
        try {
            handles = getHandles().getExpandedPaths();
        } catch (RepositoryException re) {
            log.error("Cannot expand handle list", re);
            return;
        }

        List newRepository = new ArrayList(handles.size());

        // build repository from path patterns
        for (int i=0; i < handles.size(); i++) {
            String entry = (String) handles.get(i);
            ClassPathEntry cp = null;

            // try to find repository based on this path
            if (getRepository() != null) {
                for (int j=0; j < repository.length; j++) {
                    ClassPathEntry tmp = repository[i];
                    if (tmp.getPath().equals(entry)) {
                        cp = tmp;
                        break;
                    }
                }
            }

            // not found, creating new one
            if (cp == null) {
                cp = ClassPathEntry.getInstance(session, entry);
            }

            if (cp != null) {
                log.debug("Adding path {}", entry);
                newRepository.add(cp);
            } else {
                log.debug("Cannot get a ClassPathEntry for {}", entry);
            }
        }

        // replace old repository with new one
        ClassPathEntry[] newClassPath = new ClassPathEntry[newRepository.size()];
        newRepository.toArray(newClassPath);
        setRepository(newClassPath);

        // clear un-found resource cache
        cleanCache();
    }

    /**
     * Tries to find the class in the class path from within a
     * <code>PrivilegedAction</code>. Throws <code>ClassNotFoundException</code>
     * if no class can be found for the name.
     *
     * @param name the name of the class
     *
     * @return the resulting class
     *
     * @throws ClassNotFoundException if the class could not be found
     * @throws NullPointerException If this class loader has already been
     *      destroyed.
     */
    private Class findClassPrivileged(String name) throws ClassNotFoundException {

        // prepare the name of the class
        final String path = name.replace('.', '/').concat(".class");
        log.debug("findClassPrivileged: Try to find path {} for class {}",
            path, name);

        ClassLoaderResource res = findClassLoaderResource(path);
        if (res != null) {

             // try defining the class, error aborts
             try {
                 log.debug(
                    "findClassPrivileged: Loading class from {}, created {}",
                    res, new Date(res.getLastModificationTime()));

                 Class c = defineClass(name, res);
                 if (c == null) {
                     log.warn("defineClass returned null for class {}", name);
                     throw new ClassNotFoundException(name);
                 }
                 return c;

             } catch (IOException ioe) {
                 log.debug("defineClass failed", ioe);
                 throw new ClassNotFoundException(name, ioe);
             } catch (Throwable t) {
                 log.debug("defineClass failed", t);
                 throw new ClassNotFoundException(name, t);
             }
         }

        throw new ClassNotFoundException(name);
     }

    /**
     * Returns a {@link ClassLoaderResource} for the given <code>name</code> or
     * <code>null</code> if not existing. If the resource has already been
     * loaded earlier, the cached instance is returned. If the resource has
     * not been found in an earlier call to this method, <code>null</code> is
     * returned. Otherwise the resource is looked up in the class path. If
     * found, the resource is cached and returned. If not found, the
     * {@link #NOT_FOUND_RESOURCE} is cached for the name and <code>null</code>
     * is returned.
     *
     * @param name The name of the resource to return.
     *
     * @return The named <code>ClassLoaderResource</code> if found or
     *      <code>null</code> if not found.
     *
     * @throws NullPointerException If this class loader has already been
     *      destroyed.
     */
    /* package */ ClassLoaderResource findClassLoaderResource(String name) {

        // check for cached resources first
        ClassLoaderResource res = (ClassLoaderResource) cache.get(name);
        if (res == NOT_FOUND_RESOURCE) {
            log.debug("Resource '{}' known to not exist in class path", name);
            return null;
        } else if (res != null) {
            return res;
        }

        // walk the repository list and try to find the resource
        for (int i = 0; i < repository.length; i++) {
            final ClassPathEntry cp = repository[i];
            log.debug("Checking {}", cp);

            res = cp.getResource(name);
            if (res != null) {
                log.debug("Found resource in {}, created ", res, new Date(
                    res.getLastModificationTime()));
                cache.put(name, res);
                return res;
            }

        }

        log.debug("No classpath entry contains {}", name);
        cache.put(name, NOT_FOUND_RESOURCE);
        return null;
    }

    /**
     * Defines a class getting the bytes for the class from the resource
     *
     * @param name The fully qualified class name
     * @param res The resource to obtain the class bytes from
     *
     * @throws RepositoryException If a problem occurrs getting at the data.
     * @throws IOException If a problem occurrs reading the class bytes from
     *      the resource.
     * @throws ClassFormatError If the class bytes read from the resource are
     *      not a valid class.
     */
    private Class defineClass(String name, ClassLoaderResource res)
            throws IOException, RepositoryException {

        log.debug("defineClass({}, {})", name, res);

        Class clazz = res.getLoadedClass();
        if (clazz == null) {

            /**
             * This following code for packages is duplicate from URLClassLoader
             * because it is private there. I would like to not be forced to
             * do this, but I still have to find a way ... -fmeschbe
             */

            // package support
            int i = name.lastIndexOf('.');
            if (i != -1) {
                String pkgname = name.substring(0, i);
                // Check if package already loaded.
                Package pkg = getPackage(pkgname);
                URL url = res.getCodeSourceURL();
                Manifest man = res.getManifest();
                if (pkg != null) {
                    // Package found, so check package sealing.
                    boolean ok;
                    if (pkg.isSealed()) {
                        // Verify that code source URL is the same.
                        ok = pkg.isSealed(url);
                    } else {
                        // Make sure we are not attempting to seal the package
                        // at this code source URL.
                        ok = (man == null) || !isSealed(pkgname, man);
                    }
                    if (!ok) {
                        throw new SecurityException("sealing violation");
                    }
                } else {
                    if (man != null) {
                        definePackage(pkgname, man, url);
                    } else {
                        definePackage(pkgname, null, null, null, null, null, null, null);
                    }
                }
            }

            byte[] data = res.getBytes();
            clazz = defineClass(name, data, 0, data.length);
            res.setLoadedClass(clazz);
        }

        return clazz;
    }

    /**
     * Returns true if the specified package name is sealed according to the
     * given manifest
     * <p>
     * This code is duplicate from <code>URLClassLoader.isSealed</code> because
     * the latter has private access and we need the method here.
     */
    private boolean isSealed(String name, Manifest man) {
         String path = name.replace('.', '/').concat("/");
         Attributes attr = man.getAttributes(path);
         String sealed = null;
         if (attr != null) {
             sealed = attr.getValue(Attributes.Name.SEALED);
         }
         if (sealed == null) {
             if ((attr = man.getMainAttributes()) != null) {
                 sealed = attr.getValue(Attributes.Name.SEALED);
             }
         }
         return "true".equalsIgnoreCase(sealed);
    }

    /**
     * Returns <code>true</code> if the <code>url</code> is a <code>JCR</code>
     * URL.
     *
     * @param url The URL to check whether it is a valid <code>JCR</code> URL.
     *
     * @return <code>true</code> if <code>url</code> is a valid <code>JCR</code>
     *      URL.
     *
     * @throws NullPointerException if <code>url</code> is <code>null</code>.
     */
    private boolean checkURL(URL url) {
        return URLFactory.REPOSITORY_SCHEME.equalsIgnoreCase(url.getProtocol());
    }
}