Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
Apache Ant Source Code Files
Apache Ant Source Code Files are inside the Apache Ant source package file like apache-ant-1.10.10-src.zip. Unzip the source package file and go to the "src/main" sub-directory, you will see source code files.
Here is the list of Java source code files of the Apache Ant 1.10.10 in \Users\fyicenter\apache-ant-1.10.10\src\main:
✍: FYIcenter.com
⏎ org/apache/tools/ant/AntClassLoader.java
/* * 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 * * https://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.tools.ant; import java.io.ByteArrayOutputStream; import java.io.Closeable; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.lang.reflect.Constructor; import java.net.MalformedURLException; import java.net.URL; import java.nio.file.Files; import java.security.CodeSource; import java.security.ProtectionDomain; import java.security.cert.Certificate; import java.util.Collections; import java.util.Enumeration; import java.util.HashMap; import java.util.Hashtable; import java.util.Map; import java.util.NoSuchElementException; import java.util.Objects; import java.util.StringTokenizer; import java.util.Vector; import java.util.jar.Attributes; import java.util.jar.Attributes.Name; import java.util.jar.JarEntry; import java.util.jar.JarFile; import java.util.jar.Manifest; import java.util.stream.Collectors; import java.util.stream.Stream; import java.util.zip.ZipFile; import org.apache.tools.ant.launch.Locator; import org.apache.tools.ant.types.Path; import org.apache.tools.ant.util.FileUtils; import org.apache.tools.ant.util.JavaEnvUtils; import org.apache.tools.ant.util.LoaderUtils; import org.apache.tools.ant.util.ReflectUtil; import org.apache.tools.ant.util.StringUtils; import org.apache.tools.ant.util.VectorSet; import org.apache.tools.zip.ZipLong; /** * Used to load classes within ant with a different classpath from * that used to start ant. Note that it is possible to force a class * into this loader even when that class is on the system classpath by * using the forceLoadClass method. Any subsequent classes loaded by that * class will then use this loader rather than the system class loader. * * <p> * Note that this classloader has a feature to allow loading * in reverse order and for "isolation". * Due to the fact that a number of * methods in java.lang.ClassLoader are final (at least * in java 1.4 getResources) this means that the * class has to fake the given parent. * </p> * */ public class AntClassLoader extends ClassLoader implements SubBuildListener, Closeable { private static final FileUtils FILE_UTILS = FileUtils.getFileUtils(); private static final boolean IS_ATLEAST_JAVA9 = JavaEnvUtils.isAtLeastJavaVersion(JavaEnvUtils.JAVA_9); // constructs needed to create (via reflection) a java.util.jar.JarFile instance when Java runtime version is >= 9 private static final Class[] MR_JARFILE_CTOR_ARGS; private static final Object MR_JARFILE_CTOR_RUNTIME_VERSION_VAL; static { registerAsParallelCapable(); if (IS_ATLEAST_JAVA9) { Class[] ctorArgs = null; Object runtimeVersionVal = null; try { final Class<?> runtimeVersionClass = Class.forName("java.lang.Runtime$Version"); ctorArgs = new Class[] {File.class, boolean.class, int.class, runtimeVersionClass}; runtimeVersionVal = Runtime.class.getDeclaredMethod("version").invoke(null); } catch (Exception e) { // ignore - we consider this as multi-release jar unsupported } MR_JARFILE_CTOR_ARGS = ctorArgs; MR_JARFILE_CTOR_RUNTIME_VERSION_VAL = runtimeVersionVal; } else { MR_JARFILE_CTOR_ARGS = null; MR_JARFILE_CTOR_RUNTIME_VERSION_VAL = null; } } /** * An enumeration of all resources of a given name found within the * classpath of this class loader. This enumeration is used by the * ClassLoader.findResources method, which is in * turn used by the ClassLoader.getResources method. * * @see AntClassLoader#findResources(String) * @see java.lang.ClassLoader#getResources(String) */ private class ResourceEnumeration implements Enumeration<URL> { /** * The name of the resource being searched for. */ private final String resourceName; /** * The index of the next classpath element to search. */ private int pathElementsIndex; /** * The URL of the next resource to return in the enumeration. If this * field is <code>null</code> then the enumeration has been completed, * i.e., there are no more elements to return. */ private URL nextResource; /** * Constructs a new enumeration of resources of the given name found * within this class loader's classpath. * * @param name the name of the resource to search for. */ ResourceEnumeration(final String name) { this.resourceName = name; this.pathElementsIndex = 0; findNextResource(); } /** * Indicates whether there are more elements in the enumeration to * return. * * @return <code>true</code> if there are more elements in the * enumeration; <code>false</code> otherwise. */ public boolean hasMoreElements() { return (this.nextResource != null); } /** * Returns the next resource in the enumeration. * * @return the next resource in the enumeration */ public URL nextElement() { final URL ret = this.nextResource; if (ret == null) { throw new NoSuchElementException(); } findNextResource(); return ret; } /** * Locates the next resource of the correct name in the classpath and * sets <code>nextResource</code> to the URL of that resource. If no * more resources can be found, <code>nextResource</code> is set to * <code>null</code>. */ private void findNextResource() { URL url = null; while ((pathElementsIndex < pathComponents.size()) && (url == null)) { try { final File pathComponent = pathComponents.elementAt(pathElementsIndex); url = getResourceURL(pathComponent, this.resourceName); pathElementsIndex++; } catch (final BuildException e) { // ignore path elements which are not valid relative to the // project } } this.nextResource = url; } } /** * The size of buffers to be used in this classloader. */ private static final int BUFFER_SIZE = 8192; /** * Number of array elements in a test array of strings */ private static final int NUMBER_OF_STRINGS = 256; /** * The components of the classpath that the classloader searches * for classes. */ private final Vector<File> pathComponents = new VectorSet<>(); /** * The project to which this class loader belongs. */ private Project project; /** * Indicates whether the parent class loader should be * consulted before trying to load with this class loader. */ private boolean parentFirst = true; /** * These are the package roots that are to be loaded by the parent class * loader regardless of whether the parent class loader is being searched * first or not. */ private final Vector<String> systemPackages = new Vector<>(); /** * These are the package roots that are to be loaded by this class loader * regardless of whether the parent class loader is being searched first * or not. */ private final Vector<String> loaderPackages = new Vector<>(); /** * Whether or not this classloader will ignore the base * classloader if it can't find a class. * * @see #setIsolated(boolean) */ private boolean ignoreBase = false; /** * The parent class loader, if one is given or can be determined. */ private ClassLoader parent = null; /** * A hashtable of zip files opened by the classloader (File to JarFile). */ private Hashtable<File, JarFile> jarFiles = new Hashtable<>(); /** Static map of jar file/time to manifest class-path entries */ private static Map<String, String> pathMap = Collections.synchronizedMap(new HashMap<>()); /** * The context loader saved when setting the thread's current * context loader. */ private ClassLoader savedContextLoader = null; /** * Whether or not the context loader is currently saved. */ private boolean isContextLoaderSaved = false; /** * Create an Ant ClassLoader for a given project, with * a parent classloader and an initial classpath. * @since Ant 1.7. * @param parent the parent for this classloader. * @param project The project to which this classloader is to * belong. * @param classpath The classpath to use to load classes. */ public AntClassLoader(final ClassLoader parent, final Project project, final Path classpath) { setParent(parent); setClassPath(classpath); setProject(project); } /** * Create an Ant Class Loader */ public AntClassLoader() { setParent(null); } /** * Creates a classloader for the given project using the classpath given. * * @param project The project to which this classloader is to belong. * Must not be <code>null</code>. * @param classpath The classpath to use to load the classes. This * is combined with the system classpath in a manner * determined by the value of ${build.sysclasspath}. * May be <code>null</code>, in which case no path * elements are set up to start with. */ public AntClassLoader(final Project project, final Path classpath) { setParent(null); setProject(project); setClassPath(classpath); } /** * Creates a classloader for the given project using the classpath given. * * @param parent The parent classloader to which unsatisfied loading * attempts are delegated. May be <code>null</code>, * in which case the classloader which loaded this * class is used as the parent. * @param project The project to which this classloader is to belong. * Must not be <code>null</code>. * @param classpath the classpath to use to load the classes. * May be <code>null</code>, in which case no path * elements are set up to start with. * @param parentFirst If <code>true</code>, indicates that the parent * classloader should be consulted before trying to * load the a class through this loader. */ public AntClassLoader(final ClassLoader parent, final Project project, final Path classpath, final boolean parentFirst) { this(project, classpath); if (parent != null) { setParent(parent); } setParentFirst(parentFirst); addJavaLibraries(); } /** * Creates a classloader for the given project using the classpath given. * * @param project The project to which this classloader is to belong. * Must not be <code>null</code>. * @param classpath The classpath to use to load the classes. May be * <code>null</code>, in which case no path * elements are set up to start with. * @param parentFirst If <code>true</code>, indicates that the parent * classloader should be consulted before trying to * load the a class through this loader. */ public AntClassLoader(final Project project, final Path classpath, final boolean parentFirst) { this(null, project, classpath, parentFirst); } /** * Creates an empty class loader. The classloader should be configured * with path elements to specify where the loader is to look for * classes. * * @param parent The parent classloader to which unsatisfied loading * attempts are delegated. May be <code>null</code>, * in which case the classloader which loaded this * class is used as the parent. * @param parentFirst If <code>true</code>, indicates that the parent * classloader should be consulted before trying to * load the a class through this loader. */ public AntClassLoader(final ClassLoader parent, final boolean parentFirst) { setParent(parent); project = null; this.parentFirst = parentFirst; } /** * Set the project associated with this class loader * * @param project the project instance */ public void setProject(final Project project) { this.project = project; if (project != null) { project.addBuildListener(this); } } /** * Set the classpath to search for classes to load. This should not be * changed once the classloader starts to server classes * * @param classpath the search classpath consisting of directories and * jar/zip files. */ public void setClassPath(final Path classpath) { pathComponents.removeAllElements(); if (classpath != null) { for (String pathElement : classpath.concatSystemClasspath("ignore").list()) { try { addPathElement(pathElement); } catch (final BuildException e) { // ignore path elements which are invalid // relative to the project log("Ignoring path element " + pathElement + " from " + "classpath due to exception " + e, Project.MSG_DEBUG); } } } } /** * Set the parent for this class loader. This is the class loader to which * this class loader will delegate to load classes * * @param parent the parent class loader. */ public void setParent(final ClassLoader parent) { this.parent = parent == null ? AntClassLoader.class.getClassLoader() : parent; } /** * Control whether class lookup is delegated to the parent loader first * or after this loader. Use with extreme caution. Setting this to * false violates the class loader hierarchy and can lead to Linkage errors * * @param parentFirst if true, delegate initial class search to the parent * classloader. */ public void setParentFirst(final boolean parentFirst) { this.parentFirst = parentFirst; } /** * Logs a message through the project object if one has been provided. * * @param message The message to log. * Should not be <code>null</code>. * * @param priority The logging priority of the message. */ protected void log(final String message, final int priority) { if (project != null) { project.log(message, priority); } else if (priority < Project.MSG_INFO) { System.err.println(message); } } /** * Sets the current thread's context loader to this classloader, storing * the current loader value for later resetting. */ public void setThreadContextLoader() { if (isContextLoaderSaved) { throw new BuildException("Context loader has not been reset"); } if (LoaderUtils.isContextLoaderAvailable()) { savedContextLoader = LoaderUtils.getContextClassLoader(); ClassLoader loader = this; if (project != null && "only".equals(project.getProperty(MagicNames.BUILD_SYSCLASSPATH))) { loader = this.getClass().getClassLoader(); } LoaderUtils.setContextClassLoader(loader); isContextLoaderSaved = true; } } /** * Resets the current thread's context loader to its original value. */ public void resetThreadContextLoader() { if (LoaderUtils.isContextLoaderAvailable() && isContextLoaderSaved) { LoaderUtils.setContextClassLoader(savedContextLoader); savedContextLoader = null; isContextLoaderSaved = false; } } /** * Adds an element to the classpath to be searched. * * @param pathElement The path element to add. Must not be * <code>null</code>. * * @exception BuildException if the given path element cannot be resolved * against the project. */ public void addPathElement(final String pathElement) throws BuildException { final File pathComponent = project != null ? project.resolveFile(pathElement) : new File( pathElement); try { addPathFile(pathComponent); } catch (final IOException e) { throw new BuildException(e); } } /** * Add a path component. * This simply adds the file, unlike addPathElement * it does not open jar files and load files from * their CLASSPATH entry in the manifest file. * @param file the jar file or directory to add. */ public void addPathComponent(final File file) { if (pathComponents.contains(file)) { return; } pathComponents.addElement(file); } /** * Add a file to the path. * Reads the manifest, if available, and adds any additional class path jars * specified in the manifest. * * @param pathComponent the file which is to be added to the path for * this class loader * * @throws IOException if data needed from the file cannot be read. */ protected void addPathFile(final File pathComponent) throws IOException { if (!pathComponents.contains(pathComponent)) { pathComponents.addElement(pathComponent); } if (pathComponent.isDirectory()) { return; } final String absPathPlusTimeAndLength = pathComponent.getAbsolutePath() + pathComponent.lastModified() + "-" + pathComponent.length(); String classpath = pathMap.get(absPathPlusTimeAndLength); if (classpath == null) { try (JarFile jarFile = newJarFile(pathComponent)) { final Manifest manifest = jarFile.getManifest(); if (manifest == null) { return; } classpath = manifest.getMainAttributes() .getValue(Attributes.Name.CLASS_PATH); } if (classpath == null) { classpath = ""; } pathMap.put(absPathPlusTimeAndLength, classpath); } if (!classpath.isEmpty()) { final URL baseURL = FILE_UTILS.getFileURL(pathComponent); final StringTokenizer st = new StringTokenizer(classpath); while (st.hasMoreTokens()) { final String classpathElement = st.nextToken(); final URL libraryURL = new URL(baseURL, classpathElement); if (!libraryURL.getProtocol().equals("file")) { log("Skipping jar library " + classpathElement + " since only relative URLs are supported by this" + " loader", Project.MSG_VERBOSE); continue; } final String decodedPath = Locator.decodeUri(libraryURL.getFile()); final File libraryFile = new File(decodedPath); if (libraryFile.exists() && !isInPath(libraryFile)) { addPathFile(libraryFile); } } } } /** * Returns the classpath this classloader will consult. * * @return the classpath used for this classloader, with elements * separated by the path separator for the system. */ public String getClasspath() { final StringBuilder sb = new StringBuilder(); for (final File component : pathComponents) { if (sb.length() > 0) { sb.append(File.pathSeparator); } sb.append(component.getAbsolutePath()); } return sb.toString(); } /** * Sets whether this classloader should run in isolated mode. In * isolated mode, classes not found on the given classpath will * not be referred to the parent class loader but will cause a * ClassNotFoundException. * * @param isolated Whether or not this classloader should run in * isolated mode. */ public synchronized void setIsolated(final boolean isolated) { ignoreBase = isolated; } /** * Forces initialization of a class in a JDK 1.1 compatible, albeit hacky * way. * * @param theClass The class to initialize. * Must not be <code>null</code>. * * @deprecated since 1.6.x. * Use Class.forName with initialize=true instead. */ @Deprecated public static void initializeClass(final Class<?> theClass) { // ***HACK*** We ask the VM to create an instance // by voluntarily providing illegal arguments to force // the VM to run the class' static initializer, while // at the same time not running a valid constructor. final Constructor<?>[] cons = theClass.getDeclaredConstructors(); //At least one constructor is guaranteed to be there, but check anyway. if (cons != null) { if (cons.length > 0 && cons[0] != null) { final String[] strs = new String[NUMBER_OF_STRINGS]; try { cons[0].newInstance((Object[]) strs); // Expecting an exception to be thrown by this call: // IllegalArgumentException: wrong number of Arguments } catch (final Exception e) { // Ignore - we are interested only in the side // effect - that of getting the static initializers // invoked. As we do not want to call a valid // constructor to get this side effect, an // attempt is made to call a hopefully // invalid constructor - come on, nobody // would have a constructor that takes in // 256 String arguments ;-) // (In fact, they can't - according to JVM spec // section 4.10, the number of method parameters is limited // to 255 by the definition of a method descriptor. // Constructors count as methods here.) } } } } /** * Adds a package root to the list of packages which must be loaded on the * parent loader. * * All subpackages are also included. * * @param packageRoot The root of all packages to be included. * Should not be <code>null</code>. */ public void addSystemPackageRoot(final String packageRoot) { systemPackages.addElement(packageRoot + (packageRoot.endsWith(".") ? "" : ".")); } /** * Adds a package root to the list of packages which must be loaded using * this loader. * * All subpackages are also included. * * @param packageRoot The root of all packages to be included. * Should not be <code>null</code>. */ public void addLoaderPackageRoot(final String packageRoot) { loaderPackages.addElement(packageRoot + (packageRoot.endsWith(".") ? "" : ".")); } /** * Loads a class through this class loader even if that class is available * on the parent classpath. * * This ensures that any classes which are loaded by the returned class * will use this classloader. * * @param classname The name of the class to be loaded. * Must not be <code>null</code>. * * @return the required Class object * * @exception ClassNotFoundException if the requested class does not exist * on this loader's classpath. */ public Class<?> forceLoadClass(final String classname) throws ClassNotFoundException { log("force loading " + classname, Project.MSG_DEBUG); Class<?> theClass = findLoadedClass(classname); if (theClass == null) { theClass = findClass(classname); } return theClass; } /** * Loads a class through this class loader but defer to the parent class * loader. * * This ensures that instances of the returned class will be compatible * with instances which have already been loaded on the parent * loader. * * @param classname The name of the class to be loaded. * Must not be <code>null</code>. * * @return the required Class object * * @exception ClassNotFoundException if the requested class does not exist * on this loader's classpath. */ public Class<?> forceLoadSystemClass(final String classname) throws ClassNotFoundException { log("force system loading " + classname, Project.MSG_DEBUG); Class<?> theClass = findLoadedClass(classname); if (theClass == null) { theClass = findBaseClass(classname); } return theClass; } /** * Returns a stream to read the requested resource name. * * @param name The name of the resource for which a stream is required. * Must not be <code>null</code>. * * @return a stream to the required resource or <code>null</code> if the * resource cannot be found on the loader's classpath. */ @Override public InputStream getResourceAsStream(final String name) { InputStream resourceStream = null; if (isParentFirst(name)) { resourceStream = loadBaseResource(name); } if (resourceStream != null) { log("ResourceStream for " + name + " loaded from parent loader", Project.MSG_DEBUG); } else { resourceStream = loadResource(name); if (resourceStream != null) { log("ResourceStream for " + name + " loaded from ant loader", Project.MSG_DEBUG); } } if (resourceStream == null && !isParentFirst(name)) { if (ignoreBase) { resourceStream = getRootLoader() == null ? null : getRootLoader().getResourceAsStream(name); } else { resourceStream = loadBaseResource(name); } if (resourceStream != null) { log("ResourceStream for " + name + " loaded from parent loader", Project.MSG_DEBUG); } } if (resourceStream == null) { log("Couldn't load ResourceStream for " + name, Project.MSG_DEBUG); } return resourceStream; } /** * Returns a stream to read the requested resource name from this loader. * * @param name The name of the resource for which a stream is required. * Must not be <code>null</code>. * * @return a stream to the required resource or <code>null</code> if * the resource cannot be found on the loader's classpath. */ private InputStream loadResource(final String name) { // we need to search the components of the path to see if we can // find the class we want. return pathComponents.stream().map(path -> getResourceStream(path, name)) .filter(Objects::nonNull).findFirst().orElse(null); } /** * Finds a system resource (which should be loaded from the parent * classloader). * * @param name The name of the system resource to load. * Must not be <code>null</code>. * * @return a stream to the named resource, or <code>null</code> if * the resource cannot be found. */ private InputStream loadBaseResource(final String name) { return parent == null ? super.getResourceAsStream(name) : parent.getResourceAsStream(name); } /** * Returns an inputstream to a given resource in the given file which may * either be a directory or a zip file. * * @param file the file (directory or jar) in which to search for the * resource. Must not be <code>null</code>. * @param resourceName The name of the resource for which a stream is * required. Must not be <code>null</code>. * * @return a stream to the required resource or <code>null</code> if * the resource cannot be found in the given file. */ private InputStream getResourceStream(final File file, final String resourceName) { try { JarFile jarFile = jarFiles.get(file); if (jarFile == null && file.isDirectory()) { final File resource = new File(file, resourceName); if (resource.exists()) { return Files.newInputStream(resource.toPath()); } } else { if (jarFile == null) { if (file.exists()) { jarFile = newJarFile(file); jarFiles.put(file, jarFile); } else { return null; } //to eliminate a race condition, retrieve the entry //that is in the hash table under that filename jarFile = jarFiles.get(file); } final JarEntry entry = jarFile.getJarEntry(resourceName); if (entry != null) { return jarFile.getInputStream(entry); } } } catch (final Exception e) { log("Ignoring Exception " + e.getClass().getName() + ": " + e.getMessage() + " reading resource " + resourceName + " from " + file, Project.MSG_VERBOSE); } return null; } /** * Tests whether or not the parent classloader should be checked for a * resource before this one. If the resource matches both the "use parent * classloader first" and the "use this classloader first" lists, the latter * takes priority. * * @param resourceName * The name of the resource to check. Must not be * <code>null</code>. * * @return whether or not the parent classloader should be checked for a * resource before this one is. */ private boolean isParentFirst(final String resourceName) { // default to the global setting and then see // if this class belongs to a package which has been // designated to use a specific loader first // (this one or the parent one) // TODO - shouldn't this always return false in isolated mode? return loaderPackages.stream().noneMatch(resourceName::startsWith) && (systemPackages.stream().anyMatch(resourceName::startsWith) || parentFirst); } /** * Used for isolated resource searching. * @return the root classloader of AntClassLoader. */ private ClassLoader getRootLoader() { ClassLoader ret = getClass().getClassLoader(); while (ret != null && ret.getParent() != null) { ret = ret.getParent(); } return ret; } /** * Finds the resource with the given name. A resource is * some data (images, audio, text, etc) that can be accessed by class * code in a way that is independent of the location of the code. * * @param name The name of the resource for which a stream is required. * Must not be <code>null</code>. * * @return a URL for reading the resource, or <code>null</code> if the * resource could not be found or the caller doesn't have * adequate privileges to get the resource. */ @Override public URL getResource(final String name) { // we need to search the components of the path to see if // we can find the class we want. URL url = null; if (isParentFirst(name)) { url = parent == null ? super.getResource(name) : parent.getResource(name); } if (url != null) { log("Resource " + name + " loaded from parent loader", Project.MSG_DEBUG); } else { // try and load from this loader if the parent either didn't find // it or wasn't consulted. for (final File pathComponent : pathComponents) { url = getResourceURL(pathComponent, name); if (url != null) { log("Resource " + name + " loaded from ant loader", Project.MSG_DEBUG); break; } } } if (url == null && !isParentFirst(name)) { // this loader was first but it didn't find it - try the parent if (ignoreBase) { url = getRootLoader() == null ? null : getRootLoader().getResource(name); } else { url = parent == null ? super.getResource(name) : parent.getResource(name); } if (url != null) { log("Resource " + name + " loaded from parent loader", Project.MSG_DEBUG); } } if (url == null) { log("Couldn't load Resource " + name, Project.MSG_DEBUG); } return url; } /** * Finds all the resources with the given name. A resource is some * data (images, audio, text, etc) that can be accessed by class * code in a way that is independent of the location of the code. * * <p>Would override getResources if that wasn't final in Java * 1.4.</p> * * @param name name of the resource * @return possible URLs as enumeration * @throws IOException if something goes wrong * @see #findResources(String, boolean) * @since Ant 1.8.0 */ public Enumeration<URL> getNamedResources(final String name) throws IOException { return findResources(name, false); } /** * Returns an enumeration of URLs representing all the resources with the * given name by searching the class loader's classpath. * * @param name The resource name to search for. * Must not be <code>null</code>. * @return an enumeration of URLs for the resources * @exception IOException if I/O errors occurs (can't happen) */ @Override protected Enumeration<URL> findResources(final String name) throws IOException { return findResources(name, true); } /** * Returns an enumeration of URLs representing all the resources with the * given name by searching the class loader's classpath. * * @param name The resource name to search for. * Must not be <code>null</code>. * @param parentHasBeenSearched whether ClassLoader.this.parent * has been searched - will be true if the method is (indirectly) * called from ClassLoader.getResources * @return an enumeration of URLs for the resources * @exception IOException if I/O errors occurs (can't happen) */ protected Enumeration<URL> findResources(final String name, final boolean parentHasBeenSearched) throws IOException { final Enumeration<URL> mine = new ResourceEnumeration(name); Enumeration<URL> base; if (parent != null && (!parentHasBeenSearched || parent != getParent())) { // Delegate to the parent: base = parent.getResources(name); // Note: could cause overlaps in case // ClassLoader.this.parent has matches and // parentHasBeenSearched is true } else { // ClassLoader.this.parent is already delegated to for example from // ClassLoader.getResources, no need: base = Collections.emptyEnumeration(); } if (isParentFirst(name)) { // Normal case. return append(base, mine); } if (ignoreBase) { return getRootLoader() == null ? mine : append(mine, getRootLoader().getResources(name)); } // parent last: return append(mine, base); } private static Enumeration<URL> append(Enumeration<URL> one, Enumeration<URL> two) { return Stream.concat(Collections.list(one).stream(), Collections.list(two).stream()) .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::enumeration)); } /** * Returns the URL of a given resource in the given file which may * either be a directory or a zip file. * * @param file The file (directory or jar) in which to search for * the resource. Must not be <code>null</code>. * @param resourceName The name of the resource for which a stream * is required. Must not be <code>null</code>. * * @return a stream to the required resource or <code>null</code> if the * resource cannot be found in the given file object. */ protected URL getResourceURL(final File file, final String resourceName) { try { JarFile jarFile = jarFiles.get(file); if (jarFile == null && file.isDirectory()) { final File resource = new File(file, resourceName); if (resource.exists()) { try { return FILE_UTILS.getFileURL(resource); } catch (final MalformedURLException ex) { return null; } } } else { if (jarFile == null) { if (file.exists()) { if (!isZip(file)) { final String msg = "CLASSPATH element " + file + " is not a JAR."; log(msg, Project.MSG_WARN); return null; } jarFile = newJarFile(file); jarFiles.put(file, jarFile); } else { return null; } // potential race-condition jarFile = jarFiles.get(file); } final JarEntry entry = jarFile.getJarEntry(resourceName); if (entry != null) { try { return new URL("jar:" + FILE_UTILS.getFileURL(file) + "!/" + entry); } catch (final MalformedURLException ex) { return null; } } } } catch (final Exception e) { final String msg = "Unable to obtain resource from " + file + ": "; log(msg + e, Project.MSG_WARN); log(StringUtils.getStackTrace(e), Project.MSG_WARN); } return null; } /** * Loads a class with this class loader. * * This class attempts to load the class in an order determined by whether * or not the class matches the system/loader package lists, with the * loader package list taking priority. If the classloader is in isolated * mode, failure to load the class in this loader will result in a * ClassNotFoundException. * * @param classname The name of the class to be loaded. * Must not be <code>null</code>. * @param resolve <code>true</code> if all classes upon which this class * depends are to be loaded. * * @return the required Class object * * @exception ClassNotFoundException if the requested class does not exist * on the system classpath (when not in isolated mode) or this loader's * classpath. */ @Override protected synchronized Class<?> loadClass(final String classname, final boolean resolve) throws ClassNotFoundException { // 'sync' is needed - otherwise 2 threads can load the same class // twice, resulting in LinkageError: duplicated class definition. // findLoadedClass avoids that, but without sync it won't work. Class<?> theClass = findLoadedClass(classname); if (theClass != null) { return theClass; } if (isParentFirst(classname)) { try { theClass = findBaseClass(classname); log("Class " + classname + " loaded from parent loader " + "(parentFirst)", Project.MSG_DEBUG); } catch (final ClassNotFoundException cnfe) { theClass = findClass(classname); log("Class " + classname + " loaded from ant loader " + "(parentFirst)", Project.MSG_DEBUG); } } else { try { theClass = findClass(classname); log("Class " + classname + " loaded from ant loader", Project.MSG_DEBUG); } catch (final ClassNotFoundException cnfe) { if (ignoreBase) { throw cnfe; } theClass = findBaseClass(classname); log("Class " + classname + " loaded from parent loader", Project.MSG_DEBUG); } } if (resolve) { resolveClass(theClass); } return theClass; } /** * Converts the class dot notation to a filesystem equivalent for * searching purposes. * * @param classname The class name in dot format (eg java.lang.Integer). * Must not be <code>null</code>. * * @return the classname in filesystem format (eg java/lang/Integer.class) */ private String getClassFilename(final String classname) { return classname.replace('.', '/') + ".class"; } /** * Define a class given its bytes * * @param container the container from which the class data has been read * may be a directory or a jar/zip file. * * @param classData the bytecode data for the class * @param classname the name of the class * * @return the Class instance created from the given data * * @throws IOException if the class data cannot be read. */ protected Class<?> defineClassFromData(final File container, final byte[] classData, final String classname) throws IOException { definePackage(container, classname); final ProtectionDomain currentPd = Project.class.getProtectionDomain(); final String classResource = getClassFilename(classname); final CodeSource src = new CodeSource(FILE_UTILS.getFileURL(container), getCertificates(container, classResource)); final ProtectionDomain classesPd = new ProtectionDomain(src, currentPd.getPermissions(), this, currentPd.getPrincipals()); return defineClass(classname, classData, 0, classData.length, classesPd); } /** * Define the package information associated with a class. * * @param container the file containing the class definition. * @param className the class name of for which the package information * is to be determined. * * @exception IOException if the package information cannot be read from the * container. */ protected void definePackage(final File container, final String className) throws IOException { final int classIndex = className.lastIndexOf('.'); if (classIndex == -1) { return; } final String packageName = className.substring(0, classIndex); if (getPackage(packageName) != null) { // already defined return; } // define the package now final Manifest manifest = getJarManifest(container); if (manifest == null) { definePackage(packageName, null, null, null, null, null, null, null); } else { definePackage(container, packageName, manifest); } } /** * Get the manifest from the given jar, if it is indeed a jar and it has a * manifest * * @param container the File from which a manifest is required. * * @return the jar's manifest or null is the container is not a jar or it * has no manifest. * * @exception IOException if the manifest cannot be read. */ private Manifest getJarManifest(final File container) throws IOException { if (container.isDirectory()) { return null; } final JarFile jarFile = jarFiles.get(container); if (jarFile == null) { return null; } return jarFile.getManifest(); } /** * Get the certificates for a given jar entry, if it is indeed a jar. * * @param container the File from which to read the entry * @param entry the entry of which the certificates are requested * * @return the entry's certificates or null is the container is * not a jar or it has no certificates. */ private Certificate[] getCertificates(final File container, final String entry) { if (container.isDirectory()) { return null; } final JarFile jarFile = jarFiles.get(container); if (jarFile == null) { return null; } final JarEntry ent = jarFile.getJarEntry(entry); return ent == null ? null : ent.getCertificates(); } /** * Define the package information when the class comes from a * jar with a manifest * * @param container the jar file containing the manifest * @param packageName the name of the package being defined. * @param manifest the jar's manifest */ protected void definePackage(final File container, final String packageName, final Manifest manifest) { final String sectionName = packageName.replace('.', '/') + "/"; String specificationTitle = null; String specificationVendor = null; String specificationVersion = null; String implementationTitle = null; String implementationVendor = null; String implementationVersion = null; String sealedString = null; URL sealBase = null; final Attributes sectionAttributes = manifest.getAttributes(sectionName); if (sectionAttributes != null) { specificationTitle = sectionAttributes.getValue(Name.SPECIFICATION_TITLE); specificationVendor = sectionAttributes.getValue(Name.SPECIFICATION_VENDOR); specificationVersion = sectionAttributes.getValue(Name.SPECIFICATION_VERSION); implementationTitle = sectionAttributes.getValue(Name.IMPLEMENTATION_TITLE); implementationVendor = sectionAttributes.getValue(Name.IMPLEMENTATION_VENDOR); implementationVersion = sectionAttributes.getValue(Name.IMPLEMENTATION_VERSION); sealedString = sectionAttributes.getValue(Name.SEALED); } final Attributes mainAttributes = manifest.getMainAttributes(); if (mainAttributes != null) { if (specificationTitle == null) { specificationTitle = mainAttributes.getValue(Name.SPECIFICATION_TITLE); } if (specificationVendor == null) { specificationVendor = mainAttributes.getValue(Name.SPECIFICATION_VENDOR); } if (specificationVersion == null) { specificationVersion = mainAttributes.getValue(Name.SPECIFICATION_VERSION); } if (implementationTitle == null) { implementationTitle = mainAttributes.getValue(Name.IMPLEMENTATION_TITLE); } if (implementationVendor == null) { implementationVendor = mainAttributes.getValue(Name.IMPLEMENTATION_VENDOR); } if (implementationVersion == null) { implementationVersion = mainAttributes.getValue(Name.IMPLEMENTATION_VERSION); } if (sealedString == null) { sealedString = mainAttributes.getValue(Name.SEALED); } } if (sealedString != null && sealedString.equalsIgnoreCase("true")) { try { sealBase = new URL(FileUtils.getFileUtils().toURI(container.getAbsolutePath())); } catch (final MalformedURLException e) { // ignore } } definePackage(packageName, specificationTitle, specificationVersion, specificationVendor, implementationTitle, implementationVersion, implementationVendor, sealBase); } /** * Reads a class definition from a stream. * * @param stream The stream from which the class is to be read. * Must not be <code>null</code>. * @param classname The name of the class in the stream. * Must not be <code>null</code>. * @param container the file or directory containing the class. * * @return the Class object read from the stream. * * @exception IOException if there is a problem reading the class from the * stream. * @exception SecurityException if there is a security problem while * reading the class from the stream. */ private Class<?> getClassFromStream(final InputStream stream, final String classname, final File container) throws IOException, SecurityException { final ByteArrayOutputStream baos = new ByteArrayOutputStream(); int bytesRead = -1; final byte[] buffer = new byte[BUFFER_SIZE]; while ((bytesRead = stream.read(buffer, 0, BUFFER_SIZE)) != -1) { baos.write(buffer, 0, bytesRead); } final byte[] classData = baos.toByteArray(); return defineClassFromData(container, classData, classname); } /** * Searches for and load a class on the classpath of this class loader. * * @param name The name of the class to be loaded. Must not be * <code>null</code>. * * @return the required Class object * * @exception ClassNotFoundException if the requested class does not exist * on this loader's classpath. */ @Override public Class<?> findClass(final String name) throws ClassNotFoundException { log("Finding class " + name, Project.MSG_DEBUG); return findClassInComponents(name); } /** * Indicate if the given file is in this loader's path * * @param component the file which is to be checked * * @return true if the file is in the class path */ protected boolean isInPath(final File component) { return pathComponents.contains(component); } /** * Finds a class on the given classpath. * * @param name The name of the class to be loaded. Must not be * <code>null</code>. * * @return the required Class object * * @exception ClassNotFoundException if the requested class does not exist * on this loader's classpath. */ private Class<?> findClassInComponents(final String name) throws ClassNotFoundException { // we need to search the components of the path to see if // we can find the class we want. final String classFilename = getClassFilename(name); for (final File pathComponent : pathComponents) { try (InputStream stream = getResourceStream(pathComponent, classFilename)) { if (stream != null) { log("Loaded from " + pathComponent + " " + classFilename, Project.MSG_DEBUG); return getClassFromStream(stream, name, pathComponent); } } catch (final SecurityException se) { throw se; } catch (final IOException ioe) { // ioe.printStackTrace(); log("Exception reading component " + pathComponent + " (reason: " + ioe.getMessage() + ")", Project.MSG_VERBOSE); } } throw new ClassNotFoundException(name); } /** * Finds a system class (which should be loaded from the same classloader * as the Ant core). * * For JDK 1.1 compatibility, this uses the findSystemClass method if * no parent classloader has been specified. * * @param name The name of the class to be loaded. * Must not be <code>null</code>. * * @return the required Class object * * @exception ClassNotFoundException if the requested class does not exist * on this loader's classpath. */ private Class<?> findBaseClass(final String name) throws ClassNotFoundException { return parent == null ? findSystemClass(name) : parent.loadClass(name); } /** * Cleans up any resources held by this classloader. Any open archive * files are closed. */ public synchronized void cleanup() { for (final JarFile jarFile : jarFiles.values()) { FileUtils.close(jarFile); } jarFiles = new Hashtable<>(); if (project != null) { project.removeBuildListener(this); } project = null; } /** * Gets the parent as has been specified in the constructor or via * setParent. * * @return classloader * @since Ant 1.8.0 */ public ClassLoader getConfiguredParent() { return parent; } /** * Empty implementation to satisfy the BuildListener interface. * * @param event the buildStarted event */ public void buildStarted(final BuildEvent event) { // Not significant for the class loader. } /** * Cleans up any resources held by this classloader at the end * of a build. * * @param event the buildFinished event */ public void buildFinished(final BuildEvent event) { cleanup(); } /** * Cleans up any resources held by this classloader at the end of * a subbuild if it has been created for the subbuild's project * instance. * * @param event the buildFinished event * * @since Ant 1.6.2 */ public void subBuildFinished(final BuildEvent event) { if (event.getProject() == project) { cleanup(); } } /** * Empty implementation to satisfy the BuildListener interface. * * @param event the buildStarted event * * @since Ant 1.6.2 */ public void subBuildStarted(final BuildEvent event) { // Not significant for the class loader. } /** * Empty implementation to satisfy the BuildListener interface. * * @param event the targetStarted event */ public void targetStarted(final BuildEvent event) { // Not significant for the class loader. } /** * Empty implementation to satisfy the BuildListener interface. * * @param event the targetFinished event */ public void targetFinished(final BuildEvent event) { // Not significant for the class loader. } /** * Empty implementation to satisfy the BuildListener interface. * * @param event the taskStarted event */ public void taskStarted(final BuildEvent event) { // Not significant for the class loader. } /** * Empty implementation to satisfy the BuildListener interface. * * @param event the taskFinished event */ public void taskFinished(final BuildEvent event) { // Not significant for the class loader. } /** * Empty implementation to satisfy the BuildListener interface. * * @param event the messageLogged event */ public void messageLogged(final BuildEvent event) { // Not significant for the class loader. } /** * add any libraries that come with different java versions * here */ public void addJavaLibraries() { JavaEnvUtils.getJrePackages().forEach(this::addSystemPackageRoot); } /** * Returns a <code>String</code> representing this loader. * @return the path that this classloader has. */ @Override public String toString() { return "AntClassLoader[" + getClasspath() + "]"; } /** {@inheritDoc} */ @Override public Enumeration<URL> getResources(String name) throws IOException { return getNamedResources(name); } /** {@inheritDoc} */ public void close() { cleanup(); } /** * Factory method * * @param parent ClassLoader * @param project Project * @param path Path * @param parentFirst boolean * @return AntClassLoader */ public static AntClassLoader newAntClassLoader(final ClassLoader parent, final Project project, final Path path, final boolean parentFirst) { return new AntClassLoader(parent, project, path, parentFirst); } private static final ZipLong EOCD_SIG = new ZipLong(0X06054B50L); private static final ZipLong SINGLE_SEGMENT_SPLIT_MARKER = new ZipLong(0X30304B50L); private static boolean isZip(final File file) throws IOException { final byte[] sig = new byte[4]; if (readFully(file, sig)) { final ZipLong start = new ZipLong(sig); return ZipLong.LFH_SIG.equals(start) // normal file || EOCD_SIG.equals(start) // empty zip || ZipLong.DD_SIG.equals(start) // split zip || SINGLE_SEGMENT_SPLIT_MARKER.equals(start); } return false; } private static boolean readFully(final File f, final byte[] b) throws IOException { try (InputStream fis = Files.newInputStream(f.toPath())) { final int len = b.length; int count = 0, x = 0; while (count != len) { x = fis.read(b, count, len - count); if (x == -1) { break; } count += x; } return count == len; } } /** * * @param file The file representing the jar * @return Returns a {@link JarFile} instance, which is constructed based upon the Java runtime version. * Depending on the Java runtime version, the returned instance may or may not be {@code multi-release} * aware (a feature introduced in Java 9) * @throws IOException */ private static JarFile newJarFile(final File file) throws IOException { if (!IS_ATLEAST_JAVA9 || MR_JARFILE_CTOR_ARGS == null || MR_JARFILE_CTOR_RUNTIME_VERSION_VAL == null) { return new JarFile(file); } return ReflectUtil.newInstance(JarFile.class, MR_JARFILE_CTOR_ARGS, new Object[] {file, true, ZipFile.OPEN_READ, MR_JARFILE_CTOR_RUNTIME_VERSION_VAL}); } }
⏎ org/apache/tools/ant/AntClassLoader.java
Or download all of them as a single archive file:
File name: apache-ant-1.10.10-fyi.zip File size: 2392938 bytes Release date: 2021-04-17 Download
⇐ Download Apache Ant Source Package
2021-07-10, 109797👍, 0💬
Popular Posts:
How to download and install JDK (Java Development Kit) 7? If you want to write Java applications, yo...
JDK 11 java.rmi.jmod is the JMOD file for JDK 11 RMI (Remote Method Invocation) module. JDK 11 RMI m...
How to download and install ojdbc11.jar for Oracle 21c? ojdbc11.jar for Oracle 21c is a Java JDBC Dr...
JDK 11 jdk.jlink.jmod is the JMOD file for JDK 11 JLink tool, which can be invoked by the "jlink" co...
How to display XML element type information with the jaxp\TypeInfoWriter.java provided in the Apache...