Java 在几十个JAR文件中找到一个类？

如何在大量jar文件中找到特定的类名

---

（查找实际的类名，而不是引用它的类。）

Eclipse可以做到这一点，只需创建一个（临时）项目并将库放在项目类路径上。然后你可以很容易地找到这些类

---

我想到的另一个工具是Java反编译器。它可以一次打开很多jar，也有助于查找类

当我遇到这个问题时，我不知道有什么实用程序可以做到这一点，所以我写了以下内容：

public class Main {

    /**
     * 
     */
    private static String CLASS_FILE_TO_FIND =
            "class.to.find.Here";
    private static List<String> foundIn = new LinkedList<String>();

    /**
     * @param args the first argument is the path of the file to search in. The second may be the
     *        class file to find.
     */
    public static void main(String[] args) {
        if (!CLASS_FILE_TO_FIND.endsWith(".class")) {
            CLASS_FILE_TO_FIND = CLASS_FILE_TO_FIND.replace('.', '/') + ".class";
        }
        File start = new File(args[0]);
        if (args.length > 1) {
            CLASS_FILE_TO_FIND = args[1];
        }
        search(start);
        System.out.println("------RESULTS------");
        for (String s : foundIn) {
            System.out.println(s);
        }
    }

    private static void search(File start) {
        try {
            final FileFilter filter = new FileFilter() {

                public boolean accept(File pathname) {
                    return pathname.getName().endsWith(".jar") || pathname.isDirectory();
                }
            };
            for (File f : start.listFiles(filter)) {
                if (f.isDirectory()) {
                    search(f);
                } else {
                    searchJar(f);
                }
            }
        } catch (Exception e) {
            System.err.println("Error at: " + start.getPath() + " " + e.getMessage());
        }
    }

