javac의 어떤 버전이 내 항아리를 만들었습니까?

jar를 빌드하는 데 사용 된 Java 컴파일러 버전을 어떻게 알 수 있습니까? jar 파일이 있으며 세 개의 JDK 중 하나에서 빌드되었을 수 있습니다. 우리는 정확히 어느 것을 알아야하므로 호환성을 인증 할 수 있습니다. 컴파일러 버전이 클래스 파일이나 jar에 포함되어 있습니까?

반드시 JAR 파일 자체에서 알 수는 없습니다.

16 진 편집기를 다운로드하고 JAR 내부의 클래스 파일 중 하나를 열고 바이트 오프셋 4-7을보십시오. 버전 정보가 내장되어 있습니다.

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

참고 : 아래 의견에서 언급했듯이

이 바이트는 클래스가 컴파일 된 버전이 아니라 클래스가 컴파일 된 버전을 알려줍니다.

A jar는 단지 컨테이너입니다. 파일 아카이브 tar입니다. META-INF 계층 jar내에 흥미로운 정보가 포함되어있을 수 있지만, 컨텐츠 내에 클래스의 빈티지를 지정해야 할 의무는 없습니다. 이를 위해서는 파일을 검사해야합니다 .class

뿐만 피터 Lawrey이 원래의 질문에 코멘트에 언급, 당신은 반드시 주어진 내장 된 JDK 버전 알 수없는 class파일을,하지만 당신은의 바이트 코드 클래스 버전을 찾을 수 있습니다 classA의 포함 된 파일을 jar.

예, 다소 짜증나지만 첫 번째 단계는에서 하나 이상의 클래스를 추출하는 것 jar입니다. 예를 들면 다음과 같습니다.

$ jar xf log4j-1.2.15.jar

Cygwin이 설치된 Linux, Mac OS X 또는 Windows 에서 file (1) 명령은 클래스 버전을 알고 있습니다.

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

또는 javapJDK에서 @ jikes.thunderbolt를 적절하게 지적하면 다음과 같습니다.

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

그리고 당신이 또는 Windows중 하나없이 환경 으로 강등filegrep

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

FWIW, 나는 원래의 질문보다 javap주어진 class파일 에 대해 훨씬 더 많이 말할 것이라고 동의 할 것 입니다.

어쨌든 다른 클래스 버전은 다음과 같습니다.

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

클래스 버전 메이저 번호는 다음 Java JDK 버전에 해당합니다.

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

이 정보를 찾는 Java의 방법은 다음과 같습니다.

Windows : javap -v <class> | findstr major
유닉스 :javap -v <class> | grep major

예를 들면 다음과 같습니다.
> javap -v Application | findstr major   major version: 51

JAR의 압축을 풀 필요가 없습니다 (클래스 이름 중 하나가 알려져 있거나 예를 들어 7zip을 사용하여 찾은 경우). Windows에서는 다음과 같이 충분합니다.

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

Java 컴파일러 ( javac)는 jar를 빌드하지 않고 Java 파일을 클래스 파일로 변환합니다. 항아리 도구 ( jar)는 실제 항아리를 만듭니다. 사용자 정의 매니페스트가 지정되지 않은 경우 기본 매니페스트는 jar 작성에 사용 된 JDK 버전을 지정합니다.

뚱뚱한 항아리를 분석해야했기 때문에 jar 파일의 각 개별 클래스 버전에 관심이있었습니다. 따라서 Joe Liversedge 접근 방식을 https://stackoverflow.com/a/27877215/1497139로 가져 와서 David J. Liszewski의 https://stackoverflow.com/a/3313839/1497139 클래스 번호 버전 테이블과 결합하여 bash 스크립트를 작성했습니다. jarv에 모든 클래스 파일의 버전을 표시하는 jarv

용법

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

예

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

배쉬 스크립트 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 

16 진 편집기를 사용하여 .class 파일에서 Java 컴파일러 버전을 찾을 수 있습니다.

1 단계 : Zip 추출기를 사용하여 jar 파일에서 .class 파일 추출

2 단계 : 16 진수 편집기로 .class 파일을 엽니 다.

색인 6과 7은 사용중인 클래스 파일 형식의 주요 버전 번호를 제공합니다. https://en.wikipedia.org/wiki/Java_class_file

Java SE 11 = 55 (0x37 16 진수)

Java SE 10 = 54 (0x36 16 진수)

자바 SE 9 = 53 (0x35 16 진수)

Java SE 8 = 52 (0x34 16 진수)

Java SE 7 = 51 (0x33 16 진수)

Java SE 6.0 = 50 (0x32 16 진수)

Java SE 5.0 = 49 (0x31 16 진수),

JDK 1.4 = 48 (0x30 16 진수)

JDK 1.3 = 47 (0x2F 16 진수)

JDK 1.2 = 46 (0x2E 16 진수)

JDK 1.1 = 45 (0x2D 16 진수).

처음 8 바이트 를 검사하여 (또는 가능한 앱 을 사용하여) Java 바이너리 버전을 알 수 있습니다.

