¿Cómo descompilar un archivo Jar completo? [cerrado]

¿Alguien sabe de un descompilador gratuito que pueda descompilar un archivo Jar completo en lugar de una sola clase? Tengo un problema con las subclases como name $ 1.class name $ 2.class name.class

2009: JavaDecompiler puede hacer un buen trabajo con un jar: desde 0.2.5, se muestran todos los archivos, en archivos JAR.

Consulte también la pregunta "¿Cómo" descompilo "los archivos de clase Java? .

Sin embargo, el JD-Eclipse no parece haber cambiado desde finales de 2009 (ver Cambios ).
Por lo tanto, su integración con el último Eclipse (3.8, 4.2+) podría ser problemática.

JD-Core se mantiene activamente.

Ambos son el resultado del fantástico trabajo de (usuario SO) Emmanuel Dupuy .

2018: una opción más moderna, mencionada en los comentarios de David Kennedy Araujo :

JetBrains / intellij-community / plugins / java-decompiler / engine

Fernflower es el primer descompilador analítico realmente funcional para Java y probablemente para un lenguaje de programación de alto nivel en general.

java -jar fernflower.jar [-<option>=<value>]* [<source>]+ <destination>

java -jar fernflower.jar -hes=0 -hdc=0 c:\Temp\binary\ -e=c:\Java\rt.jar c:\Temp\source\

Consulte también Cómo descompilar en archivos java intellij idea para un comando que funciona con IntelliJ IDEA reciente.

En primer lugar, vale la pena recordar que todos los archivos de Java ( .jar/ .war/ etc ...) son básicamente .ziparchivos sofisticados , con algunos manifiestos y metadatos agregados.

En segundo lugar, para abordar este problema, personalmente uso varias herramientas que manejan este problema en todos los niveles:

• Jad + Jadclipse mientras trabajaba en IDE para descompilar.classarchivos
• WinRAR , mi herramienta de compresión favorita es compatible de forma nativa con archivos Java (nuevamente, vea el primer párrafo).
• Más allá de Comparar , mi herramienta de diferencias favorita, cuando está configurada correctamente, puede hacer comparaciones sobre la marcha entre cualquier archivo, inclusojars. Vale la pena intentarlo.

La ventaja de todo lo mencionado anteriormente es que no necesito tener ninguna otra herramienta externa que satura mi entorno de trabajo. Todo lo que pueda necesitar de uno de esos archivos se puede manejar dentro de mi IDE o diferir con otros archivos de forma nativa.

Si tiene un bash shell y jad:

JAR=(your jar file name)
unzip -d $JAR.tmp $JAR
pushd $JAR.tmp
for f in `find . -name '*.class'`; do
    jad -d $(dirname $f) -s java -lnc $f
done
popd

Podría estar un poco, muy poco con eso, pero debería funcionar más o menos como se anuncia. Debería terminar $JAR.tmpconteniendo sus archivos descompilados.

He tenido un éxito razonable con una herramienta llamada (frustrantemente) " JD: Java Decompiler ".

Lo he encontrado mejor que la mayoría de los descompiladores cuando se trata de clases compiladas para Java 5 y superior . Desafortunadamente, todavía puede tener algunos contratiempos donde JAD normalmente tendría éxito.

Algo como:

jar -xf foo.jar && find . -iname "*.class" | xargs /opt/local/bin/jad -r

¿tal vez?

Inserte lo siguiente en decompile.jar.sh

# Usage: decompile.jar.sh some.jar [-d]

# clean target folders
function clean_target {
  rm -rf $unjar $src $jad_log
}

# clean all debug stuff
function clean_stuff {
  rm -rf $unjar $jad_log
}

# the main function
function work {
  jar=$1
  unjar=`basename $jar.unjar`
  src=`basename $jar.src`
  jad_log=jad.log

  clean_target

  unzip -q $jar -d $unjar
  jad -d $src -ff -r -lnc -o -s java $unjar/**/*.class > $jad_log 2>&1

  if [ ! $debug ]; then
    clean_stuff
  fi

  if [ -d $src ] 
    then
      echo "$jar has been decompiled to $src"
    else
      echo "Got some problems check output or run in debug mode"
  fi
}

function usage {
  echo "This script extract and decompile JAR file"
  echo "Usage: $0 some.jar [-d]"
  echo "    where: some.jar is the target to decompile"
  echo "    use -d for debug mode"
}

# check params
if [ -n "$1" ]
  then
    if [ "$2" == "-d" ]; then
      debug=true
      set -x
    fi
    work $1
  else
    usage
fi

• chmod + x decomplie.jar.sh // ejecutable
• ln -s ./decomplie.jar.s / usr / bin / dj

Listo para usar, solo escriba dj your.jary obtendrá una your.jar.srccarpeta con las fuentes. Use la -dopción para el modo de depuración.

Un archivo jar es solo un archivo zip con extensión jar. Debería poder descomprimir (winzip) un jar como un archivo zip.

Lo extrae y luego usa jad contra el directorio.

Nota: Esta solución solo funciona para usuarios de Mac y * nix.

También intenté encontrar a Jad sin suerte. Mi solución rápida fue descargar MacJad que contiene jad. Una vez que lo haya descargado, puede encontrar jad en [where-you-download-macjad] / MacJAD / Contents / Resources / jad.