Finden Sie eine Klasse irgendwo in Dutzenden von JAR-Dateien?

Wie findet man einen bestimmten class-Namen innen viele jar-Dateien?

(Für die Suche nach dem eigentlichen Klassennamen, nicht die Klassen, die darauf verweisen.)

InformationsquelleAutor der Frage Kapsh | 2009-08-27

52

Eclipse kann es tun, erstellen Sie einfach eine (temporäre) Projekt und stellen Ihre Bibliotheken auf die Projekte classpath. Dann können Sie ganz einfach die Klassen.

Weiteres tool, dass mir in den Sinn kommt, ist Java Decompiler. Es kann öffnen viele Gläser auf einmal und hilft, Klassen sowie.

InformationsquelleAutor der Antwort Andreas_D
335

Unix

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

Beispielsweise der folgenden Liste alle class Dateien mit einem bestimmten Namen:
```
for i in *.jar; do jar -tvf "$i" | grep -Hsi ClassName && echo "$i"; done
```
Wenn Sie wissen, die gesamte Liste der Java-Archive, die Sie suchen möchten, können Sie Sie alle in das gleiche Verzeichnis mit (symbolischen) links.

Oder verwenden Sie find (Fall empfindlich) zu finden, die JAR-Datei enthält eine bestimmte Klasse name:
```
find path/to/libs -name '*.jar' -exec grep -Hls ClassName {} \;
```
Zum Beispiel, um den Namen des Archivs enthält IdentityHashingStrategy:
```
$ find . -name "*.jar" -exec grep -Hsli IdentityHashingStrategy {} \;
./trove-3.0.3.jar
```
Wenn das GLAS könnte überall in das system und die suchen - Befehl zur Verfügung:
```
for i in $(locate "*.jar");
  do echo $i; jar -tvf $i | grep -Hsi ClassName;
done
```
Windows

Öffnen Sie eine Eingabeaufforderungwechseln Sie zu dem Verzeichnis (oder Vorgänger -) Verzeichnis mit den JAR-Dateien, dann:
```
for /R %G in (*.jar) do @jar -tvf "%G" | find "ClassName" > NUL && echo %G
```
Hier ist, wie es funktioniert:
1. for /R %G in (*.jar) do - Schleife über alle JAR-Dateien, Verzeichnisse rekursiv Durchlaufen; speichern der Datei-name in %G.
2. @jar -tvf "%G" | - führen Sie das Java-Archiv Befehl, um eine Liste aller Dateinamen in dem angegebenen Archiv, und schreiben Sie die Ergebnisse auf die Standardausgabe; die @ symbol unterdrückt das drucken der Befehl Aufruf.
3. find "ClassName" > NUL - Suche die standard-Eingabe, geleitet von der Ausgabe von dem jar-Kommando für die angegebenen Klassennamen; dies wird ERRORLEVEL 1 iff es eine übereinstimmung gibt (sonst 0).
4. && echo %G - iff ERRORLEVEL ungleich null ist, schreiben Sie das Java-Archiv-Dateinamen auf die Standardausgabe (Konsole).
Web

Verwenden Suchmaschine , scans JAR-Dateien.

InformationsquelleAutor der Antwort Dave Jarvis
53

vor einiger Zeit habe ich ein Programm geschrieben nur für: https://github.com/javalite/jar-explorer

InformationsquelleAutor der Antwort ipolevoy
21
```
grep -l "classname" *.jar
```
gibt man den Namen der jar -
```
find . -name "*.jar" -exec jar -t -f {} \; | grep  "classname"
```
gibt Ihnen das Paket der Klasse

InformationsquelleAutor der Antwort 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

InformationsquelleAutor der Antwort Pascal Lambert

Wusste ich nicht von einem Werkzeug, es zu tun, wenn ich stieß auf dieses problem, also schrieb ich Folgendes:

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

}

InformationsquelleAutor der Antwort ILMTitan

5

