Comment utiliser Java Reflection pour inspecter et manipuler des cours lors de l'exécution?

Comment utiliser la réflexion Java pour inspecter et manipuler des classes à l'exécution

La réflexion Java fournit un mécanisme puissant pour examiner et interagir avec les classes et leurs membres (champs, méthodes, constructeurs) à l'exécution, plutôt que de compilation. Ceci est réalisé via le package java.lang.reflect . Voici une répartition de la façon de l'utiliser:

Tout d'abord, vous devez obtenir un objet classe représentant la classe que vous souhaitez inspecter. Cela peut être fait de plusieurs manières:

• Utilisation de class.forname () : Cette méthode prend le nom de classe entièrement qualifié en tant que chaîne. Par exemple: class & lt ;? & gt; myClass = class.forname (& quot; com.example.myclass & quot;); notez que cette méthode peut lancer classNotFoundException .
• en utilisant .class : Si vous avez déjà une instance d'une classe, vous pouvez obtenir son CLASSE Par exemple: <code> myClass myObject = new myClass (); Classe & lt ;? & gt; myClass = myObject.getClass ();
• En utilisant une classe de type primitif littéral: pour les types primitifs comme int

Constructeurs: Constructeur & lt ;? & gt; [] constructeurs = myClass.getConstructors (); Cela renvoie un tableau de tous les constructeurs public . Pour obtenir des constructeurs spécifiques (par exemple, par des types de paramètres), utilisez myclass.getConstructor (ParameterType1.class, ParameterType2.class, ...);

Obtenir des méthodes: Méthode [] Méthodes = MyClass.getMethods (); Ce renvoie un arrivée de tous les Public Em>. Pour obtenir une méthode spécifique, utilisez myClass.getMethod (& quot; Methodname & quot;, paramètreType1.class, ParameterType2.class, ...); pour accéder aux méthodes non publiques, utilisez

Getting FIELDS: Strong>. myClass.getFields (); Cela renvoie un tableau de tous les champs public . Semblable aux méthodes, utilisez myClass.getDeclaredFields () pour les champs non publiques.

Après avoir obtenu une méthode ou champ , vous pouvez invoquer la méthode ou l'accès / modifier le champ en utilisant Method.Invoke (Object, Args) et le Code> et le champ <code> field.get (objet) / field.set (objet, valeur) , respectivement. N'oubliez pas de gérer des exceptions potentielles comme invocationTargetException , illégalaccessException , et NosuchMethodexception .

peut-on accès à la réflexion Java Les membres privés d'une classe?

Cependant, cela nécessite des étapes supplémentaires. Appeler simplement myClass.getDeclaredFields () ou myClass.getDeclaredMethods () vous donnera accès à tous les membres , y compris les membres privés. Cependant, tenter de les accéder ou de les modifier directement lancera toujours un illégalaccessException . Pour surmonter cela, vous devez utiliser la méthode setAccessible (true) sur le champ ou Méthode objet:

 <code class="java"> champ privatefield = myclass.getDeclaredField (& quot; myPrivateField & quot;); privatefield.setAccessible (true); Valeur d'objet = privatefield.get (myObject); // accéder au champ privé PrivateField.set (MyObject, NewValue); // Modifiez le champ privé </code> 

Utilisation de setAccessible (true) doit être fait avec prudence. Il contourne les modificateurs d'accès, la rupture potentielle de l'encapsulation et conduisant à des conséquences imprévues dans votre code. Il est généralement préférable d'éviter d'accéder directement aux membres privés, sauf si c'est absolument nécessaire.

Quelles sont les implications de performance de l'utilisation de la réflexion Java de manière approfondie dans mon application?

L'utilisation de la réflexion Java peut considérablement avoir un impact significatif sur les performances de votre application. Voici pourquoi:

• Lookup dynamique: La réflexion implique une recherche d'exécution des cours et des membres. Ceci est plus lent que l'accès statique direct, car le JVM ne connaît pas les détails au moment de la compilation.
• Vérification de la sécurité: Le JVM effectue des vérifications de sécurité pendant la réflexion, ajoutant des frais généraux.
• Optimisation JIT: Le compilation JuT-in-temps (JIT) optimise le code basé sur les informations de type statique. La réflexion entrave cette optimisation, conduisant à un code machine moins efficace.
• La consommation accrue de la mémoire: La réflexion peut augmenter l'utilisation de la mémoire, surtout si elle est utilisée pour créer de nombreux objets dynamiquement.

Par conséquent, il est crucial d'utiliser la réflexion judicieusement. Pour les parties critiques de votre application, les appels de méthode directe et l'accès statique sont toujours préférés. Considérez la réflexion uniquement lorsque le comportement dynamique est absolument essentiel et que le coût des performances est acceptable.

Comment puis-je utiliser la réflexion Java pour instancier dynamiquement des objets de différentes classes à l'exécution?

La réflexion Java permet une instanciation d'objets dynamique à l'aide de l'objet Constructor . Voici comment:

 <code class="java"> String classname = & quot; com.example.myclass & quot ;; // ou obtenez-le à partir d'un fichier de configuration, d'une entrée utilisateur, etc. Classe & lt;? & Gt; myClass = class.forname (className); Constructeur & lt ;? & gt; Constructor = myClass.getConstructor (String.class, int.class); // Spécifiez les paramètres du constructeur objet MyObject = constructor.newinstance (& quot; Hello & quot;, 123); // Instancier l'objet </code>  pre> <p> Cet extrait de code crée dynamiquement une instance de la classe spécifiée par <code> classname </code>. La méthode <code> getConstructor </code> trouve le constructeur approprié en fonction des types de paramètres. La méthode <code> newInstance </code> crée ensuite une instance de la classe à l'aide de ce constructeur. N'oubliez pas de gérer des exceptions potentielles comme <code> classNotFoundException </code>, <code> nosuchMethodeException </code>, <code> InstantiationException </code>, et <code> invocationTargetException </code>. Cette approche vous permet de créer des objets de différentes classes en fonction des informations d'exécution sans avoir besoin de coder les noms de classe dans votre code. Ceci est particulièrement utile dans les cadres et les architectures de plugin. </p>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!