Refine search
ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(true); provider.addIncludeFilter(new AssignableTypeFilter(MyClass.class)); // scan in org.example.package Set<BeanDefinition> components = provider.findCandidateComponents("org/example/package"); for (BeanDefinition component : components) { Class cls = Class.forName(component.getBeanClassName()); // use class cls found }
@Test public void antStylePackageWithIndex() { ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(true); provider.setResourceLoader(new DefaultResourceLoader(TEST_BASE_CLASSLOADER)); testAntStyle(provider, AnnotatedGenericBeanDefinition.class); }
@Test public void excludeFilterWithIndex() { ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(true); provider.setResourceLoader(new DefaultResourceLoader(TEST_BASE_CLASSLOADER)); provider.addExcludeFilter(new RegexPatternTypeFilter(Pattern.compile(TEST_BASE_PACKAGE + ".*Named.*"))); testExclude(provider, AnnotatedGenericBeanDefinition.class); }
/** * Create a ClassPathScanningCandidateComponentProvider with the given {@link Environment}. * @param useDefaultFilters whether to register the default filters for the * {@link Component @Component}, {@link Repository @Repository}, * {@link Service @Service}, and {@link Controller @Controller} * stereotype annotations * @param environment the Environment to use * @see #registerDefaultFilters() */ public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters, Environment environment) { if (useDefaultFilters) { registerDefaultFilters(); } setEnvironment(environment); setResourceLoader(null); }
private ClassPathScanningCandidateComponentProvider createComponentProvider() { ClassPathScanningCandidateComponentProvider componentProvider = new ClassPathScanningCandidateComponentProvider( false); componentProvider.setEnvironment(this.applicationContext.getEnvironment()); componentProvider.setResourceLoader(this.applicationContext); for (ServletComponentHandler handler : HANDLERS) { componentProvider.addIncludeFilter(handler.getTypeFilter()); } return componentProvider; }
private void scanPluginsPackage(ClassPathScanningCandidateComponentProvider scanner, String packageName) throws Exception { Set<BeanDefinition> beans = scanner.findCandidateComponents(packageName); for (BeanDefinition bean : beans) { Class<?> clazz = Class.forName(bean.getBeanClassName()); KaaPluginConfig annotation = clazz.getAnnotation(KaaPluginConfig.class); PluginConfig pluginConfig = (PluginConfig) clazz.newInstance(); RecordField fieldConfiguration = FormAvroConverter.createRecordFieldFromSchema(pluginConfig.getPluginConfigSchema()); PluginInfoDto pluginInfo = new PluginInfoDto(pluginConfig.getPluginTypeName(), fieldConfiguration, pluginConfig.getPluginClassName()); pluginsInfo.get(annotation.pluginType()).put(pluginInfo.getPluginClassName(), pluginInfo); } }
@Test public void testWithInterfaceType() { ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false); provider.addIncludeFilter(new AssignableTypeFilter(FooDao.class)); Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_BASE_PACKAGE); assertEquals(1, candidates.size()); assertTrue(containsBeanClass(candidates, StubFooDao.class)); }
public Collection<String> getCandidates(ResourceLoader loader) { ClassPathScanningCandidateComponentProvider scanner = new RepositoryComponentProvider(getIncludeFilters()); scanner.setResourceLoader(loader); for (TypeFilter filter : getExcludeFilters()) { scanner.addExcludeFilter(filter); } Set<String> result = new HashSet<String>(); for (String basePackage : getBasePackages()) { Collection<BeanDefinition> components = scanner.findCandidateComponents(basePackage); for (BeanDefinition definition : components) { result.add(definition.getBeanClassName()); } } return result; }
@Override public void afterPropertiesSet() throws Exception { ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false); scanner.addIncludeFilter(new AnnotationTypeFilter(KaaPluginConfig.class)); scanPluginsPackage(scanner, "org.kaaproject.kaa.server.appenders"); scanPluginsPackage(scanner, "org.kaaproject.kaa.server.verifiers"); if (!isEmpty(additionalPluginsScanPackage)) { scanPluginsPackage(scanner, additionalPluginsScanPackage); } simpleSchemaFormAvroConverter = new SimpleSchemaFormAvroConverter(); commonSchemaFormAvroConverter = new SchemaFormAvroConverter(); configurationSchemaFormAvroConverter = new ConfigurationSchemaFormAvroConverter(); ecfSchemaFormAvroConverter = new EcfSchemaFormAvroConverter(); }
scanner.addIncludeFilter(typeFilter); scanner.addIncludeFilter(typeFilter); scanner.addExcludeFilter(typeFilter); scanner.setResourceLoader(this.resourceLoader); Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage); for (BeanDefinition candidateComponent : candidateComponents) { if (candidateComponent instanceof AnnotatedBeanDefinition) {
private Set<BeanDefinition> findCandidateBeanDefinitions(ImplementationDetectionConfiguration config) { String postfix = config.getImplementationPostfix(); ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false, environment); provider.setResourceLoader(resourceLoader); provider.setResourcePattern(String.format(CUSTOM_IMPLEMENTATION_RESOURCE_PATTERN, postfix)); provider.setMetadataReaderFactory(config.getMetadataReaderFactory()); provider.addIncludeFilter((reader, factory) -> true); config.getExcludeFilters().forEach(it -> provider.addExcludeFilter(it)); return config.getBasePackages().stream()// .flatMap(it -> provider.findCandidateComponents(it).stream())// .collect(Collectors.toSet()); }
private Stream<Class<?>> findBySuperType(Collection<String> packages, Class<?> type) { ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider( false); scanner.setResourceLoader(appContext); scanner.addIncludeFilter(new AssignableTypeFilter(type)); return packages.stream().map(scanner::findCandidateComponents) .flatMap(set -> set.stream()).map(this::getBeanClass); }
@Test public void bogusPackageWithIndex() { ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(true); provider.setResourceLoader(new DefaultResourceLoader(TEST_BASE_CLASSLOADER)); Set<BeanDefinition> candidates = provider.findCandidateComponents("bogus"); assertEquals(0, candidates.size()); }
private void testCustomAnnotationTypeIncludeFilter(ClassPathScanningCandidateComponentProvider provider, Class<? extends BeanDefinition> expectedBeanDefinitionType) { provider.addIncludeFilter(new AnnotationTypeFilter(Component.class)); testDefault(provider, expectedBeanDefinitionType); }
@Nullable private BeanDefinition getCustomConversions(Element element, ParserContext parserContext) { List<Element> customConvertersElements = DomUtils.getChildElementsByTagName(element, "custom-converters"); if (customConvertersElements.size() == 1) { Element customerConvertersElement = customConvertersElements.get(0); ManagedList<BeanMetadataElement> converterBeans = new ManagedList<>(); List<Element> converterElements = DomUtils.getChildElementsByTagName(customerConvertersElement, "converter"); if (converterElements != null) { for (Element listenerElement : converterElements) { converterBeans.add(parseConverter(listenerElement, parserContext)); } } // Scan for Converter and GenericConverter beans in the given base-package String packageToScan = customerConvertersElement.getAttribute(BASE_PACKAGE); if (StringUtils.hasText(packageToScan)) { ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(true); provider.addExcludeFilter(new NegatingFilter(new AssignableTypeFilter(Converter.class), new AssignableTypeFilter(GenericConverter.class))); converterBeans.addAll(provider.findCandidateComponents(packageToScan)); } BeanDefinitionBuilder conversionsBuilder = BeanDefinitionBuilder.rootBeanDefinition(MongoCustomConversions.class); conversionsBuilder.addConstructorArgValue(converterBeans); AbstractBeanDefinition conversionsBean = conversionsBuilder.getBeanDefinition(); conversionsBean.setSource(parserContext.extractSource(element)); parserContext.registerBeanComponent(new BeanComponentDefinition(conversionsBean, "customConversions")); return conversionsBean; } return null; }
@Test public void testWithInactiveProfile() { ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(true); ConfigurableEnvironment env = new StandardEnvironment(); env.setActiveProfiles("other"); provider.setEnvironment(env); Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_PROFILE_PACKAGE); assertThat(containsBeanClass(candidates, ProfileAnnotatedComponent.class), is(false)); }
@Test public void testWithNoFilters() { ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false); Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_BASE_PACKAGE); assertEquals(0, candidates.size()); }
public EntityViewComponentProvider(Iterable<? extends TypeFilter> includeFilters) { super(false); Assert.notNull(includeFilters); if (includeFilters.iterator().hasNext()) { for (TypeFilter filter : includeFilters) { addIncludeFilter(filter); } } else { super.addIncludeFilter(new AnnotationTypeFilter(EntityView.class, false, false)); } super.addExcludeFilter(new TypeFilter() { @Override public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException { return !metadataReader.getAnnotationMetadata().hasAnnotation(EntityView.class.getName()); } }); }
private void testCustomAssignableTypeIncludeFilter(ClassPathScanningCandidateComponentProvider provider, Class<? extends BeanDefinition> expectedBeanDefinitionType) { provider.addIncludeFilter(new AssignableTypeFilter(FooService.class)); Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_BASE_PACKAGE); // Interfaces/Abstract class are filtered out automatically. assertTrue(containsBeanClass(candidates, AutowiredQualifierFooService.class)); assertTrue(containsBeanClass(candidates, FooServiceImpl.class)); assertTrue(containsBeanClass(candidates, ScopedProxyTestBean.class)); assertEquals(3, candidates.size()); assertBeanDefinitionType(candidates, expectedBeanDefinitionType); }
private void scanPackage( ClassPathScanningCandidateComponentProvider componentProvider, String packageToScan) { for (BeanDefinition candidate : componentProvider .findCandidateComponents(packageToScan)) { if (candidate instanceof ScannedGenericBeanDefinition) { for (ServletComponentHandler handler : HANDLERS) { handler.handle(((ScannedGenericBeanDefinition) candidate), (BeanDefinitionRegistry) this.applicationContext); } } } }