Utilisation de handles de méthodes et de variables en Java pour l'accès et la manipulation des objets d'exécution

La réflexion et les poignées de méthode/var sont deux fonctionnalités puissantes de Java qui permettent aux développeurs d'accéder et de manipuler des objets au moment de l'exécution. Cependant, ils diffèrent dans la manière dont ils accèdent et manipulent les objets.

Jetons un coup d'œil à un exemple d'utilisation de la réflexion pour accéder à une méthode dans une classe. Nous allons commencer par une classe simple appelée "MyClass" qui possède une variable de chaîne privée et une méthode getter pour cette variable. Pour créer cet objet, nous pouvons utiliser l'instanciation normale :

MyClass objectInstance = new MyClass("John Doe");

Pour accéder à la méthode par réflexion, nous devons d'abord obtenir la classe de notre instance d'objet à l'aide de la méthode getClass(). Ensuite, nous pouvons utiliser la méthode getDeclaredMethod() pour trouver la méthode à laquelle nous voulons accéder, dans ce cas, "getName". Enfin, nous devons invoquer la méthode à l’aide de la méthode Invoke() et transmettre notre instance d’objet. Voici le code de ce processus :

Class<?> clazz = objectInstance.getClass();
Method method = clazz.getDeclaredMethod("getName");
String value = (String) method.invoke(objectInstance);
System.out.println(value); // prints "John Doe"

D'un autre côté, les handles de méthode, trouvés dans la classe MethodHandles, offrent un moyen plus sûr et plus optimisé d'accéder aux méthodes. En effet, ils ont été conçus spécifiquement à cet effet et sont améliorés pour l'optimisation JVM.

L'utilisation de handles de méthode pour accéder à une méthode est similaire à l'utilisation de la réflexion. Nous commençons par obtenir la classe de notre instance d’objet. Ensuite, nous utilisons la méthode findVirtual() sur MethodHandles pour rechercher la méthode à laquelle nous souhaitons accéder. Ensuite, nous appelons la méthode à l’aide de la méthode Invoke() et transmettons notre instance d’objet. Voici le code de ce processus :

Class<?> clazz = objectInstance.getClass();
MethodHandle handle = MethodHandles.lookup().findVirtual(clazz, "getName", methodType(String.class));
String value = (String) handle.invoke(objectInstance);
System.out.println(value);  // Prints “John Doe”

Cependant, il existe des limites à ce que les handles de méthode peuvent faire. Ils ne peuvent pas gérer des tâches telles que l'instanciation de classes, ce qui est possible avec la réflexion.

Pour montrer la puissance des handles de méthode, voyons comment ils peuvent être utilisés pour accéder directement à un champ privé dans une classe. Disons que notre classe "MyClass" possède une variable de chaîne privée appelée "name". Nous pourrions utiliser la réflexion pour y accéder, mais utiliser des handles de méthode est une alternative plus sûre.

Pour accéder directement à un champ privé par réflexion, nous devons d'abord obtenir la classe de notre instance d'objet. Ensuite, nous utilisons la méthode getDeclaredField() pour trouver le champ auquel nous voulons accéder, dans ce cas, « nom ». Cependant, comme ce champ est privé, nous devons utiliser la méthode setAccessible() pour définir son accessibilité sur true. Enfin, on peut utiliser la méthode get() pour récupérer la valeur du champ. Voici le code de ce processus :

Class<?> clazz = objectInstance.getClass(); 
Field field = clazz.getDeclaredField("name"); 
field.setAccessible(true); 
String value = (String) field.get(objectInstance);
System.out.println(value); // prints “John Doe”

En utilisant les handles de méthode, le processus est similaire. On commence par obtenir la classe de notre instance d'objet, puis on utilise la méthode privateLookupIn() sur MethodHandles pour respecter les modificateurs d'accès du champ (puisqu'il est privé). Ensuite, nous utilisons la méthode findVarHandle() pour trouver le champ auquel nous souhaitons accéder. Enfin, nous pouvons utiliser la méthode get() pour récupérer sa valeur. Voici le code de ce processus :

Class<?> clazz = objectInstance.getClass(); 
VarHandle handle = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup()).findVarHandle(clazz, "name", String.class);
String value = (String) handle.get(objectInstance);
System.out.println(value); // prints “John Doe”

Il est recommandé d'instancier statiquement le handle pour des raisons de performances, mais cela nécessite de connaître le nom de la classe. Si vous ne connaissez pas le nom de la classe, il n'est pas possible d'utiliser cette approche.

Une limitation des handles de méthode est qu’ils ne fournissent pas de moyen de gérer les exceptions vérifiées. Diverses opérations sur les handles de méthode et les handles de var génèrent des exceptions vérifiées qui doivent être interceptées et déclarées dans le code de production.

En conclusion, les descripteurs de méthodes et de variables fournissent une gamme ciblée de fonctionnalités dans le JDK pour rechercher des métadonnées de classe et accéder aux méthodes et aux champs en dehors des restrictions Java normales. Bien qu'ils ne couvrent pas toutes les capacités de réflexion, ils offrent des alternatives plus sûres et optimisées pour ces tâches.

Découvrez la meilleure façon d'étudier pour la certification Java avec les plans d'études de MyExamCloud et profitez de tests pratiques gratuits.

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!