Example usage for org.springframework.context.annotation ClassPathBeanDefinitionScanner addIncludeFilter

Introduction

In this page you can find the example usage for org.springframework.context.annotation ClassPathBeanDefinitionScanner addIncludeFilter.

Prototype

public void addIncludeFilter(TypeFilter includeFilter) 

Source Link

Document

Add an include type filter to the end of the inclusion list.

Usage

From source file:org.opentides.bean.factory.support.BaseEntityRegistry.java

@Override
public void afterPropertiesSet() throws Exception {
    if (packagesToScan == null)
        packagesToScan = new ArrayList<String>();
    packagesToScan.add("org.opentides.bean");
    baseEntities = new ArrayList<String>();
    BeanDefinitionRegistry registry = new SimpleBeanDefinitionRegistry();
    ClassPathBeanDefinitionScanner s = new ClassPathBeanDefinitionScanner(registry);
    TypeFilter tf = new AssignableTypeFilter(BaseEntity.class);
    s.resetFilters(false);/*from   w w  w.j  a  va  2 s. c  o  m*/
    s.addIncludeFilter(tf);
    s.scan(packagesToScan.toArray(new String[packagesToScan.size()]));
    for (String name : registry.getBeanDefinitionNames()) {
        Class<?> clazz = Class.forName(registry.getBeanDefinition(name).getBeanClassName());
        if (BaseEntity.class.isAssignableFrom(clazz))
            baseEntities.add(registry.getBeanDefinition(name).getBeanClassName());
    }
}

---

From source file:com.codestd.spring.cxf.config.EndpointBeanProcessor.java

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    if (annotationPackage == null || annotationPackage.length() == 0) {
        return;/*from  w  w w.ja v  a 2s.c  o  m*/
    }

    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry beanDefinitionRegistry = (BeanDefinitionRegistry) beanFactory;
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(beanDefinitionRegistry,
                true);

        AnnotationTypeFilter filter = new AnnotationTypeFilter(Endpoint.class);
        scanner.addIncludeFilter(filter);

        scanner.scan(annotationPackages);
    }
}

---

From source file:info.sargis.eventbus.config.EventBusHandlerBeanDefinitionParser.java

protected void parseTypeFilters(Element element, ClassPathBeanDefinitionScanner scanner,
        XmlReaderContext readerContext, ParserContext parserContext) {

    // Parse exclude and include filter elements.
    ClassLoader classLoader = scanner.getResourceLoader().getClassLoader();
    NodeList nodeList = element.getChildNodes();
    for (int i = 0; i < nodeList.getLength(); i++) {
        Node node = nodeList.item(i);
        if (node.getNodeType() == Node.ELEMENT_NODE) {
            String localName = parserContext.getDelegate().getLocalName(node);
            try {
                if (INCLUDE_FILTER_ELEMENT.equals(localName)) {
                    TypeFilter typeFilter = createTypeFilter((Element) node, classLoader);
                    scanner.addIncludeFilter(typeFilter);
                } else if (EXCLUDE_FILTER_ELEMENT.equals(localName)) {
                    TypeFilter typeFilter = createTypeFilter((Element) node, classLoader);
                    scanner.addExcludeFilter(typeFilter);
                }/*from ww w.j av a 2s . co  m*/
            } catch (Exception ex) {
                readerContext.error(ex.getMessage(), readerContext.extractSource(element), ex.getCause());
            }
        }
    }
}

---

From source file:org.elasticsoftware.elasticactors.spring.AnnotationConfigWebApplicationContext.java

