Java ConfigurationBuilder.setScanners方法代码示例

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
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);
}
 

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
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);
}
 

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
public static void initialize() {
	// Scan for json configuration files on the classpath
	ConfigurationBuilder builder = new ConfigurationBuilder();
	builder.setScanners(new ResourcesScanner());
	builder.setUrls(ClasspathHelper.forClassLoader(
			ClasspathHelper.contextClassLoader(),
			ClasspathHelper.staticClassLoader()));

	reflections = new Reflections(builder);
	json = new Json();
	for (String path : reflections.getResources(Pattern.compile(".*\\.json"))) {
		if (!path.startsWith("items") && !path.startsWith("tiles") && !path.startsWith("walls"))
			continue;

		FileHandle file = Gdx.files.internal(path);
		Type type = json.fromJson(null, file);
		registerType(type);
	}

	airItem = getItem("airItem");
	airTile = getTile("airTile");
	airWall = getWall("airWall");
}
 

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
private static void RegisterActors(Binder binder) {
	Logger.debug("Actor Scanner Started...");
	final Map<String, ActorHolder> map = new HashMap<>();		
	final ConfigurationBuilder configBuilder = build();
	final Reflections reflections = new Reflections(configBuilder.setScanners(new SubTypesScanner()));
	final Set<Class<? extends UntypedActor>> actors = reflections.getSubTypesOf(UntypedActor.class);
       final Set<Class<? extends AbstractActor>> abstractActors = reflections.getSubTypesOf(AbstractActor.class);
       loopOnActors(map, actors);
       loopOnAbstractActors(map, abstractActors);
       if(!map.isEmpty()) Logger.debug("Registering actors: ");
	for(final String key : map.keySet()) {
		final ActorHolder actorHolder = map.get(key);
		final Class<? extends Actor> actor = actorHolder.getActor();
		if(actorHolder.isSingleton()) {
			Logger.debug("Binding class " + actor.getSimpleName() + " to name: " + key + " Singleton Scoped.");
			binder.bind(ActorRef.class).annotatedWith(Names.named(key)).toProvider(new ActorRefProvider(actor, key, true)).in(Singleton.class);
		} else {
			Logger.debug("Binding class " + actor.getSimpleName() + " to name: " + key + " Request Scoped.");
			binder.bind(ActorRef.class).annotatedWith(Names.named(key)).toProvider(new ActorRefProvider(actor, key, false));
			PropsContext.put(key, actorHolder);
		}
	}
}
 

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
@Path("virtualips")
public Object retrieveVirtualIpsResource() throws IllegalAccessException, InstantiationException {
    String enabledExtension = PluginConfiguration.getExtensionPrefix();
    ConfigurationBuilder configBuilder = new ConfigurationBuilder();
    configBuilder.addUrls(ClasspathHelper.forPackage("org.daylight.pathweaver." + enabledExtension + ".api"));

    // TODO: Decompose this out and dynamically resolve sub-resource base off of extensions prefix
    Reflections reflections = new Reflections(configBuilder.setScanners(new SubTypesScanner()));
    Set<Class<? extends VirtualIpsResource>> subTypes = reflections.getSubTypesOf(VirtualIpsResource.class);

    if (subTypes.iterator().hasNext()) {
        final Class<? extends VirtualIpsResource> subClass = subTypes.iterator().next();
        final VirtualIpsResource bean = PluginContextLoaderListener.getCurrentWebApplicationContext().getBean(subClass);
        bean.setLoadBalancerId(id);
        bean.setAccountId(accountId);
        return bean;
    } else {
        virtualIpsResource.setLoadBalancerId(id);
        virtualIpsResource.setAccountId(accountId);
        return  virtualIpsResource;
    }
}
 

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
@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;
    }
 

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
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;
}
 

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
@Override
public List<String> getDataMapperNames() {

    List<ClassLoader> classLoadersList = new LinkedList<>();
    classLoadersList.add(ClasspathHelper.contextClassLoader());
    classLoadersList.add(ClasspathHelper.staticClassLoader());

    ConfigurationBuilder cb = new ConfigurationBuilder();
    cb.setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner());
    cb.setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0])));

    FilterBuilder fb = new FilterBuilder();

    for (Package aPackage : getSearchPackages()) {
        fb.include(FilterBuilder.prefix(aPackage.getName()));
    }
    cb.filterInputsBy(fb);
    Reflections reflections = new Reflections(cb);

    Set<Class<?>> subTypesOf =
            reflections.getSubTypesOf(Object.class);

    ArrayList<String> collected = subTypesOf.stream()
            .map(Class::getSimpleName)
            .collect(Collectors.toCollection(ArrayList::new));

    return collected;

}
 

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
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()));
}
 

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
private static Reflections configureReflection(Bundle bundle, ClassLoader classLoader, Scanner... scanners) {
    ConfigurationBuilder configuration = new ConfigurationBuilder();
    configuration.addUrls(resolveLocation(bundle));
    configuration.setScanners(scanners);

    // we add the ability to load classes from the bundle
    configuration.addClassLoader(classLoader);

    LOGGER.debug("Initialized Reflections configuration");

    return new Reflections(configuration);
}
 

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
private void registerHealthChecks(Binder binder) {
	Logger.debug("registerHealthChecks");
	final ConfigurationBuilder configBuilder = build(namespaces);
	final Reflections reflections = new Reflections(configBuilder.setScanners(new SubTypesScanner()));
	Set<Class<? extends HealthCheck>> checks = reflections.getSubTypesOf(HealthCheck.class);
	for(Class<? extends HealthCheck> check : checks) {
		Logger.debug("Heathcheck bound: " + check.getName());
		binder.bind(HealthCheck.class).annotatedWith(Names.named("PlayGuiceStatsD-HealthCheck-" + check.getName())).to(check);
	}
	binder.bind(ActorRef.class).annotatedWith(Names.named("PlayGuiceStatsD-HealthCheckActor")).toProvider(new ActorRefProvider(checks)).in(Singleton.class);
}
 

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
/**
 * This is not entirely reliable method.
 * Maybe it would be better to rely on Spring ClassPathScanningCandidateComponentProvider
 */
