Heiner KückerProxy-Methoden |
|
|
Home Java-Seite Weiterentwicklung_Java NullPointer Algorithmische Symmetrie Finder_Feature Multiple_Interface Implementationen Proxy_Methoden Speicher_Klassen WebCam_Demo JSP WorkFlow PageFlow FlowControl Page Flow Engine Control_and_Command JSP_Spreadsheet Domain Parser Codegenerator_für hierarchische Datenstrukturen Expression_Engine Formula_Parser State Transition Engine AspectJ Java_Explorer DBF_Library Kalender_Applet SetGetGen BeanSetGet CheckPackage LineNumbers GradDms Excel-Export StringTokenizer JspDoc JspCheck JSP-Schulung Java Server Pages Struts AsciiTabellenLayouter StringSerial Silbentrennung JDBC_Schlüssel- Generierung bidirektional/ unidirektional gelinkte Liste Java_Sitemap Generator XmlBuilder RangeMap Alaska-XBase++-Seite Projekte Philosophien Techniken Konzepte Sudoku Kontakt / Impressum Links SiteMap Letzte Aktualisierung: 30.08.2002 |
Proxy-MethodenBei der Vererbung überschreiben oder überdecken die Methoden der vererbten Klassen die Methoden der Elternklasse. Es ist möglich, aus den Methoden der Kind-Klasse die Methoden der Eleternklasse aufzurufen.
public void method(){
...
super.method();
...
}
Das bedeutet, daß der Code der Kindklasse den Code der Elternklasse wrappt.
+---------------------------+ | Code der Kindklasse | | +-----------------------+ | | | Code der Elternklasse | | | +-----------------------+ | +---------------------------+Das Aufrufen des Codes der Kindklasse aus der Elternklasse ist nicht so einfach möglich. Hierfür gibt es abstrakte Klassen.
abstract class ParentClass{
public void method(){
...
protectedMethod();
...
}
abstract public protectedMethod();
}
class ChildClass extends ParentClass{
protected protectedMethod(){
...
}
}
Das Problem dabei ist, daß beim nachträglichen Einführen des wrappenden Codes,
alle Kind-Klassen geändert werden müssen.
Alternativ kann man diese Problematik auch mit Dekoratoren, Delegates oder Proxys lösen. Bei jeder dieser Lösungen muß aber noch weiterer Code hinzugefügt bzw. geändert werden.
LösungsvorschlagDurch das Hinzufügen neuer Schlüsselworte wird der Compiler angewiesen Code zu erzeugen, der dafür sorgt, daß stets der Code der Elternklasse aufgerufen wird. Wahrscheinlich sind dabei auch Änderungen an der JVM nötig, da in den virtuellen-Methoden-Tabellen der Klassen auf Methoden der Elternklasse verlinkt werden muß.
+---------------------------+
| Code der Elternklasse |
| +-----------------------+ |
| | Code der Kindklasse | |
| +-----------------------+ |
+---------------------------+
class ParentClass{
public proxy void method(){
...
sub.method();
...
}
}
class ChildClass extends ParentClass{
public [proxed] method(){
...
}
}
Der Bezeichner proxy kennzeichnet eine Proxy-Methode in der Elternklasse.
Der Bezeichner sub kennzeichnet den Aufruf der Methode der Kind-Klasse. Der optionale Bezeichner proxed kennzeichnet eine gewrappte Methode der Kindklasse. Dieser Bezeichner soll hauptsächlich dazu dienen, daß beim Lesen des Codes die Umleitung sofort erkennbar ist. Eigentlich ist er nicht nötig und insofern nachteilig, daß beim Einfügen einer Proxy-Methode doch noch Code-Änderungen an anderen Stellen nötig sind. Günstiger ist es, wenn javadoc und die IDE hier eine Information geben. Ich bin mir nicht sicher, ob die Bennenung der neuen Bezeichner optimal ist und mit der Sprach-Spezifikation harmoniert. Hier können Änderungen nötig sein. Die neuen Sprach-Features wirken sich auch auf das Reflection-API aus.
ErweiterungWünschenswert wäre die Möglichkeit wrappenden Code zum Debugging, Test oder für erweiterte Funktionalität, einer Gruppe von Methoden mitzugeben.Die Gruppierung der ausgeählten Methoden könnte nach Applikation, Package, Klasse, Elternklasse oder -interface sowie nach Methoden-Name und -Signatur entsprechend einem Muster erfolgen. Neben der Zuschaltung der Funktionalität beim Compilieren ist eine Lösung zum Zuschalten zur Laufzeit wünschenswert. Das könnte über das Umhängen der Methoden-Zeiger in den virtuellen-Methoden- Tabellen der Klassen erfolgen. Anstelle der konkreten Methode wird ein Zeiger auf die Proxy-Methode mit einem Zusatzfeld für die Original-Methode gesetzt. Das Zusatzfeld ermöglicht der Proxy-Methode den Aufruf der Original-Methode über den sub-Operator. Die Proxy-Methode benötigt eine Möglichkeit Informationen über die Methode, Klasse und das konkrete Objekt zu bekommen sowie Zugriff auf die Parameterliste der Methode. Eine solche Erweiterung der JVM ist nicht trivial. |