Refactor findMetaAnnotations to use collector

Replace the previous boolean/list-returning recursion with a collector-based approach: build a LinkedList, recurse into annotation types to accumulate matching meta-annotations, and return an unmodifiable list. Import newLinkedList and remove unused isNotEmpty. Update tests to use a new assertFindMetaAnnotation helper and adjust assertions accordingly. This simplifies recursion and ensures all matching meta-annotations are collected in a single list.

Author: mercyblitz

microsphere-java-core/src/main/java/io/microsphere/util/AnnotationUtils.java

@@ -38,8 +38,8 @@
 import java.util.function.Predicate;
 
 import static io.microsphere.collection.CollectionUtils.isEmpty;
-import static io.microsphere.collection.CollectionUtils.isNotEmpty;
 import static io.microsphere.collection.ListUtils.first;
+import static io.microsphere.collection.ListUtils.newLinkedList;
 import static io.microsphere.collection.Lists.ofList;
 import static io.microsphere.collection.MapUtils.immutableEntry;
 import static io.microsphere.collection.MapUtils.toFixedMap;
@@ -1761,9 +1761,9 @@ public static boolean isNativeAnnotationType(Class<? extends Annotation> annotat
      * <p>If either the annotated element or the meta-annotation type is {@code null},
      * this method will return {@code null}.</p>
      *
-     * @param annotatedElement the element to search for meta-annotations on
+     * @param annotatedElement   the element to search for meta-annotations on
      * @param metaAnnotationType the type of meta-annotation to look for
-     * @param <A> the type of the meta-annotation to find
+     * @param <A>                the type of the meta-annotation to find
      * @return the first matching meta-annotation of the specified type, or {@code null} if none is found
      */
     @Nullable
@@ -1822,23 +1822,32 @@ public static <A extends Annotation> A findMetaAnnotation(AnnotatedElement annot
      * <p>If either the annotated element or the meta-annotation type is {@code null},
      * this method will return an empty list.</p>
      *
-     * @param annotatedElement the element to search for meta-annotations on
+     * @param annotatedElement   the element to search for meta-annotations on
      * @param metaAnnotationType the type of meta-annotation to look for
-     * @param <A> the type of the meta-annotation to find
+     * @param <A>                the type of the meta-annotation to find
      * @return a read-only list of all matching meta-annotations of the specified type, never {@code null}
      */
     @Nonnull
     @Immutable
     public static <A extends Annotation> List<A> findMetaAnnotations(AnnotatedElement annotatedElement, Class<A> metaAnnotationType) {
-        return (List<A>) findDeclaredAnnotations(annotatedElement, annotation -> {
+        List<A> annotations = newLinkedList();
+        findMetaAnnotations(annotatedElement, metaAnnotationType, annotations);
+        return unmodifiableList(annotations);
+    }
+
+    static <A extends Annotation> void findMetaAnnotations(AnnotatedElement annotatedElement, Class<A> metaAnnotationType, List<A> annotations) {
+        findDeclaredAnnotations(annotatedElement, annotation -> {
             Class<? extends Annotation> annotationType = annotation.annotationType();
             if (isNativeAnnotationType(annotationType)) {
                 return false;
             }
             if (annotationType.equals(metaAnnotationType)) {
+                annotations.add((A) annotation);
                 return true;
             }
-            return isNotEmpty(findMetaAnnotations(annotationType, metaAnnotationType));
+            // Recursively find meta-annotations on the annotation type
+            findMetaAnnotations(annotationType, metaAnnotationType, annotations);
+            return false;
         });
     }
 

microsphere-java-core/src/test/java/io/microsphere/util/AnnotationUtilsTest.java

@@ -631,14 +631,14 @@ void testIsCallerSensitivePresent() {
 
     @Test
     void testFindMetaAnnotation() {
-        assertNotNull(findMetaAnnotation(A.class, Monitored.class));
-        assertNotNull(findMetaAnnotation(B.class, Monitored.class));
+        assertFindMetaAnnotation(A.class, Monitored.class);
+        assertFindMetaAnnotation(B.class, Monitored.class);
 
-        assertNotNull(findMetaAnnotation(A.class, ServiceMode.class));
-        assertNotNull(findMetaAnnotation(B.class, ServiceMode.class));
+        assertFindMetaAnnotation(A.class, ServiceMode.class);
+        assertFindMetaAnnotation(B.class, ServiceMode.class);
 
-        assertNotNull(findMetaAnnotation(A.class, Template.class));
-        assertNotNull(findMetaAnnotation(B.class, Template.class));
+        assertFindMetaAnnotation(A.class, Template.class);
+        assertFindMetaAnnotation(B.class, Template.class);
 
         assertNull(findMetaAnnotation(AnnotationUtils.class, Monitored.class));
         assertNull(findMetaAnnotation(AnnotationUtils.class, ServiceMode.class));
@@ -657,6 +657,12 @@ void testFindMetaAnnotations() {
         assertFindMetaAnnotations(B.class, Template.class);
     }
 
+    private void assertFindMetaAnnotation(AnnotatedElement annotatedElement, Class<? extends Annotation> metaAnnotationType) {
+        Annotation metaAnnotation = findMetaAnnotation(annotatedElement, metaAnnotationType);
+        assertNotNull(metaAnnotation);
+        assertSame(metaAnnotationType, metaAnnotation.annotationType());
+    }
+
     private void assertFindMetaAnnotations(AnnotatedElement annotatedElement, Class<? extends Annotation> metaAnnotationType) {
         List<? extends Annotation> metaAnnotations = findMetaAnnotations(annotatedElement, metaAnnotationType);
         assertEquals(1, metaAnnotations.size());