Qu'est-ce que la réflexion et pourquoi est-il utile?

Reflection est la capacité d'un langage à inspecter et à appeler dynamiquement des classes, des méthodes, des attributs, etc. au moment 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 le connaissez pas au moment de la compilation (par exemple si vous l'avez déclaré comme Object) - cela peut sembler 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, les constructeurs, etc.

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

Beaucoup de cadres modernes utilisent largement la réflexion pour cette raison même. La plupart des autres langues 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.

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 Java reflection 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 dans la machine virtuelle Java. Il s'agit d'une fonctionnalité relativement avancée et ne devrait être utilisée que par les développeurs qui maîtrisent parfaitement les fondamentaux du langage. Avec cette mise en garde à l'esprit, la réflexion est une technique puissante et peut permettre aux applications d'effectuer des opérations qui seraient autrement impossible.

Caractéristiques 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. Classe Navigateurs et Environnements de Développement Visuel Un navigateur de classe doit pouvoir énumérer les membres des classes. Les environnements de développement visuel peuvent bénéficier de l'utilisation des informations de type disponibles dans reflection pour aider le développeur à écrire du code correct. Les débogueurs et Outils de Test Les débogueurs doivent pouvoir examiner les membres privés dans les classes. Les harnais de test peuvent utiliser la réflexion pour appeler systématiquement un ensemble d'API détectables défini sur une classe, afin d'assurer un niveau élevé de couverture de code dans une suite de tests.

Les Inconvénients de la Réflexion

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

• Frais généraux de performance

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

• Sécurité Restrictions

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é. C'est 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 internes

Étant donné que la réflexion permet au code d'effectuer des opérations qui seraient illégales dans le code non réfléchissant, 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, qui peuvent rendre le code dysfonctionnel et peuvent détruire la portabilité. Le code réfléchissant casse les abstractions et peut donc changer le comportement avec les mises à niveau de la plate-forme.

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!

Prenez par exemple votre web typique.fichier xml. Cela contiendra une liste d'éléments de servlet, qui contiennent des éléments de classe de servlet imbriqués. Le conteneur de servlet traitera le web.fichier XML, et créer 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 Le 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 Spring {[6] } qui utilise la réflexion pour créer ses beans, et pour son utilisation intensive de proxies

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

La réflexion est la capacité de "réfléchir" sur la structure de votre programme. Ou plus concrète. Pour regarder les objets et les classes que vous avez et récupérer par programme des informations sur les méthodes, les champs et les interfaces qu'ils implémentent. Vous pouvez également regarder des choses comme des annotations.

C'est utile dans beaucoup de situations. Partout où vous voulez être en mesure de dynamiquement branchez 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 de plug-in sont un autre endroit 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.

Reflection permet l'instanciation de nouveaux objets, l'invocation de méthodes et les opérations get/set sur des variables de classe dynamiquement au moment de l'exécution sans avoir 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 invoquer la méthode. Si la méthode est statique, vous fournissez null. Si la méthode n'est pas statique, alors lors de l'appel, vous devez fournir une instance MyObject valide au lieu de null.

Réflexion permet également de accéder aux membres privés / méthodes 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 en excès, car elle résout tous les types lors de l'exécution.

La réflexion Java est assez puissante et peut être très utile. La réflexion Java permet d'inspecter les classes, interfaces, champs et méthodes à l'exécution, sans connaître les noms des classes, méthodes, etc. au moment de la compilation. Il est également possible d'instancier de nouveaux objets, d'invoquer des méthodes et d'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 de Classe de la classe appelée MyObject. En utilisant l'objet class, l'exemple obtient une liste des méthodes de cette classe, itère les méthodes et imprime leurs noms.

Exactement comment tout cela fonctionne est expliqué ici

Edit : Après presque 1 an, je modifie cette réponse car en lisant sur la réflexion, j'ai eu peu d'autres utilisations de la réflexion.

