it-swarm.com.de

Suchen Sie eine Klasse in Dutzenden von JAR-Dateien?

Wie würden Sie einen bestimmten Klassennamen in vielen JAR-Dateien finden?

(Suchen Sie nach dem tatsächlichen Klassennamen, nicht nach den Klassen, die darauf verweisen.)

231
Kapsh

Eclipse kann dies tun, indem Sie einfach ein (temporäres) Projekt erstellen und Ihre Bibliotheken im Klassenpfad des Projekts ablegen. Dann können Sie die Klassen leicht finden.

Ein anderes Tool, das mir in den Sinn kommt, ist Java Decompiler. Es kann viele Jars gleichzeitig öffnen und hilft, Klassen zu finden.

54
Andreas_D

Unix

Verwenden Sie die Befehle jar (oder unzip -v), grep und find.

Im Folgenden werden beispielsweise alle Klassendateien aufgelistet, die mit einem bestimmten Namen übereinstimmen:

for i in *.jar; do jar -tvf "$i" | grep -Hsi ClassName && echo "$i"; done

Wenn Sie die gesamte Liste der zu durchsuchenden Java) - Archive kennen, können Sie diese über (symbolische) Links in demselben Verzeichnis ablegen.

Oder verwenden Sie find (Groß- und Kleinschreibung beachten), um die JAR-Datei zu finden, die einen bestimmten Klassennamen enthält:

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

Um beispielsweise den Namen des Archivs zu finden, das IdentityHashingStrategy enthält, gehen Sie wie folgt vor:

$ find . -name "*.jar" -exec grep -Hsli IdentityHashingStrategy {} \;
./trove-3.0.3.jar

Wenn sich die JAR Irgendwo im System befindet und der Befehl locate verfügbar ist:

for i in $(locate "*.jar");
  do echo $i; jar -tvf $i | grep -Hsi ClassName;
done

Windows

Öffnen Sie ein Eingabeaufforderung , wechseln Sie in das Verzeichnis (oder Vorgängerverzeichnis), das die JAR-Dateien enthält, und führen Sie dann Folgendes aus:

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

So funktioniert das:

  1. for /R %G in (*.jar) do - Durchlaufen aller JAR-Dateien rekursiv die Verzeichnisse. Speichern Sie den Dateinamen in% G.
  2. @jar -tvf "%G" | - Führen Sie den Befehl Java Archive aus, um alle Dateinamen im angegebenen Archiv aufzulisten, und schreiben Sie die Ergebnisse in die Standardausgabe. Das Symbol @ Unterdrückt das Drucken des Archivs Aufruf des Befehls.
  3. find "ClassName" > NUL - Durchsucht die Standardeingabe, die aus der Ausgabe des Befehls jar abgeleitet wird, nach dem angegebenen Klassennamen. Dies setzt ERRORLEVEL auf 1, wenn eine Übereinstimmung vorliegt (andernfalls 0).
  4. && echo %G - Wenn ERRORLEVEL nicht Null ist, schreiben Sie den Namen der Java Archivdatei in die Standardausgabe (die Konsole).

Web

Verwenden Sie eine Suchmaschine , die JAR-Dateien durchsucht.

374
Dave Jarvis

vor einiger Zeit habe ich dafür ein Programm geschrieben: https://github.com/javalite/jar-Explorer

58
ipolevoy
grep -l "classname" *.jar

gibt dir den Namen des Glases

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

gibt Ihnen das Paket der Klasse

23
user311174
#!/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
11
Pascal Lambert

Als ich auf dieses Problem stieß, kannte ich kein Hilfsprogramm, weshalb ich Folgendes schrieb:

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();
        }
    }

}
7
ILMTitan

So suchen Sie nach Gläsern, die mit einer bestimmten Zeichenfolge übereinstimmen:

find . -name \*.jar -exec grep -l YOUR_CLASSNAME {} \;

7
George Armhold

Es gibt auch zwei verschiedene Dienstprogramme mit dem Namen "JarScan", die genau das tun, wonach Sie suchen: JarScan (inetfeedback.com) und JarScan (Java.net)

5
salzo

Ich habe dies immer unter Windows verwendet und es hat außergewöhnlich gut funktioniert.

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

findstr.exe wird standardmäßig mit Windows und den folgenden Parametern geliefert:

  • / s = rekursiv
  • / m = Nur den Dateinamen ausgeben, wenn eine Übereinstimmung vorliegt
  • / c = Literalzeichenfolge (in diesem Fall Ihr Paketname + Klassennamen, getrennt durch '/')

