Refine search
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) { ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry, componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader); scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator : BeanUtils.instantiateClass(generatorClass)); scanner.setScopedProxyMode(scopedProxyMode); scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass)); scanner.setResourcePattern(componentScan.getString("resourcePattern")); scanner.addIncludeFilter(typeFilter); scanner.addExcludeFilter(typeFilter); scanner.getBeanDefinitionDefaults().setLazyInit(true); scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) { @Override protected boolean matchClassName(String className) { return scanner.doScan(StringUtils.toStringArray(basePackages));
private ApplicationContext createContext(ScopedProxyMode scopedProxyMode) { GenericWebApplicationContext context = new GenericWebApplicationContext(); ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context); scanner.setIncludeAnnotationConfig(false); scanner.setBeanNameGenerator((definition, registry) -> definition.getScope()); scanner.setScopedProxyMode(scopedProxyMode); // Scan twice in order to find errors in the bean definition compatibility check. scanner.scan(getClass().getPackage().getName()); scanner.scan(getClass().getPackage().getName()); context.refresh(); return context; }
@Override public boolean checkCandidate(String beanName, BeanDefinition beanDefinition) throws IllegalStateException { return super.checkCandidate(beanName, beanDefinition); }
/** * Create a new {@code ClassPathBeanDefinitionScanner} for the given bean factory and * using the given {@link Environment} when evaluating bean definition profile metadata. * @param registry the {@code BeanFactory} to load bean definitions into, in the form * of a {@code BeanDefinitionRegistry} * @param useDefaultFilters whether to include the default filters for the * {@link org.springframework.stereotype.Component @Component}, * {@link org.springframework.stereotype.Repository @Repository}, * {@link org.springframework.stereotype.Service @Service}, and * {@link org.springframework.stereotype.Controller @Controller} stereotype annotations * @param environment the Spring {@link Environment} to use when evaluating bean * definition profile metadata * @param resourceLoader the {@link ResourceLoader} to use * @since 4.3.6 */ public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment, @Nullable ResourceLoader resourceLoader) { Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); this.registry = registry; if (useDefaultFilters) { registerDefaultFilters(); } setEnvironment(environment); setResourceLoader(resourceLoader); }
protected void parseBeanNameGenerator(Element element, ClassPathBeanDefinitionScanner scanner) { if (element.hasAttribute(NAME_GENERATOR_ATTRIBUTE)) { BeanNameGenerator beanNameGenerator = (BeanNameGenerator) instantiateUserDefinedStrategy( element.getAttribute(NAME_GENERATOR_ATTRIBUTE), BeanNameGenerator.class, scanner.getResourceLoader().getClassLoader()); scanner.setBeanNameGenerator(beanNameGenerator); } }
protected void parseScope(Element element, ClassPathBeanDefinitionScanner scanner) { // Register ScopeMetadataResolver if class name provided. if (element.hasAttribute(SCOPE_RESOLVER_ATTRIBUTE)) { if (element.hasAttribute(SCOPED_PROXY_ATTRIBUTE)) { throw new IllegalArgumentException( "Cannot define both 'scope-resolver' and 'scoped-proxy' on <component-scan> tag"); } ScopeMetadataResolver scopeMetadataResolver = (ScopeMetadataResolver) instantiateUserDefinedStrategy( element.getAttribute(SCOPE_RESOLVER_ATTRIBUTE), ScopeMetadataResolver.class, scanner.getResourceLoader().getClassLoader()); scanner.setScopeMetadataResolver(scopeMetadataResolver); } if (element.hasAttribute(SCOPED_PROXY_ATTRIBUTE)) { String mode = element.getAttribute(SCOPED_PROXY_ATTRIBUTE); if ("targetClass".equals(mode)) { scanner.setScopedProxyMode(ScopedProxyMode.TARGET_CLASS); } else if ("interfaces".equals(mode)) { scanner.setScopedProxyMode(ScopedProxyMode.INTERFACES); } else if ("no".equals(mode)) { scanner.setScopedProxyMode(ScopedProxyMode.NO); } else { throw new IllegalArgumentException("scoped-proxy only supports 'no', 'interfaces' and 'targetClass'"); } } }
@Test public void testSimpleScanWithDefaultFiltersAndSameBeanTwice() { GenericApplicationContext context = new GenericApplicationContext(); ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context); scanner.setIncludeAnnotationConfig(false); // should not fail! scanner.scan(BASE_PACKAGE); scanner.scan(BASE_PACKAGE); }
@Override public BeanDefinition parse(Element element, ParserContext parserContext) { final Iterable<String> basePackages = getBasePackages(element); if (!plugins3Available()) { log.debug("Plugins 3 not available, aborting scanning of packages: {}", basePackages); return null; } else { log.debug("Scanning packages {} for spring components"); } registerAutowireAnnotationPostProcessor(parserContext, element, "__component_import", ComponentImport.class); registerAutowireAnnotationPostProcessor(parserContext, element, "__inject", Inject.class); final ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(parserContext.getRegistry(), false); scanner.setBeanNameGenerator(new NamedAnnotationBeanNameGenerator()); scanner.addIncludeFilter(new AnnotationTypeFilter(Named.class)); scanner.addIncludeFilter(new AnnotationTypeFilter(PublicComponent.class)); scanner.setResourceLoader(parserContext.getReaderContext().getResourceLoader()); scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults()); final int scanned = scanner.scan(toArray(basePackages, String.class)); log.debug("Found {} components scanning packages {}", scanned, basePackages); new ComponentImportScanBeanDefinitionParser().parse(element, parserContext); new PublicComponentBeanDefinitionParser().parse(element, parserContext); return null; }
/** * Create a new AnnotationConfigApplicationContext that needs to be populated * through {@link #register} calls and then manually {@linkplain #refresh refreshed}. */ public AnnotationConfigApplicationContext() { this.reader = new AnnotatedBeanDefinitionReader(this); this.scanner = new ClassPathBeanDefinitionScanner(this); }
@Test public void testCustomIncludeFilterWithoutDefaultsButIncludingPostProcessors() { GenericApplicationContext context = new GenericApplicationContext(); ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context, false); scanner.addIncludeFilter(new AnnotationTypeFilter(CustomComponent.class)); int beanCount = scanner.scan(BASE_PACKAGE); assertEquals(6, beanCount); assertTrue(context.containsBean("messageBean")); assertTrue(context.containsBean(AnnotationConfigUtils.AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)); assertTrue(context.containsBean(AnnotationConfigUtils.COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)); assertTrue(context.containsBean(AnnotationConfigUtils.EVENT_LISTENER_PROCESSOR_BEAN_NAME)); assertTrue(context.containsBean(AnnotationConfigUtils.EVENT_LISTENER_FACTORY_BEAN_NAME)); }
@Test public void testMultipleBasePackagesWithDefaultsOnly() { GenericApplicationContext singlePackageContext = new GenericApplicationContext(); ClassPathBeanDefinitionScanner singlePackageScanner = new ClassPathBeanDefinitionScanner(singlePackageContext); GenericApplicationContext multiPackageContext = new GenericApplicationContext(); ClassPathBeanDefinitionScanner multiPackageScanner = new ClassPathBeanDefinitionScanner(multiPackageContext); int singlePackageBeanCount = singlePackageScanner.scan(BASE_PACKAGE); assertEquals(12, singlePackageBeanCount); multiPackageScanner.scan(BASE_PACKAGE, "org.springframework.dao.annotation"); // assertTrue(multiPackageBeanCount > singlePackageBeanCount); }
reader.setBeanNameGenerator(beanNameGenerator); scanner.setBeanNameGenerator(beanNameGenerator); beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator); reader.setScopeMetadataResolver(scopeMetadataResolver); scanner.setScopeMetadataResolver(scopeMetadataResolver); StringUtils.collectionToCommaDelimitedString(this.annotatedClasses) + "]"); reader.register(ClassUtils.toClassArray(this.annotatedClasses)); StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]"); scanner.scan(StringUtils.toStringArray(this.basePackages)); "] - trying package scan. " + ex); int count = scanner.scan(configLocation); if (count == 0 && logger.isDebugEnabled()) { logger.debug("No annotated classes found for specified class/package [" + configLocation + "]");
@Test public void testBeanAutowiredWithAnnotationConfigEnabled() { GenericApplicationContext context = new GenericApplicationContext(); context.registerBeanDefinition("myBf", new RootBeanDefinition(StaticListableBeanFactory.class)); ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context); scanner.setBeanNameGenerator(new TestBeanNameGenerator()); int beanCount = scanner.scan(BASE_PACKAGE); assertEquals(12, beanCount); context.refresh(); FooServiceImpl fooService = context.getBean("fooService", FooServiceImpl.class); StaticListableBeanFactory myBf = (StaticListableBeanFactory) context.getBean("myBf"); MessageSource ms = (MessageSource) context.getBean("messageSource"); assertTrue(fooService.isInitCalled()); assertEquals("bar", fooService.foo(123)); assertEquals("bar", fooService.lookupFoo(123)); assertSame(context.getDefaultListableBeanFactory(), fooService.beanFactory); assertEquals(2, fooService.listableBeanFactory.size()); assertSame(context.getDefaultListableBeanFactory(), fooService.listableBeanFactory.get(0)); assertSame(myBf, fooService.listableBeanFactory.get(1)); assertSame(context, fooService.resourceLoader); assertSame(context, fooService.resourcePatternResolver); assertSame(context, fooService.eventPublisher); assertSame(ms, fooService.messageSource); assertSame(context, fooService.context); assertEquals(1, fooService.configurableContext.length); assertSame(context, fooService.configurableContext[0]); assertSame(context, fooService.genericContext); }
@Override public Set<BeanDefinitionHolder> doScan(String... basePackages) { return super.doScan(basePackages); }
public void scan( String[] basePackages, TypeFilter[] excludedTypes ) { ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner( this, true, getEnvironment(), this ); scanner.setBeanNameGenerator( beanNameGenerator ); scanner.setScopeMetadataResolver( scopeMetadataResolver ); scanner.setResourcePattern( "**/*.class" ); for ( TypeFilter filter : excludedTypes ) { scanner.addExcludeFilter( filter ); } scanner.scan( basePackages ); } }
@Override public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { AnnotationAttributes annotationAttributes = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(GRpcServerScan.class.getCanonicalName())); if (annotationAttributes == null) { log.warn("GrpcScan was not found.Please check your configuration."); return; } ClassPathBeanDefinitionScanner classPathGrpcApiScanner = new ClassPathBeanDefinitionScanner(registry, false); classPathGrpcApiScanner.setResourceLoader(this.resourceLoader); classPathGrpcApiScanner.addIncludeFilter(new AnnotationTypeFilter(GRpcApi.class)); List<String> basePackages = AutoConfigurationPackages.get(this.beanFactory); for (String pkg : annotationAttributes.getStringArray("basePackages")) { if (StringUtils.hasText(pkg)) { basePackages.add(pkg); } } classPathGrpcApiScanner.scan(StringUtils.toStringArray(basePackages)); } }
private ApplicationContext createContext(final ScopedProxyMode scopedProxyMode) { GenericWebApplicationContext context = new GenericWebApplicationContext(); ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context); scanner.setIncludeAnnotationConfig(false); scanner.setScopeMetadataResolver(new ScopeMetadataResolver() { @Override public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) { scanner.scan(getClass().getPackage().getName()); scanner.scan(getClass().getPackage().getName());
private ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, BeanDefinitionRegistry registry) { XmlReaderContext readerContext = parserContext.getReaderContext(); // Delegate bean definition registration to scanner class. ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry, false); scanner.setIncludeAnnotationConfig(false); scanner.addIncludeFilter(new AnnotationTypeFilter(Entity.class)); scanner.setResourceLoader(readerContext.getResourceLoader()); scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults()); scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns()); return scanner; } }
@Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { if (beanFactory instanceof BeanDefinitionRegistry) { try { BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory; ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry); scanner.setResourceLoader(applicationContext); scanner.scan("io.github.saluki.monitor.rest"); } catch (Throwable e) { log.error(e.getMessage(), e); } } }
protected ClassPathBeanDefinitionScanner createClassPathBeanDefinitionScanner() { ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this); ClassLoader classLoader = scanner.getResourceLoader().getClassLoader(); scanner.addIncludeFilter(createTypeFilter("annotation", AutoConfig.class.getName(), classLoader)); scanner.setBeanNameGenerator(new ConfigAnnotationBeanNameGenerator()); return scanner; }