Merge pull request #144 from microsphere-projects/main

Release 0.1.0

Author: mercyblitz

.github/workflows/maven-build.yml

@@ -12,7 +12,7 @@ on:
   push:
     branches: [ "dev" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "dev" , "main" ]
 
 jobs:
   build:

microsphere-annotation-processor/pom.xml

@@ -25,7 +25,7 @@
 
     <dependencies>
 
-        <!-- microsphere-->
+        <!-- Microsphere Java Core -->
         <dependency>
             <groupId>io.github.microsphere-projects</groupId>
             <artifactId>microsphere-java-core</artifactId>
@@ -45,6 +45,13 @@
             <scope>test</scope>
         </dependency>
 
+        <!-- Logback -->
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <scope>test</scope>
+        </dependency>
+
         <!-- JAX-RS API -->
         <dependency>
             <groupId>javax.ws.rs</groupId>

microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/AnnotationUtils.java

@@ -32,10 +32,14 @@
  *     <li>Comparing to the type names of parameters {@link String#compareTo(String) lexicographically}</li>
  * </ol>
  *
+ * @author <a href="mailto:mercyblitz@gmail.com">Mercy<a/>
  * @since 1.0.0
  */
 public class ExecutableElementComparator implements Comparator<ExecutableElement> {
 
+    /**
+     * The singleton instance
+     */
     public static final ExecutableElementComparator INSTANCE = new ExecutableElementComparator();
 
     private ExecutableElementComparator() {
@@ -60,7 +64,7 @@ public int compare(ExecutableElement e1, ExecutableElement e2) {
 
             if (value == 0) { // Step 3
                 for (int i = 0; i < ps1.size(); i++) {
-                    value = CharSequenceComparator.INSTANCE.compare(ps1.get(i).getSimpleName(), ps2.get(i).getSimpleName());
+                    value = CharSequenceComparator.INSTANCE.compare(ps1.get(i).asType().toString(), ps2.get(i).asType().toString());
                     if (value != 0) {
                         break;
                     }

microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ExecutableElementComparator.java

@@ -16,23 +16,25 @@
  */
 package io.microsphere.annotation.processor.util;
 
+import io.microsphere.util.Utils;
+
 import javax.lang.model.element.Element;
 import javax.lang.model.element.Modifier;
 import javax.lang.model.element.VariableElement;
 import javax.lang.model.type.TypeMirror;
-import java.util.Collection;
 import java.util.List;
 import java.util.function.Predicate;
-import java.util.stream.Collectors;
 
+import static io.microsphere.annotation.processor.util.MemberUtils.getAllDeclaredMembers;
 import static io.microsphere.annotation.processor.util.MemberUtils.getDeclaredMembers;
 import static io.microsphere.annotation.processor.util.MemberUtils.hasModifiers;
-import static io.microsphere.annotation.processor.util.MemberUtils.matches;
-import static io.microsphere.annotation.processor.util.TypeUtils.getHierarchicalTypes;
+import static io.microsphere.annotation.processor.util.MemberUtils.matchesElementKind;
 import static io.microsphere.annotation.processor.util.TypeUtils.isEnumType;
+import static io.microsphere.collection.CollectionUtils.isEmpty;
 import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY;
 import static io.microsphere.lang.function.Streams.filterAll;
 import static io.microsphere.lang.function.Streams.filterFirst;
+import static io.microsphere.util.ArrayUtils.isNotEmpty;
 import static java.util.Collections.emptyList;
 import static javax.lang.model.element.ElementKind.ENUM_CONSTANT;
 import static javax.lang.model.element.ElementKind.FIELD;
@@ -42,60 +44,79 @@
 /**
  * The utilities class for the field in the package "javax.lang.model."
  *
+ * @author <a href="mailto:mercyblitz@gmail.com">Mercy<a/>
  * @since 1.0.0
  */
-public interface FieldUtils {
+public interface FieldUtils extends Utils {
 
-    static List<VariableElement> getDeclaredFields(Element element, Predicate<VariableElement>... fieldFilters) {
-        return element == null ? emptyList() : getDeclaredFields(element.asType(), fieldFilters);
+    static VariableElement getDeclaredField(Element element, String fieldName) {
+        return element == null ? null : getDeclaredField(element.asType(), fieldName);
     }
 
-    static List<VariableElement> getDeclaredFields(Element element) {
-        return getDeclaredFields(element, EMPTY_PREDICATE_ARRAY);
+    static VariableElement getDeclaredField(TypeMirror type, String fieldName) {
+        return filterFirst(findDeclaredFields(type, field -> fieldName.equals(field.getSimpleName().toString())));
     }
 
-    static List<VariableElement> getDeclaredFields(TypeMirror type, Predicate<VariableElement>... fieldFilters) {
-        return filterAll(fieldsIn(getDeclaredMembers(type)), fieldFilters);
+    static List<VariableElement> getDeclaredFields(Element element) {
+        return findDeclaredFields(element, EMPTY_PREDICATE_ARRAY);
     }
 
     static List<VariableElement> getDeclaredFields(TypeMirror type) {
-        return getDeclaredFields(type, EMPTY_PREDICATE_ARRAY);
+        return findDeclaredFields(type, EMPTY_PREDICATE_ARRAY);
     }
 
-    static List<VariableElement> getAllDeclaredFields(Element element, Predicate<VariableElement>... fieldFilters) {
-        return element == null ? emptyList() : getAllDeclaredFields(element.asType(), fieldFilters);
+    static List<VariableElement> getAllDeclaredFields(Element element) {
+        return findAllDeclaredFields(element, EMPTY_PREDICATE_ARRAY);
     }
 
-    static List<VariableElement> getAllDeclaredFields(Element element) {
-        return getAllDeclaredFields(element, EMPTY_PREDICATE_ARRAY);
+    static List<VariableElement> getAllDeclaredFields(TypeMirror type) {
+        return findAllDeclaredFields(type, EMPTY_PREDICATE_ARRAY);
     }
 
-    static List<VariableElement> getAllDeclaredFields(TypeMirror type, Predicate<VariableElement>... fieldFilters) {
-        return getHierarchicalTypes(type)
-                .stream()
-                .map(t -> getDeclaredFields(t, fieldFilters))
-                .flatMap(Collection::stream)
-                .collect(Collectors.toList());
+    static VariableElement findField(Element element, String fieldName) {
+        return element == null ? null : findField(element.asType(), fieldName);
     }
 
-    static List<VariableElement> getAllDeclaredFields(TypeMirror type) {
-        return getAllDeclaredFields(type, EMPTY_PREDICATE_ARRAY);
+    static VariableElement findField(TypeMirror type, String fieldName) {
+        return filterFirst(findAllDeclaredFields(type, field -> equalsFieldName(field, fieldName)));
     }
 
-    static VariableElement getDeclaredField(Element element, String fieldName) {
-        return element == null ? null : getDeclaredField(element.asType(), fieldName);
+    static List<VariableElement> findDeclaredFields(Element element, Predicate<? super VariableElement>... fieldFilters) {
+        return element == null ? emptyList() : findDeclaredFields(element.asType(), fieldFilters);
     }
 
-    static VariableElement getDeclaredField(TypeMirror type, String fieldName) {
-        return filterFirst(getDeclaredFields(type, field -> fieldName.equals(field.getSimpleName().toString())));
+    static List<VariableElement> findDeclaredFields(TypeMirror type, Predicate<? super VariableElement>... fieldFilters) {
+        return filterDeclaredFields(type, false, fieldFilters);
     }
 
-    static VariableElement findField(Element element, String fieldName) {
-        return element == null ? null : findField(element.asType(), fieldName);
+    static List<VariableElement> findAllDeclaredFields(Element element, Predicate<? super VariableElement>... fieldFilters) {
+        return element == null ? emptyList() : findAllDeclaredFields(element.asType(), fieldFilters);
     }
 
-    static VariableElement findField(TypeMirror type, String fieldName) {
-        return filterFirst(getAllDeclaredFields(type, field -> equals(field, fieldName)));
+    static List<VariableElement> findAllDeclaredFields(TypeMirror type, Predicate<? super VariableElement>... fieldFilters) {
+        return filterDeclaredFields(type, true, fieldFilters);
+    }
+
+    static List<VariableElement> filterDeclaredFields(TypeMirror type, boolean all, Predicate<? super VariableElement>... fieldFilters) {
+        if (type == null) {
+            return emptyList();
+        }
+
+        List<? extends Element> declaredMembers = all ? getAllDeclaredMembers(type) : getDeclaredMembers(type);
+        if (isEmpty(declaredMembers)) {
+            return emptyList();
+        }
+
+        List<VariableElement> fields = fieldsIn(declaredMembers);
+        if (isEmpty(fields)) {
+            return emptyList();
+        }
+
+        if (isNotEmpty(fieldFilters)) {
+            fields = filterAll(fields, fieldFilters);
+        }
+
+        return isEmpty(fields) ? emptyList() : fields;
     }
 
     /**
@@ -116,31 +137,30 @@ static boolean isNonStaticField(VariableElement field) {
     }
 
     static boolean isField(VariableElement field) {
-        return matches(field, FIELD) || isEnumMemberField(field);
+        return matchesElementKind(field, FIELD) || isEnumMemberField(field);
     }
 
     static boolean isField(VariableElement field, Modifier... modifiers) {
         return isField(field) && hasModifiers(field, modifiers);
     }
 
     static List<VariableElement> getNonStaticFields(TypeMirror type) {
-        return getDeclaredFields(type, FieldUtils::isNonStaticField);
+        return findDeclaredFields(type, FieldUtils::isNonStaticField);
     }
 
     static List<VariableElement> getNonStaticFields(Element element) {
         return element == null ? emptyList() : getNonStaticFields(element.asType());
     }
 
     static List<VariableElement> getAllNonStaticFields(TypeMirror type) {
-        return getAllDeclaredFields(type, FieldUtils::isNonStaticField);
+        return findAllDeclaredFields(type, FieldUtils::isNonStaticField);
     }
 
     static List<VariableElement> getAllNonStaticFields(Element element) {
         return element == null ? emptyList() : getAllNonStaticFields(element.asType());
     }
 
-    static boolean equals(VariableElement field, CharSequence fieldName) {
+    static boolean equalsFieldName(VariableElement field, CharSequence fieldName) {
         return field != null && fieldName != null && field.getSimpleName().toString().equals(fieldName.toString());
     }
-
 }

microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/FieldUtils.java

@@ -17,31 +17,38 @@
 package io.microsphere.annotation.processor.util;
 
 
-
-
 import io.microsphere.logging.Logger;
-import io.microsphere.logging.LoggerFactory;
+import io.microsphere.util.Utils;
 
-import static java.lang.String.format;
+import static io.microsphere.logging.LoggerFactory.getLogger;
 
 /**
  * Logger Utils
  *
+ * @author <a href="mailto:mercyblitz@gmail.com">Mercy<a/>
  * @since 1.0.0
  */
-public interface LoggerUtils {
+public interface LoggerUtils extends Utils {
+
+    Logger LOGGER = getLogger("microsphere-annotation-processor");
+
+    static void trace(String format, Object... args) {
+        LOGGER.trace(format, args);
+    }
 
-    Logger LOGGER = LoggerFactory.getLogger(LoggerUtils.class);
+    static void debug(String format, Object... args) {
+        LOGGER.debug(format, args);
+    }
 
     static void info(String format, Object... args) {
-        if (LOGGER.isInfoEnabled()) {
-            LOGGER.info(format(format, args));
-        }
+        LOGGER.info(format, args);
     }
 
     static void warn(String format, Object... args) {
-        if (LOGGER.isWarnEnabled()) {
-            LOGGER.warn(format(format, args));
-        }
+        LOGGER.warn(format, args);
+    }
+
+    static void error(String format, Object... args) {
+        LOGGER.error(format, args);
     }
 }