เครื่องมือในการอ่านและแสดงเวอร์ชัน Java .class

มีใครรู้จักเครื่องมือที่ใช้ค้นหาไฟล์. class แล้วแสดงเวอร์ชันที่คอมไพล์แล้วหรือไม่?

ฉันรู้ว่าคุณสามารถดูทีละไฟล์ในโปรแกรมแก้ไขฐานสิบหก แต่ฉันมีไฟล์คลาสมากมายให้ดู (มีบางอย่างในแอปพลิเคชันขนาดใหญ่ของฉันกำลังรวบรวมเป็น Java6 ด้วยเหตุผลบางประการ)

ใช้เครื่องมือjavapที่มาพร้อมกับ JDK -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

ง่ายพอที่จะอ่านลายเซ็นไฟล์คลาสและรับค่าเหล่านี้โดยไม่ต้องใช้ 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);
    }
  }
}

ไดเรกทอรีการเดิน ( ไฟล์ ) และไฟล์เก็บถาวร ( JarFile ) การมองหาไฟล์คลาสเป็นเรื่องเล็กน้อย

บล็อกของJoe Darcy ของ Oracle จะแสดงรายการเวอร์ชันคลาสในการแมปเวอร์ชัน JDKถึง Java 7:

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

บน Unix-like

ไฟล์ /path/to/Thing.class

จะให้ประเภทไฟล์และเวอร์ชันด้วย. นี่คือลักษณะของผลลัพธ์:

คอมไพล์ข้อมูลคลาส Java เวอร์ชัน 49.0

หากคุณใช้ระบบยูนิกซ์คุณสามารถทำไฟล์

find /target-folder -name \*.class | xargs file | grep "version 50\.0"

(ไฟล์เวอร์ชันของฉันระบุว่า "คอมไพล์ข้อมูลคลาส Java เวอร์ชัน 50.0" สำหรับคลาส java6)

ตรวจสอบเวอร์ชัน java อีกครั้ง

od -t d -j 7 -N 1 ApplicationContextProvider.class | head -1 | awk '{print "Java", $2 - 44}'

ในคราสหากคุณไม่ได้แนบแหล่งที่มา คำนึงถึงบรรทัดแรกหลังปุ่มแนบแหล่งที่มา

// รวบรวมจาก CDestinoLog.java ( เวอร์ชัน 1.5: 49.0, super bit )

สิ่งนี้อาจช่วยใครบางคนได้เช่นกัน ดูเหมือนจะมีวิธีที่ง่ายกว่าในการรับเวอร์ชัน JAVA ที่ใช้ในการคอมไพล์ / สร้าง. class วิธีนี้มีประโยชน์ในการตรวจสอบตัวเองของแอปพลิเคชัน / คลาสในเวอร์ชัน JAVA

ฉันได้ผ่านห้องสมุด JDK และพบว่าคงมีประโยชน์นี้: com.sun.deploy.config.BuiltInProperties.CURRENT_VERSION ฉันไม่รู้ว่ามันอยู่ใน JAVA JDK ตั้งแต่เมื่อไหร่

ลองใช้โค้ดนี้สำหรับค่าคงที่หลายเวอร์ชันฉันได้ผลลัพธ์ด้านล่าง:

src:

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

ในคลาส bytecode มีค่าคงที่ที่เก็บไว้จริงๆ - ดูส่วนที่มีเครื่องหมายสีแดงของ Main.call - ค่าคงที่ที่เก็บไว้ใน. class bytecode

ค่าคงที่อยู่ในคลาสที่ใช้สำหรับตรวจสอบว่าเวอร์ชัน JAVA ล้าสมัยหรือไม่ (ดูวิธีการตรวจสอบ Java ที่ล้าสมัย ) ...

วิธีการแก้ปัญหา Java-based ใช้รุ่นหมายเลขมายากล ด้านล่างนี้โปรแกรมจะใช้เพื่อตรวจจับเวอร์ชัน bytecode

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

คลาส Java นี้จะสแกนเนื้อหาของเนื้อหา WAR และ JAR ทั้งหมดที่พบภายใต้รายการไดเร็กทอรีและพิมพ์สรุปเวอร์ชันไฟล์คลาส java สำหรับแต่ละคอมโพเนนต์รวมถึง JAR แต่ละตัวภายใน WAR:

public class ShowClassVersions {
    private static final byte[] CLASS_MAGIC = new byte[] {(byte)0xca, (byte)0xfe, (byte)0xba, (byte)0xbe};
    private final byte[] bytes = new byte[8];
    private TreeMap<String,ArrayList<String>> vers = new TreeMap<>();

    private void scan(Path f) throws IOException {
        if (Files.isDirectory(f)) {
            Pattern pattern = Pattern.compile("\\.[wj]ar$"); // or |\\.class
            try(var stream = Files.find(f, Integer.MAX_VALUE, (p,a) -> a.isRegularFile() && pattern.matcher(p.toString()).find())) {
                stream.forEach(this::scanFile);
            }
            return;
        }
        scanFile(f);
    }
    private void scanFile(Path f) {
        String fn = f.getFileName().toString();
        try {
            if (fn.endsWith(".jar"))
                scanArchive(f);
            else if (fn.endsWith(".war"))
                scanArchive(f);
            else if (fn.endsWith(".class"))
                record(f, 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(), in);
        }
    }
    private String scanArchive(String desc, InputStream in) throws IOException {
        String version = null;
        ZipInputStream zip = new ZipInputStream(in);
        ZipEntry entry = null;
        while ((entry = zip.getNextEntry()) != null) {
            String name = entry.getName();
            if (version == null && name.endsWith(".class"))  {
                version = versionOfClass(zip);
            }
            else if (name.endsWith(".jar"))  {
                scanArchive(desc+" ==>> "+name, zip);
            }
        }
        if (version != null)
            record(desc, version);
        return version;
    }

    private String versionOfClass(Path p) throws IOException {
        String version = null;
        try(InputStream in = Files.newInputStream(p)) {
            version = versionOfClass(in);
        }
        return version;
    }

    private String versionOfClass(InputStream in) throws IOException {
        String version = null;
        int c = in.read(bytes);
        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);
            version = ""+majorVersion + "." + minorVersion;
        }
        return version;
    }
    private void record(String p, String v) {
        vers.computeIfAbsent(String.valueOf(v), k -> new ArrayList<String>()).add(p);
    }
    private void record(Path p, String v) {
        record(p.toAbsolutePath().toString(), v);
    }
    public static void main(String[] args) throws IOException {
        ShowClassVersions v = new ShowClassVersions();
        var files = Arrays.stream(args).map(Path::of).collect(Collectors.toList());
        for (var f : files) {
            v.scan(f);
        }
        for (var ver : v.vers.keySet()) {
            System.out.println("Version: "+ver);
            for (var p : v.vers.get(ver)) {
                System.out.println("   "+p);
            }
        };
    }
}