Uso y escenarios de uso de la clase LambdaMetafactory

introducir

Introducción:
la clase LambdaMetafactory es la clave para implementar expresiones Lambda dentro de Java. A través de LambdaMetafactory, el compilador de Java puede convertir expresiones Lambda en clases anónimas internas.
Las expresiones lambda son esencialmente azúcar sintáctica del compilador y se convierten en clases internas anónimas en tiempo de ejecución. El rol de LambdaMetafactory es realizar este proceso de conversión.
Escenario de uso:
cuando usamos expresiones Lambda en el código, el compilador usará LambdaMetafactory para convertir expresiones Lambda en clases internas anónimas

La clase LambdaMetafactory contiene principalmente tres métodos:

metafactory: se utiliza para convertir expresiones Lambda con múltiples parámetros en clases anónimas internas. Devuelve un objeto CallSite que representa la expresión convertida.
altMetafactory: se utiliza para convertir expresiones Lambda sin parámetros o con solo un parámetro en clases anónimas internas. También devuelve un objeto CallSite.
defaultCallSite: devuelve un objeto CallSite predeterminado. Cuando la expresión Lambda no se puede convertir con precisión, se llamará a este método para devolver el objeto predeterminado para evitar excepciones.

Estos tres métodos son la clave para el proceso de conversión de la expresión Lambda. El compilador seleccionará automáticamente el método apropiado para asignar la expresión Lambda que escribimos a la clase anónima interna y luego devolverá el objeto CallSite que representa esta expresión.

Los escenarios de uso de LambdaMetafactory incluyen principalmente:

Cuando usamos expresiones Lambda, el compilador usará la clase LambdaMetafactory para completar la conversión de expresiones a clases anónimas internas. Este es el escenario de uso principal de LambdaMetafactory, que es la base para implementar expresiones Lambda.
Cuando la expresión Lambda no se puede convertir con precisión, se llamará al método defaultCallSite para devolver un objeto CallSite predeterminado para garantizar la ejecución normal del método. Este es un escenario anormal, principalmente considerando la robustez de la transformación.
Cuando necesite comprender profundamente los principios de las expresiones Lambda, puede estudiar el código fuente de la clase LambdaMetafactory. Al observar cómo completa la asignación de expresiones Lambda a clases anónimas internas, podemos comprender mejor el mecanismo de trabajo de Lambda. Este es un escenario de uso más avanzado.

Entonces, el uso de LambdaMetafactory desde dos aspectos:

Por un lado:
su uso es transparente para nosotros, y cuando usamos expresiones lambda, el compilador llamará automáticamente al método correspondiente. Este es el uso básico de LambdaMetafactory.
Por otro lado,
comprender el principio y el mecanismo de implementación de LambdaMetafactory nos ayudará a estudiar en profundidad el complejo proceso de trabajo detrás de las expresiones Lambda. Este es un uso más avanzado, principalmente para desarrolladores que dominan Java y los principios de compilación de Java.

Resumen: en general, LambdaMetafactory es la clave para implementar expresiones Lambda y su existencia nos permite usar fácilmente Lambda en el código. Al mismo tiempo, comprender esta clase también nos brinda la oportunidad de aprender más sobre una característica importante introducida en las expresiones Java8-Lambda.

Uso del método de la metafábrica

El método metafactory es uno de los métodos más importantes de la clase LambdaMetafactory. Su función es convertir expresiones lambda con múltiples parámetros en clases anónimas internas.

Su firma de método es:

public static CallSite metafactory(MethodHandles.Lookup caller, 
                                   String invokedName, 
                                   MethodType invokedType, 
                                   MethodType samMethodType, 
                                   MethodHandle implMethod, 
                                   MethodType instantiatedMethodType)

Descripción de parámetros:

llamador: método para encontrar objetos para verificar permisos
invocatedName: indica el nombre del método invocado por la expresión Lambda
invocadoTipo: Indica el tipo de expresión Lambda
samMethodType: Indica el tipo de método abstracto en la interfaz funcional
implMethod: indica el identificador del método que se reemplazará por la expresión Lambda
instantiatedMethodType: indica el tipo de interfaz que implementará la clase anónima interna.
Este método devolverá un objeto CallSite, que representa el punto de llamada de la expresión Lambda.

Por ejemplo, tenemos una expresión Lambda como esta:

//该表达式的类型是(int, int) -> int,要代替的方法是int x(int, int)。
(x, y) -> x + y

A través del método metafactory, esta expresión lambda se transformará en:

new I() {
    
    
   public int m(int x, int y) {
    
    
     return x + y; 
   } 
}

I es una interfaz funcional y m es un método abstracto en la interfaz.

Los pasos principales de la conversión son:

Obtenga el tipo de expresión Lambda (invokedType) y el tipo de interfaz que se implementará (instantiatedMethodType)
Obtener el identificador del método que se va a reemplazar (implMethod)
Cree un objeto CallSite que represente el sitio de invocación de la expresión Lambda
CallSite creará una clase anónima interna y anulará el método abstracto correspondiente
Devuelve el objeto CallSite, que representa la expresión Lambda convertida

