public static void main(String[] args) throws Exception { Reflections reflections = new Reflections(); LukkitPlus.BUKKIT_EVENTS = reflections.getSubTypesOf(Event.class); ClassPool classpath = ClassPool.getDefault(); CtClass eventClass = classpath.makeClass("online.pizzacrust.lukkitplus" + ".EventCallback"); for (Class<? extends Event> event : LukkitPlus.BUKKIT_EVENTS) { CtMethod eventMethod = CtNewMethod.make(CtClass.voidType, "on" + event.getSimpleName (), new CtClass[] { classpath.get(event.getName()) }, new CtClass[0], "online" + ".pizzacrust.lukkitplus.EventCallbackGenerator.call($1);", eventClass); eventClass.addMethod(eventMethod); AnnotationsAttribute attribute = new AnnotationsAttribute(eventClass.getClassFile() .getConstPool(), AnnotationsAttribute.visibleTag); Annotation eventHandlerAnnt = new Annotation(EventHandler.class.getName(), eventClass .getClassFile().getConstPool()); attribute.addAnnotation(eventHandlerAnnt); eventMethod.getMethodInfo().addAttribute(attribute); } System.out.println("Done!"); eventClass.writeFile(); }
@SuppressWarnings("unchecked") private void registerAnnotations() { final Reflections reflections = new Reflections(packagePrefix); final Set<Class<?>> namedClasses = reflections.getTypesAnnotatedWith(Named.class); for (final Class<?> namedClass : namedClasses) { final ServiceReference reference = namedClassReference(namedClass); final Constructor<?> namedConstructor = constructorFinder.apply(namedClass); final ServiceReference<?>[] parameters = stream(namedConstructor.getParameterTypes()) .map(NamedClassReference::namedClassReference) .toArray(ServiceReference<?>[]::new); accept(serviceDefinition( namedClassReference(namedClass), constructor(reference, namedConstructor, parameters), postConstructDependencyFinder.apply(namedClass) )); stream(serviceFromMethodFinder.apply(namedClass)).forEach(this); } }
private static void loadSchemas() { Set<String> scan = SchemaScanSettings.SCAN_CLASSPATH; Map<Integer, NamedSchema> tmp = Maps.newHashMap(); for (String pkg : scan) { Reflections reflections = new Reflections(pkg); Set<Class<? extends CustomRecord>> classes = reflections.getSubTypesOf(CustomRecord.class); for (Class<? extends CustomRecord> cls : classes) { RecordSchema schema = getSchema(cls); if (!schema.isIdSchema() && schema.getType() != Type.ENUM) { System.out.println("Found schema " + schema.getName() + " with id " + schema.getShortId()); tmp.put(schema.getShortId(), schema); } } } idToName.putAll(tmp); }
@Override @RequestMapping(value = ApiConfig.PROVIDERS_BASE + "/schema", method = RequestMethod.GET, headers = ApiConfig.API_HEADERS, produces = {ApiConfig.API_PRODUCES}) @ResponseBody public String getRelationships( @CookieValue(value = SessionManager.SESSION_COOKIE, required = false) final String sessionId, final HttpServletResponse response) throws NoSuchProviderException, NoSuchSessionException { GenerateSchema drawer = new GenerateSchema(); List<Class<? extends Item>> items = new ArrayList<>(); if (rateLimiter.tryAcquire()) { Reflections reflections = new Reflections("com"); Set<Class<? extends Item>> subTypes = reflections.getSubTypesOf(Item.class); for (Class<? extends Item> class1 : subTypes) { items.add(class1); } } Session session = modelValidator.validateSession(sessionId, response); return drawer.process(stitcher, items, session.getProviders().keySet()); }
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); }
/** * 获取方法映射map * * @param reflections 反射类列表 * @return 方法映射map */ private Map<String, ServerMethod> getMethodMap(Reflections reflections) throws IllegalAccessException, InstantiationException { // 获取HermesService注解类 Set<Class<?>> classes = reflections.getTypesAnnotatedWith(HermesService.class); Map<String, ServerMethod> map = new TreeMap<>(); for (Class<?> c : classes) { for (Method method : c.getDeclaredMethods()) { Object object = c.newInstance(); HermesMapping hermesMapping = method.getAnnotation(HermesMapping.class); if (hermesMapping != null) { map.put(hermesMapping.value(), new ServerMethod(object, method)); } } } return map; }
private void searchRouters(RouteRegister register, String pacakge) { Reflections reflections = new Reflections(pacakge); Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(Route.class); for (Class<?> c : annotated) { Route annotation = c.getAnnotation(Route.class); try { if (annotation.method().length > 0) register.registerRouter(annotation.method()[0], annotation.path(), (Handler<RoutingContext>) c.newInstance()); else register.registerRouter(annotation.path(), (Handler<RoutingContext>) c.newInstance()); } catch (InstantiationException | IllegalAccessException | RegisterException e) { e.printStackTrace(); } } }
/** * Auto register classes annotated with `Service` */ private void autoRegister() { Reflections reflections = ReflectKit.getReflections(appClass); // scan inject annotated class Set<Class<?>> types = reflections.getTypesAnnotatedWith(Service.class); types.forEach(this::recursiveRegisterType); // cache constructors types.forEach(t -> { try { ConstructorWalker.findInjectConstructor(t); } catch (Exception e) { log.error(e.getMessage()); } }); }
private Set<Class<?>> doGetClasses() { String packages = servletContext.getInitParameter(OryxApplication.class.getName() + ".packages"); log.info("Creating JAX-RS from endpoints in package(s) {}", packages); Objects.requireNonNull(packages); Set<Class<?>> classes = new HashSet<>(); for (String thePackage : packages.split(",")) { Reflections reflections = new Reflections(thePackage); classes.addAll(getClassesInPackageAnnotatedBy(thePackage, reflections, Path.class)); classes.addAll(getClassesInPackageAnnotatedBy(thePackage, reflections, Produces.class)); classes.addAll(getClassesInPackageAnnotatedBy(thePackage, reflections, Provider.class)); } // Want to configure these globally, but not depend on Jersey, even though it's // what will be used in practice by the provided apps. for (String optionalJerseyClass : new String[] { "org.glassfish.jersey.message.DeflateEncoder", "org.glassfish.jersey.message.GZipEncoder", "org.glassfish.jersey.server.filter.EncodingFilter"}) { if (ClassUtils.classExists(optionalJerseyClass)) { classes.add(ClassUtils.loadClass(optionalJerseyClass)); } } log.debug("Found JAX-RS resources: {}", classes); return classes; }
/** * Initialize customized implements of some features */ private void initImplements() { Reflections reflections = ReflectKit.getReflections(appClass); // Exception handler Set<Class<? extends ExceptionHandler>> exceptionHandlers = reflections.getSubTypesOf(ExceptionHandler.class); if (exceptionHandlers.size() > 0) { this.exceptionHandler = ioc.resolve(exceptionHandlers.iterator().next()); } // Session manager Set<Class<? extends SessionManager>> sessionManagers = reflections.getSubTypesOf(SessionManager.class); if (sessionManagers.size() > 0) { this.sessionManager = ioc.resolve(sessionManagers.iterator().next()); } }
public void start() { Reflections reflections = new Reflections(packages); Set<Class<? extends ConsumerAble>> subTypes = reflections.getSubTypesOf(ConsumerAble.class); for(Class<? extends ConsumerAble> consumerAble : subTypes){ ConsumerAble consumer = ArgumentExtractors.instantiateComponent(beanFactory,consumerAble,null); consumer.init(this); } consumerMap.forEach((cid, consumerId) -> { Map<String, Tag> tagMap = consumerId.getTagMap(); for (Map.Entry<String, Tag> tagEntry : tagMap.entrySet()) { Tag tag = tagEntry.getValue(); Object invokeObj = ArgumentExtractors.instantiateComponent(beanFactory, tag.getInvokeCls(), null); tagEntry.getValue().setInvokeObject(invokeObj); } new ConsumerRun(accessKey, secretKey, suffix, consumerId).start(); }); }
private static void populateMap(final Map<String, FsConnRuleCommand<FsConnRuleCmdParamBean, FsConnRuleCmdResultBean>> commands) { final String commandPackage = "com.espirit.moddev.fstesttools.rules.firstspirit.commands"; LOGGER.info("Scanning class path in '{}' for command classes...", commandPackage); Reflections reflections = new Reflections(commandPackage); Set<Class<? extends FsConnRuleCommand>> commandsFromPackage = reflections.getSubTypesOf(FsConnRuleCommand.class); int counter = 0; for (Class<? extends FsConnRuleCommand> commandClass : commandsFromPackage) { if (commandClass.isAnonymousClass()) { continue; } LOGGER.debug("Processing '{}'...", commandClass.getSimpleName()); counter = handleEnumCommands(commands, counter, commandClass); counter = handleSimpleCommands(commands, counter, commandClass); } LOGGER.info("Loaded {} commands!", counter); }
/** * Get fields for a type. It extracts all JsonProperty fields * @param type * @return */ public static String[] getIncludeFields(Class type) { if (!fieldsCache.containsKey(type.getTypeName())) { Reflections reflections = new Reflections(type.getCanonicalName(), new FieldAnnotationsScanner()); List<String> ret = new ArrayList<>(); for (Field field : reflections.getFieldsAnnotatedWith(JsonProperty.class)) { JsonProperty property = field.getAnnotation(JsonProperty.class); ret.add(property.value()); } if (type.getSuperclass() != null) { ret.addAll(Arrays.asList(getIncludeFields(type.getSuperclass()))); } fieldsCache.putIfAbsent(type.getTypeName(), ret.toArray(new String[ret.size()])); } return fieldsCache.get(type.getTypeName()); }
public void load() { Reflections reflect = new Reflections(new Object[]{Manager.class}); Set managers = reflect.getSubTypesOf(Manager.class); float progress = 0; for (Object obj : managers) { Class objClass = (Class)obj; try { progress += 100.0f / managers.size(); Manager manager = (Manager)objClass.newInstance(); this.managers.add(manager); ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft()); ProgressBar progressBar = new ProgressBar(scaledresolution.getScaledWidth() / 2, scaledresolution.getScaledHeight() / 2, 100, 10, progress, "Loading Managers " + this.managers.size() + " / " + managers.size(), -1); ProgressBarList.addProgress(0, progressBar); Thread.sleep(10); } catch (Exception e) {;} } this.managers.sort((o2, o1) -> o2.getLoadLevel() - o1.getLoadLevel()); }
private static int getAmountOfEndpointTests() { Reflections reflections = new Reflections("io.teiler.server.endpoints"); Set<Class<? extends BaseEndpointControllerTest>> allClasses = reflections.getSubTypesOf(BaseEndpointControllerTest.class); LOGGER.trace("Amount of test classes: " + allClasses.size()); int amountOfTestMethods = 0; for (Class<? extends BaseEndpointControllerTest> c : allClasses) { for (Method m : c.getDeclaredMethods()) { if (m.isAnnotationPresent(Test.class)) { amountOfTestMethods++; } } } LOGGER.trace("Amount of test methods: " + amountOfTestMethods); return amountOfTestMethods; }
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(); } }
EventListener() { final Reflections loader = new Reflections("jukebot.commands"); Set<Class<?>> discoveredCommands = loader.getTypesAnnotatedWith(CommandProperties.class); JukeBot.LOG.info("Discovered " + discoveredCommands.size() + " commands"); for (Class klass : discoveredCommands) { try { final Command cmd = (Command) klass.newInstance(); if (!cmd.properties().enabled()) continue; commands.put(cmd.name().toLowerCase(), cmd); } catch (InstantiationException | IllegalAccessException e) { JukeBot.LOG.error("An error occurred while creating a new instance of command '" + klass.getName() + "'"); } } }
public static List<Class<? extends DataFieldDefinition>> listTags() { Reflections reflections = new Reflections("de.gwdg.metadataqa.marc.definition.tags"); Set<Class<? extends DataFieldDefinition>> subTypes = reflections.getSubTypesOf(DataFieldDefinition.class); Comparator<Class<? extends DataFieldDefinition>> byTag = (e1, e2) -> e1.getSimpleName().compareTo(e2.getSimpleName()); List<Class<? extends DataFieldDefinition>> tags = new ArrayList<>(); subTypes .stream() .sorted(byTag) .forEach((Class tagClass) -> { tags.add(tagClass); }); return tags; }
public static void main(String[] args) throws FileNotFoundException { if (args.length != 1) throw new IllegalArgumentException("Missing argument 0: Path to write routes"); Reflections reflections = new Reflections("io.t2l.matrix.homeserver.federation.transport.http.routes"); Set<Class<?>> routedClasses = reflections.getTypesAnnotatedWith(Route.class); try (PrintWriter writer = new PrintWriter(args[0])) { writer.println("# !!!!! This file is automatically generated !!!!!"); writer.println("# ! Any changes you make may not be saved. Use !"); writer.println("# ! `gradle buildRoutes` to change these routes !"); writer.println("# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); for (Class<?> clazz : routedClasses) { String route = clazz.getAnnotation(Route.class).value(); writer.println("rest." + route + "=" + clazz.getName()); System.out.println("Writing route " + route + " for class " + clazz.getName()); } } }
public AlgorithmServiceImpl() { map = new HashMap<>(); List<URL> urlList = new ArrayList<>(); for(String f:System.getProperty("java.class.path").split(":")){ System.err.println(f); try { urlList.add(new File(f).toURI().toURL()); } catch (IOException e) { e.printStackTrace(); } } URL[] urls = urlList.toArray(new URL[0]); Reflections reflections = new Reflections("jobreading.algorithm.experiment",new MethodAnnotationsScanner(),urls); for(Method method : reflections.getMethodsAnnotatedWith(Algorithm.class)){ final Algorithm my = method.getAnnotation(Algorithm.class); Class<?> clazz = method.getDeclaringClass(); if (null != my) { map.put(my.name(), clazz); } } }
private void autoloadPackage(String path, Consumer<Reflectionable> callback) { Set<Class<? extends Reflectionable>> types = new Reflections(path).getSubTypesOf(Reflectionable.class); Class[] arguments = new Class[1]; arguments[0] = AvaIre.class; for (Class<? extends Reflectionable> reflectionClass : types) { if (reflectionClass.getPackage().getName().contains("contracts")) { continue; } try { callback.accept(reflectionClass.getDeclaredConstructor(arguments).newInstance(this)); } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) { getLogger().error("Failed to create a new instance of package {}", reflectionClass.getName(), e); } } }
private <T> Collection<PluginDesc<T>> getPluginDesc( Reflections reflections, Class<T> klass, ClassLoader loader ) throws InstantiationException, IllegalAccessException { Set<Class<? extends T>> plugins = reflections.getSubTypesOf(klass); Collection<PluginDesc<T>> result = new ArrayList<>(); for (Class<? extends T> plugin : plugins) { if (PluginUtils.isConcrete(plugin)) { // Temporary workaround until all the plugins are versioned. if (Connector.class.isAssignableFrom(plugin)) { result.add( new PluginDesc<>( plugin, ((Connector) plugin.newInstance()).version(), loader ) ); } else { result.add(new PluginDesc<>(plugin, "undefined", loader)); } } } return result; }
private Set<Class<?>> scanTypes(String packageName) { Reflections reflections = new Reflections(packageName, new MethodAnnotationsScanner()); Set<Class<?>> types = new HashSet<>(); types.addAll(typesAnnotatedWith(reflections, Given.class)); types.addAll(typesAnnotatedWith(reflections, When.class)); types.addAll(typesAnnotatedWith(reflections, Then.class)); types.addAll(typesAnnotatedWith(reflections, Before.class)); types.addAll(typesAnnotatedWith(reflections, After.class)); types.addAll(typesAnnotatedWith(reflections, BeforeScenario.class)); types.addAll(typesAnnotatedWith(reflections, AfterScenario.class)); types.addAll(typesAnnotatedWith(reflections, BeforeStory.class)); types.addAll(typesAnnotatedWith(reflections, AfterStory.class)); types.addAll(typesAnnotatedWith(reflections, BeforeStories.class)); types.addAll(typesAnnotatedWith(reflections, AfterStories.class)); types.addAll(typesAnnotatedWith(reflections, AsParameterConverter .class)); return types; }
/** * Loads the processes * * @return {@code Set<Class<? extends Process>>} */ private Set<Class<? extends Process>> loadProcesses() { Reflections reflections = new Reflections(); Set<Class<? extends Process>> classes = reflections. getSubTypesOf(Process.class).stream(). collect(Collectors.toSet()); classes.add(DynamicPixelProcess.class); classes.add(ObjectExtractionProcess.class); classes.add(InputProcess.class); return Collections.unmodifiableSet(classes); }
private Set<Class<? extends ILoggerFactory>> scanContextForLoggerFactories() { final Set<Class<? extends ILoggerFactory>> loggerFactories; final Collection<URL> set = ClasspathHelper.forPackage(PACKAGE_TO_SCAN); final Reflections reflections = new Reflections(new ConfigurationBuilder().addUrls(set).setScanners(new SubTypesScanner())); loggerFactories = reflections.getSubTypesOf(ILoggerFactory.class); loggerFactories.remove(this.getClass()); return loggerFactories; }
/** * Instantiates a new Cas logger factory. * Configures the reflection scanning engine to be prepared to scan <code>org.slf4j.impl</code> * in order to find other available factories. */ public CasLoggerFactory() { this.loggerMap = new ConcurrentHashMap<>(); final Collection<URL> set = ClasspathHelper.forPackage(PACKAGE_TO_SCAN); final Reflections reflections = new Reflections(new ConfigurationBuilder().addUrls(set).setScanners(new SubTypesScanner())); final Set<Class<? extends ILoggerFactory>> subTypesOf = reflections.getSubTypesOf(ILoggerFactory.class); subTypesOf.remove(this.getClass()); if (subTypesOf.size() > 1) { Util.report("Multiple ILoggerFactory bindings are found on the classpath:"); for (final Class<? extends ILoggerFactory> c : subTypesOf) { Util.report("* " + c.getCanonicalName()); } } if (subTypesOf.isEmpty()) { final RuntimeException e = new RuntimeException("No ILoggerFactory could be found on the classpath." + " CAS cannot determine the logging framework." + " Examine the project dependencies and ensure that there is one and only one logging framework available."); Util.report(e.getMessage(), e); throw e; } this.realLoggerFactoryClass = subTypesOf.iterator().next(); Util.report("ILoggerFactory to be used for logging is: " + this.realLoggerFactoryClass.getName()); }
private Map<String, Rule> gatherRules() { Map<String, Rule> defaultRules = new HashMap<>(); Reflections reflections = new Reflections("com.rdavis.swagger.rules.impl"); Set<Class<? extends RuleV2>> classes = reflections.getSubTypesOf(RuleV2.class); for (Class classRule : classes) { try { RuleV2 rule = (RuleV2) classRule.newInstance(); defaultRules.put(CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, rule.getRuleName()), rule); } catch (Exception e) { LOGGER.error("Exception occurred creating rule " + classRule, e); } } return defaultRules; }
public static Set<Class<? extends ObjectPayload>> getPayloadClasses () { final Reflections reflections = new Reflections(ObjectPayload.class.getPackage().getName()); final Set<Class<? extends ObjectPayload>> payloadTypes = reflections.getSubTypesOf(ObjectPayload.class); for ( Iterator<Class<? extends ObjectPayload>> iterator = payloadTypes.iterator(); iterator.hasNext(); ) { Class<? extends ObjectPayload> pc = iterator.next(); if ( pc.isInterface() || Modifier.isAbstract(pc.getModifiers()) ) { iterator.remove(); } } return payloadTypes; }
public OidcProfileScopeToAttributesFilter(final PrincipalFactory principalFactory, final ServicesManager servicesManager, final Collection<BaseOidcScopeAttributeReleasePolicy> userScopes, final OidcAttributeToScopeClaimMapper attributeToScopeClaimMapper) { this.attributeToScopeClaimMapper = attributeToScopeClaimMapper; this.filters = new HashMap<>(); final String packageName = BaseOidcScopeAttributeReleasePolicy.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 BaseOidcScopeAttributeReleasePolicy>> subTypes = reflections.getSubTypesOf(BaseOidcScopeAttributeReleasePolicy.class); subTypes.forEach(Unchecked.consumer(t -> { final BaseOidcScopeAttributeReleasePolicy ex = t.newInstance(); filters.put(ex.getScopeName(), ex); })); userScopes.forEach(t -> filters.put(t.getScopeName(), t)); this.principalFactory = principalFactory; this.servicesManager = servicesManager; this.userScopes = userScopes; }
private static Collection<Class<?>> getClassesInPackageAnnotatedBy( String thePackage, Reflections reflections, Class<? extends Annotation> annotation) { // Filter classes actually in subpackages return reflections.getTypesAnnotatedWith(annotation).stream(). filter(c -> c.getPackage().getName().equals(thePackage)). collect(Collectors.toList()); }
public void scan(List<String> scanPackages) { ExecutionTimer timer = new ExecutionTimer(LogLevel.Info, true); for (String scanPackage : scanPackages) { logger.debug("Scanning for limberest services in package: {}", scanPackage); Reflections reflect = new Reflections(scanPackage); // service classes for (Class<?> classWithPath : reflect.getTypesAnnotatedWith(Path.class)) { logger.info("Found service class: {}", classWithPath.getName()); Path pathAnnotation = classWithPath.getAnnotation(Path.class); if (pathAnnotation != null) { String path = pathAnnotation.value(); if (path != null) { logger.info(" -> and registering with path: {}", path); Produces producesAnnotation = classWithPath.getAnnotation(Produces.class); if (producesAnnotation != null && producesAnnotation.value() != null) { // TODO can only produce one thing and consume if present must match produce Consumes consumesAnnotation = classWithPath.getAnnotation(Consumes.class); for (String contentType : producesAnnotation.value()) { logger.info(" -> for content-type: {}", contentType); @SuppressWarnings({"unchecked", "rawtypes"}) Class<? extends RestService<?>> serviceClass = (Class)classWithPath.asSubclass(RestService.class); if (!RestService.class.isAssignableFrom(serviceClass)) throw new IllegalArgumentException(serviceClass + " does not extend " + RestService.class); RegistryKey key = new RegistryKey(new ResourcePath(path), contentType); ServiceRegistry.getInstance().put(key, serviceClass); } } } } } } if (timer.isEnabled()) timer.log("limberest initializer scanned " + scanPackages.size() + " packages in "); }
/** * {@link Reflections} bean. * * @return bean */ @Bean public Reflections reflections() { return new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forPackage(SCAN_PACKAGE)) .setScanners(new MethodAnnotationsScanner())); }
private static List<Class> getTestClasses(String folderName) { Reflections reflections = new Reflections(folderName); Set<Class<? extends LambdaBaseTest>> allClasses = reflections.getSubTypesOf(LambdaBaseTest.class); List<Class> classes = new ArrayList<>(); classes.addAll(allClasses); return classes; }
private static List<Class> getSubClasses(final Class<?> clazz) { final Set<URL> urls = new HashSet<>(); urls.addAll(ClasspathHelper.forPackage("uk.gov.gchq")); final List<Class> classes = new ArrayList<Class>(new Reflections(urls).getSubTypesOf(clazz)); keepPublicConcreteClasses(classes); classes.removeIf(c -> c.getName().contains("uk.gov.gchq.gaffer.doc")); classes.removeAll(SYSTEM_CLASSES); classes.sort(Comparator.comparing(Class::getName)); return classes; }
private <CLASS> LinkedHashSet<Class<? extends CLASS>> getSubClasses(final Class<?> clazz, final String packageName) { final Set<URL> urls = new HashSet<>(ClasspathHelper.forPackage("gaffer")); final List<Class<? extends CLASS>> classes = new ArrayList(new Reflections(urls).getSubTypesOf(clazz)); keepPublicConcreteClasses(classes); keepClassesInPackage(classes, packageName); Collections.sort(classes, new Comparator<Class>() { @Override public int compare(final Class class1, final Class class2) { return class1.getName().compareTo(class2.getName()); } }); return Sets.newLinkedHashSet((Iterable) classes); }
@Autowired public TaskService(TaskRepository taskRepository, TaskMapper taskMapper, Scheduler scheduler) { this.taskRepository = taskRepository; this.taskMapper = taskMapper; this.scheduler = scheduler; this.jobTypeSet = new Reflections(Constants.JOBS_PACKAGE).getSubTypesOf(Job.class); }
@Autowired public FlowService(FlowRepository flowRepository, FlowMapper flowMapper, SubscriberService subscriberService) { this.flowRepository = flowRepository; this.flowMapper = flowMapper; this.subscriberService = subscriberService; this.eventTypeSet = new Reflections(Constants.EVENTS_PACKAGE).getSubTypesOf(SentryEvent.class); }
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"); }
/** * 发现服务, 查找所有扩展了abstractService的类, 这些类保存下来作为service */ private static void findService() { try { Reflections reflections = new Reflections("com.recklessMo.rpc"); Set<Class<?>> classSet = reflections.getTypesAnnotatedWith(RpcServiceFlag.class, true); for (Class<?> inner : classSet) { RpcServiceFlag rpcServiceFlag = inner.getAnnotation(RpcServiceFlag.class); if (!serverMap.containsKey(rpcServiceFlag.value())) { serverMap.put(rpcServiceFlag.value(), inner.newInstance()); } } } catch (Exception e) { e.printStackTrace(); } }