ZhouXY108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-05-09 23:51:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix comment

Browse Source
This commit is contained in:
huangchengxing 2022-06-30 15:34:16 +08:00
parent 7cc0994942
commit 8cf3015075
7 changed files with 75 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
hutool-core/src/main/java/cn/hutool/core/annotation/AnnotationUtil.java
View File

@ -151,7 +151,7 @@ public class AnnotationUtil {
*/ */
public static Annotation[] getAnnotations(AnnotatedElement annotationEle, boolean isToCombination, Predicate<Annotation> predicate) { public static Annotation[] getAnnotations(AnnotatedElement annotationEle, boolean isToCombination, Predicate<Annotation> predicate) {
if (null == annotationEle) { if (null == annotationEle) {
return null; return new Annotation[0];
} }
if (isToCombination) { if (isToCombination) {
@ -438,7 +438,7 @@ public class AnnotationUtil {
} }
/** /**
* 方法是否为注解属性方法。 <br /> * 方法是否为注解属性方法。 <br>
* 方法无参数，且有返回值的方法认为是注解属性的方法。 * 方法无参数，且有返回值的方法认为是注解属性的方法。
* *
* @param method 方法 * @param method 方法

12
hutool-core/src/main/java/cn/hutool/core/annotation/scanner/AbstractTypeAnnotationScanner.java
View File

@ -159,14 +159,14 @@ public abstract class AbstractTypeAnnotationScanner<T extends AbstractTypeAnnota
/** /**
* 则根据广度优先递归扫描类的层级结构，并对层级结构中类/接口声明的层级索引和它们声明的注解对象进行处理 * 则根据广度优先递归扫描类的层级结构，并对层级结构中类/接口声明的层级索引和它们声明的注解对象进行处理
* *
* @param consumer 对获取到的注解和注解对应的层级索引的处理 * @param consumer 对获取到的注解和注解对应的层级索引的处理
* @param annotatedElement 注解元素 * @param annotatedEle 注解元素
* @param filter 注解过滤器，无法通过过滤器的注解不会被处理。该参数允许为空。 * @param filter 注解过滤器，无法通过过滤器的注解不会被处理。该参数允许为空。
*/ */
@Override @Override
public void scan(BiConsumer<Integer, Annotation> consumer, AnnotatedElement annotatedElement, Predicate<Annotation> filter) { public void scan(BiConsumer<Integer, Annotation> consumer, AnnotatedElement annotatedEle, Predicate<Annotation> filter) {
filter = ObjectUtil.defaultIfNull(filter, annotation -> true); filter = ObjectUtil.defaultIfNull(filter, annotation -> true);
final Class<?> sourceClass = getClassFormAnnotatedElement(annotatedElement); final Class<?> sourceClass = getClassFormAnnotatedElement(annotatedEle);
final Deque<List<Class<?>>> classDeque = CollUtil.newLinkedList(CollUtil.newArrayList(sourceClass)); final Deque<List<Class<?>>> classDeque = CollUtil.newLinkedList(CollUtil.newArrayList(sourceClass));
final Set<Class<?>> accessedTypes = new LinkedHashSet<>(); final Set<Class<?>> accessedTypes = new LinkedHashSet<>();
int index = 0; int index = 0;
@ -185,7 +185,7 @@ public abstract class AbstractTypeAnnotationScanner<T extends AbstractTypeAnnota
// 扫描接口 // 扫描接口
scanInterfaceIfNecessary(nextClassQueue, targetClass); scanInterfaceIfNecessary(nextClassQueue, targetClass);
// 处理层级索引和注解 // 处理层级索引和注解
final Annotation[] targetAnnotations = getAnnotationsFromTargetClass(annotatedElement, index, targetClass); final Annotation[] targetAnnotations = getAnnotationsFromTargetClass(annotatedEle, index, targetClass);
for (final Annotation annotation : targetAnnotations) { for (final Annotation annotation : targetAnnotations) {
if (AnnotationUtil.isNotJdkMateAnnotation(annotation.annotationType()) || filter.test(annotation)) { if (AnnotationUtil.isNotJdkMateAnnotation(annotation.annotationType()) || filter.test(annotation)) {
consumer.accept(index, annotation); consumer.accept(index, annotation);

60
hutool-core/src/main/java/cn/hutool/core/annotation/scanner/AnnotationScanner.java
View File

@ -29,22 +29,22 @@ public interface AnnotationScanner {
/** /**
* 判断是否支持扫描该注解元素 * 判断是否支持扫描该注解元素
* *
* @param annotatedElement 注解元素 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @return 是否支持扫描该注解元素 * @return 是否支持扫描该注解元素
*/ */
default boolean support(AnnotatedElement annotatedElement) { default boolean support(AnnotatedElement annotatedEle) {
return false; return false;
} }
/** /**
* 获取注解元素上的全部注解。调用该方法前，需要确保调用{@link #support(AnnotatedElement)}返回为true * 获取注解元素上的全部注解。调用该方法前，需要确保调用{@link #support(AnnotatedElement)}返回为true
* *
* @param annotatedElement 注解元素 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @return 注解 * @return 注解
*/ */
default List<Annotation> getAnnotations(AnnotatedElement annotatedElement) { default List<Annotation> getAnnotations(AnnotatedElement annotatedEle) {
final List<Annotation> annotations = new ArrayList<>(); final List<Annotation> annotations = new ArrayList<>();
scan((index, annotation) -> annotations.add(annotation), annotatedElement, null); scan((index, annotation) -> annotations.add(annotation), annotatedEle, null);
return annotations; return annotations;
} }
@ -53,24 +53,24 @@ public interface AnnotationScanner {
* 则调用并返回{@link #getAnnotations(AnnotatedElement)}结果， * 则调用并返回{@link #getAnnotations(AnnotatedElement)}结果，
* 否则返回{@link Collections#emptyList()} * 否则返回{@link Collections#emptyList()}
* *
* @param annotatedElement 注解元素 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @return 注解 * @return 注解
*/ */
default List<Annotation> getIfSupport(AnnotatedElement annotatedElement) { default List<Annotation> getIfSupport(AnnotatedElement annotatedEle) {
return support(annotatedElement) ? getAnnotations(annotatedElement) : Collections.emptyList(); return support(annotatedEle) ? getAnnotations(annotatedEle) : Collections.emptyList();
} }
/** /**
* 扫描注解元素的层级结构（若存在），然后对获取到的注解和注解对应的层级索引进行处理。 * 扫描注解元素的层级结构（若存在），然后对获取到的注解和注解对应的层级索引进行处理。
* 调用该方法前，需要确保调用{@link #support(AnnotatedElement)}返回为true * 调用该方法前，需要确保调用{@link #support(AnnotatedElement)}返回为true
* *
* @param consumer 对获取到的注解和注解对应的层级索引的处理 * @param consumer 对获取到的注解和注解对应的层级索引的处理
* @param annotatedElement 注解元素 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @param filter 注解过滤器，无法通过过滤器的注解不会被处理。该参数允许为空。 * @param filter 注解过滤器，无法通过过滤器的注解不会被处理。该参数允许为空。
*/ */
default void scan(BiConsumer<Integer, Annotation> consumer, AnnotatedElement annotatedElement, Predicate<Annotation> filter) { default void scan(BiConsumer<Integer, Annotation> consumer, AnnotatedElement annotatedEle, Predicate<Annotation> filter) {
filter = ObjectUtil.defaultIfNull(filter, annotation -> true); filter = ObjectUtil.defaultIfNull(filter, annotation -> true);
for (Annotation annotation : annotatedElement.getAnnotations()) { for (Annotation annotation : annotatedEle.getAnnotations()) {
if (AnnotationUtil.isNotJdkMateAnnotation(annotation.annotationType()) && filter.test(annotation)) { if (AnnotationUtil.isNotJdkMateAnnotation(annotation.annotationType()) && filter.test(annotation)) {
consumer.accept(0, annotation); consumer.accept(0, annotation);
} }
@ -80,47 +80,47 @@ public interface AnnotationScanner {
/** /**
* 若{@link #support(AnnotatedElement)}返回{@code true}，则调用{@link #scan(BiConsumer, AnnotatedElement, Predicate)} * 若{@link #support(AnnotatedElement)}返回{@code true}，则调用{@link #scan(BiConsumer, AnnotatedElement, Predicate)}
* *
* @param consumer 对获取到的注解和注解对应的层级索引的处理 * @param consumer 对获取到的注解和注解对应的层级索引的处理
* @param annotatedElement 注解元素 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @param filter 注解过滤器，无法通过过滤器的注解不会被处理。该参数允许为空。 * @param filter 注解过滤器，无法通过过滤器的注解不会被处理。该参数允许为空。
*/ */
default void scanIfSupport(BiConsumer<Integer, Annotation> consumer, AnnotatedElement annotatedElement, Predicate<Annotation> filter) { default void scanIfSupport(BiConsumer<Integer, Annotation> consumer, AnnotatedElement annotatedEle, Predicate<Annotation> filter) {
if (support(annotatedElement)) { if (support(annotatedEle)) {
scan(consumer, annotatedElement, filter); scan(consumer, annotatedEle, filter);
} }
} }
/** /**
* 给定一组扫描器，使用第一个支持处理该类型元素的扫描器获取元素上可能存在的注解 * 给定一组扫描器，使用第一个支持处理该类型元素的扫描器获取元素上可能存在的注解
* *
* @param annotatedElement 注解元素 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @param scanners 注解扫描器 * @param scanners 注解扫描器
* @return 注解 * @return 注解
*/ */
static List<Annotation> scanByAnySupported(AnnotatedElement annotatedElement, AnnotationScanner... scanners) { static List<Annotation> scanByAnySupported(AnnotatedElement annotatedEle, AnnotationScanner... scanners) {
if (ObjectUtil.isNull(annotatedElement) && ArrayUtil.isNotEmpty(scanners)) { if (ObjectUtil.isNull(annotatedEle) && ArrayUtil.isNotEmpty(scanners)) {
return Collections.emptyList(); return Collections.emptyList();
} }
return Stream.of(scanners) return Stream.of(scanners)
.filter(scanner -> scanner.support(annotatedElement)) .filter(scanner -> scanner.support(annotatedEle))
.findFirst() .findFirst()
.map(scanner -> scanner.getAnnotations(annotatedElement)) .map(scanner -> scanner.getAnnotations(annotatedEle))
.orElseGet(Collections::emptyList); .orElseGet(Collections::emptyList);
} }
/** /**
* 根据指定的扫描器，扫描元素上可能存在的注解 * 根据指定的扫描器，扫描元素上可能存在的注解
* *
* @param annotatedElement 注解元素 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @param scanners 注解扫描器 * @param scanners 注解扫描器
* @return 注解 * @return 注解
*/ */
static List<Annotation> scanByAllScanner(AnnotatedElement annotatedElement, AnnotationScanner... scanners) { static List<Annotation> scanByAllScanner(AnnotatedElement annotatedEle, AnnotationScanner... scanners) {
if (ObjectUtil.isNull(annotatedElement) && ArrayUtil.isNotEmpty(scanners)) { if (ObjectUtil.isNull(annotatedEle) && ArrayUtil.isNotEmpty(scanners)) {
return Collections.emptyList(); return Collections.emptyList();
} }
return Stream.of(scanners) return Stream.of(scanners)
.map(scanner -> scanner.getIfSupport(annotatedElement)) .map(scanner -> scanner.getIfSupport(annotatedEle))
.flatMap(Collection::stream) .flatMap(Collection::stream)
.collect(Collectors.toList()); .collect(Collectors.toList());
} }

16
hutool-core/src/main/java/cn/hutool/core/annotation/scanner/FieldAnnotationScanner.java
View File

@ -19,25 +19,25 @@ public class FieldAnnotationScanner implements AnnotationScanner {
/** /**
* 判断是否支持扫描该注解元素，仅当注解元素是{@link Field}时返回{@code true} * 判断是否支持扫描该注解元素，仅当注解元素是{@link Field}时返回{@code true}
* *
* @param annotatedElement 注解元素 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @return 是否支持扫描该注解元素 * @return 是否支持扫描该注解元素
*/ */
@Override @Override
public boolean support(AnnotatedElement annotatedElement) { public boolean support(AnnotatedElement annotatedEle) {
return annotatedElement instanceof Field; return annotatedEle instanceof Field;
} }
/** /**
* 扫描{@link Field}上直接声明的注解，调用前需要确保调用{@link #support(AnnotatedElement)}返回为true * 扫描{@link Field}上直接声明的注解，调用前需要确保调用{@link #support(AnnotatedElement)}返回为true
* *
* @param consumer 对获取到的注解和注解对应的层级索引的处理 * @param consumer 对获取到的注解和注解对应的层级索引的处理
* @param annotatedElement 注解元素 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @param filter 注解过滤器，无法通过过滤器的注解不会被处理。该参数允许为空。 * @param filter 注解过滤器，无法通过过滤器的注解不会被处理。该参数允许为空。
*/ */
@Override @Override
public void scan(BiConsumer<Integer, Annotation> consumer, AnnotatedElement annotatedElement, Predicate<Annotation> filter) { public void scan(BiConsumer<Integer, Annotation> consumer, AnnotatedElement annotatedEle, Predicate<Annotation> filter) {
filter = ObjectUtil.defaultIfNull(filter, annotation -> true); filter = ObjectUtil.defaultIfNull(filter, annotation -> true);
for (Annotation annotation : annotatedElement.getAnnotations()) { for (Annotation annotation : annotatedEle.getAnnotations()) {
if (AnnotationUtil.isNotJdkMateAnnotation(annotation.annotationType()) && filter.test(annotation)) { if (AnnotationUtil.isNotJdkMateAnnotation(annotation.annotationType()) && filter.test(annotation)) {
consumer.accept(0, annotation); consumer.accept(0, annotation);
} }

25
hutool-core/src/main/java/cn/hutool/core/annotation/scanner/MetaAnnotationScanner.java
View File

@ -49,27 +49,26 @@ public class MetaAnnotationScanner implements AnnotationScanner {
/** /**
* 判断是否支持扫描该注解元素，仅当注解元素是{@link Annotation}接口的子类{@link Class}时返回{@code true} * 判断是否支持扫描该注解元素，仅当注解元素是{@link Annotation}接口的子类{@link Class}时返回{@code true}
* *
* @param annotatedElement 注解元素 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @return 是否支持扫描该注解元素 * @return 是否支持扫描该注解元素
*/ */
@Override @Override
public boolean support(AnnotatedElement annotatedElement) { public boolean support(AnnotatedElement annotatedEle) {
return (annotatedElement instanceof Class && ClassUtil.isAssignable(Annotation.class, (Class<?>) annotatedElement)); return (annotatedEle instanceof Class && ClassUtil.isAssignable(Annotation.class, (Class<?>)annotatedEle));
} }
/** /**
* 获取注解元素上的全部注解。调用该方法前，需要确保调用{@link #support(AnnotatedElement)}返回为true * 获取注解元素上的全部注解。调用该方法前，需要确保调用{@link #support(AnnotatedElement)}返回为true
* *
* @param annotatedElement 注解元素 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @return 注解 * @return 注解
*/ */
@Override @Override
public List<Annotation> getAnnotations(AnnotatedElement annotatedElement) { public List<Annotation> getAnnotations(AnnotatedElement annotatedEle) {
final List<Annotation> annotations = new ArrayList<>(); final List<Annotation> annotations = new ArrayList<>();
scan( scan(
(index, annotation) -> annotations.add(annotation), (index, annotation) -> annotations.add(annotation), annotatedEle,
annotatedElement, annotation -> ObjectUtil.notEqual(annotation, annotatedEle)
annotation -> ObjectUtil.notEqual(annotation, annotatedElement)
); );
return annotations; return annotations;
} }
@ -77,15 +76,15 @@ public class MetaAnnotationScanner implements AnnotationScanner {
/** /**
* 按广度优先扫描指定注解上的元注解，对扫描到的注解与层级索引进行操作 * 按广度优先扫描指定注解上的元注解，对扫描到的注解与层级索引进行操作
* *
* @param consumer 当前层级索引与操作 * @param consumer 当前层级索引与操作
* @param source 源注解 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @param filter 过滤器 * @param filter 过滤器
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@Override @Override
public void scan(BiConsumer<Integer, Annotation> consumer, AnnotatedElement source, Predicate<Annotation> filter) { public void scan(BiConsumer<Integer, Annotation> consumer, AnnotatedElement annotatedEle, Predicate<Annotation> filter) {
filter = ObjectUtil.defaultIfNull(filter, t -> true); filter = ObjectUtil.defaultIfNull(filter, t -> true);
final Deque<List<Class<? extends Annotation>>> deque = CollUtil.newLinkedList(CollUtil.newArrayList((Class<? extends Annotation>)source)); final Deque<List<Class<? extends Annotation>>> deque = CollUtil.newLinkedList(CollUtil.newArrayList((Class<? extends Annotation>)annotatedEle));
int distance = 0; int distance = 0;
do { do {
final List<Class<? extends Annotation>> annotationTypes = deque.removeFirst(); final List<Class<? extends Annotation>> annotationTypes = deque.removeFirst();

17
hutool-core/src/main/java/cn/hutool/core/annotation/scanner/MethodAnnotationScanner.java
View File

@ -49,21 +49,19 @@ public class MethodAnnotationScanner extends AbstractTypeAnnotationScanner<Metho
/** /**
* 判断是否支持扫描该注解元素，仅当注解元素是{@link Method}时返回{@code true} * 判断是否支持扫描该注解元素，仅当注解元素是{@link Method}时返回{@code true}
* *
* @param annotatedElement 注解元素 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @return boolean 是否支持扫描该注解元素 * @return boolean 是否支持扫描该注解元素
*/ */
@Override @Override
public boolean support(AnnotatedElement annotatedElement) { public boolean support(AnnotatedElement annotatedEle) {
return annotatedElement instanceof Method; return annotatedEle instanceof Method;
} }
/** /**
* 获取声明该方法的类 * 获取声明该方法的类
* *
* @param annotatedElement 注解元素 * @param annotatedElement 注解元素
* @return java.lang.Class<?> * @return 要递归的类型
* @author huangchengxing
* @date 2022/6/29 17:21
* @see Method#getDeclaringClass() * @see Method#getDeclaringClass()
*/ */
@Override @Override
@ -74,9 +72,10 @@ public class MethodAnnotationScanner extends AbstractTypeAnnotationScanner<Metho
/** /**
* 若父类/父接口中方法具有相同的方法签名，则返回该方法上的注解 * 若父类/父接口中方法具有相同的方法签名，则返回该方法上的注解
* *
* @param source 原始方法 * @param source 原始方法
* @param index 类的层级索引 * @param index 类的层级索引
* @param targetClass 类 * @param targetClass 类
* @return 最终所需的目标注解
*/ */
@Override @Override
protected Annotation[] getAnnotationsFromTargetClass(AnnotatedElement source, int index, Class<?> targetClass) { protected Annotation[] getAnnotationsFromTargetClass(AnnotatedElement source, int index, Class<?> targetClass) {
@ -92,7 +91,7 @@ public class MethodAnnotationScanner extends AbstractTypeAnnotationScanner<Metho
/** /**
* 设置是否扫描类层级结构中具有相同方法签名的方法 * 设置是否扫描类层级结构中具有相同方法签名的方法
* *
* @param scanSuperMethodIfOverride 则是否扫描原方法 * @param scanSuperMethodIfOverride 是否扫描类层级结构中具有相同方法签名的方法
* @return 当前实例 * @return 当前实例
*/ */
public MethodAnnotationScanner setScanSameSignatureMethod(boolean scanSuperMethodIfOverride) { public MethodAnnotationScanner setScanSameSignatureMethod(boolean scanSuperMethodIfOverride) {

20
hutool-core/src/main/java/cn/hutool/core/annotation/scanner/TypeAnnotationScanner.java
View File

@ -38,23 +38,23 @@ public class TypeAnnotationScanner extends AbstractTypeAnnotationScanner<TypeAnn
/** /**
* 判断是否支持扫描该注解元素，仅当注解元素是{@link Class}接时返回{@code true} * 判断是否支持扫描该注解元素，仅当注解元素是{@link Class}接时返回{@code true}
* *
* @param annotatedElement 注解元素 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @return 是否支持扫描该注解元素 * @return 是否支持扫描该注解元素
*/ */
@Override @Override
public boolean support(AnnotatedElement annotatedElement) { public boolean support(AnnotatedElement annotatedEle) {
return annotatedElement instanceof Class; return annotatedEle instanceof Class;
} }
/** /**
* 将注解元素转为{@link Class} * 将注解元素转为{@link Class}
* *
* @param annotatedElement 注解元素 * @param annotatedEle {@link AnnotatedElement}，可以是Class、Method、Field、Constructor、ReflectPermission
* @return 类 * @return 要递归的类型
*/ */
@Override @Override
protected Class<?> getClassFormAnnotatedElement(AnnotatedElement annotatedElement) { protected Class<?> getClassFormAnnotatedElement(AnnotatedElement annotatedEle) {
return (Class<?>)annotatedElement; return (Class<?>)annotatedEle;
} }
/** /**
@ -73,7 +73,7 @@ public class TypeAnnotationScanner extends AbstractTypeAnnotationScanner<TypeAnn
/** /**
* 是否允许扫描父类 * 是否允许扫描父类
* *
* @param includeSupperClass 是否 * @param includeSupperClass 是否允许扫描父类
* @return 当前实例 * @return 当前实例
*/ */
@Override @Override
@ -84,7 +84,7 @@ public class TypeAnnotationScanner extends AbstractTypeAnnotationScanner<TypeAnn
/** /**
* 是否允许扫描父接口 * 是否允许扫描父接口
* *
* @param includeInterfaces 是否 * @param includeInterfaces 是否允许扫描父类
* @return 当前实例 * @return 当前实例
*/ */
@Override @Override
@ -94,9 +94,7 @@ public class TypeAnnotationScanner extends AbstractTypeAnnotationScanner<TypeAnn
/** /**
* 若类型为jdk代理类，则尝试转换为原始被代理类 * 若类型为jdk代理类，则尝试转换为原始被代理类
* @deprecated replace with {@link AbstractTypeAnnotationScanner.JdkProxyClassConverter}
*/ */
@Deprecated
public static class JdkProxyClassConverter implements UnaryOperator<Class<?>> { public static class JdkProxyClassConverter implements UnaryOperator<Class<?>> {
@Override @Override
public Class<?> apply(Class<?> sourceClass) { public Class<?> apply(Class<?> sourceClass) {