Qu’est-ce que la réflexion et pourquoi est-elle utile ?

https://stackoverflow.com/questions/37628

09-06-2019
|

Question

Je suis particulièrement intéressé par Java, mais je suppose que les principes sont les mêmes dans n'importe quel langage.

La solution

Le nom réflexion est utilisé pour décrire un code capable d'inspecter un autre code dans le même système (ou lui-même).

Par exemple, disons que vous avez un objet d'un type inconnu en Java et que vous souhaitez appeler une méthode « doSomething » dessus, s'il en existe une.Le système de typage statique de Java n'est pas vraiment conçu pour prendre en charge cela à moins que l'objet ne soit conforme à une interface connue, mais en utilisant la réflexion, votre code peut examiner l'objet et découvrir s'il possède une méthode appelée « doSomething », puis l'appeler si vous vouloir.

Donc, pour vous donner un exemple de code en Java (imaginez que l'objet en question est foo) :

Method method = foo.getClass().getMethod("doSomething", null);
method.invoke(foo, null);

Un cas d’utilisation très courant en Java est l’utilisation avec des annotations.JUnit 4, par exemple, utilisera la réflexion pour rechercher dans vos classes les méthodes étiquetées avec l'annotation @Test, puis les appellera lors de l'exécution du test unitaire.

Il existe quelques bons exemples de réflexion pour vous aider à démarrer http://docs.oracle.com/javase/tutorial/reflect/index.html

Et enfin, oui, les concepts sont à peu près similaires dans d'autres langages de types statiques qui prennent en charge la réflexion (comme C#).Dans les langages typés dynamiquement, le cas d'utilisation décrit ci-dessus est moins nécessaire (puisque le compilateur permettra à n'importe quelle méthode d'être appelée sur n'importe quel objet, échouant à l'exécution s'il n'existe pas), mais le deuxième cas de recherche de méthodes marquées ou le travail d’une certaine manière est encore courant.

Mise à jour à partir d'un commentaire :

La capacité d'inspecter le code dans le système et de voir les types d'objets n'est pas une réflexion, mais plutôt de type introspection.La réflexion est alors la possibilité d'apporter des modifications lors de l'exécution en utilisant l'introspection.La distinction est nécessaire ici car certaines langues soutiennent l'introspection, mais ne soutiennent pas la réflexion.Un tel exemple est C ++

Autres conseils

Réflexion est la capacité d'un langage à inspecter et à appeler dynamiquement des classes, des méthodes, des attributs, etc.lors de l'exécution.

Par exemple, tous les objets en Java ont la méthode getClass(), qui vous permet de déterminer la classe de l'objet même si vous ne la connaissez pas au moment de la compilation (par ex.si vous l'avez déclaré comme Object) - cela peut paraître trivial, mais une telle réflexion n'est pas possible dans des langages moins dynamiques tels que C++.Des utilisations plus avancées vous permettent de lister et d'appeler des méthodes, des constructeurs, etc.

La réflexion est importante car elle vous permet d'écrire des programmes qui n'ont pas besoin de tout "savoir" au moment de la compilation, ce qui les rend plus dynamiques, puisqu'ils peuvent être liés ensemble au moment de l'exécution.Le code peut être écrit sur des interfaces connues, mais les classes réelles à utiliser peuvent être instanciées en utilisant la réflexion des fichiers de configuration.

De nombreux frameworks modernes utilisent largement la réflexion pour cette raison.La plupart des autres langages modernes utilisent également la réflexion, et dans les langages de script (tels que Python), ils sont encore plus étroitement intégrés, car cela semble plus naturel dans le modèle de programmation général de ces langages.

L'une de mes utilisations préférées de la réflexion est la méthode de vidage Java ci-dessous.Il prend n'importe quel objet comme paramètre et utilise l'API de réflexion Java pour imprimer chaque nom et valeur de champ.

