Brève description
J'ai toujours été inquiet du manque de mécanisme de délégation de Java. Heureusement, j'ai un peu de temps récemment et j'ai écrit un module de délégation simple avec réflexion pour référence.
API du module
Classe publique Delegater () // Construction de paramètres vide, cette classe gère l'instance du délégué et implémente la méthode du délégué // Ajouter un délégué de méthode statique et renvoie l'ID de valeur entière pour représenter l'instance composée de la méthode et des paramètres. S'il échoue, retournez -1. public synchronisé int addFunctionDelegate (class <?> srcclass, string méthodyname, objet ... params); // ajouter un délégué de méthode d'instance, renvoie l'ID de valeur entier pour représenter l'instance composée de la méthode et des paramètres. S'il échoue, retournez -1. public synchronisé int addFunctionDelegate (objet srCobj, string méthodyname, objet ... params); // supprimer un délégué de la méthode de l'instance déléguée basée sur l'ID entier et renvoyer s'il est réussi public synchronisé booléen supprime la séquence (int regritant); // exécuter tous les délégués de la méthode dans cette instance déléguée dans la séquence (non enregistrée) invokeAllMethod (); // convertir la table de paramètre en Table de paramètre Table Private Class <?> [] getParAmTypes (objet [] params); // Obtenez la méthode privée de l'instance de méthode à partir de la classe spécifiée, du nom de la méthode et du type de paramètre Table Private Method GetDstMethod) Params) // Classe Delegatenode décrit une délégation de méthode statique lors de ne pas utiliser de construction d'objets, y compris les instances de méthode et les tables de paramètres. Classe DelegaTenode (Object SrCobj, Method RefMethod, Object [] Params) // La classe Delegatenode décrit une délégation de méthode d'instance lors de l'utilisation de la construction d'objets, y compris les instances de classe, les instances de méthode et les tables de paramètres publics Void invokeThod (); // La délégation de méthode qui exécute la description du nœud est la description du nœud est
code source
Importer java.lang.reflect.invocationtargetException; import java.lang.reflect.method; import java.util.hashtable; / ** la classe Delegater utilise rtti et réflexion pour implémenter le mécanisme du délégué dans java * @author à trois bricks * * / public Delegater {static int regrin = integer. Variable HashTable <Integer, Delegatenode> nodeTable; // Gérer l'ID et le conteneur du délégué public de délégater () {NodeTable = nouveau HashTable <Integer, Delegatenode> ();} // Ajouter une méthode statique Delegate Public Synchronisé int AddFunctionDelegate (class <?> Srcclass, String méthode String, ajes {Class <?> [] Paramtypes = getParamTypes (params); méthode refMethod; if ((RefMethod = getDStMethod (srcclass, méthodyname, paramtypes))! = Null) {registre ++; nodeTable.put (registre, new delegatenode (regethod, params)); return register;} else {relegatéNode -1; Méthode Delegate Public synchronisé int addFunctionDelegate (objet srCobj, string méthodyname, objet ... params) {class <?> [] paramtypes = getParamTypes (params); méthode refMethod; if ((RefMethod = GetDstMethod (srCobj.getClass (), méthode, paramtypes)! = null)! {registre ++; nodeTable.put (registre, new Delegatenode (srCobj, RefMethod, params)); return register;} else {return -1;}} // supprimer une méthode Delegate Public Synchronied boolean removemethod (int regrinsId) {if (nodetable.containSkey (registre)) {nodETable.ReMove (RegisterId); FAUX;} // Exécuter la méthode du délégué sans ordonnance synchronisée void invokeAlLMethod () {for (Delegatenode nœud: nodeTable.values ()) {node.invokemethod ();}} // convertir le tableau des paramètres en un tableau de type paramètre <? = new Class <?> [params.length]; for (int i = 0; i <params.length; i ++) {paramtypes [i] = params [i] .getClass ();} return paramtypes;} // obtenir une instance de méthode basée sur l'instance de classe de classe, le nom de la méthode, et la méthode de type paramètre, la méthode privée <?] {Méthode result = null; try {result = srcclass.getMethod (méthodyname, paramtypes); if (result.getReturnType ()! = Void.class) {system.out.println ("avertissement, méthode:" + méthode + "a une valeur de retour!");}} Catch (nosuchmethodException | SecurityException a) {System.out.println ("ne peut pas trouver la méthode:" + méthodyname + ", assurez-vous qu'il existe et visible!");} Retour Result;}} class Delegatenode {Object SrCobj; Method RefMethod; Object [] Params; public Delegatenode (Method RefMethod, Object [] Params) {this.refMethod = RefMethod; this.params = params;} public Delegatenode (objet srCobj, méthode refMethod, object [] params) {this.srcobj = srCobj; this.refMethod = RefMethod; this.params = params;} public void invokeMethod () {try {RefMethod.invoke (srcobj, params);} catch (illégalaccessException | illégalargumentException | invocationTargexception e) {System.out.println ("Méthode:" + RefMeth.Tostring () + "inviter!");Tests de module
classe publique DelegaterTest {public void showInfo () {System.out.println ("Hello Delegate!");} public void showCustomInfo (String info) {System.out.println (info);} public static showStaticinfo () {System.out.println ("static Delegate!");} Public Static Void showCustomStaticInfo (String info) {System.out.println (info);} public static void main (String [] args) {delegater dele = new Delegater (); delegaterTest tester = new DelegaterTest (); int id = dele.addfunctiondelegate (testeur, "showInfo"); dele.addfunctiondelegate (testeur, "showcustominfo", "coutust!"); dele.addfonctiondelegate (delegatertest.class, "showstatic onDelegate(DelegaterTest.class,"showCustomStaticInfo","StaticCustom!");dele.invokeAllMethod();dele.removeMethod(ID);System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Résultats de l'exécution:
StaticCustom!
StaticDelegate!
Coutume!
HelloDelegate!
------------------
StaticCustom!
StaticDelegate!
Coutume!
Autres questions
Certaines méthodes publiques utilisent une synchronisation pour assurer la sécurité du fil des variables de registre afin qu'elles ne fassent pas d'erreurs en raison de plusieurs threads.
Un avertissement sera émis pour les délégués avec des valeurs de retour, mais le module accepte toujours de telles délégations, mais vous n'obtiendrez pas la valeur de retour lors de l'exécution de la délégation.
La valeur maximale du délégué ajouté est le processus de tolérance aux défauts après Integer.max_value-iteger.min_value n'est pas pris en compte (généralement il n'y a pas autant de fonctions qui nécessitent un délégué.
L'exécution déléguée est désordonnée et lorsque les exigences de performance sont nécessaires, essayez de ne pas bloquer la fonction déléguée, sinon cela affectera l'exécution d'autres fonctions déléguées.
Toute autre question peut être publiée pour discuter.
Résumer
Ce qui précède est toute l'explication détaillée de cet article sur la mise en œuvre du code du mécanisme du délégué dans Java par réflexion. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets liés à Java sur ce site Web. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!