Basic idea behind this utility class is to use it from inside the + * different ant objects (and user defined objects) that need dclassLoading + * for their operation. + * Normally those would have a setClasspathRef() {for the @@classpathref} + * and/or a createClasspath() {for the nested <classpath>} + * Typically one would have
+ * + *
+ * public void setClasspathRef(Reference r) {
+ * this.classpathId = r.getRefId();
+ * createClasspath().setRefid(r);
+ * }
+ *
+ * public Path createClasspath() {
+ * if (this.classpath == null) {
+ * this.classpath = new Path(getProject());
+ * }
+ * return this.classpath.createPath();
+ * }
+ *
+ * public void setClassname(String fqcn) {
+ * this.classname = fqcn;
+ * }
+ * when you actually need the classloading you can just:
+ * + *
+ * ClassLoader cl = ClasspathUtils.getClassLoaderForPath(this.classpath, this.classpathId);
+ * Object o = ClasspathUtils.newInstance(this.classname, cl);
+ * Assumes the logical 'false' for the reverseLoader.
+ * + * @param path + * @param pathId + * @return + */ + public static ClassLoader getClassLoaderForPath(Project p, Reference ref) { + return getClassLoaderForPath(p, ref, false); + } + + /** + * Convenience overloaded version of {@link #geClassLoader(Path, + * String, boolean)}. + * + *Delegates to the other one after extracting the referenced + * Path from the Project This checks also that the passed + * Reference is pointing to a Path all right.
+ * @param p current ant project + * @param ref Reference to Path structure + * @param reverseLoader if set to true this new loader will take + * precedence over it's parent (which is contra the regular + * classloader behaviour) + * @return + */ + public static ClassLoader getClassLoaderForPath(Project p, Reference ref, + boolean reverseLoader) { + String pathId = ref.getRefId(); + Object path = p.getReference(pathId); + if (!(path instanceof Path)){ + throw new BuildException ("The specified classpathref " + pathId + + " does not reference a Path."); + } + return getClassLoaderForPath((Path)path, pathId, reverseLoader); + } + + /** + * Convenience overloaded version of {@link + * #getClassLoaderForPath(Path, String, boolean)}. + * + *Assumes the logical 'false' for the reverseLoader.
+ * + * @param path + * @param pathId + * @return + */ + public static ClassLoader getClassLoaderForPath(Path path, String pathId){ + return getClassLoaderForPath(path, pathId, false); + } + + /** + * Gets a classloader that loads classes from the classpath + * defined in the path argument. + * + *Based on the setting of the magic property + * 'ant.reuse.loader' this will try to reuse the perviously + * created loader with that id, and of course store it there upon + * creation.
+ * @param path Path object to be used as classpath for this classloader + * @param pathId identification for this Path, will be used to + * identify the classLoader as well. + * @param reverseLoader if set to true this new loader will take + * precedence over it's parent (which is contra the regular + * classloader behaviour) + * @return ClassLoader that uses the Path as its classpath. + */ + public static ClassLoader getClassLoaderForPath(Path path, String pathId, + boolean reverseLoader) { + ClassLoader cl = null; + Project p = path.getProject(); + String loaderId = LOADER_ID_PREFIX + pathId; + // code stolen from o.a.t.a.taskdefs.Definer, might be a todo + // to remove it there didn't look at the reverse loader stuff + // however (todo that first) + + // magic property + if (p.getProperty(REUSE_LOADER_REF) != null) { + //chose not to do the extra instanceof checking here, consider it + // a programming error and not a config error if this fails + // so I assume the RuntimeException is OK + cl = (ClassLoader)p.getReference(loaderId); + } + if (cl == null){ + cl = getUniqueClassLoaderForPath(path, reverseLoader); + p.addReference(loaderId, cl); + } + + return cl; + } + + /** + * Gets a fresh, different, not used before classloader that uses the + * passed path as it's classpath. + * + *This method completely ignores the ant.reuse.loader magic + * property and should be used with caution.
+ * @param path the classpath for this loader + * @param reverseLoader + * @return + */ + public static ClassLoader getUniqueClassLoaderForPath(Path path, + boolean reverseLoader) { + ClassLoader cl = null; + Project p = path.getProject(); + + AntClassLoader acl = p.createClassLoader(Path.systemClasspath); + if (reverseLoader) { + acl.setParentFirst(false); + acl.addJavaLibraries(); + } + + return cl; + } + + public static Object newInstance(String className, + ClassLoader userDefinedLoader){ + try { + Class clazz = userDefinedLoader.loadClass(className); + Object o = clazz.newInstance(); + return o; + } catch (ClassNotFoundException e) { + throw new BuildException("Class " + className + + " not found by the specific classLoader.", + e); + } catch (InstantiationException e) { + throw new BuildException("Could not instantiate " + className + + ". Specified class should have a no " + + "argument constructor.", e); + } catch (IllegalAccessException e) { + throw new BuildException("Could not instantiate " + className + + ". Specified class should have a " + + "public constructor.", e); + } + } + +}