From 0b60b24950546a2e1e716f94a2eea8286a8d413a Mon Sep 17 00:00:00 2001 From: huangchengxing <841396397@qq.com> Date: Thu, 30 Jun 2022 15:30:41 +0800 Subject: [PATCH] =?UTF-8?q?test:=20=E6=B3=A8=E8=A7=A3=E6=89=AB=E6=8F=8F?= =?UTF-8?q?=E5=99=A8=E7=9A=84=E5=AE=8C=E5=96=84=E6=B5=8B=E8=AF=95=E7=94=A8?= =?UTF-8?q?=E4=BE=8B;?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../scanner/AnnotationForScannerTest.java | 2 +- .../scanner/FieldAnnotationScannerTest.java | 37 +++++- .../scanner/MateAnnotationScannerTest.java | 47 ++++++- .../scanner/MethodAnnotationScannerTest.java | 123 ++++++++++++++++-- .../scanner/TypeAnnotationScannerTest.java | 105 +++++++++++++-- 5 files changed, 278 insertions(+), 36 deletions(-) diff --git a/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/AnnotationForScannerTest.java b/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/AnnotationForScannerTest.java index d032a516b..c6fab4ddb 100644 --- a/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/AnnotationForScannerTest.java +++ b/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/AnnotationForScannerTest.java @@ -11,5 +11,5 @@ import java.lang.annotation.Target; @Retention(RetentionPolicy.RUNTIME) @Target({ ElementType.ANNOTATION_TYPE, ElementType.TYPE, ElementType.METHOD, ElementType.FIELD }) @interface AnnotationForScannerTest { - + String value() default ""; } diff --git a/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/FieldAnnotationScannerTest.java b/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/FieldAnnotationScannerTest.java index 59af613bd..e9881b234 100644 --- a/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/FieldAnnotationScannerTest.java +++ b/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/FieldAnnotationScannerTest.java @@ -7,16 +7,25 @@ import org.junit.Test; import java.lang.annotation.Annotation; import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; -/** - * @author huangchengxing - */ public class FieldAnnotationScannerTest { @Test - public void testFieldAnnotationScanner() { - FieldAnnotationScanner scanner = new FieldAnnotationScanner(); + public void supportTest() { + AnnotationScanner scanner = new FieldAnnotationScanner(); + Assert.assertTrue(scanner.support(ReflectUtil.getField(Example.class, "id"))); + Assert.assertFalse(scanner.support(ReflectUtil.getMethod(Example.class, "getId"))); + Assert.assertFalse(scanner.support(null)); + Assert.assertFalse(scanner.support(Example.class)); + } + + @Test + public void getAnnotationsTest() { + AnnotationScanner scanner = new FieldAnnotationScanner(); Field field = ReflectUtil.getField(Example.class, "id"); Assert.assertNotNull(field); Assert.assertTrue(scanner.support(field)); @@ -25,9 +34,27 @@ public class FieldAnnotationScannerTest { Assert.assertEquals(AnnotationForScannerTest.class, CollUtil.getFirst(annotations).annotationType()); } + @Test + public void scanTest() { + AnnotationScanner scanner = new FieldAnnotationScanner(); + Field field = ReflectUtil.getField(Example.class, "id"); + Map> map = new HashMap<>(); + scanner.scan( + (index, annotation) -> map.computeIfAbsent(index, i -> new ArrayList<>()).add(annotation), + field, null + ); + Assert.assertEquals(1, map.size()); + Assert.assertEquals(1, map.get(0).size()); + Assert.assertEquals(AnnotationForScannerTest.class, map.get(0).get(0).annotationType()); + } + public static class Example { @AnnotationForScannerTest private Integer id; + + public Integer getId() { + return id; + } } } diff --git a/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/MateAnnotationScannerTest.java b/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/MateAnnotationScannerTest.java index 1b36181fe..780edd62a 100644 --- a/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/MateAnnotationScannerTest.java +++ b/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/MateAnnotationScannerTest.java @@ -1,21 +1,30 @@ package cn.hutool.core.annotation.scanner; import cn.hutool.core.collection.CollUtil; +import cn.hutool.core.util.ReflectUtil; import org.junit.Assert; import org.junit.Test; import java.lang.annotation.*; +import java.util.ArrayList; import java.util.HashMap; +import java.util.List; import java.util.Map; -/** - * @author huangchengxing - * @date 2022/06/10 16:51 - */ public class MateAnnotationScannerTest { @Test - public void testMateAnnotationScanner() { + public void supportTest() { + AnnotationScanner scanner = new MetaAnnotationScanner(); + Assert.assertTrue(scanner.support(AnnotationForScannerTest.class)); + Assert.assertFalse(scanner.support(ReflectUtil.getField(Example.class, "id"))); + Assert.assertFalse(scanner.support(ReflectUtil.getMethod(Example.class, "getId"))); + Assert.assertFalse(scanner.support(null)); + Assert.assertFalse(scanner.support(Example.class)); + } + + @Test + public void getAnnotationsTest() { AnnotationScanner scanner = new MetaAnnotationScanner(); Assert.assertTrue(scanner.support(AnnotationForScannerTest3.class)); Map, Annotation> annotations = CollUtil.toMap(scanner.getAnnotations(AnnotationForScannerTest3.class), new HashMap<>(), Annotation::annotationType); @@ -35,8 +44,32 @@ public class MateAnnotationScannerTest { Assert.assertFalse(annotations.containsKey(AnnotationForScannerTest3.class)); } - @AnnotationForScannerTest3 - static class Example {} + @Test + public void scanTest() { + AnnotationScanner scanner = new MetaAnnotationScanner(); + Map> map = new HashMap<>(); + scanner.scan( + (index, annotation) -> map.computeIfAbsent(index, i -> new ArrayList<>()).add(annotation), + AnnotationForScannerTest3.class, null + ); + + Assert.assertEquals(3, map.size()); + Assert.assertEquals(1, map.get(0).size()); + Assert.assertEquals(AnnotationForScannerTest2.class, map.get(0).get(0).annotationType()); + + Assert.assertEquals(1, map.get(1).size()); + Assert.assertEquals(AnnotationForScannerTest1.class, map.get(1).get(0).annotationType()); + + Assert.assertEquals(1, map.get(2).size()); + Assert.assertEquals(AnnotationForScannerTest.class, map.get(2).get(0).annotationType()); + } + + static class Example { + private Integer id; + public Integer getId() { + return id; + } + } @AnnotationForScannerTest @Retention(RetentionPolicy.RUNTIME) diff --git a/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/MethodAnnotationScannerTest.java b/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/MethodAnnotationScannerTest.java index 25798c84d..1ccde3908 100644 --- a/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/MethodAnnotationScannerTest.java +++ b/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/MethodAnnotationScannerTest.java @@ -1,35 +1,138 @@ package cn.hutool.core.annotation.scanner; import cn.hutool.core.collection.CollUtil; +import cn.hutool.core.util.ClassUtil; import cn.hutool.core.util.ReflectUtil; import org.junit.Assert; import org.junit.Test; import java.lang.annotation.Annotation; import java.lang.reflect.Method; -import java.util.List; +import java.util.*; -/** - * @author huangchengxing - */ public class MethodAnnotationScannerTest { @Test - public void testMethodAnnotationScanner() { + public void supportTest() { + AnnotationScanner scanner = new MethodAnnotationScanner(); + Assert.assertTrue(scanner.support(ReflectUtil.getMethod(Example.class, "test"))); + Assert.assertFalse(scanner.support(null)); + Assert.assertFalse(scanner.support(Example.class)); + Assert.assertFalse(scanner.support(ReflectUtil.getField(Example.class, "id"))); + } + + @Test + public void getAnnotationsTest() { AnnotationScanner scanner = new MethodAnnotationScanner(); Method method = ReflectUtil.getMethod(Example.class, "test"); Assert.assertNotNull(method); - Assert.assertTrue(scanner.support(method)); + + // 不查找父类中具有相同方法签名的方法 List annotations = scanner.getAnnotations(method); Assert.assertEquals(1, annotations.size()); Assert.assertEquals(CollUtil.getFirst(annotations).annotationType(), AnnotationForScannerTest.class); + + // 查找父类中具有相同方法签名的方法 + scanner = new MethodAnnotationScanner(true); + annotations = scanner.getAnnotations(method); + Assert.assertEquals(3, annotations.size()); + Assert.assertEquals("Example", ((AnnotationForScannerTest) annotations.get(0)).value()); + Assert.assertEquals("SuperClass", ((AnnotationForScannerTest) annotations.get(1)).value()); + Assert.assertEquals("SuperInterface", ((AnnotationForScannerTest) annotations.get(2)).value()); + + // 查找父类中具有相同方法签名的方法，但是不查找SuperInterface + scanner = new MethodAnnotationScanner(true).addExcludeTypes(SuperInterface.class); + annotations = scanner.getAnnotations(method); + Assert.assertEquals(2, annotations.size()); + Assert.assertEquals("Example", ((AnnotationForScannerTest) annotations.get(0)).value()); + Assert.assertEquals("SuperClass", ((AnnotationForScannerTest) annotations.get(1)).value()); + + // 查找父类中具有相同方法签名的方法，但是只查找SuperClass + scanner = new MethodAnnotationScanner(true) + .setFilter(t -> ClassUtil.isAssignable(SuperClass.class, t)); + annotations = scanner.getAnnotations(method); + Assert.assertEquals(2, annotations.size()); + Assert.assertEquals("Example", ((AnnotationForScannerTest) annotations.get(0)).value()); + Assert.assertEquals("SuperClass", ((AnnotationForScannerTest) annotations.get(1)).value()); } - static class Example { - @AnnotationForScannerTest - public void test() { + @Test + public void scanTest() { + Method method = ReflectUtil.getMethod(Example.class, "test"); + + // 不查找父类中具有相同方法签名的方法 + Map> map = new HashMap<>(); + new MethodAnnotationScanner(false).scan( + (index, annotation) -> map.computeIfAbsent(index, i -> new ArrayList<>()).add(annotation), + method, null + ); + Assert.assertEquals(1, map.get(0).size()); + Assert.assertEquals("Example", ((AnnotationForScannerTest) map.get(0).get(0)).value()); + + // 查找父类中具有相同方法签名的方法 + map.clear(); + new MethodAnnotationScanner(true).scan( + (index, annotation) -> map.computeIfAbsent(index, i -> new ArrayList<>()).add(annotation), + method, null + ); + Assert.assertEquals(3, map.size()); + Assert.assertEquals(1, map.get(0).size()); + Assert.assertEquals("Example", ((AnnotationForScannerTest) map.get(0).get(0)).value()); + Assert.assertEquals(1, map.get(1).size()); + Assert.assertEquals("SuperClass", ((AnnotationForScannerTest) map.get(1).get(0)).value()); + Assert.assertEquals(1, map.get(2).size()); + Assert.assertEquals("SuperInterface", ((AnnotationForScannerTest) map.get(2).get(0)).value()); + + // 查找父类中具有相同方法签名的方法，但是不查找SuperInterface + map.clear(); + new MethodAnnotationScanner(true) + .addExcludeTypes(SuperInterface.class) + .scan( + (index, annotation) -> map.computeIfAbsent(index, i -> new ArrayList<>()).add(annotation), + method, null + ); + Assert.assertEquals(2, map.size()); + Assert.assertEquals(1, map.get(0).size()); + Assert.assertEquals("Example", ((AnnotationForScannerTest) map.get(0).get(0)).value()); + Assert.assertEquals(1, map.get(1).size()); + Assert.assertEquals("SuperClass", ((AnnotationForScannerTest) map.get(1).get(0)).value()); + + // 查找父类中具有相同方法签名的方法，但是只查找SuperClass + map.clear(); + new MethodAnnotationScanner(true) + .setFilter(t -> ClassUtil.isAssignable(SuperClass.class, t)) + .scan( + (index, annotation) -> map.computeIfAbsent(index, i -> new ArrayList<>()).add(annotation), + method, null + ); + Assert.assertEquals(2, map.size()); + Assert.assertEquals(1, map.get(0).size()); + Assert.assertEquals("Example", ((AnnotationForScannerTest) map.get(0).get(0)).value()); + Assert.assertEquals(1, map.get(1).size()); + Assert.assertEquals("SuperClass", ((AnnotationForScannerTest) map.get(1).get(0)).value()); + } + + static class Example extends SuperClass { + private Integer id; + + @Override + @AnnotationForScannerTest("Example") + public List test() { return Collections.emptyList(); } + } + + static class SuperClass implements SuperInterface { + + @Override + @AnnotationForScannerTest("SuperClass") + public Collection test() { return Collections.emptyList(); } + + } + + interface SuperInterface { + + @AnnotationForScannerTest("SuperInterface") + Object test(); - } } } diff --git a/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/TypeAnnotationScannerTest.java b/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/TypeAnnotationScannerTest.java index 1df0727d1..0b3f31f81 100644 --- a/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/TypeAnnotationScannerTest.java +++ b/hutool-core/src/test/java/cn/hutool/core/annotation/scanner/TypeAnnotationScannerTest.java @@ -1,62 +1,141 @@ package cn.hutool.core.annotation.scanner; import cn.hutool.core.util.ClassUtil; +import cn.hutool.core.util.ReflectUtil; import org.junit.Assert; import org.junit.Test; import java.lang.annotation.Annotation; +import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; -/** - * @author huangchengxing - * @date 2022/06/10 16:51 - */ public class TypeAnnotationScannerTest { @Test - public void testTypeAnnotationScanner() { + public void supportTest() { AnnotationScanner scanner = new TypeAnnotationScanner(); Assert.assertTrue(scanner.support(Example.class)); + Assert.assertFalse(scanner.support(ReflectUtil.getField(Example.class, "id"))); + Assert.assertFalse(scanner.support(ReflectUtil.getMethod(Example.class, "getId"))); + Assert.assertFalse(scanner.support(null)); + } + + @Test + public void getAnnotationsTest() { + AnnotationScanner scanner = new TypeAnnotationScanner(); List annotations = scanner.getAnnotations(Example.class); Assert.assertEquals(3, annotations.size()); annotations.forEach(a -> Assert.assertEquals(a.annotationType(), AnnotationForScannerTest.class)); // 不查找父接口 scanner = new TypeAnnotationScanner().setIncludeInterfaces(false); - Assert.assertTrue(scanner.support(Example.class)); annotations = scanner.getAnnotations(Example.class); Assert.assertEquals(2, annotations.size()); annotations.forEach(a -> Assert.assertEquals(a.annotationType(), AnnotationForScannerTest.class)); // 不查找父类 scanner = new TypeAnnotationScanner().setIncludeSupperClass(false); - Assert.assertTrue(scanner.support(Example.class)); annotations = scanner.getAnnotations(Example.class); Assert.assertEquals(1, annotations.size()); annotations.forEach(a -> Assert.assertEquals(a.annotationType(), AnnotationForScannerTest.class)); // 不查找ExampleSupplerClass.class scanner = new TypeAnnotationScanner().addExcludeTypes(ExampleSupplerClass.class); - Assert.assertTrue(scanner.support(Example.class)); annotations = scanner.getAnnotations(Example.class); Assert.assertEquals(1, annotations.size()); annotations.forEach(a -> Assert.assertEquals(a.annotationType(), AnnotationForScannerTest.class)); // 只查找ExampleSupplerClass.class scanner = new TypeAnnotationScanner().setFilter(t -> ClassUtil.isAssignable(ExampleSupplerClass.class, t)); - Assert.assertTrue(scanner.support(Example.class)); annotations = scanner.getAnnotations(Example.class); Assert.assertEquals(2, annotations.size()); annotations.forEach(a -> Assert.assertEquals(a.annotationType(), AnnotationForScannerTest.class)); } - @AnnotationForScannerTest + @Test + public void scanTest() { + Map> map = new HashMap<>(); + + // 查找父类与父接口 + new TypeAnnotationScanner().scan( + (index, annotation) -> map.computeIfAbsent(index, i -> new ArrayList<>()).add(annotation), + Example.class, null + ); + Assert.assertEquals(3, map.size()); + Assert.assertEquals(1, map.get(0).size()); + Assert.assertEquals("Example", ((AnnotationForScannerTest) map.get(0).get(0)).value()); + Assert.assertEquals(1, map.get(1).size()); + Assert.assertEquals("ExampleSupplerClass", ((AnnotationForScannerTest) map.get(1).get(0)).value()); + Assert.assertEquals(1, map.get(2).size()); + Assert.assertEquals("ExampleInterface", ((AnnotationForScannerTest) map.get(2).get(0)).value()); + + // 不查找父接口 + map.clear(); + new TypeAnnotationScanner() + .setIncludeInterfaces(false) + .scan( + (index, annotation) -> map.computeIfAbsent(index, i -> new ArrayList<>()).add(annotation), + Example.class, null + ); + Assert.assertEquals(2, map.size()); + Assert.assertEquals(1, map.get(0).size()); + Assert.assertEquals("Example", ((AnnotationForScannerTest) map.get(0).get(0)).value()); + Assert.assertEquals(1, map.get(1).size()); + Assert.assertEquals("ExampleSupplerClass", ((AnnotationForScannerTest) map.get(1).get(0)).value()); + + // 不查找父类 + map.clear(); + new TypeAnnotationScanner() + .setIncludeSupperClass(false) + .scan( + (index, annotation) -> map.computeIfAbsent(index, i -> new ArrayList<>()).add(annotation), + Example.class, null + ); + Assert.assertEquals(1, map.size()); + Assert.assertEquals(1, map.get(0).size()); + Assert.assertEquals("Example", ((AnnotationForScannerTest) map.get(0).get(0)).value()); + + // 不查找ExampleSupplerClass.class + map.clear(); + new TypeAnnotationScanner() + .addExcludeTypes(ExampleSupplerClass.class) + .scan( + (index, annotation) -> map.computeIfAbsent(index, i -> new ArrayList<>()).add(annotation), + Example.class, null + ); + Assert.assertEquals(1, map.size()); + Assert.assertEquals(1, map.get(0).size()); + Assert.assertEquals("Example", ((AnnotationForScannerTest) map.get(0).get(0)).value()); + + // 只查找ExampleSupplerClass.class + map.clear(); + new TypeAnnotationScanner() + .setFilter(t -> ClassUtil.isAssignable(ExampleSupplerClass.class, t)) + .scan( + (index, annotation) -> map.computeIfAbsent(index, i -> new ArrayList<>()).add(annotation), + Example.class, null + ); + Assert.assertEquals(2, map.size()); + Assert.assertEquals(1, map.get(0).size()); + Assert.assertEquals("Example", ((AnnotationForScannerTest) map.get(0).get(0)).value()); + Assert.assertEquals(1, map.get(1).size()); + Assert.assertEquals("ExampleSupplerClass", ((AnnotationForScannerTest) map.get(1).get(0)).value()); + } + + @AnnotationForScannerTest("ExampleSupplerClass") static class ExampleSupplerClass implements ExampleInterface {} - @AnnotationForScannerTest + @AnnotationForScannerTest("ExampleInterface") interface ExampleInterface {} - @AnnotationForScannerTest - static class Example extends ExampleSupplerClass {} + @AnnotationForScannerTest("Example") + static class Example extends ExampleSupplerClass { + private Integer id; + public Integer getId() { + return id; + } + } }