Hoffe das hilft jemandem.

3
Ramesh Rooplahl

das Skript von user1207523 funktioniert einwandfrei für mich. Hier ist eine Variante, die nach JAR-Dateien sucht, wobei find anstelle einer einfachen Erweiterung verwendet wird.

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

Ich habe diesen neuen Weg gefunden

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
...

Dies listet also das jar und die Klasse auf, wenn sie gefunden werden. Wenn Sie möchten, können Sie ls -1 * .jar geben oder xargs mit dem find-Befehl HTH Someone eine Eingabe geben.

2
Cleonjoys

Eine bash script - Lösung mit unzip (zipinfo). Getestet auf Ubuntu 12.

#!/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
2
Filippo Lauria

Ich bin mir nicht sicher, warum Skripte hier nie wirklich für mich gearbeitet haben. Das funktioniert:

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

Verwenden Sie einfach FindClassInJars util, ein einfaches, aber nützliches Swing-Programm. Sie können den Quellcode überprüfen oder die JAR-Datei unter http://code.google.com/p/find-class-in-jars/ herunterladen

1
Liubing

Check JBoss Tattletale ; Obwohl ich es nie persönlich benutzt habe, scheint es das Werkzeug zu sein, das Sie brauchen.

1

So durchsuchen Sie alle JAR-Dateien in einem bestimmten Verzeichnis nach einer bestimmten Klasse:

ls *.jar | xargs grep -F MyClass

oder noch einfacher

grep -F MyClass *.jar

Die Ausgabe sieht folgendermaßen aus:

Binary file foo.jar matches

Dies ist sehr schnell, da die Option -F die Suche nach einer festen Zeichenfolge bedeutet, sodass die Regex-Engine nicht bei jedem Aufruf von grep geladen wird. Bei Bedarf können Sie die Option -F immer weglassen und reguläre Ausdrücke verwenden.

1
Jeff

Ein weiteres Tool hinzufügen ... Dies ist ein sehr einfaches und nützliches Tool für Windows. Eine einfache exe-Datei, auf die Sie klicken, und ein Verzeichnis, in dem gesucht werden soll, sowie ein Klassenname. Anschließend wird die jar-Datei gefunden, die diese Klasse enthält. Ja, es ist rekursiv.

http://sourceforge.net/projects/jarfinder/

1
Ben

Skript zum Finden der JAR-Datei: find_jar.sh

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

Verwendung: ./find_jar.sh <Verzeichnis der obersten Ebene mit JAR-Dateien> <zu suchender Klassenname>

Dies ähnelt den meisten hier gegebenen Antworten. Es gibt aber nur den Dateinamen aus, wenn grep etwas findet. Wenn Sie die Ausgabe von grep unterdrücken möchten, leiten Sie diese möglicherweise nach/dev/null um, aber ich bevorzuge, auch die Ausgabe von grep zu sehen, damit ich Teilklassennamen verwenden und den richtigen aus einer Liste der angezeigten Ausgaben herausfinden kann.

Der Klassenname kann sowohl ein einfacher Klassenname wie "String" oder ein vollständig qualifizierter Name wie "Java.lang.String" sein.

1
Joydip Datta

schamlose Eigenwerbung, aber Sie können ein Dienstprogramm ausprobieren, das ich geschrieben habe: http://sourceforge.net/projects/zfind

Es unterstützt die gängigsten archivierten/komprimierten Dateien (jar, zip, tar, tar.gz usw.) und unterstützt im Gegensatz zu vielen anderen jar/zip-Findern verschachtelte zip-Dateien (zip in zip, jar in jar usw.) bis zu einer unbegrenzten Tiefe.

0
Dipankar Datta

So finden Sie eine Klasse in einer Reihe von JARs in Ordnern (und Unterordnern): https://jarscan.com/

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

Beispiel:

Java -jar jarscan.jar -dir C:\Folder\To\Search -showProgress -class GenericServlet
0
KrishPrabakar

Das folgende Skript hilft Ihnen dabei

for file in *.jar
do
  # do something on "$file"
  echo "$file"
  /usr/local/jdk/bin/jar -tvf "$file" | grep '$CLASSNAME'
done
0
Kartik Jajal

Sie finden eine Klasse in einem Verzeichnis voller Gläser mit etwas Shell:

Auf der Suche nach Klasse "FooBar":

LIB_DIR=/some/dir/full/of/jarfiles
for jarfile in $(find $LIBDIR -name "*.jar"); do
   echo "--------$jarfile---------------"
   jar -tvf $jarfile | grep FooBar
