Java 类org.reflections.Reflections 实例源码

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);
}

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;
}

@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();
    }
}