Encuentra una clase en algún lugar dentro de docenas de archivos JAR?

¿Cómo encontrarías un nombre de clase particular dentro de muchos archivos jar?

(Buscando el nombre de clase real, no las clases que lo hacen referencia).

Eclipse puede hacerlo, solo crea un proyecto (temporal) y coloca tus bibliotecas en el classpath de los proyectos. Entonces puedes encontrar fácilmente las clases.

Otra herramienta, que me viene a la mente, es Java Decompiler. Puede abrir muchos tarros a la vez y ayuda a encontrar clases también.

Unix

Use el jar (o unzip -v ), grep y find comandos.

Por ejemplo, lo siguiente enumerará todos los archivos de clase que coincidan con un nombre de stack:

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

Si conoce la lista completa de archivos Java que desea buscar, puede colocarlos todos en el mismo directorio usando enlaces (simbólicos).

O use find (distingue entre mayúsculas y minúsculas) para encontrar el archivo JAR que contiene un nombre de clase determinado:

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

Por ejemplo, para encontrar el nombre del archivo que contiene IdentityHashingStrategy :

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

Si el JAR puede estar en cualquier lugar del sistema y el comando locate está disponible:

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

Windows

Abra un símbolo del sistema , cambie al directorio (o ancestro) que contiene los archivos JAR, luego:

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

Así es como funciona:

  1. for /R %G in (*.jar) do – repite todos los archivos JAR, recorriendo recursivamente los directorios; almacena el nombre del archivo en% G.
  2. @jar -tvf "%G" | – ejecutar el comando Java Archive para listar todos los nombres de archivo dentro del archivo dado, y escribir los resultados en salida estándar; el símbolo @ suprime la impresión de la invocación del comando.
  3. find "ClassName" > NUL – entrada estándar de búsqueda, canalizada desde la salida del comando jar, para el nombre de clase dado; esto establecerá ERRORLEVEL en 1 si hay una coincidencia (de lo contrario 0).
  4. && echo %G – iff ERRORLEVEL no es cero, escriba el nombre del archivo de Java en la salida estándar (la consola).

Web

Use un motor de búsqueda que escanee archivos JAR .

Hace algún tiempo, escribí un progtwig solo para eso: https://github.com/javalite/jar-explorer

 grep -l "classname" *.jar 

te da el nombre del flask

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

te da el paquete de la clase

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

No sabía de una utilidad para hacerlo cuando me encontré con este problema, así que escribí lo siguiente:

 public class Main { /** * */ private static String CLASS_FILE_TO_FIND = "class.to.find.Here"; private static List foundIn = new LinkedList(); /** * @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(); } } } 

Para localizar tarros que coincidan con una cadena dada:

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

También hay dos utilidades diferentes llamadas “JarScan” que hacen exactamente lo que está pidiendo: JarScan (inetfeedback.com) y JarScan (java.net)

El script de user1207523 funciona bien para mí. Aquí hay una variante que busca archivos jar de forma recusiva usando find en lugar de simple expansión;

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

Siempre he usado esto en Windows y funcionó excepcionalmente bien.

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

findstr.exe viene de serie con Windows y los params:

  • / s = recursivamente
  • / m = imprime solo el nombre del archivo si hay una coincidencia
  • / c = cadena literal (en este caso su nombre de paquete + nombres de clase separados por ‘/’)

Espero que esto ayude a alguien.

Una solución de bash script que usa unzip (zipinfo) . Probado en 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 

Encontré esta nueva forma

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

Así que esto enumera el jar y la clase si se encuentra, si quieres puedes dar ls -1 * .jar o ingresar a xargs con el comando Find HTH Someone.

Compruebe JBoss Tattletale ; aunque nunca lo he usado personalmente, esta parece ser la herramienta que necesita.

Simplemente use FindClassInJars util, es un progtwig de swing simple, pero útil. Puede verificar el código fuente o descargar el archivo jar en http://code.google.com/p/find-class-in-jars/

No estoy seguro de por qué los guiones aquí nunca funcionaron para mí. Esto funciona:

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

Para buscar todos los archivos jar en un directorio determinado para una clase en particular, puede hacer esto:

 ls *.jar | xargs grep -F MyClass 

o, incluso más simple,

 grep -F MyClass *.jar 

La salida se ve así:

 Binary file foo.jar matches 

Es muy rápido porque la opción -F significa búsqueda de cadena Fija, por lo que no carga el motor de expresiones regulares para cada invocación de grep. Si es necesario, siempre puede omitir la opción -F y usar expresiones regulares.

Script para encontrar el archivo 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 

Uso: ./find_jar.sh

Esto es similar a la mayoría de las respuestas dadas aquí. Pero solo muestra el nombre del archivo, si grep encuentra algo. Si desea suprimir la salida de grep, puede redirigirlo a / dev / null, pero también prefiero ver la salida de grep para poder utilizar nombres de clase parciales y encontrar el correcto de una lista de salida mostrada.

El nombre de clase puede ser tanto un nombre de clase simple como “Cadena” o un nombre completamente calificado como “java.lang.String”

Para agregar otra herramienta … esta es una herramienta muy simple y útil para Windows. Un simple archivo ejecutable en el que hace clic, le da un directorio para buscar, un nombre de clase y encontrará el archivo jar que contiene esa clase. Sí, es recursivo

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

Puede encontrar una clase en un directorio lleno de jarras con un poco de shell:

Buscando la clase “FooBar”:

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

Una cosa para agregar a todo lo anterior: si no tiene el ejecutable jar disponible (viene con el JDK pero no con el JRE), puede usar descomprimir (o WinZip, o lo que sea) para lograr lo mismo.

auto promoción desvergonzada, pero puedes probar una utilidad que escribí: http://sourceforge.net/projects/zfind

Admite la mayoría de los archivos comprimidos / archivados (jar, zip, tar, tar.gz, etc.) y, a diferencia de muchos otros archivos jar / zip, admite archivos zip nesteds (zip dentro de zip, jar dentro de jar, etc.) hasta profundidad ilimitada.

Un poco tarde para la fiesta, pero sin embargo …

He estado usando JarBrowser para encontrar en qué jar está presente una clase en particular. Tiene una GUI fácil de usar que le permite navegar a través del contenido de todos los flasks en la ruta seleccionada.

El siguiente script te ayudará

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

Este funciona bien en MinGW (entorno windows bash) ~ gitbash

Coloque esta función en su archivo .bashrc en su directorio HOME:

 # 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 es una utilidad de línea de comandos para buscar clases dentro de archivos jar. Yo soy el autor de la utilidad.

Puede ejecutar la utilidad como grepj package.Class my1.jar my2.war my3.ear

Se pueden proporcionar varios archivos jar, ear, war. Para uso avanzado, use find para proporcionar una lista de jarrones para buscar.

Compruebe este complemento para eclipse que puede hacer el trabajo que está buscando.

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

En un entorno Linux, podrías hacer lo siguiente:

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

Donde nombre es el nombre del archivo de clase que está buscando dentro de los archivos jar distribuidos en la jerarquía de directorios enrutados en el directorio_base .

Puede usar locate y grep :

 locate jar | xargs grep 'my.class' 

Asegúrese de ejecutar updatedb antes de usar locate .

Usa esto … puedes encontrar cualquier archivo en classpath … garantizado …

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

En eclipse puedes usar el antiguo pero todavía útil plugin jarsearch