确定任何Java框架的JDK兼容性

我们的是一个遗留的Java项目，已经维护了15年以上。我们有800多个模块。

从Struts到Spring，使用了各种框架。根据当时的需要，开发人员选择了框架并进行了开发。所以没有标准化。

现在我们要求将JDK从1.6版升级到1.8版。

1. 有没有办法轻松知道哪些框架会产生影响？
2. 是否有任何信息以API形式提供，以获取任何框架的JDK版本？

请让我知道...

---

解决方案

升级会告诉您的，并进行一些测试。如果您的系统有800多个模块，您应该考虑在升级之前解决您的标准化问题-尝试使用相同版本的依赖项-例如JDBC驱动程序、日志JAR等，并对您的开发人员构建环境使用相同的版本，以便每个人都可以一起完成相同的步骤-因此，如果在某个阶段失败，则一起回滚。

此类将转储它在所扫描的任何目录或文件中看到的所有.class和.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-??";
        }
    }

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