Handle null fields and prevent reflection cycles

Updated reflection helpers to be more null-safe and robust. `FieldUtils#getFieldValue`/`setFieldValue` now accept nullable `Field` inputs and return `null` when a field is missing instead of throwing from null assertions, with trace logging aligned to the new flow. `ReflectionUtils#readFieldsAsMap` now reads inherited non-static fields and tracks visited instances to avoid recursive cycles while mapping nested objects. Tests were adjusted to match the new missing-field behavior, and `Data#hashCode` was hardened with null-safe/object-type-specific hash calls.

Author: mercyblitz

microsphere-java-core/src/main/java/io/microsphere/reflect/FieldUtils.java

@@ -37,7 +37,6 @@
 import static io.microsphere.reflect.AccessibleObjectUtils.trySetAccessible;
 import static io.microsphere.reflect.TypeUtils.isObjectClass;
 import static io.microsphere.text.FormatUtils.format;
-import static io.microsphere.util.Assert.assertNotNull;
 import static io.microsphere.util.ClassUtils.getAllInheritedTypes;
 import static io.microsphere.util.ObjectUtils.defaultIfNull;
 import static java.util.Collections.unmodifiableSet;
@@ -767,17 +766,16 @@ public static <V> V getFieldValue(boolean forceAccess, @Nonnull Object instance,
      *
      * @param <V>      The type of the field value
      * @param instance The object instance from which to retrieve the field value
-     * @param field    The {@link Field} object representing the field to retrieve
+     * @param field    The {@link Field} object representing the field to retrieve (nullable)
      * @return The field value, or {@code null} if the field is {@code null}
      * @throws IllegalStateException    if this {@code Field} object is enforcing Java language access control and the
      *                                  underlying field is inaccessible
      * @throws IllegalArgumentException if the specified object is not an instance of the class or interface declaring
-     *                                  the underlying field (or a subclass or implementor thereof), or if the field
-     *                                  is <code>null</code>.
+     *                                  the underlying field (or a subclass or implementor thereof)
      * @throws NullPointerException     if the specified object is null and the field is an instance field.
      */
     @Nullable
-    public static <V> V getFieldValue(@Nullable Object instance, @Nonnull Field field) throws IllegalStateException,
+    public static <V> V getFieldValue(@Nullable Object instance, @Nullable Field field) throws IllegalStateException,
             IllegalArgumentException, NullPointerException {
         return getFieldValue(false, instance, field);
     }
@@ -804,19 +802,21 @@ public static <V> V getFieldValue(@Nullable Object instance, @Nonnull Field fiel
      * @param <V>         The type of the field value
      * @param forceAccess Whether to force reflective accessibility when reading the field
      * @param instance    The object instance from which to retrieve the field value
-     * @param field       The {@link Field} object representing the field to retrieve
+     * @param field       The {@link Field} object representing the field to retrieve (nullable)
      * @return The value of the field if found and accessible; otherwise, {@code null}
      * @throws IllegalStateException    if this {@code Field} object is enforcing Java language access control and the
      *                                  underlying field is inaccessible.
      * @throws IllegalArgumentException if the specified object is not an
      *                                  instance of the class or interface declaring the underlying field (or a subclass
-     *                                  or implementor thereof). or if the field is <code>null</code>.
+     *                                  or implementor thereof).
      * @throws NullPointerException     if the specified object is null and the field is an instance field.
      */
     @Nullable
-    public static <V> V getFieldValue(boolean forceAccess, @Nullable Object instance, @Nonnull Field field) throws
+    public static <V> V getFieldValue(boolean forceAccess, @Nullable Object instance, @Nullable Field field) throws
             IllegalStateException, IllegalArgumentException, NullPointerException {
-        assertNotNull(field, () -> "The 'field' must not be null");
+        if (field == null) {
+            return null;
+        }
 
         V fieldValue = null;
         RuntimeException failure = null;
@@ -830,7 +830,7 @@ public static <V> V getFieldValue(boolean forceAccess, @Nullable Object instance
             failure = new IllegalStateException(e);
         } finally {
             if (logger.isTraceEnabled()) {
-                logger.trace("The value of field[signature : '{}' , forceAccess : {} , trySetAccessible : {} , instance : {}] : {}",
+                logger.trace("Got the value of field[signature : '{}' , forceAccess : {} , trySetAccessible : {} , instance : {}] : {}",
                         field, forceAccess, trySetAccessible, instance, fieldValue, failure);
             }
         }
@@ -971,7 +971,7 @@ public static <V> V setFieldValue(boolean forceAccess, @Nullable Object instance
      * @throws NullPointerException     if the specified object is null and the field is an instance field.
      */
     @Nullable
-    public static <V> V setFieldValue(@Nullable Object instance, @Nonnull Field field, @Nullable V value) throws IllegalStateException, IllegalArgumentException {
+    public static <V> V setFieldValue(@Nullable Object instance, @Nullable Field field, @Nullable V value) throws IllegalStateException, IllegalArgumentException {
         return setFieldValue(false, instance, field, value);
     }
 
@@ -1009,22 +1009,34 @@ public static <V> V setFieldValue(@Nullable Object instance, @Nonnull Field fiel
      * @throws NullPointerException     if the specified object is null and the field is an instance field
      */
     @Nullable
-    public static <V> V setFieldValue(boolean forceAccess, @Nullable Object instance, @Nonnull Field field, @Nullable V value)
+    public static <V> V setFieldValue(boolean forceAccess, @Nullable Object instance, @Nullable Field field, @Nullable V value)
             throws IllegalStateException, IllegalArgumentException, NullPointerException {
-        assertNotNull(field, () -> "The 'field' must not be null");
+        if (field == null) {
+            return null;
+        }
 
         V previousValue = null;
+        RuntimeException failure = null;
+        boolean trySetAccessible = false;
         try {
             if (forceAccess) {
-                trySetAccessible(field);
+                trySetAccessible = trySetAccessible(field);
             }
             previousValue = (V) field.get(instance);
             if (!Objects.equals(previousValue, value)) {
                 field.set(instance, value);
             }
         } catch (IllegalAccessException | IllegalArgumentException e) {
-            handleFieldException(e, instance, field);
-            throw new IllegalArgumentException(e);
+            failure = new IllegalArgumentException(e);
+        } finally {
+            if (logger.isTraceEnabled()) {
+                logger.trace("Set the value of field[signature : '{}' , forceAccess : {} , trySetAccessible : {} , instance : {}] : {} -> {}",
+                        field, forceAccess, trySetAccessible, instance, previousValue, value, failure);
+            }
+        }
+
+        if (failure != null) {
+            throw failure;
         }
 
         return previousValue;
@@ -1073,12 +1085,6 @@ public static void assertFieldMatchType(Object instance, String fieldName, Class
         }
     }
 
-    static void handleFieldException(Exception e, Object instance, Field field) {
-        if (logger.isTraceEnabled()) {
-            logger.trace("The instance[object : {}] can't match the field[{}]", instance, field, e);
-        }
-    }
-
     private FieldUtils() {
     }
 }

microsphere-java-core/src/main/java/io/microsphere/reflect/ReflectionUtils.java

@@ -15,16 +15,18 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static io.microsphere.collection.ListUtils.newArrayList;
 import static io.microsphere.collection.MapUtils.newLinkedHashMap;
+import static io.microsphere.collection.SetUtils.newHashSet;
 import static io.microsphere.invoke.MethodHandlesLookupUtils.findPublicStatic;
 import static io.microsphere.logging.LoggerFactory.getLogger;
+import static io.microsphere.reflect.FieldUtils.findAllDeclaredFields;
 import static io.microsphere.reflect.FieldUtils.getFieldValue;
-import static io.microsphere.reflect.MemberUtils.isStatic;
 import static io.microsphere.reflect.MethodUtils.findMethod;
 import static io.microsphere.reflect.MethodUtils.invokeMethod;
 import static io.microsphere.reflect.MethodUtils.invokeStaticMethod;
@@ -445,25 +447,33 @@ public static Map<String, Object> readFieldsAsMap(Object object) {
         if (object == null) {
             return emptyMap();
         }
-        Class<?> type = object.getClass();
-        Field[] fields = type.getDeclaredFields();
-        LinkedHashMap<String, Object> fieldsAsMap = newLinkedHashMap(fields.length);
-        for (Field field : fields) {
-
-            if (isStatic(field)) { // To filter static fields
-                continue;
-            }
+        Set<Object> visitedInstances = newHashSet();
+        return readFieldsAsMap(object, visitedInstances);
+    }
 
+    static Map<String, Object> readFieldsAsMap(Object object, Set<Object> visitedInstances) {
+        if (object == null) {
+            return emptyMap();
+        }
+        Class<?> type = object.getClass();
+        Set<Field> allDeclaredFields = findAllDeclaredFields(type, MemberUtils::isNonStatic);
+        visitedInstances.add(object);
+        LinkedHashMap<String, Object> fieldsAsMap = newLinkedHashMap(allDeclaredFields.size());
+        for (Field field : allDeclaredFields) {
             String fieldName = field.getName();
-            Object fieldValue = getFieldValue(true, object, field);
             Class<?> fieldValueType = field.getType();
-            if (fieldValue != object) {
-                if (!isPrimitive(fieldValueType) && !isSimpleType(fieldValueType)
-                        && !object.getClass().equals(fieldValueType)) {
-                    fieldValue = readFieldsAsMap(fieldValue);
+            Object fieldValue = getFieldValue(true, object, field);
+            if (fieldValue != null) {
+                if (!visitedInstances.add(fieldValue)) {
+                    continue;
                 }
-                fieldsAsMap.put(fieldName, fieldValue);
             }
+
+            if (!isPrimitive(fieldValueType) && !isSimpleType(fieldValueType)) {
+                fieldValue = readFieldsAsMap(fieldValue, visitedInstances);
+            }
+
+            fieldsAsMap.put(fieldName, fieldValue);
         }
         return unmodifiableMap(fieldsAsMap);
     }

microsphere-java-core/src/test/java/io/microsphere/reflect/FieldUtilsTest.java

@@ -30,13 +30,11 @@
 import static io.microsphere.reflect.FieldUtils.getDeclaredField;
 import static io.microsphere.reflect.FieldUtils.getFieldValue;
 import static io.microsphere.reflect.FieldUtils.getStaticFieldValue;
-import static io.microsphere.reflect.FieldUtils.handleFieldException;
 import static io.microsphere.reflect.FieldUtils.setFieldValue;
 import static io.microsphere.reflect.FieldUtils.setStaticFieldValue;
 import static io.microsphere.util.VersionUtils.CURRENT_JAVA_VERSION;
 import static io.microsphere.util.VersionUtils.JAVA_VERSION_8;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
@@ -239,7 +237,7 @@ void testSetFieldValue() {
 
     @Test
     void testSetFieldValueOnFieldNotFound() {
-        assertThrows(IllegalArgumentException.class, () -> setFieldValue(test, "notFoundField", null));
+        assertNull(setFieldValue(test, "notFoundField", null));
     }
 
     @Test
@@ -271,12 +269,6 @@ void testAssertFieldMatchTypeOnIllegalArgumentException() {
         assertThrows(IllegalArgumentException.class, () -> assertFieldMatchType(test, "privateField", Integer.class));
     }
 
-    @Test
-    void testHandleFieldException() {
-        Field field = findField(ReflectionTest.class, "staticField");
-        assertDoesNotThrow(() -> handleFieldException(new IllegalAccessException(), test, field));
-    }
-
     private void assertFindField(Object object, String fieldName) {
         assertNotNull(findField(object, fieldName));
     }

microsphere-java-core/src/test/java/io/microsphere/test/Data.java

@@ -179,16 +179,16 @@ && compare(weight, data.weight) == 0
 
     @Override
     public int hashCode() {
-        int result = name.hashCode();
-        result = 31 * result + age;
+        int result = Objects.hashCode(name);
+        result = 31 * result + Integer.hashCode(age);
         result = 31 * result + Boolean.hashCode(male);
         result = 31 * result + Double.hashCode(height);
         result = 31 * result + Float.hashCode(weight);
         result = 31 * result + Long.hashCode(birth);
-        result = 31 * result + index;
-        result = 31 * result + grade;
-        result = 31 * result + sex;
-        result = 31 * result + object.hashCode();
+        result = 31 * result + Short.hashCode(index);
+        result = 31 * result + Byte.hashCode(grade);
+        result = 31 * result + Character.hashCode(sex);
+        result = 31 * result + Objects.hashCode(object);
         result = 31 * result + Arrays.hashCode(names);
         return result;
     }