protected GuiceApplication(String... basePackages) { final ConfigurationBuilder confBuilder = new ConfigurationBuilder(); final FilterBuilder filterBuilder = new FilterBuilder(); if (basePackages.length == 0) { basePackages = new String[] {}; } logger.info("op=create, auto_scan_packages={}", (Object[]) basePackages); for (String pkg : basePackages) { confBuilder.addUrls(ClasspathHelper.forPackage(pkg)); filterBuilder.include(FilterBuilder.prefix(pkg)); } confBuilder.filterInputsBy(filterBuilder) .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()); this.reflections = new Reflections(confBuilder); }
/** * Prepares the logger context. Locates the context and * sets the configuration file. * @return the logger context */ private ServletContextListener prepareAndgetContextListener() { try { if (StringUtils.isNotBlank(this.loggerContextPackageName)) { final Collection<URL> set = ClasspathHelper.forPackage(this.loggerContextPackageName); final Reflections reflections = new Reflections(new ConfigurationBuilder().addUrls(set).setScanners(new SubTypesScanner())); final Set<Class<? extends ServletContextListener>> subTypesOf = reflections.getSubTypesOf(ServletContextListener.class); final ServletContextListener loggingContext = subTypesOf.iterator().next().newInstance(); this.context.setInitParameter(this.logConfigurationField, this.logConfigurationFile.getURI().toString()); return loggingContext; } return null; } catch (final Exception e) { throw new RuntimeException(e); } }
/** * Gets cas banner instance. * * @return the cas banner instance */ public static Banner getCasBannerInstance() { final String packageName = CasEmbeddedContainerUtils.class.getPackage().getName(); final Reflections reflections = new Reflections(new ConfigurationBuilder() .filterInputsBy(new FilterBuilder().includePackage(packageName)) .setUrls(ClasspathHelper.forPackage(packageName)) .setScanners(new SubTypesScanner(true))); final Set<Class<? extends AbstractCasBanner>> subTypes = reflections.getSubTypesOf(AbstractCasBanner.class); subTypes.remove(DefaultCasBanner.class); if (subTypes.isEmpty()) { return new DefaultCasBanner(); } try { final Class<? extends AbstractCasBanner> clz = subTypes.iterator().next(); LOGGER.debug("Created banner [{}]", clz); return clz.newInstance(); } catch (final Exception e) { LOGGER.error(e.getMessage(), e); } return new DefaultCasBanner(); }
public ReflectionsServiceDiscovery(String resourceSearchPackages, JsonServiceLocator locator) { this.locator = locator; ConfigurationBuilder builder = new ConfigurationBuilder(); PreconditionUtil.assertNotNull("no resourceSearchPackage configured", resourceSearchPackages); FilterBuilder filter = new FilterBuilder(); for (String resourceSearchPackage : resourceSearchPackages.split(",")) { builder = builder.addUrls(ClasspathHelper.forPackage(resourceSearchPackage)); filter.includePackage(resourceSearchPackage); } filter.includePackage(Repository.class.getPackage().getName()); filter.includePackage(ResourceRepository.class.getPackage().getName()); builder = builder.filterInputsBy(filter); builder = builder.addUrls(ClasspathHelper.forClass(Repository.class)); builder = builder.addUrls(ClasspathHelper.forClass(ResourceRepository.class)); builder = builder.addUrls(ClasspathHelper.forClass(ResourceRepositoryV2.class)); builder = builder.setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner()); reflections = new Reflections(builder); }
public CommandHandler() { try { Set<URL> classPathList = new HashSet<>(); classPathList.addAll(ClasspathHelper.forJavaClassPath()); Set<Class<? extends Command>> result = new Reflections( new ConfigurationBuilder().setScanners(new SubTypesScanner()).setUrls(classPathList)) .getSubTypesOf(Command.class); for (Class<? extends Command> c : result) { String[] categoryString = c.getPackage().toString().split("\\."); String category = categoryString[categoryString.length - 1]; if (category.equalsIgnoreCase("commands")) { category = "default"; } Command command = c.newInstance(); command.getSettings().setCategory(category); commands.add(command); } } catch (Exception e) { e.printStackTrace(); } }
private static <T> List<Class<? extends T>> concreteSubTypesOf(final Class<? extends T> clazz) { final ConfigurationBuilder conf = new ConfigurationBuilder() .setUrls(ClasspathHelper.forClass(clazz)) .setScanners(new SubTypesScanner(true)); final Reflections reflections = new Reflections(conf); final List<Class<? extends T>> result = new ArrayList<>(); for (final Class<? extends T> type : reflections.getSubTypesOf(clazz)) { if (type.isInterface()) { continue; } if (Modifier.isAbstract(type.getModifiers())) { continue; } result.add(type); } return result; }
@Test public void tweetEntities() { Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forJavaClassPath()) .forPackages(TweetEntity.class.getPackage().getName()) ); List<Class<?>> allClasses = new ArrayList<>(); List<Class<? extends TweetEntity>> classes = list(reflections, TweetEntity.class); allClasses.add(MediaEntity.Variant.class); allClasses.add(MediaEntity.Size.class); allClasses.addAll(classes); for (Class<?> cls : allClasses) { StringBuilder builder = new StringBuilder(); processClass(cls, builder); System.out.println(builder); } }
@BeforeEach public void before() throws MalformedURLException { log.info("before() - Configuring reflections to use package '{}'", packages()); if (null == this.reflections) { this.reflections = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forJavaClassPath()) .forPackages(packages()) ); } List<Class<? extends Transformation>> transformClasses = list(Transformation.class); List<Class<? extends SourceConnector>> sourceConnectorClasses = list(SourceConnector.class); List<Class<? extends SinkConnector>> sinkConnectorClasses = list(SinkConnector.class); this.pluginTemplate = PluginTemplate.from(sourceConnectorClasses, sinkConnectorClasses, transformClasses); }
private void computeClasses() { this.annotatedClassMap = new HashMap<>(); this.otherClassMap = new HashMap<>(); TypesHandled handlesTypes = handlesTypes(); // check if any type is handled if (!handlesTypes.isEmpty()) { // create reflections Reflections reflections = new Reflections(new ConfigurationBuilder().setExpandSuperTypes(false).setUrls(getURLs())); // add types annotated for each type to be handled for (Class<? extends Annotation> annotationType : handlesTypes.getAnnotationTypes()) { this.annotatedClassMap.put(annotationType, reflections.getTypesAnnotatedWith(annotationType)); } // add subtype of other types to be handled for (Class<?> otherType : handlesTypes.getOtherTypes()) { this.otherClassMap.put(otherType, (Set<Class<?>>) reflections.getSubTypesOf(otherType)); } } }
private void doPackage(FilterBuilder fb, List<RuleFactory> resultL) throws Exception { List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>(); classLoadersList.add(ClasspathHelper.contextClassLoader()); classLoadersList.add(ClasspathHelper.staticClassLoader()); Reflections reflections = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner()) .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0]))) .filterInputsBy(fb)); Set<Class<? extends RuleFactory>> subTypes = reflections.getSubTypesOf(RuleFactory.class); for(Class<? extends RuleFactory> clazz : subTypes) { RuleFactory factory = clazz.newInstance(); resultL.add(factory); } }
@Test public void testReflections() throws Exception { List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>(); classLoadersList.add(ClasspathHelper.contextClassLoader()); classLoadersList.add(ClasspathHelper.staticClassLoader()); String packageName = "org.dnal.core.world"; Reflections reflections = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner()) .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0]))) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(packageName)))); Set<String> types = reflections.getAllTypes(); for(String s : types) { System.out.println(s); } Set<Class<? extends RuleFactory>> subTypes = reflections.getSubTypesOf(RuleFactory.class); for(Class<? extends RuleFactory> clazz : subTypes) { System.out.println("sub: " + clazz.getName()); RuleFactory factory = clazz.newInstance(); RuleDeclaration decl = factory.getDeclaration(); System.out.println("d: " + decl.ruleName); } }
private ArrayList<String> getResourceDirectoryContent(String resourcePattern) { ArrayList<String> tempFilesContentList = new ArrayList<>(); Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forPackage("io.logz")) .setScanners(new ResourcesScanner()) .filterInputsBy(new FilterBuilder().include(resourcePattern))); Set<String> properties = reflections.getResources(Pattern.compile(".*\\.json")); properties.forEach((resourceName) -> { URL resourceUrl = Resources.getResource(resourceName); try { tempFilesContentList.add(Resources.toString(resourceUrl, Charset.forName("utf-8")).replace("\n", "")); } catch (IOException e) { logger.info("Could not read file {}", resourceUrl.toString()); } }); if (tempFilesContentList.isEmpty()) throw new RuntimeException("Did not find any files under "+ resourcePattern +"!"); return tempFilesContentList; }
Set<Class<? extends T>> scan(Class<? extends T> aClass) { Configuration configuration = ConfigurationBuilder.build((Object[]) packages).addClassLoaders(classLoaders) .addScanners(new AssignableScanner(aClass)); Reflections reflections = new Reflections(configuration); Predicate<Class<? extends T>> classPredicate = klass -> Modifier.isPublic(klass.getModifiers()) && (!klass.isMemberClass() || (klass.isMemberClass() && Modifier .isStatic(klass.getModifiers()))) && !Modifier.isInterface(klass.getModifiers()) && !Modifier.isAbstract(klass.getModifiers()); HashSet<Class<? extends T>> subtypes = Sets.newHashSet( ReflectionUtils.forNames( reflections.getStore() .getAll(AssignableScanner.class.getSimpleName(), Collections.singletonList(aClass.getName())), classLoaders)); return subtypes.stream().filter(classPredicate).collect(Collectors.toSet()); }
public BeanScanner(final BeanManagerImpl beanManager, final ClassLoader classLoader, final String packageToScan) { this.beanManager = beanManager; final ConfigurationBuilder config = new ConfigurationBuilder(); config.setClassLoaders(new ClassLoader[] {classLoader}); config.setUrls(ClasspathHelper.forPackage(packageToScan, classLoader)); if (StringUtils.isNotEmpty(packageToScan)) { config.filterInputsBy(new FilterBuilder().includePackage(packageToScan)); } config.useParallelExecutor(); config.setScanners(new SubTypesScanner(false)); this.reflections = new Reflections(config); }
/** * Finds all package names starting with prefix * @param prefix The package in which to start searching * @param statik True to statically return components names * @return a set of component name */ public List<String> findAllPackagesStartingWith(final String prefix, final boolean statik) { final List<ClassLoader> classLoadersList = new ArrayList<>(); classLoadersList.add(ClasspathHelper.contextClassLoader()); Reflections reflections = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(false), new ResourcesScanner()) .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[classLoadersList.size()]))) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(prefix)))); Set<Class<?>> classes = reflections.getSubTypesOf(Object.class); final Set<String> packages = new HashSet<>(); for (final Class classInstance : classes) { String packageName = classInstance.getPackage().getName(); packageName = packageName.split("\\.")[packageName.split("\\.").length-1].toLowerCase(); packages.add(packageName); } return new ArrayList<>(packages); }
public void scan(String base) { Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forPackage(base)) .setScanners(new MethodAnnotationsScanner()) ); Set<Method> predicateMethods = reflections.getMethodsAnnotatedWith(Predicate.class); for (Method method : predicateMethods) { String name = method.getAnnotation(Predicate.class).name(); if (name.isEmpty()) { name = method.getName(); } this.register(method, name); } }
/** * For a specific jar file, this method will extract any implementing Plugin * classes of the specified type. * * @param pluginJar Plugin jar file from which to extract any concrete * plugins. * @param pluginType Plugin types to extract. * @return An ArrayList of plugin classes. * @throws MalformedURLException If there is a problem reading the plugin * jar. */ public static ArrayList<Class<? extends Plugin>> getPluginsFromExternalJar(File pluginJar, Class pluginType) throws MalformedURLException { URL[] urlArray = new URL[1]; urlArray[0] = pluginJar.toURI().toURL(); URLClassLoader childJar = new URLClassLoader(urlArray); Reflections reflections = new Reflections(new ConfigurationBuilder().setUrls(urlArray).addClassLoader(childJar));//confusing, but it works ArrayList<Class<? extends Plugin>> csfi = new ArrayList(reflections.getSubTypesOf(pluginType)); ArrayList<Class<? extends Plugin>> toReturn = new ArrayList<>(); for (Class<? extends Plugin> c : csfi) { if (!Modifier.isAbstract(c.getModifiers()))//don't pick up abstract plugins, we can't implement them anyway { toReturn.add(c); logger.debug("Read class: " + c.getCanonicalName() + " from jar: " + pluginJar.getAbsolutePath()); } } return toReturn; }
private String getKeywordClassList(URLClassLoader cl) throws Exception { URL url = cl.getURLs()[0]; try { Reflections reflections = new Reflections(new ConfigurationBuilder().setUrls(url) .addClassLoader(cl).setScanners(new MethodAnnotationsScanner())); Set<Method> methods = reflections.getMethodsAnnotatedWith(Keyword.class); Set<String> kwClasses = new HashSet<>(); for(Method method:methods) { kwClasses.add(method.getDeclaringClass().getName()); } StringBuilder kwClassnamesBuilder = new StringBuilder(); kwClasses.forEach(kwClassname->kwClassnamesBuilder.append(kwClassname+";")); return kwClassnamesBuilder.toString(); } catch (Exception e) { String errorMsg = "Error while looking for methods annotated with @Keyword in "+url.toString(); throw new Exception(errorMsg, e); } }
private static Collection<? extends Class<?>> getPackageTypes(String packageToPase, Collection<URL> urls) { Set<Class<?>> classes = new HashSet<>(); Reflections reflections = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(false /* exclude Object.class */), new ResourcesScanner(), new TypeElementsScanner()) .setUrls(urls) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(packageToPase)).exclude("java.*"))); Set<String> types; types = reflections.getStore().get("TypeElementsScanner").keySet(); for (String type: types) { Class<?> aClass = TypesHelper.loadClass(type, CLASS_LOADER); boolean wantedElement = StringUtils.startsWith(type, packageToPase); if (null != aClass && wantedElement) { logger.log(Level.INFO, "looking up for type: " + type); classes.add(aClass); } } return classes; }
public static void scanForCommands() { //Populate all the cmds System.out.println("[EvenWurse] Reloading cmd list..."); ArrayList<ClassLoader> classLoadersList = new ArrayList<>(); classLoadersList.add(ClasspathHelper.contextClassLoader()); classLoadersList.add(ClasspathHelper.staticClassLoader()); Reflections reflections = new Reflections( new ConfigurationBuilder().setScanners(new SubTypesScanner(), new ResourcesScanner()).setUrls( ClasspathHelper .forClassLoader(classLoadersList.toArray(new ClassLoader[classLoadersList.size()])))); Set<Class<? extends Cmd>> classes = reflections.getSubTypesOf(Cmd.class); KNOWN_CMDS = new Class[classes.size()]; for (int i = 0; i < classes.size(); i++) { KNOWN_CMDS[i] = (Class<? extends Cmd>) classes.toArray()[i]; System.out.println("[EvenWurse] Found cmd: " + KNOWN_CMDS[i].getSimpleName() + "!"); } System.out.println("[EvenWurse] Found " + KNOWN_CMDS.length + " cmds!"); }
public static void scanForMods() { //Populate all the mods System.out.println("[EvenWurse] Reloading mod list..."); ArrayList<ClassLoader> classLoadersList = new ArrayList<>(); classLoadersList.add(ClasspathHelper.contextClassLoader()); classLoadersList.add(ClasspathHelper.staticClassLoader()); Reflections reflections = new Reflections( new ConfigurationBuilder().setScanners(new SubTypesScanner(), new ResourcesScanner()).setUrls( ClasspathHelper .forClassLoader(classLoadersList.toArray(new ClassLoader[classLoadersList.size()])))); Set<Class<? extends Mod>> classes = reflections.getSubTypesOf(Mod.class); KNOWN_MODS = new Class[classes.size()]; for (int i = 0; i < classes.size(); i++) { KNOWN_MODS[i] = (Class<? extends Mod>) classes.toArray()[i]; System.out.println("[EvenWurse] Found mod: " + KNOWN_MODS[i].getSimpleName() + "!"); } System.out.println("[EvenWurse] Found " + KNOWN_MODS.length + " mods!"); }
public void addLoader(ClassLoader loader) { if (builder == null) { this.builder = new ConfigurationBuilder(); builder.setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()); } builder.addClassLoader(loader); builder.addUrls(ClasspathHelper.forClassLoader(loader)); if(loader instanceof JoinClassLoader) { // When the object "reflections" is created in the method scanClassPath(), are scanned the URLs so // it is necessary to add the URLs from the enclosing class loader in the JoinClassLoader that it // contains the fixture classpath (see org.reflections.Reflections.scan()). builder.addUrls(ClasspathHelper.forClassLoader(((JoinClassLoader) loader).getEnclosingClassLoader())); } scanClassPath(builder); }
/** * Gets and stores all of the commands in a HashMap for easier use. * @author Jared314 */ public static void init() { commands=new HashMap<>(); Reflections r = new Reflections(new ConfigurationBuilder().setUrls(ClasspathHelper.forJavaClassPath())); // Find all commands Set<Class<? extends Command>> commandClassList = r.getSubTypesOf(Command.class); // Add command instances to the commands hash map for(Class<? extends Command> cClass: commandClassList){ try { Command c = cClass.newInstance(); commands.put(c.getCommandText(), c); } catch (Exception e) { logger.log(Level.WARNING, "An error occurred initializing a command", e); } } }
private static Set<Class<?>> getReflected() { synchronized (LOCK) { if (reflected != null) { return reflected; } Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forPackage("com.jivesoftware")) .setScanners(new MethodAnnotationsScanner(), new TypeAnnotationsScanner())); Set<Class<?>> result = reflections.getTypesAnnotatedWith(Path.class); Set<Method> methods = reflections.getMethodsAnnotatedWith(Path.class); for (Method method : methods) { result.add(method.getDeclaringClass()); } reflected = Collections.unmodifiableSet(result); return reflected; } }
public synchronized void init(ServletContext context) { if (HANDLERS != null) { return; } LOG.info("Initializing output handlers..."); Map<String, Class<? extends IOutputHandler>> handlers = new HashMap<>(); Reflections reflections = new Reflections(new ConfigurationBuilder() .addUrls(ClasspathHelper.forWebInfLib(context)) .setScanners(new TypeAnnotationsScanner(), new SubTypesScanner(false))); Set<Class<?>> classes = reflections.getTypesAnnotatedWith(OutputHandler.class); for (Class<?> clazz : classes) { LOG.info("Found annotated output handler class: " + clazz.getName()); if (IOutputHandler.class.isAssignableFrom(clazz)) { String id = clazz.getAnnotation(OutputHandler.class).id(); //noinspection unchecked handlers.put(id, (Class<? extends IOutputHandler>)clazz); LOG.info("Added output handler " + id + " in class: " + clazz.getName()); } } HANDLERS = handlers; LOG.info("Initialization of output handlers completed."); }
public static Iterable<URL> scan(String pattern) { // lookup from classpath ConfigurationBuilder rcp = new ConfigurationBuilder()// .setUrls(ClasspathHelper.forClassLoader())// .setScanners(new ResourcesScanner()); { String path = pathChar.replaceFrom(pattern, '.'); rcp.setInputsFilter(in -> (false == in.startsWith("java.")) && Wildcard.match(in, path)); } Set<String> scans = new Reflections(rcp).getResources(Predicates.alwaysTrue()); // transforms strings to urls return Iterables.transform(scans, res -> getURL(res)); }
public void test() { final Reflections reflections = new Reflections(new ConfigurationBuilder() .addUrls(ClasspathHelper.forClassLoader()) .setScanners(new MethodAnnotationsScanner()) ); final Set<Method> methods = reflections.getMethodsAnnotatedWith(Cached.class); System.out.println("Found " + methods.size() + " methods annotated with " + Cached.class); for (final Method method : methods) { testMethod(method); } assertNoExceptions(); }
public void test() { final Reflections reflections = new Reflections(new ConfigurationBuilder() .addUrls(ClasspathHelper.forClassLoader()) .setScanners(new TypeAnnotationsScanner(), new SubTypesScanner()) ); final Set<Class<?>> classes_withValidator = reflections.getTypesAnnotatedWith(Validator.class); System.out.println("Found " + classes_withValidator.size() + " classes annotated with " + Validator.class); final Set<Class<?>> classes_withInterceptor = reflections.getTypesAnnotatedWith(Interceptor.class); System.out.println("Found " + classes_withInterceptor.size() + " classes annotated with " + Interceptor.class); final Set<Class<?>> classes = ImmutableSet.<Class<?>> builder() .addAll(classes_withValidator) .addAll(classes_withInterceptor) .build(); System.out.println("=> " + classes.size() + " classes to test"); for (final Class<?> clazz : classes) { testClass(clazz); } assertNoExceptions(); }
private void scanConceptsWithReflections() throws ObjectStoreConfigException { logger.debug("Search for concepts with reflections"); Set<URL> classpath = new HashSet<>(); classpath.addAll(ClasspathHelper.forClassLoader()); classpath.addAll(ClasspathHelper.forJavaClassPath()); classpath.addAll(ClasspathHelper.forManifest()); classpath.addAll(ClasspathHelper.forPackage("")); Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(classpath) .useParallelExecutor() .filterInputsBy(FilterBuilder.parsePackages("-java, -javax, -sun, -com.sun")) .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner())); Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(Iri.class, true); logger.debug("Search for concepts with reflections resulted in " + annotated.size() + " classes"); for (Class clazz : annotated) { logger.debug("Found concept class: " + clazz.getCanonicalName()); roleMapper.addConcept(clazz); } }
/** * Init stuff is responsible to grab all DTOs found in classpath (classloader) and setup model for * String Template */ protected void init() { ConfigurationBuilder configurationBuilder = new ConfigurationBuilder().setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()); if (useClassPath) { configurationBuilder.setUrls(forJavaClassPath()); } else { configurationBuilder.setUrls(forClassLoader()); } // keep only DTO interfaces Reflections reflections = new Reflections(configurationBuilder); List<Class<?>> annotatedWithDtos = new ArrayList<>(reflections.getTypesAnnotatedWith(DTO.class)); List<Class<?>> interfacesDtos = annotatedWithDtos .stream() .filter(clazz -> clazz.isInterface()) .collect(Collectors.toList()); interfacesDtos.stream().forEach(this::analyze); }
@Override public void execute() throws MojoExecutionException, MojoFailureException { Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forPackage(basePackage)).setScanners( new SubTypesScanner(), new TypeAnnotationsScanner())); Set<Class<?>> resources = reflections .getTypesAnnotatedWith(Resource.class); Set<Class<?>> apis = reflections .getTypesAnnotatedWith(ApiGateway.class); Map<String, EndpointResource> endpointResources = getEndpointResources(resources); String apiName = getApiName(apis); fileWriter.createSwaggerFile(new ArrayList<EndpointResource>(endpointResources.values()), apiName); }
@SuppressWarnings("unchecked") private void registerScriptEngineFactories() { List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>(); classLoadersList.add(ClasspathHelper.contextClassLoader()); classLoadersList.add(ClasspathHelper.staticClassLoader()); Reflections reflections = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner(), new ResourcesScanner()) .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0]))) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix("com.jsen")))); Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(ScriptEngineFactory.class); for (Class<?> clazz : annotated) { if (AbstractScriptEngineFactory.class.isAssignableFrom(clazz)) { registerMimeContentFactory((Class<AbstractScriptEngineFactory>)clazz); } } }
/** * Scans the specified packages for annotated classes, and applies Config values to them. * * @param config the Config to derive values from * @param packageNamePrefix the prefix to limit scanning to - e.g. "com.github" * @return The constructed TypesafeConfigModule. */ public static TypesafeConfigModule fromConfigWithPackage(Config config, String packageNamePrefix) { ConfigurationBuilder configBuilder = new ConfigurationBuilder() .filterInputsBy(new FilterBuilder().includePackage(packageNamePrefix)) .setUrls(ClasspathHelper.forPackage(packageNamePrefix)) .setScanners( new TypeAnnotationsScanner(), new MethodParameterScanner(), new MethodAnnotationsScanner(), new FieldAnnotationsScanner() ); Reflections reflections = new Reflections(configBuilder); return new TypesafeConfigModule(config, reflections); }
private void _processPackages(final Set<String> packages) { if (CollectionUtils.hasData(_packages)) { // [1] - Find all types annotated with @XmlRootElement Set<Class<?>> allPckgsTypes = Sets.newHashSet(); List<URL> urls = new ArrayList<URL>(); //urls.addAll(ClasspathHelper.forPackage("javax.xml.bind.annotation")); for (String p : packages) { //Reflections typeScanner = new Reflections(p); urls.addAll(ClasspathHelper.forPackage(p)); // see https://code.google.com/p/reflections/issues/detail?id=53 log.debug("Scanning package {} for @XmlRootElement annotated types",p); } Reflections typeScanner = new Reflections(new ConfigurationBuilder() .setUrls(urls)); Set<Class<?>> pckgTypes = typeScanner.getTypesAnnotatedWith(XmlRootElement.class); if (CollectionUtils.hasData(pckgTypes)) { for (Class<?> type : pckgTypes) log.trace(">Type {}",type); allPckgsTypes.addAll(pckgTypes); } else { log.debug("NO types annotated with @XmlRootElement"); } // [2] - Process... _processTypes(allPckgsTypes); } }
private Map<String, String> getAllDocStrings0(ClassLoader classLoader) { final Configuration configuration = new ConfigurationBuilder() .filterInputsBy(new FilterBuilder().includePackage(path)) .setUrls(ClasspathHelper.forPackage(path)) .addClassLoader(classLoader) .setScanners(new ResourcesScanner()); if (configuration.getUrls() == null || configuration.getUrls().isEmpty()) { return Collections.emptyMap(); } Map<String, byte[]> files = new Reflections(configuration) .getResources(this::acceptFile).stream() .map(f -> { try { URL url = classLoader.getResource(f); if (url == null) { throw new IllegalStateException("not found: " + f); } return new SimpleImmutableEntry<>(f, Resources.toByteArray(url)); } catch (IOException e) { throw new UncheckedIOException(e); } }) .collect(toImmutableMap(Entry::getKey, Entry::getValue)); return getDocStringsFromFiles(files); }
private Set<Class<?>> getSubtypes(final Class<?> type) throws ComboBoxIsTooFullException { final ClassLoader[] classloaders = new ClassLoader[] { currentModelHandler.getCustomClassLoader(), currentModelHandler.getCustomClassLoader().getParent() }; final ConfigurationBuilder builder = new ConfigurationBuilder(). addUrls(ClasspathHelper.forClassLoader(currentModelHandler.getCustomClassLoader())). addClassLoaders(classloaders). setScanners(new SubTypesScanner(false)); final Reflections ref = new Reflections(builder); final Set<Class<?>> result = new HashSet<Class<?>>(); final Set<String> subTypesStr = ref.getStore().getSubTypesOf(type.getName()); if (subTypesStr.size() > MAX_SIZE_OF_SUBPARAMETER_COMBOBOX) throw new ComboBoxIsTooFullException(); for (final String clsName : subTypesStr) { try { result.add(ReflectionUtils.forName(clsName,classloaders)); } catch (final ReflectionsException e) { // intentionally blank } } return result; }
public static List<URL> urls( String atPackage, String ext ) { final ExecutorService executorService = Executors.newFixedThreadPool( Runtime.getRuntime().availableProcessors(), new ThreadFactoryBuilder().setNameFormat( "reflections-%d" ).build() ); try { final ConfigurationBuilder configuration = new ConfigurationBuilder() .setUrls( ClasspathHelper.forPackage( atPackage ) ) .setScanners( new ResourcesScanner() ) .filterInputsBy( new FilterBuilder().includePackage( atPackage ) ) .setExecutorService( executorService ); final Reflections reflections = new Reflections( configuration ); final Set<String> resources = reflections.getResources( in -> in.endsWith( "." + ext ) ); return new ArrayList<>( Sets.map( resources, r -> Thread.currentThread().getContextClassLoader().getResource( r ) ) ); } finally { executorService.shutdown(); } }
/** * Creates a {@link org.reflections.Reflections} with the given packages (configuration) * * @param scanPackages */ private void createReflections(String[] scanPackages) { if (scanPackages.length < 1) { LOGGER.warn("No package defined in configuration (scanPackages)!"); return; } ConfigurationBuilder configurationBuilder = new ConfigurationBuilder(); FilterBuilder filterBuilder = new FilterBuilder(); for (String packageName : scanPackages) { configurationBuilder.addUrls(ClasspathHelper.forPackage(packageName)); filterBuilder.include(FilterBuilder.prefix(packageName)); } configurationBuilder.filterInputsBy(filterBuilder).setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()); this.reflections = new Reflections(configurationBuilder); }