Suchen Gläser, die entsprechen einer bestimmten Zeichenfolge:

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

InformationsquelleAutor der Antwort George Armhold
5

Gibt es auch zwei unterschiedliche Dienstprogramme aufgerufen, sowohl "JarScan", die genau das tun, was Sie fordern:
JarScan (inetfeedback.com) und JarScan (java.net)

InformationsquelleAutor der Antwort salzo
3

user1207523 das Skript funktioniert gut für mich. Hier ist eine Variante, die sucht nach jar-Dateien recusively Verwendung finden anstelle von einfachem ausbau;
```
#!/bin/bash
for i in `find . -name '*.jar'`; do jar -tf "$i" | grep $1 | xargs -I{} echo -e "$i : {}" ; done
```
InformationsquelleAutor der Antwort Kurtcebe Eroglu
3

Habe ich immer diese verwendet auf Windows und arbeitete außerordentlich gut.
```
findstr /s /m /c:"package/classname" *.jar, where
```
findstr.exe kommt standard mit Windows und den params:
- /s = rekursiv
- /m = drucken nur den Dateinamen, wenn es eine übereinstimmung gibt
- /c = literal-Zeichenfolge (in diesem Fall Ihr Paket name + Klasse Namen
  durch ' /' getrennt)
Hoffe, das jemand hilft.

InformationsquelleAutor der Antwort Ramesh Rooplahl

Einen 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

InformationsquelleAutor der Antwort Filippo Lauria

Fand ich diese neue Art

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

So, in diesem Listen Sie die jar-und die Klasse, wenn Sie gefunden, wenn Sie möchten, kann Ihnen ls -1 *.Glas-oder Eingang zu xargs mit dem Befehl "suchen" HTH Jemand.

InformationsquelleAutor der Antwort Cleonjoys

1

Überprüfen JBoss Tattletale; obwohl ich noch nie benutzt habe es persönlich scheint dies das Werkzeug, das Sie brauchen.

InformationsquelleAutor der Antwort Wilfred Springer
1

Verwenden Sie einfach FindClassInJars util, es ist ein einfaches swing Programm, aber nützlich. Sie können überprüfen, source-code oder laden Sie die jar-Datei auf http://code.google.com/p/find-class-in-jars/

InformationsquelleAutor der Antwort Liubing
1

Nicht sicher, warum Skripte hier noch nie wirklich für mich gearbeitet. Das funktioniert:
```
#!/bin/bash
for i in *.jar; do jar -tf "$i" | grep $1 | xargs -I{} echo -e "$i : {}" ; done
```
InformationsquelleAutor der Antwort Mikael Lindlöf
1

Suche alle jar-Dateien in einem gegebenen Verzeichnis eine bestimmte Klasse, die Sie dies tun können:
```
ls *.jar | xargs grep -F MyClass
```
oder, noch einfacher,
```
grep -F MyClass *.jar
```
Ausgabe sieht wie folgt aus:
```
Binary file foo.jar matches
```
Es ist sehr schnell, da die option-F bedeutet, dass die Suche für den Festen string, so macht es keinen laden, der die regex-engine für jede grep-Aufruf. Wenn Sie brauchen, um, können Sie immer weglassen der option-F und verwenden regexes.

InformationsquelleAutor der Antwort Jeff
1

