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

List of usage examples for org.springframework.context.annotation ClassPathScanningCandidateComponentProvider addIncludeFilter

Introduction

In this page you can find the example usage for org.springframework.context.annotation ClassPathScanningCandidateComponentProvider 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:natalia.dymnikova.cluster.scheduler.impl.requirements.ComputeMemberRequirementsBuilder.java

private Entry<Field, Set<ScannedGenericBeanDefinition>> scan(TypeFilterWithField filter) {
    final ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
            false, scannerEnvironment);/*from   www .  ja  v a2s  . c  o m*/

    scanner.setResourceLoader(resourcePatternResolver);
    scanner.setMetadataReaderFactory(metadataReaderFactory);

    scanner.resetFilters(false);
    scanner.addIncludeFilter(new CompositeFilter(new AnnotationTypeFilter(Component.class), filter));

    final Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);

    final Set<ScannedGenericBeanDefinition> collect = candidateComponents.stream()
            .map(bd -> (ScannedGenericBeanDefinition) bd).collect(toSet());

    return new SimpleEntry<>(filter.field, collect);
}

From source file:com.newtranx.util.cassandra.spring.AccessorScannerConfigurer.java

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory context) throws BeansException {
    ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
            false) {/*from   w  w w  .jav  a 2  s .co  m*/

        @Override
        protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
            return beanDefinition.getMetadata().isInterface();
        }

    };
    scanner.addIncludeFilter(new AnnotationTypeFilter(Accessor.class));
    for (BeanDefinition bd : scanner.findCandidateComponents(basePackage)) {
        Class<?> accessorCls;
        try {
            accessorCls = Class.forName(bd.getBeanClassName());
        } catch (ClassNotFoundException e) {
            throw new AssertionError(e);
        }
        log.info("Creating proxy accessor: " + accessorCls.getName());
        MethodInterceptor interceptor = new MethodInterceptor() {

            private final Lazy<?> target = new Lazy<>(() -> {
                log.info("Creating actual accessor: " + accessorCls.getName());
                Session session;
                if (AccessorScannerConfigurer.this.session == null)
                    session = mainContext.getBean(Session.class);
                else
                    session = AccessorScannerConfigurer.this.session;
                MappingManager mappingManager = new MappingManager(session);
                return mappingManager.createAccessor(accessorCls);
            });

            @Override
            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
                    throws Throwable {
                if ("toString".equals(method.getName())) {
                    return accessorCls.getName();
                }
                return method.invoke(target.get(), args);
            }

        };
        Enhancer enhancer = new Enhancer();
        enhancer.setInterfaces(new Class<?>[] { accessorCls });
        enhancer.setCallback(interceptor);
        Object bean = enhancer.create();
        String beanName = StringUtils.uncapitalize(accessorCls.getSimpleName());
        context.registerSingleton(beanName, bean);
        log.info("Bean registed, name=" + beanName + ", bean=" + bean.toString());
    }
}

From source file:edu.rit.flick.config.FileArchiverExtensionRegistry.java

/**
 * Constructs the file archiver extension registry and scans for
 * FileArchiver classes./*from  w  w  w.  j  a  va2s .  c  o m*/
 */
private FileArchiverExtensionRegistry() {
    registry = new HashMap<String, FileDeflatorInflator>();
    deflationOptionSets = new ArrayList<DeflationOptionSet>();
    inflationOptionSets = new ArrayList<InflationOptionSet>();

    final ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
            false) {
        @Override
        protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
            return beanDefinition.getMetadata().isIndependent();
        }
    };

    scanner.addIncludeFilter(new AnnotationTypeFilter(RegisterFileDeflatorInflator.class));

    for (final BeanDefinition bd : scanner.findCandidateComponents("*")) {
        try {
            final Class<?> cl = Class.forName(bd.getBeanClassName());
            final RegisterFileDeflatorInflator fileDIP = cl.getAnnotation(RegisterFileDeflatorInflator.class);
            if (fileDIP != null)
                registerFileArchiverExtensions(fileDIP);
        } catch (Exception e) {
        }
    }
}