import java.lang.reflect.Array;
import java.lang.reflect.Field;

public static String dump(Object o, int callCount) {
    callCount++;
    StringBuffer tabs = new StringBuffer();
    for (int k = 0; k < callCount; k++) {
        tabs.append("\t");
    }
    StringBuffer buffer = new StringBuffer();
    Class oClass = o.getClass();
    if (oClass.isArray()) {
        buffer.append("\n");
        buffer.append(tabs.toString());
        buffer.append("[");
        for (int i = 0; i < Array.getLength(o); i++) {
            if (i < 0)
                buffer.append(",");
            Object value = Array.get(o, i);
            if (value.getClass().isPrimitive() ||
                    value.getClass() == java.lang.Long.class ||
                    value.getClass() == java.lang.String.class ||
                    value.getClass() == java.lang.Integer.class ||
                    value.getClass() == java.lang.Boolean.class
                    ) {
                buffer.append(value);
            } else {
                buffer.append(dump(value, callCount));
            }
        }
        buffer.append(tabs.toString());
        buffer.append("]\n");
    } else {
        buffer.append("\n");
        buffer.append(tabs.toString());
        buffer.append("{\n");
        while (oClass != null) {
            Field[] fields = oClass.getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                buffer.append(tabs.toString());
                fields[i].setAccessible(true);
                buffer.append(fields[i].getName());
                buffer.append("=");
                try {
                    Object value = fields[i].get(o);
                    if (value != null) {
                        if (value.getClass().isPrimitive() ||
                                value.getClass() == java.lang.Long.class ||
                                value.getClass() == java.lang.String.class ||
                                value.getClass() == java.lang.Integer.class ||
                                value.getClass() == java.lang.Boolean.class
                                ) {
                            buffer.append(value);
                        } else {
                            buffer.append(dump(value, callCount));
                        }
                    }
                } catch (IllegalAccessException e) {
                    buffer.append(e.getMessage());
                }
                buffer.append("\n");
            }
            oClass = oClass.getSuperclass();
        }
        buffer.append(tabs.toString());
        buffer.append("}\n");
    }
    return buffer.toString();
}

Utilisations de la réflexion

La réflexion est couramment utilisée par les programmes qui nécessitent la possibilité d'examiner ou de modifier le comportement d'exécution des applications exécutées sur la machine virtuelle Java.Il s'agit d'une fonctionnalité relativement avancée et ne doit être utilisée que par des développeurs maîtrisant parfaitement les principes fondamentaux du langage.En gardant cela à l’esprit, la réflexion est une technique puissante qui peut permettre aux applications d’effectuer des opérations qui seraient autrement impossibles.

Fonctionnalités d'extensibilité

Une application peut utiliser des classes externes définies par l'utilisateur en créant des instances d'objets d'extensibilité à l'aide de leurs noms complets.Les navigateurs de classe et les environnements de développement visuel Un navigateur de classe doit être en mesure d'énumérer les membres des classes.Les environnements de développement visuel peuvent bénéficier de l'utilisation des informations de type disponibles en réflexion pour aider le développeur à écrire un code correct.Les débuggeurs et les outils de test débuggeurs doivent être en mesure d'examiner les membres privés en classe.Les harnais de tests peuvent utiliser la réflexion pour appeler systématiquement un ensemble détectable d'API définies sur une classe, afin de garantir un haut niveau de couverture de code dans une suite de tests.

Inconvénients de la réflexion

La réflexion est puissante, mais ne doit pas être utilisée sans discernement.S'il est possible d'effectuer une opération sans utiliser la réflexion, alors il est préférable d'éviter de l'utiliser.Les préoccupations suivantes doivent être gardées à l’esprit lors de l’accès au code via la réflexion.

Frais généraux de performances

