Phiên bản nào của javac xây dựng jar của tôi?

Làm thế nào tôi có thể biết phiên bản nào của trình biên dịch Java đã được sử dụng để xây dựng một jar? Tôi có một tệp jar và nó có thể đã được xây dựng trong bất kỳ một trong ba JDK. Chúng ta cần biết chính xác cái nào, vì vậy chúng ta có thể chứng nhận khả năng tương thích. Là phiên bản trình biên dịch được nhúng ở đâu đó trong các tệp lớp hoặc jar?

Bạn không thể nói từ chính tệp JAR.

Tải xuống trình soạn thảo hex và mở một trong các tệp lớp bên trong JAR và xem xét các byte từ 4 đến 7. Thông tin phiên bản được tích hợp sẵn.

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

Lưu ý: Như đã đề cập trong bình luận bên dưới,

các byte đó cho bạn biết phiên bản nào đã được biên dịch FOR, chứ không phải phiên bản nào đã biên dịch nó.

A jarchỉ là một container. Nó là một tập tin lưu trữ ā la tar. Mặc dù jarcó thể có thông tin thú vị trong hệ thống phân cấp META-INF , nhưng nó không có nghĩa vụ phải chỉ định cổ điển của các lớp trong nội dung của nó. Đối với điều đó, người ta phải kiểm traclass tập tin trong đó.

Như Peter Lawrey đã đề cập trong bình luận cho câu hỏi ban đầu, bạn không nhất thiết phải biết bản phát hành JDK nào đã tạo một classtệp đã cho , nhưng bạn có thể tìm ra phiên bản lớp mã byte của classtệp có trong mộtjar .

Vâng, điều này thật tệ, nhưng bước đầu tiên là trích xuất một hoặc nhiều lớp từ jar. Ví dụ:

$ jar xf log4j-1.2.15.jar

Trên Linux, Mac OS X hoặc Windows đã cài đặt Cygwin , lệnh tệp (1) biết phiên bản lớp.

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

Hoặc cách khác, sử dụng javaptừ JDK như @ jike.thunderbolt khéo léo chỉ ra:

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

Và nếu bạn bị rớt xuống một Windowsmôi trường mà không có filehoặcgrep

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

FWIW, tôi sẽ đồng ý rằng javapsẽ nói rất nhiều về một classtập tin nhất định so với câu hỏi ban đầu được hỏi.

Dù sao, một phiên bản lớp khác, ví dụ:

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

Số chính của phiên bản lớp tương ứng với các phiên bản Java JDK sau:

• 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

Đây là cách của Java để tìm thông tin này.

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

Ví dụ:
> javap -v Application | findstr major   major version: 51

Không cần giải nén JAR (nếu một trong các tên lớp được biết hoặc được tra cứu, ví dụ như sử dụng 7zip), vì vậy trên Windows, điều sau đây là đủ:

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

Trình biên dịch Java ( javac) không xây dựng các tệp jar, nó dịch các tệp Java thành các tệp lớp. Công cụ Jar ( jar) tạo ra các lọ thực tế. Nếu không có tệp kê khai tùy chỉnh nào được chỉ định, thì bảng kê khai mặc định sẽ chỉ định phiên bản JDK nào được sử dụng để tạo tệp jar.

Vì tôi cần phân tích các lọ chất béo, tôi quan tâm đến phiên bản của từng lớp riêng lẻ trong một tệp jar. Do đó, tôi đã sử dụng phương pháp tiếp cận của Joe Liversedge https://stackoverflow.com/a/27877215/1497139 và kết hợp nó với bảng https://stackoverflow.com/a/3313839/1497139 của David J. Liszewski để tạo một tập lệnh bash jarv để hiển thị các phiên bản của tất cả các tệp lớp trong một tệp jar.

sử dụng

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

Thí dụ

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

#!/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 

bạn có thể tìm thấy phiên bản trình biên dịch Java từ các tệp. class bằng Hex Editor.

Bước 1: Trích xuất các tệp. Class từ tệp jar bằng trình giải nén zip

Bước 2: mở tệp. class bằng trình soạn thảo hex. (Tôi đã sử dụng plugin trình soạn thảo hex notepad ++. Plugin này đọc tệp dưới dạng nhị phân và hiển thị dưới dạng hex) Bạn có thể xem bên dưới.

Chỉ số 6 và 7 cung cấp số phiên bản chính của định dạng tệp lớp đang được sử dụng. https://en.wikipedia.org/wiki/Java_group_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 (hex 0x30),

JDK 1.3 = 47 (hex 0x2F),

JDK 1.2 = 46 (hex 0x2E),

JDK 1.1 = 45 (hex 0x2D).

Bạn có thể nói phiên bản nhị phân Java bằng cách kiểm tra 8 byte đầu tiên (hoặc sử dụng một ứng dụng có thể).

Trình biên dịch tự nó không, theo sự hiểu biết tốt nhất của tôi, chèn bất kỳ chữ ký nhận dạng nào. Tôi không thể phát hiện ra một điều như vậy trong định dạng lớp VM spec .

Các mã đăng bởi Owen có thể cho bạn những thông tin được đề cập bởi một số các câu trả lời khác tại đây:

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