• Spring utilise une configuration de bean telle que:

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

Lorsque le Le contexte Spring traite cet élément , il utilisera la classe.forName (String) avec l'argument "com.exemple.Foo " pour instancier cette classe.

Il utilisera ensuite à nouveau la réflexion pour obtenir le setter approprié pour l'élément et définir sa valeur à la valeur spécifiée.

• Junit utilise la réflexion en particulier pour tester des 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 champs privés,

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

Exemple:

Prenez par exemple une application distante qui donne à votre application un objet que vous obtenez en utilisant 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 que 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 dans runtime vous ne pouvez donc pas coder statiquement pour effectuer le calcul, donc reflection est utilisé pour instancier l'objet de la classe dont vous avez besoin pour effectuer le calcul en fonction de l'objet reçu du fournisseur .

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

1. Les classes requises pour la réflexion sont fournies sous java.lang.reflect package.
2. La réflexion nous donne des informations sur la classe à laquelle appartient un objet et aussi sur les méthodes de cette classe qui peuvent être exécutées en utilisant l'objet.
3. Par réflexion, nous pouvons invoquer des méthodes à l'exécution quel que soit le spécificateur d'accès utilisé avec eux.

Les paquets java.lang et java.lang.reflect fournissent des classes pour la réflexion java.

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

1. De Catégorie Le getClass() méthode est utilisée pour obtenir le nom de la classe à laquelle appartient un objet.

2. Constructeurs La méthode getConstructors() est utilisée pour obtenir les constructeurs publics de la classe à laquelle appartient un objet.

3. Les Méthodes de Le getMethods() méthode est utilisée pour obtenir les méthodes publiques de la classe à laquelle un objet appartient.

L'API de réflexion est principalement utilisée dans:

Environment (Environnement de développement intégré) par exemple Eclipse, MyEclipse, NetBeans etc.
Débogueur et outils de test, etc.

Avantages de l'Utilisation de la Réflexion:

Caractéristiques d'extensibilité: Une application peut utiliser des classes externes définies par l'utilisateur en créant des instances de objets d'extensibilité utilisant leurs noms complets.

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

Inconvénients:

Surcharge de performance: Les opérations réfléchissantes ont des performances plus lentes que leurs homologues non réfléchissantes, et doivent être évitées dans les sections de code qui sont appelées fréquemment dans les applications sensibles aux performances.

Exposition de Internals: Reflective code casse les abstractions et peut donc changer de comportement avec les mises à niveau de la plate-forme.

Ref: Réflexion Java javarevisited.blogspot.dans

Exemple simple de réflexion. Dans un jeu d'échecs, vous ne savez pas ce qui va être 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);
    }

}

Selon ma compréhension:

Reflection permet au programmeur d'accéder dynamiquement aux entités du programme. c'est-à-dire lors du codage d'une application si le programmeur n'est pas au courant d'une classe ou de ses méthodes, il peut utiliser cette classe dynamiquement (au moment de l'exécution) en utilisant la réflexion.

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

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

Reflection est un ensemble de fonctions qui vous permet d'accéder aux informations d'exécution de votre programme et de modifier son comportement (avec certaines 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 changer la façon dont vous gérez la situation.

En C# par exemple, vous pouvez charger un assembly (un .dll) dans l'exécution et l'examiner, en naviguant à travers le cours et prendre des mesures en fonction de ce que vous avez trouvé. Il vous permet également de créer une instance d'une classe sur l'exécution, invoquer sa méthode, etc.

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

Je veux juste ajouter un point à tout ce qui a été répertorié.

Avec Reflection API vous pouvez écrire une méthode universelle toString() pour n'importe quel objet.

Il est utile au 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;
   }    
}

La réflexion consiste à laisser les objets voir leur apparence. Cet argument ne semble rien à voir avec la réflexion. En fait, c'est le "s'identifier" la capacité.

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

