*.class ändern/ersetzen/überschreiben

[enemy]

hi,

habe mir etwas schwer getan mein problem kurz für den titel zu formulieren...ich hoffe ihr verzeiht mir :)

ich habe folgendes problem:
es gibt da eine opensource applikation, die ich vor gut 2 jahren auf meine bedürfnisse angepasst habe.
das lief nun wie gesagt seit ewigkeiten wunderbar, nur seit dem diese anwendung nun aktualisiert wurde, verursachen einige methoden aus meinen änderungen probleme...
und selbstverständlich ist in diesen zwei jahren mein quellcode verschwunden :/

der versuch diese klassen zu decompelieren ist gescheitert, da der erzeugte code einige hundert (gemeine) fehler enthält und ich im grunde schneller währe, wenn ich das ganze neuschreiben würde :(

meine bisherige und einzige idee ist folgende:
eine zweite klasse schreiben und von der alten erben lassen. in dieser klasse die meisten aufrufe auf die super klasse umzuleiten und nur die nötigen methoden zu überschreiben. es sind zwar noch immer einige zeilen code zu schreiben und ich müsste ein haufen aufrufe auf die neue klasse umleiten, allerdings würde das den aufwand erheblich minimieren (im vergleich zum decompelieren und fehler fixen).


nach so viel text ist meine eigentliche frage ganz kurz:
habt ihr evtl. bessere ideen? eine möglichkeit die mir vielleicht noch ein paar tage arbeit sparen könnte?


mfg
enemy

[Trap]

Es gibt verschiedene Decompiler, hast du alle probiert?

Eine andere Möglichkeit, wenn du nur wenig ändern musst, wäre disassembler und assembler.

[Gast]

joa, probiert habe ich die gängigen, d.h. also die ersten google treffer ;)
das problem ist halt, dass der code danach nicht mehr compelierbar ist, z.b. durch falsch platzierte super aufrufe und deklarationen von reservierten variablen (this$1) oder so sachen wie '_L1:'
und das ganze halt auf einige zeilen verteilt...

und ändern muss ich am eigentlichen code wirklich nicht viel, aber Disassembler? also verstehen tue ich davon nicht viel, oder zumindest ist es schon ne recht lange weile her... da werde ich glaub noch mehr zeit brauchen...

[Berni]

Disassembler und Assembler bei Java Bytecode? Wie soll das gehen?

[Coda]

http://sourceforge.net/projects/jasmin

[gereggter Gast]

Womit decompilierst du? Mit Jad? Wenn nein, dann nimm Jad.
Mit Jadclipse gibt es sogar ein Plugin für Eclipse.

Deine bisherige einzige Idee ist nicht gut. Composition ist das Stichwort!

Alternativ kannst du auch den Bytecode während der Laufzeit manipulieren. Damit kannst du dann den fehlerhaften Code umgehen. Das geht z.B. mit Javassist.

[gereggter Gast]

Noch ein Tipp für die Zukunft.....
Beim Erstellen deiner jar Library kopiere den Sourcecode mit hinein. Dann geht der Sourcecode nicht mehr verloren.

[Gast]

Womit decompilierst du? Mit Jad? Wenn nein, dann nimm Jad.

probiert habe ich jad/jd decompiler/jasmin und noch ein paar andere. aber im großen und ganzen ist das ergebnis immer gleichschlecht

[Gast]

Deine bisherige einzige Idee ist nicht gut. Composition ist das Stichwort!


habe ich erst jetzt gelesen^^
ich habe ja geschrieben das ich die imports aus anderen klassen anpassen müsste...[oder habe ich dich falsch verstanden?]

[enemy]

so ist fertig :p

habe die klasse mit nem bytecode editor umbenannt und diese in einer neuen erweitert.

class -> class_old - neue class extends class_old

und da die notwendigen methoden überschrieben

[registrierter Gast]

habe ich erst jetzt gelesen^^
ich habe ja geschrieben das ich die imports aus anderen klassen anpassen müsste...[oder habe ich dich falsch verstanden?]
Composition bezeichnet eine Klasse, in welcher es ein Objekt gibt, welches beim Initialisieren der Klasse initialisiert wird. In die Klasse selbst fügst du alle Methoden hinzu, welche es auch für das Objekt gibt und leitest auf die entsprechenden Methoden des Objektes weiter.
So kannst du steuern, welche Methode unverändert weiter geleitet wird, für welche Methode du vorher Anpassungen durchführen möchtest und welche Methode du komplett anders bearbeiten möchtest.

z.B. so:

public class StringList {
private List<String> list;

public StringList() {
list = new ArrayList<String>();
}

/**
* Simple Weiterleitung zur size-Methode der Liste.
*/
public int size() {
return list.size();
}

/**
* Simple Weiterleitung zur add-Methode der Liste.
*/
public void add(String string) {
return list.add(string);
}

/**
* Leitet zuerst auf die in der Liste bestehende Methode
* weiter, fügt vor das Ergebnis noch einen anderen
* String an.
*/
public String get(int i) {
return "3DCenter_ist_" + list.get(i);
}


public static void main(String[] argv) {
StringList stringList = new StringList();
stringList.add("orange");
System.out.println(stringList.get(0));
}
}

Diese Composition ist schnell mal zusammen getippt. Es fehlen etliche Methoden, die auch einer normalen Liste zur Verfügung stehen. Aber die get-Methode verdeutlicht, was eine Composition machen kann.

Composition hat gegenüber Vererbung vor allem bei Klassen, welche man nicht kennt einen enormen Vorteil. Bei den zu erbenden Klassen weiß man nie, was intern geschieht. Wenn man dann eine Methode überschreibt, kann dies unberechenbare Folgen bis hin zu kritischen Fehlern haben.