Seemingly random errors (Class Loading)

Question

Hi,
I wonder if anyone out there could help me or point me in the right direction to solve this problem im having.
For a Uni project I am writing a Java application that takes three components stored in seperate Jar files (GUI, AI, and Model) dynamically from user defined locations by a central loading class.
eg GUIAddress = "c:/java/guis/gui.jar"
Each has a loading class defined in a MANIFEST.MF file within each Jar file and these are in turn defined by interfaces within my central loading program.
I have set it out like this to allow me to quickly test out different components without changing the main structure of the program.
The problem im having is that I keep getting different ClassFormatErrors depending on what I have changed. Errors include:
Local variable name has bad constant pool index
Extra bytes at the end of the class file
Code segment has wrong length
Illegal constant pool index
Code of a method has length 0All these errors are produced with the same compiler (JRE1.4.2) and with minimal changes to the source code.
For example I get the program to a stage where it works then add the un-used constant to a classprivate int foobar = 10; recompile and reload and i get the error Extra bytes at the end of the class file if I take it out again recompile and rerun and alls better.
Now to me that one line shouldnt make a differene to the program in any significant way. But anyway thats just a small example to show you what my problem is.
These problems started when i made a class Span (http://rex.homeip.net/~matt/java/gui/src/gui/graphs/Span.java) which as you can see does nothing special, but when i use it from another class (http://rex.homeip.net/~matt/java/gui/src/gui/GraphViewer.java) all hell breaks loose. Now i know the class is being loaded and methods can be called from it (line 84) but if i try to call setSpan() then i get the error Local variable name has bad constant pool indexIf anyone has any clues please let me know, im getting sick of going round in circles.
Cheers in advance.
Matt
links
Main loading class: http://rex.homeip.net/~matt/java/loader/src/loader/Loader.java
Class Loader: http://rex.homeip.net/~matt/java/loader/src/loader/setup/SetupManager.java
GUI: http://rex.homeip.net/~matt/java/gui/src/gui/Gui.java
GraphViewer: http://rex.homeip.net/~matt/java/gui/src/gui/GraphViewer.java
Span: http://rex.homeip.net/~matt/java/gui/src/gui/graphs/Span.java

Answer 1

I think I have the solution....
I had the same exact (seemingly random) ClassFormatExceptions being thrown from my custom Class-Loader as well. I would get the same variety of debug prints as you (Invalid constant pool, Code segment has wrong length, etc). At times it seemed to happen randomly to different classes that I loaded, depending on small changes I made to the code.
Here is the background and how I solved it.
I dervied from ClassLoader to make my custom class-loader. I overrode the findClass() method, and NOT the loadClass() method. This is the Java 2 method of making class-loaders, which is simplier than implementing your own loadClass() as in the older Java 1.1way of doing things.
My custom class-loader (called JarFileClassLoader, BTW) already had a list of JAR files that it searched when its findClass() method was called from its parent. I was using a JarFile object to examine the contents of a particular JAR file. Once it found the JarEntry that represented the class I wanted to load, it asked for the InputStream by calling:
JarEntry desiredEntry = // assigned to the JarEntry that represents the class you want to load
InputStream myStream = myJar.getInputStream( desiredEntry );
Then I asked how many bytes were available for reading, I created a byte array that could hold that many bytes, and I read the bytes from the InputStream:
int totalBytes = myStream.available();
byte[] classBytes = new byte[totalBytes];
myStream.read( classBytes );
Finally, I would define and resolve my class by:
Class loadedClass = super.defineClass( className, classBytes, 0, classBytes.length );
resolveClass( loadedClass );
Sometimes, on the call to defineClass(), I would get all the weird ClassFormatExeptions.
After the searching around these forums for a while, I found a lot of discussion about this problem, but I didn't find any concrete explanations or solutions. But I did see some cursory discussion about the InputStream class. This lead me to investigate how this class works exactly.
As it turns out, when you call:
myStream.read( classBytes );
it is NOT guaranteed to read all the available bytes and completely fill the byte array you made for it. It could very easily read LESS than the total available bytes. I don't know why it would do this...maybe something to do with internal buffering of the stream. This happens more often on bigger sized class files that you are trying to read.
The read() call will return an integer that represents the actual number of bytes read during that attempt to read. So, the solution is to check if you got all your bytes during the first call to read(), if not, then read some more.
There is another version of the read() method that takes an 'offset' value into your array and a max bytes to read value. I used this method to modify my code to look like:
int total = myStream.available();
int numNeeded = total;
int numRead = 0;
int offset = 0;
byte[] classBytes = new byte[total];
do
numNeeded -= numRead;
offset = numRead;
numRead += inStream.read( classBytes, offset, numNeeded );
} while( numRead < total );
This will continue looping until all the bytes are read. Then I never got those funky ClassFormatExceptions again. Before my fix, I was getting partial class definitions from calls to read() that didn't return all the bytes. Depending on which part of the class was omitted, I got the varied error prints that you got. Now, after this fix, it seems to work just fine.
Hope this helps!
-Mark