AbstractTypeAnnotationScanner (hutool

java.lang.Object
- cn.hutool.core.annotation.scanner.AbstractTypeAnnotationScanner<T>

All Implemented Interfaces:

AnnotationScanner

Direct Known Subclasses:

MethodAnnotationScanner, TypeAnnotationScanner
```
public abstract class AbstractTypeAnnotationScanner<T extends AbstractTypeAnnotationScanner<T>>
extends Object
implements AnnotationScanner
```
为需要从类的层级结构中获取注解的AnnotationScanner提供基本实现

Author:

huangchengxing

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class AbstractTypeAnnotationScanner.JdkProxyClassConverter
若类型为jdk代理类，则尝试转换为原始被代理类

Nested Classes
Modifier and Type	Class and Description
`static class`	`AbstractTypeAnnotationScanner.JdkProxyClassConverter` 若类型为jdk代理类，则尝试转换为原始被代理类

Field Summary
- Fields inherited from interface cn.hutool.core.annotation.scanner.AnnotationScanner
  DIRECTLY, DIRECTLY_AND_META_ANNOTATION, INTERFACE, INTERFACE_AND_META_ANNOTATION, NOTHING, SUPERCLASS, SUPERCLASS_AND_META_ANNOTATION, TYPE_HIERARCHY, TYPE_HIERARCHY_AND_META_ANNOTATION

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AbstractTypeAnnotationScanner(boolean includeSuperClass, boolean includeInterfaces, Predicate<Class<?>> filter, Set<Class<?>> excludeTypes)` 构造一个类注解扫描器

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`T`	`addConverters(UnaryOperator<Class<?>> converter)` 添加转换器
`T`	`addExcludeTypes(Class<?>... excludeTypes)` 添加不扫描的类型，该类型及其树结构将直接不被查找
`protected Class<?>`	`convert(Class<?> target)` 若存在转换器，则使用转换器对目标类进行转换
`protected abstract Annotation[]`	`getAnnotationsFromTargetClass(AnnotatedElement source, int index, Class<?> targetClass)` 从类上获取最终所需的目标注解
`protected abstract Class<?>`	`getClassFormAnnotatedElement(AnnotatedElement annotatedElement)` 从要搜索的注解元素上获得要递归的类型
`boolean`	`isIncludeInterfaces()` 是否允许扫描父接口
`boolean`	`isIncludeSuperClass()` 是否允许扫描父类
`protected boolean`	`isNotNeedProcess(Set<Class<?>> accessedTypes, Class<?> targetClass)` 当前类是否不需要处理
`void`	`scan(BiConsumer<Integer,Annotation> consumer, AnnotatedElement annotatedEle, Predicate<Annotation> filter)` 则根据广度优先递归扫描类的层级结构，并对层级结构中类/接口声明的层级索引和它们声明的注解对象进行处理
`protected void`	`scanInterfaceIfNecessary(List<Class<?>> nextClasses, Class<?> targetClass)` 若`includeInterfaces`为`true`，则将目标类的父接口也添加到nextClasses
`protected void`	`scanSuperClassIfNecessary(List<Class<?>> nextClassQueue, Class<?> targetClass)` 若`includeSuperClass`为`true`，则将目标类的父类也添加到nextClasses
`T`	`setFilter(Predicate<Class<?>> filter)` 设置过滤器，若类型无法通过该过滤器，则该类型及其树结构将直接不被查找
`protected T`	`setIncludeInterfaces(boolean includeInterfaces)` 是否允许扫描父接口
`protected T`	`setIncludeSuperClass(boolean includeSuperClass)` 是否允许扫描父类

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface cn.hutool.core.annotation.scanner.AnnotationScanner
getAnnotations, getAnnotationsIfSupport, scanByAllSupported, scanByAnySupported, scanIfSupport, support

- Constructor Detail
  - AbstractTypeAnnotationScanner
```
protected AbstractTypeAnnotationScanner(boolean includeSuperClass,
                                        boolean includeInterfaces,
                                        Predicate<Class<?>> filter,
                                        Set<Class<?>> excludeTypes)
```
    构造一个类注解扫描器
    
    Parameters:
    
    includeSuperClass - 是否允许扫描父类
    
    includeInterfaces - 是否允许扫描父接口
    
    filter - 过滤器
    
    excludeTypes - 不包含的类型
- Method Detail
  - isIncludeSuperClass
```
public boolean isIncludeSuperClass()
```
    是否允许扫描父类
    
    Returns:
    
    是否允许扫描父类
  - isIncludeInterfaces
```
public boolean isIncludeInterfaces()
```
    是否允许扫描父接口
    
    Returns:
    
    是否允许扫描父接口
  - setFilter
```
public T setFilter(Predicate<Class<?>> filter)
```
    设置过滤器，若类型无法通过该过滤器，则该类型及其树结构将直接不被查找
    
    Parameters:
    
    filter - 过滤器
    
    Returns:
    
    当前实例
  - addExcludeTypes
```
public T addExcludeTypes(Class<?>... excludeTypes)
```
    添加不扫描的类型，该类型及其树结构将直接不被查找
    
    Parameters:
    
    excludeTypes - 不扫描的类型
    
    Returns:
    
    当前实例
  - addConverters
```
public T addConverters(UnaryOperator<Class<?>> converter)
```
    添加转换器
    
    Parameters:
    
    converter - 转换器
    
    Returns:
    
    当前实例
    
    See Also:
    
    AbstractTypeAnnotationScanner.JdkProxyClassConverter
  - setIncludeSuperClass
```
protected T setIncludeSuperClass(boolean includeSuperClass)
```
    是否允许扫描父类
    
    Parameters:
    
    includeSuperClass - 是否
    
    Returns:
    
    当前实例
  - setIncludeInterfaces
```
protected T setIncludeInterfaces(boolean includeInterfaces)
```
    是否允许扫描父接口
    
    Parameters:
    
    includeInterfaces - 是否
    
    Returns:
    
    当前实例
  - scan
```
public void scan(BiConsumer<Integer,Annotation> consumer,
                 AnnotatedElement annotatedEle,
                 Predicate<Annotation> filter)
```
    则根据广度优先递归扫描类的层级结构，并对层级结构中类/接口声明的层级索引和它们声明的注解对象进行处理
    
    Specified by:
    
    scan in interface AnnotationScanner
    
    Parameters:
    
    consumer - 对获取到的注解和注解对应的层级索引的处理
    
    annotatedEle - 注解元素
    
    filter - 注解过滤器，无法通过过滤器的注解不会被处理。该参数允许为空。
  - getClassFormAnnotatedElement
```
protected abstract Class<?> getClassFormAnnotatedElement(AnnotatedElement annotatedElement)
```
    从要搜索的注解元素上获得要递归的类型
    
    Parameters:
    
    annotatedElement - 注解元素
    
    Returns:
    
    要递归的类型
  - getAnnotationsFromTargetClass
```
protected abstract Annotation[] getAnnotationsFromTargetClass(AnnotatedElement source,
                                                              int index,
                                                              Class<?> targetClass)
```
    从类上获取最终所需的目标注解
    
    Parameters:
    
    source - 最初的注解元素
    
    index - 类的层级索引
    
    targetClass - 类
    
    Returns:
    
    最终所需的目标注解
  - isNotNeedProcess
```
protected boolean isNotNeedProcess(Set<Class<?>> accessedTypes,
                                   Class<?> targetClass)
```
    当前类是否不需要处理
    
    Parameters:
    
    accessedTypes - 访问类型
    
    targetClass - 目标类型
    
    Returns:
    
    是否不需要处理
  - scanInterfaceIfNecessary
```
protected void scanInterfaceIfNecessary(List<Class<?>> nextClasses,
                                        Class<?> targetClass)
```
    若includeInterfaces为true，则将目标类的父接口也添加到nextClasses
    
    Parameters:
    
    nextClasses - 下一个类集合
    
    targetClass - 目标类型
  - scanSuperClassIfNecessary
```
protected void scanSuperClassIfNecessary(List<Class<?>> nextClassQueue,
                                         Class<?> targetClass)
```
    若includeSuperClass为true，则将目标类的父类也添加到nextClasses
    
    Parameters:
    
    nextClassQueue - 下一个类队列
    
    targetClass - 目标类型
  - convert
```
protected Class<?> convert(Class<?> target)
```
    若存在转换器，则使用转换器对目标类进行转换
    
    Parameters:
    
    target - 目标类
    
    Returns:
    
    转换后的类

Class AbstractTypeAnnotationScanner<T extends AbstractTypeAnnotationScanner<T>>

Nested Class Summary

Field Summary

Fields inherited from interface cn.hutool.core.annotation.scanner.AnnotationScanner

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface cn.hutool.core.annotation.scanner.AnnotationScanner

Constructor Detail

AbstractTypeAnnotationScanner

Method Detail

isIncludeSuperClass

isIncludeInterfaces

setFilter

addExcludeTypes

addConverters

setIncludeSuperClass

setIncludeInterfaces

scan

getClassFormAnnotatedElement

getAnnotationsFromTargetClass

isNotNeedProcess

scanInterfaceIfNecessary

scanSuperClassIfNecessary

convert