public static ScanParams in(String... packages) { return new ScanParams().in(packages); }
@SuppressWarnings("unchecked") public static ScanParams annotated(Collection<Class<? extends Annotation>> annotated) { return new ScanParams().annotated(annotated); }
public static ScanParams classLoader(ClassLoader classLoader) { return new ScanParams().classLoader(classLoader); }
public static ScanParams classpath(String... classpath) { return new ScanParams().classpath(classpath); }
private static List<String> scanClasses(ScanParams params) { String[] pkgs = params.in(); String rootPackage = ClasspathUtil.getRootPackage(); if (U.isEmpty(pkgs)) { pkgs = rootPackage != null ? new String[]{rootPackage} : new String[]{""}; } long startingAt = U.time(); String regex = params.matching(); Pattern pattern = U.notEmpty(regex) ? Pattern.compile(regex) : null; if (regex != null) { Log.info("Scanning classpath", "!annotated", Msc.annotations(params.annotated()), "!packages", Arrays.toString(pkgs), "!matching", regex); } else { Log.info("Scanning classpath", "!annotated", Msc.annotations(params.annotated()), "!packages", Arrays.toString(pkgs)); } Set<String> classpath = U.notEmpty(params.classpath()) ? U.set(params.classpath()) : ClasspathUtil.getClasspath(); AtomicInteger searched = new AtomicInteger(); Set<String> classes = U.set(); for (String pkg : pkgs) { classes.addAll(retrieveClasses(classpath, pkg, params.annotated(), params.bytecodeFilter(), pattern, params.classLoader(), searched)); } List<String> classList = U.list(classes); long timeMs = U.time() - startingAt; Log.info("Finished classpath scan", "time", Msc.maybeMasked(timeMs) + "ms", "searched", searched.get(), "!found", Msc.classNames(classList)); return classList; }
@SuppressWarnings("unchecked") public static synchronized List<String> getEntityTypes(String packages[], Class<?>... entities) { List<String> entityTypes = Scan.annotated(Entity.class).in(packages).getAll(); for (Class<?> entity : entities) { String type = entity.getName(); if (!entityTypes.contains(type)) { entityTypes.add(type); } } if (!entityTypes.isEmpty()) { Log.info("!Found " + entityTypes.size() + " JPA Entities"); } return entityTypes; }
public static List<Class<?>> scanClasses(ScanParams params) { String packageName = U.or(params.pkg(), ""); long startingAt = U.time(); String regex = params.matching(); Pattern pattern = regex != null ? Pattern.compile(regex) : null; Log.info("Retrieving classes", "annotated", params.annotated(), "package", packageName, "matching", regex); List<Class<?>> classes = retrieveClasses(packageName, params.filter(), params.annotated(), pattern, params.classLoader()); long timeMs = U.time() - startingAt; Log.info("Finished classpath scan", "time", timeMs + "ms", "classes", classes); return classes; }
public ScanParams in(Iterable<String> packages) { return in(U.arrayOf(String.class, packages)); }
private static void scanForMainClass(String path, Collection<String> mainClasses) { mainClasses.addAll(Scan.classpath(path).bytecodeFilter(input -> hasMainMethod(new ClassFile(new DataInputStream(input)))).getAll()); }
public static ScanParams matching(String matching) { return new ScanParams().matching(matching); }
public static ScanParams bytecodeFilter(Predicate<InputStream> bytecodeFilter) { return new ScanParams().bytecodeFilter(bytecodeFilter); }
public void forEach(Operation<Class<?>> classOperation) { for (Class<?> cls : loadAll()) { try { classOperation.execute(cls); } catch (Exception e) { Log.error("Cannot process annotated class!", e); } } }
public static List<Class<?>> loadAll() { return ClasspathUtil.loadClasses(new ScanParams()); }
public static ScanParams filter(org.rapidoid.lambda.Predicate<Class<?>> filter) { return new ScanParams().filter(filter); }
public static ScanParams pkg(String pkg) { return new ScanParams().pkg(pkg); }
@SuppressWarnings("unchecked") public ScanParams annotated(Collection<Class<? extends Annotation>> annotated) { return annotated(U.arrayOf(Class.class, annotated)); }
public static List<Class<?>> loadClasses(ScanParams scanParams) { List<String> classNames = ClasspathScanner.scan(scanParams); List<Class<?>> classes = U.list(); ClassLoader classLoader = U.or(scanParams.classLoader(), defaultClassLoader); for (String clsName : classNames) { try { Log.trace("Loading class", "name", clsName); classes.add(classLoader != null ? Class.forName(clsName, true, classLoader) : Class.forName(clsName)); } catch (Throwable e) { Log.debug("Error while loading class", "name", clsName, "error", e); } } return classes; }
private static void scanForMainClass(String path, Collection<String> mainClasses) { mainClasses.addAll(Scan.classpath(path).bytecodeFilter(new Predicate<InputStream>() { @Override public boolean eval(InputStream input) throws Exception { return hasMainMethod(new ClassFile(new DataInputStream(input))); } }).getAll()); }
public static ScanParams classLoader(ClassLoader classLoader) { return new ScanParams().classLoader(classLoader); }