Étant donné que la réflexion implique des types résolus dynamiquement, certaines optimisations de machine virtuelle Java ne peuvent pas être effectuées.Par conséquent, les opérations réflexives ont des performances plus lentes que leurs homologues non réflexives et doivent être évitées dans les sections de code fréquemment appelées dans les applications sensibles aux performances.

Restrictions de sécurité

Reflection nécessite une autorisation d'exécution qui peut ne pas être présente lors de l'exécution sous un gestionnaire de sécurité.Il s'agit d'une considération importante pour le code qui doit s'exécuter dans un contexte de sécurité restreint, comme dans une applet.

Exposition des composants internes

Étant donné que la réflexion permet au code d'effectuer des opérations qui seraient illégales dans un code non réflexif, telles que l'accès à des champs et des méthodes privés, l'utilisation de la réflexion peut entraîner des effets secondaires inattendus, susceptibles de rendre le code dysfonctionnel et de détruire la portabilité.Le code réfléchissant brise les abstractions et peut donc changer de comportement avec les mises à niveau de la plateforme.

source: L'API de réflexion

La réflexion est un mécanisme clé pour permettre à une application ou à un framework de fonctionner avec du code qui n'a peut-être même pas encore été écrit !

Prenons par exemple votre fichier web.xml typique.Celui-ci contiendra une liste d'éléments de servlet, qui contiennent des éléments de classe servlet imbriqués.Le conteneur de servlet traitera le fichier web.xml et créera une nouvelle instance de chaque classe de servlet par réflexion.

Un autre exemple serait l'API Java pour l'analyse XML. (JAXP).Où un fournisseur d'analyseur XML est « branché » via des propriétés système bien connues, qui sont utilisées pour construire de nouvelles instances par réflexion.

Et enfin, l'exemple le plus complet est Printemps qui utilise la réflexion pour créer ses beans, et pour son utilisation intensive de proxys

Toutes les langues ne prennent pas en charge la réflexion, mais les principes sont généralement les mêmes dans les langues qui la prennent en charge.

La réflexion est la capacité de « réfléchir » sur la structure de votre programme.Ou plus concret.Pour examiner les objets et les classes dont vous disposez et récupérer par programme des informations sur les méthodes, les champs et les interfaces qu'ils implémentent.Vous pouvez également consulter des éléments tels que les annotations.

C'est utile dans beaucoup de situations.Partout où vous souhaitez pouvoir intégrer dynamiquement des classes dans votre code.De nombreux mappeurs relationnels d'objets utilisent la réflexion pour pouvoir instancier des objets à partir de bases de données sans savoir à l'avance quels objets ils vont utiliser.Les architectures plug-in sont un autre domaine où la réflexion est utile.Être capable de charger dynamiquement du code et de déterminer s'il existe des types qui implémentent la bonne interface à utiliser comme plugin est important dans ces situations.

La réflexion permet l'instanciation de nouveaux objets, l'invocation de méthodes et les opérations d'obtention/définition sur les variables de classe de manière dynamique au moment de l'exécution sans avoir de connaissance préalable de son implémentation.

Class myObjectClass = MyObject.class;
Method[] method = myObjectClass.getMethods();

//Here the method takes a string parameter if there is no param, put null.
Method method = aClass.getMethod("method_name", String.class); 

Object returnValue = method.invoke(null, "parameter-value1");

Dans l'exemple ci-dessus, le paramètre null est l'objet sur lequel vous souhaitez appeler la méthode.Si la méthode est statique, vous fournissez null.Si la méthode n'est pas statique, lors de l'appel, vous devez fournir une instance MyObject valide au lieu de null.

Reflection vous permet également d'accéder aux membres/méthodes privés d'une classe :

public class A{

  private String str= null;

  public A(String str) {
  this.str= str;
  }
}

A obj= new A("Some value");

Field privateStringField = A.class.getDeclaredField("privateString");

//Turn off access check for this field
privateStringField.setAccessible(true);

String fieldValue = (String) privateStringField.get(obj);
System.out.println("fieldValue = " + fieldValue);

