你们有谁知道一个工具可以搜索 .class 文件，然后显示它们的编译版本？
我知道您可以在十六进制编辑器中单独查看它们，但我有很多类文件要查看（我的巨型应用程序中的某些内容由于某种原因正在编译为 Java6）。
SCdF
问问题
63726 次
10 回答
148
使用JDK自带的javap工具。该-verbose选项将打印类文件的版本号。
> javap -verbose MyClass
Compiled from "MyClass.java"
public class MyClass
SourceFile: "MyClass.java"
minor version: 0
major version: 46
...
仅显示版本：
WINDOWS> javap -verbose MyClass | find "version"
LINUX > javap -verbose MyClass | grep version
于 2008-08-26T07:16:23.953 回答
47
无需 3rd 方 API 即可轻松读取类文件签名并获取这些值。您需要做的就是读取前 8 个字节。
ClassFile {
u4 magic;
u2 minor_version;
u2 major_version;
对于类文件版本 51.0 (Java 7)，开始字节是：
CA FE BA BE 00 00 00 33
...其中 0xCAFEBABE 是魔术字节，0x0000 是次要版本，0x0033 是主要版本。
import java.io.*;
public class Demo {
public static void main(String[] args) throws IOException {
ClassLoader loader = Demo.class.getClassLoader();
try (InputStream in = loader.getResourceAsStream("Demo.class");
DataInputStream data = new DataInputStream(in)) {
if (0xCAFEBABE != data.readInt()) {
throw new IOException("invalid header");
}
int minor = data.readUnsignedShort();
int major = data.readUnsignedShort();
System.out.println(major + "." + minor);
}
}
}
查找类文件的遍历目录 ( File ) 和档案 ( JarFile ) 是微不足道的。
Oracle 的Joe Darcy 的博客列出了类版本到 Java 7的 JDK 版本映射：
Target Major.minor Hex
1.1 45.3 0x2D
1.2 46.0 0x2E
1.3 47.0 0x2F
1.4 48.0 0x30
5 (1.5) 49.0 0x31
6 (1.6) 50.0 0x32
7 (1.7) 51.0 0x33
8 (1.8) 52.0 0x34
9 53.0 0x35
于 2008-08-25T23:47:38.150 回答
24
在类 Unix 上
文件 /path/to/Thing.class
也会给出文件类型和版本。这是输出的样子：
编译的 Java 类数据，版本 49.0
于 2011-07-07T10:34:00.720 回答
9
如果你在一个 unix 系统上，你可以做一个
find /target-folder -name \*.class | xargs file | grep "version 50\.0"
（我的文件版本为 java6 类的“编译的 Java 类数据，版本 50.0”）。
于 2008-08-26T12:32:05.647 回答
6
另一个 java 版本检查
od -t d -j 7 -N 1 ApplicationContextProvider.class | head -1 | awk '{print "Java", $2 - 44}'
于 2014-08-08T10:30:37.790 回答
5
如果您没有附加来源，则在 Eclipse 中。注意附加源按钮后的第一行。
// 从 CDestinoLog.java 编译（版本 1.5：49.0，超级位）
于 2016-01-29T08:49:08.050 回答
3
也许这对某人也有帮助。看起来有更简单的方法来获取用于编译/构建 .class 的 JAVA 版本。这种方式对于应用程序/类在 JAVA 版本上的自检很有用。
我浏览了 JDK 库并发现了这个有用的常量： com.sun.deploy.config.BuiltInProperties.CURRENT_VERSION。我不知道它是从什么时候开始在 JAVA JDK 中的。
为几个版本常量尝试这段代码，我得到以下结果：
源代码：
System.out.println("JAVA DEV ver.: " + com.sun.deploy.config.BuiltInProperties.CURRENT_VERSION);
System.out.println("JAVA RUN v. X.Y: " + System.getProperty("java.specification.version") );
System.out.println("JAVA RUN v. W.X.Y.Z: " + com.sun.deploy.config.Config.getJavaVersion() ); //_javaVersionProperty
System.out.println("JAVA RUN full ver.: " + System.getProperty("java.runtime.version") + " (may return unknown)" );
System.out.println("JAVA RUN type: " + com.sun.deploy.config.Config.getJavaRuntimeNameProperty() );
输出：
JAVA DEV ver.: 1.8.0_77
JAVA RUN v. X.Y: 1.8
JAVA RUN v. W.X.Y.Z: 1.8.0_91
JAVA RUN full ver.: 1.8.0_91-b14 (may return unknown)
JAVA RUN type: Java(TM) SE Runtime Environment
在类字节码中确实存储了常量 - 请参见 Main.call 的红色标记部分 -常量存储在 .class 字节码中
常量在用于检查 JAVA 版本是否过时的类中（请参阅Java 如何检查是否过时）...
于 2016-05-16T14:31:26.473 回答
2
使用版本幻数的基于 java 的解决方案。下面它被程序本身用来检测它的字节码版本。
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;
import org.apache.commons.io.IOUtils;
public class Main {
public static void main(String[] args) throws DecoderException, IOException {
Class clazz = Main.class;
Map<String,String> versionMapping = new HashMap();
versionMapping.put("002D","1.1");
versionMapping.put("002E","1.2");
versionMapping.put("002F","1.3");
versionMapping.put("0030","1.4");
versionMapping.put("0031","5.0");
versionMapping.put("0032","6.0");
versionMapping.put("0033","7");
versionMapping.put("0034","8");
versionMapping.put("0035","9");
versionMapping.put("0036","10");
versionMapping.put("0037","11");
versionMapping.put("0038","12");
versionMapping.put("0039","13");
versionMapping.put("003A","14");
InputStream stream = clazz.getClassLoader()
.getResourceAsStream(clazz.getName().replace(".", "/") + ".class");
byte[] classBytes = IOUtils.toByteArray(stream);
String versionInHexString =
Hex.encodeHexString(new byte[]{classBytes[6],classBytes[7]});
System.out.println("bytecode version: "+versionMapping.get(versionInHexString));
}
}
于 2019-10-31T12:02:08.863 回答
2
读取第 8 个字节为十进制：
类 Unix：hexdump -s 7 -n 1 -e '"%d"' Main.class
视窗：busybox.exe hexdump -s 7 -n 1 -e '"%d"' Main.class
输出示例：
55
解释：
-s 7偏移量 7-n 1限制 1-e '"%d"'以十进制打印
版本图：
JDK 1.1 = 45 (0x2D hex)
JDK 1.2 = 46 (0x2E hex)
JDK 1.3 = 47 (0x2F hex)
JDK 1.4 = 48 (0x30 hex)
Java SE 5.0 = 49 (0x31 hex)
Java SE 6.0 = 50 (0x32 hex)
Java SE 7 = 51 (0x33 hex)
Java SE 8 = 52 (0x34 hex)
Java SE 9 = 53 (0x35 hex)
Java SE 10 = 54 (0x36 hex)
Java SE 11 = 55 (0x37 hex)
Java SE 12 = 56 (0x38 hex)
Java SE 13 = 57 (0x39 hex)
Java SE 14 = 58 (0x3A hex)
Java SE 15 = 59 (0x3B hex)
Java SE 16 = 60 (0x3C hex)
Java SE 17 = 61 (0x3D hex)
于 2021-12-10T02:22:37.450 回答
0
最简单的方法是使用此处读取类文件魔术字节的许多答案来扫描类文件。
然而，一些代码被打包在 jars 或其他存档格式中，如 WAR 和 EAR，其中一些包含其他存档或类文件，而且您现在拥有多版本 JAR 文件 - 请参阅JEP-238，每个 JAR 使用不同的 JDK 编译器。
该程序从文件+文件夹列表中扫描类，并为每个组件（包括 WAR/EAR 中的每个 JAR）打印 java 类文件版本的摘要：
public static void main(String[] args) throws IOException {
var files = Arrays.stream(args).map(Path::of).collect(Collectors.toList());
ShowClassVersions v = new ShowClassVersions();
for (var f : files) {
v.scan(f);
}
v.print();
}
扫描的示例输出：
Version: 49.0 ~ JDK-5
C:\jars\junit-platform-console-standalone-1.7.1.jar
Version: 50.0 ~ JDK-6
C:\jars\junit-platform-console-standalone-1.7.1.jar
Version: 52.0 ~ JDK-8
C:\java\apache-tomcat-10.0.12\lib\catalina.jar
C:\jars\junit-platform-console-standalone-1.7.1.jar
Version: 53.0 ~ JDK-9
C:\java\apache-tomcat-10.0.12\lib\catalina.jar
C:\jars\junit-platform-console-standalone-1.7.1.jar
扫描仪：
public class ShowClassVersions {
private TreeMap<String, ArrayList<String>> vers = new TreeMap<>();
private static final byte[] CLASS_MAGIC = new byte[] { (byte) 0xca, (byte) 0xfe, (byte) 0xba, (byte) 0xbe };
private final byte[] bytes = new byte[8];
private String versionOfClass(InputStream in) throws IOException {
int c = in.readNBytes(bytes, 0, bytes.length);
if (c == bytes.length && Arrays.mismatch(bytes, CLASS_MAGIC) == CLASS_MAGIC.length) {
int minorVersion = (bytes[4] << 8) + (bytes[4] << 0);
int majorVersion = (bytes[6] << 8) + (bytes[7] << 0);
return ""+ majorVersion + "." + minorVersion;
}
return "Unknown";
}
private Matcher classes = Pattern.compile("\\.(class|ear|war|jar)$").matcher("");
// This code scans any path (dir or file):
public void scan(Path f) throws IOException {
try (var stream = Files.find(f, Integer.MAX_VALUE,
(p, a) -> a.isRegularFile() && classes.reset(p.toString()).find())) {
stream.forEach(this::scanFile);
}
}
private void scanFile(Path f) {
String fn = f.getFileName().toString();
try {
if (fn.endsWith(".ear") || fn.endsWith(".war") || fn.endsWith(".jar"))
scanArchive(f);
else if (fn.endsWith(".class"))
store(f.toAbsolutePath().toString(), versionOfClass(f));
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
private void scanArchive(Path p) throws IOException {
try (InputStream in = Files.newInputStream(p)) {
scanArchive(p.toAbsolutePath().toString(), Files.newInputStream(p));
}
}
private void scanArchive(String desc, InputStream in) throws IOException {
HashSet<String> versions = new HashSet<>();
ZipInputStream zip = new ZipInputStream(in);
for (ZipEntry entry = null; (entry = zip.getNextEntry()) != null; ) {
String name = entry.getName();
// There could be different compiler versions per class in one jar
if (name.endsWith(".class")) {
versions.add(versionOfClass(zip));
} else if (name.endsWith(".jar") || name.endsWith(".war")) {
scanArchive(desc + " => " + name, zip);
}
}
if (versions.size() > 1)
System.out.println("Warn: "+desc+" contains multiple versions: "+versions);
for (String version : versions)
store(desc, version);
}
private String versionOfClass(Path p) throws IOException {
try (InputStream in = Files.newInputStream(p)) {
return versionOfClass(in);
}
}
private void store(String path, String jdkVer) {
vers.computeIfAbsent(jdkVer, k -> new ArrayList<>()).add(path);
}
// Could add a mapping table for JDK names, this guesses based on (JDK17 = 61.0)
public void print() {
for (var ver : vers.keySet()) {
System.out.println("Version: " + ver + " ~ " +jdkOf(ver));
for (var p : vers.get(ver)) {
System.out.println(" " + p);
}
}
}
private static String jdkOf(String ver) {
try {
return "JDK-"+((int)Float.parseFloat(ver)-44);
}
catch(NumberFormatException nfe)
{
return "JDK-??";
}
}
}
于 2020-08-01T10:17:17.920 回答