diff --git a/pom.xml b/pom.xml
index e9ccec5..b736f47 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
 
     <groupId>io.github.glytching</groupId>
     <artifactId>junit-extensions</artifactId>
-    <version>2.7.0-SNAPSHOT</version>
+    <version>2.8.0-SNAPSHOT</version>
     <packaging>jar</packaging>
 
     <name>JUnit Extensions</name>
@@ -54,7 +54,7 @@
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 
         <junit.platform.version>1.2.0</junit.platform.version>
-        <junit.jupiter.version>5.2.0</junit.jupiter.version>
+        <junit.jupiter.version>5.9.2</junit.jupiter.version>
         <hamcrest.version>1.3</hamcrest.version>
         <mockito.version>2.7.19</mockito.version>
         <random.beans.version>3.9.0</random.beans.version>
@@ -209,6 +209,11 @@
                 </exclusion>
             </exclusions>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-params</artifactId>
+            <version>${junit.jupiter.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.hamcrest</groupId>
             <artifactId>hamcrest-library</artifactId>
@@ -221,6 +226,29 @@
             <version>${mockito.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.alibaba.fastjson2</groupId>
+            <artifactId>fastjson2</artifactId>
+            <version>2.0.25</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.30</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains</groupId>
+            <artifactId>annotations</artifactId>
+            <version>24.1.0</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.jeasy</groupId>
+            <artifactId>easy-random-core</artifactId>
+            <version>4.3.0</version>
+        </dependency>
+
     </dependencies>
 
     <profiles>
diff --git a/src/main/java/io/github/glytching/junit/extension/json/JsonFileArgumentsProvider.java b/src/main/java/io/github/glytching/junit/extension/json/JsonFileArgumentsProvider.java
new file mode 100644
index 0000000..66f35d9
--- /dev/null
+++ b/src/main/java/io/github/glytching/junit/extension/json/JsonFileArgumentsProvider.java
@@ -0,0 +1,288 @@
+package io.github.glytching.junit.extension.json;
+
+import static java.util.Arrays.copyOf;
+import static java.util.Arrays.stream;
+import static java.util.concurrent.CompletableFuture.*;
+
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.JSONReader;
+import java.io.*;
+import java.lang.reflect.*;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.function.BiFunction;
+import java.util.stream.Stream;
+
+import io.github.glytching.junit.extension.json.annotation.JsonFileSource;
+import io.github.glytching.junit.extension.util.RecursiveReferenceDetector;
+import io.github.glytching.junit.extension.util.ReflectionUtils;
+import io.github.glytching.junit.extension.util.TypeUtils;
+import lombok.SneakyThrows;
+import org.jeasy.random.EasyRandom;
+import org.jetbrains.annotations.NotNull;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.support.AnnotationConsumer;
+import org.junit.platform.commons.util.Preconditions;
+
+/**
+ * Provides a way to supply arguments to parameterized tests in JUnit 5 by reading JSON files
+ * specified by the {@link JsonFileSource} annotation. This class implements the {@link ArgumentsProvider}
+ * interface, which is part of the JUnit Jupiter Params API, and the {@link AnnotationConsumer} interface
+ * to consume the {@link JsonFileSource} annotations.
+ *
+ * <p>The {@code JsonFileArgumentsProvider} is responsible for locating the JSON files specified in the
+ * annotation, reading their contents, and converting them into objects of the type expected by the
+ * test method parameters. It supports both simple and generic types, including handling of recursive
+ * type references by setting them to {@code null} to prevent infinite loops during JSON parsing.
+ *
+ * <p>Usage of this class requires the {@code @JsonFileSource} annotation to be present on the test
+ * method with one or more JSON file resources specified. The class will then read each file, deserialize
+ * the JSON content into the required parameter type, and provide it as arguments to the parameterized test.
+ *
+ * <p>Example usage:
+ * <pre>{@code
+ * @ParameterizedTest
+ * @JsonFileSource(resources = "yourTestData.json")
+ * void testWithJsonFileSource(YourCustomType customArgument) {
+ *     assertNotNull(customArgument);
+ *     // Perform tests with the deserialized customArgument object
+ * }
+ * }</pre>
+ *
+ * Detailed example usage can be seen in the {@code JsonFileArgumentsProviderTest}.
+ * <p>Note that this class relies on the {@link com.alibaba.fastjson2.JSON} library for JSON processing
+ * and uses the {@link org.jeasy.random.EasyRandom} library for generating random values for object
+ * instantiation when needed. It also makes use of {@link lombok.SneakyThrows} to bypass checked
+ * exceptions, which should be used cautiously as it may hide potentially recoverable errors.
+ *
+ * <p>This class is part of a suite of extensions that enhance JUnit 5's parameterized testing capabilities,
+ * allowing for more flexible and data-driven test cases.
+ *
+ * @author xiaohui
+ * @see ArgumentsProvider
+ * @see AnnotationConsumer
+ * @see JsonFileSource
+ * @see ParameterizedTest
+ */
+public class JsonFileArgumentsProvider
+    implements AnnotationConsumer<JsonFileSource>, ArgumentsProvider {
+
+    public static final String ADDRESS_DASH = "/";
+    private final BiFunction<Class<?>, String, InputStream> inputStreamProvider;
+    private static final String RESOURCES_PATH_PREFIX = "src/test/resources";
+
+    private static final EasyRandom RANDOM = new EasyRandom();
+
+    private String[] resourceNames;
+
+    private Method requiredTestMethod;
+
+    private Class<?> requiredTestClass;
+
+    private Class<?> testMethodParameterClazz;
+
+    @SuppressWarnings("unused")
+    JsonFileArgumentsProvider() {
+        this(Class::getResourceAsStream);
+    }
+
+    JsonFileArgumentsProvider(BiFunction<Class<?>, String, InputStream> inputStreamProvider) {
+        this.inputStreamProvider = inputStreamProvider;
+    }
+
+    private Object valueOfType(InputStream inputStream) {
+        try (JSONReader reader = JSONReader.of(inputStream, Charset.defaultCharset())) {
+            return reader.read(testMethodParameterClazz);
+        }
+    }
+
+    @Override
+    public void accept(JsonFileSource jsonFileSource) {
+        resourceNames = jsonFileSource.resources();
+    }
+
+    private String[] getResourcePaths(String[] partResourceNames) {
+        final String[] resourcePaths = copyOf(partResourceNames, partResourceNames.length);
+        String packageName = requiredTestClass.getPackage().getName();
+        for (int i = 0; i < resourcePaths.length; i++) {
+            resourcePaths[i] =
+                    packageName.replaceAll("\\.", ADDRESS_DASH) + ADDRESS_DASH + partResourceNames[i];
+        }
+        for (int i = 0; i < resourcePaths.length; i++) {
+            if (!partResourceNames[i].startsWith(ADDRESS_DASH)) {
+                resourcePaths[i] = ADDRESS_DASH + resourcePaths[i];
+            }
+        }
+        return resourcePaths;
+    }
+
+    /** Only support one genericParameterType */
+    @Override
+    public Stream<? extends Arguments> provideArguments(ExtensionContext context) {
+        requiredTestMethod = context.getRequiredTestMethod();
+        requiredTestClass = context.getRequiredTestClass();
+        testMethodParameterClazz = initTestMethodParameterClazz();
+        String[] resourcePaths = getResourcePaths(resourceNames);
+        return stream(resourcePaths)
+                .map(resource -> openInputStream(requiredTestClass, resource))
+                .map(this::valueOfType)
+                .map(Arguments::arguments);
+    }
+
+    /** Only support one genericParameterType */
+    @SneakyThrows
+    private Class<?> initTestMethodParameterClazz() {
+        Type genericParameterType = requiredTestMethod.getGenericParameterTypes()[0];
+        String testMethodParameterTypeName =
+                genericParameterType instanceof ParameterizedType
+                        ? ((ParameterizedType) genericParameterType).getRawType().getTypeName()
+                        : genericParameterType.getTypeName();
+        return Class.forName(testMethodParameterTypeName);
+    }
+
+    @SneakyThrows(Exception.class)
+    private InputStream openInputStream(Class<?> testClass, String resource) {
+        InputStream inputStream;
+        inputStream = inputStreamProvider.apply(testClass, resource);
+        if (inputStream == null) {
+            CompletableFuture<String> resourceFuture = supplyAsync(() -> createTestResource(resource));
+            // avoid too long to end this process by io error
+            inputStream = inputStreamProvider.apply(testClass, resourceFuture.get(5, TimeUnit.SECONDS));
+        }
+        return Preconditions.notNull(
+                inputStream,
+                () ->
+                        "*** Classpath resource does not exist: " + resource + ", and we have created it ***");
+    }
+
+    private String createTestResource(String resource) {
+        createDirectoryForResource(resource);
+        return createFileAndWriteTestResource(resource);
+    }
+
+    private String createFileAndWriteTestResource(String resource) {
+        try {
+            String moduleAbsoluteResource = RESOURCES_PATH_PREFIX + resource;
+            File file = createFile(moduleAbsoluteResource);
+            writeTestResource2File(moduleAbsoluteResource, file);
+            return resource;
+        } catch (IOException e) {
+            System.out.println("Error creating file: " + e.getMessage());
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static File createFile(String moduleAbsoluteResource) throws IOException {
+        File file = new File(moduleAbsoluteResource);
+        if (!file.createNewFile()) {
+            System.out.println("File already exists or could not be created: " + moduleAbsoluteResource);
+        }
+        return file;
+    }
+
+    private void writeTestResource2File(String moduleAbsoluteResource, File file) throws IOException {
+        try (BufferedWriter writer = new BufferedWriter(new FileWriter(moduleAbsoluteResource))) {
+            Type[] genericParameterTypes = requiredTestMethod.getGenericParameterTypes();
+            Type genericParameterType = genericParameterTypes[0];
+            Object parameterInstance = getParameterInstance(genericParameterType);
+            writer.write(JSON.toJSONString(parameterInstance));
+            writer.flush();
+            System.out.println(
+                    moduleAbsoluteResource + (file.exists() ? "\ncreated successfully" : "on way..."));
+        }
+    }
+
+    @SneakyThrows
+    private Object getParameterInstance(Type genericParameterType) {
+        Object object;
+        if (genericParameterType instanceof ParameterizedType) {
+            object = newParameterTypeInstance((ParameterizedType) genericParameterType);
+        } else {
+            object = newConcreteTypeInstance(Class.forName(genericParameterType.getTypeName()));
+        }
+        return object;
+    }
+
+    private static Object newConcreteTypeInstance(Class<?> testMethodParameterClazz1) {
+        Object object = RANDOM.nextObject(testMethodParameterClazz1);
+        setNullIfRecursive(object);
+        return object;
+    }
+
+    public static void setNullIfRecursive(Object object) {
+        if (object == null || TypeUtils.isBuiltInType(object.getClass())) {
+            return;
+        }
+        boolean hasRecursiveReference = RecursiveReferenceDetector.hasRecursiveReference(object);
+        if (hasRecursiveReference) {
+            Stream.of(object.getClass().getDeclaredFields())
+                    .forEach(field -> setNullIfRecursive(object, field));
+        }
+    }
+
+    private static void setNullIfRecursive(Object object, Field it) {
+        Object filedObj = ReflectionUtils.getField(object, it.getName());
+        if (RecursiveReferenceDetector.hasRecursiveReference(filedObj)) {
+            ReflectionUtils.setField(object, it, null);
+        } else {
+            setNullIfRecursive(filedObj);
+        }
+    }
+
+    /**
+     * Here it is assumed that {@code testMethodParameterClass} must have corresponding constructor
+     * arguments.
+     *
+     * <p>Because for parameterized types of classes (such as generic classes), we cannot actually
+     * find that field to assign a value to it, so as a compromise, it is agreed to use the
+     * constructor instead.
+     */
+    @SneakyThrows
+    @NotNull
+    private Object newParameterTypeInstance(ParameterizedType genericParameterType) {
+        Class<?> methodParameterClazz = Class.forName(genericParameterType.getRawType().getTypeName());
+        Type[] genericParameterTypes = genericParameterType.getActualTypeArguments();
+        Object newInstance;
+        try {
+            newInstance = newInstanceBySuitableConstructor(methodParameterClazz, genericParameterTypes);
+        } catch (UnsupportedOperationException exception) {
+            System.out.println(exception.toString());
+            newInstance = RANDOM.nextObject(methodParameterClazz);
+        }
+        return newInstance;
+    }
+
+    @NotNull
+    private Object newInstanceBySuitableConstructor(
+            Class<?> methodParameterClazz, Type[] genericParameterTypes)
+            throws InstantiationException, IllegalAccessException, InvocationTargetException {
+        Constructor<?> suitableConstructor =
+                findSuitableConstructor(methodParameterClazz, genericParameterTypes);
+        Object[] args = stream(genericParameterTypes).map(this::getParameterInstance).toArray();
+        return suitableConstructor.newInstance(args);
+    }
+
+    @SneakyThrows
+    public static Constructor<?> findSuitableConstructor(Class<?> clazz, Type[] typeArguments) {
+        return stream(clazz.getConstructors())
+                .filter(it -> it.getParameterCount() == typeArguments.length)
+                .findFirst()
+                .orElseThrow(
+                        () ->
+                                new UnsupportedOperationException(
+                                        "Lack of the first matched constructors for type argument: "
+                                                + Arrays.toString(typeArguments)));
+    }
+
+    private static void createDirectoryForResource(String resource) {
+        String fileDirPath = RESOURCES_PATH_PREFIX + resource.substring(0, resource.lastIndexOf("/"));
+        if (!new File(fileDirPath).mkdirs()) {
+            System.out.println("Directory already exists or could not be created: " + fileDirPath);
+        }
+    }
+}
diff --git a/src/main/java/io/github/glytching/junit/extension/json/TestCase.java b/src/main/java/io/github/glytching/junit/extension/json/TestCase.java
new file mode 100644
index 0000000..152ea88
--- /dev/null
+++ b/src/main/java/io/github/glytching/junit/extension/json/TestCase.java
@@ -0,0 +1,78 @@
+package io.github.glytching.junit.extension.json;
+
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.TypeReference;
+import io.github.glytching.junit.extension.util.TypeUtils;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+/**
+ * @author xiaohui
+ */
+@RequiredArgsConstructor
+@Getter
+public class TestCase<IN, OUT> {
+
+    /**
+     * input args of function
+     */
+    private final IN input;
+
+    /**
+     * output result of function*
+     */
+    private final OUT output;
+
+    /**
+     *
+     * @param inType one level type
+     * @return {@link IN}
+     */
+    public IN getInput(Class<IN> inType) {
+        if(TypeUtils.isJsonType(input)){
+            return JSON.parseObject(JSON.toJSONString(input),inType) ;
+        }else {
+            return input ;
+        }
+    }
+
+    /**
+     *
+     * @param typeReference any type
+     * @return {@link IN}
+     */
+    public IN getInput(TypeReference<IN> typeReference) {
+        if(TypeUtils.isJsonType(input)){
+            return JSON.parseObject(JSON.toJSONString(input),typeReference) ;
+        }else {
+            return input ;
+        }
+    }
+
+    /**
+     *
+     * @param outType one level type
+     * @return {@link OUT}
+     */
+    public OUT getOutput(Class<OUT> outType) {
+        if(TypeUtils.isJsonType(output)){
+            return JSON.parseObject(JSON.toJSONString(output),outType) ;
+        }else {
+            return output ;
+        }
+    }
+
+    /**
+     *
+     * @param typeReference any type
+     * @return {@link OUT}
+     */
+    public OUT getOutput(TypeReference<OUT> typeReference) {
+        if(TypeUtils.isJsonType(output)){
+            return JSON.parseObject(JSON.toJSONString(output),typeReference) ;
+        }else {
+            return output;
+        }
+    }
+
+}
diff --git a/src/main/java/io/github/glytching/junit/extension/json/annotation/JsonFileSource.java b/src/main/java/io/github/glytching/junit/extension/json/annotation/JsonFileSource.java
new file mode 100644
index 0000000..764ab9e
--- /dev/null
+++ b/src/main/java/io/github/glytching/junit/extension/json/annotation/JsonFileSource.java
@@ -0,0 +1,24 @@
+package io.github.glytching.junit.extension.json.annotation;
+
+import java.lang.annotation.*;
+
+import io.github.glytching.junit.extension.json.JsonFileArgumentsProvider;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+
+/**
+ * @author xiaohui
+ */
+@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@ArgumentsSource(JsonFileArgumentsProvider.class)
+@ParameterizedTest
+public @interface JsonFileSource {
+
+    /**
+     * The JsonFile Resource Path in the test/resources
+     */
+    String[] resources();
+
+}
\ No newline at end of file
diff --git a/src/main/java/io/github/glytching/junit/extension/random/RandomBeansExtension.java b/src/main/java/io/github/glytching/junit/extension/random/RandomBeansExtension.java
index 2e18b1c..56c118d 100644
--- a/src/main/java/io/github/glytching/junit/extension/random/RandomBeansExtension.java
+++ b/src/main/java/io/github/glytching/junit/extension/random/RandomBeansExtension.java
@@ -22,6 +22,7 @@
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
+import java.nio.charset.StandardCharsets;
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;
diff --git a/src/main/java/io/github/glytching/junit/extension/util/RecursiveReferenceDetector.java b/src/main/java/io/github/glytching/junit/extension/util/RecursiveReferenceDetector.java
new file mode 100644
index 0000000..6b48af2
--- /dev/null
+++ b/src/main/java/io/github/glytching/junit/extension/util/RecursiveReferenceDetector.java
@@ -0,0 +1,101 @@
+package io.github.glytching.junit.extension.util;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.*;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+/**
+ * @author mac
+ */
+public class RecursiveReferenceDetector {
+
+    /**
+     * Checks for recursive references in an object using a breadth-first search approach.
+     *
+     * @param obj The object to check.
+     * @return true if a recursive reference is found, false otherwise.
+     */
+    public static boolean hasRecursiveReference(Object obj) {
+        IdentityHashMap<Object, Boolean> visited = new IdentityHashMap<>();
+        return Stream.of(obj).anyMatch(newObj -> checkRecursiveAndAdd(visited, newObj));
+    }
+
+    private static boolean checkRecursiveAndAdd(IdentityHashMap<Object, Boolean> visited, Object obj) {
+        return Optional.ofNullable(obj)
+                .map(Object::getClass)
+                .filter(it -> !TypeUtils.isBuiltInType(it))
+                .map(
+                        it ->
+                                canIterate(it)
+                                        ? Arrays.stream(toInstanceArray(obj))
+                                        : Stream.of(it.getDeclaredFields()).map(field -> getFieldValue(obj, field)))
+                .map(
+                        it ->
+                                it.anyMatch(
+                                        childObj -> {
+                                            if (isNotRecursion(visited, childObj)) {
+                                                return checkRecursiveAndAdd(visited, childObj);
+                                            }
+                                            return true;
+                                        }))
+                .orElse(false);
+    }
+
+    private static boolean canIterate(Class<?> it) {
+        return it.isArray() || Collection.class.isAssignableFrom(it);
+    }
+
+    private static Object getFieldValue(Object obj, Field cur) {
+        Predicate<Field> fieldPredicate = getFieldTypePredicate(TypeUtils::isBuiltInType)
+                .and(combineModifierPredicates(
+                        Modifier::isFinal,
+                        Modifier::isAbstract,
+                        Modifier::isNative,
+                        Modifier::isTransient,
+                        Modifier::isInterface
+                ));
+        return Optional.of(cur)
+                .map(field -> ReflectionUtils.getFieldWithFilter(obj, field.getName(), fieldPredicate))
+                .orElse(null);
+    }
+
+    private static Predicate<Field> getFieldTypePredicate(Predicate<Class<?>> classPredicate) {
+        return field -> !classPredicate.test(field.getType());
+    }
+
+    @SafeVarargs
+    private static Predicate<Field> combineModifierPredicates(Predicate<Integer>... predicates) {
+        Predicate<Field> combinedPredicate = field -> true;
+        for (Predicate<Integer> predicate : predicates) {
+            combinedPredicate = combinedPredicate.and(field -> !predicate.test(field.getModifiers()));
+        }
+        return combinedPredicate;
+    }
+
+    /**
+     * The `putIfAbsent` method returns the value previously associated with the key, or `null` if
+     * there was no previous association. If it's the first access, the condition is true,which means
+     * no recursive reference is found; if it's not the first access, the condition is false,
+     * indicating that a recursive reference has been detected.
+     */
+    private static boolean isNotRecursion(IdentityHashMap<Object, Boolean> visited, Object childObj) {
+        if(childObj == null){
+            return true;
+        }
+        return visited.putIfAbsent(childObj, Boolean.TRUE) == null;
+    }
+
+    private static Object[] toInstanceArray(Object array) {
+        array = array.getClass().isArray() ? array : ((Collection<?>) array).toArray();
+        int length = Array.getLength(array);
+        List<Object> list = new ArrayList<>(length);
+        for (int i = 0; i < length; i++) {
+            list.add(Array.get(array, i));
+        }
+        return list.toArray();
+    }
+}
+
diff --git a/src/main/java/io/github/glytching/junit/extension/util/ReflectionUtils.java b/src/main/java/io/github/glytching/junit/extension/util/ReflectionUtils.java
new file mode 100644
index 0000000..13341a9
--- /dev/null
+++ b/src/main/java/io/github/glytching/junit/extension/util/ReflectionUtils.java
@@ -0,0 +1,203 @@
+package io.github.glytching.junit.extension.util;
+
+import static io.github.glytching.junit.extension.util.UnsafeUtils.unsafe;
+
+import java.lang.reflect.*;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.*;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import lombok.*;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import sun.misc.Unsafe;
+
+/**
+ * This class is changed from WhileBox in PowerMock. The class can set instance field,including
+ * final field, not null or static field
+ *
+ * @author xiaohui
+ */
+public class ReflectionUtils {
+
+  /**
+   * If you want to set static field, you should call {@link ReflectionUtils#setField(Object, Field,
+   * Object)}
+   *
+   * @param modifiedObj modifiedObj
+   * @param fieldName including final field, not null or static field
+   * @param value value
+   */
+  @SneakyThrows(NoSuchFieldException.class)
+  public static void setField(Object modifiedObj, String fieldName, Object value) {
+    Predicate<Field> fieldPredicate = field -> hasFieldProperModifier(modifiedObj, field);
+    Field foundField =
+        findFieldInHierarchy(modifiedObj, fieldName, fieldPredicate)
+            .orElseThrow(
+                () ->
+                    new NoSuchFieldException(
+                        String.format(
+                            "No %s field named \"%s\" could be found in the \"%s\" class hierarchy",
+                            isClass(modifiedObj) ? "static" : "instance",
+                            fieldName,
+                            getClassOf(modifiedObj).getName())));
+    setField(modifiedObj, foundField, value);
+  }
+
+  @Nullable
+  public static <T> T getField(Object object, String fieldName) {
+    return getFieldWithFilter(object, fieldName, anyField -> true);
+  }
+
+  @Nullable
+  @SneakyThrows({IllegalAccessException.class})
+  public static <T> T getFieldWithFilter(
+      Object object, String fieldName, Predicate<Field> fieldPredicate) {
+    Field foundField = findFieldInHierarchy(object, fieldName, fieldPredicate).orElse(null);
+    if (foundField == null) {
+      return null;
+    }
+    return (T) foundField.get(object);
+  }
+
+  public static Optional<Field> findFieldInHierarchy(
+      Object modifiedObj, String fieldName, @NotNull Predicate<Field> fieldPredicate) {
+    if (modifiedObj == null) {
+      throw new IllegalArgumentException("The modifiedObj containing the field cannot be null!");
+    }
+    Class<?> startClass = getClassOf(modifiedObj);
+
+    Optional<Field> optionalField =
+        findFieldByUniqueName(fieldName, startClass).filter(fieldPredicate);
+    optionalField.ifPresent(it -> it.setAccessible(true));
+    return optionalField;
+  }
+
+  public static Optional<Field> findFieldByUniqueName(String fieldName, Class<?> startClass) {
+    FieldSearchCriteria criteria =
+        new FieldSearchCriteria(startClass, field -> field.getName().equals(fieldName), fieldName);
+    return findField(criteria);
+  }
+
+  private static Optional<Field> findField(FieldSearchCriteria criteria) {
+    Field foundField = null;
+    Class<?> currentClass = criteria.getStartClass();
+    while (currentClass != null) {
+      Field[] declaredFields = currentClass.getDeclaredFields();
+      for (val field : declaredFields) {
+        if (criteria.getMatcher().apply(field)) {
+          if (foundField != null) {
+            throw new IllegalStateException(
+                "Two or more fields matching " + criteria.getErrorMessage() + ".");
+          }
+          foundField = field;
+        }
+      }
+      if (foundField != null) {
+        break;
+      }
+      currentClass = currentClass.getSuperclass();
+    }
+    return Optional.ofNullable(foundField);
+  }
+
+  @Getter
+  @RequiredArgsConstructor
+  public static class FieldSearchCriteria {
+    private final Class<?> startClass;
+
+    private final Function<Field, Boolean> matcher;
+
+    private final String errorMessage;
+  }
+
+  private static boolean hasFieldProperModifier(Object object, Field field) {
+    if (isClass(object)) {
+      return Modifier.isStatic(field.getModifiers());
+    } else {
+      return !Modifier.isStatic(field.getModifiers());
+    }
+  }
+
+  private static Class<?> getClassOf(@NotNull Object object) {
+    Class<?> type;
+    if (isClass(object)) {
+      type = (Class<?>) object;
+    } else {
+      type = object.getClass();
+    }
+    return type;
+  }
+
+  private static boolean isClass(Object object) {
+    return object instanceof Class<?>;
+  }
+
+  public static void setField(Object object, Field foundField, Object value) {
+    boolean isStatic = isModifier(foundField, Modifier.STATIC);
+    Unsafe unsafe = unsafe();
+    if (isStatic) {
+      setStaticFieldUsingUnsafe(foundField, value);
+    } else {
+      setFieldUsingUnsafe(object, foundField, unsafe.objectFieldOffset(foundField), value);
+    }
+  }
+
+  private static void setStaticFieldUsingUnsafe(Field field, Object value) {
+    Object base = unsafe().staticFieldBase(field);
+    long offset = unsafe().staticFieldOffset(field);
+    setFieldUsingUnsafe(base, field, offset, value);
+  }
+
+  /**
+   * judge whether modifier the field belongs to
+   *
+   * @param field field
+   * @param modifier {@link Modifier#STATIC }.etc
+   * @return if modifier the field belongs to
+   */
+  private static boolean isModifier(Field field, int modifier) {
+    return (field.getModifiers() & modifier) == modifier;
+  }
+
+  @SneakyThrows
+  @SuppressWarnings("all")
+  private static void setFieldUsingUnsafe(Object base, Field field, long offset, Object newValue) {
+    field.setAccessible(true);
+    boolean isFinal = isModifier(field, Modifier.FINAL);
+    if (isFinal) {
+      AccessController.doPrivileged(
+          (PrivilegedAction<Object>)
+              () -> {
+                setFieldUsingUnsafe(base, field.getType(), offset, newValue);
+                return null;
+              });
+    } else {
+      field.set(base, newValue);
+    }
+  }
+
+  private static void setFieldUsingUnsafe(
+      Object base, Class<?> type, long offset, Object newValue) {
+    if (type == Integer.TYPE) {
+      unsafe().putInt(base, offset, (Integer) newValue);
+    } else if (type == Short.TYPE) {
+      unsafe().putShort(base, offset, (Short) newValue);
+    } else if (type == Long.TYPE) {
+      unsafe().putLong(base, offset, (Long) newValue);
+    } else if (type == Byte.TYPE) {
+      unsafe().putByte(base, offset, (Byte) newValue);
+    } else if (type == Boolean.TYPE) {
+      unsafe().putBoolean(base, offset, (Boolean) newValue);
+    } else if (type == Float.TYPE) {
+      unsafe().putFloat(base, offset, (Float) newValue);
+    } else if (type == Double.TYPE) {
+      unsafe().putDouble(base, offset, (Double) newValue);
+    } else if (type == Character.TYPE) {
+      unsafe().putChar(base, offset, (Character) newValue);
+    } else {
+      unsafe().putObject(base, offset, newValue);
+    }
+  }
+}
diff --git a/src/main/java/io/github/glytching/junit/extension/util/TypeUtils.java b/src/main/java/io/github/glytching/junit/extension/util/TypeUtils.java
new file mode 100644
index 0000000..9a0fb78
--- /dev/null
+++ b/src/main/java/io/github/glytching/junit/extension/util/TypeUtils.java
@@ -0,0 +1,35 @@
+package io.github.glytching.junit.extension.util;
+
+
+import com.alibaba.fastjson2.JSONArray;
+import com.alibaba.fastjson2.JSONObject;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @author mac
+ */
+public class TypeUtils {
+
+    private static final Set<Class<?>> BUILT_IN_TYPES = new HashSet<>(
+            Arrays.asList(
+                    Boolean.class, Byte.class, Character.class, Short.class,
+                    Integer.class, Long.class, Float.class, Double.class,
+                    boolean.class, byte.class, char.class, short.class,
+                    int.class, long.class, float.class, double.class
+            )
+    );
+
+    public static boolean isBuiltInType(Class<?> clazz) {
+        if (clazz == null) {
+            return false;
+        }
+        return BUILT_IN_TYPES.contains(clazz);
+    }
+
+    public static  <T> boolean isJsonType(T o){
+        return o instanceof JSONObject || o instanceof JSONArray;
+    }
+}
diff --git a/src/main/java/io/github/glytching/junit/extension/util/UnsafeUtils.java b/src/main/java/io/github/glytching/junit/extension/util/UnsafeUtils.java
new file mode 100644
index 0000000..e6c4e8c
--- /dev/null
+++ b/src/main/java/io/github/glytching/junit/extension/util/UnsafeUtils.java
@@ -0,0 +1,29 @@
+package io.github.glytching.junit.extension.util;
+
+import sun.misc.Unsafe;
+
+import java.lang.reflect.Field;
+
+/**
+ * @author mac
+ */
+public class UnsafeUtils {
+
+    public static Unsafe unsafe(){
+        return Singleton.UNSAFE;
+    }
+
+    private static class Singleton{
+        private static final Unsafe UNSAFE;
+        static  {
+            Field unsafeFiled;
+            try {
+                unsafeFiled = Unsafe.class.getDeclaredField("theUnsafe");
+                unsafeFiled.setAccessible(true);
+                UNSAFE =  (Unsafe)unsafeFiled.get(Unsafe.class);
+            } catch (NoSuchFieldException | IllegalAccessException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+}
diff --git a/src/test/java/io/github/glytching/junit/extension/json/JsonFileArgumentsProviderTest.java b/src/test/java/io/github/glytching/junit/extension/json/JsonFileArgumentsProviderTest.java
new file mode 100644
index 0000000..33e2b9c
--- /dev/null
+++ b/src/test/java/io/github/glytching/junit/extension/json/JsonFileArgumentsProviderTest.java
@@ -0,0 +1,75 @@
+package io.github.glytching.junit.extension.json;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import com.alibaba.fastjson2.TypeReference;
+import io.github.glytching.junit.extension.json.annotation.JsonFileSource;
+import java.util.List;
+import java.util.Map;
+import lombok.Data;
+import org.jeasy.random.EasyRandom;
+import org.junit.jupiter.api.Test;
+
+public class JsonFileArgumentsProviderTest {
+
+    @JsonFileSource(resources = {"string_test_case.json"})
+    void should_generate_test_case_json_lack_of_it(TestCase<String, String> testCase) {
+        assertEquals("eOMtThyhVNLWUZNRcBaQKxI", testCase.getInput());
+        assertEquals("yedUsFwdkelQbxeTeQOvaScfqIOOmaa", testCase.getOutput());
+    }
+
+    @JsonFileSource(resources = {"string_test_case.json"})
+    void should_generate_test_case_json_given_ownClass(TestCase<String, String> testCase) {
+        assertEquals("eOMtThyhVNLWUZNRcBaQKxI", testCase.getInput());
+        assertEquals("yedUsFwdkelQbxeTeQOvaScfqIOOmaa", testCase.getOutput());
+    }
+
+    @JsonFileSource(resources = {"list_testCase.json", "list_testCase.json"})
+    void should_parse_multi_List_with_Integer_type_test_case(
+            TestCase<List<Integer>, List<Integer>> testCase) {
+        assertEquals(0, testCase.getInput().size());
+        assertEquals(0,  testCase.getOutput(new TypeReference<List<Integer>>() {}).size());
+    }
+
+    @JsonFileSource(resources = {"map_testCase.json"})
+    void should_parse_Map_type_test_case(
+            TestCase<Map<String, Integer>, Map<String, Integer>> testCase) {
+        assertNull(testCase.getInput().get("key1"));
+        assertNull(testCase.getOutput().get("key2"));
+    }
+
+    @JsonFileSource(resources = {"people_input.json"})
+    void should_parse_People_input(People people) {
+        assertEquals("lele", people.name);
+    }
+
+    @JsonFileSource(resources = {"RecursionClass_input.json"})
+    void should_parse_recursionClass_input(RecursionClass recursionClass) {
+        assertNotNull(recursionClass);
+        assertNull(recursionClass.getRecursionClasses());
+        assertNotNull(recursionClass.getPeople());
+    }
+
+    @Test
+    void set_null_if_recursive() {
+        RecursionClass recursionClass = new EasyRandom().nextObject(RecursionClass.class);
+        JsonFileArgumentsProvider.setNullIfRecursive(recursionClass);
+        assertNull(recursionClass.getRecursionClass());
+        assertNull(recursionClass.getRecursionClasses());
+        assertNotNull(recursionClass.getPeople());
+    }
+
+    @Data
+    public static class RecursionClass {
+        private People people;
+        private RecursionClass recursionClass;
+        private List<RecursionClass> recursionClasses;
+    }
+
+    public static class People {
+        public final String id = "02";
+        public final String name = "lele";
+    }
+
+
+}
\ No newline at end of file
diff --git a/src/test/java/io/github/glytching/junit/extension/util/RecursiveReferenceDetectorTest.java b/src/test/java/io/github/glytching/junit/extension/util/RecursiveReferenceDetectorTest.java
new file mode 100644
index 0000000..e043d57
--- /dev/null
+++ b/src/test/java/io/github/glytching/junit/extension/util/RecursiveReferenceDetectorTest.java
@@ -0,0 +1,43 @@
+package io.github.glytching.junit.extension.util;
+
+import static io.github.glytching.junit.extension.json.JsonFileArgumentsProviderTest.*;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.jeasy.random.EasyRandom;
+import org.junit.jupiter.api.Test;
+
+public class RecursiveReferenceDetectorTest {
+
+    private final RecursionClass recursionClass = new EasyRandom().nextObject(RecursionClass.class);
+
+    @Test
+    public void should_judge_recursion() {
+        boolean res = RecursiveReferenceDetector.hasRecursiveReference(recursionClass);
+        assertTrue(res);
+    }
+
+    @Test
+    public void should_judge_recursion_list() {
+        List<RecursionClass> recursionClasses = new ArrayList<>();
+        recursionClasses.add(recursionClass);
+        boolean res = RecursiveReferenceDetector.hasRecursiveReference(recursionClasses);
+        assertTrue(res);
+    }
+
+    @Test
+    public void should_not_judge_recursion() {
+        Object object = new EasyRandom().nextObject(Object.class);
+        boolean res = RecursiveReferenceDetector.hasRecursiveReference(object);
+        assertFalse(res);
+    }
+
+    @Test
+    public void should_not_judge_recursion_2() {
+        Object object = new EasyRandom().nextObject(People.class);
+        boolean res = RecursiveReferenceDetector.hasRecursiveReference(object);
+        assertFalse(res);
+    }
+}
diff --git a/src/test/java/io/github/glytching/junit/extension/util/ReflectionUtilsTest.java b/src/test/java/io/github/glytching/junit/extension/util/ReflectionUtilsTest.java
new file mode 100644
index 0000000..4c364c2
--- /dev/null
+++ b/src/test/java/io/github/glytching/junit/extension/util/ReflectionUtilsTest.java
@@ -0,0 +1,78 @@
+package io.github.glytching.junit.extension.util;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+class ReflectionUtilsTest {
+
+  private static final String wuwei = "wuwei";
+  private static final String died = "died";
+  private WhoIAm whoIAm;
+  private WhereIGo whereIGo;
+
+  @BeforeEach
+  void setUp() {
+    whoIAm = new WhoIAm();
+    whereIGo = new WhereIGo();
+  }
+
+  @Test
+  void should_throw_exception_if_setting_static_field() {
+    String value = "island";
+    assertThrows(
+        NoSuchFieldException.class, () -> ReflectionUtils.setField(whoIAm, "country", value));
+  }
+
+  @ParameterizedTest
+  @CsvSource(value = {"name,me", "heart,will always go on"})
+  void should_set_final_field_and_get_it(String fieldName, String value) {
+    ReflectionUtils.setField(whoIAm, fieldName, value);
+    String heart = ReflectionUtils.getField(whoIAm, fieldName);
+    assertEquals(value, heart);
+  }
+
+  @Test
+  void should_set_parent_final_field_and_get_it() {
+    String value = "will always go on";
+    String fieldName = "heart";
+    ReflectionUtils.setField(whereIGo, fieldName, value);
+    String heart = ReflectionUtils.getField(whereIGo, fieldName);
+    assertEquals(value, heart);
+  }
+
+  @Test
+  void should_get_static_field_value() {
+    String country = ReflectionUtils.getField(whereIGo, "country");
+    assertEquals(wuwei, country);
+  }
+
+  @Test
+  void should_not_get_non_exist_field_value_with_null() {
+    assertDoesNotThrow(() -> ReflectionUtils.getField(whereIGo, "died"));
+  }
+
+  @Test
+  void should_set_final_field_value() {
+    assertDoesNotThrow(() -> ReflectionUtils.setField(whereIGo, "heart", null));
+  }
+
+  public static class WhoIAm {
+    private final String name = "halley";
+
+    private static final String country = wuwei;
+
+    private final String heart = died;
+
+    private final TestClassEnum type = TestClassEnum.WHO_AM_I;
+  }
+
+  public static class WhereIGo extends WhoIAm {}
+
+  public enum TestClassEnum {
+    WHO_AM_I;
+  }
+}
diff --git a/src/test/java/io/github/glytching/junit/extension/util/TypeUtilsTest.java b/src/test/java/io/github/glytching/junit/extension/util/TypeUtilsTest.java
new file mode 100644
index 0000000..5c77dd9
--- /dev/null
+++ b/src/test/java/io/github/glytching/junit/extension/util/TypeUtilsTest.java
@@ -0,0 +1,5 @@
+package io.github.glytching.junit.extension.util;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class TypeUtilsTest {}
diff --git a/src/test/resources/io/github/glytching/junit/extension/json/RecursionClass_input.json b/src/test/resources/io/github/glytching/junit/extension/json/RecursionClass_input.json
new file mode 100644
index 0000000..0703ad4
--- /dev/null
+++ b/src/test/resources/io/github/glytching/junit/extension/json/RecursionClass_input.json
@@ -0,0 +1 @@
+{"people":{"id":"02","name":"lele"}}
\ No newline at end of file
diff --git a/src/test/resources/io/github/glytching/junit/extension/json/absent_test_case.json b/src/test/resources/io/github/glytching/junit/extension/json/absent_test_case.json
new file mode 100644
index 0000000..0f513d4
--- /dev/null
+++ b/src/test/resources/io/github/glytching/junit/extension/json/absent_test_case.json
@@ -0,0 +1 @@
+{"input":"eOMtThyhVNLWUZNRcBaQKxI","output":"yedUsFwdkelQbxeTeQOvaScfqIOOmaa"}
\ No newline at end of file
diff --git a/src/test/resources/io/github/glytching/junit/extension/json/list_testCase.json b/src/test/resources/io/github/glytching/junit/extension/json/list_testCase.json
new file mode 100644
index 0000000..269e101
--- /dev/null
+++ b/src/test/resources/io/github/glytching/junit/extension/json/list_testCase.json
@@ -0,0 +1 @@
+{"input":[],"output":[]}
\ No newline at end of file
diff --git a/src/test/resources/io/github/glytching/junit/extension/json/map_testCase.json b/src/test/resources/io/github/glytching/junit/extension/json/map_testCase.json
new file mode 100644
index 0000000..447a1ab
--- /dev/null
+++ b/src/test/resources/io/github/glytching/junit/extension/json/map_testCase.json
@@ -0,0 +1 @@
+{"input":{},"output":{}}
\ No newline at end of file
diff --git a/src/test/resources/io/github/glytching/junit/extension/json/people_input.json b/src/test/resources/io/github/glytching/junit/extension/json/people_input.json
new file mode 100644
index 0000000..ddeaaec
--- /dev/null
+++ b/src/test/resources/io/github/glytching/junit/extension/json/people_input.json
@@ -0,0 +1 @@
+{"id":"02","name":"lele"}
\ No newline at end of file
diff --git a/src/test/resources/io/github/glytching/junit/extension/json/string_test_case.json b/src/test/resources/io/github/glytching/junit/extension/json/string_test_case.json
new file mode 100644
index 0000000..2529ce2
--- /dev/null
+++ b/src/test/resources/io/github/glytching/junit/extension/json/string_test_case.json
@@ -0,0 +1,4 @@
+{
+  "input": "eOMtThyhVNLWUZNRcBaQKxI",
+  "output": "yedUsFwdkelQbxeTeQOvaScfqIOOmaa"
+}
\ No newline at end of file