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); }
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 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); }
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 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); }
/** * 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); }
public void init() { packages = config.getConfig().getString("fuse.scan.packages"); verbose = config.getConfig().getBoolean("fuse.scan.verbose"); if (!StringUtils.isEmpty(packages)) { // prepare reflections config builder ConfigurationBuilder builder = new ConfigurationBuilder(); builder.addScanners(new TypeAnnotationsScanner()); // add packages to scan Arrays.stream(packages.split(",")) .forEach( name -> builder.addUrls(ClasspathHelper.forPackage(name)) ); reflections = new Reflections(builder); } }
private Reflections buildReflections(String packages) { String[] packagesArray = packages.replaceAll(" ", "").split(","); FilterBuilder filter = new FilterBuilder(); Set<URL> urls = new HashSet(); for (String packageStr : packagesArray) { urls.addAll(ClasspathHelper.forPackage(packageStr)); filter.include(FilterBuilder.prefix(packageStr)); } return new Reflections(new ConfigurationBuilder() .addUrls(urls) .filterInputsBy(filter) .setScanners(new TypeAnnotationsScanner(), new SubTypesScanner())); }
private void init(String packageName) { FilterBuilder filters = new FilterBuilder().includePackage(packageName); Scanner[] scanners = { new TypeAnnotationsScanner(), new MethodAnnotationsScanner(), new MethodParameterScanner(), new FieldAnnotationsScanner(), new SubTypesScanner().filterResultsBy(filters) }; reflections = new ConfigurationBuilder() .addUrls(ClasspathHelper.forPackage(packageName)) .addScanners(scanners) .filterInputsBy(filters) .build(); }
public static ArrayList<Class> getSubtypes(String rootPackage) { log.debug("------------ Getting all children of MOI from package: " + rootPackage); Reflections reflections = new Reflections(new ConfigurationBuilder() .filterInputsBy(new FilterBuilder.Include(FilterBuilder.prefix(rootPackage))) .setUrls(ClasspathHelper.forPackage(rootPackage)) .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner(), new ResourcesScanner())); ArrayList<Class> annoList = new ArrayList<Class>(); annoList.addAll(reflections.getTypesAnnotatedWith(IgnoreFromTableCreation.class, true)); log.debug("annoList.size()::" + annoList.size()); ArrayList<Class> subTypesList = new ArrayList<Class>(); subTypesList.addAll(reflections.getSubTypesOf(ModelObjectInterface.class)); log.debug("getSubtypes: removing because it's annotated with @IgnoreFromTableCreation clazz = " + annoList); subTypesList.removeAll(annoList); log.debug("getSubtypes: found types: " + subTypesList); return subTypesList; }
public static ArrayList<Class> getSubtypes(Class rootClass) { log.debug("------------ Getting all children of MOI for class: " + rootClass.getCanonicalName()); Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forClass(rootClass)) .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner(), new ResourcesScanner())); ArrayList<Class> annoList = new ArrayList<Class>(); annoList.addAll(reflections.getTypesAnnotatedWith(IgnoreFromTableCreation.class, true)); log.debug("annoList.size()::" + annoList.size()); ArrayList<Class> subTypesList = new ArrayList<Class>(); subTypesList.addAll(reflections.getSubTypesOf(ModelObjectInterface.class)); log.debug("getSubtypes: removing because it's annotated with @IgnoreFromTableCreation clazz = " + annoList); subTypesList.removeAll(annoList); log.debug("getSubtypes: found types: " + subTypesList); return subTypesList; }
public void generateReport(String packageName,List<String> flagList) throws IOException { URL testClassesURL = Paths.get("target/test-classes").toUri().toURL(); URLClassLoader classLoader = URLClassLoader.newInstance(new URL[]{testClassesURL}, ClasspathHelper.staticClassLoader()); reflections = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forPackage(packageName,classLoader)) .addClassLoader(classLoader) .filterInputsBy(new FilterBuilder().includePackage(packageName)) .setScanners(new MethodAnnotationsScanner(), new TypeAnnotationsScanner(), new SubTypesScanner()) ); List<Map<String, TestClass>> list = new ArrayList<>(); for (String flag : flagList) { list.add(printMethods(flag)); } Gson gson = new Gson(); String overviewTemplate = IOUtils.toString(getClass().getResourceAsStream("/index.tpl.html")); String editedTemplate = overviewTemplate.replace("##TEST_DATA##", gson.toJson(list)); FileUtils.writeStringToFile(new File("target/test-list-html-report/index.html"), editedTemplate); logger.info("report file generated"); }
public static Reflections getReflections(Class<?> appClass) { String packageName = appClass.getPackage().getName(); return new Reflections( packageName, new SubTypesScanner(), new TypeAnnotationsScanner(), new FilterBuilder.Exclude(".*.xml") ); }
public static boolean init() { LogUtils.infof("Initializing commands..."); Reflections reflections = new Reflections(Shadbot.class.getPackage().getName(), new SubTypesScanner(), new TypeAnnotationsScanner()); for(Class<?> cmdClass : reflections.getTypesAnnotatedWith(Command.class)) { if(!AbstractCommand.class.isAssignableFrom(cmdClass)) { LogUtils.errorf("An error occurred while generating command, %s cannot be cast to AbstractCommand.", cmdClass.getSimpleName()); continue; } try { AbstractCommand cmd = (AbstractCommand) cmdClass.newInstance(); List<String> names = cmd.getNames(); if(!cmd.getAlias().isEmpty()) { names.add(cmd.getAlias()); } for(String name : names) { if(COMMANDS_MAP.putIfAbsent(name, cmd) != null) { LogUtils.errorf(String.format("Command name collision between %s and %s", cmdClass.getSimpleName(), COMMANDS_MAP.get(name).getClass().getSimpleName())); continue; } } } catch (InstantiationException | IllegalAccessException err) { LogUtils.errorf(err, "An error occurred while initializing command %s.", cmdClass.getDeclaringClass().getSimpleName()); return false; } } LogUtils.infof("%s initialized.", StringUtils.pluralOf((int) COMMANDS_MAP.values().stream().distinct().count(), "command")); return true; }
public Set<Class<?>> loadClasses() { Reflections reflections = new Reflections( new ConfigurationBuilder() .setUrls(ClasspathHelper.forPackage(packageToScan)) .setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner()) .filterInputsBy(new FilterBuilder().includePackage(packageToScan))); Set<Class<?>> result = new LinkedHashSet<>(); result.addAll(getClasses(reflections)); return result; }
@Override public ReflectionsWrapper configure() { reflections = (Reflections) cache.get(Reflections.class.getName()); if (reflections == null) { ConfigurationBuilder cb = new ConfigurationBuilder(); Set<URL> classLocations = new LinkedHashSet<>(); try { List<URL> urls = Collections.list(Thread.currentThread().getContextClassLoader().getResources("")); for (URL url : urls) { if (url.getPath().contains("/geemvc/target/")) { classLocations.add(url); } } } catch (IOException e) { throw new IllegalStateException(e); } cb = cb.addUrls(classLocations).addClassLoader(Thread.currentThread().getContextClassLoader()); cb = cb.setScanners(new ResourcesScanner(), new TypeAnnotationsScanner(), new MethodAnnotationsScanner(), new SubTypesScanner()); reflections = cb.build(); // Reflections cachedReflections = (Reflections) cache.putIfAbsent(Reflections.class.getName(), reflections); // if (cachedReflections != null) // reflections = cachedReflections; } return this; }
private static String getExceptionAdviceAnnotatedClassName() { Reflections reflections = new Reflections("", new TypeAnnotationsScanner()); Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(ExceptionAdvice.class,true); if (annotated.size() != 1) { return ""; } Class<?> item = (Class<?>) annotated.toArray()[0]; return item.getName(); }
private static String getExceptionAdviceAnnotatedClassName() { Reflections reflections = new Reflections("", new TypeAnnotationsScanner()); Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(ExceptionAdvice.class, true); if (annotated.size() != 1) { return ""; } Class<?> item = (Class<?>) annotated.toArray()[0]; declaredClass = item; return item.getName(); }
public static Set<Class<?>> getClassesWithAnnotation(final Class<? extends Annotation> annotation, final String[] packageNames) { final Reflections reflections; final Set<Class<?>> classes = new HashSet<>(); final ConfigurationBuilder builder = new ConfigurationBuilder(); for (final String packageName : packageNames) { builder.addUrls(ClasspathHelper.forPackage(packageName)); } builder.setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()); reflections = new Reflections(builder); classes.addAll(reflections.getTypesAnnotatedWith(annotation)); return classes; }
public QuikReflector() { this.reflections = new Reflections( new ConfigurationBuilder().setScanners( new SubTypesScanner(), new TypeAnnotationsScanner() ).forPackages("com", "net", "org") ); this.registers = new QuikRegisterRegistry(); this.domains = new QuikDomains(); }
/** * Scans the specified classpath for an annotation. * * @param classpathUrls the classpath, not null * @param annotationClassName the annotation to find, not null * @return the matching elements, not null */ public static Set<String> scan(URL[] classpathUrls, String annotationClassName) { ArgumentChecker.notNull(annotationClassName, "annotationClassName"); Set<URL> urls = new HashSet<>(Arrays.asList(classpathUrls)); AnnotationReflector reflector = new AnnotationReflector( null, urls, new TypeAnnotationsScanner(), ClassNameAnnotationScannerUtils.class.getClassLoader(), Thread.currentThread().getContextClassLoader()); Set<String> classNames = reflector.getReflector().getStore().getTypesAnnotatedWith(annotationClassName); if (classNames == null) { return Collections.emptySet(); } return Collections.unmodifiableSet(classNames); }
@Parameters(name= "{0}") public static Collection<Object[]> getDomainClasses() { Reflections reflections = new Reflections(TestConstants.DOMAIN_PACKAGE, new SubTypesScanner(false), new TypeAnnotationsScanner()); Collection<Object[]> classes = new ArrayList<Object[]>(); for (Class<? extends Object> dclass:reflections.getTypesAnnotatedWith(Entity.class)) { classes.add(new Object[]{dclass}); } return classes; }
public Anno4j(Repository repository, IDGenerator idGenerator, URI defaultContext, boolean persistSchemaAnnotations, Set<URL> additionalClasses) throws RepositoryConfigException, RepositoryException { this.idGenerator = idGenerator; this.defaultContext = defaultContext; classpath = new HashSet<>(); classpath.addAll(ClasspathHelper.forClassLoader()); classpath.addAll(ClasspathHelper.forJavaClassPath()); classpath.addAll(ClasspathHelper.forManifest()); classpath.addAll(ClasspathHelper.forPackage("")); if(additionalClasses != null) { classpath.addAll(additionalClasses); } Reflections annotatedClasses = new Reflections(new ConfigurationBuilder() .setUrls(classpath) .useParallelExecutor() .filterInputsBy(FilterBuilder.parsePackages("-java, -javax, -sun, -com.sun")) .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner(), new MethodAnnotationsScanner(), new FieldAnnotationsScanner())); // Bugfix: Searching for Reflections creates a lot ot Threads, that are not closed at the end by themselves, // so we close them manually. annotatedClasses.getConfiguration().getExecutorService().shutdown(); // find classes with @Partial annotation this.partialClasses = annotatedClasses.getTypesAnnotatedWith(Partial.class, true); scanForEvaluators(annotatedClasses); if(!repository.isInitialized()) { repository.initialize(); } this.setRepository(repository, additionalClasses, additionalClasses); // Persist schema information to repository: if(persistSchemaAnnotations) { persistSchemaAnnotations(annotatedClasses); } }
@Test public void testMatchingExistingSchema() throws Exception { Anno4j anno4j = new Anno4j(); OWLClazz myPerson = anno4j.createObject(OWLClazz.class, (Resource) new URIImpl("http://example.de/#validly_annotated_person")); RDFSProperty bossProperty = anno4j.createObject(RDFSProperty.class, (Resource) new URIImpl("http://example.de/#has_boss")); Restriction bossAllValuesFromRestr = anno4j.createObject(Restriction.class); bossAllValuesFromRestr.setOnClazz(Sets.newHashSet(myPerson)); bossAllValuesFromRestr.setOnProperty(Sets.newHashSet(bossProperty)); bossAllValuesFromRestr.setAllValuesFrom(Sets.<OWLClazz>newHashSet(myPerson)); Reflections types = new Reflections( new ConfigurationBuilder() .setUrls( ClasspathHelper.forClass(Person.class, ClasspathHelper.staticClassLoader()), ClasspathHelper.forClass(PersonSupport.class, ClasspathHelper.staticClassLoader()) ) .setScanners(new MethodAnnotationsScanner(), new FieldAnnotationsScanner(), new TypeAnnotationsScanner(), new SubTypesScanner()) ); Transaction transaction = anno4j.createTransaction(); transaction.begin(); SchemaPersistingManager persistingManager = new OWLSchemaPersistingManager(transaction.getConnection()); boolean exceptionThrown = false; try { persistingManager.persistSchema(types); } catch (SchemaPersistingManager.ContradictorySchemaException e) { exceptionThrown = true; } assertFalse(exceptionThrown); }
@Test public void testContradictoryExistingSchema() throws Exception { Anno4j anno4j = new Anno4j(); Transaction setupTransaction = anno4j.createTransaction(); setupTransaction.begin(); setupTransaction.getConnection().prepareUpdate("INSERT DATA {" + " <http://example.de/#validly_annotated_person> rdfs:subClassOf _:restr . " + " _:restr a owl:Restriction . " + " _:restr owl:onProperty <http://example.de/#id> . " + " _:restr owl:minCardinality '42'^^xsd:nonNegativeInteger . " + "}").execute(); setupTransaction.commit(); Transaction transaction = anno4j.createTransaction(); transaction.begin(); SchemaPersistingManager persistingManager = new OWLSchemaPersistingManager(transaction.getConnection()); Reflections types = new Reflections( new ConfigurationBuilder() .setUrls( ClasspathHelper.forClass(Person.class, ClasspathHelper.staticClassLoader()), ClasspathHelper.forClass(PersonSupport.class, ClasspathHelper.staticClassLoader()) ) .setScanners(new MethodAnnotationsScanner(), new FieldAnnotationsScanner(), new TypeAnnotationsScanner(), new SubTypesScanner()) ); boolean exceptionThrown = false; try { persistingManager.persistSchema(types); } catch (SchemaPersistingManager.ContradictorySchemaException e) { exceptionThrown = true; } assertTrue(exceptionThrown); }
private void findDynaObjects() throws IOException { ConfigurationBuilder configuration = new ConfigurationBuilder(); List<URL> urls = new ArrayList<>(); for (String element : classpath) { urls.add(new File(element).toURI().toURL()); } ClassLoader contextClassLoader = URLClassLoader.newInstance( urls.toArray(new URL[urls.size()]), Thread.currentThread().getContextClassLoader()); Thread.currentThread().setContextClassLoader(contextClassLoader); configuration.setUrls(ClasspathHelper.forClassLoader(contextClassLoader)); configuration.setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()); Reflections reflection = new Reflections(configuration); Set<Class<?>> classes = reflection.getTypesAnnotatedWith(DynaObject.class); for (Class clazz : classes) { // accept only classes if (clazz.isEnum() || clazz.isInterface() || clazz.isAnnotation()) { continue; } dynaClasses.add(new ClassModel(clazz)); System.out.println(String.format("New Dyna Object Found: %s", clazz.getCanonicalName())); } System.out.println(String.format("Found: %d Dyna Objects", dynaClasses.size())); }
@Override public void afterPropertiesSet() throws Exception { final Map<String, Object> nanaClients = ((ListableBeanFactory) applicationContext) .getBeansWithAnnotation((Class<? extends Annotation>) EntityRestService.class); for (final Object myClient : nanaClients.values()) { final Class<? extends Object>clientClass = myClient.getClass(); final EntityRestService annotation = clientClass .getAnnotation(EntityRestService.class); System.out.println(String.format("Found class %s\n",clientClass.getName() )); } Predicate<String> myClassAnnotationsFilter = new Predicate<String>() { @Override public boolean apply(String arg0) { return true; } }; final Reflections reflections = new Reflections( new ConfigurationBuilder() .filterInputsBy(new FilterBuilder().include("example.api")) .setUrls(ClasspathHelper.forClassLoader()) .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner().filterResultsBy(myClassAnnotationsFilter))); Set<Class<?>> theFoos = reflections.getTypesAnnotatedWith(EntityRestService.class); System.out.println(theFoos.size()); for(Class<?> eachFoo : theFoos) { System.out.println(String.format("Found class %s\n",eachFoo.getName() )); ; } }
@Override public void autoSetup(String packageName) { List<ClassLoader> classLoadersList = Lists.newArrayList(); ClassLoader contextClassLoader = ClasspathHelper.contextClassLoader(); classLoadersList.add(contextClassLoader); ClassLoader staticClassLoader = ClasspathHelper.staticClassLoader(); if (staticClassLoader != contextClassLoader) { classLoadersList.add(staticClassLoader); } // formatter: off ConfigurationBuilder configuration = new ConfigurationBuilder() .setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner()) .addClassLoaders(classLoadersList) .setUrls(ClasspathHelper.forPackage(packageName)); // formatter: on Reflections reflections = new Reflections(configuration); Set<Class<?>> collections = reflections.getTypesAnnotatedWith(io.seventyone.mongoutils.annotations.MongoCollection.class); collections.forEach(c -> { io.seventyone.mongoutils.annotations.MongoCollection annotation; annotation = c.getAnnotation(io.seventyone.mongoutils.annotations.MongoCollection.class); if (annotation.noAutoSetup() == false) { this.setupCollection(c, annotation.value()); } }); }
@Override public void populateEntityDictionary(EntityDictionary dictionary) { Reflections reflections = new Reflections(new ConfigurationBuilder() .addUrls(ClasspathHelper.forPackage(beanPackage.getName())) .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner())); reflections.getTypesAnnotatedWith(Entity.class).stream() .filter(entityAnnotatedClass -> entityAnnotatedClass.getPackage().getName() .startsWith(beanPackage.getName())) .forEach(dictionary::bindEntity); }
@Override public void populateEntityDictionary(EntityDictionary dictionary) { Reflections reflections = new Reflections(new ConfigurationBuilder() .addUrls(ClasspathHelper.forPackage(beanPackage.getName())) .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner())); reflections.getTypesAnnotatedWith(Entity.class).stream() .filter(entityAnnotatedClass -> entityAnnotatedClass.getPackage().getName() .startsWith(beanPackage.getName())) .forEach((cls) -> { dictionary.bindEntity(cls); dataStore.put(cls, Collections.synchronizedMap(new LinkedHashMap<>())); }); this.dictionary = dictionary; }
/** * Get all the entities in a package. * * @param packageName Package name * @return All entities found in package. */ public static HashSet<Class> getAllEntities(String packageName) { return new HashSet<>(new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner()) .setUrls(ClasspathHelper.forClassLoader(ClassLoader.getSystemClassLoader())) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(packageName)))) .getTypesAnnotatedWith(Entity.class)); }
/** * Looks for classes annotated with a given annotation. * * @param annotation an annotation to look for * @param bundle a bundle to look in. * @return A list of classes, annotated with the given annotation */ public static Set<Class<?>> getClasses(Class<? extends Annotation> annotation, Bundle bundle) { LOGGER.debug("Scanning bundle: {}", bundle.getSymbolicName()); LOGGER.debug("Searching for classes with annotations: {}", annotation.getName()); Reflections reflections = configureReflection(bundle, new PristineBundleClassLoader(bundle), new TypeAnnotationsScanner(), new SubTypesScanner()); Set<Class<?>> classes = reflections.getTypesAnnotatedWith(annotation); // in order to prevent processing of user defined or auto generated fields // we have to load the bytecode from the jar and define the class in a temporary // classLoader PristineBundleClassLoader pristineBundleClassLoader = new PristineBundleClassLoader(bundle); Set<Class<?>> result = new HashSet<>(); for (Class clazz : classes) { try { result.add(pristineBundleClassLoader.loadClass(clazz.getName())); } catch (ClassNotFoundException e) { LOGGER.error("Could not find class", e); } } LOGGER.debug("Searched for classes with annotations: {}", annotation.getName()); LOGGER.trace("Found {} classes with annotations: {}", result.size(), annotation.getName()); return result; }
@GET @Path("getclasses") public List<GenericClassDescription> getSupportedClasses() { List<GenericClassDescription> classes=new ArrayList<GenericClassDescription>(); Reflections reflections = new Reflections( new ConfigurationBuilder().setUrls(ClasspathHelper.forPackage("cm.homeautomation")).setScanners( new SubTypesScanner(), new TypeAnnotationsScanner(), new MethodAnnotationsScanner())); // MethodAnnotationsScanner Set<Class<?>> typesAnnotatedWith = reflections.getTypesAnnotatedWith(Entity.class); for (Class<?> declaringClass : typesAnnotatedWith) { GenericClassDescription clazz=new GenericClassDescription(); clazz.setName(declaringClass.getName()); Field[] fields = declaringClass.getDeclaredFields(); for (Field field : fields) { clazz.getFields().put(field.getName(), field.getType().getSimpleName()); } /*Method[] methods = declaringClass.getDeclaredMethods(); for (Method method : methods) { clazz.getMethods().put(method.getName(), method.getParameters()); }*/ classes.add(clazz); } return classes; }