Xem thêm này và này trang web. Cuối cùng tôi đã sửa đổi mã Sản phẩm Tâm trí để kiểm tra xem mỗi phụ thuộc của tôi được biên dịch để làm gì.

Các nhà phát triển và quản trị viên chạy Bash có thể thấy các chức năng tiện lợi này hữu ích:

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

Bạn có thể dán chúng vào để sử dụng một lần hoặc thêm chúng vào ~/.bash_aliaseshoặc ~/.bashrc. Các kết quả trông giống như:

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

và

$ 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 Như jackrabbit chỉ ra, bạn không thể dựa vào bảng kê khai 100% để cho bạn biết bất cứ điều gì hữu ích. Nếu đúng như vậy, thì bạn có thể lấy nó ra trong vỏ UNIX yêu thích của mình bằng 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 này không có gì hữu ích trong bảng kê khai về các lớp chứa.

Một lớp lót (Linux)

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

Điều này in nội dung của MANIFEST.MF tệp vào thiết bị xuất chuẩn (hy vọng có một tệp trong tệp jar của bạn :)

Tùy thuộc vào những gì đã xây dựng gói của bạn, bạn sẽ tìm thấy phiên bản JDK trong Created-Byhoặc Build-Jdkkhóa.

Mỗi tệp lớp có một số phiên bản được nhúng cho mức mã byte mà JVM sử dụng để xem liệu nó có thích đoạn mã byte cụ thể đó hay không. Đây là 48 cho Java 1.4, 49 cho Java 1.5 và 50 cho Java 6.

Nhiều trình biên dịch tồn tại có thể tạo mã byte ở mỗi cấp độ, javac sử dụng tùy chọn "-target" để chỉ ra mức mã byte nào sẽ tạo và javac Java 6 có thể tạo mã byte cho ít nhất 1,4, 1,5 và 6. Tôi không tin rằng trình biên dịch chèn bất cứ thứ gì có thể xác định chính trình biên dịch đó là những gì tôi nghĩ bạn yêu cầu. Ngoài ra, trình biên dịch Eclipse đang ngày càng được sử dụng, vì nó là một jar duy nhất có thể chạy chỉ với JRE.

Trong một tệp jar thường có nhiều lớp và mỗi lớp là độc lập, vì vậy bạn cần điều tra tất cả các lớp trong tệp jar để chắc chắn về các đặc điểm của nội dung.

Theo dõi câu trả lời của @David J. Liszewski, tôi đã chạy các lệnh sau để trích xuất tệp kê khai tệp jar trên 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

Rất nhiều lần, bạn có thể đang xem toàn bộ tệp jar hoặc tệp chiến tranh có chứa nhiều tệp jar ngoài chính chúng.

Vì tôi không muốn kiểm tra từng lớp, tôi đã viết một chương trình java để làm điều đó:

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

Mặc dù điều này không nói rõ lớp đã được biên dịch VỚI, nhưng nó xác định những gì JDK sẽ có thể LOAD các lớp, đó có lẽ là những gì bạn muốn bắt đầu.

Để mở rộng của Jonathon Faust và McDowell của câu trả lời: Nếu bạn đang ở trên một hệ thống * nix dựa, bạn có thể sử dụng od(một trong những chương trình Unix sớm ¹ mà nên có sẵn hầu như ở khắp mọi nơi) để truy vấn .classtập tin trên một mức độ nhị phân:

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

Ý chí sản lượng này các giá trị số nguyên quen thuộc, ví dụ như 50cho Java 5, 51cho Java 6và vân vân.

¹ Trích dẫn từ https://en.wikipedia.org/wiki/Od_(Unix)

Tôi cũng đã viết tập lệnh bash của riêng mình để kết xuất phiên bản Java theo yêu cầu của tất cả các tệp được truyền tại dòng lệnh ... Của tôi hơi thô, nhưng hoạt động với tôi ;-)

sử dụng ví dụ

$ 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_Vquired.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

Bạn có thể dễ dàng thực hiện điều này trên dòng lệnh bằng quy trình sau:

Nếu bạn biết bất kỳ tên lớp nào trong jar, bạn có thể sử dụng lệnh sau:

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

thí dụ :

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

Đầu ra:

    major version: 51

Tham khảo nhanh:

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: nếu bạn không biết bất kỳ tên lớp nào, bạn có thể dễ dàng thực hiện điều này bằng cách sử dụng bất kỳ trình dịch ngược jar nào hoặc chỉ bằng cách sử dụng lệnh sau để giải nén tệp jar:

jar xf myFile.jar

Bạn kiểm tra tệp Manifest của ví dụ jar:

Bản kê khai-Phiên bản: 1.0 Được tạo bởi: 1.6.0 (Tập đoàn IBM)

Trên Windows, hãy làm như sau:

1. Giải nén hoặc giải nén tệp JAR bằng lệnh JAR WinZip / Java.
2. Kéo và thả một trong các tệp lớp vào dự án Java Eclipse của bạn.
3. Mở tệp lớp.

Bây giờ Eclipse sẽ hiển thị phiên bản chính và phụ chính xác.

Tôi xây dựng một tập lệnh bash nhỏ (trên github) dựa trên đề xuất Davids bằng cách sử dụng filelệnh