done
0
Steve B.

Aktivieren Sie dieses Plugin für Eclipse, das den gewünschten Job ausführen kann.

https://marketplace.Eclipse.org/content/jarchiveexplorer

0
kutty

In einer Linux-Umgebung können Sie Folgendes tun:

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

Wobei name der Name der Klassendatei ist, die Sie in den Gläsern suchen, die über die Hierarchie der Verzeichnisse verteilt sind, die im Stammverzeichnis des base_dir .

0
Victor

Wenn Sie eine Instanz der Klasse haben oder eine bekommen können, haben Sie eine reine Java Lösung:

try{
    Class clazz = Class.forName("        try{
        Class clazz = Class.forName("class-name");
        String name = "/"+clazz.getName().replace('.', '/')+".class";
        URL url = clazz.getResource(name);
        String jar = url.toString().substring(10).replaceAll("!.*", "");
        System.out.println( jar );
    }catch(Exception err){
        err.printStackTrace();
    }

Natürlich müssen die ersten beiden Zeilen angepasst werden, je nachdem, wo Sie eine Instanz der Klasse oder den Klassennamen haben.

0
AlainD

Dieser funktioniert gut in MinGW (Windows Bash-Umgebung) ~ gitbash

Fügen Sie diese Funktion in Ihre .bashrc-Datei in Ihrem HOME-Verzeichnis ein:

# 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
}
0
kisp

Eine Sache, die Sie zu all dem hinzufügen sollten: Wenn Sie die ausführbare JAR-Datei nicht zur Verfügung haben (sie wird mit dem JDK geliefert, aber nicht mit dem JRE), können Sie das gleiche mit unzip (oder WinZip oder was auch immer) erreichen.

0
Alex

Dateiname: searchForFiles.py

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 __== "__main__":
    sys.exit(main())

Sie können dies einfach ausführen, indem Sie eine .bat-Datei mit dem folgenden Text erstellen (ersetzen Sie "AddWorkflows.class" durch die gesuchte Datei):

(Datei: CallSearchForFiles.bat)

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

Sie können auf CallSearchForFiles.bat doppelklicken, um es auszuführen, oder es über die Befehlszeile "CallSearchForFiles.bat SearchFile.class" aufrufen.

Klicken Sie hier, um die Beispielausgabe anzuzeigen.

0
Collin Fox

Sie können locate und grep verwenden:

locate jar | xargs grep 'my.class'

Stellen Sie sicher, dass Sie updatedb ausführen, bevor Sie locate verwenden.

0
mulugu mahesh

In Eclipse können Sie das alte, aber noch verwendbare Plugin jarsearch verwenden

0
keiki

Grepj ist ein Befehlszeilenprogramm zum Suchen nach Klassen in JAR-Dateien. Ich bin der Autor des Dienstprogramms.

Sie können das Dienstprogramm wie folgt ausführen: grepj package.Class my1.jar my2.war my3.ear

Es können mehrere Glas-, Ohr- und Kriegsdateien bereitgestellt werden. Für den fortgeschrittenen Gebrauch verwenden Sie find, um eine Liste der zu durchsuchenden Gläser bereitzustellen.

0
rrevo

Verwenden Sie diese .. Sie können jede Datei im Klassenpfad finden .. garantiert ..

import Java.net.URL;
import Java.net.URLClassLoader;
import Java.util.Zip.ZipEntry;
import Java.util.Zip.ZipInputStream;

public class FileFinder {

    public static void main(String[] args) throws Exception {

        String file = <your file name>;

        ClassLoader cl = ClassLoader.getSystemClassLoader();

        URL[] urls = ((URLClassLoader)cl).getURLs();

        for(URL url: urls){
            listFiles(file, url);
        }
    }

    private static void listFiles(String file, URL url) throws Exception{
        ZipInputStream Zip = new ZipInputStream(url.openStream());
          while(true) {
            ZipEntry e = Zip.getNextEntry();
            if (e == null)
              break;
            String name = e.getName();
            if (name.endsWith(file)) {
                System.out.println(url.toString() + " -> " + name);
            }
          }
    }

}
0
Apurva Singh

Ein bisschen spät zur Party, aber trotzdem ...

Ich habe JarBrowser verwendet, um herauszufinden, in welchem ​​Glas eine bestimmte Klasse vorhanden ist. Es ist eine einfach zu bedienende Benutzeroberfläche, mit der Sie den Inhalt aller Gläser im ausgewählten Pfad durchsuchen können.

0
maccaroo