    private static void searchJar(File f) {
        try {
            System.out.println("Searching: " + f.getPath());
            JarFile jar = new JarFile(f);
            ZipEntry e = jar.getEntry(CLASS_FILE_TO_FIND);
            if (e == null) {
                e = jar.getJarEntry(CLASS_FILE_TO_FIND);
                if (e != null) {
                    foundIn.add(f.getPath());
                }
            } else {
                foundIn.add(f.getPath());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

公共类主{
/**
* 
*/
要查找的私有静态字符串类文件=
“class.to.find.Here”；
private static List foundIn=new LinkedList（）；
/**
*@param args第一个参数是要搜索的文件的路径。第二个参数可能是
*要查找的类文件。
*/
公共静态void main（字符串[]args）{
如果（！CLASS_FILE_TO_FIND.endsWith（“.CLASS”））{
CLASS_FILE_TO_FIND=CLASS_FILE_TO_FIND.replace（'.'，'/'）+“.CLASS”；
}
文件开始=新文件（args[0]）；
如果（参数长度>1）{
CLASS_FILE_TO_FIND=args[1]；
}
搜索（开始）；
System.out.println（“----结果------”）；
for（字符串s:foundIn）{
系统输出打印项次；
}
}
专用静态无效搜索（文件开始）{
试一试{
最终文件过滤器=新文件过滤器（）{
公共布尔接受（文件路径名）{
返回pathname.getName（）.endsWith（“.jar”）|| pathname.isDirectory（）；
}
};
对于（文件f:start.listFiles（过滤器））{
if（f.isDirectory（））{
搜查（f）；
}否则{
搜索引擎（f）；
}
}
}捕获（例外e）{
System.err.println（“错误位于：”+start.getPath（）+“”+e.getMessage（））；
}
}
私有静态void searchJar（文件f）{
试一试{
System.out.println（“搜索：+f.getPath（））；
JarFile jar=新的JarFile（f）；
ZipEntry e=jar.getEntry（要查找的类文件）；
如果（e==null）{
e=jar.getJarEntry（要查找的类文件）；
如果（e！=null）{
add（f.getPath（））；
}
}否则{
add（f.getPath（））；
}
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}

Unix 在Linux、其他Unix变体、Windows上的Git Bash或Cygwin上，使用

jar

（或

unzip-v

）、

grep

和

find

命令

以下列出了与给定名称匹配的所有类文件：

用于*.jar中的i；dojar-tvf“$i”| grep-Hsi类名和echo“$i”；完成

如果知道要搜索的Java归档文件的完整列表，可以使用（符号）链接将它们全部放在同一目录中

或者使用

find

（区分大小写）查找包含给定类名的JAR文件：

find path/to/libs-name'*.jar'-exec grep-Hls ClassName{}；

例如，要查找包含

IdentityHashingStrategy

的存档的名称：

$find-名称'*.jar'-exec grep-Hsli IdentityHashingStrategy{}\；
./trove-3.0.3.jar

如果JAR可以位于系统中的任何位置，并且命令可用：

以美元表示的i的

（定位“*.jar”）；
做回显“$i”；jar-tvf“$i”| grep-Hsi类名；
完成

语法变体：

find path/to/libs-name'*.jar'-print |\
当我读书时；dojar-tvf“$i”| grep-Hsi类名和echo“$i”；完成

窗户 打开，更改到包含JAR文件的目录（或祖先目录），然后：

for /R %G in (*.jar) do @jar -tvf "%G" | find "ClassName" > NUL && echo %G

下面是它的工作原理：

对于（*.jar）中的/R%G执行

-循环所有jar文件，递归遍历目录；将文件名存储在

%G

中

@jar-tvf“%G”

-运行Java Archive命令列出给定归档中的所有文件名，并将结果写入标准输出；

@

符号禁止打印命令的调用

find“ClassName”>NUL

-从jar命令的输出管道中搜索给定类名的标准输入；如果存在匹配项，则将

ERRORLEVEL

设置为1（否则为0）

&&echo%G

-iff

ERRORLEVEL

为非零，将Java归档文件名写入标准输出（控制台）

网状物

---

使用一个可以扫描的类。

您可以在一个目录中找到一个类，该目录中充满了jar，并带有一点shell：

正在查找“FooBar”类：

---

检查JBoss；尽管我从未亲自使用过它，但这似乎是您所需要的工具。

以上所有内容都需要添加一件事：如果您没有可用的jar可执行文件（它随JDK提供，但不随JRE提供），您可以使用unzip（或WinZip，或其他任何工具）来完成相同的任务

#!/bin/bash

pattern=$1
shift

for jar in $(find $* -type f -name "*.jar")
do
  match=`jar -tvf $jar | grep $pattern`
  if [ ! -z "$match" ]
  then
    echo "Found in: $jar"
    echo "$match"
  fi
done

给你这个罐子的名字

find . -name "*.jar" -exec jar -t -f {} \; | grep  "classname"

---

提供类的包

只需使用FindClassInJars util，它是一个简单的swing程序，但很有用。您可以在

处查看源代码或下载jar文件。不久前，我为此编写了一个程序：

查找与给定字符串匹配的jar：

---

find-name\*.jar-exec grep-l您的{}
无耻的自我推销，但您可以尝试我编写的实用程序：

它支持最常见的存档/压缩文件（jar、zip、tar、tar.gz等），并且与许多其他jar/zip查找程序不同，它支持嵌套的zip文件（zip中的zip、jar中的jar等），直到无限深度。
还有两个称为“JarScan”的不同实用程序，它们完全满足您的要求：
去派对有点晚了，不过

我一直在用它来寻找
grep -l "classname" *.jar

find . -name "*.jar" -exec jar -t -f {} \; | grep  "classname"

#!/bin/bash
for i in *.jar; do jar -tf "$i" | grep $1 | xargs -I{} echo -e "$i : {}" ; done

ls *.jar | xargs grep -F MyClass

grep -F MyClass *.jar

Binary file foo.jar matches

#!/bin/bash

# ./jarwalker.sh "/a/Starting/Path" "aClassName"

IFS=$'\n'
jars=( $( find -P "$1" -type f -name "*.jar" ) )

for jar in ${jars[*]}
    do
        classes=( $( zipinfo -1 ${jar} | awk -F '/' '{print $NF}' | grep .class | awk -F '.' '{print $1}' ) )
        if [ ${#classes[*]} -ge 0 ]; then
            for class in ${classes[*]}
                do
                    if [ ${class} == "$2" ]; then
                        echo "Found in ${jar}"
                    fi
                done
        fi
    done

#!/bin/bash
for i in `find . -name '*.jar'`; do jar -tf "$i" | grep $1 | xargs -I{} echo -e "$i : {}" ; done

# this function helps you to find a jar file for the class
function find_jar_of_class() {
  OLD_IFS=$IFS
  IFS=$'\n'
  jars=( $( find -type f -name "*.jar" ) )
  for i in ${jars[*]} ; do 
    if [ ! -z "$(jar -tvf "$i" | grep -Hsi $1)" ] ; then
      echo "$i"
    fi
   done 
  IFS=$OLD_IFS
}

IFS=$(echo -en "\n\b") # Set the field separator newline

for f in `find ${1} -iname *.jar`; do
  jar -tf ${f}| grep --color $2
  if [ $? == 0 ]; then
    echo -n "Match found: "
    echo -e "${f}\n"
  fi
done
unset IFS

$ find <base_dir> -name *.jar -print0 | xargs -0 -l jar tf | grep <name>

bash $ ls -1  | xargs -i -t jar -tvf '{}'| grep Abstract
jar -tvf activation-1.1.jar
jar -tvf antisamy-1.4.3.jar
  2263 Thu Jan 13 21:38:10 IST 2011 org/owasp/validator/html/scan/AbstractAntiSamyScanner.class
...

findstr /s /m /c:"package/classname" *.jar, where

Usage: java -jar jarscan.jar [-help | /?]
                    [-dir directory name]
                    [-zip]
                    [-showProgress]
                    <-files | -class | -package>
                    <search string 1> [search string 2]
                    [search string n]

Help:
  -help or /?           Displays this message.

  -dir                  The directory to start searching
                        from default is "."

  -zip                  Also search Zip files

  -showProgress         Show a running count of files read in

  -files or -class      Search for a file or Java class
                        contained in some library.
                        i.e. HttpServlet

  -package              Search for a Java package
                        contained in some library.
                        i.e. javax.servlet.http

  search string         The file or package to
                        search for.
                        i.e. see examples above

java -jar jarscan.jar -dir C:\Folder\To\Search -showProgress -class GenericServlet

import os, zipfile, glob, sys

def main():
    searchFile = sys.argv[1] #class file to search for, sent from batch file below (optional, see second block of code below)
    listOfFilesInJar = []
    for file in glob.glob("*.jar"):
        archive = zipfile.ZipFile(file, 'r')
        for x in archive.namelist():
            if str(searchFile) in str(x):
                listOfFilesInJar.append(file)

    for something in listOfFilesInJar:
        print("location of "+str(searchFile)+": ",something)

if __name__ == "__main__":
    sys.exit(main())

@echo off
python -B -c "import searchForFiles;x=searchForFiles.main();" AddWorkflows.class
pause