Skript zu finden 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
```
Usage: ./find_jar.sh < top-level-Verzeichnis mit der jar-Dateien > < Klassennamen zu finden>

Dies ist ähnlich wie die meisten hier gegebenen Antworten. Aber es gibt nur den Dateinamen, wenn grep etwas findet. Wenn Sie möchten, zu unterdrücken grep-Ausgabe können Sie umleiten, die nach /dev/null, aber ich bevorzuge zu sehen, die Ausgabe von grep als gut, so dass ich verwenden können, teilweise Klassennamen und herauszufinden, die richtige aus einer Liste von Ausgabe gezeigt.

Den Namen der Klasse können sowohl einfache Klasse Namen Wie "String" oder den vollständig qualifizierten Namen wie "java".lang.String"

InformationsquelleAutor der Antwort Joydip Datta
1

Hinzufügen noch ein weiteres tool... dies ist ein sehr einfaches und nützliches tool für windows. Eine einfache exe-Datei, die Sie klicken Sie auf, ihm ein Verzeichnis zu suchen, in der der name einer Klasse und es finden die jar-Datei enthält die Klasse. Ja, es ist rekursiv.

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

InformationsquelleAutor der Antwort Ben

Finden Sie eine Klasse in ein Verzeichnis voll von Gläsern mit ein bisschen shell:

Sucht 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

InformationsquelleAutor der Antwort Steve B.

0

Eine Sache hinzufügen, um alle der oben genannten: wenn Sie nicht über die ausführbare jar-verfügbar (es kommt mit dem JDK, aber nicht mit der JRE), die Sie verwenden können, entpacken (WinZip oder, oder was auch immer) das gleiche erreichen.

InformationsquelleAutor der Antwort Alex
0

schamlose Eigenwerbung, aber man kann versuchen, ein Dienstprogramm, das ich schrieb : http://sourceforge.net/projects/zfind

Es unterstützt die meisten gängigen Archiv/komprimierte Dateien (jar, zip, tar, tar.gz usw) und im Gegensatz zu vielen anderen jar/zip Finder, unterstützt verschachtelte zip-Dateien (zip-in zip -, jar-in-jar, etc) bis in unbegrenzte Tiefe.

InformationsquelleAutor der Antwort Dipankar Datta
0

Etwas spät zur party, aber dennoch...

Habe ich mit JarBrowser zu finden, in dem jar einer bestimmten Klasse vorhanden ist. Es hat eine einfach zu bedienende GUI, das Ihnen erlaubt, durchsuchen Sie den Inhalt der Gläser in dem ausgewählten Pfad.

InformationsquelleAutor der Antwort maccaroo

Folgenden Skript wird Ihnen helfen, aus

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

InformationsquelleAutor der Antwort Kartik Jajal

Dieser arbeitet auch in MinGW ( windows-bash-Umgebung ) ~ gitbash

Setzen Sie diese Funktion in Ihr .bashrc Datei im HOME-Verzeichnis:

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

InformationsquelleAutor der Antwort kisp

0

Grepj ist ein Befehlszeilen-Dienstprogramm, um die Suche für die Klassen innerhalb der jar-Dateien. Ich bin der Autor des Dienstprogramms.

Können Sie das Dienstprogramm ausführen, wie grepj package.Class my1.jar my2.war my3.ear

Mehrere jar -, ear -, war-Dateien können zur Verfügung gestellt werden. Für die erweiterte Nutzung Verwendung finden, um eine Liste von jars gesucht werden.

InformationsquelleAutor der Antwort rrevo
0

Prüfen Sie dieses Plugin für eclipse, die den job tun können, die Sie suchen.

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

InformationsquelleAutor der Antwort kutty
0

Unter einer Linux-Umgebung können Sie das folgende tun :
```
$ find <base_dir> -name *.jar -print0 | xargs -0 -l jar tf | grep <name>
```
Wo Namen ist der name der class-Datei, die Sie suchen, innerhalb der Gläser verteilt, die Hierarchie der Verzeichnisse, verwurzelt in der base_dir.

InformationsquelleAutor der Antwort Victor
0

Können Sie locate und grep:
```
locate jar | xargs grep 'my.class'
```
Stellen Sie sicher, dass updatedb vor der Verwendung locate.

InformationsquelleAutor der Antwort mulugu mahesh

Verwenden.. finden Sie jede Datei in den classpath.. 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);
            }
          }
    }

}

InformationsquelleAutor der Antwort Apurva Singh

0

In eclipse können Sie die alten aber noch brauchbaren plugin jarsearch

InformationsquelleAutor der Antwort keiki

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Unix

Windows

Web