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

Question

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

从支柱到弹簧，已经使用了各种各样的框架。基于当时的需要，开发人员选择了框架并进行了开发。所以没有标准化。

现在我们需要将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();
}
}