1

当我得到一个 java.io.InvalidClassException 时，它给了我它想要的 serialVersionUID，以及它得到的 serialVersionUID。有没有一种简单的方法可以判断我的几十个 jar 中的哪一个使用了错误的 serialVersionUID？

更新：我应该提到我们的意图是同时更新所有内容，但我正在尝试调试我们构建和部署过程中的问题。

4

6 回答 6

5

对 jar 中的每个类使用来自 sun jdk 的 serialver 工具。

于 2008-10-10T18:51:56.327 回答
2

处理这种麻烦的最好方法是同时更新服务器端和客户端的 jars。这将保证双方的类版本相同，并且在序列化/反序列化时不会遇到麻烦。每次遇到此问题时跟踪串行 UID 并不能解决任何问题，只会浪费大量时间和资源。花一些时间并实施适当的部署/打包策略要好得多。

如果你真的没有其他选择，你可以编写一个工具，从每个 jar 中加载一个类（使用 URLClassLoader），然后使用它java.io.ObjectStreamClass.getSerialVersionUID()来获取你需要的信息。

于 2008-10-10T15:17:58.037 回答
2

请记住，各种 JVM/容器/类加载器组合对于应该从引导类路径和应用程序/webapp 类路径加载哪些类有不同的看法。

由于 serialver 总是首先从 bootclasspath 加载，这很复杂，因此您可能需要使用 -J-Xbootclasspath 来模拟不同的行为：

f=/System/Library/Frameworks/JavaVM.framework/Versions/1.5/Classes/
serialver -J-Xbootclasspath:.:$f/dt.jar:$f/classes.jar:$f/ui.jar javax.xml.namespace.QName

另一种方法是使用javap，例如：

javap -verbose -bootclasspath . javax.xml.namespace.QName | sed -n -e '/static.*serialVersionUID/{N;p;}'
于 2008-12-09T19:47:08.483 回答
2

根据 SO 中的一些答案，我想出了一个实用程序来执行此操作。这是我的课。

package jar;

import java.io.File;
import java.io.IOException;
import java.io.ObjectStreamClass;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;


/**
 * Searches all the jars in a given directory for a class with the given UID.
 * Additional directories can be specified to support with loading the jars.  
 * For example, you might want to load the lib dir from your app server to get
 * the Servlet API, etc.  
 */
public class JarUidSearch
{
    public static void main(String args[])
            throws IOException, ClassNotFoundException
    {
        if( args.length < 2)
        {
            System.err.println("Usage: <UID to search for> <directory with jars to search> [additional directories with jars]");
            System.exit(-1);
        }

        long targetUID = Long.parseLong(args[0]);

        ArrayList<URL> urls = new ArrayList<URL>();

        File libDir = new File(args[1]);

        for (int i = 1; i < args.length; i++)
        {
            gatherJars(urls, new File(args[i]));
        }

        File[] files = libDir.listFiles();

        for (File file : files)
        {
            try
            {
                checkJar(targetUID, urls, file);
            }
            catch(Throwable t)
            {
                System.err.println("checkJar for " + file + " threw: " + t);
                t.printStackTrace();
            }   
        }
    }

    /**
     * 
     * @param urls
     * @param libDir
     * @throws MalformedURLException
     */
    public static void gatherJars(ArrayList<URL> urls, File libDir)
            throws MalformedURLException
    {
        File[] files = libDir.listFiles();

        for (File file : files)
        {
            urls.add(file.toURL());
        }
    }

    /**
     * 
     * @param urls
     * @param file
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static void checkJar(long targetUID, ArrayList<URL> urls, File file)
            throws IOException, ClassNotFoundException
    {
        System.out.println("Checking: " + file);
        JarFile jarFile = new JarFile(file);
        Enumeration allEntries = jarFile.entries();
        while (allEntries.hasMoreElements())
        {
            JarEntry entry = (JarEntry) allEntries.nextElement();
            String name = entry.getName();

            if (!name.endsWith(".class"))
            {
                // System.out.println("Skipping: " + name);
                continue;
            }

            try
            {
                URLClassLoader loader = URLClassLoader.newInstance((URL[]) urls.toArray(new URL[0]));
                String className = name.substring(0,
                    name.length() - ".class".length()).replaceAll("/", ".");
                Class<?> clazz = loader.loadClass(className);
                ObjectStreamClass lookup = ObjectStreamClass.lookup(clazz);

                if (lookup != null)
                {
                    long uid = lookup.getSerialVersionUID();

                    if (targetUID == uid)
                    {
                        System.out.println(file + " has class: " + clazz);
                    }
                }
            }
            catch (Throwable e)
            {
                System.err.println("entry " + name + " caused Exception: " + e);
            }
        }
    }
}
于 2014-09-24T18:02:43.200 回答
0

笨拙但有效

我会使用逆向工程工具
1）解压缩 jar
2）在类文件树上运行 jad
3）在这个新的源树上运行 grep 或任何其他查找工具来查找串行版本的 uid。

于 2008-10-10T16:41:12.520 回答
0

我在 Linux 上使用这个命令来检查当前目录中的所有 Jar：

find . -type f -name "*.jar" -exec sh -c 'javap -verbose -p -constants -cp {} com.myCompany.myClass | grep serialVersionUID' \;

请记住，serialVersionUID 可能未在您的类中明确声明。在这种情况下，serialVersionUID 将在运行时计算，并且无法使用上面的 find 命令进行搜索。

于 2021-04-20T06:20:25.413 回答