Pour l'inspection des classes (également appelée introspection), vous n'avez pas besoin d'importer le package de réflexion (java.lang.reflect).Les métadonnées de classe sont accessibles via java.lang.Class.

Reflection est une API très puissante, mais elle peut ralentir l'application si elle est utilisée de manière excessive, car elle résout tous les types au moment de l'exécution.

Exemple :
Prenons par exemple une application distante qui donne à votre application un objet que vous obtenez à l'aide de leurs méthodes API.Maintenant, en fonction de l'objet, vous devrez peut-être effectuer une sorte de calcul.
Le fournisseur garantit que l'objet peut être de 3 types et nous devons effectuer un calcul en fonction du type d'objet.
Nous pourrions donc implémenter dans 3 classes contenant chacune une logique différente. Évidemment, les informations sur l'objet sont disponibles au moment de l'exécution, vous ne pouvez donc pas coder statiquement pour effectuer le calcul, donc la réflexion est utilisée pour instancier l'objet de la classe dont vous avez besoin pour effectuer le calcul basé sur le objet reçu du fournisseur.

Java Reflection est assez puissant et peut être très utile.Java Reflection le rend possible pour inspecter les classes, les interfaces, les champs et les méthodes au moment de l'exécution, sans connaître les noms des classes, méthodes etc.au moment de la compilation.Il est également possible de instancier de nouveaux objets, invoquer des méthodes et obtenir/définir des valeurs de champ à l'aide de la réflexion.

Un exemple rapide de réflexion Java pour vous montrer à quoi ressemble l'utilisation de la réflexion :

Method[] methods = MyObject.class.getMethods();

    for(Method method : methods){
        System.out.println("method = " + method.getName());
    }

Cet exemple obtient l'objet Class de la classe appelée MyObject.En utilisant l'objet de classe, l'exemple obtient une liste des méthodes de cette classe, itère les méthodes et imprime leurs noms.

Comment tout cela fonctionne exactement est expliqué ici

Modifier:Après presque 1 an, j'édite cette réponse car en lisant sur la réflexion, j'ai eu quelques utilisations supplémentaires de Reflection.

Spring utilise une configuration de bean telle que :

<bean id="someID" class="com.example.Foo">
    <property name="someField" value="someValue" />
</bean>

Lorsque le contexte Spring traite cet élément <bean>, il utilisera Class.forName(String) avec l'argument "com.example.Foo" pour instancier cette classe.

Il utilisera ensuite à nouveau la réflexion pour obtenir le paramètre approprié pour l'élément < property > et définira sa valeur sur la valeur spécifiée.

Junit utilise Reflection spécialement pour tester les méthodes privées/protégées.

Pour les méthodes privées,

Method method = targetClass.getDeclaredMethod(methodName, argClasses);
method.setAccessible(true);
return method.invoke(targetObject, argObjects);

Pour les terrains privés,

Field field = targetClass.getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);

D'après ma compréhension :

La réflexion permet au programmeur d'accéder dynamiquement aux entités du programme.c'est à dire.lors du codage d'une application, si le programmeur ne connaît pas une classe ou ses méthodes, il peut utiliser cette classe de manière dynamique (au moment de l'exécution) en utilisant la réflexion.

Il est fréquemment utilisé dans les scénarios où le nom d'une classe change fréquemment.Si une telle situation se présente, il est alors compliqué pour le programmeur de réécrire l'application et de changer encore et encore le nom de la classe.

Au lieu de cela, en utilisant la réflexion, il faut s'inquiéter d'un éventuel changement de nom de classe.

Réflexion est une API utilisée pour examiner ou modifier le comportement de méthodes, classes, interfaces lors de l'exécution.