From source file:natalia.dymnikova.cluster.scheduler.impl.RolesChecker.java

private List<Set<ScannedGenericBeanDefinition>> scan(final String basePackage, final List<TypeFilter> filters) {
    final ArrayList<Set<ScannedGenericBeanDefinition>> sets = new ArrayList<>(filters.size());

    final ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
            false, scannerEnvironment);//from w w w.j a  v a  2 s.c o  m

    scanner.setResourceLoader(resourcePatternResolver);
    scanner.setMetadataReaderFactory(metadataReaderFactory);

    for (final TypeFilter filter : filters) {
        scanner.resetFilters(false);
        scanner.addIncludeFilter(new CompositeFilter(new AnnotationTypeFilter(Component.class), filter));

        final Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);

        final Set<ScannedGenericBeanDefinition> collect = candidateComponents.stream()
                .map(bd -> (ScannedGenericBeanDefinition) bd).collect(toSet());

        sets.add(collect);
    }

    scanner.clearCache();

    return sets;
}

From source file:com.mmnaseri.dragonfly.runtime.session.ApplicationSessionPreparator.java

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory context) throws BeansException {
    showDeprecationWarning();/*  ww w .j a v  a2s  . co  m*/
    long time = System.nanoTime();
    log.warn(
            "Preparing the session at runtime can be harmful to your performance. You should consider switching to "
                    + "the Maven plugin.");
    log.debug("Looking up the necessary components ...");
    tableMetadataRegistry = context.getBean(TableMetadataRegistry.class);
    statementRegistry = context.getBean(StatementRegistry.class);
    final ModifiableEntityContext entityContext = context.getBean(ModifiableEntityContext.class);
    final ClassPathScanningCandidateComponentProvider componentProvider = new ClassPathScanningCandidateComponentProvider(
            false);
    log.info("Finding entity classes ...");
    log.debug("Looking for classes with @Entity");
    componentProvider.addIncludeFilter(new AnnotationTypeFilter(Entity.class));
    if (parentClassLoader == null) {
        log.debug("Falling back to the application context class loader");
        parentClassLoader = context.getBeanClassLoader();
    }
    for (String basePackage : basePackages) {
        final Set<BeanDefinition> beanDefinitions = componentProvider.findCandidateComponents(basePackage);
        for (BeanDefinition beanDefinition : beanDefinitions) {
            try {
                log.debug("Registering entity " + beanDefinition.getBeanClassName());
                //noinspection unchecked
                definitionContext.addDefinition(new ImmutableEntityDefinition<Object>(
                        ClassUtils.forName(beanDefinition.getBeanClassName(), parentClassLoader),
                        Collections.<Class<?>, Class<?>>emptyMap()));
            } catch (ClassNotFoundException e) {
                throw new FatalBeanException("Failed to retrieve class: " + beanDefinition.getBeanClassName(),
                        e);
            }
        }
    }
    componentProvider.resetFilters(false);
    log.info("Finding extensions to the data access ...");
    log.debug("Looking for classes with @Extension");
    componentProvider.addIncludeFilter(new AnnotationTypeFilter(Extension.class));
    final AnnotationExtensionMetadataResolver extensionMetadataResolver = new AnnotationExtensionMetadataResolver(
            metadataResolver);
    for (String basePackage : basePackages) {
        final Set<BeanDefinition> beanDefinitions = componentProvider.findCandidateComponents(basePackage);
        for (BeanDefinition beanDefinition : beanDefinitions) {
            try {
                log.debug("Registering extension " + beanDefinition.getBeanClassName());
                extensionManager.addExtension(extensionMetadataResolver
                        .resolve(ClassUtils.forName(beanDefinition.getBeanClassName(), parentClassLoader)));
            } catch (ClassNotFoundException e) {
                throw new FatalBeanException("Failed to retrieve class: " + beanDefinition.getBeanClassName(),
                        e);
            }
        }
    }
    log.info("Preparing entity statements for later use");
    final StatementRegistryPreparator preparator = new StatementRegistryPreparator(databaseDialect,
            resolverContext, tableMetadataRegistry);
    for (Class<?> entity : definitionContext.getEntities()) {
        preparator.addEntity(entity);
    }
    preparator.prepare(statementRegistry);
    log.info("Registering interfaces with the context");
    entityContext.setInterfaces(
            with(definitionContext.getEntities()).map(new Transformer<Class<?>, Map<Class<?>, Class<?>>>() {
                @Override
                public Map<Class<?>, Class<?>> map(Class<?> input) {
                    //noinspection unchecked
                    final EntityDefinition<Object> definition = extensionManager
                            .intercept(new ImmutableEntityDefinition<Object>((Class<Object>) input,
                                    Collections.<Class<?>, Class<?>>emptyMap()));
                    return definition.getInterfaces();
                }
            }));
    if (initializeSession) {
        final DataAccessSession session = context.getBean(DataAccessSession.class);
        session.initialize();
        session.markInitialized();
    }
    log.info("Setting the class loader for the entity context");
    entityContext.setDefaultClassLoader(context.getBeanClassLoader());
    time = System.nanoTime() - time;
    log.info("Session preparation took " + Math.round((double) time / 1000000d) / 1000d + " second(s)");
}

