Example usage for org.springframework.core.type.filter AnnotationTypeFilter AnnotationTypeFilter

List of usage examples for org.springframework.core.type.filter AnnotationTypeFilter AnnotationTypeFilter

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.core.type.filter.*
  5. AnnotationTypeFilter
  6. AnnotationTypeFilter

Introduction

In this page you can find the example usage for org.springframework.core.type.filter AnnotationTypeFilter AnnotationTypeFilter.

Prototype

public AnnotationTypeFilter(Class<? extends Annotation> annotationType)

Source Link

Document

Create a new AnnotationTypeFilter for the given annotation type.

Usage

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;/*  w w w .  ja  v  a 2 s . c  om*/
    }

    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:org.spring.guice.annotation.GuiceModuleRegistrar.java

private List<TypeFilter> typeFiltersFor(AnnotationAttributes filterAttributes) {

    List<TypeFilter> typeFilters = new ArrayList<TypeFilter>();
    FilterType filterType = filterAttributes.getEnum("type");

    for (Class<?> filterClass : filterAttributes.getClassArray("value")) {
        switch (filterType) {
        case ANNOTATION:
            Assert.isAssignable(Annotation.class, filterClass,
                    "An error occured when processing a @ComponentScan " + "ANNOTATION type filter: ");
            @SuppressWarnings("unchecked")
            Class<Annotation> annoClass = (Class<Annotation>) filterClass;
            typeFilters.add(new AnnotationTypeFilter(annoClass));
            break;
        case ASSIGNABLE_TYPE:
            typeFilters.add(new AssignableTypeFilter(filterClass));
            break;
        case CUSTOM:
            Assert.isAssignable(TypeFilter.class, filterClass,
                    "An error occured when processing a @ComponentScan " + "CUSTOM type filter: ");
            typeFilters.add(BeanUtils.instantiateClass(filterClass, TypeFilter.class));
            break;
        default://from   w ww  .j av a  2s  .  c o  m
            throw new IllegalArgumentException("Unknown filter type " + filterType);
        }
    }

    for (String expression : getPatterns(filterAttributes)) {

        String rawName = filterType.toString();

        if ("REGEX".equals(rawName)) {
            typeFilters.add(new RegexPatternTypeFilter(Pattern.compile(expression)));
        } else if ("ASPECTJ".equals(rawName)) {
            typeFilters.add(new AspectJTypeFilter(expression, this.resourceLoader.getClassLoader()));
        } else {
            throw new IllegalArgumentException("Unknown filter type " + filterType);
        }
    }

    return typeFilters;
}

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

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory context) throws BeansException {
    showDeprecationWarning();//from   w w  w .  j a  v a  2 s.  c om
    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.codehaus.grepo.core.config.GenericRepositoryScanBeanDefinitionParser.java

/**
 * @param element The element.//from   w  w w.  j  a  v a  2  s  .  com
 * @param classLoader The class loader.
 * @return Returns the type filter.
 */
@SuppressWarnings("unchecked")
protected TypeFilter createTypeFilter(Element element, ClassLoader classLoader) {
    String filterType = element.getAttribute(FILTER_TYPE_ATTRIBUTE);
    String expression = element.getAttribute(FILTER_EXPRESSION_ATTRIBUTE);
    try {
        if ("annotation".equals(filterType)) {
            return new AnnotationTypeFilter((Class<Annotation>) classLoader.loadClass(expression));
        } else if ("assignable".equals(filterType)) {
            return new AssignableTypeFilter(classLoader.loadClass(expression));
        } else if ("aspectj".equals(filterType)) {
            return new AspectJTypeFilter(expression, classLoader);
        } else if ("regex".equals(filterType)) {
            return new RegexPatternTypeFilter(Pattern.compile(expression));
        } else if ("custom".equals(filterType)) {
            Class filterClass = classLoader.loadClass(expression);
            if (!TypeFilter.class.isAssignableFrom(filterClass)) {
                throw new IllegalArgumentException(
                        "Class is not assignable to [" + TypeFilter.class.getName() + "]: " + expression);
            }
            return (TypeFilter) BeanUtils.instantiateClass(filterClass);
        } else {
            throw new IllegalArgumentException("Unsupported filter type: " + filterType);
        }
    } catch (ClassNotFoundException ex) {
        throw new FatalBeanException("Type filter class not found: " + expression, ex);
    }
}

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

@SuppressWarnings("unchecked")
protected TypeFilter createTypeFilter(Element element, ClassLoader classLoader) {
    String filterType = element.getAttribute(FILTER_TYPE_ATTRIBUTE);
    String expression = element.getAttribute(FILTER_EXPRESSION_ATTRIBUTE);
    try {/*from   ww  w . ja  v  a  2 s .  co  m*/
        if ("annotation".equals(filterType)) {
            return new AnnotationTypeFilter((Class<Annotation>) classLoader.loadClass(expression));
        } else if ("assignable".equals(filterType)) {
            return new AssignableTypeFilter(classLoader.loadClass(expression));
        } else if ("regex".equals(filterType)) {
            return new RegexPatternTypeFilter(Pattern.compile(expression));
        } else if ("custom".equals(filterType)) {
            Class filterClass = classLoader.loadClass(expression);
            if (!TypeFilter.class.isAssignableFrom(filterClass)) {
                throw new IllegalArgumentException(
                        "Class is not assignable to [" + TypeFilter.class.getName() + "]: " + expression);
            }
            return (TypeFilter) BeanUtils.instantiateClass(filterClass);
        } else {
            throw new IllegalArgumentException("Unsupported filter type: " + filterType);
        }
    } catch (ClassNotFoundException ex) {
        throw new FatalBeanException("Type filter class not found: " + expression, ex);
    }
}

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  w  w.ja v a  2 s. co 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:com.longio.spring.LioBootstrap.java

private void doScanAndRegist(ConfigurableListableBeanFactory beanFactory) {
    LioScanningCandidateComponentProvider provider = new LioScanningCandidateComponentProvider();
    provider.addIncludeFilter(new AnnotationTypeFilter(Lservice.class));
    provider.addIncludeFilter(new AnnotationTypeFilter(LsFilter.class));
    Set<String> LioClassNames = new HashSet<String>();
    for (String pkg : basePackages) {
        Set<BeanDefinition> dfs = provider.findCandidateComponents(pkg);

        for (BeanDefinition beanDefinition : dfs) {
            String LioClassName = beanDefinition.getBeanClassName();
            if (LioClassNames.contains(LioClassName)) {
                continue;
            }//  w w w  . j  a  v a2s  .  c  om
            LioClassNames.add(LioClassName);
            registerLioDefinition(beanFactory, beanDefinition);
        }
    }
}

From source file:com.laxser.blitz.lama.core.LamaDaoComponentProvider.java

/**
 * Register the default filter for {@link Component @Component}. This
 * will implicitly register all annotations that have the
 * {@link Component @Component} meta-annotation including the
 * {@link Repository @Repository}, {@link Service @Service}, and
 * {@link Controller @Controller} stereotype annotations.
 *//*w ww. j a v  a  2 s .  c  o m*/
protected void registerDefaultFilters() {
    addIncludeFilter(new AnnotationTypeFilter(DAO.class));
}

From source file:org.dd4t.databind.builder.BaseDataBinder.java

protected void scanAndLoadModels() {
    LOG.info("Init: scanning view models.");
    final ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
            false);/*from  w w  w  .  j a  v  a 2  s  . co  m*/
    scanner.addIncludeFilter(new AnnotationTypeFilter(ViewModel.class));
    for (BeanDefinition bd : scanner.findCandidateComponents(this.viewModelPackageRoot)) {
        try {
            final Class clazz = Class.forName(bd.getBeanClassName());
            if (clazz != null) {
                LOG.debug("Loading class: " + clazz.getCanonicalName());
                final ViewModel viewModelParameters = (ViewModel) clazz.getAnnotation(ViewModel.class);

                if (hasProperModelInformation(viewModelParameters, clazz)) {
                    LOG.debug(
                            "Parameters: Viewmodel name(s):{}, Root Element name(s){}, Set Component: {}, Set raw: {} ",
                            new Object[] { viewModelParameters.viewModelNames(),
                                    viewModelParameters.rootElementNames(),
                                    viewModelParameters.setComponentObject(),
                                    viewModelParameters.setRawData() });
                    storeModelClass(viewModelParameters, clazz);
                }
            }
            LOG.info("Init: Done scanning view models.");
        } catch (ClassNotFoundException e) {
            LOG.error("Unexpected exception", e);
        }
    }
}