Java 获取类路径中的所有类

如何在运行时获取中所有可用类的列表？
在EclipseIDE中，可以通过按Ctrl+Shift+T来完成此操作。

---

Java中有什么方法可以完成它吗？

您可以通过将空的

字符串

传递到中来获取所有类路径根

Enumeration root=classLoader.getResources（“”）；

您可以基于以下内容构造一个：

File root=新文件（url.getPath（））；

您可以使用获取给定目录中所有文件的列表：

for（文件：root.listFiles（））{
// ...
}

您可以使用标准方法检查它是否是目录和/或获取文件名

if（file.isDirectory（））{
//递归地遍历其listFiles（）。
}否则{
字符串名称=file.getName（）；
//检查它是.class文件还是.jar文件，并进行相应的处理。
}

---

取决于唯一的功能需求，我想这更确切地说是你想要的

我经常找这个。这有点困难，因为即使您设法找到类路径上的所有内容，也可能找不到给定类加载器可用的所有内容（例如，我曾经参与过一个直接从DB加载类定义的项目）

在这一点上，最好的办法可能是看看春天。他们扫描类路径上的类，看看是否有需要启动的注释

这里公认的答案是一个很好的起点：

---

以下是我写的内容。我敢肯定，如果你对类路径做了一些奇怪的事情，它不会得到所有的东西，但它似乎对我来说工作得很好。注意，它实际上并没有加载类，只是返回它们的名称。这是因为它不会将所有类加载到内存中，而且因为我公司代码库中的某些类在错误的时间加载时会导致初始化错误

public interface Visitor<T> {
    /**
     * @return {@code true} if the algorithm should visit more results,
     * {@code false} if it should terminate now.
     */
    public boolean visit(T t);
}

public class ClassFinder {
    public static void findClasses(Visitor<String> visitor) {
        String classpath = System.getProperty("java.class.path");
        String[] paths = classpath.split(System.getProperty("path.separator"));

        String javaHome = System.getProperty("java.home");
        File file = new File(javaHome + File.separator + "lib");
        if (file.exists()) {
            findClasses(file, file, true, visitor);
        }

        for (String path : paths) {
            file = new File(path);
            if (file.exists()) {
                findClasses(file, file, false, visitor);
            }
        }
    }

    private static boolean findClasses(File root, File file, boolean includeJars, Visitor<String> visitor) {
        if (file.isDirectory()) {
            for (File child : file.listFiles()) {
                if (!findClasses(root, child, includeJars, visitor)) {
                    return false;
                }
            }
        } else {
            if (file.getName().toLowerCase().endsWith(".jar") && includeJars) {
                JarFile jar = null;
                try {
                    jar = new JarFile(file);
                } catch (Exception ex) {

                }
                if (jar != null) {
                    Enumeration<JarEntry> entries = jar.entries();
                    while (entries.hasMoreElements()) {
                        JarEntry entry = entries.nextElement();
                        String name = entry.getName();
                        int extIndex = name.lastIndexOf(".class");
                        if (extIndex > 0) {
                            if (!visitor.visit(name.substring(0, extIndex).replace("/", "."))) {
                                return false;
                            }
                        }
                    }
                }
            }
            else if (file.getName().toLowerCase().endsWith(".class")) {
                if (!visitor.visit(createClassName(root, file))) {
                    return false;
                }
            }
        }

        return true;
    }

    private static String createClassName(File root, File file) {
        StringBuffer sb = new StringBuffer();
        String fileName = file.getName();
        sb.append(fileName.substring(0, fileName.lastIndexOf(".class")));
        file = file.getParentFile();
        while (file != null && !file.equals(root)) {
            sb.insert(0, '.').insert(0, file.getName());
            file = file.getParentFile();
        }
        return sb.toString();
    }
}

公共界面访问者{
/**
*@return{@code true}如果算法应该访问更多结果，
*{@code false}如果它现在应该终止。
*/
公众参观（T）；
}
公共类查找器{
公共静态void findClass（访问者）{
字符串classpath=System.getProperty（“java.class.path”）；
String[]path=classpath.split（System.getProperty（“path.separator”）；
字符串javaHome=System.getProperty（“java.home”）；
File File=新文件（javaHome+File.separator+“lib”）；
if（file.exists（））{
FindClass（文件、文件、true、访问者）；
}
用于（字符串路径：路径）{
文件=新文件（路径）；
if（file.exists（））{
FindClass（文件、文件、false、访问者）；
}
}
}
私有静态布尔FindClass（文件根、文件文件、布尔includeJars、访问者）{
if（file.isDirectory（））{
对于（文件子项：File.listFiles（））{
if（！findClasses（根、子、includeJars、访问者））{
返回false；
}
}
}否则{
if（file.getName（）.toLowerCase（）.endsWith（“.jar”）&&includeJars）{
JarFile jar=null；
试一试{
jar=新的JarFile（文件）；
}捕获（例外情况除外）{
}
if（jar！=null）{
枚举条目=jar.entries（）；
while（entries.hasMoreElements（））{
JarEntry=entries.nextElement（）；
String name=entry.getName（）；
int dex=name.lastIndexOf（“.class”）；
如果（指数>0）{
if（！visitor.visit（name.substring（0，demedex.replace（“/”，“）））{
返回false；
}
}
}
}
}
else if（file.getName（）.toLowerCase（）.endsWith（“.class”））{
如果（！visitor.visit（createClassName（根，文件）））{
返回false；
}
}
}
返回true；
}
私有静态字符串createClassName（文件根，文件名）{
StringBuffer sb=新的StringBuffer（）；
字符串文件名=file.getName（）；
sb.append（fileName.substring（0，fileName.lastIndexOf（“.class”））；
file=file.getParentFile（）；
while（file！=null&&！file.equals（root））{
sb.insert（0，'.'）。insert（0，file.getName（））；
file=file.getParentFile（）；
}
使某人返回字符串（）；
}
}

要使用它：

ClassFinder.findClasses(new Visitor<String>() {
    @Override
    public boolean visit(String clazz) {
        System.out.println(clazz)
        return true; // return false if you don't want to see any more classes
    }
});

ClassFinder.findClasses（新访问者（）{
@凌驾
公共布尔访问（字符串clazz）{
系统输出打印LN（clazz）
return true；//如果不想看到更多的类，则返回false
}
});

您可以使用Guava库

com.google.common.reflect

包中的实用程序类。例如，要获取特定包中的所有类：

    ClassLoader cl = getClass().getClassLoader();
    Set<ClassPath.ClassInfo> classesInPackage = ClassPath.from(cl).getTopLevelClassesRecursive("com.mycompany.mypackage");

ClassLoader cl=getClass（）.getClassLoader（）；
设置classesInPackage=ClassPath.from（cl.getTopLevelClassesRecursive（“com.mycompany.mypackage”）；

---

这是简洁的，但是与其他答案描述的相同的警告仍然适用，即它通常只查找由“标准”类加载器加载的类，例如

URLClassLoader

您应该使用String[]path=classpath.split（System.getProperty（“path.separator”）；否则它对LinuxI不起作用，我想试试这个。你能展示使用ClassFinder的代码吗？这太可怕了。访问者界面的实现在哪里？@belgarion调用

findClasses

的代码应该创建一个实现（通常是一个匿名类）。例如，它与JavaScript中传递给

forEach

的回调非常相似。我可以