public List<Properties> getJarProperties() throws IOException { ResolverUtil resolver = new ResolverUtil(); List<Properties> poms = new ArrayList<Properties>(); resolver.findNamedResource("pom.properties", "META-INF/maven"); Set<URL> urls = resolver.getResources(); for (URL url : urls) { Properties p = new Properties(); p.load(url.openStream()); poms.add(p); } return poms; } }
/** * Attempts to discover classes that pass the test. Accumulated * classes can be accessed by calling {@link #getClasses()}. * * @param test the test to determine matching classes * @param packageNames one or more package names to scan (including subpackages) for classes */ public void find(Test test, String... packageNames) { if (packageNames == null) return; for (String pkg : packageNames) { findInPackage(test, pkg); } }
/** * Finds matches in a physical directory on a filesystem. Examines all * files within a directory - if the File object is not a directory, and ends with <i>.class</i> * the file is loaded and tested to see if it is acceptable according to the Test. Operates * recursively to find classes within a folder structure matching the package structure. * * @param test a Test used to filter the classes that are discovered * @param parent the package name up to this directory in the package hierarchy. E.g. if * /classes is in the classpath and we wish to examine files in /classes/org/apache then * the values of <i>parent</i> would be <i>org/apache</i> * @param location a File object representing a directory */ private void loadImplementationsInDirectory(Test test, String parent, File location) { File[] files = location.listFiles(); StringBuilder builder = null; for (File file : files) { builder = new StringBuilder(100); builder.append(parent).append("/").append(file.getName()); String packageOrClass = ( parent == null ? file.getName() : builder.toString() ); if (file.isDirectory()) { loadImplementationsInDirectory(test, packageOrClass, file); } else if (isTestApplicable(test, file.getName())) { addIfMatching(test, packageOrClass); } } }
ClassLoader loader = getClassLoader(); Enumeration<URL> urls; loadImplementationsInDirectory(test, packageName, file); loadImplementationsInJar(test, packageName, file);
/** * Finds matching classes within a jar files that contains a folder structure * matching the package structure. If the File is not a JarFile or does not exist a warning * will be logged, but no error will be raised. * * @param test a Test used to filter the classes that are discovered * @param parent the parent package under which classes must be in order to be considered * @param jarfile the jar file to be examined for classes */ private void loadImplementationsInJar(Test test, String parent, File jarfile) { try { JarEntry entry; JarInputStream jarStream = new JarInputStream(new FileInputStream(jarfile)); while ( (entry = jarStream.getNextJarEntry() ) != null) { String name = entry.getName(); if (!entry.isDirectory() && name.startsWith(parent) && isTestApplicable(test, name)) { addIfMatching(test, name); } } } catch (IOException ioe) { LOG.error("Could not search jar file '" + jarfile + "' for classes matching criteria: " + test + " due to an IOException", ioe); } }
ClassLoader loader = getClassLoader(); if (test.doesMatchClass()) { String externalName = fqn.substring(0, fqn.indexOf('.')).replace('/', '.');
public void findNamedResource(String name, String... pathNames) { if (pathNames == null) return; Test test = new NameIs(name); for (String pkg : pathNames) { findInPackage(test, pkg); } }
/** * Attempts to discover classes that are annotated with to the annotation. Accumulated * classes can be accessed by calling {@link #getClasses()}. * * @param annotation the annotation that should be present on matching classes * @param packageNames one or more package names to scan (including subpackages) for classes */ public void findAnnotated(Class<? extends Annotation> annotation, String... packageNames) { if (packageNames == null) return; Test test = new AnnotatedWith(annotation); for (String pkg : packageNames) { findInPackage(test, pkg); } }
/** * Attempts to discover classes who's name ends with the provided suffix. Accumulated classes can be * accessed by calling {@link #getClasses()}. * * @param suffix The class name suffix to match * @param packageNames one or more package names to scan (including subpackages) for classes */ public void findSuffix(String suffix, String... packageNames) { if (packageNames == null) return; Test test = new NameEndsWith(suffix); for (String pkg : packageNames) { findInPackage(test, pkg); } }
/** * Attempts to discover classes that are assignable to the type provided. In the case * that an interface is provided this method will collect implementations. In the case * of a non-interface class, subclasses will be collected. Accumulated classes can be * accessed by calling {@link #getClasses()}. * * @param parent the class of interface to find subclasses or implementations of * @param packageNames one or more package names to scan (including subpackages) for classes */ public void findImplementations(Class parent, String... packageNames) { if (packageNames == null) return; Test test = new IsA(parent); for (String pkg : packageNames) { findInPackage(test, pkg); } }