Welche Version von Javac hat mein Glas gebaut?

Wie kann ich feststellen, mit welcher Version des Java-Compilers ein JAR erstellt wurde? Ich habe eine JAR-Datei, die in einem von drei JDKs erstellt werden könnte. Wir müssen genau wissen, welche, damit wir die Kompatibilität zertifizieren können. Ist die Compilerversion irgendwo in den Klassendateien oder im JAR eingebettet?

Sie können es nicht unbedingt anhand der JAR-Datei selbst erkennen.

Laden Sie einen Hex-Editor herunter, öffnen Sie eine der Klassendateien in der JAR und sehen Sie sich die Byte-Offsets 4 bis 7 an. Die Versionsinformationen sind integriert.

http://en.wikipedia.org/wiki/Java_class_file

Hinweis: Wie im Kommentar unten erwähnt,

Diese Bytes geben an, für welche Version die Klasse kompiliert wurde, nicht für welche Version sie kompiliert wurde.

A jarist nur ein Behälter. Es ist ein Dateiarchiv à la tar. Während a jarmöglicherweise interessante Informationen in seiner META-INF- Hierarchie enthält, ist es nicht verpflichtet, den Jahrgang der Klassen in seinem Inhalt anzugeben. Dazu muss man die classdarin enthaltenen Dateien untersuchen .

Wie Peter Lawrey im Kommentar zur ursprünglichen Frage erwähnt hat, können Sie nicht unbedingt wissen, welche JDK-Version eine bestimmte classDatei erstellt hat, aber Sie können die Bytecode-Klassenversion der classin a enthaltenen Datei herausfinden jar.

Ja, das ist ein bisschen scheiße, aber der erste Schritt besteht darin, eine oder mehrere Klassen aus dem zu extrahieren jar. Beispielsweise:

$ jar xf log4j-1.2.15.jar

Unter Linux, Mac OS X oder Windows mit installiertem Cygwin kennt der Befehl file (1) die Klassenversion.

$ file ./org/apache/log4j/Appender.class
./org/apache/log4j/Appender.class: compiled Java class data, version 45.3

Alternativ kann die Verwendung javapaus dem JDK als @ jikes.thunderbolt treffend darauf hinweisen:

$ javap -v ./org/apache/log4j/Appender.class | grep major
 major version: 45

Und wenn Sie in eine WindowsUmgebung ohne entweder fileoder verbannt sindgrep

> javap -v ./org/apache/log4j/Appender.class | findstr major
 major version: 45

FWIW, ich stimme zu, dass dies javapviel mehr über eine bestimmte classDatei aussagt als die ursprünglich gestellte Frage.

Wie auch immer, eine andere Klassenversion, zum Beispiel:

$ file ~/bin/classes/P.class
/home/dave/bin/classes/P.class: compiled Java class data, version 50.0

Die Hauptnummer der Klassenversion entspricht den folgenden Java JDK-Versionen:

• 45.3 = Java 1.1
• 46 = Java 1.2
• 47 = Java 1.3
• 48 = Java 1.4
• 49 = Java 5
• 50 = Java 6
• 51 = Java 7
• 52 = Java 8
• 53 = Java 9

Hier ist Javas Weg, um diese Informationen zu finden.

Windows: javap -v <class> | findstr major
Unix:javap -v <class> | grep major

Beispielsweise:
> javap -v Application | findstr major   major version: 51

Es ist nicht erforderlich, die JAR zu entpacken (wenn einer der Klassennamen bekannt ist oder beispielsweise mit 7zip nachgeschlagen wird), sodass unter Windows Folgendes ausreichen würde:

javap -cp log4j-core-2.5.jar -verbose org.apache.logging.log4j.core.Logger | findstr major

Der Java-Compiler ( javac) erstellt keine Jars, sondern übersetzt Java-Dateien in Klassendateien. Das Jar-Tool ( jar) erstellt die eigentlichen Gläser. Wenn kein benutzerdefiniertes Manifest angegeben wurde, gibt das Standardmanifest an, welche Version des JDK zum Erstellen des JAR verwendet wurde.

