archiveclasspathentry.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.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.jar.JarEntry;
import java.util.jar.JarInputStream;
import java.util.jar.Manifest;

import javax.jcr.Property;
import javax.jcr.RepositoryException;

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


/**
 * The <code>ArchiveClassPathEntry</code> implements the {@link ClassPathEntry}
 * abstract class with support for archives containing classes and other
 * resources. The path used to construct the instance is the path of an item
 * resolving to a property containing the jar archive to access.
 *
 * @author Felix Meschberger
 */
class ArchiveClassPathEntry extends ClassPathEntry {

    /** Default logger */
    private static final Logger log =
        LoggerFactory.getLogger(ArchiveClassPathEntry.class);

    /** The property containing the archive */
    private final Property prop;

    /**
     * Cache all entries in the archive for faster decision on whether such
     * an entry is contained.
     */
    private Map entryMap;

    /**
     * The JAR file manifest. Set on demand by the {@link #getManifest()}
     * method.
     */
    private Manifest jarManifest;

    /**
     * Flag to indicate, whether the {@link #jarManifest} has already been read
     * from the archive. This field is used and set by the
     * {@link #getManifest()} to decide, whether to try to read the manifest.
     */
    private boolean jarManifestRead;

    /**
     * Creates an instance of the <code>ArchiveClassPathEntry</code> class.
     *
     * @param prop The <code>Property</code> containing the archive and
     *      the session used to access the repository.
     * @param path The original class path entry leading to the creation of
     *      this instance. This is not necessairily the same path as the
     *      properties path if the property was found through the primary
     *      item chain.
     *
     * @throws RepositoryException If an error occurrs retrieving the session
     *      from the property.
     */
    ArchiveClassPathEntry(Property prop, String path) throws RepositoryException {
        super(prop.getSession(), path);
        this.prop = prop;
    }

    /**
     * Clones the indicated <code>ArchiveClassPathEntry</code> object by
     * taking over its path, session and property.
     *
     * @param base The base <code>ArchiveClassPath</code> entry to clone.
     *
     * @see ClassPathEntry#ClassPathEntry(ClassPathEntry)
     */
    protected ArchiveClassPathEntry(ArchiveClassPathEntry base) {
        super(base);
        this.prop = base.prop;
    }

    /**
     * Returns the <code>Property</code> containing the JAR file of this
     * archive class path entry.
     */
    protected Property getProperty() {
        return prop;
    }

    /**
     * Returns a {@link ClassLoaderResource} for the named resource if it
     * can be found in the archive identified by the path given at
     * construction time. Note that if the archive property would exist but is
     * not readable by the current session, no resource is returned.
     * <p>
     * This method accesses the archive through an <code>InputStream</code>
     * retrievedfrom the property. This <code>InputStream</code> is closed before
     * returning to the caller to release the resources behind the stream
     * such that it might be updated, etc. For this reason the resource
     * instance returned will again open an <code>InputStream</code> on the
     * archive property to access the resource. Users of the resource
     * <code>InputStream</code> are encouraged to close the stream when no
     * longer used to prevent lockups in the Repository.
     *
     * @param name The name of the resource to return. If the resource would
     *      be a class the name must already be modified to denote a valid
     *      path, that is dots replaced by slashes and the <code>.class</code>
     *      extension attached.
     *
     * @return The {@link ClassLoaderResource} identified by the name or
     *      <code>null</code> if no resource is found for that name.
     */
    public ClassLoaderResource getResource(final String name) {

        JarInputStream zins = null;
        try {
            // get the archive and try to find the entry
            zins = getJarInputStream(prop);
            JarEntry entry = findEntry(zins, name);

            // if found create the resource to return
            if (entry != null) {
                return new ArchiveClassPathResource(this, entry);
            }

            log.debug("getResource: resource {} not found in archive {}", name,
                path);

        } catch (IOException ioe) {

            log.warn("getResource: problem accessing the archive {} for {}",
                new Object[]{ path, name}, ioe);

        } catch (RepositoryException re) {

            log.warn("getResource: problem accessing the archive {} for {}",
                new Object[]{ path, name}, re);

        } finally {

            // make sure streams are closed at the end
            if (zins != null) {
                try {
                    zins.close();
                } catch (IOException ignore) {
                }
            }

        }
        // invariant : not found or problem accessing the archive

        return null;
    }

