Unix

Użyj jar (lub unzip -v), grep, i find komendy.

Na przykład, poniżej wymieniono wszystkie pliki klas, które pasują do danej nazwy:

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

Jeśli znasz całą listę archiwów Javy, które chcesz przeszukać, możesz umieścić je wszystkie w tym samym katalogu za pomocą (symbolicznych) linków.

Lub użyj find (z wyczuciem wielkości liter), aby znaleźć plik JAR zawierający nazwę danej klasy:

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

Na przykład, aby znaleźć nazwę archiwum zawierające IdentityHashingStrategy:

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

Gdyby słoik mógł być gdziekolwiek w systemie i locate polecenie jest dostępne:

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

Okna

Otwórz wiersz polecenia , przejdź do katalogu (lub katalogu nadrzędnego) zawierającego pliki JAR, a następnie:

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

Oto jak to działa:

1. for /R %G in (*.jar) do - pętla nad wszystkimi plikami JAR, rekurencyjnie przemierzając katalogi; przechowuj nazwę pliku w %G.
2. @jar -tvf "%G" | - Uruchom Javę Polecenie Archive wyświetla wszystkie nazwy plików w danym archiwum i zapisuje wyniki na standardowe wyjście; symbol @ wyłącza drukowanie wywołania polecenia.
3. find "ClassName" > NUL - wyszukuje standardowe wejście, wyprowadzone z wyjścia polecenia jar, dla podanej nazwy klasy; to ustawi ERRORLEVEL na 1 iff jest dopasowanie (w przeciwnym razie 0).
4. && echo %G - iff ERRORLEVEL jest niezerowe, zapisuje nazwę pliku archiwum Javy na standardowe wyjście (konsola).

Web

Użycie wyszukiwarka która skanuje pliki JAR.

Jakiś czas temu napisałem program właśnie po to: https://github.com/javalite/jar-explorer

grep -l "classname" *.jar

Podaje nazwę słoika

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

Daje pakiet klasy

#!/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

Nie wiedziałem o narzędziu do tego, kiedy natknąłem się na ten problem, więc napisałem co następuje:

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

}

Aby zlokalizować słoiki pasujące do danego ciągu:

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

Istnieją również dwa różne narzędzia zwane zarówno "JarScan", które robią dokładnie to, o co prosisz: JarScan (inetfeedback.com) I JarScan (java.net)

User1207523 ' s script works fine for me. Oto wariant, który rekusywnie wyszukuje pliki jar za pomocą find zamiast prostego rozszerzenia;

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

Zawsze używałem tego na Windows i działało wyjątkowo dobrze.

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

Findstr.exe jest standardowo wyposażony w Windows i params:

• / s = rekurencyjnie
• / m = wyświetla tylko nazwę pliku, jeśli istnieje dopasowanie
• / c = literalny łańcuch znaków (w tym przypadku Nazwa pakietu + nazwy klas separated by'/')

A bash script roztwór z użyciem unzip (zipinfo). Testowane na 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

I found this new way

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

Więc ta lista zawiera jar i klasę, jeśli zostanie znaleziona, jeśli chcesz, możesz dać ls -1 *.jar lub input to xargs with find command HTH Someone.

Sprawdź JBoss ; chociaż nigdy nie używałem go osobiście, to wydaje się, że jest to narzędzie, którego potrzebujesz.

Wystarczy użyć FindClassInJars util, jest to prosty program swing, ale przydatny. Możesz sprawdzić kod źródłowy lub pobrać plik jar pod adresem http://code.google.com/p/find-class-in-jars/

Nie jestem pewien, dlaczego scenariusze tutaj nigdy tak naprawdę nie działały dla mnie. To działa:

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

Aby przeszukać wszystkie pliki jar w danym katalogu dla określonej klasy, możesz to zrobić:

ls *.jar | xargs grep -F MyClass

Lub, jeszcze prościej,

grep -F MyClass *.jar

Wyjście wygląda tak:

Binary file foo.jar matches

Jest to bardzo szybkie, ponieważ opcja-F oznacza wyszukiwanie stałego ciągu znaków, więc nie ładuje silnika regex dla każdego wywołania grepa. Jeśli trzeba, zawsze można pominąć opcję-F i użyć wyrażeń regularnych.

Skrypt do znalezienia pliku jar: 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

Użycie:. /find_jar.sh

Jest to podobne do większości udzielonych tutaj odpowiedzi. Ale wyświetla nazwę pliku tylko wtedy, gdy grep coś znajdzie. Jeśli chcesz wyłączyć wyjście grepa, Możesz przekierować je do /dev / null, ale wolę zobaczyć wyjście grepa, tak żebym mógł użyć częściowych nazw klas i dowiedzieć się poprawnej z listy wyjścia.

The nazwa klasy może być zarówno prostą nazwą klasy jak "String" lub w pełni kwalifikowaną nazwą jak " java.lang.String "

Aby dodać kolejne narzędzie... jest to bardzo proste i przydatne narzędzie dla systemu windows. Prosty plik exe, który klikniesz, nadasz mu katalog do przeszukiwania, nazwę klasy i znajdzie plik jar, który zawiera tę klasę. Tak, jest rekurencyjny.

Http://sourceforge.net/projects/jarfinder/

Możesz znaleźć klasę w katalogu pełnym słoików z odrobiną powłoki:

Szukam klasy "FooBar":

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

Jedna rzecz do dodania do wszystkich powyższych: jeśli nie masz dostępnego pliku wykonywalnego jar (jest dostarczany z JDK, ale nie z JRE), możesz użyć unzip (lub WinZip, lub cokolwiek innego), aby osiągnąć to samo.

Bezwstydna autopromocja, ale możesz wypróbować narzędzie, które napisałem: http://sourceforge.net/projects/zfind

Obsługuje większość popularnych plików archiwalnych / skompresowanych (jar, zip, tar, tar.w przeciwieństwie do wielu innych wyszukiwarek jar / zip, obsługuje zagnieżdżone pliki zip (zip w zip, jar w jar itp.) do nieograniczonej głębokości.

Trochę za późno na imprezę, ale mimo wszystko...

Używam JarBrowser , aby znaleźć, w którym Jarze znajduje się dana klasa. Ma łatwy w użyciu GUI, który pozwala przeglądać zawartość wszystkich słoików w wybranej ścieżce.

Poniższy skrypt ci pomoże

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

Ten działa dobrze w MinGW ( Windows Bash environment) ~ gitbash

Umieść tę funkcję w swoim .plik bashrc w katalogu domowym:

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

Grepj jest narzędziem wiersza poleceń do wyszukiwania klas w plikach jar. Jestem autorem narzędzia.

Możesz uruchomić narzędzie jak grepj package.Class my1.jar my2.war my3.ear

Można dostarczyć wiele plików jar, ear, war. W przypadku użycia Zaawansowanego użyj funkcji find, aby podać listę słoików do przeszukiwania.

Sprawdź ten Plugin dla eclipse, który może wykonać pracę, której szukasz.

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

W środowisku Linux można wykonać następujące czynności:

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

Gdzie Nazwa jest nazwą pliku klasy, który przeglądasz wewnątrz słoików rozmieszczonych w hierarchii katalogów zakorzenionych w base_dir.

Możesz użyć locate i grep:

locate jar | xargs grep 'my.class'

Upewnij się, że uruchomiłeś updatedb przed użyciem locate.

Użyj tego.. możesz znaleźć dowolny plik w classpath.. gwarantuję..

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

}

W eclipse możesz użyć starego, ale wciąż używalnego pluginu jarsearch