Da ich fette Gläser analysieren musste, interessierte ich mich für die Version jeder einzelnen Klasse in einer Glasdatei. Daher habe ich den Joe Liversedge-Ansatz https://stackoverflow.com/a/27877215/1497139 gewählt und ihn mit David J. Liszewskis https://stackoverflow.com/a/3313839/1497139 Klassennummer-Versionstabelle kombiniert , um ein Bash-Skript zu erstellen jarv, um die Versionen aller Klassendateien in einer JAR-Datei anzuzeigen.

Verwendung

usage: ./jarv jarfile
 -h|--help: show this usage

Beispiel

jarv $Home/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar

java 1.4 org.apache.log4j.Appender
java 1.4 org.apache.log4j.AppenderSkeleton
java 1.4 org.apache.log4j.AsyncAppender$DiscardSummary
java 1.4 org.apache.log4j.AsyncAppender$Dispatcher
...

Bash-Skript jarv

#!/bin/bash
# WF 2018-07-12
# find out the class versions with in jar file
# see https://stackoverflow.com/questions/3313532/what-version-of-javac-built-my-jar

# uncomment do debug
# set -x

#ansi colors
#http://www.csc.uvic.ca/~sae/seng265/fall04/tips/s265s047-tips/bash-using-colors.html
blue='\033[0;34m'  
red='\033[0;31m'  
green='\033[0;32m' # '\e[1;32m' is too bright for white bg.
endColor='\033[0m'

#
# a colored message 
#   params:
#     1: l_color - the color of the message
#     2: l_msg - the message to display
#
color_msg() {
  local l_color="$1"
  local l_msg="$2"
  echo -e "${l_color}$l_msg${endColor}"
}

#
# error
#
#   show an error message and exit
#
#   params:
#     1: l_msg - the message to display
error() {
  local l_msg="$1"
  # use ansi red for error
  color_msg $red "Error: $l_msg" 1>&2
  exit 1
}

#
# show the usage
#
usage() {
  echo "usage: $0 jarfile"
  # -h|--help|usage|show this usage
  echo " -h|--help: show this usage"
  exit 1 
}

#
# showclassversions
#
showclassversions() {
  local l_jar="$1"
  jar -tf "$l_jar" | grep '.class' | while read classname
  do
    class=$(echo $classname | sed -e 's/\.class$//')
    class_version=$(javap -classpath "$l_jar" -verbose $class | grep 'major version' | cut -f2 -d ":" | cut -c2-)
    class_pretty=$(echo $class | sed -e 's#/#.#g')
    case $class_version in
      45.3) java_version="java 1.1";;
      46) java_version="java 1.2";;
      47) java_version="java 1.3";;
      48) java_version="java 1.4";;
      49) java_version="java5";;
      50) java_version="java6";;
      51) java_version="java7";;
      52) java_version="java8";;
      53) java_version="java9";;
      54) java_version="java10";;
      *) java_version="x${class_version}x";;
    esac
    echo $java_version $class_pretty
  done
}

# check the number of parameters
if [ $# -lt 1 ]
then
  usage
fi

# start of script
# check arguments
while test $# -gt 0
do
  case $1 in
    # -h|--help|usage|show this usage
    -h|--help) 
      usage
      exit 1
      ;;
    *)
     showclassversions "$1"
  esac
  shift
done 

Sie können die Java-Compilerversion aus .class-Dateien mit einem Hex-Editor finden.

Schritt 1: Extrahieren Sie .class-Dateien mit einem Zip-Extraktor aus der JAR-Datei

Schritt 2: Öffnen Sie die .class-Datei mit einem Hex-Editor. (Ich habe das Notepad ++ Hex-Editor-Plugin verwendet. Dieses Plugin liest die Datei als Binärdatei und zeigt sie in Hex an.) Sie können unten sehen.

Die Indizes 6 und 7 geben die Hauptversionsnummer des verwendeten Klassendateiformats an. https://en.wikipedia.org/wiki/Java_class_file

Java SE 11 = 55 (0x37 hex)

Java SE 10 = 54 (0x36 hex)

