Unix

Utilice el jar (o unzip -v), grep, y find órdenes.

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

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

Si conoce toda la lista de archivos Java que desea buscar, podría colocarlos todos en el mismo directorio utilizando enlaces (simbólicos).

O use find (sensible a mayúsculas y minúsculas) para encontrar el archivo JAR que contiene un nombre de clase dado:

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

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

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

Si el FRASCO podría estar en cualquier lugar en el sistema y el locate el comando 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 directorio antepasado) 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 - loop sobre todos los archivos JAR, atravesando recursivamente directorios; almacena el nombre del archivo en % G.
2. @jar -tvf "%G" | - ejecutar el Java Comando Archive para listar todos los nombres de archivo dentro del archivo dado, y escribir los resultados en la salida estándar; el símbolo @ suprime la impresión de la invocación del comando.
3. find "ClassName" > NUL - buscar entrada estándar, canalizada desde la salida del comando jar, para el nombre de clase dado; esto establecerá ERRORLEVEL a 1 si hay una coincidencia (de lo contrario 0).
4. && echo %G - iff ERRORLEVEL es distinto de cero, escriba el nombre del archivo de archivo Java en la salida estándar (la consola).

Web

Uso un motor de búsqueda que escanea archivos JAR.

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

grep -l "classname" *.jar

Te da el nombre del frasco

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

}

Para localizar jars 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 recursiva usando find en lugar de una 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 utilizado esto en Windows y su funcionó excepcionalmente bien.

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

Findstr.exe viene de serie con Windows y los parámetros:

• / 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 bash script usando 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é este nuevo camino

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 lo desea puede dar ls -1 *.jar o entrada a xargs con find comando HTH Alguien.

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

Simplemente use FindClassInJars util, es un programa de swing simple, pero útil. Puede consultar 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 scripts aquí nunca han funcionado realmente 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 dado para una clase en particular, puede hacer esto:

ls *.jar | xargs grep -F MyClass

O, aún 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 buscar cadena fija, por lo que no carga el motor de expresiones regulares para cada invocación grep. Si lo necesita, 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 grep, puede redirigirla a /dev / null, pero prefiero ver la salida de grep también para poder usar nombres de clases parciales y averiguar la correcta de una lista de salida mostrada.

El el nombre de la clase puede ser un nombre de clase simple como " String "o un nombre completo como" java.lang.String "

Para añadir otra herramienta... esta es una herramienta muy simple y útil para windows. Un simple archivo exe en el que haga clic, le dará 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 /

Puedes encontrar una clase en un directorio lleno de frascos 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 unzip (o WinZip, o lo que sea) para lograr lo mismo.

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

Es compatible con la mayoría de los archivos comprimidos (jar, zip, tar, tar.gz etc) y a diferencia de muchos otros buscadores jar/zip, admite archivos zip anidados (zip dentro de zip, jar dentro de jar, etc) hasta una 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 interfaz gráfica de usuario fácil de usar que le permite navegar a través del contenido de todos los jars 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 de Windows bash ) ~ gitbash

Ponga esta función en su .archivo bashrc en su directorio PERSONAL:

# 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. Soy el autor de la utilidad.

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

Se pueden proporcionar múltiples archivos jar, ear, war. Para un uso avanzado, use buscar para proporcionar una lista de frascos a buscar.

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

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

En un entorno Linux se puede hacer lo siguiente:

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

Donde nombre es el nombre del archivo de clase que está buscando dentro de los jars distribuidos a través de la jerarquía de directorios arraigados en el base_dir.

Puedes usar locate y grep:

locate jar | xargs grep 'my.class'

Asegúrese de ejecutar updatedb antes de usar locate.

Use esto.. puedes encontrar cualquier archivo en classpath.. garantizar..

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

}

En eclipse puedes usar el plugin antiguo pero aún utilizable jarsearch