动态获取解析jar包，并调用方法

  <dependency>
            <groupId>io.github.classgraph</groupId>
            <artifactId>classgraph</artifactId>
            <version>4.8.110</version>
        </dependency>

        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.8.0</version>
        </dependency>```


public class ClassInstantiator {
    public static Object instantiate(Class<?> clazz) throws Exception {
        Constructor<?> constructor = clazz.getConstructor();
        return constructor.newInstance();
    }
}


public class ClassScanner {
    public static Set<ClassInfo> scanClasses(String jarPath, String packageName, String interfaceName) {
        try (ScanResult scanResult = new ClassGraph()
                .addClassLoader(createClassLoader(getAllJars(jarPath)))
                .acceptPackages(packageName)
                .enableClassInfo()
                .scan()) {
            Set<ClassInfo> classInfoSet = new HashSet<>();
            scanResult.getClassesImplementing(interfaceName)
                    .loadClasses()
                    .forEach(clazz -> classInfoSet.add(scanResult.getClassInfo(clazz.getName())));
            return classInfoSet;        }
    }

    //获取所有jar包
    public static Collection<File> getAllJars(String directory) {
        IOFileFilter fileFilter = new SuffixFileFilter(".jar");
        File libDir = new File(directory);
        if (!libDir.exists()) {
            throw new IllegalArgumentException(directory + "不存在！");
        }
        if (!libDir.isDirectory()) {
            throw new IllegalArgumentException(directory + "不是一个文件目录！");
        }
        Collection<File> files = FileUtils.listFiles(libDir, fileFilter, TrueFileFilter.INSTANCE);
        return files;
    }

    public static URLClassLoader createClassLoader(Collection<File> jars) {
        URL[] urlArray = jars.stream().map(jar -> {
            try {
                //获取jar包中class路径
                return jar.toURI().toURL();
            } catch (MalformedURLException e) {
                throw new RuntimeException(e);
            }
        }).toArray(URL[]::new);
        return new URLClassLoader(urlArray, null);

    }

}

public class JarParser {
    private static final String JAR_PATH = "";
    private static final String PACKAGE_NAME = "com.test.junit";
    private static final String INTERFACE_NAME = "com.test.junit.TestInterface";

    public static void main(String[] args) throws Exception {
        HashMap hashMap = new HashMap();
        Set<ClassInfo> classesImplementingTestInterface = ClassScanner.scanClasses(JAR_PATH, PACKAGE_NAME, INTERFACE_NAME);
        for (ClassInfo classInfo : classesImplementingTestInterface) {
            Class<?> clazz = Class.forName(classInfo.getName(),true,ClassScanner.createClassLoader(ClassScanner.getAllJars(JAR_PATH)));
            Object instance = ClassInstantiator.instantiate(clazz);
            Method[] methods = clazz.getDeclaredMethods();
            for (Method method : methods) {
                    MethodInvoker.invoke(method, instance,hashMap);

            }
        }
    }
}

public class MethodInvoker {
    public static void invoke(Method method, Object instance,Map map) throws Exception {
        Parameter[] parameters = method.getParameters();
        Object[] args = new Object[parameters.length];
        for (int i = 0; i < parameters.length; i++) {
            Parameter parameter = parameters[i];
            if (parameter.getType() == String.class) {
                args[i] = "hello";
            } else if (parameter.getType() == int.class) {
                args[i] = 123;
            } else if (parameter.getType() == boolean.class) {
                args[i] = true;
            }else if (parameter.getType() == Map.class){
                args[i] = map;
            } else {
                args[i] = null;
            }
        }
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        executorService.submit(() -> {
            try {
                System.out.println(Thread.currentThread().getName());
                method.invoke(instance, args);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        });
        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.HOURS);
    }
}