Quelle est la version de javac construit mon pot?

Un jar est simplement un conteneur. C'est un fichier d'archive à la tar. Alors qu'un jar peut avoir des informations intéressantes contenues à l'intérieur de son META-INF hiérarchie, il n'a pas l'obligation de préciser la cuvée des classes à l'intérieur de son contenu. Pour cela, on doit examiner la class les fichiers qui y sont.

Comme Peter Lawrey mentionné en commentaire à la question initiale, vous ne pouvez pas savoir à quel JDK version construit un class fichier, mais vous pouvez trouver le code octet version de la classe de la class fichier contenu dans un jar.

Oui, cela un peu nul, mais la première étape consiste à extraire un ou plusieurs classes de la jar. Par exemple:

$ jar xf log4j-1.2.15.jar

Sur Linux, Mac OS X ou Windows avec Cygwin installé, le fichier(1) commande connaît la version de la classe.

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

Ou, alternativement, à l'aide de javap à partir du JDK que @jikes.thunderbolt bien des points:

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

Et si vous êtes relégué à un Windows environnement sans file ou grep

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

FWIW, je vais d'accord pour dire que javap vous en dira beaucoup plus sur un class fichier que l'original de la question posée.

De toute façon, une autre version de la classe, par exemple:

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

La version de la classe de numéro majeur correspond à la Java JDK versions:

• 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

Le compilateur Java (javac) ne permet pas de créer des pots, il traduit les fichiers Java dans des fichiers de classe. Le Pot de l'outil (jar) crée le réel pots. Si aucun manifeste personnalisé a été spécifié, la valeur par défaut manifeste spécifier la version du JDK utilisé pour créer le jar.

Depuis que j'ai le nécessaire pour analyser la graisse pots j'ai été intéressé par la version de chaque classe dans un fichier jar. Donc j'ai pris Joe Liversedge approche
https://stackoverflow.com/a/27877215/1497139 et l'a combiné avec David J. Liszewski' https://stackoverflow.com/a/3313839/1497139 classe numéro de version de la table pour créer un script bash jarv pour afficher les versions de tous les fichiers de classe dans un fichier jar.

utilisation

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

Exemple

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

Script Bash 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 

Vous pouvez dire à la Java version binaire par inspecter les 8 premiers octets (ou à l'aide d'un app qui peut).

Le compilateur lui-même n'a pas, à ma connaissance, insérer l'identification de la signature. Je ne peux pas en place une telle chose dans le fichier VM spec format de toute façon.

Un liner (Linux)

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

Ce imprime le contenu de MANIFEST.MF fichier sur la sortie standard (j'espère qu'il y en existe une dans votre fichier jar 🙂

En fonction de ce qui construit votre colis, vous trouverez la version du JDK dans Created-By ou Build-Jdk clé.

Les développeurs et les administrateurs de l'exécution de Bash peut trouver ces fonctions de confort utile:

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

Vous pouvez coller à pour une utilisation en temps ou de les ajouter à ~/.bash_aliases ou ~/.bashrc. Les résultats ressembler à quelque chose comme:

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

et

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

MODIFIER
Comme jackrabbit points, vous ne pouvez pas 100% compter sur le manifeste de vous dire quelque chose d'utile. Si c'était le cas, vous pourriez sortir de votre favori shell UNIX avec 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

Cette .jar n'est pas quelque chose d'utile dans le manifeste sur les classes de contenu.

Une bonne affaire de temps, vous pourriez être à la recherche à l'ensemble des fichiers jar, ou la guerre des fichiers qui contiennent plusieurs fichiers jar en plus d'eux-mêmes.

Parce que je ne voulais pas la main de vérifier chaque classe, j'ai écrit un programme en java pour le faire:

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

Tout cela ne veut pas dire que la classe a été compilé AVEC l', il détermine ce JDK sera en mesure de CHARGER les classes, ce qui est probablement ce que vous vouliez commencer avec.

Vous de vérifier dans le fichier Manifest du jar
exemple:

Manifest-Version: 1.0
Créé Par: 1.6.0 (IBM Corporation)

Sur Windows, procédez de la manière suivante:

1. Décompresser ou extraire le fichier JAR à l'aide de WinZip /Java JAR commande.
2. Faites glisser et Déposez l'un des fichiers de classe dans votre projet Eclipse Java.
3. Ouvrez le fichier de classe.

Maintenant Éclipse sera l'exacte version principale et secondaire.