java - for - no hay ningún atributo de manifiesto principal en spring boot

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

Question

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

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

Answer 1

Unix

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

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

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 (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 contiene IdentityHashingStrategy :

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

Si el JAR podría estar en cualquier parte del sistema y el comando de 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 directorio 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 - loop en todos los archivos JAR, atravesando recursivamente directorios; almacenar el nombre del archivo en% G.
2. @jar -tvf "%G" | - ejecute el comando Java Archive para enumerar todos los nombres de archivos dentro del archivo dado y escriba los resultados en la salida estándar; El símbolo @ suprime la impresión de la invocación del comando.
3. find "ClassName" > NUL - busque la entrada estándar, 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 - si ERRORLEVEL no es cero, escriba el nombre del archivo de almacenamiento de Java en la salida estándar (la consola).

Web

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

Answer 2

Éste funciona bien en MinGW (entorno de 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
}

Answer 3

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

Answer 4

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

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

Answer 5

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

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

Answer 6

El script de user1207523 funciona bien para mí. Aquí hay una variante que busca archivos jar de forma recusiva 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

Answer 7

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

Answer 8

En un entorno Linux, puedes 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 tarros distribuidos en la jerarquía de directorios enraizados en base_dir .

Answer 9

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 lista el jar y la clase si se encuentra, si lo desea, puede dar ls -1 * .jar o entrada a xargs con el comando find HTH Someone.

Answer 10

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

Answer 11

No estoy seguro de por qué los scripts aquí nunca me han funcionado. Esto funciona:

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

Answer 12

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

}

Answer 13

Para agregar 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/

Answer 14

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, incluso más sencillo,

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

Answer 15

Para localizar frascos que coincidan con una cadena dada:

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

Answer 16

Puedes encontrar una clase en un directorio lleno de jars con un poco de shell:

Buscando 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

Answer 17

Puedes usar locate y grep :

locate jar | xargs grep ''my.class''

Asegúrese de ejecutar updatedb antes de usar locate .

Answer 18

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 <directorio de nivel superior que contiene archivos jar> <nombre de clase para buscar>

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 prefiero ver la salida de grep también para poder usar nombres de clase parciales y averiguar el correcto de la lista de salida mostrada.

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

Answer 19

Siempre he usado esto en Windows y ha funcionado excepcionalmente bien.

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

findstr.exe viene estándar con Windows y los parámetros:

• / s = recursivamente
• / m = imprimir 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.

Answer 20

Siguiendo guión te ayudará

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

Answer 21

Solo use la utilidad FindClassInJars, 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/

Answer 22

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

Answer 23

Un poco tarde para la fiesta, pero sin embargo ...

He estado usando JarBrowser para encontrar en qué tarro 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 archivos en la ruta seleccionada.

Answer 24

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.

Answer 25

Una solución de 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

Answer 26

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

}

Answer 27

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

Admite los archivos comprimidos / archivados más comunes (jar, zip, tar, tar.gz, etc.) y, a diferencia de muchos otros buscadores de jar / zip, admite archivos zip anidados (zip dentro de zip, jar dentro de jar, etc.) hasta una profundidad ilimitada.

Answer 28

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

Múltiples jarras, orejas, archivos de guerra pueden ser proporcionados. Para uso avanzado, busque para obtener una lista de los frascos que se deben buscar.

Answer 29

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

Answer 30

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