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

Question

我们的项目是一个遗留的 Java 项目，已维护超过 15 年。我们有 800 多个模块。

从 struts 到 spring，已经使用了各种框架。根据当时的需要，开发者选择了框架并进行了开发。所以没有标准化。

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

1. 有什么方法可以轻松知道哪些框架会产生影响？
2. 是否有任何可用的 API 信息，以获取任何框架的 JDK 版本？

请告诉我......

Answer 1

有什么方法可以轻松知道哪些框架会产生影响？

没有简单的方法。

您需要阅读您正在使用的每个框架的文档，以确定是否需要对其进行升级。

或者只是尝试升级 Java 平台，看看有什么问题。 （作为一般规则，Java 6 到 Java 8 的迁移不会出现问题。Java 8 到 Java 11 会出现更多问题......但这不是你现在要做的。）

是否有任何信息可作为 API，获取任何框架的 JDK 版本？

没有这样的 API。

Answer 2

升级会告诉你，通过一些测试。如果您有一个包含 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();
    }
}