/**
 * Register a {@link org.springframework.beans.factory.config.BeanDefinition} for
 * any classes specified by {@link #register(Class...)} and scan any packages
 * specified by {@link #scan(String...)}.
 * <p>For any values specified by {@link #setConfigLocation(String)} or
 * {@link #setConfigLocations(String[])}, attempt first to load each location as a
 * class, registering a {@code BeanDefinition} if class loading is successful,
 * and if class loading fails (i.e. a {@code ClassNotFoundException} is raised),
 * assume the value is a package and attempt to scan it for annotated classes.
 * <p>Enables the default set of annotation configuration post processors, such that
 * {@code @Autowired}, {@code @Required}, and associated annotations can be used.
 * <p>Configuration class bean definitions are registered with generated bean
 * definition names unless the {@code value} attribute is provided to the stereotype
 * annotation.//from w w w . j  ava  2  s. co m
 * @see #register(Class...)
 * @see #scan(String...)
 * @see #setConfigLocation(String)
 * @see #setConfigLocations(String[])
 * @see AnnotatedBeanDefinitionReader
 * @see ClassPathBeanDefinitionScanner
 */
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {
    AnnotatedBeanDefinitionReader reader = new AnnotatedBeanDefinitionReader(beanFactory);
    reader.setEnvironment(this.getEnvironment());

    ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(beanFactory);
    scanner.setEnvironment(this.getEnvironment());

    BeanNameGenerator beanNameGenerator = getBeanNameGenerator();
    ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();
    if (beanNameGenerator != null) {
        reader.setBeanNameGenerator(beanNameGenerator);
        scanner.setBeanNameGenerator(beanNameGenerator);
        beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
                beanNameGenerator);
    }
    if (scopeMetadataResolver != null) {
        reader.setScopeMetadataResolver(scopeMetadataResolver);
        scanner.setScopeMetadataResolver(scopeMetadataResolver);
    }

    if (!this.annotatedClasses.isEmpty()) {
        if (logger.isInfoEnabled()) {
            logger.info("Registering annotated classes: ["
                    + StringUtils.collectionToCommaDelimitedString(this.annotatedClasses) + "]");
        }
        reader.register(this.annotatedClasses.toArray(new Class<?>[this.annotatedClasses.size()]));
    }

    if (!this.basePackages.isEmpty()) {
        if (logger.isInfoEnabled()) {
            logger.info("Scanning base packages: ["
                    + StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]");
        }
        for (TypeFilter typeFilter : includeFilters) {
            scanner.addIncludeFilter(typeFilter);
        }
        scanner.scan(this.basePackages.toArray(new String[this.basePackages.size()]));
    }

    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        for (String configLocation : configLocations) {
            try {
                Class<?> clazz = getClassLoader().loadClass(configLocation);
                if (logger.isInfoEnabled()) {
                    logger.info("Successfully resolved class for [" + configLocation + "]");
                }
                reader.register(clazz);
            } catch (ClassNotFoundException ex) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Could not load class for config location [" + configLocation
                            + "] - trying package scan. " + ex);
                }
                int count = scanner.scan(configLocation);
                if (logger.isInfoEnabled()) {
                    if (count == 0) {
                        logger.info("No annotated classes found for specified class/package [" + configLocation
                                + "]");
                    } else {
                        logger.info(
                                "Found " + count + " annotated classes in package [" + configLocation + "]");
                    }
                }
            }
        }
    }
}

---

From source file:org.codehaus.groovy.grails.context.annotation.ClosureClassIgnoringComponentScanBeanDefinitionParser.java

@Override
protected ClassPathBeanDefinitionScanner createScanner(XmlReaderContext readerContext,
        boolean useDefaultFilters) {
    final ClassPathBeanDefinitionScanner scanner = super.createScanner(readerContext, useDefaultFilters);
    BeanDefinitionRegistry beanDefinitionRegistry = readerContext.getRegistry();

    GrailsPluginManager pluginManager = null;

    if (beanDefinitionRegistry instanceof HierarchicalBeanFactory) {
        HierarchicalBeanFactory beanFactory = (HierarchicalBeanFactory) beanDefinitionRegistry;
        BeanFactory parent = beanFactory.getParentBeanFactory();
        if (parent != null && parent.containsBean(GrailsPluginManager.BEAN_NAME)) {
            pluginManager = parent.getBean(GrailsPluginManager.BEAN_NAME, GrailsPluginManager.class);
        }/*  ww  w .j av  a2 s.  co  m*/
    }

    if (pluginManager != null) {
        List<TypeFilter> typeFilters = pluginManager.getTypeFilters();
        for (TypeFilter typeFilter : typeFilters) {
            scanner.addIncludeFilter(typeFilter);
        }
    }
    return scanner;
}

---

From source file:org.tinygroup.springmvc.coc.ConventionBeanDefinitionRegistryPostProcessor.java

private void addTypeFilters(ClassPathBeanDefinitionScanner scaner) {
    if (conventionComponentIdentifierComposite == null
            || CollectionUtil.isEmpty(conventionComponentIdentifierComposite)) {
        return;//from w  w  w .ja  v a  2  s  .com
    }
    List<ConventionComponentIdentifier> identifiers = conventionComponentIdentifierComposite;
    if (CollectionUtil.isEmpty(identifiers)) {
        return;
    }
    for (final ConventionComponentIdentifier identifier : identifiers) {
        scaner.addIncludeFilter(new TypeFilter() {

            public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
                    throws IOException {
                boolean match = identifier.isComponent(metadataReader.getClassMetadata().getClassName());
                if (match) {
                    if (metadataReader.getAnnotationMetadata().hasAnnotation(RequestMapping.class.getName())
                            || metadataReader.getAnnotationMetadata()
                                    .hasAnnotatedMethods(RequestMapping.class.getName())) {
                        return false;
                    }
                }
                return match;
            }

        });

    }

}

---