Les cours requis pour la réflexion sont fournis sous java.lang.reflect package.
La réflexion nous donne des informations sur la classe à laquelle appartient un objet ainsi que sur les méthodes de cette classe qui peuvent être exécutées en utilisant l'objet.
Grâce à la réflexion, nous pouvons invoquer des méthodes au moment de l'exécution quel que soit le spécificateur d'accès utilisé avec elles.

Le java.lang et java.lang.reflect les packages fournissent des classes pour la réflexion Java.

Réflexion peut être utilisé pour obtenir des informations sur –

Classe Le getClass() La méthode est utilisée pour obtenir le nom de la classe à laquelle appartient un objet.
Constructeurs Le getConstructors() La méthode est utilisée pour obtenir les constructeurs publics de la classe à laquelle appartient un objet.
Méthodes Le getMethods() La méthode est utilisée pour obtenir les méthodes publiques de la classe à laquelle appartient un objet.

Le API de réflexion est principalement utilisé dans :

IDE (environnement de développement intégré), par ex.Eclipse, MyEclipse, NetBeans, etc.
Débogueur et outils de test, etc.

Avantages de l'utilisation de la réflexion :

Fonctionnalités d'extensibilité : Une application peut utiliser des classes externes définies par l'utilisateur en créant des instances d'objets d'extensibilité à l'aide de leurs noms complets.

Outils de débogage et de test : Les débogueurs utilisent la propriété de réflexion pour examiner les membres privés des classes.

Désavantages:

Frais généraux de performances : Les opérations réflexives ont des performances plus lentes que leurs homologues non réflexives et doivent être évitées dans les sections de code fréquemment appelées dans les applications sensibles aux performances.

Exposition des composants internes : Le code réfléchissant brise les abstractions et peut donc changer de comportement avec les mises à niveau de la plateforme.

Réf : Réflexion Java javarevisited.blogspot.in

Reflection est un ensemble de fonctions qui vous permettent d'accéder aux informations d'exécution de votre programme et de modifier son comportement (avec quelques limitations).

C'est utile car cela vous permet de modifier le comportement d'exécution en fonction des méta-informations de votre programme, c'est-à-dire que vous pouvez vérifier le type de retour d'une fonction et modifier la façon dont vous gérez la situation.

En C#, par exemple, vous pouvez charger un assembly (un .dll) au moment de l'exécution et l'examiner, en parcourant les classes et en prenant des mesures en fonction de ce que vous avez trouvé.Il vous permet également de créer une instance d'une classe au moment de l'exécution, d'invoquer sa méthode, etc.

Où peut-il être utile ?N'est pas utile à tout moment mais pour des situations concrètes.Par exemple, vous pouvez l'utiliser pour obtenir le nom de la classe à des fins de connexion, pour créer dynamiquement des gestionnaires d'événements en fonction de ce qui est spécifié dans un fichier de configuration, etc.

exemple simple pour la réflexion.Dans une partie d'échecs, vous ne savez pas ce qui sera déplacé par l'utilisateur au moment de l'exécution.la réflexion peut être utilisée pour appeler des méthodes déjà implémentées au moment de l'exécution.

public class Test {

    public void firstMoveChoice(){
        System.out.println("First Move");
    } 
    public void secondMOveChoice(){
        System.out.println("Second Move");
    }
    public void thirdMoveChoice(){
        System.out.println("Third Move");
    }

    public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException { 
        Test test = new Test();
        Method[] method = test.getClass().getMethods();
        //firstMoveChoice
        method[0].invoke(test, null);
        //secondMoveChoice
        method[1].invoke(test, null);
        //thirdMoveChoice
        method[2].invoke(test, null);
    }

}

La réflexion consiste à laisser les objets voir leur apparence.Cet argument ne semble rien avoir à voir avec la réflexion.En fait, il s’agit de la capacité de « s’identifier ».