Java SE 9 = 53 (0x35 hex)

Java SE 8 = 52 (0x34 hex),

Java SE 7 = 51 (0x33 hex),

Java SE 6.0 = 50 (0x32 hex),

Java SE 5.0 = 49 (0x31 hex),

JDK 1,4 = 48 (0 × 30 hex),

JDK 1.3 = 47 (0x2F hex),

JDK 1,2 = 46 (0 × 2E hex),

JDK 1.1 = 45 (0x2D hex).

Sie können die Java-Binärversion erkennen, indem Sie die ersten 8 Bytes überprüfen (oder eine App verwenden , die dies kann).

Der Compiler selbst fügt meines Wissens keine identifizierende Signatur ein. Ich kann so etwas sowieso nicht im Format der Datei- VM-Spezifikationsklasse erkennen .

Der von Owen gepostete Code kann Ihnen die Informationen mitteilen, die in einer Reihe anderer Antworten hier erwähnt werden:

public void simpleExample ()
{
    FileInputStream fis = new FileInputStream ("mytest.class");
    parseJavaClassFile ( fis );
}
protected void parseJavaClassFile ( InputStream classByteStream ) throws Exception
{
    DataInputStream dataInputStream = new DataInputStream ( classByteStream );
    magicNumber = dataInputStream.readInt();
    if ( magicNumber == 0xCAFEBABE )
    {
        int minorVer = dataInputStream.readUnsignedShort();
        int majorVer = dataInputStream.readUnsignedShort();
        // do something here with major & minor numbers
    }
}

Siehe auch diese und diese Seite. Am Ende habe ich den Mind Products-Code schnell geändert, um zu überprüfen, wofür jede meiner Abhängigkeiten kompiliert wurde.

Entwickler und Administratoren, die Bash ausführen, finden diese praktischen Funktionen möglicherweise hilfreich:

jar_jdk_version() {
  [[ -n "$1" && -x "`command -v javap`" ]] && javap -classpath "$1" -verbose $(jar -tf "$1" | grep '.class' | head -n1 | sed -e 's/\.class$//') | grep 'major version' | sed -e 's/[^0-9]\{1,\}//'
}

print_jar_jdk_version() {
  local version
  version=$(jar_jdk_version "$1")
  case $version in 49) version=1.5;; 50) version=1.6;; 51) version=1.7;; 52) version=1.8;; esac
  [[ -n "$version" ]] && echo "`basename "$1"` contains classes compiled with JDK version $version."
}

Sie können sie zur einmaligen Verwendung einfügen oder zu ~/.bash_aliasesoder hinzufügen ~/.bashrc. Die Ergebnisse sehen ungefähr so ​​aus:

$ jar_jdk_version poi-ooxml-3.5-FINAL.jar
49

und

$ print_jar_jdk_version poi-ooxml-3.5-FINAL.jar
poi-ooxml-3.5-FINAL.jar contains classes compiled with JDK version 1.5.

BEARBEITEN Wie Jackrabbit betont , können Sie sich nicht zu 100% auf das Manifest verlassen, um Ihnen etwas Nützliches zu sagen. Wenn ja, können Sie es in Ihrer bevorzugten UNIX-Shell herausziehen mit unzip:

$ unzip -pa poi-ooxml-3.5-FINAL.jar META-INF/MANIFEST.MF
Manifest-Version: 1.0
Ant-Version: Apache Ant 1.7.1
Created-By: 11.3-b02 (Sun Microsystems Inc.)
Built-By: yegor
Specification-Title: Apache POI
Specification-Version: 3.5-FINAL-20090928
Specification-Vendor: Apache
Implementation-Title: Apache POI
Implementation-Version: 3.5-FINAL-20090928
Implementation-Vendor: Apache

Diese .jar-Datei enthält im Manifest nichts Nützliches zu den enthaltenen Klassen.

Ein Liner (Linux)

unzip -p mylib.jar META-INF/MANIFEST.MF

Dies druckt den Inhalt der MANIFEST.MFDatei nach stdout (hoffentlich gibt es einen in Ihrer JAR-Datei :)