public static void searchClasses(String packageName, Consumer<Class> consumer) {
    ConfigurationBuilder builder = new ConfigurationBuilder();
    builder.setScanners(new SubTypesScanner(false));
    builder.setUrls(ClasspathHelper.forPackage(packageName, LOGGER.getClass().getClassLoader()));
    builder.setInputsFilter(new FilterBuilder().includePackage(packageName));

    Reflections reflections = new Reflections(builder);

    Multimap<String, String> map = reflections.getStore().get(SubTypesScanner.class.getSimpleName());
    Set<String> types = new HashSet<>();

    for (String key : map.keySet()) {
        Collection<String> col = map.get(key);
        if (col == null) {
            continue;
        }

        for (String c : col) {
            String simpleName = c.replaceFirst(packageName + "\\.", "");
            if (simpleName.contains(".")) {
                continue;
            }

            types.add(c);
        }
    }

    for (String type : types) {
        try {
            Class clazz = Class.forName(type);
            consumer.accept(clazz);
        } catch (ClassNotFoundException e) {
            LOGGER.error("Error during loading class {}. ", type);
        }
    }
}
 

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
static void ScheduleOnceActors() {
	final ConfigurationBuilder configBuilder = build();
	final Reflections reflections = new Reflections(configBuilder.setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()));
	final Set<Class<?>> schedules = reflections.getTypesAnnotatedWith(ScheduleOnce.class);
	if(!schedules.isEmpty()) Logger.debug("Scheduling actors once:");
	for(final Class<?> scheduleOnce : schedules) {
		final ActorRef actor = Akka.system().actorOf(GuiceProvider.get(Akka.system()).props((Class<? extends Actor>) scheduleOnce));
		final ScheduleOnce annotation = scheduleOnce.getAnnotation(ScheduleOnce.class);
		long initialDelay = 0;
		TimeUnit timeUnit = TimeUnit.MILLISECONDS;
		String configName = scheduleOnce.getName() + ".initialDelay";
		String configEnabled = scheduleOnce.getName() + ".enabled";
		if(config.getString(configEnabled) != null && !config.getBoolean(configEnabled)) continue;
		if(config.getString(configName) != null) {
			initialDelay = getTime(config.getString(configName));
			timeUnit = getTimeUnit(config.getString(configName));
		} else {
			initialDelay = annotation.initialDelay();
			timeUnit = annotation.timeUnit();
		}
		Akka.system().scheduler().scheduleOnce(
				Duration.apply(initialDelay, timeUnit),
				actor,
				"tick",
				Akka.system().dispatcher(),
				null);
		Logger.debug(scheduleOnce + " on delay: " + initialDelay + " " + timeUnit);
	}
}
 

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
public static Set<Class<?>> getClassesWithAnnotation(Class<? extends Annotation> annotation, String[] packageNames) {
    Reflections reflections;
    Set<Class<?>> classes = new HashSet<Class<?>>();
    ConfigurationBuilder builder=new ConfigurationBuilder();
    for (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;
}
 

import org.reflections.util.ConfigurationBuilder; //导入方法依赖的package包/类
private List<String> findEntities() {
	final ConfigurationBuilder c = new ConfigurationBuilder();
	c.setUrls(ClasspathHelper.forPackage(PACKAGE));
	c.setScanners(new TypeAnnotationsScanner());
	final Reflections reflections = new Reflections(c);
	final Set<Class<?>> entities = reflections.getTypesAnnotatedWith(Entity.class);
	final List<String> entityClassNameList = new ArrayList<String>(entities.size());
	for (final Class<?> entity : entities) {
		entityClassNameList.add(entity.getName());
	}
	return entityClassNameList;
}