Apa versi javac yang membangun toples saya?

Bagaimana saya tahu versi Java compiler apa yang digunakan untuk membuat toples? Saya punya file jar, dan itu bisa dibangun di salah satu dari tiga JDK. Kami perlu tahu persis yang mana, sehingga kami dapat memeriksa kompatibilitasnya. Apakah versi kompiler tertanam di suatu tempat di file kelas atau toples?

Anda tidak bisa membedakannya dari file JAR itu sendiri.

Unduh hex editor dan buka salah satu file kelas di dalam JAR dan lihat byte offset 4 hingga 7. Informasi versi sudah ada di dalamnya.

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

Catatan: Seperti disebutkan dalam komentar di bawah,

byte tersebut memberi tahu Anda versi apa yang telah dikompilasi kelas, bukan versi apa yang dikompilasi.

A jarhanyalah sebuah wadah. Ini adalah arsip file ā la tar. Meskipun jarmungkin memiliki informasi menarik yang terkandung dalam hierarki META-INF itu, ia tidak memiliki kewajiban untuk menentukan vintage kelas di dalamnya. Untuk itu, seseorang harus memeriksa classfile - file di dalamnya.

Seperti yang disebutkan oleh Peter Lawrey dalam komentar terhadap pertanyaan awal, Anda tidak dapat selalu mengetahui rilis JDK mana yang membangun classfile yang diberikan , tetapi Anda dapat mengetahui versi kelas kode byte dari classfile yang terkandung dalam a jar.

Ya, ini agak menyebalkan, tetapi langkah pertama adalah mengekstraksi satu atau lebih kelas dari jar. Sebagai contoh:

$ jar xf log4j-1.2.15.jar

Di Linux, Mac OS X atau Windows dengan Cygwin terinstal, perintah file (1) tahu versi kelasnya.

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

Atau sebagai alternatif, menggunakan javapdari JDK sebagai @ jikes.thunderbolt dengan tepat menunjukkan:

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

Dan jika Anda terdegradasi ke Windowslingkungan tanpa salah satu fileataugrep

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

FWIW, saya akan setuju bahwa javapakan memberi tahu lebih banyak tentang classfile yang diberikan daripada pertanyaan asli yang diajukan.

Bagaimanapun, versi kelas yang berbeda, misalnya:

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

Nomor utama versi kelas sesuai dengan versi Java JDK berikut:

• 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

Berikut adalah cara Java untuk menemukan informasi ini.

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

Sebagai contoh:
> javap -v Application | findstr major   major version: 51

Tidak perlu membongkar JAR (jika salah satu nama kelas diketahui atau dicari misalnya menggunakan 7zip), maka pada Windows berikut ini sudah cukup:

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

Java compiler ( javac) tidak membuat toples, ia menerjemahkan file Java ke file kelas. Alat Jar ( jar) membuat toples yang sebenarnya. Jika tidak ada manifes khusus yang ditentukan, manifes default akan menentukan versi JDK mana yang digunakan untuk membuat toples.

Karena saya perlu menganalisis guci gemuk saya tertarik pada versi setiap kelas individu dalam file jar. Karenanya saya mengambil pendekatan Joe Liversedge https://stackoverflow.com/a/27877215/1497139 dan menggabungkannya dengan https://stackoverflow.com/a/3313839/1497139 tabel versi nomor kelas David untuk membuat skrip bash jarv untuk menampilkan versi semua file kelas dalam file jar.

pemakaian

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

Contoh

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 script 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 

Anda dapat menemukan versi kompiler Java dari file .class menggunakan Hex Editor.

Langkah 1: Ekstrak file .class dari file jar menggunakan zip extractor

langkah 2: buka file .class dengan hex editor. (Saya telah menggunakan notepad ++ hex editor plugin. Plugin ini membaca file sebagai biner dan menunjukkannya dalam hex) Anda dapat melihat di bawah ini.

Indeks 6 dan 7 memberikan nomor versi utama dari format file kelas yang digunakan. https://en.wikipedia.org/wiki/Java_class_file

Java SE 11 = 55 (0x37 hex)

Java SE 10 = 54 (hex 0x36)

Java SE 9 = 53 (hex 0x35)

Java SE 8 = 52 (hex 0x34),

Java SE 7 = 51 (0x33 hex),

Java SE 6.0 = 50 (hex 0x32),

Java SE 5.0 = 49 (0x31 hex),

JDK 1.4 = 48 (hex 0x30),

JDK 1.3 = 47 (hex 0x2F),

JDK 1.2 = 46 (hex 0x2E),

JDK 1.1 = 45 (hex 0x2D).

Anda dapat memberi tahu versi biner Java dengan memeriksa 8 byte pertama (atau menggunakan aplikasi yang bisa).

Kompiler itu sendiri, setahu saya, tidak memasukkan tanda tangan pengenal apa pun. Saya tidak dapat menemukan hal seperti itu dalam format file spesifikasi kelas VM .

