When I get a java.io.InvalidClassException, it gives me the serialVersionUID that it wants, and the serialVersionUID that it got. Is there an easy way to tell which of my dozens of jars using the wrong serialVersionUID?
Update: I should mention that our intention is to update everything at the same time, but I'm trying to debug a problem in our build and deploy process.
The best way to deal with this kind of trouble is to update jars on the server and client side at the same time. This will guarantee the same version of your classes on both sides and you'll not have trouble when serializing / deserializing. Tracking serial UIDs each time you have this problem is not going to solve anything, you're only going to waste considerable time and resources. Its much better to spend some time and implement a proper deployment / packaging strategy.
If you really don't have any other choice, you can write a tool that loads a class from each jar (using a URLClassLoader) and then use java.io.ObjectStreamClass.getSerialVersionUID() to obtain the information you need.
I came up with a utility to perform this, based on some answers in SO. Here's my class.
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);
}
}
}
}
Bear in mind that various JVM/container/classloader combinations have different opinions on which classes should be loaded from the bootclasspath versus the application/webapp classpath.
This is complicated by the fact that serialver always loads from the bootclasspath first, so you may need to use -J-Xbootclasspath as below, to simulate different behaviour:
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
Another approach is to use javap, for example:
javap -verbose -bootclasspath . javax.xml.namespace.QName | sed -n -e '/static.*serialVersionUID/{N;p;}'
clumsy but works
i would use a reverse engineering tool
1) unzip the jars
2) run, say, jad on the class file tree
3) run grep or any other find tool on this new tree of source to look for the serial version uid.
I was using this command on Linux to examine all Jars in current directory:
find . -type f -name "*.jar" -exec sh -c 'javap -verbose -p -constants -cp {} com.myCompany.myClass | grep serialVersionUID' \;
Please bear in mind that serialVersionUID might be not declared in your class explicitly. In that case serialVersionUID will be calculated at runtime and cannot be searched for using find command above.
