我正在尝试制作一个 Java 工具来扫描 Java 应用程序的结构并提供一些有意义的信息。 为此，我需要能够从项目位置（JAR/WAR 或只是一个文件夹）扫描所有 .class 文件，并使用反射来读取它们的方法。 事实证明这几乎是不可能的。
我可以找到很多基于 URLClassloader 的解决方案，这些解决方案允许我从目录/存档加载特定的类，但没有一个允许我在没有任何有关类名或包结构的信息的情况下加载类。
编辑： 我认为我的措辞很糟糕。 我的问题不是我无法获取所有类文件，我可以通过递归等来做到这一点并正确找到它们。 我的问题是为每个类文件获取一个 Class 对象。
以下代码从 JAR 文件加载所有类。它不需要了解有关类的任何信息。类的名称是从 JarEntry 中提取的。
JarFile jarFile = new JarFile(pathToJar);
Enumeration<JarEntry> e = jarFile.entries();
URL[] urls = { new URL("jar:file:" + pathToJar+"!/") };
URLClassLoader cl = URLClassLoader.newInstance(urls);
while (e.hasMoreElements()) {
JarEntry je = e.nextElement();
if(je.isDirectory() || !je.getName().endsWith(".class")){
continue;
}
// -6 because of .class
String className = je.getName().substring(0,je.getName().length()-6);
className = className.replace('/', '.');
Class c = cl.loadClass(className);
}
编辑：
正如上面评论中所建议的，javassist 也是一种可能性。 在上述代码的 while 循环之前的某个位置初始化 ClassPool，您可以创建一个 CtClass 对象，而不是使用类加载器加载类：
ClassPool cp = ClassPool.getDefault();
...
CtClass ctClass = cp.get(className);
从 ctClass 中，您可以获得所有方法、字段、嵌套类...... 看一下javassist api： https://jboss-javassist.github.io/javassist/html/index.html
列出 jar 文件中的所有类。
public static List getClasseNames(String jarName) {
ArrayList classes = new ArrayList();
if (debug)
System.out.println("Jar " + jarName );
try {
JarInputStream jarFile = new JarInputStream(new FileInputStream(
jarName));
JarEntry jarEntry;
while (true) {
jarEntry = jarFile.getNextJarEntry();
if (jarEntry == null) {
break;
}
if (jarEntry.getName().endsWith(".class")) {
if (debug)
System.out.println("Found "
+ jarEntry.getName().replaceAll("/", "\\."));
classes.add(jarEntry.getName().replaceAll("/", "\\."));
}
}
} catch (Exception e) {
e.printStackTrace();
}
return classes;
}
为此，我需要能够从项目位置（JAR/WAR 或只是一个文件夹）扫描所有 .class 文件
扫描文件夹中的所有文件非常简单。 一种选择是在表示文件夹的
File.listFiles()File扫描 JAR 文件的文件可以使用
JarFile这些都不是特别复杂。 只需阅读 javadoc 并开始编码。
来到这里有类似的要求：
在某些包中拥有越来越多的服务类，它们实现了通用的 接口，并希望在运行时检测它们。
部分问题是在特定包内查找类，其中应用程序可能从 jar 文件或包/文件夹结构中解压的类加载。
所以我把 amicagh 和 anonymous 的解决方案放在一起。
// Retrieve classes of a package and it's nested package from file based class repository
package esc;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarInputStream;
public class GetClasses
{
private static boolean debug = false;
/**
* test function with assumed package esc.util
*/
public static void main(String... args)
{
try
{
final Class<?>[] list = getClasses("esc.util");
for (final Class<?> c : list)
{
System.out.println(c.getName());
}
}
catch (final IOException e)
{
e.printStackTrace();
}
}
/**
* Scans all classes accessible from the context class loader which belong to the given package and subpackages.
*
* @precondition Thread Class loader attracts class and jar files, exclusively
* @precondition Classes with static code sections are executed, when loaded and thus must not throw exceptions
*
* @param packageName
* [in] The base package path, dot-separated
*
* @return The classes of package /packageName/ and nested packages
*
* @throws IOException,
* ClassNotFoundException not applicable
*
* @author Sam Ginrich, http://www.java2s.com/example/java/reflection/recursive-method-used-to-find-all-classes-in-a-given-directory-and-sub.html
*
*/
public static Class<?>[] getClasses(String packageName) throws IOException
{
final ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
assert classLoader != null;
if (debug)
{
System.out.println("Class Loader class is " + classLoader.getClass().getName());
}
final String packagePath = packageName.replace('.', '/');
final Enumeration<URL> resources = classLoader.getResources(packagePath);
final List<Class<?>> classes = new ArrayList<Class<?>>();
while (resources.hasMoreElements())
{
final URL resource = resources.nextElement();
final String proto = resource.getProtocol();
if ("file".equals(proto))
{
classes.addAll(findFileClasses(new File(resource.getFile()), packageName));
}
else if ("jar".equals(proto))
{
classes.addAll(findJarClasses(resource));
}
else
{
System.err.println("Protocol " + proto + " not supported");
continue;
}
}
return classes.toArray(new Class[classes.size()]);
}
/**
* Linear search for classes of a package from a jar file
*
* @param packageResource
* [in] Jar URL of the base package, i.e. file URL bested in jar URL
*
* @return The classes of package /packageResource/ and nested packages
*
* @throws -
*
* @author amicngh, Sam [email protected]
*/
private static List<Class<?>> findJarClasses(URL packageResource)
{
final List<Class<?>> classes = new ArrayList<Class<?>>();
try
{
System.out.println("Jar URL Path is " + packageResource.getPath());
final URL fileUrl = new URL(packageResource.getPath());
final String proto = fileUrl.getProtocol();
if ("file".equals(proto))
{
final String filePath = fileUrl.getPath().substring(1); // skip leading /
final int jarTagPos = filePath.indexOf(".jar!/");
if (jarTagPos < 0)
{
System.err.println("Non-conformant jar file reference " + filePath + " !");
}
else
{
final String packagePath = filePath.substring(jarTagPos + 6);
final String jarFilename = filePath.substring(0, jarTagPos + 4);
if (debug)
{
System.out.println("Package " + packagePath);
System.out.println("Jar file " + jarFilename);
}
final String packagePrefix = packagePath + '/';
try
{
final JarInputStream jarFile = new JarInputStream(
new FileInputStream(jarFilename));
JarEntry jarEntry;
while (true)
{
jarEntry = jarFile.getNextJarEntry();
if (jarEntry == null)
{
break;
}
final String classPath = jarEntry.getName();
if (classPath.startsWith(packagePrefix) && classPath.endsWith(".class"))
{
final String className = classPath
.substring(0, classPath.length() - 6).replace('/', '.');
if (debug)
{
System.out.println("Found entry " + jarEntry.getName());
}
try
{
classes.add(Class.forName(className));
}
catch (final ClassNotFoundException x)
{
System.err.println("Cannot load class " + className);
}
}
}
jarFile.close();
}
catch (final Exception e)
{
e.printStackTrace();
}
}
}
else
{
System.err.println("Nested protocol " + proto + " not supprted!");
}
}
catch (final MalformedURLException e)
{
e.printStackTrace();
}
return classes;
}
/**
* Recursive method used to find all classes in a given directory and subdirs.
*
* @param directory
* The base directory
* @param packageName
* The package name for classes found inside the base directory
* @return The classes
* @author http://www.java2s.com/example/java/reflection/recursive-method-used-to-find-all-classes-in-a-given-directory-and-sub.html
* @throws -
*
*/
private static List<Class<?>> findFileClasses(File directory, String packageName)
{
final List<Class<?>> classes = new ArrayList<Class<?>>();
if (!directory.exists())
{
System.err.println("Directory " + directory.getAbsolutePath() + " does not exist.");
return classes;
}
final File[] files = directory.listFiles();
if (debug)
{
System.out.println("Directory "
+ directory.getAbsolutePath()
+ " has "
+ files.length
+ " elements.");
}
for (final File file : files)
{
if (file.isDirectory())
{
assert !file.getName().contains(".");
classes.addAll(findFileClasses(file, packageName + "." + file.getName()));
}
else if (file.getName().endsWith(".class"))
{
final String className = packageName
+ '.'
+ file.getName().substring(0, file.getName().length() - 6);
try
{
classes.add(Class.forName(className));
}
catch (final ClassNotFoundException cnf)
{
System.err.println("Cannot load class " + className);
}
}
}
return classes;
}
}
字符串位置=“C:\plugins-1.0.jar”;
ClassLoader classLoader = URLClassLoader.newInstance(new URL[] { new URL("文件:" + 位置)} , ReloadClassAndInvokeMethodFromJar.class.getClassLoader());
Class cl = Class.forName("com.api.Plugins", true, classLoader);
System.out.println(cl);
对象 p = cl.getDeclaredConstructor().newInstance();
方法声明方法 = cl.getDeclaredMethod("printName", String.class); System.out.println(declaredMethod.getName());
对象调用=declaredMethod.invoke(p, "John");
System.out.println(调用);