Hallo Zusammen
Ich habe eine Frage ist es möglich mittels Java Reflection ein Objekt eine Interface zu implementieren
ein Beispiel:
ich habe eine Klasse Test, bei dieser Klasse wird kein Interface implementiert. Nun möchte ich aber diese Klasse serialisieren, für diese Vorgehen muss aber das Interface das Serializable implementieren. nun werden die Klassen im Class.forName() geladen. Muss ich jetzt jeder Klasse das Implemts hinzufügen oder gibt es eine Möglichkeit diesen Vorgang zu automatisieren****
mit freundlichen Grüssen
Raphael Fehlmann

also wenn du jetzt objekte wirklich serialisieren willst *um sie z.b. über einen object-stream schicken zu können* müssen die entsprechenden klassen nunmal das Serializeable-interface implementieren ...
wie das nun genau funktioniert müssen dir die anderen mal verraten oder du fragst google ...

ach und btw : arbeite mal bitte an deiner ausdrucksweise ... es ist schwer einen solchen text zu lesen und vorallem zu verstehen

Zitat von SPiKEe

also wenn du jetzt objekte wirklich serialisieren willst *um sie z.b. über einen object-stream schicken zu können* müssen die entsprechenden klassen nunmal das Serializeable-interface implementieren ...
wie das nun genau funktioniert müssen dir die anderen mal verraten oder du fragst google ...

ach und btw : arbeite mal bitte an deiner ausdrucksweise ... es ist schwer einen solchen text zu lesen und vorallem zu verstehen

*hust* Das könnte ich manchmal auch zu dir sagen *hust*

Zum Problem:
Wenn ich dich richtig verstehe, willst du eine Art "nachträgliche Implementierung eines Interfaces in eine Klasse" oder? Ich habe sowas noch nicht ausprobiert, aber ich glaube auch nicht, dass das geht. Wenn eine Klasse kompiliert wird, dann enthällt der kompilierte Bytecode alle Informationen zu der Klasse. Ich denke also nicht, dass du die Klasse "on the fly" via Reflection ändern kannst, höchstens mit einem selbstgebautem "Live-Compiler".

Das ist jedenfalls meine Antwort. Ich lasse mich natürlich belehren, wie gesagt, ich habe in der Richtung auch noch nix gemacht, daher ist meine Antwort eher "Glaube" als "Wissen".

Hallo danke für deine Antwort.
das ist mir scho klar das die Klassen diese Interface implementieren müssen. ich wollte eigentlich wissen ob es möglich ist ein Interface zu implemtieren aber in dem ich das Interface über Reflection hinzufüge. Also so das ich nicht in jeder Klasse sagen muss "implements Serializeable"
gruss
raphael

@Akeshihiro
gut .. geb ich zu und bin ich als kritik-punkt mir gegenüber auch völlig mit einverstanden

zum thema
gut ... verräts du uns dann auch mal bitte WIE du dir das so vorstellst ?
du kannst über reflections schlecht die compilete klasse manipulieren ...
du kannst lediglich auf objekte in diesen klassen zugriefen und mit diesen arbeiten ... das wars dann aber auch schon ...

btw : es heißt DAS interface ... nicht DIE interface ...

Achso, was die "Unmöglichkeit" angeht, C- und C++-Leute kennen das Wort nicht, zur Not wird im Speicher direkt gepfuscht, aber da Java nicht so tief gehen kann, denke ich, dass das auf Java-Wege nicht machbar ist.

EDIT:
Ach SPiKEe, warum meldest du dich nicht mal im Forum an? Du hast hier schon so viele Posts hinterlassen und kommst auch immer wieder, da wäre eine Account doch nicht schlecht oder? Son Gast-Zugang muss doch auf Dauer langweilig sein oder?

Zitat von Akeshihiro

Achso, was die "Unmöglichkeit" angeht, C- und C++-Leute kennen das Wort nicht, zur Not wird im Speicher direkt gepfuscht, aber da Java nicht so tief gehen kann, denke ich, dass das auf Java-Wege nicht machbar ist.

der post war echt n leerschuss ...
wir reden hier von JAVA-Reflections ...
und darauf war auch meine aussage bezogen ...

