Javac'ın hangi versiyonu kavanozumu inşa etti?

Bir kavanoz oluşturmak için Java derleyicisinin hangi sürümünün kullanıldığını nasıl anlayabilirim? Bir jar dosyam var ve üç JDK'dan herhangi birinde oluşturulmuş olabilir. Tam olarak hangisini bilmemiz gerekir, böylece uyumluluğu doğrulayabiliriz. Derleyici sürümü sınıf dosyalarının veya kavanozun içine yerleştirilmiş mi?

Mutlaka JAR dosyasından söyleyemezsiniz.

Bir onaltılık düzenleyici indirin ve JAR içindeki sınıf dosyalarından birini açın ve 4 ile 7 arasındaki bayt uzaklığına bakın. Sürüm bilgileri yerleşiktir.

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

Not: Aşağıdaki yorumda belirtildiği gibi,

bu baytlar, sınıfın hangi sürümü derlediğini değil, hangi sürümün derlendiğini söyler.

bir jar sadece bir kaptır. Bir dosya arşivi ā la tar. A'nın META-INF hiyerarşisinde jarilginç bilgiler olsa da , içeriğindeki sınıfların vintage'lerini belirtme zorunluluğu yoktur. Bunun için içindeki dosyaları incelemek gerekir .class

Peter Lawrey'in orijinal soruya yaptığı yorumda belirtildiği gibi , hangi JDK sürümünün belirli bir classdosya oluşturduğunu bilmeniz gerekmez , ancak classa jar.

Evet, bu biraz berbat, ama ilk adım bir veya daha fazla sınıftan çıkarmaktır jar. Örneğin:

$ jar xf log4j-1.2.15.jar

Linux, Mac OS X veya Cygwin yüklü Windows işletim sistemlerinde , dosya (1) komutu sınıf sürümünü bilir.

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

Veya alternatif olarak, javap JDK'dan @ jikes.thunderbolt olarak uygun şekilde işaret ederek:

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

Ve eğer Windowsikisinden biri olmayan bir ortama düşersenizfile veyagrep

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

FWIW, javapverilen bir classdosya hakkında sorulan orijinal sorudan çok daha fazlasını anlatacağım konusunda hemfikirim .

Her neyse, farklı bir sınıf versiyonu, örneğin:

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

Sınıf sürümü ana numarası aşağıdaki Java JDK sürümlerine karşılık gelir:

• 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

Java'nın bu bilgiyi bulmanın yolu.

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

Örneğin:
> javap -v Application | findstr major   major version: 51

JAR'ın paketini açmaya gerek yoktur (sınıf adlarından biri biliniyorsa veya örneğin 7zip kullanılıyorsa), bu nedenle Windows'ta aşağıdakiler yeterli olacaktır:

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

Java derleyicisi ( javac) kavanoz oluşturmaz, Java dosyalarını sınıf dosyalarına çevirir. Kavanoz aracı ( jar) gerçek kavanozları oluşturur. Herhangi bir özel bildirim belirtilmezse, varsayılan bildirim, kavanoz oluşturmak için hangi JDK sürümünün kullanıldığını belirtir.

Yağ kavanozlarını analiz etmem gerektiğinden, bir kavanoz dosyasındaki her bir sınıfın versiyonuyla ilgileniyordum. Bu nedenle Joe Liversedge yaklaşımını https://stackoverflow.com/a/27877215/1497139 aldım ve bash betiği oluşturmak için David J. Liszewski'nin https://stackoverflow.com/a/3313839/1497139 sınıf numarası sürüm tablosuyla birleştirdim. jarv tüm jar dosyalarının sürümlerini bir jar dosyasında gösterir.

kullanım

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

Misal

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 komut dosyası 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 

Java derleyici sürümünü bir Hex Editor kullanarak .class dosyalarından bulabilirsiniz.

Adım 1: Bir zip çıkarıcı kullanarak .class dosyalarını jar dosyasından ayıklayın

Adım 2: bir hex editörü ile .class dosyasını açın. (Notepad ++ hex editörü eklentisini kullandım. Bu eklenti dosyayı ikili olarak okur ve hex olarak gösterir) Aşağıda görebilirsiniz.

Dizin 6 ve 7, kullanılan sınıf dosyası biçiminin ana sürüm numarasını verir. 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 (0x30 hex),

JDK 1.3 = 47 (0x2F altıgen),

JDK 1.2 = 46 (0x2E altıgen),

JDK 1.1 = 45 (0x2D altıgen).

Java ikili sürümünü ilk 8 baytı inceleyerek (veya bir uygulama kullanarak) söyleyebilirsiniz. yapabilen ) söyleyebilirsiniz.

Derleyicinin kendisi, bildiğim kadarıyla, herhangi bir tanımlayıcı imza eklemez. Zaten dosya VM spec sınıf biçiminde böyle bir şey tespit edemez .

Owen tarafından gönderildi kod size burada diğer cevaplar sayısına göre söz bilgileri verirler:

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

