Add interface checks to ClassUtils

Introduce `ClassUtils.isInterface()` and `ClassUtils.isFunctionalInterface()` to make interface detection and functional-interface introspection available through the utility API. The change also updates internal interface modifier usage, fixes a Javadoc reference, and adds coverage for standard and custom interface cases.

Author: mercyblitz

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

@@ -15,6 +15,7 @@
 import io.microsphere.reflect.ConstructorUtils;
 
 import java.io.File;
+import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.math.BigDecimal;
 import java.math.BigInteger;
@@ -56,7 +57,11 @@
 import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY;
 import static io.microsphere.logging.LoggerFactory.getLogger;
 import static io.microsphere.net.URLUtils.resolveProtocol;
+import static io.microsphere.reflect.MethodUtils.findMethods;
+import static io.microsphere.reflect.MethodUtils.isOverridenObjectMethod;
 import static io.microsphere.reflect.Modifier.isAnnotation;
+import static io.microsphere.reflect.Modifier.isBridge;
+import static io.microsphere.reflect.Modifier.isStatic;
 import static io.microsphere.reflect.Modifier.isSynthetic;
 import static io.microsphere.util.ArrayUtils.EMPTY_CLASS_ARRAY;
 import static io.microsphere.util.ArrayUtils.isEmpty;
@@ -73,7 +78,6 @@
 import static java.lang.Boolean.FALSE;
 import static java.lang.Boolean.TRUE;
 import static java.lang.reflect.Modifier.isAbstract;
-import static java.lang.reflect.Modifier.isInterface;
 import static java.util.Collections.addAll;
 import static java.util.Collections.emptyList;
 import static java.util.Collections.emptySet;
@@ -415,6 +419,24 @@ public static boolean isAbstractClass(@Nullable Class<?> type) {
         return isGeneralClass(type, TRUE);
     }
 
