Java 类org.springframework.context.annotation.FilterType 实例源码

@SuppressWarnings("unchecked")
private TypeFilter createTypeFilter(FilterType filterType, Class<?> filterClass) {
    switch (filterType) {
    case ANNOTATION:
        Assert.isAssignable(Annotation.class, filterClass,
                "An error occurred while processing a ANNOTATION type filter: ");
        return new AnnotationTypeFilter((Class<Annotation>) filterClass);
    case ASSIGNABLE_TYPE:
        return new AssignableTypeFilter(filterClass);
    case CUSTOM:
        Assert.isAssignable(TypeFilter.class, filterClass,
                "An error occurred while processing a CUSTOM type filter: ");
        return BeanUtils.instantiateClass(filterClass, TypeFilter.class);
    }
    throw new IllegalArgumentException(
            "Filter type not supported with Class value: " + filterType);
}

@SuppressWarnings("unchecked")
private TypeFilter createTypeFilter(FilterType filterType, Class<?> filterClass) {
    switch (filterType) {
    case ANNOTATION:
        Assert.isAssignable(Annotation.class, filterClass,
                "An error occurred while processing a ANNOTATION type filter: ");
        return new AnnotationTypeFilter((Class<Annotation>) filterClass);
    case ASSIGNABLE_TYPE:
        return new AssignableTypeFilter(filterClass);
    case CUSTOM:
        Assert.isAssignable(TypeFilter.class, filterClass,
                "An error occurred while processing a CUSTOM type filter: ");
        return BeanUtils.instantiateClass(filterClass, TypeFilter.class);
    }
    throw new IllegalArgumentException(
            "Filter type not supported with Class value: " + filterType);
}

private TypeFilter createTypeFilter(FilterType filterType, String pattern) {
    switch (filterType) {
    case ASPECTJ:
        return new AspectJTypeFilter(pattern, this.classLoader);
    case REGEX:
        return new RegexPatternTypeFilter(Pattern.compile(pattern));
    }
    throw new IllegalArgumentException(
            "Filter type not supported with String pattern: " + filterType);
}

private TypeFilter createTypeFilter(FilterType filterType, String pattern) {
    switch (filterType) {
    case ASPECTJ:
        return new AspectJTypeFilter(pattern, this.classLoader);
    case REGEX:
        return new RegexPatternTypeFilter(Pattern.compile(pattern));
    }
    throw new IllegalArgumentException(
            "Filter type not supported with String pattern: " + filterType);
}

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:
                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;
    }

FilterType type() {
    return (FilterType) attributes.get("type");
}