Préface:
Récemment, l'entreprise subit un processus de composontisation commerciale et l'implémentation de routage utilise le mécanisme de réflexion de Java. Puisqu'il est utilisé, je veux étudier et le résumer attentivement. En fait, qu'il s'agisse de la version EventBus 2.x précédente, de la rénovation ou du cadre d'annotation de vue précoce, il utilise le mécanisme de réflexion de Java dans une plus ou moins loin.
Qu'est-ce que le mécanisme de réflexion Java?
Le mécanisme de réflexion Java est que dans l'état de course, pour n'importe quelle classe, vous pouvez connaître toutes les propriétés et méthodes de cette classe; Pour n'importe quel objet, vous pouvez appeler n'importe quelle méthode de son appel dynamiquement acquis et d'appel dynamiquement que la méthode de l'objet est appelée mécanisme de réflexion Java.
Quelles fonctions le mécanisme de réflexion fournit-il?
Classe de mécanisme de réflexion Java:
java.lang.class; // class java.lang.reflect.constructor; // Méthode du constructeur java.lang.reflect.field; // Variable membre de la classe java.lang.reflect.method; // Méthode de classe java.lang.reflect.modificier; // Accès aux autorisations
Mise en œuvre du mécanisme de réflexion Java:
1.) Obtenir un objet de classe
// La première méthode consiste à utiliser l'objet méthode getClass Person personne = new Person (); class <?> Class1 = personne.getClass (); // La deuxième méthode consiste à utiliser l'attribut class Class1 = Person.class; try {// La troisième méthode consiste à utiliser la méthode statique de la classe Class - Forname () pour implémenter la classe 1 = class.forname ("com.hoishish.reflectDemo. (ClassNotFoundException e) {e.printStackTrace ();}2.) Obtenez les informations de résumé de l'objet de classe
Boolean isPrimitive = class1.isprimitive (); // juger si c'est le type de base booléen isArray = class1.isArray (); // juger s'il s'agit d'une classe Boolean isannotation = class1.isannotation (); // juge si c'est une classe annotation booléenne est interface = class1.isinterface (); // classe 1.isenum (); // juger s'il s'agit d'un énumération de classe booléenne isanonymousclass = class1.isanonymousclass (); // juger s'il s'agit d'une classe interne anonyme booléenne isannotationpresent = class1.isannotationpresent (déprécié.class); // jugera si elle est modifiée par une classe annotée annotée = Classname =. Contient le package de package le package apackage = class1.getPackage (); // obtenir la chaîne d'informations de package de classe SimpLename = class1.getSimplename (); // Get Class Nom de la classe Int modificateurs = class1.getModificaires (); // Get Class Access Permite classe1.getDeclareAnclass (); // classe externe
3.) Obtenez les attributs, les méthodes, les constructeurs, etc. de l'objet de classe
Field [] allFields = class1.getDeclaredFields (); // Obtenez tous les attributs du champ d'objet de classe [] publicFields = class1.getFields (); // Obtenez l'attribut public de l'objet de classe Essayez {Field AgeField = Class1.getDeclaredField ("Age"); // Get the Specified Field Field Desfield = Class1.get (""); Attribut de la classe} catch (NosuchFieldException e) {e.printStackTrace ();} méthode [] méthodes = class1.getDeclaredMethods (); // Obtenez toutes les méthodes de déclaration de la méthode d'objet de classe [] AllMethods = class1.getMethods (); // Obtenir toutes les méthodes de classe, y compris la méthode parentale de la classe parent Classe de classe Class Class <?> [] interfaceClasses = class1.getInterfaces (); // Obtenez toutes les interfaces de Class Object Constructor <?> [] AllConstructors = Class1.getDeclaredConstructeurs (); // Obtenir tous les constructeurs de déclaration de Class Object Constructor <?> [] PublicConstructors = Class1.getConstructor (); // Get the Class Public Contructor Constructor <?> Constructor = class1.getDeclaredConstructor (new Class [] {String.class}); // Obtenez la déclaration spécifiée du constructeur publicConstructor = Class1.getConstructor (New Class [] {}); // Obtenir la déclaration spécifiée publiqueur} Catch (nosuchhexexception e) {E.PrintStackTrace (); annotations = class1.getAnnotations (); // Obtenez toutes les annotations de l'annotation d'objet de classe Annotation = class1.getAnTannotation (déprécated.class); // Obtenez l'annotation spécifiée du type d'objet de classe génériqueauclasse = Class1.getGenerricSuperclass (); // Obtenir le type de type interfacéty Toutes les interfaces de l'objet de classe 4.) Génération dynamique d'objets de classe
// La première méthode d'objet de classe appelle la méthode NewInstance () pour générer un objet obj = class1.newinstance (); // La deuxième méthode de l'objet obtient l'objet constructeur correspondant, puis génère le constructeur <?> Constructor = class1.getDeclaredConstructor (new class [] {String.class}); // obtenir le constructeur spécifié du constructeur spécifié obj = constructeur. Objet [] {"lcj"});5.) appelez dynamiquement les fonctions
essayez {// générer un nouvel objet: utilisez l'objet newInstance () Méthode obj = class1.newinstance (); // juger si l'objet est une sous-classe de personne booléenne est en instance = obj instance de personne; // Tout d'abord, vous devez obtenir la méthode correspondant à la méthode de méthode méthode Méthode = class1.getDeclaredMethod ("setage", new class [] {int.class}); // Appelez la fonction spécifiée et transmettez le paramètre méthode.invoke (OBJ, 28); Method = class1.getDeclaredMethod ("Getage"); Objet résultat = méthode.invoke (obj, new class [] {});} catch (instanciationException e) {e.printStackTrace ();} catch (illégalaccessException e) {e.printStackTrace ();} catch (nosuchMethodexception e) {e.printStackTrace ();} catch (invocationTarTexex e.printStackTrace ();} 6.) Obtenir des types génériques par mécanisme de réflexion
Par exemple, la structure suivante
// classe des gens classe publique People <T> {} // Personne Classe Hérite des gens classe publique classe publique Personne <T> étend les gens <string> implémente PersonInterface <Integer> {} // Interface PersonInterface Interface publique PersonInterface <T> {}Obtenir des types génériques
Personne <string> personne = new Person <> (); // La première façon est d'utiliser l'objet GetClass Method Class <?> Class1 = personne.getClass (); Type GenericsUperClass = class1.getGenerICSUperClass (); // Get TypeType [] interfacetypes = class1.getGenericInterfaces (); // Obtenez la composition de toutes les interfaces de l'objet Class GetComponentType (génériqueuperclass); getComponentType (interfacetypes [0]);
Implémentation GetComponentType
classe privée <?> getComponentType (type type) {class <?> ComponentType = null; if (type instanceof parameterzedType) {// getActualTypeArguments () renvoie un tableau d'objets de type représentant les paramètres de type réels de ce type. Type [] réelTypearguments = ((paramètreType) type) .getActualTypeArguments (); if (réelTypeArGuments! = null && actualTypearguments.length> 0) {composantType = (class <?>) actualTypearGuments [0]; }} else if (type instance de genericArrayType) {// Type de tableau qui représente un type d'élément qui est un type de type paramétré ou de type variable composantype = (class <?>) ((genericArrayType). 6.) Obtenir des informations d'annotation par le mécanisme de réflexion
Ici, nous nous concentrons sur l'obtention des informations d'annotation de la méthode comme exemple
essayez {// tout d'abord, vous devez obtenir l'objet de méthode correspondant à cette méthode méthode = class1.getDeclaredMethod ("Jumptogoodsdetail", new class [] {string.class, string.class}); Annotation [] annotations1 = méthode.getAntoTations (); // Obtenez toutes les informations d'annotation de la méthode Annotation Annotation1 = Method.getAnnotation (Routeruri.class); // Obtenir les informations d'annotation spécifiées TypeVariable [] Typevariables1 = Method.getTypeParameters (); Annotation [] [] ParameterannotationsArray = Method.GetParameTannotations (); // Obtenir tous les paramètres Annotations Classe <?> [] ParamètreTypes = méthode.getParAmEterTypes (); // Obtenir tous les paramètres Type de classe [] GenericParAmEterTypes = Method.GetGenericParTypeSes (); // Gevel Method.GetRetTurnType (); // Obtenez le type de retour de la méthode int modificateurs = method.getModifiers (); // Obtenez les autorisations d'accès de la méthode} catch (NosuchMethodexception e) {e.printStackTrace ();}Scénarios d'application du mécanisme de réflexion:
Avantages et inconvénients du mécanisme de réflexion:
Avantages: jugement du type d'exécution, chargement de classe dynamique et réflexion d'utilisation de proxy dynamique.
Inconvénients: les performances sont un problème. La réflexion équivaut à une série d'opérations d'explication. En informer JVM sur ce qu'il faut faire, les performances sont beaucoup plus lentes que le code Java direct.
Résumer:
Le mécanisme de réflexion de Java est rarement utilisé dans le développement des affaires quotidiennes, mais il est largement utilisé dans la construction de certains cadres de base. Aujourd'hui, je l'ai brièvement résumé et appris, et il y a encore beaucoup de connaissances inconnues à utiliser plus tard pour la compléter.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.