Entonces, a través del método metafactory, el compilador puede convertir expresiones Lambda con múltiples parámetros en clases anónimas internas. Esta es la clave para implementar expresiones Lambda, y hemos usado implícitamente este método cuando usamos expresiones Lambda.
Comprender el principio de la metafábrica puede brindarnos una comprensión más profunda del mecanismo de trabajo de las expresiones lambda. Aunque no necesita tocar este método directamente en el uso diario, como desarrollador de Java, es útil comprender los principios detrás de las expresiones Lambda.

Uso del método altMetafactory

El método altMetafactory es otro método importante en la clase LambdaMetafactory. Su función es convertir expresiones lambda sin parámetros o con solo un parámetro en clases anónimas internas.

Su firma de método es:

public static CallSite altMetafactory(MethodHandles.Lookup caller, 
                                    String invokedName, 
                                    MethodType invokedType,  
                                    Object... invokedExactArgs)

Descripción de parámetros:

llamador: método para encontrar objetos para verificar permisos
invocatedName: indica el nombre del método invocado por la expresión Lambda
invocadoTipo: Indica el tipo de expresión Lambda
invocadoExactArgs: Indica la lista de parámetros de la expresión Lambda

Este método devolverá un objeto CallSite, que representa el sitio de llamada de la expresión Lambda.

Por ejemplo, tenemos una expresión Lambda como esta:

() -> System.out.println("Hello")
//该表达式的类型是() -> void,没有参数。

A través del método altMetafactory, esta expresión Lambda se transformará en:

new I() {
    
    
   public void m() {
    
    
     System.out.println("Hello");
   }
}

I es una interfaz funcional y m es un método abstracto en la interfaz.

Los pasos principales de la conversión son:

Obtener el tipo de expresión Lambda (invokedType)
Cree un objeto CallSite que represente el sitio de invocación de la expresión Lambda
CallSite creará una clase anónima interna y anulará el método abstracto correspondiente
Devuelve el objeto CallSite, que representa la expresión Lambda convertida

Entonces, a través del método altMetafactory, el compilador puede convertir expresiones Lambda sin parámetros o solo un parámetro en clases anónimas internas. Esta es también la clave para implementar expresiones Lambda.
Al igual que el método metafactory, altMetafactory también es una parte importante del proceso de transformación de expresiones Lambda y se especializa en la transformación de expresiones Lambda simples. Comprender el principio de este método nos permite comprender completamente el mecanismo de trabajo de las expresiones Lambda, aunque no necesitamos usarlas directamente en la programación diaria.
La expresión Lambda es una característica importante introducida en Java 8. Para dominar verdaderamente Lambda, debe tener una comprensión profunda de los principios que la sustentan. altMetafactory y metafactory son dos métodos clave para realizar Lambda, y cooperan con el compilador para completar el proceso de conversión de la expresión Lambda a la clase anónima interna.

Uso del método defaultCallSite

El método defaultCallSite es otro método de la clase LambdaMetafactory. Su función es devolver un objeto CallSite predeterminado.

Su firma de método es:

public static CallSite defaultCallSite(MethodHandles.Lookup caller, 
                                      String invokedName, 
                                      MethodType invokedType)

Descripción de parámetros:

llamador: método para encontrar objetos para verificar permisos
invocatedName: indica el nombre del método invocado por la expresión Lambda
invocadoTipo: Indica el tipo de expresión Lambda

Este método devuelve un objeto CallSite predeterminado.

Cuando la expresión Lambda no se puede convertir con precisión en una clase anónima interna a través de la clase LambdaMetafactory, se utilizará el método defaultCallSite para devolver un objeto CallSite predeterminado. Este objeto predeterminado no se convierte en una clase anónima interna de coincidencia exacta como lo hacen los métodos metafactory y altMetafactory.
Su función es principalmente asegurar que el método de la clase LambdaMetafactory regrese en todos los casos, y no habrá excepciones como NullPointerException. Pero es posible que el objeto CallSite devuelto no represente exactamente la expresión Lambda escrita por el programador.

Por ejemplo, tenemos una expresión Lambda como esta:

(x, y) -> x + y

Si no se puede convertir con precisión en una clase anónima interna a través del método metafactory , se llamará al método defaultCallSite para devolver un objeto CallSite predeterminado.
Este objeto no representa la expresión Lambda (x, y) -> x + y, pero puede evitar excepciones.
Por lo tanto, la función principal del método defaultCallSite es devolver un valor predeterminado para garantizar la ejecución normal del método cuando falla la conversión de la expresión Lambda.
No asigna exactamente expresiones lambda a clases anónimas internas como lo hacen los métodos metafactory y altMetafactory.
Su existencia se debe principalmente a la consideración de condiciones anormales, para garantizar que el método de la clase LambdaMetafactory tenga un valor de retorno determinado bajo cualquier circunstancia. Sin embargo, el objeto CallSite devuelto no representa necesariamente con precisión la expresión Lambda escrita por el programador, a la que se debe prestar atención cuando se usa.

Al comprender el uso de la clase LambdaMetafactory, también debe comprender el método defaultCallSite. Aunque no lo usamos directamente en la programación diaria, es parte del mecanismo de conversión de expresiones de Lambda, y su existencia demuestra que Java considera excepciones en este sentido. Comprender este método nos ayuda a comprender completamente los principios de implementación de las expresiones Lambda.