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

Introduction

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

Prototype

public AspectJTypeFilter(String typePatternExpression, @Nullable ClassLoader classLoader) 

Source Link

Usage

From source file:com.github.ljtfreitas.restify.spring.configure.RestifyConfigurationRegistrar.java

@SuppressWarnings("unchecked")
private Set<TypeFilter> filters(RestifyExcludeFilter[] filters) {
    Set<TypeFilter> typeFilters = new LinkedHashSet<>();

    Arrays.stream(filters).forEach(f -> {
        Arrays.stream(f.classes()).forEach(classType -> {
            switch (f.type()) {
            case ANNOTATION: {
                typeFilters.add(new AnnotationTypeFilter((Class<? extends Annotation>) classType));
                break;
            }/*  w  w w  . j  a  va 2s.c o m*/
            case ASSIGNABLE_TYPE: {
                typeFilters.add(new AssignableTypeFilter(classType));
                break;
            }
            case CUSTOM: {
                typeFilters.add(Tryable.of(() -> (TypeFilter) classType.newInstance(),
                        () -> new IllegalArgumentException(
                                "Cannot construct your custom TypeFilter of type [" + classType + "]")));
            }
            default: {
                throw new IllegalArgumentException("Illegal @Filter use. "
                        + "Your configure [classes] attribute with filter type [" + f.type() + "]");
            }
            }
        });

        Arrays.stream(f.pattern()).forEach(pattern -> {
            switch (f.type()) {
            case REGEX: {
                typeFilters.add(new RegexPatternTypeFilter(Pattern.compile(pattern)));
            }
            case ASPECTJ: {
                typeFilters.add(new AspectJTypeFilter(pattern, resourceLoader.getClassLoader()));
            }
            default: {
                throw new IllegalArgumentException("Illegal @Filter use. "
                        + "Your configure [pattern] attribute with filter type [" + f.type() + "]");
            }
            }
        });
    });

    return typeFilters;
}

---

From source file:org.codehaus.grepo.core.config.GenericRepositoryScanBeanDefinitionParser.java

/**
 * @param element The element.//from   www.j a va2  s . co  m
 * @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: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:/*  www.  j  a  v  a2 s. co 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;
}

---