Kurze Beschreibung
Ich war immer besorgt über Javas Mangel an vorbereiteten Delegationsmechanismus. Glücklicherweise habe ich in letzter Zeit einige Zeit und schrieb ein einfaches Delegationsmodul mit Reflexion als Referenz.
Modul -API
Die öffentliche Klasse Delegater () // leere Parameterkonstruktion verwaltet diese Klasse die Delegateinstanz und implementiert die Delegate -Methode // Fügen Sie eine statische Methode Delegierter hinzu und gibt die Ganzzahlwert -ID zurück, um die aus der Methode und den Parametern zusammengestellte Instanz darzustellen. Wenn es fehlschlägt, geben Sie -1 zurück. public synchronisierte int addfunctionDelegate (Klasse <?> SRCClass, String MethodName, Objekt ... Params); // Fügen Sie eine Instanzmethode Delegate hinzu, die Ganzzahlwert -ID zurückgeben, um die Instanz darzustellen, die aus der Methode und den Parametern zusammengestellt wird. Wenn es fehlschlägt, geben Sie -1 zurück. public synchronisierte int addfunctionDelegate (Objekt SRCOBJ, String MethodName, Objekt ... Params); // Löschen eines Methoden -Delegierens aus der Delegierteninstanz basierend auf der Ganzzahl -ID und zurückzahlen, ob es sich invokeAllMethod();//Convert the parameter table to parameter type table private Class<?>[] getParamTypes(Object[] params);//Get the method instance private Method from the specified Class, method name, and parameter type table private Method getDstMethod(Class<?> srcClass,String methodName,Class<?>[] paramTypes);class DelegateNode(Method RefMethod, Object [] Params) // Die Delegatenode -Klasse beschreibt eine statische Methode -Delegation, wenn keine Objektkonstruktion verwendet wird, einschließlich Methodeninstanzen und Parametertabellen. Klasse DelegateNode (Objekt SRCOBJ, Method RefMethod, Object [] Params) // Delegatenode -Klasse beschreibt eine Instanzmethode Delegation bei der Verwendung von Objektkonstruktionen, einschließlich Klasseninstanzen, Methodeninstanzen und Parametertabellen Public Void Invocemethod (); // Die Methode -Delegation, die die Beschreibung des Knotens ausführt, ist.
Quellcode
Importieren Sie java.lang.reflect.invocationTargetException; import Java.lang.reflect.Method; Import Java.util.hashtable;/** Delegaterklasse verwendet RTTI und Reflection, um den Delegate-Mechanismus in Java *Author Drei-Way-Backstein zu implementieren. Variable Hashtable <Integer, Delegatenode> Nodetable; // ID verwalten und der Container des entsprechenden Delegierten -öffentlichen Delegaters () {nodetable = new Hashtable <Integer, Delegatenode> ();} // add statische Methode Delegate öffentlich synchronisierte int addtunctiondelegate (class) <? {Class <?> [] Paramtypes = getParamTypes (Params); Methode RefMethod; if (refMethod = getdstMethod (srcclass, methodname, paramtypes)! Methode Delegate public synchronisierte int addfunctionDelegate (Objekt SRCOBJ, String MethodName, Objekt ... Params) {Klasse <?> [] paramtypes = getParamTypes (Params); Methode RefMethod; if ((RefMethod = getdstMethod (srcobj.getClass {register++;nodeTable.put(register,new DelegateNode(srcObj,refMethod, params));return register;} else {return -1;}}//Delete a method delegate public synchronized Boolean removeMethod(int registerID) {if(nodeTable.containsKey(registerID)) {nodeTable.remove(registerID);return true;}return false;}//Execute the delegate method unorderedly public synchronized void invokeAllMethod() {for (DelegateNode node:nodeTable.values()) {node.invokeMethod();}}//Convert the parameter table into a parameter type table private Class<?>[] getParamTypes(Object[] params) {Class<?>[] paramTypes = Neue Klasse <?> [params.length]; für (int i = 0; i <params.Length; i ++) {paramtypes [i] = params [i] .getClass ();} Paramtypes return; paramtypes) {Methode result = null; try {result = srcclass.getMethod (methodName, paramtypes); if (resultReturnType ()! {System.out.println ("kann keine Methode gefunden:"+methodName+", stellen Sie sicher, dass es existiert und sichtbar ist!");} Return Ergebnis;}} Klasse Delegatenode {Object Srcobj; this.params = params;} public delegateNode (Object Srcobj, Methode RefMethod, Object [] Params) {this.srcobj = srcobj; this.refMethod = refMethod; this.params = params;} public void invokemethod () {try {refMethod.invoke (srcobj, params);} catch (illegalAccessException | illegalArgumentException | InvocationTargetException E) {System.out.println (";Modultests
öffentliche Klasse Delegatertest {public void showInfo () {System.out.println ("Hallo Delegate!"); showCustomstaticInfo (String info) {System.out.println (info);} public static void main (String [] args) {delegater dele = new delegater (); Dele.AddfunctionDelegate (Tester, "ShowInfo"); Dele.AddfunctionDelegate (Tester, "Showcustominfo", "Custom!"); Dele.addfunctionDelegate (Delegatertest.Class, "ShowstaticInfo"); Dele.addfuncti ONDELEGATE (DelegaterTest.Class, "ShowcustomstaticInfo", "staticCustom!"); Dele.invokeallMethod (); --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Ausführungsergebnisse:
Staticcustom!
StaticDelegate!
Brauch!
Hellodelegate!
----------------------
Staticcustom!
StaticDelegate!
Brauch!
Andere Angelegenheiten
Einige öffentliche Methoden verwenden synchronisiert, um die Gewindesicherheit von Registervariablen zu gewährleisten, damit sie aufgrund mehrerer Threads keine Fehler machen.
Für Delegierte mit Rückgabewerten wird eine Warnung ausgestellt, das Modul akzeptiert jedoch immer noch solche Delegationen, aber Sie erhalten den Rückgabewert bei der Ausführung der Delegation nicht.
Der maximale Wert des hinzugefügten Delegiertens ist der Fehlertoleranzprozess nach Integer.max_Value-Integer
Die delegierte Ausführung ist ungeordnet, und wenn Leistungsanforderungen erforderlich sind, versuchen Sie, die delegierte Funktion nicht zu blockieren, andernfalls wirkt sich dies auf die Ausführung anderer delegierter Funktionen aus.
Alle anderen Fragen können zum Besprechen gestellt werden.
Zusammenfassen
Das obige ist die detaillierte Erklärung dieses Artikels über die Implementierung des Delegierten -Mechanismus -Code in Java durch Reflexion. Ich hoffe, es wird für alle hilfreich sein. Interessierte Freunde können weiterhin auf andere Java-bezogene Themen auf dieser Website verweisen. Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen. Vielen Dank an Freunde für Ihre Unterstützung für diese Seite!