Ayrıca bkz bu ve bu siteyi. Her bir bağımlılığımın ne için derlendiğini kontrol etmek için Mind Products kodunu hızlı bir şekilde değiştirdim.

Bash çalıştıran geliştiriciler ve yöneticiler bu kullanışlı işlevleri yararlı bulabilir:

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

Sen tek kez kullanım yapıştırabilirsiniz ya da onları eklemek ~/.bash_aliasesveya ~/.bashrc. Sonuçlar şuna benzer:

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

ve

$ 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 Jackrabbit'in işaret ettiği gibi ,% 100 size faydalı bir şey söylemek için manifestoya güvenemezsiniz. Eğer öyleyse, o zaman en sevdiğiniz UNIX kabuğunda şunları yapabilirsiniz 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

Bu .jar, içerdiği sınıflar hakkında bildirimde yararlı bir şey içermez.

Bir astar (Linux)

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

Bu, MANIFEST.MFdosyanın içeriğini stdout'a yazdırır (umarım jar dosyanızda bir tane vardır :)

Paketinizi neyin oluşturduğuna bağlı olarak, JDK sürümünü Created-Byveya Build-Jdkanahtarında bulacaksınız .

Her sınıf dosyası, JVM'nin belirli bayt kod yığınını beğenip beğenmediğini görmek için kullandığı bayt kodu düzeyi için gömülü bir sürüm numarasına sahiptir. Bu, Java 1.4 için 48, Java 1.5 için 49 ve Java 6 için 50'dir.

Her düzeyde bayt kodu oluşturabilen birçok derleyici vardır, javac hangi bayt kodu düzeyini oluşturmak için belirtmek için "-target" seçeneğini kullanır ve Java 6 javac en az 1.4, 1.5 ve 6 için bayt kodu üretebilir. Derleyicinin derleyicinin kendisini tanımlayabilecek herhangi bir şey eklediğine inanıyorum. Ayrıca Eclipse derleyicisi, yalnızca JRE ile çalışabilen tek bir kavanoz olduğu için giderek daha fazla kullanılmaktadır.

Bir kavanoz dosyasında genellikle birçok sınıf vardır ve her biri bağımsızdır, bu nedenle içeriğin özellikleri hakkında emin olmak için kavanozdaki tüm sınıfları araştırmanız gerekir.

@David J. Liszewski'nin cevabını takiben, jar dosyasının Ubuntu'daki manifestosunu çıkarmak için aşağıdaki komutları çalıştırdım:

# 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

Çoğu zaman, tüm jar dosyalarına veya kendilerine ek olarak birçok jar dosyası içeren savaş dosyalarına bakabilirsiniz.

Her sınıfı kontrol etmek istemediğim için bunu yapmak için bir java programı yazdım:

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

Bu, sınıfın neyle derlendiğini söylemese de, JDK'ların sınıfları YÜKLENECEĞİNİ belirler, bu da muhtemelen başlamak istediğiniz şeydir.

Jonathon Faust ve McDowell'in cevaplarını genişletmek için : * nix tabanlı bir sistemdeyseniz, dosyayı ikili düzeyde sorgulamak için (hemen hemen her yerde kullanılabilir olması gereken oden eski Unix programlarından ¹ ) kullanabilirsiniz .class:

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

Çıktısı verir tanıdık tamsayı değerleri, mesela 50için Java 5, 51için Java 6vb.

Https://en.wikipedia.org/wiki/Od_(Unix) ' den ¹ alıntı

Ben de komut satırında geçen tüm kavanozlar tarafından gerekli Java sürümünü dökümü için kendi bash betiğimi yazdı ... Benim biraz kaba, ama benim için çalışıyor ;-)

örnek kullanım

$ 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

Bunu aşağıdaki işlemi kullanarak komut satırında kolayca yapabilirsiniz:

Jar içindeki sınıf adlarından herhangi birini biliyorsanız, aşağıdaki komutu kullanabilirsiniz:

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

misal :

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

Çıktı :

    major version: 51

Hızlı referans :

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 

Not: sınıf adlarından herhangi birini bilmiyorsanız, kavanoz çözücülerden herhangi birini kullanarak veya kavanoz dosyasını ayıklamak için aşağıdaki komutu kullanarak bunu kolayca yapabilirsiniz:

jar xf myFile.jar

Jar örneğinin Manifest dosyasında kontrol edersiniz:

Bildirim Sürümü: 1.0 Düzenleyen: 1.6.0 (IBM Corporation)

Windows'ta aşağıdakileri yapın:

1. WinZip / Java JAR komutunu kullanarak JAR dosyasını açın veya çıkarın.
2. Sınıf dosyalarından birini Eclipse Java projenize sürükleyip bırakın.
3. Sınıf dosyasını açın.

Şimdi Eclipse tam ana ve ikincil sürümünü gösterecek.

Biraz bash komut dosyası oluşturmak (github) kullanarak Davids öneri dayalı filekomutu