Je nachdem, was Ihr Paket erstellt hat, finden Sie die JDK-Version in Created-Byoder Build-Jdkkey.

In jede Klassendatei ist eine Versionsnummer für die Bytecode-Ebene eingebettet, anhand derer die JVM prüft, ob sie diesen bestimmten Bytecode-Block mag oder nicht. Dies sind 48 für Java 1.4, 49 für Java 1.5 und 50 für Java 6.

Es gibt viele Compiler, die auf jeder Ebene Bytecode generieren können. Javac verwendet die Option "-target", um anzugeben, welche Bytecode-Ebene generiert werden soll, und Java 6-Javac kann Bytecode für mindestens 1.4, 1.5 und 6 generieren. Ich nicht Ich glaube, der Compiler fügt alles ein, was den Compiler selbst identifizieren kann. Ich denke, Sie fragen danach. Auch der Eclipse-Compiler wird zunehmend verwendet, da es sich um ein einzelnes JAR handelt, das nur mit der JRE ausgeführt werden kann.

In einer JAR-Datei gibt es normalerweise viele Klassen, von denen jede unabhängig ist. Daher müssen Sie alle Klassen in der JAR-Datei untersuchen, um sicherzugehen, welche Eigenschaften der Inhalt hat.

Nach der Antwort von @David J. Liszewski habe ich die folgenden Befehle ausgeführt, um das Manifest der JAR-Datei unter Ubuntu zu extrahieren:

# Determine the manifest file name:
$ jar tf LuceneSearch.jar | grep -i manifest
META-INF/MANIFEST.MF

# Extract the file:
$ sudo jar xf LuceneSearch.jar META-INF/MANIFEST.MF

# Print the file's contents:
$ more META-INF/MANIFEST.MF
Manifest-Version: 1.0
Ant-Version: Apache Ant 1.8.2
Created-By: 1.7.0_25-b30 (Oracle Corporation)
Main-Class: org.wikimedia.lsearch.config.StartupManager

Häufig sehen Sie sich ganze JAR-Dateien oder Kriegsdateien an, die neben sich selbst viele JAR-Dateien enthalten.

Da ich nicht jede Klasse von Hand überprüfen wollte, schrieb ich dazu ein Java-Programm:

https://github.com/Nthalk/WhatJDK

./whatjdk some.war
some.war:WEB-INF/lib/xml-apis-1.4.01.jar contains classes compatible with Java1.1
some.war contains classes compatible with Java1.6

Dies sagt zwar nicht aus, mit was die Klasse kompiliert wurde, bestimmt jedoch, mit welchen JDKs die Klassen geladen werden können. Dies ist wahrscheinlich das, womit Sie beginnen wollten.

So erweitern Sie die Antworten von Jonathon Faust und McDowell : Wenn Sie auf einem * nix-basierten System arbeiten, können Sie od(eines der frühesten Unix-Programme ^1, das praktisch überall verfügbar sein sollte) die .classDatei auf Binärebene abfragen :

od -An -j7 -N1 -t dC SomeClassFile.class

Dies gibt die bekannten ganzzahligen Werte aus, z. B. 50für Java 5, 51für Java 6und so weiter.

¹ Zitat aus https://en.wikipedia.org/wiki/Od_(Unix)

Ich habe auch mein eigenes Bash-Skript geschrieben, um die Java-Version zu sichern, die für alle an der Befehlszeile übergebenen Jars erforderlich ist ... Meins ist etwas rau, funktioniert aber für mich ;-)

Beispiel Verwendung

$ jar_dump_version_of_jvm_required.sh *.jar
JVM VERSION REQUIRED: 46.0, /private/tmp/jars/WEB-INF/lib/json-simple-1.1.jar
JVM VERSION REQUIRED: 49.0, /private/tmp/jars/WEB-INF/lib/json-smart-1.1.1.jar
JVM VERSION REQUIRED: 50.0, /private/tmp/jars/WEB-INF/lib/jsontoken-1.0.jar
JVM VERSION REQUIRED: 50.0, /private/tmp/jars/WEB-INF/lib/jsr166y-1.7.0.jar