À Partir de la documentation java page

java.lang.reflect package fournit des classes et des interfaces pour obtenir des informations réfléchissantes sur les classes et les objets. Reflection permet un accès programmatique aux informations sur les champs, méthodes et constructeurs des classes chargées, et l'utilisation des champs, méthodes et constructeurs reflétés pour opérer sur leurs homologues sous-jacents, dans les limites des restrictions de sécurité.

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

Les classes de ce paquet, ainsi que java.lang.Class accueillent 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 aux membres publics d'un objet cible (en fonction de sa classe d'exécution) ou aux membres déclarés par une classe donnée

Il inclut les fonctionnalités suivantes.

1. Obtention d'objets de classe,
2. Examiner les propriétés d'une classe (champs, méthodes, constructeurs),
3. Définition et obtention des valeurs de champ,
4. Méthodes d'appel,
5. Création de nouvelles instances d'objets.

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

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

Je peux voir des inconvénients considérables que les utilisations d'utiliser la réflexion

Utilisateur de Réflexion:

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

les Inconvénients de la Réflexion:

1. 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.
2. Cela peut obscurcir ce qui se passe réellement à l'intérieur de votre code
3. Il contourne le code source peut créer des problèmes de maintenance
4. Le code de réflexion est également plus complexe que le code direct correspondant
5. Il permet la violation des principales contraintes de sécurité Java telles que en tant que protection de l'accès aux données et sécurité de type

Général abus:

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

Jetez un oeil à cette question SE concernant l'abus de fonction de réflexion:

Comment lire un champ privé en Java?

Résumé:

L'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é Javal. 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é pour invoquer la méthode créant une instance dynamiquement à l'exécution.

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

Reflection vous donne la possibilité d'écrire du code plus générique. Il vous permet de créer un objet à l'exécution et d'appeler sa méthode à l'exécution. Par conséquent, le programme peut être hautement paramétré. Il permet également l'introspection de l'objet et de la classe pour détecter ses variables et sa méthode exposées au monde extérieur.

Reflection a beaucoup de utilise. Celui que je connais le plus, c'est de pouvoir créer du code à la volée.

IE: classes dynamiques, fonctions , constructeurs-basé sur toutes les données (xml / tableau / résultats sql/codé en dur / etc..)

Je veux répondre à cette question par l'exemple. Tout d'abord, le projet Hibernate utilise Reflection API pour générer des instructions CRUD afin de combler le gouffre entre l'application en cours d'exécution et le magasin de persistance. Lorsque 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 setters)

Hibernate choisi reflection, car il a peu d'impact sur le processus de construction d'une application.

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

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

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

Comme je trouve qu'il est préférable d'expliquer par l'exemple et aucune des réponses ne semble le faire...

Un exemple pratique d'utilisation de reflections serait un serveur de langage Java écrit en Java ou un serveur de langage PHP écrit en PHP, etc. Language Server donne à votreE des capacités telles que la saisie semi-automatique, le saut à la définition, l'aide au contexte, les types de suggestion et plus encore. Afin d'avoir tous les noms de balises (mots qui peuvent être complétés automatiquement) pour afficher toutes les correspondances possibles lorsque vous tapez, le serveur de langue doit inspecter tout sur la classe, y compris les blocs doc et les membres privés. Pour cela, il a besoin d'un reflet de ladite classe.

Un autre exemple serait un test unitaire d'une méthode privée. Une façon de le faire est de créer une réflexion et de changer la portée de la méthode en public dans la phase de configuration du test. Bien sûr, on peut affirmer que les méthodes privées ne devraient pas être testées directement, mais ce n'est pas le but.

IMPORTANT

À partir de Java 9, vous ne pouvez plus utiliser reflection à moins que le package-info.java ouvre le module d'accès à la réflexion.

Par défaut, l'accès à tous les paquets du module est refusé.

Voir Comprendre les modules Java 9