Reflection und Serializable

[Mewel]

Hoi,

ich habe eine externe Klasse mit einem eigenen URLClassLoader geladen. Auf diese Klasse kann ich dann auch ganz normal zugreifen (Instanzen bilden und auf deren Methoden zugreifen). Die Klasse implementiert das Interface Serializable.

Nun möchte ich die Klasse über ByteArrayOutputStream und ObjectInputStream kopieren. Ich bekomme aber immer eine "java.lang.ClassNotFoundException".

Alle andere Klassen kann ich kopieren, funktioniert prima, nur bei den selbst geladenen Klassen bekomm ich den Fehler. Jemand ne Idee wo das Problem liegt?

Danke schon mal, Mewel


ps. Kann es sein das die Klasse "java.lang.reflect.Method" nicht serilisierbar ist, die Klasse "java.lang.Class" aber schon?

 

[Guest]

Nein, das liegt daran, dass die geladenen Klassen nur im Kontext deines URL-Classloaders
bekannt sind. Die Streams instanzierst du aber über den System-Classloader, der deine
geladenen Klassen nicht kennt. Ein Lösung wäre, die Streams über deinen Classloader zu
laden.

 

[Mewel]

Ich benötige aber beide, die Klassen aus dem System-Classloader und die aus meinem.

Wie ich es aus meinem Classloader laden soll, wüsst ich aber auch nicht.

 

[Guest]

Scheibe eine Art Boootstrap-Klasse, die über deinen Classloader geladen wird und das
Hauptrogramm startet. Dadurch wird gewährleistet, dass alles über deinen Classloader
läuft. Dein Classloader kennt den System-Classloader (erbt ja davon), umgekehrt ist
es leider nicht der Fall.

 

[Mewel]

Ok, hab mich grad ma informiert was der Bootstrap-Classloader überhaupt ist.

Aber wie ich so ein Teil implementieren sollte hab ich keine Ahnung ^^.

 

[Mewel]

Ich habe nun doch noch eine Lösung für das Problem gefunden. Ist zwar ein bisschen tricky und ich finde sie auch nicht sehr hübsch aber funktioniert wunderbar.

Man muss eine Klasse von "ObjectInputStream" ableiten (Fehler tritt nur beim lesen, nicht beim schreiben auf) und die Methoden die die Methode "private static native ClassLoader latestUserDefinedLoader();" nutzen überschreiben.

Nun kann man einfach seinen ClassLoader im Konstruktor mit übergeben und diesen nutzen.

public class MyObjectInputStream extends ObjectInputStream {

	private ClassLoader classLoader = null;

	/** table mapping primitive type names to corresponding class objects */
	private static final HashMap primClasses = new HashMap(8, 1.0F);
	static {
		primClasses.put("boolean", boolean.class);
		primClasses.put("byte", byte.class);
		primClasses.put("char", char.class);
		primClasses.put("short", short.class);
		primClasses.put("int", int.class);
		primClasses.put("long", long.class);
		primClasses.put("float", float.class);
		primClasses.put("double", double.class);
		primClasses.put("void", void.class);
	}

	protected MyObjectInputStream(ClassLoader newClassLoader) throws IOException, SecurityException {
		super();
		classLoader = newClassLoader;
	}

	public MyObjectInputStream(ClassLoader newClassLoader, InputStream in) throws IOException {
		super(in);
		classLoader = newClassLoader;
	}

	protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
		String name = desc.getName();
		try {
			return Class.forName(name, false, classLoader);
		} catch (ClassNotFoundException ex) {
			Class cl = (Class) primClasses.get(name);
			if (cl != null) {
				return cl;
			} else {
				throw ex;
			}
		}
	}

	protected Class<?> resolveProxyClass(String[] interfaces) throws IOException, ClassNotFoundException {
		ClassLoader latestLoader = classLoader;
		ClassLoader nonPublicLoader = null;
		boolean hasNonPublicInterface = false;

		// define proxy in class loader of non-public interface(s), if any
		Class[] classObjs = new Class[interfaces.length];
		for (int i = 0; i < interfaces.length; i++) {
			Class cl = Class.forName(interfaces[i], false, latestLoader);
			if ((cl.getModifiers() & Modifier.PUBLIC) == 0) {
				if (hasNonPublicInterface) {
					if (nonPublicLoader != cl.getClassLoader()) {
						throw new IllegalAccessError("conflicting non-public interface class loaders");
					}
				} else {
					nonPublicLoader = cl.getClassLoader();
					hasNonPublicInterface = true;
				}
			}
			classObjs[i] = cl;
		}
		try {
			return Proxy.getProxyClass(hasNonPublicInterface ? nonPublicLoader : latestLoader, classObjs);
		} catch (IllegalArgumentException e) {
			throw new ClassNotFoundException(null, e);
		}
	}
}

Das wär natürlich noch schöner:
http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4638170

Sieht aber nich so aus als ob das bald was wird