jar_dump_version_of_jvm_required.sh

#!/bin/bash

DIR=$(PWD)
function show_help()
{
  ME=$(basename $0)
  IT=$(cat <<EOF

  Dumps the version of the JVM required to run the classes in a jar file

  usage: $ME JAR_FILE

  e.g. 

  $ME myFile.jar    ->  VERSION: 50.0     myFile.jar

  Java versions are:
  54 = Java 10
  53 = Java 9
  52 = Java 8
  51 = Java 7
  50 = Java 6
  49 = Java 5
  48 = Java 1.4
  47 = Java 1.3
  46 = Java 1.2
  45.3 = Java 1.1

EOF
  )
  echo "$IT"
  exit
}

if [ "$1" == "help" ]
then
  show_help
fi
if [ -z "$1" ]
then
  show_help
fi

function unzipJarToTmp()
{
  JAR=$1
  CLASS_FILE=$(jar -tf "$JAR" | grep \.class$ | grep -v '\$' | head -n1 | awk '{print $NF}')
  OUT_FILE="$CLASS_FILE"
  #echo "J=$JAR C=$CLASS_FILE O=$OUT_FILE"
  jar xf "$JAR" "$CLASS_FILE"

  MAJOR=$(javap -v "$OUT_FILE" 2>&1 | grep major | awk -F' ' '{print $3'})
  MINOR=$(javap -v "$OUT_FILE" 2>&1 | grep minor | awk -F' ' '{print $3'})
  if [ -z "$MAJOR" ]
  then
    echo "JVM VERSION REQUIRED: NA as no classes in $JAR"
  else
    echo "JVM VERSION REQUIRED: $MAJOR.$MINOR, $JAR"
  fi
}

# loop over cmd line args
for JAR in "$@"
do
  cd "$DIR"
  JAR_UID=$(basename "$JAR" | sed s/.jar//g)
  TMPDIR=/tmp/jar_dump/$JAR_UID/
  mkdir -p "$TMPDIR"
  JAR_ABS_PATH=$(realpath $JAR)

  cd "$TMPDIR"

  #echo "$JAR_ABS_PATH"
  unzipJarToTmp "$JAR_ABS_PATH"
  #sleep 2
done

Sie können dies einfach über die Befehlszeile mit folgendem Verfahren tun:

Wenn Sie einen der Klassennamen in jar kennen, können Sie den folgenden Befehl verwenden:

javap -cp jarname.jar -verbose packagename.classname | findstr major

Beispiel:

    C:\pathwherejarlocated> javap -cp jackson-databind-2.8.6.jar -verbose com.fasterxml.jackson.databind.JsonMappingException | findstr major

Ausgabe :

    major version: 51

Kurzübersicht :

JDK 1.0 — major version 45 
DK 1.1 — major version 45 
JDK 1.2 — major version 46 
JDK 1.3 — major version 47 
JDK 1.4 — major version 48 
JDK 1.5 — major version 49 
JDK 1.6 — major version 50 
JDK 1.7 — major version 51 
JDK 1.8 — major version 52 
JDK 1.9 — major version 53 

PS: Wenn Sie keinen der Klassennamen kennen, können Sie dies einfach tun, indem Sie einen der JAR-Dekompilierer verwenden oder einfach den folgenden Befehl verwenden, um die JAR-Datei zu extrahieren:

jar xf myFile.jar

Sie checken in der Manifest-Datei des JAR-Beispiels ein:

Manifest-Version: 1.0 Erstellt von: 1.6.0 (IBM Corporation)

Gehen Sie unter Windows wie folgt vor:

1. Entpacken oder extrahieren Sie die JAR-Datei mit dem WinZip / Java-JAR-Befehl.
2. Ziehen Sie eine der Klassendateien per Drag & Drop in Ihr Eclipse Java-Projekt.
3. Öffnen Sie die Klassendatei.

Jetzt zeigt Eclipse die genaue Haupt- und Nebenversion.

Ich erstelle ein kleines Bash-Skript (auf Github) basierend auf Davids Vorschlag mit dem fileBefehl