From source file:org.synyx.hades.dao.config.DaoConfigDefinitionParser.java

/**
 * Tries to detect a custom implementation for a DAO bean by classpath
 * scanning.//w w  w. j  a  va  2  s  .  c  om
 * 
 * @param context
 * @param parser
 * @return the {@code BeanDefinition} of the custom implementation or null
 *         if none found
 */
private AbstractBeanDefinition detectCustomImplementation(final DaoContext context,
        final ParserContext parser) {

    // Build pattern to lookup implementation class
    Pattern pattern = Pattern.compile(".*" + context.getImplementationClassName());

    // Build classpath scanner and lookup bean definition
    ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(
            false);
    provider.setResourceLoader(parser.getReaderContext().getResourceLoader());
    provider.addIncludeFilter(new RegexPatternTypeFilter(pattern));
    Set<BeanDefinition> definitions = provider.findCandidateComponents(context.getDaoBasePackageName());

    return (0 == definitions.size() ? null : (AbstractBeanDefinition) definitions.iterator().next());
}

From source file:com.github.philippn.springremotingautoconfigure.client.annotation.HttpInvokerProxyFactoryBeanRegistrar.java

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {

    Set<String> basePackages = new HashSet<>();
    for (String beanName : registry.getBeanDefinitionNames()) {
        BeanDefinition definition = registry.getBeanDefinition(beanName);
        if (definition.getBeanClassName() != null) {
            try {
                Class<?> resolvedClass = ClassUtils.forName(definition.getBeanClassName(), null);
                EnableHttpInvokerAutoProxy autoProxy = AnnotationUtils.findAnnotation(resolvedClass,
                        EnableHttpInvokerAutoProxy.class);
                if (autoProxy != null) {
                    if (autoProxy.basePackages().length > 0) {
                        Collections.addAll(basePackages, autoProxy.basePackages());
                    } else {
                        basePackages.add(resolvedClass.getPackage().getName());
                    }//from   w ww. j a va2s . c  o  m
                }
            } catch (ClassNotFoundException e) {
                throw new IllegalStateException("Unable to inspect class " + definition.getBeanClassName()
                        + " for @EnableHttpInvokerAutoProxy annotations");
            }
        }
    }

    ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
            false) {

        /* (non-Javadoc)
        * @see org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#isCandidateComponent(org.springframework.beans.factory.annotation.AnnotatedBeanDefinition)
        */
        @Override
        protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
            return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
        }
    };
    scanner.addIncludeFilter(new AnnotationTypeFilter(RemoteExport.class));

    for (String basePackage : basePackages) {
        for (BeanDefinition definition : scanner.findCandidateComponents(basePackage)) {
            if (definition.getBeanClassName() != null) {
                try {
                    Class<?> resolvedClass = ClassUtils.forName(definition.getBeanClassName(), null);
                    setupProxy(resolvedClass, registry);
                } catch (ClassNotFoundException e) {
                    throw new IllegalStateException("Unable to inspect class " + definition.getBeanClassName()
                            + " for @RemoteExport annotations");
                }
            }
        }
    }
}

