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); }
/** * Initializes correlations between json paths and xpaths */ private static PathCorrelation loadPathCorrelation() { PathCorrelation pathCorrelation; try { InputStream input = ClasspathHelper.contextClassLoader().getResourceAsStream(config); ObjectMapper mapper = new ObjectMapper(); pathCorrelation = mapper.readValue(input, PathCorrelation.class); flattenCorrelations(pathCorrelation); } catch (IOException ioe) { String message = "Problem loading path correlation configuration"; DEV_LOG.error(message, ioe); throw new PathCorrelationException(message, ioe); } return pathCorrelation; }
public static Map<String, MeasureConfig> grabConfiguration(String fileName) { ObjectMapper mapper = new ObjectMapper(); InputStream measuresInput = ClasspathHelper.contextClassLoader().getResourceAsStream(fileName); try { TypeReference<List<MeasureConfig>> measureConfigType = new TypeReference<List<MeasureConfig>>() {}; List<MeasureConfig> configurations = mapper.readValue(measuresInput, measureConfigType); return configurations.stream() .collect(Collectors.toMap(MeasureConfigs::getMeasureId, Function.identity())); } catch (IOException e) { String message = "failure to correctly read measures config json"; DEV_LOG.error(message); throw new IllegalArgumentException(message, e); } }
@Test void parseClinicalDocument() throws Exception { InputStream stream = ClasspathHelper.contextClassLoader().getResourceAsStream("valid-QRDA-III-abridged.xml"); String xmlFragment = IOUtils.toString(stream, StandardCharsets.UTF_8); Context context = new Context(); Node clinicalDocumentNode = XmlInputDecoder.decodeXml(context, XmlUtils.stringToDom(xmlFragment)); // remove default nodes (will fail if defaults change) DefaultDecoder.removeDefaultNode(clinicalDocumentNode.getChildNodes()); QppOutputEncoder encoder = new QppOutputEncoder(context); encoder.setNodes(Collections.singletonList(clinicalDocumentNode)); StringWriter sw = new StringWriter(); encoder.encode(new BufferedWriter(sw)); assertThat(sw.toString()).isEqualTo(expected); }
@BeforeAll static void setup() { ObjectMapper mapper = new ObjectMapper(); InputStream stream = ClasspathHelper.contextClassLoader().getResourceAsStream("measures-data-aci-test.json"); try { TypeReference<List<MeasureConfig>> measureConfigType = new TypeReference<List<MeasureConfig>>() {}; measureConfigs = mapper.readValue(stream, measureConfigType); } catch (IOException e) { throw new IllegalArgumentException("failure to correctly read measures config json", e); } theConfig = measureConfigs.get(0); }
/** * 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); }
@Test public void doExecute() throws Exception { final PackageMojo mojo = getMojoFromPom(); final PackageMojo mojoSpy = spy(mojo); ReflectionUtils.setVariableValueInObject(mojoSpy, "finalName", "artifact-0.1.0"); doReturn(mock(AnnotationHandler.class)).when(mojoSpy).getAnnotationHandler(); doReturn(ClasspathHelper.forPackage("com.microsoft.azure.maven.function.handlers").toArray()[0]) .when(mojoSpy) .getTargetClassUrl(); doReturn("target/azure-functions").when(mojoSpy).getDeploymentStageDirectory(); doReturn("target").when(mojoSpy).getBuildDirectoryAbsolutePath(); doReturn(mock(MavenProject.class)).when(mojoSpy).getProject(); doReturn(mock(MavenSession.class)).when(mojoSpy).getSession(); doReturn(mock(MavenResourcesFiltering.class)).when(mojoSpy).getMavenResourcesFiltering(); mojoSpy.doExecute(); }
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 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; }
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); } }
/** * This is copied from {@link ClasspathHelper}, but there's a bug when using default packages, so the implementation is changed. * * @param aClass * @param classLoaders * @return */ public static URL forClass(Class<?> aClass, ClassLoader... classLoaders) { final ClassLoader[] loaders = ClasspathHelper.classLoaders(classLoaders); final String resourceName = aClass.getName().replace(".", "/") + ".class"; for (ClassLoader classLoader : loaders) { try { final URL url = classLoader.getResource(resourceName); if (url != null) { Package aPackage = aClass.getPackage(); String externalForm = url.toExternalForm(); if(aPackage != null) { String convertedPackageName = aPackage.getName().replace(".", "/"); final String normalizedUrl = externalForm.substring(0, externalForm.lastIndexOf(convertedPackageName)); return new URL(normalizedUrl); } return url; } } catch (MalformedURLException e) { if (Reflections.log != null) { Reflections.log.warn("Could not get URL", e); } } } return null; }
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); }
/** * Derives the OpenGamma build from the classpath and dependencies. * * @return the build, null if not known */ public static String deriveBuild() { URL url = ClasspathHelper.forClass(VersionUtils.class, VersionUtils.class.getClassLoader()); if (url != null && url.toString().contains(".jar")) { try { final String part = ClasspathHelper.cleanPath(url); try (JarFile myJar = new JarFile(part)) { final Manifest manifest = myJar.getManifest(); if (manifest != null) { Attributes attributes = manifest.getMainAttributes(); if (attributes != null) { if (attributes.getValue(IMPLEMENTATION_BUILD) != null) { return attributes.getValue(IMPLEMENTATION_BUILD); } } } } } catch (Exception ex) { s_logger.warn(ex.getMessage(), ex); } } return null; }
/** * Derives the OpenGamma build ID from the classpath and dependencies. * <p> * This ID is derived from the CI server. * * @return the build ID, null if not known */ public static String deriveBuildId() { URL url = ClasspathHelper.forClass(VersionUtils.class, VersionUtils.class.getClassLoader()); if (url != null && url.toString().contains(".jar")) { try { final String part = ClasspathHelper.cleanPath(url); try (JarFile myJar = new JarFile(part)) { final Manifest manifest = myJar.getManifest(); if (manifest != null) { Attributes attributes = manifest.getMainAttributes(); if (attributes != null) { if (attributes.getValue(IMPLEMENTATION_BUILD_ID) != null) { return attributes.getValue(IMPLEMENTATION_BUILD_ID); } } } } } catch (Exception ex) { s_logger.warn(ex.getMessage(), ex); } } return null; }
/** * 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); } }
/** * Creates an Anno4j instance that can use the concepts contained in the given JAR file. * @param ontologyJar A JAR file containing concepts. * @param classLoader The class loader to use. * @param persistSchemaAnnotations Whether schema annotations should be scanned. * @return Returns an Anno4j instance. * @throws Exception Thrown on error. */ private static Anno4j getAnno4jWithClassLoader(File ontologyJar, ClassLoader classLoader, boolean persistSchemaAnnotations) throws Exception { Set<URL> clazzes = new HashSet<>(); clazzes.addAll(ClasspathHelper.forManifest(ontologyJar.toURI().toURL())); Anno4j anno4j = new Anno4j(new SailRepository(new MemoryStore()), new IDGeneratorAnno4jURN(), null, persistSchemaAnnotations, clazzes); // Register concepts found in JAR: RoleMapper mapper = anno4j.getObjectRepository().getConnection().getObjectFactory().getResolver().getRoleMapper(); for (final String className : getClassNamesInJar(ontologyJar)) { Class<?> clazz = classLoader.loadClass(className); if(clazz.getAnnotation(Iri.class) != null) { mapper.addConcept(clazz); } } return anno4j; }
@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); }