Examples with TypeFilter org.springframework.core.type.filter.TypeFilter used on opensource projects

Example 1 with TypeFilter

use of org.springframework.core.type.filter.TypeFilter in project openmrs-core by openmrs.

the class OpenmrsClassScanner method getClassesWithAnnotation.

/**
 * Searches for classes with a given annotation.
 *
 * @param annotationClass the annotation class
 * @return the list of found classes
 */
public Set<Class<?>> getClassesWithAnnotation(Class annotationClass) {
    if (annotationToClassMap != null) {
        if (annotationToClassMap.containsKey(annotationClass)) {
            return annotationToClassMap.get(annotationClass);
        }
    } else {
        annotationToClassMap = new HashMap<>();
    }
    Set<Class<?>> types = new HashSet<>();
    String pattern = "classpath*:org/openmrs/**/*.class";
    try {
        Resource[] resources = resourceResolver.getResources(pattern);
        TypeFilter typeFilter = new AnnotationTypeFilter(annotationClass);
        for (Resource resource : resources) {
            try {
                MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);
                if (typeFilter.match(metadataReader, metadataReaderFactory)) {
                    String classname = metadataReader.getClassMetadata().getClassName();
                    try {
                        Class<?> metadata = (Class<?>) OpenmrsClassLoader.getInstance().loadClass(classname);
                        types.add(metadata);
                    } catch (ClassNotFoundException e) {
                        throw new IOException("Class cannot be loaded: " + classname, e);
                    }
                }
            } catch (IOException e) {
                log.debug("Resource cannot be loaded: " + resource);
            }
        }
    } catch (IOException ex) {
        log.error("Failed to look for classes with annocation" + annotationClass, ex);
    }
    annotationToClassMap.put(annotationClass, types);
    return types;
}

Example 2 with TypeFilter

use of org.springframework.core.type.filter.TypeFilter in project spring-data-commons by spring-projects.

the class AnnotationRepositoryConfigurationSource method typeFiltersFor.

/**
 * Copy of {@code ComponentScanAnnotationParser#typeFiltersFor}.
 *
 * @param filterAttributes
 * @return
 */
private List<TypeFilter> typeFiltersFor(AnnotationAttributes filterAttributes) {
    List<TypeFilter> typeFilters = new ArrayList<>();
    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:
                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;
}

Example 3 with TypeFilter

use of org.springframework.core.type.filter.TypeFilter in project spring-framework by spring-projects.

the class ComponentScanAnnotationParser method parse.

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, String declaringClass) {
    ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry, componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
    Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
    boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
    scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator : BeanUtils.instantiateClass(generatorClass));
    ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
    if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
        scanner.setScopedProxyMode(scopedProxyMode);
    } else {
        Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
        scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
    }
    scanner.setResourcePattern(componentScan.getString("resourcePattern"));
    for (AnnotationAttributes includeFilterAttributes : componentScan.getAnnotationArray("includeFilters")) {
        List<TypeFilter> typeFilters = TypeFilterUtils.createTypeFiltersFor(includeFilterAttributes, this.environment, this.resourceLoader, this.registry);
        for (TypeFilter typeFilter : typeFilters) {
            scanner.addIncludeFilter(typeFilter);
        }
    }
    for (AnnotationAttributes excludeFilterAttributes : componentScan.getAnnotationArray("excludeFilters")) {
        List<TypeFilter> typeFilters = TypeFilterUtils.createTypeFiltersFor(excludeFilterAttributes, this.environment, this.resourceLoader, this.registry);
        for (TypeFilter typeFilter : typeFilters) {
            scanner.addExcludeFilter(typeFilter);
        }
    }
    boolean lazyInit = componentScan.getBoolean("lazyInit");
    if (lazyInit) {
        scanner.getBeanDefinitionDefaults().setLazyInit(true);
    }
    Set<String> basePackages = new LinkedHashSet<>();
    String[] basePackagesArray = componentScan.getStringArray("basePackages");
    for (String pkg : basePackagesArray) {
        String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg), ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
        Collections.addAll(basePackages, tokenized);
    }
    for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
        basePackages.add(ClassUtils.getPackageName(clazz));
    }
    if (basePackages.isEmpty()) {
        basePackages.add(ClassUtils.getPackageName(declaringClass));
    }
    scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {

        @Override
        protected boolean matchClassName(String className) {
            return declaringClass.equals(className);
        }
    });
    return scanner.doScan(StringUtils.toStringArray(basePackages));
}

Example 4 with TypeFilter

use of org.springframework.core.type.filter.TypeFilter in project spring-framework by spring-projects.

the class ComponentScanBeanDefinitionParser method parseTypeFilters.

protected void parseTypeFilters(Element element, ClassPathBeanDefinitionScanner scanner, 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, parserContext);
                    scanner.addIncludeFilter(typeFilter);
                } else if (EXCLUDE_FILTER_ELEMENT.equals(localName)) {
                    TypeFilter typeFilter = createTypeFilter((Element) node, classLoader, parserContext);
                    scanner.addExcludeFilter(typeFilter);
                }
            } catch (ClassNotFoundException ex) {
                parserContext.getReaderContext().warning("Ignoring non-present type filter class: " + ex, parserContext.extractSource(element));
            } catch (Exception ex) {
                parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
            }
        }
    }
}

Example 5 with TypeFilter

use of org.springframework.core.type.filter.TypeFilter in project spring-framework by spring-projects.

the class ComponentScanBeanDefinitionParser method createTypeFilter.

@SuppressWarnings("unchecked")
protected TypeFilter createTypeFilter(Element element, @Nullable ClassLoader classLoader, ParserContext parserContext) throws ClassNotFoundException {
    String filterType = element.getAttribute(FILTER_TYPE_ATTRIBUTE);
    String expression = element.getAttribute(FILTER_EXPRESSION_ATTRIBUTE);
    expression = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(expression);
    if ("annotation".equals(filterType)) {
        return new AnnotationTypeFilter((Class<Annotation>) ClassUtils.forName(expression, classLoader));
    } else if ("assignable".equals(filterType)) {
        return new AssignableTypeFilter(ClassUtils.forName(expression, classLoader));
    } 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 = ClassUtils.forName(expression, classLoader);
        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);
    }
}