JavaJive

English | 简体中文 | Website

Un toolkit Java portabile, in puro Go — estratto e ridotto da yaklang — che fa tre cose e nient'altro:

• Decompilare — .class / .jar / .war / .zip → codice sorgente Java leggibile.
• Analizzare le classi — ispezionare la struttura di un file .class (constant pool, campi, metodi, versione, flag di accesso).
• (De)serializzare — analizzare e rimarshalare il formato wire della serializzazione Java (ObjectStream) con fedeltà a livello di byte, e convertirlo da/verso JSON.

Progettato per portabilità e integrazione:

• Puro Go, binario singolo — nessun JDK, nessun cgo, nessun runtime ANTLR, nessuna libreria nativa. Cross-compila per linux / macOS / windows su amd64 e arm64.
• Un solo import — un pacchetto facade unificato javajive racchiude tutte e tre le funzionalità; i sotto-pacchetti restano disponibili per usi avanzati.
• CLI di prima classe — sottocomandi decompile, classinfo e serial, basati sulla libreria standard.
• Cross-testato contro un JDK reale — la CI compila .class / .jar reali e blob serializzati dal JDK con javac/java, poi verifica JavaJive contro di essi (vedi HARNESS-WORKFLOW.md).
• Grafo delle dipendenze ridotto — utils / codec / log / go-funk sono reimplementati come un core internal/ minimale e autosufficiente.

Validazione della v0.4.0

Il completo audit differenziale su 38 JAR registra zero regressioni rispetto alla baseline fissata: tutti i 20 JAR precedentemente compilabili senza errori sono mantenuti e 26 ora compilano completamente. I difetti della baseline e 4 stub di metodi esistenti restano visibili. Vedi i risultati per-JAR e la riproduzione.

250 round trip semantici isolati registrano separatamente compilazione, verifica JVM, stub e uguaglianza a runtime; le classi applicative originali sono assenti dai classpath ricostruiti. La CI esegue l'audit semantico su JDK 17 e 21, il confronto storico completo, e le matrici OS/Go e race. Questi controlli non provano l'equivalenza di ogni metodo di libreria. Vedi l'implementazione e i confini rimanenti.

Benchmark storici (v0.3.0)

Le seguenti cifre sono state riportate per la v0.3.0 il 2026-09-05. Non sono risultati di accettazione della versione corrente né prova di equivalenza comportamentale.

Misurati su 34 jar reali (18.759 unità appiattite) tramite decompile → ricompilazione con javac --release 8 → repackage → verifica JVM:

• Tasso di unità pulite al 100% — 18.759 / 18.759 unità appiattite (Outer$Inner.java) ricompilano con zero errori javac, e 0 errori di sintassi su tutti i 34 jar (un'asserzione rigida imposta dalla CI, così nessun errore di tipo può nascondersi dietro un fallimento del lexer).
• Tutte le 34 librerie completano il round-trip — decompile → ricompilazione → repackage → verifica esterna JVM -Xverify:all per-classe superata end-to-end (il codec è identico byte per byte al jar originale sotto un differenziale di chiamate). Bloccato in provenClean.
• 14 / 14 algoritmi self-hosted (MD5 · SHA-256 · CRC32 · quicksort · Base64 · HeapSort · KMP · SwitchFSM · TryFinally · UnionFind · DiamondTryCatch · DiamondTryFinally · ForContinue · ComputeIfAbsent) completano il round-trip byte per byte.
• #1 in un confronto equo a 3 vie sul set originale di 8 jar — tasso di unità pulite 100% contro Vineflower 1.10.1 (90,8%) e CFR 0.152 (79,8%); vincendo su tutti gli 8 jar contro entrambi.

Vedi BENCHMARK.md per la metodologia completa, le tabelle per-jar e i comandi di riproduzione.

Installazione

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

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

Oppure compila dai sorgenti:

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

Richiede 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

Libreria

Usa il pacchetto facade unificato — un solo import copre tutte e tre le funzionalità:

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 unificata