La réflexion elle-même est un mot pour désigner des langages qui n'ont pas la capacité de connaissance de soi et d'auto-détection comme Java et C#.Parce qu’ils n’ont pas la capacité de se connaître, lorsque nous voulons observer à quoi cela ressemble, nous devons avoir autre chose à réfléchir sur ce à quoi cela ressemble.D'excellents langages dynamiques tels que Ruby et Python peuvent percevoir leur propre reflet sans l'aide d'autres personnes.On peut dire que l'objet de Java ne peut pas percevoir à quoi il ressemble sans un miroir, qui est un objet de la classe réflexion, mais un objet en Python peut le percevoir sans miroir.C'est pourquoi nous avons besoin d'une réflexion en Java.

Je veux juste ajouter quelque chose à tout ce qui a été répertorié.

Avec API de réflexion tu peux écrire universel toString() méthode pour n’importe quel objet.

C'est utile pour le débogage.

Voici un exemple :

class ObjectAnalyzer {

   private ArrayList<Object> visited = new ArrayList<Object>();

   /**
    * Converts an object to a string representation that lists all fields.
    * @param obj an object
    * @return a string with the object's class name and all field names and
    * values
    */
   public String toString(Object obj) {
      if (obj == null) return "null";
      if (visited.contains(obj)) return "...";
      visited.add(obj);
      Class cl = obj.getClass();
      if (cl == String.class) return (String) obj;
      if (cl.isArray()) {
         String r = cl.getComponentType() + "[]{";
         for (int i = 0; i < Array.getLength(obj); i++) {
            if (i > 0) r += ",";
            Object val = Array.get(obj, i);
            if (cl.getComponentType().isPrimitive()) r += val;
            else r += toString(val);
         }
         return r + "}";
      }

      String r = cl.getName();
      // inspect the fields of this class and all superclasses
      do {
         r += "[";
         Field[] fields = cl.getDeclaredFields();
         AccessibleObject.setAccessible(fields, true);
         // get the names and values of all fields
         for (Field f : fields) {
            if (!Modifier.isStatic(f.getModifiers())) {
               if (!r.endsWith("[")) r += ",";
               r += f.getName() + "=";
               try {
                  Class t = f.getType();
                  Object val = f.get(obj);
                  if (t.isPrimitive()) r += val;
                  else r += toString(val);
               } catch (Exception e) {
                  e.printStackTrace();
               }
            }
         }
         r += "]";
         cl = cl.getSuperclass();
      } while (cl != null);

      return r;
   }    
}

À partir de la documentation Java page

java.lang.reflect Le package fournit des classes et des interfaces pour obtenir des informations réfléchies sur les classes et les objets.La réflexion permet l'accès par programmation aux informations sur les champs, les méthodes et les constructeurs des classes chargées, ainsi que l'utilisation des champs, méthodes et constructeurs réfléchis pour opérer sur leurs homologues sous-jacents, dans le cadre de restrictions de sécurité.

AccessibleObject permet la suppression des contrôles d'accès si nécessaire ReflectPermission est disponible.

Cours de ce package, ainsi que java.lang.Class prendre en charge des applications telles que des débogueurs, des interprètes, des inspecteurs d'objets, des navigateurs de classes et des services tels que Object Serialization et JavaBeans qui ont besoin d'accéder soit aux membres publics d'un objet cible (en fonction de sa classe d'exécution), soit aux membres déclarés par une classe donnée

Il comprend les fonctionnalités suivantes.

Obtention d'objets de classe,
Examiner les propriétés d'une classe (champs, méthodes, constructeurs),
Définir et obtenir les valeurs des champs,
Invoquer des méthodes,
Création de nouvelles instances d'objets.

Jetez un oeil à ceci Documentation lien pour les méthodes exposées par Class classe.

De ceci article (par Dennis Sosnoski, président, Sosnoski Software Solutions, Inc) et ceci article (sécurité-explorations pdf) :

Je peux voir des inconvénients considérables par rapport à l'utilisation de Reflection

Utilisateur de Réflexion :