컴파일러 자체는 내가 아는 한 식별 서명을 삽입하지 않습니다. 어쨌든 파일 VM 사양 클래스 형식 에서 그러한 것을 발견 할 수 없습니다 .

오웬에 의해 게시 코드는 당신에게 여기에 다른 답변들에 의해 언급 된 정보를 알 수 있습니다 :

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

참조 이 와 이 사이트를. 필자는 Mind Products 코드를 신속하게 수정하여 각 종속성이 컴파일 된 것을 확인했습니다.

Bash를 실행하는 개발자와 관리자는 다음과 같은 편리한 기능이 도움이 될 수 있습니다.

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

당신은 한 시간 사용에 붙여 넣을 수 있습니다 또는 그들에 추가 ~/.bash_aliases하거나 ~/.bashrc. 결과는 다음과 같습니다.

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

과

$ 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 로는 잭 래빗 당신은 100 % 당신에게 유용한 아무것도 말할 매니페스트에 의존 할 수 있습니다 점을. 그렇다면 다음을 사용하여 좋아하는 UNIX 셸에서 가져올 수 있습니다 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에는 포함 된 클래스에 대한 매니페스트에 유용한 것이 없습니다.

하나의 라이너 (Linux)

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

이것은 MANIFEST.MF파일 의 내용 을 stdout에 출력합니다 (jar 파일에 내용이 있습니다 :)

패키지를 빌드 한 내용에 따라 JDK 버전 Created-By또는 Build-Jdk키를 찾을 수 있습니다.

각 클래스 파일에는 JVM이 특정 바이트 코드 청크를 좋아하는지 여부를 확인하는 데 사용하는 바이트 코드 레벨에 대해 포함 된 버전 번호가 있습니다. Java 1.4의 경우 48, Java 1.5의 경우 49, Java 6의 경우 50입니다.

각 레벨에서 바이트 코드를 생성 할 수있는 많은 컴파일러가 존재하고 javac는 "-target"옵션을 사용하여 생성 할 바이트 코드 레벨을 표시하며 Java 6 javac는 1.4, 1.5 및 6 이상의 바이트 코드를 생성 할 수 있습니다. 컴파일러는 컴파일러 자체를 식별 할 수있는 모든 것을 삽입한다고 생각합니다. 또한 Eclipse 컴파일러는 JRE에서만 실행할 수있는 단일 jar이므로 점점 더 많이 사용되고 있습니다.

jar 파일에는 대개 많은 클래스가 있으며 각 클래스는 독립적이므로 jar의 모든 클래스를 조사하여 내용의 특성을 확인해야합니다.

@David J. Liszewski의 답변에 이어 Ubuntu에서 jar 파일의 매니페스트를 추출하기 위해 다음 명령을 실행했습니다.

# 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

많은 경우, 전체 jar 파일 또는 많은 jar 파일이 포함 된 war 파일을 자체적으로보고있을 수 있습니다.

각 클래스를 직접 확인하고 싶지 않기 때문에 Java 프로그램을 작성했습니다.

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

이것은 클래스가 컴파일 된 것을 말하지는 않지만 JDK가 클래스를로드 할 수있는 것을 결정합니다.

Jonathon Faust 와 McDowell의 답변 을 확장하려면 : * nix 기반 시스템 인 경우 od( 실제로 사용할 수 있는 초기 Unix 프로그램 ¹ 중 하나 )를 사용하여 .class이진 레벨 에서 파일 을 쿼리 할 수 ​​있습니다 .

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

이 출력됩니다 익숙한 정수 값, 예를 들어, 50대한 Java 5, 51대한 Java 6등등.

¹ 에서 인용 https://en.wikipedia.org/wiki/Od_(Unix)

나는 또한 명령 줄에 전달 된 모든 항아리에 필요한 Java 버전을 덤프하기 위해 내 자신의 bash 스크립트를 작성했다.

사용법 예

$ 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

다음 프로세스를 사용하여 명령 행에서 쉽게 수행 할 수 있습니다.

jar에서 클래스 이름을 알고 있다면 다음 명령을 사용할 수 있습니다.

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

예 :

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

출력 :

    major version: 51

빠른 참조 :

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 

추신 : 클래스 이름을 모르는 경우 jar 디 컴파일러를 사용하거나 jar 파일을 추출하기 위해 다음 명령을 사용하여 쉽게 수행 할 수 있습니다.

jar xf myFile.jar

jar 예제의 Manifest 파일을 체크인하십시오.

매니페스트 버전 : 1.0 작성 기준 : 1.6.0 (IBM Corporation)

Windows에서 다음을 수행하십시오.

1. WinZip / Java JAR 명령을 사용하여 JAR 파일의 압축을 풀거나 추출하십시오.
2. 클래스 파일 중 하나를 Eclipse Java 프로젝트로 끌어서 놓으십시오.
3. 수업 파일을 엽니 다.

이제 Eclipse는 정확한 메이저 버전과 마이너 버전을 보여줍니다.

명령을 사용하여 Davids 제안에 따라 작은 bash 스크립트 (github에서) 를 빌드합니다.file