introduire
Introduction :
La classe LambdaMetafactory est la clé de l'implémentation des expressions Lambda dans Java. Grâce à LambdaMetafactory, le compilateur Java peut convertir des expressions Lambda en classes anonymes internes.
Les expressions lambda sont essentiellement du sucre syntaxique du compilateur et deviennent des classes anonymes internes lors de l'exécution. Le rôle de LambdaMetafactory est de réaliser ce processus de conversion.
Scénario d'utilisation :
lorsque nous utilisons des expressions Lambda dans le code, le compilateur utilise LambdaMetafactory pour convertir les expressions Lambda en classes anonymes internes
La classe LambdaMetafactory contient principalement trois méthodes :
- metafactory : utilisé pour convertir les expressions Lambda avec plusieurs paramètres en classes anonymes internes. Elle renvoie un objet CallSite représentant l'expression convertie.
- altMetafactory : utilisé pour convertir des expressions Lambda sans paramètre ou avec un seul paramètre en classes anonymes internes. Il renvoie également un objet CallSite.
- defaultCallSite : renvoie un objet CallSite par défaut. Lorsque l'expression Lambda ne peut pas être convertie avec précision, cette méthode est appelée pour renvoyer l'objet par défaut afin d'éviter les exceptions.
Ces trois méthodes sont la clé du processus de conversion de l'expression Lambda. Le compilateur sélectionnera automatiquement la méthode appropriée pour mapper l'expression Lambda que nous avons écrite à la classe anonyme interne, puis renverra l'objet CallSite représentant cette expression.
Les scénarios d'utilisation de LambdaMetafactory incluent principalement :
- Lorsque nous utilisons des expressions Lambda, le compilateur utilise la classe LambdaMetafactory pour terminer la conversion des expressions en classes anonymes internes. Il s'agit du principal scénario d'utilisation de LambdaMetafactory, qui constitue la base de l'implémentation des expressions Lambda.
- Lorsque l'expression Lambda ne peut pas être convertie avec précision, la méthode defaultCallSite est appelée pour renvoyer un objet CallSite par défaut afin de garantir l'exécution normale de la méthode. Il s'agit d'un scénario anormal, compte tenu principalement de la robustesse de la transformation.
- Lorsque vous avez besoin de comprendre en profondeur les principes des expressions Lambda, vous pouvez étudier le code source de la classe LambdaMetafactory. En observant comment il complète le mappage des expressions Lambda aux classes anonymes internes, nous pouvons mieux comprendre le mécanisme de fonctionnement de Lambda. Il s'agit d'un scénario d'utilisation plus avancé.
Donc l'utilisation de LambdaMetafactory sous deux aspects :
D'une part :
son utilisation nous est transparente, et lorsque nous utilisons des expressions Lambda, le compilateur appellera automatiquement la méthode correspondante. Il s'agit de l'utilisation de base de LambdaMetafactory.
D'autre part :
comprendre le principe et le mécanisme de mise en œuvre de LambdaMetafactory nous aidera à étudier en profondeur le processus de travail complexe derrière les expressions Lambda. Il s'agit d'une utilisation plus avancée, principalement pour les développeurs maîtrisant Java et les principes de compilation Java.
Résumé : En général, LambdaMetafactory est la clé de l'implémentation des expressions Lambda, et son existence nous permet d'utiliser facilement Lambda dans le code. Dans le même temps, la compréhension de cette classe nous donne également l'opportunité d'en savoir plus sur une fonctionnalité importante introduite dans les expressions Java8-Lambda.
Utilisation de la méthode métafactorielle
La méthode metafactory est l'une des méthodes les plus importantes de la classe LambdaMetafactory. Son rôle est de convertir les expressions lambda avec plusieurs paramètres en classes anonymes internes.
Sa signature de méthode est :
public static CallSite metafactory(MethodHandles.Lookup caller,
String invokedName,
MethodType invokedType,
MethodType samMethodType,
MethodHandle implMethod,
MethodType instantiatedMethodType)
Description du paramètre :
- appelant : méthode permettant de rechercher des objets pour vérifier les autorisations
- invocedName : indique le nom de la méthode invoquée par l'expression Lambda
- invocedType : indique le type d'expression Lambda
- samMethodType : indique le type de méthode abstraite dans l'interface fonctionnelle
- implMethod : indique le handle de méthode à remplacer par l'expression Lambda
- instantiatedMethodType : indique le type d'interface à implémenter par la classe anonyme interne.
Cette méthode renverra un objet CallSite, qui représente le point d'appel de l'expression Lambda.
Par exemple, nous avons une expression Lambda comme celle-ci :
//该表达式的类型是(int, int) -> int,要代替的方法是int x(int, int)。
(x, y) -> x + y
Grâce à la méthode metafactory, cette expression Lambda sera transformée en :
new I() {
public int m(int x, int y) {
return x + y;
}
}
I est une interface fonctionnelle et m est une méthode abstraite dans l'interface.
Les principales étapes de conversion sont :
- Obtenir le type d'expression Lambda (invokedType) et le type d'interface à implémenter (instantiatedMethodType)
- Obtenir le handle de méthode à remplacer (implMethod)
- Créer un objet CallSite qui représente le site d'appel de l'expression Lambda
- CallSite créera une classe anonyme interne et remplacera la méthode abstraite correspondante
- Renvoie l'objet CallSite, qui représente l'expression Lambda convertie
Ainsi, grâce à la méthode metafactory, le compilateur peut convertir des expressions Lambda avec plusieurs paramètres en classes anonymes internes. C'est la clé de l'implémentation des expressions Lambda, et nous avons implicitement utilisé cette méthode lors de l'utilisation des expressions Lambda.
Comprendre le principe de la méta-usine peut nous permettre de mieux comprendre le mécanisme de fonctionnement des expressions Lambda. Bien que vous n'ayez pas besoin de toucher directement à cette méthode dans l'utilisation quotidienne, en tant que développeur Java, il est utile de comprendre les principes qui sous-tendent les expressions Lambda.
Utilisation de la méthode altMetafactory
La méthode altMetafactory est une autre méthode importante de la classe LambdaMetafactory. Sa fonction est de convertir des expressions Lambda sans paramètre ou avec un seul paramètre en classes anonymes internes.
Sa signature de méthode est :
public static CallSite altMetafactory(MethodHandles.Lookup caller,
String invokedName,
MethodType invokedType,
Object... invokedExactArgs)
Description du paramètre :
- appelant : méthode permettant de rechercher des objets pour vérifier les autorisations
- invocedName : indique le nom de la méthode invoquée par l'expression Lambda
- invocedType : indique le type d'expression Lambda
- invocedExactArgs : indique la liste des paramètres de l'expression Lambda
Cette méthode renvoie un objet CallSite, qui représente le site appelant de l'expression Lambda.
Par exemple, nous avons une expression Lambda comme celle-ci :
() -> System.out.println("Hello")
//该表达式的类型是() -> void,没有参数。
Grâce à la méthode altMetafactory, cette expression Lambda sera transformée en :
new I() {
public void m() {
System.out.println("Hello");
}
}
I est une interface fonctionnelle et m est une méthode abstraite dans l'interface.
Les principales étapes de conversion sont :
- Obtenir le type d'expression Lambda (invokedType)
- Créer un objet CallSite qui représente le site d'appel de l'expression Lambda
- CallSite créera une classe anonyme interne et remplacera la méthode abstraite correspondante
- Renvoie l'objet CallSite, qui représente l'expression Lambda convertie
Ainsi, via la méthode altMetafactory, le compilateur peut convertir des expressions Lambda sans paramètre ou avec un seul paramètre en classes anonymes internes. C'est également la clé de l'implémentation des expressions Lambda.
Comme la méthode metafactory, altMetafactory est également une partie importante du processus de transformation des expressions Lambda et se spécialise dans la transformation d'expressions Lambda simples. Comprendre le principe de cette méthode nous permet de saisir pleinement le mécanisme de fonctionnement des expressions Lambda, bien que nous n'ayons pas besoin de les utiliser directement dans la programmation quotidienne.
L'expression Lambda est une fonctionnalité importante introduite dans Java 8. Pour vraiment maîtriser Lambda, vous devez avoir une compréhension approfondie des principes qui la sous-tendent. altMetafactory et metafactory sont deux méthodes clés pour réaliser Lambda, et elles coopèrent avec le compilateur pour terminer le processus de conversion de l'expression Lambda en classe anonyme interne.
Utilisation de la méthode defaultCallSite
La méthode defaultCallSite est une autre méthode de la classe LambdaMetafactory. Son rôle est de renvoyer un objet CallSite par défaut.
Sa signature de méthode est :
public static CallSite defaultCallSite(MethodHandles.Lookup caller,
String invokedName,
MethodType invokedType)
Description du paramètre :
- appelant : méthode permettant de rechercher des objets pour vérifier les autorisations
- invocedName : indique le nom de la méthode invoquée par l'expression Lambda
- invocedType : indique le type d'expression Lambda
Cette méthode renvoie un objet CallSite par défaut.
Lorsque l'expression Lambda ne peut pas être convertie avec précision en une classe anonyme interne via la classe LambdaMetafactory, la méthode defaultCallSite sera utilisée pour renvoyer un objet CallSite par défaut. Cet objet par défaut n'est pas converti en une classe anonyme interne à correspondance exacte comme le font les méthodes metafactory et altMetafactory.
Sa fonction est principalement de garantir que la méthode de la classe LambdaMetafactory est renvoyée dans tous les cas, et qu'il n'y aura pas d'exceptions telles que NullPointerException. Mais l'objet CallSite renvoyé peut ne pas représenter exactement l'expression Lambda écrite par le programmeur.
Par exemple, nous avons une expression Lambda comme celle-ci :
(x, y) -> x + y
S'il ne peut pas être converti avec précision en une classe anonyme interne via la méthode metafactory , la méthode defaultCallSite sera appelée pour renvoyer un objet CallSite par défaut.
Cet objet ne représente pas l'expression Lambda (x, y) -> x + y, mais il peut éviter les exceptions.
Par conséquent, la fonction principale de la méthode defaultCallSite est de renvoyer une valeur par défaut pour garantir l'exécution normale de la méthode lorsque la conversion de l'expression Lambda échoue.
Il ne mappe pas exactement les expressions lambda aux classes anonymes internes comme le font les méthodes metafactory et altMetafactory .
Son existence est principalement due à la prise en compte des conditions anormales, pour s'assurer que la méthode de la classe LambdaMetafactory a une certaine valeur de retour en toutes circonstances. Cependant, l'objet CallSite renvoyé ne représente pas nécessairement avec précision l'expression Lambda écrite par le programmeur, à laquelle il faut prêter attention lors de son utilisation.
Lorsque vous comprenez l'utilisation de la classe LambdaMetafactory, vous devez également comprendre la méthode defaultCallSite. Bien que nous ne l'utilisions pas directement dans notre programmation quotidienne, il fait partie du mécanisme de transformation des expressions Lambda, et son existence montre que Java considère les exceptions à cet égard. La compréhension de cette méthode nous aide à bien comprendre les principes de mise en œuvre des expressions Lambda.