zu deinem edit im vor-post : live-compiler ? ... gut ... stell ich mir sehr interessant vor ... aber müsste man dafür dann nicht erstmal die entsprechenden source-files haben *meinet wegen auch mit vorgeschaltetem de-compiler* ... weil ich glaube nicht das du ein objekt *dessen klasse im classloader gehalten wird* einfach so editieren kannst *die diskusion hatten wir erst neulich bei meinem update-thread*
von daher wird ein *nachträgliches* editieren der instanz doch eingentlich unmöglich weil 1) die class im classloader hängt und 2) dann aus der neuen erst eine neue instanz erzeugt werden müsste ... wäre ziemlich speicher-intensiv ein solches vorgehen ...

Das mit der C/C++-Geschichte war nur so nebenbei, um zu zeigen, dass das geht (bzw. theoretisch gehen müsste, ich bin auf dem Gebiet auch nicht bewandert), aber eben nicht mit Java.

Ja, mit einem Live-Compiler bräuchte man die Sources, hast du auch recht. Und genau da fängt schon das Problem an, wie kommt man an den Source-Code ran? Zur Not dekompilieren, aber wie zuverlässig die Decompiler sind, weiß ich nicht. Den Update-Thread habe ich verfolgt und ich weiß, dass das nicht geklappt hat. Allerdings könnte es vielleicht klappen, wenn das Programm sich "selbst" startet o.O Der erneute Start hätte eigentlich eine neue Programminstanz zur Folge und somit würden sich die ClassLoader unterscheiden, der neue ClassLoader würde also die neue Klasse laden.

Aber das sind alles Spekulationen, ich kann das alles nicht beweisen, habs auch selbst nicht ausprobiert.

SPiKEe hat leider recht, ich habe es jetzt so gemacht das ich halt die Angaben von Hand erstellt habe.
Allerdings bin ich auf ein interessantes Framework gestossen mit dem es gehen soll hier mal der link:
http://www.gnu.org/software/kawa/
muss aber mir noch genauer anschauen

Hallo,

einer einzelnen Objekt-Instanz die schon existiert kannst du kein Interface unterschieben. Dazu müsstest bevor eine Instanz erzeugt wird die Klasse erweitern. Neben der einfachen Möglichkeit dann den entsprechenden Klassen Serializable anzutragen (warum ist dass denn überhaupt ein Problem?) gibts für dein Problem auch mehrere mehr oder weniger exotische Lösungen.

Eine Möglichkeit wäre beispielsweise deine Klassen (ohne Serializable) für die Serialisierung in einen Serialisieruns Proxy zu wrappen und diesen dann zu serialisieren, dabei enthält der Proxy quasi die Serialsiierungslogik für das gewrappte Objekt. So kann der Proxy durch implementieren des Externalizable (extends Serializable) über readExternal / writeExternal die Serialisierung durchführen.

Diese Proxies kann man statisch aber auch dynamisch (generisch mit Reflection über einen JDK DynamicProxy) definieren.


Eine weitere Möglichkeit wurde schon angedeutet, nämlich durch ByteCode Modifikation. Dazu hat man natürlich auch wieder mehrere Möglichkeiten. Entweder man schreibt sich einen eigenen ClassLoader der dann mit BCEL oder ASM den ByteCode um die Implementierung von Serializable erweitern (hat dann aber aber wie schon erwähnt eventuell ClassLoader / ClassCastEx Probleme). Ein andere Möglichkeit zur ByteCode Manipulation bietet sich über Instrumentierung über einen eigenen Java-Agent an: (hier mal ein beispiel:
http://www.tutorials.de/java/245814-...tgroessen.html) durch das Instrumentation Interface kann man den ByteCode ändern bevor er im AppClassLoader sichtbar wird.

Das jetzt mal kurz dazu. Da das alles jedoch ziemliche Hacks sind würde ich hier zwei Varianten klar vorziehen:

1) Ich würde mir nochmal überlegen ob es wirklich so umständlich ist die entsprechenden Klassen Serializable implementieren zu lassen würde ich das tun.

2) Ich würde hier wohl Custom Serialisation verwenden (entweder über den Proxy-Ansatz oder von Hand mit einem DataOutputStream)

3) Verwende einfach einer andere Serialisierungs Lib die nicht auf Serializable arbeitet: http://xstream.codehaus.org/

Gruß Tom

Hallo
danke für deine Antwort wie gesagt habe es jetzt so gelöst das ich die Klasse in eine andere Klasse die Serializable implementiert. Die ganze Frage hat auch noch ein bisschen darauf abgezielt wie weit ich eine bereits existierende Klasse verändern kann. Demnach ist es auch nicht möglich Methoden oder Variablen zu Objekte hinzu zufügen?
Danke für eure Hilfe
gruss raphael