The kode diposting oleh Owen dapat memberitahu Anda informasi yang disebutkan oleh sejumlah jawaban lain di sini:

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
    }
}

Lihat juga ini dan situs ini . Saya akhirnya memodifikasi kode Produk Pikiran dengan cepat untuk memeriksa untuk apa masing-masing dependensi saya dikompilasi.

Pengembang dan administrator yang menjalankan Bash mungkin menemukan fungsi kenyamanan ini bermanfaat:

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."
}

Anda dapat menempelkannya untuk penggunaan satu kali atau menambahkannya ke ~/.bash_aliasesatau ~/.bashrc. Hasilnya terlihat seperti:

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

dan

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

EDIT Seperti yang ditunjukkan oleh jackrabbit , Anda tidak dapat 100% mengandalkan manifes untuk memberi tahu Anda sesuatu yang bermanfaat. Jika ya, maka Anda bisa mengeluarkannya di shell UNIX favorit Anda dengan 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

.Jar ini tidak memiliki apa pun yang berguna dalam manifes tentang kelas yang ada.

One liner (Linux)

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

Ini mencetak konten MANIFEST.MFfile ke stdout (mudah-mudahan ada satu di file jar Anda :)

Bergantung pada apa yang membangun paket Anda, Anda akan menemukan versi Created-Byatau Build-Jdkkunci JDK .

Setiap file kelas memiliki nomor versi yang disematkan untuk level kode byte yang digunakan JVM untuk melihat apakah itu suka potongan kode byte tertentu atau tidak. Ini adalah 48 untuk Java 1.4, 49 untuk Java 1.5 dan 50 untuk Java 6.

Ada banyak kompiler yang dapat menghasilkan kode byte di setiap level, javac menggunakan opsi "-target" untuk menunjukkan level kode byte mana yang akan dihasilkan, dan Java 6 javac dapat menghasilkan kode byte setidaknya 1,4, 1,5 dan 6. Saya tidak percaya bahwa kompiler memasukkan apa pun yang dapat mengidentifikasi kompiler itu sendiri yang saya pikir Anda minta. Kompiler Eclipse juga semakin banyak digunakan, karena ini adalah satu toples yang dapat dijalankan dengan JRE saja.

Dalam file jar biasanya ada banyak kelas, dan masing-masingnya independen, jadi Anda perlu menyelidiki semua kelas di jar untuk memastikan tentang karakteristik konten.

Menindaklanjuti jawaban @ David J. Liszewski, saya menjalankan perintah berikut untuk mengekstrak manifes file jar di Ubuntu:

# 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

Banyak kali, Anda mungkin melihat file jar keseluruhan, atau file perang yang berisi banyak file jar selain diri mereka sendiri.

Karena saya tidak ingin memeriksa setiap kelas dengan tangan, saya menulis program java untuk melakukannya:

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

Meskipun ini tidak mengatakan apa yang dikompilasi dengan kelas, itu menentukan apa JDK akan dapat memuat kelas, yang mungkin adalah apa yang Anda ingin mulai dengan.

Untuk memperluas jawaban Jonathon Faust dan McDowell : Jika Anda menggunakan sistem berbasis * nix, Anda dapat menggunakan od(salah satu program Unix ¹ yang paling awal yang seharusnya tersedia secara praktis di mana saja) untuk meminta .classfile pada tingkat biner:

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

Ini akan menampilkan nilai integer yang sudah dikenal, misalnya 50untuk Java 5, 51untuk , Java 6dan seterusnya.

¹ Kutipan dari https://en.wikipedia.org/wiki/Od_(Unix)

Saya juga menulis skrip bash saya sendiri untuk membuang versi Java yang diperlukan oleh semua stoples yang dilewati di baris perintah ... Tambang saya agak kasar, tetapi bekerja untuk saya ;-)

contoh penggunaan

$ 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

Anda dapat dengan mudah melakukan ini di baris perintah menggunakan proses berikut:

Jika Anda tahu salah satu nama kelas dalam toples, Anda dapat menggunakan perintah berikut:

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

contoh:

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

Output:

    major version: 51

Referensi cepat :

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: jika Anda tidak tahu nama classnya, Anda dapat dengan mudah melakukan ini dengan menggunakan salah satu decompiler jar atau dengan hanya menggunakan perintah berikut untuk mengekstrak file jar:

jar xf myFile.jar

Anda memeriksa di file Manifest toples:

Manifest-Version: 1.0 Created-By: 1.6.0 (IBM Corporation)

Di Windows lakukan hal berikut:

1. Unzip atau ekstrak file JAR menggunakan perintah WinZip / Java JAR.
2. Seret dan Jatuhkan salah satu file kelas ke proyek Eclipse Java Anda.
3. Buka file kelas.

Sekarang Eclipse akan menampilkan versi utama dan minor yang tepat.

Saya membuat skrip bash kecil (di github) berdasarkan saran Davids menggunakan fileperintah