+    /**
+     * Checks if the specified type is an interface.
+     *
+     * <h3>Example Usage</h3>
+     * <pre>{@code
+     * boolean result1 = ClassUtils.isInterface(List.class);    // returns true
+     * boolean result2 = ClassUtils.isInterface(String.class);  // returns false
+     * boolean result3 = ClassUtils.isInterface(null);          // returns false
+     * }</pre>
+     *
+     * @param type the type to check, may be {@code null}
+     * @return {@code true} if the specified type is an interface, {@code false} otherwise
+     * @see Class#isInterface()
+     */
+    public static boolean isInterface(@Nullable Class<?> type) {
+        return type != null && type.isInterface();
+    }
+
     /**
      * Checks if the specified type is a general class.
      * <p>
@@ -467,7 +489,7 @@ protected static boolean isGeneralClass(@Nullable Class<?> type, @Nullable Boole
         int mod = type.getModifiers();
         if (isAnnotation(mod)
                 || io.microsphere.reflect.Modifier.isEnum(mod)
-                || isInterface(mod)
+                || io.microsphere.reflect.Modifier.isInterface(mod)
                 || isSynthetic(mod)
                 || isPrimitive(type)
                 || isArray(type)) {
@@ -617,6 +639,55 @@ public static boolean isLambdaClass(@Nullable Class<?> type) {
         return isSyntheticClass(type) && getTypeName(type).contains("$$Lambda/");
     }
 
+
+    /**
+     * Checks if the specified class is a functional interface.
+     * <p>
+     * A functional interface is an interface that has exactly one abstract method.
+     * This method returns {@code true} if the given class is an interface and has exactly one abstract method,
+     * or if it is annotated with {@link FunctionalInterface}. It returns {@code false} otherwise, including for
+     * non-interface classes or interfaces with more than one abstract method. It also returns {@code false} if
+     * the class is {@code null}.
+     * </p>
+     *
+     * <h3>Example Usage</h3>
+     * <pre>{@code
+     * @FunctionalInterface
+     * interface MyFunctionalInterface {
+     *     void doSomething();
+     * }
+     *
+     * boolean result1 = ClassUtils.isFunctionalInterface(MyFunctionalInterface.class); // returns true
+     * boolean result2 = ClassUtils.isFunctionalInterface(Runnable.class);              // returns true
+     * boolean result3 = ClassUtils.isFunctionalInterface(List.class);                  // returns false (not a functional interface)
+     * boolean result4 = ClassUtils.isFunctionalInterface(null);                        // returns false
+     * }</pre>
+     *
+     * @param type the class to check, may be {@code null}
+     * @return {@code true} if the specified class is a functional interface, {@code false} otherwise
+     */
+    public static boolean isFunctionalInterface(@Nullable Class<?> type) {
+        if (!isInterface(type)) {
+            return false;
+        }
+
+        // Trusted by the Java compiler, if the interface is annotated with @FunctionalInterface, it is a functional interface.
+        if (type.isAnnotationPresent(FunctionalInterface.class)) {
+            return true;
+        }
+
+        List<Method> methods = findMethods(type, false, true, method -> {
+            int modifiers = method.getModifiers();
+            if (isStatic(modifiers) || isOverridenObjectMethod(method) || isBridge(modifiers) || isSynthetic(modifiers)
+                    || method.isDefault()) {
+                return false;
+            }
+            return true;
+        });
+
+        return methods.size() == 1;
+    }
+
     /**
      * Checks if the specified class is a primitive type.
      * <p>
@@ -1104,7 +1175,7 @@ public static boolean arrayTypeEquals(@Nullable Class<?> oneArrayType, @Nullable
      * </p>
      * <p>
      * Note: This method does <i>not</i> support the "[]" suffix notation for
-     * primitive arrays; this is only supported by {@link #forName(String)}.
+     * primitive arrays; this is only supported by {@link Class#forName(String)}.
      * </p>
      *
      * <h3>Example Usage</h3>

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

@@ -7,6 +7,7 @@
 import io.microsphere.lang.ClassDataRepository;
 import io.microsphere.test.A;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import javax.annotation.Nonnull;
 import java.io.File;
@@ -20,6 +21,7 @@
 import java.util.AbstractMap;
 import java.util.Collection;
 import java.util.Date;
+import java.util.EventListener;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -29,6 +31,7 @@
 import java.util.TreeMap;
 import java.util.concurrent.TimeUnit;
 import java.util.function.BiFunction;
+import java.util.function.BinaryOperator;
 import java.util.function.Predicate;
 
 import static io.microsphere.AbstractTestCase.createRandomTempFile;
@@ -84,7 +87,9 @@
 import static io.microsphere.util.ClassUtils.isDerived;
 import static io.microsphere.util.ClassUtils.isEnum;
 import static io.microsphere.util.ClassUtils.isFinal;
+import static io.microsphere.util.ClassUtils.isFunctionalInterface;
 import static io.microsphere.util.ClassUtils.isGeneralClass;
+import static io.microsphere.util.ClassUtils.isInterface;
 import static io.microsphere.util.ClassUtils.isLambdaClass;
 import static io.microsphere.util.ClassUtils.isNumber;
 import static io.microsphere.util.ClassUtils.isPrimitive;
@@ -191,6 +196,13 @@ void testIsAbstractClass() {
         assertFalse(isAbstractClass(Object.class));
     }
 
+    @Test
+    void testIsInterface() {
+        assertTrue(isInterface(List.class));
+        assertFalse(isInterface(String.class));
+        assertFalse(isInterface(null));
+    }
+
     @Test
     void testIsGeneralClass() {
         // test null
@@ -248,6 +260,25 @@ void testIsLambdaClass() {
         assertFalse(isLambdaClass(null));
     }
 
+    @Test
+    void testIsFunctionalInterface() {
+        assertFalse(isFunctionalInterface(null));
+        assertFalse(isFunctionalInterface(Object.class));
+        assertFalse(isFunctionalInterface(Serializable.class));
+        assertFalse(isFunctionalInterface(EventListener.class));
+        assertFalse(isFunctionalInterface(Collection.class));
+        // Runnable is annotated with @FunctionalInterface
+        assertTrue(isFunctionalInterface(Runnable.class));
+        // Comparable is not annotated with @FunctionalInterface, and it has only one abstract method compareTo(T o)
+        assertTrue(isFunctionalInterface(Comparable.class));
+        // Annotation
+        assertFalse(isFunctionalInterface(ValueSource.class));
+
+        assertTrue(isFunctionalInterface(StringDescriptive.class));
+        //
+        assertFalse(isFunctionalInterface(Calculator.class));
+    }
+
     @Test
     void testIsPrimitive() {
         assertTrue(isPrimitive(void.class));
@@ -993,4 +1024,27 @@ private void assertFindClassNamesInClassPath(URL location) {
         Set<String> classNamesInClassPath = findClassNamesInClassPath(path, true);
         assertFalse(classNamesInClassPath.isEmpty());
     }
+
+    interface Descriptive {
+
+        CharSequence getDescription();
+    }
+
+    interface StringDescriptive extends Descriptive {
+
+        @Override
+        String getDescription();
+
+        static String name() {
+            return "StringDescriptive";
+        }
+    }
+
+    interface Calculator {
+        // A default method containing a lambda expression
+        default int getAdder() {
+            BinaryOperator<Integer> adder = (a, b) -> a + b;
+            return adder.apply(5, 10);
+        }
+    }
 }