    /**
     * Returns a <code>ClassPathEntry</code> with the same configuration as
     * this <code>ClassPathEntry</code>.
     * <p>
     * The <code>ArchiveClassPathEntry</code> class has internal state.
     * Therefore a new instance is created from the unmodifiable configuration
     * of this instance.
     */
    ClassPathEntry copy() {
        return new ArchiveClassPathEntry(this);
    }

    /**
     * Returns a JAR URL with no entry as the base URL of this class path entry.
     */
    public URL toURL() {
        if (baseURL == null) {
            try {
                baseURL = URLFactory.createJarURL(session, path, null);
            } catch (MalformedURLException mue) {
                log.warn("Problem creating baseURI for " + path, mue);
            }
        }

        return baseURL;
    }

    //----------- internal helper to find the entry ------------------------

    /**
     * Returns a JAR URL to access the named resource within the archive
     * underlying this class path entry. This is a helper method for the
     * {@link ClassLoaderResource} instance returned by
     * {@link #getResource(String)} method.
     * <p>
     * This method does not check, whether the named entry actually exists in
     * the underlying archive.
     *
     * @param name The name of the resource for which to create the JAR URL.
     */
    protected URL getURL(String name) {
        try {
            return URLFactory.createJarURL(session, path, name);
        } catch (MalformedURLException mue) {
            log.error("getURL: Cannot create URL for " + name, mue);
        }
        return null;
    }

    /**
     * Returns an URL to access the underlying archive itself of this class
     * path entry. The URL returned may be used as the code source for Java
     * securtiy protection domains. This is a helper method for the
     * {@link ClassLoaderResource} instance returned by
     * {@link #getResource(String)} method.
     *
     * @return The URL to access the underlying archive.
     */
    protected URL getCodeSourceURL() {
        try {
            return URLFactory.createURL(session, path);
        } catch (MalformedURLException mue) {
            log.warn("getCodeSourceURL: Cannot getURL for " + path, mue);
        }
        return null;
    }

    /**
     * Returns a <code>JarInputStream</code> from the property.
     *
     * @param property The <code>Property</code> containing the archive to
     *      access.
     *
     * @return A valid <code>JarInputStream</code>.
     *
     * @throws RepositoryException If an <code>InputStream</code> cannot be
     *      retrieved from the property.
     * @throws IOException If the <code>JarInputStream</code> cannot be
     *      created.
     */
    static JarInputStream getJarInputStream(Property property)
            throws RepositoryException, IOException {
        return new JarInputStream(property.getStream());
    }

    /**
     * Returns the <code>Manifest</code> object of the JAR archive file
     * underlying this archive class path entry. If no manifest exists in the
     * JAR file or if the archive is not a JAR file at - e.g. a plain ZIP
     * file - this method returns <code>null</code>. If an error occurrs
     * trying to access the manifest, <code>null</code> is also returned. Later
     * calls to this method, will not try again to read the manifest file,
     * though.
     * <p>
     * This method is synchronized to prevent two threads from trying to access
     * the manifest at the same time, which might result in false negative
     * returned.
     *
     * @return The manifest contained in the underlying JAR file or
     *      <code>null</code> if none exists or an error occurrs trying to
     *      load the manifest.
     */
    protected synchronized Manifest getManifest() {
        if (jarManifest == null && !jarManifestRead) {

            // immediately mark the manifest read, to prevent repeated read
            // in the case of missing manifest
            jarManifestRead = true;

            JarInputStream zipIns = null;
            try {
                zipIns = new JarInputStream(prop.getStream());
                jarManifest = zipIns.getManifest();