Descripción breve
Siempre me ha preocupado la falta de mecanismo de delegación de Java. Afortunadamente, tengo algún tiempo recientemente y escribí un módulo de delegación simple con reflexión de referencia.
API del módulo
Public Class Delegater () // Construcción de parámetros vacías, esta clase gestiona la instancia de delegado e implementa el método delegado // Agregar un delegado de método estático y devuelve la ID de valor entero para representar la instancia compuesta del método y los parámetros. Si falla, regrese -1. public sincronizado int addfunctionDelegate (class <?> SrcClass, String MethodName, Object ... Params); // Agregue un método de instancia delegado, devuelva la ID de valor entero para representar la instancia compuesta del método y los parámetros. Si falla, regrese -1. public sincronizado int addfunctionDelegate (objeto srcobj, string metodname, object ... params);/Eliminar un método delegado de la instancia delegada basada en el ID de entero y devolver si es exitosa sincronizada boolean boolean removemethod (int registro); // ejecutar todos los métodos delegados de delegado en secuencia (no ordenada) invokeAllmethod (); // Convertir la tabla de parámetros en la tabla de tipos de parámetros de la clase privada <?> [] getParaMTypes (objeto [] params); // Obtener el método de instancia de instancia de método Método de la clase especificada, el nombre del método y el tipo de parámetro Tabla Método privado getDstmethod (class <?> srcChass, string MethodName, class <?> [] Paramtypes); class delegatode (MethodeDEnEndeDeDEDED, objeto, objeto, objeto, objeto, objeto, objeto, Class <?> [] Paramtypes); class delegatEnEnde (MethodeDEDEDED, MethodeDEDED, objeto, objeto, objeto, objeto, Class [? Params) // La clase Delegatenode describe una delegación de método estático cuando no se usa la construcción de objetos, incluidas las instancias de método y las tablas de parámetros. clase delegateNode (objeto srcobj, método refmethod, object [] params) // DelegateNode La clase describe una delegación de método de instancia cuando se usa la construcción de objetos, incluidas las instancias de clase, las instancias del método y las tablas de parámetros públicos void invokemethod (); // La delegación del método que ejecuta la descripción del nodo es
código fuente
import java.lang.reflect.invocationTargetException; import java.lang.reflect.method; import java.util.hashtable;/** La clase delegater usa rtti y reflexión para implementar el mecanismo delegado en java*@author tres-vye ladrillo**/public classegater {static intignic = intreger. variable hashtable <integer, delegateNode> nodetable; // Administrar ID y el contenedor del delegado público correspondiente delegater () {nodetable = new Hashtable <Integer, delegateNode> ();} // Método estático de delegado ... {Class <?> [] ParamTypes = getParAMTypes (params); método refmethod; if ((refmethod = getDstMethod (srcclass, métodeName, paramTypes))! = Null) {registro ++; nodetable.put (registro, nuevo delegateNode (refmethod, params)); método delegado público sincronizado int addFunctionDelegate (objeto srcobj, string metodName, object ... params) {class <?> [] paramTypes = getParamTypes (params); método refmethod; if (((refmethod = getDStMethod (srcobj.getclasss (), método, paramtypes))))))))))))))))))))))))))))))))))) {registro ++; nodetable.put (registro, nuevo delegateNode (srcobj, refmethod, params)); return registro;} else {return -1;}} // eliminar un método delegar public sincronizado boolean removemethod (int registro) {if (nodetable.containskey (registre) {nodetable.remove; falso;} // ejecutar el método delegado underedly public sincronizado sincronizado invokeallmethod () {for (delegateNode nodo: nodetable.values ()) {node.invokemethod ();}} // convierte la tabla de parámetros en una tabla de parámetros privado <?> [] getparamtypes (object [] objects [] ore paramTypes = new class <?> [params.length]; for (int i = 0; i <params.length; i ++) {paramTypes [i] = params [i] .getClass ();} return ParamTypes;} // Obtener una instancia de método basada en instancia de clase de clase, nombre de método y tipo de tabla de parámetros Método privado getDstmethod (class <?> srcClass, cita método de clase, Class de tipo de método. paramTypes) {método resultado = null; try {result = srcclass.getMethod (métodeName, paramTypes); if (resultado.getReturnType ()! = void.class) {System.out.println ("Advertencia, Method:"+MethodName+"Tiene un valor de retorno!");} {System.out.println ("no se puede encontrar el método:"+MethodName+", asegúrese de que exista y visible!");} Return resultado;}} clase delegateNode {objeto srcobj; método refmethod; object [] params; public delegateNode (método refmethod, objeto [] params) {this.refmethod = refmethod; this.params = params;} public delegateNode (objeto srcobj, método refmethod, object [] params) {this.srcobj = srcobj; this.refmethod = refmethod; this.params = params;} public void invokemethod () {try {refmethod.invoke (srcobj, params);} catch (ilegalAccessexception | ilegalArGumentException | InvocationTargetException e) {System.out.Println ("Método:"+RefMethod.TosSorcing ()+"Invoke Fail!")Prueba de módulo
public class delegaterTest {public void showInfo () {System.out.println ("¡Hello Delegate!");} public void showcustominfo (string info) {system.println (info);} public static void showStaticInfo () {system.println ("static delegate!");} showCustomstaticInfo (String Info) {System.out.println (info);} public static void main (string [] args) {delegater dele = new delegater (); delegaterstest tester = new delegaterTest (); int id = = dele.addfunctionDelegate (tester, "showInfo"); dele.addfunctionDelegate (tester, "showCustOnfo", "personalizado!"); dele.addfunctionDelegate (delegaterTest.class, "showStaticInfo"); dele.addfuncti onDelegate(DelegaterTest.class,"showCustomStaticInfo","StaticCustom!");dele.invokeAllMethod();dele.removeMethod(ID);System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------- -----------------------------------------------------------------------------------------------Resultados de la ejecución:
Staticcustom!
StaticDelegate!
¡Costumbre!
¡Helodelegado!
------------------
Staticcustom!
StaticDelegate!
¡Costumbre!
Otros asuntos
Algunos métodos públicos usan sincronizados para garantizar la seguridad de los subprocesos de las variables de registro para que no cometan errores debido a múltiples hilos.
Se emitirá una advertencia para delegados con valores de retorno, pero el módulo aún acepta tales delegaciones, pero no obtendrá el valor de retorno al ejecutar la delegación.
El valor máximo del delegado agregado es el proceso de tolerancia a fallas después de entero.
La ejecución delegada está desordenada, y cuando se requieren requisitos de rendimiento, intente no bloquear la función delegada, de lo contrario afectará la ejecución de otras funciones delegadas.
Cualquier otra pregunta se puede publicar para discutir.
Resumir
Lo anterior es toda la explicación detallada de este artículo sobre la implementación del código del mecanismo delegado en Java a través de la reflexión. Espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados con Java en este sitio web. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!