Il fournit un moyen très polyvalent de relier dynamiquement les composants du programme
C'est utile pour créer des bibliothèques qui fonctionnent avec des objets de manière très générale.

Inconvénients de la réflexion :

La réflexion est beaucoup plus lente que le code direct lorsqu'elle est utilisée pour l'accès aux champs et aux méthodes.
Cela peut masquer ce qui se passe réellement dans votre code
Il contourne le code source peut créer des problèmes de maintenance
Le code de réflexion est également plus complexe que le code direct correspondant
Il permet la violation des principales contraintes de sécurité Java telles que la protection d'accès aux données et la sécurité des types

Abus généraux :

Chargement des classes restreintes,
Obtenir des références à des constructeurs, des méthodes ou des champs d'une classe restreinte,
Création de nouvelles instances d'objet, appel de méthodes, obtention ou définition des valeurs de champ d'une classe restreinte.

Jetez un œil à cette question SE concernant l'abus de la fonctionnalité de réflexion :

Comment lire un champ privé en Java ?

Résumé:

Une utilisation non sécurisée de ses fonctions effectuée à partir d'un code système peut également facilement conduire à la compromission d'un mode de sécurité Java.l. Utilisez donc cette fonctionnalité avec parcimonie

Comme le nom lui-même le suggère, il reflète ce qu'il contient, par exemple la méthode de classe, etc., en plus de fournir une fonctionnalité permettant d'invoquer une méthode créant une instance de manière dynamique au moment de l'exécution.

Il est utilisé par de nombreux frameworks et applications sous le bois pour appeler des services sans réellement connaître le code.

Reflection a beaucoup les usages.Celui que je connais le mieux est de pouvoir créer du code à la volée.

C'EST À DIRE:Classes dynamiques, fonctions, constructeurs - basés sur toutes les données (Résultats XML / Array / SQL / Hardcoded / etc.)

La réflexion vous donne la possibilité d'écrire du code plus générique.Il vous permet de créer un objet au moment de l'exécution et d'appeler sa méthode au moment de l'exécution.Le programme peut donc être hautement paramétré.Il permet également d'introspecter l'objet et la classe pour détecter ses variables et sa méthode exposées au monde extérieur.

Je veux répondre à cette question par un exemple.Tout d'abord Hibernate utilisations du projet Reflection API générer CRUD instructions pour combler le fossé entre l'application en cours d'exécution et le magasin de persistance.Quand les choses changent dans le domaine, le Hibernate doit les connaître pour les conserver dans le magasin de données et vice versa.

Fonctionne alternativement Lombok Project.Il injecte simplement du code au moment de la compilation, ce qui entraîne l'insertion de code dans vos classes de domaine.(Je pense que c'est OK pour les getters et les setters)

Hibernate choisi reflection car cela a un impact minimal sur le processus de création d'une application.

Et depuis Java 7, nous avons MethodHandles, qui fonctionne comme Reflection API.Dans les projets, pour travailler avec les loggers, il suffit de copier-coller le code suivant :

Logger LOGGER = Logger.getLogger(MethodHandles.lookup().lookupClass().getName());

Parce qu'il est difficile de faire une erreur de frappe dans ce cas.

Comme je trouve préférable d'expliquer par exemple et aucune des réponses ne semble faire cela...

Un exemple pratique d'utilisation des réflexions serait un serveur de langage Java écrit en Java ou un serveur de langage PHP écrit en PHP, etc.Language Server offre à votre IDE des fonctionnalités telles que la saisie semi-automatique, le passage à la définition, l'aide contextuelle, les types d'indications et bien plus encore.Afin que tous les noms de balises (mots pouvant être complétés automatiquement) correspondent lorsque vous appuyez sur, disons : LANGUETTE et afficher tous les indices, Language Server doit tout inspecter sur la classe, y compris ses blocs de documentation et ses membres privés.Pour cela, il faut un reflet de ladite classe.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow