JavaJive

English | 简体中文 | Website

Un kit de herramientas Java portátil y puro en Go — extraído y recortado de yaklang — que hace tres cosas y nada más:

• Decompilar — .class / .jar / .war / .zip → código fuente Java legible.
• Analizar clases — inspeccionar la estructura de un archivo .class (pool de constantes, campos, métodos, versión, flags de acceso).
• (De)serializar — analizar y volver a serializar el formato de cable de la serialización Java (ObjectStream) con fidelidad de bytes, y convertirlo a/desde JSON.

Diseñado para portabilidad e integración:

• Go puro, binario único — sin JDK, sin cgo, sin runtime de ANTLR, sin bibliotecas nativas. Compilación cruzada para linux / macOS / windows en amd64 y arm64.
• Una sola importación — un paquete fachada unificado javajive envuelve las tres capacidades; los subpaquetes siguen disponibles para uso avanzado.
• CLI de primera clase — subcomandos decompile, classinfo y serial, construidos sobre la biblioteca estándar.
• Probado de forma cruzada contra un JDK real — CI compila .class / .jar reales y blobs serializados por el JDK con javac/java, y luego verifica JavaJive contra ellos (ver HARNESS-WORKFLOW.md).
• Grafo de dependencias recortado — utils / codec / log / go-funk están reimplementados como un núcleo internal/ mínimo y autocontenido.

Validación de v0.4.0

La auditoría diferencial completa de 38 JAR registra cero regresiones contra la línea base fija: los 20 JAR previamente compilables sin errores se conservan y 26 ahora compilan en su totalidad. Los defectos de la línea base y 4 stubs de métodos existentes permanecen visibles. Ver los resultados por JAR y reproducción.

250 round trips semánticos aislados registran compilación, verificación de la JVM, stubs e igualdad en tiempo de ejecución por separado; las clases de la aplicación original están ausentes de los classpaths reconstruidos. CI ejecuta la auditoría semántica en JDK 17 y 21, la comparación histórica completa, y las matrices de OS/Go y de race. Estas comprobaciones no demuestran la equivalencia de todos los métodos de las bibliotecas. Ver la implementación y límites restantes.

Benchmarks históricos (v0.3.0)

Las siguientes cifras se reportaron para v0.3.0 el 2026-09-05. No son resultados de aceptación de la versión actual ni prueba de equivalencia de comportamiento.

Medido en 34 jars del mundo real (18,759 unidades aplanadas) mediante decompile → recompilación con javac --release 8 → reempaquetado → verificación de la JVM:

• Tasa de unidades limpias del 100% — 18,759 / 18,759 unidades aplanadas (Outer$Inner.java) recompilan con cero errores de javac, y 0 errores de sintaxis en los 34 jars (una aserción estricta aplicada por CI, de modo que ningún error de tipo puede ocultarse tras un fallo del lexer).
• Las 34 bibliotecas completan el round-trip — decompile → recompilar → reempaquetar → verificación externa por clase con -Xverify:all de la JVM pasa de extremo a extremo (el codec es idéntico byte a byte al jar original bajo un diferencial de llamadas). Fijado en provenClean.
• 14 / 14 algoritmos autoalojados (MD5 · SHA-256 · CRC32 · quicksort · Base64 · HeapSort · KMP · SwitchFSM · TryFinally · UnionFind · DiamondTryCatch · DiamondTryFinally · ForContinue · ComputeIfAbsent) hacen round-trip byte a byte.
• #1 en una comparación justa de 3 vías sobre el conjunto original de 8 jars — tasa de unidades limpias 100% vs Vineflower 1.10.1 (90.8%) y CFR 0.152 (79.8%); ganando los 8 jars frente a ambos.

Ver BENCHMARK.md para la metodología completa, tablas por jar y comandos de reproducción.

Instalación

# CLI
go install github.com/yaklang/javajive/cmd/javajive@latest

# Library
go get github.com/yaklang/javajive@latest

O compilar desde el código fuente:

git clone https://github.com/yaklang/javajive
cd javajive
go build -o javajive ./cmd/javajive

Requiere Go 1.22+.

CLI

javajive <command> [arguments]

Commands:
  decompile   decompile .class/.jar/.war/.zip or a directory into Java source
  classinfo   print the structure of a .class file (version, fields, methods)
  serial      Java serialization tools (subcommands: tojson, fromjson)
  version     print the version
  help        show help

decompile

# Single class: prints to stdout by default, or -o to write a file.
javajive decompile Foo.class
javajive decompile Foo.class -o Foo.java

# Archive: defaults to a "<input>.src" directory, or -o to choose one.
javajive decompile app.jar
javajive decompile app.war -o ./app-src

# Directory: recursively decompile .class files (requires -o output dir).
javajive decompile ./classes -o ./src

classinfo

javajive classinfo Foo.class

class:      InvisibleAnnoSeed
super:      java/lang/Object
version:    61.0
access:     public
constants:  18

fields (0):

methods (2):
   <init>()V
   run()I

serial

# Serialized binary -> JSON. (-hex: input is a hex string, -: read from stdin)
javajive serial tojson dump.bin
printf 'aced000574000568656c6c6f' | javajive serial tojson -hex -

# JSON -> serialized binary. (default prints hex; with -o writes raw bytes)
javajive serial fromjson dump.json -o out.bin
javajive serial fromjson dump.json          # prints hex

Biblioteca

Usa el paquete fachada unificado — una sola importación cubre las tres capacidades:

import "github.com/yaklang/javajive"

// Decompile a single class, or a whole archive into a directory.
src, err := javajive.Decompile(classBytes)
err = javajive.DecompileArchive("app.jar", "app-src")

// Inspect class structure.
obj, err := javajive.ParseClass(classBytes)
_ = obj.GetClassName()

// Java serialization: binary -> JSON -> binary.
objs, _ := javajive.ParseSerialized(raw)          // or ParseSerializedHex(hexStr)
jsonBytes, _ := javajive.SerializedToJSON(objs...)
restored, _ := javajive.SerializedFromJSON(jsonBytes)
out := javajive.MarshalSerialized(restored...)

API unificada