From source file:org.kuali.coeus.s2sgen.impl.generate.support.stylesheet.StylesheetValidationTest.java

private Stream<Class<? extends S2SFormGenerator>> getGeneratorsToTest() {
    final ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(
            false);//from  w ww  .j a  v  a2s .  c  o m

    final TypeFilter testableFilter = (metadataReader,
            metadataReaderFactory) -> new AnnotationTypeFilter(FormGenerator.class).match(metadataReader,
                    metadataReaderFactory)
                    && new AssignableTypeFilter(S2SFormGenerator.class).match(metadataReader,
                            metadataReaderFactory)
                    && !metadataReader.getClassMetadata().isAbstract()
                    && !BROKEN_GENERATORS.contains(metadataReader.getClassMetadata().getClassName());

    provider.addIncludeFilter(testableFilter);
    provider.addExcludeFilter(new AssignableTypeFilter(DynamicNamespace.class));
    provider.setResourceLoader(new PathMatchingResourcePatternResolver(this.getClass().getClassLoader()));
    final Set<BeanDefinition> generators = provider
            .findCandidateComponents("org.kuali.coeus.s2sgen.impl.generate.support");
    return generators.stream().map(generator -> {
        try {
            @SuppressWarnings("unchecked")
            final Class<? extends S2SFormGenerator> clazz = (Class<? extends S2SFormGenerator>) Class
                    .forName(generator.getBeanClassName());
            return clazz;
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    });
}

From source file:org.apache.syncope.client.console.init.ClassPathScanImplementationLookup.java

@SuppressWarnings("unchecked")
public void load() {
    pages = new ArrayList<>();
    previewers = new ArrayList<>();
    extPages = new ArrayList<>();
    extWidgets = new ArrayList<>();
    ssoLoginFormPanels = new ArrayList<>();
    reportletConfs = new HashMap<>();
    accountRuleConfs = new HashMap<>();
    passwordRuleConfs = new HashMap<>();
    pullCorrelationRuleConfs = new HashMap<>();

    ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
            false);//from ww  w .j a  va2  s.  com
    scanner.addIncludeFilter(new AssignableTypeFilter(BasePage.class));
    scanner.addIncludeFilter(new AssignableTypeFilter(AbstractBinaryPreviewer.class));
    scanner.addIncludeFilter(new AssignableTypeFilter(BaseExtPage.class));
    scanner.addIncludeFilter(new AssignableTypeFilter(BaseExtWidget.class));
    scanner.addIncludeFilter(new AssignableTypeFilter(SSOLoginFormPanel.class));
    scanner.addIncludeFilter(new AssignableTypeFilter(ReportletConf.class));
    scanner.addIncludeFilter(new AssignableTypeFilter(AccountRuleConf.class));
    scanner.addIncludeFilter(new AssignableTypeFilter(PasswordRuleConf.class));
    scanner.addIncludeFilter(new AssignableTypeFilter(PullCorrelationRuleConf.class));

    scanner.findCandidateComponents(getBasePackage()).forEach(bd -> {
        try {
            Class<?> clazz = ClassUtils.resolveClassName(bd.getBeanClassName(),
                    ClassUtils.getDefaultClassLoader());
            boolean isAbsractClazz = Modifier.isAbstract(clazz.getModifiers());

            if (!isAbsractClazz) {
                if (BaseExtPage.class.isAssignableFrom(clazz)) {
                    if (clazz.isAnnotationPresent(ExtPage.class)) {
                        extPages.add((Class<? extends BaseExtPage>) clazz);
                    } else {
                        LOG.error("Could not find annotation {} in {}, ignoring", ExtPage.class.getName(),
                                clazz.getName());
                    }
                } else if (BaseExtWidget.class.isAssignableFrom(clazz)) {
                    if (clazz.isAnnotationPresent(ExtWidget.class)) {
                        extWidgets.add((Class<? extends BaseExtWidget>) clazz);
                    } else {
                        LOG.error("Could not find annotation {} in {}, ignoring", ExtWidget.class.getName(),
                                clazz.getName());
                    }
                } else if (BasePage.class.isAssignableFrom(clazz)) {
                    pages.add((Class<? extends BasePage>) clazz);
                } else if (AbstractBinaryPreviewer.class.isAssignableFrom(clazz)) {
                    previewers.add((Class<? extends AbstractBinaryPreviewer>) clazz);
                } else if (SSOLoginFormPanel.class.isAssignableFrom(clazz)) {
                    ssoLoginFormPanels.add((Class<? extends SSOLoginFormPanel>) clazz);
                } else if (ReportletConf.class.isAssignableFrom(clazz)) {
                    reportletConfs.put(clazz.getName(), (Class<? extends ReportletConf>) clazz);
                } else if (AccountRuleConf.class.isAssignableFrom(clazz)) {
                    accountRuleConfs.put(clazz.getName(), (Class<? extends AccountRuleConf>) clazz);
                } else if (PasswordRuleConf.class.isAssignableFrom(clazz)) {
                    passwordRuleConfs.put(clazz.getName(), (Class<? extends PasswordRuleConf>) clazz);
                } else if (PullCorrelationRuleConf.class.isAssignableFrom(clazz)) {
                    pullCorrelationRuleConfs.put(clazz.getName(),
                            (Class<? extends PullCorrelationRuleConf>) clazz);
                }
            }
        } catch (Throwable t) {
            LOG.warn("Could not inspect class {}", bd.getBeanClassName(), t);
        }
    });
    pages = Collections.unmodifiableList(pages);
    previewers = Collections.unmodifiableList(previewers);

    Collections.sort(extPages, (o1, o2) -> ObjectUtils.compare(o1.getAnnotation(ExtPage.class).priority(),
            o2.getAnnotation(ExtPage.class).priority()));
    extPages = Collections.unmodifiableList(extPages);

    Collections.sort(extWidgets, (o1, o2) -> ObjectUtils.compare(o1.getAnnotation(ExtWidget.class).priority(),
            o2.getAnnotation(ExtWidget.class).priority()));
    extWidgets = Collections.unmodifiableList(extWidgets);

    ssoLoginFormPanels = Collections.unmodifiableList(ssoLoginFormPanels);

    reportletConfs = Collections.unmodifiableMap(reportletConfs);
    accountRuleConfs = Collections.unmodifiableMap(accountRuleConfs);
    passwordRuleConfs = Collections.unmodifiableMap(passwordRuleConfs);
    pullCorrelationRuleConfs = Collections.unmodifiableMap(pullCorrelationRuleConfs);

    LOG.debug("Binary previewers found: {}", previewers);
    LOG.debug("Extension pages found: {}", extPages);
    LOG.debug("Extension widgets found: {}", extWidgets);
    LOG.debug("SSO Login pages found: {}", ssoLoginFormPanels);
    LOG.debug("Reportlet configurations found: {}", reportletConfs);
    LOG.debug("Account Rule configurations found: {}", accountRuleConfs);
    LOG.debug("Password Rule configurations found: {}", passwordRuleConfs);
    LOG.debug("Pull Correlation Rule configurations found: {}", pullCorrelationRuleConfs);
}