Java 7: Soporte a lenguajes dinmicos

Roberto Montero Miguel 01/11/2011 7

Java 7: Soporte a lenguajes dinmicos

Tabla de contenido
1. Introduccin ............................................................................................................................. 2 1.1. Introduccin a los lenguajes dinmicos........................................................................... 2 2. Lenguajes dinmicos ejecutados sobre la mquina virtual Java ........................................... 4 3. Especificacin JSR-292 y Java 7............................................................................................ 5 4. El paquete java.lang.invoke .................................................................................................... 6 4.1. Primeras prcticas con el paquete java.lang.invoke ....................................................... 8 Prctica 1: Un ejemplo simple con invocador dinmico ......................................................... 9 Prctica 2: Diferencia entre lookup y publicLookup.............................................................. 11 Prctica 3: Diferencia entre invoke() e invokeExact() en el retorno de parmetros. ........... 12 Prctica 4: Diferencia entre MutableCallSite y ConstantCallSite. ........................................ 14 Prctica 5: Invocando a mtodos con parmetros de entrada y salida ............................... 16 Prctica 6: El mtodo filterReturnValue a fondo................................................................... 18 Prctica 7: Invocar a constructores....................................................................................... 19 Prctica 8: Acceder a las campos de la clase ...................................................................... 20 Prctica 9: Mtodos estticos ............................................................................................... 21 Prctica 10: Trabajando con interfaces ................................................................................ 22 5. Conclusiones ......................................................................................................................... 23 6. Anexo: Referencias ............................................................................................................... 24

www.javahispano.org

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos

1. Introduccin
Una de las novedades ms destacadas que incorpora Java 7 es el soporte mejorado a los lenguajes dinmicos. Esta nueva caracterstica es de gran transcendencia, debido a dos factores totalmente distintos, por un lado la clara apuesta de Oracle por abrir camino y apoyar a otros lenguajes de programacin capaces de ejecutarse sobre la mquina virtual de Java y que actualmente se encuentran en pleno auge. Por otro lado, esta nueva peculiaridad del lenguaje Java, ha implicado importantes cambios a nivel de la propia mquina virtual, incorporando nuevas instrucciones bytecode. Recordar que la filosofa de estos lenguajes dinmicos rompe un poco con la de Java que se identifica por su sintaxis principalmente esttica.

1.1. Introduccin a los lenguajes dinmicos

En esta seccin trataremos de definir e identificar los lenguajes dinmicos, olvidndonos por el momento del lenguaje Java. Un lenguaje dinmico es aquel que define su comportamiento en tiempo de ejecucin, y en ocasiones no requiere de un proceso previo de compilacin. Uno de los principios de los lenguajes dinmicos, es que el programador est libre de preocupaciones livianas, como por ejemplo la declaracin de las variables y sus apropiados tipos de datos, posponiendo al tiempo de ejecucin, este tipo de tareas que definirn el comportamiento del programa. Debido a este tipo evaluaciones de la sintaxis del programa en tiempo de ejecucin, hay quienes pueden pensar que se trata de lenguajes lentos o poco eficientes, pero esta afirmacin no es del todo cierta para la mayora de estos lenguajes, adems de que proporcionan interesantes caractersticas, como mayor flexibilidad y menor nmero de lneas de cdigo para construir un programa. En los lenguajes estticos la variables deben ser inicializadas antes de ser usadas, tarea que deber realizar el desarrollador del programa (declarar el tipo y ser inicializado), mientras que en los lenguajes dinmicos, la accin de definir el tipo de dato se realizar en tipo de ejecucin. Veamos a continuacin algunos ejemplos de las caractersticas de los lenguajes dinmicos, para ello hemos escogido JavaScript, aunque podramos haber elegido cualquiera de los lenguajes ilustrados en la tabla 1.1.

www.javahispano.org

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos

<html> <script> a = 1; a = a + 3; alert(a); //Mostramos un mensaje con el valor de a (es un nmero) a = a + "hola mundo"; alert(a); //Mostramos un mensaje con el valor de a (ahora ya es una cadena de texto) </script> </html>
Listado 1.1 Lenguaje dinmico JavaScript

En el listado 1.1, para los acostumbrados a los lenguajes estticos, lo primero que nos puede llamar la atencin es la asignacin de un valor a la variable a sin haber definido antes el tipo de dato que recibir. A continuacin, como en cualquier otro lenguaje, realizamos una operacin aritmtica de suma, para posteriormente mostrar en un mensaje, el nuevo valor adquirido, que como podremos comprobar, an es un tipo numrico. En el siguiente paso concatenamos una cadena de texto a la misma variable, y aqu viene la magia de los lenguajes dinmicos, la variable ha pasado a ser un tipo de dato alfanumrico como comprobaremos al mostrar el mensaje por pantalla. Podemos convertir el listado anterior en una nica funcin, mientras que si lo comparamos con un lenguaje de programacin esttico, necesitaremos al menos dos funciones:

<html> <script> function doTest(salida){ alert(salida); } a = 1; a = a + 3; doTest(a);//Llamamos a la funcin pasndole un dato numrico a = a + "hola mundo"; doTest(a); //Llamamos a la funcin pasndole un dato tipo texto </script> </html>
Listado 1.2 Lenguaje dinmico JavaScript II

package org.javahispano; public class TestEstatico { public static void main(String[] args) { int a = 1; a = a + 3; doTest(a); String strB = a + "hola mundo"; doTest(strB);

www.javahispano.org

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos

} public static void doTest(int variableNumerica) { System.out.println(variableNumerica); } public static void doTest(String variableTexto) { System.out.println(variableTexto); } }
Listado 1.3 Lenguaje esttico Java

En la siguiente tabla podemos encontrar algunos de los lenguajes clasificados como dinmicos: ActionScript ColdFusion E programming language Matlab Perl Ruby BASIC Common Lisp and some other Lisps JavaScript Lua PHP Smalltalk BeanShell Groovy VBScript Objective-C Python Tcl

Tabla 1.1 - Algunos lenguajes dinmicos (fuente Wikipedia)

2. Lenguajes dinmicos ejecutados sobre la mquina virtual Java

Existen multitud de lenguajes dinmicos capaces de ejecutarse sobre la mquina virtual Java. Podemos diferenciarlos en dos grupos: los que tienen sus races en otros lenguajes alejados de Java que han sido versionados para su ejecucin sobre la JVM (tabla 1.2), y los que fueron diseados especficamente para ser ejecutados sobre ella (tabla 1.3):
Language On JVM

Erlang JavaScript Pascal PHP www.javahispano.org

Erjang Rhino Free Pascal Resin

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos Python REXX Ruby Tcl Jython NetRexx[4] JRuby Jacl

Tabla 1.2 Lenguajes versionados para su ejecucin en JVM (fuente Wikipedia)

Language JVM Groovy Scala Fantom BBj Clojure

Tabla 1.3 Lenguajes diseados para su ejecucin en JVM (fuente Wikipedia)

Otra caracterstica de algunos de estos lenguajes es que a la hora de ejecutarlos tenemos dos opciones: Ejecutar directamente el cdigo fuente sobre la mquina virtual a travs de ciertas clases Java que lo interpretarn. Compilar el cdigo fuente generando bytecode compatible con el de la JVM.

Existen al menos dos especificaciones que estandarizan este tipo de lenguajes: JSR-223: Fija los mecanismos para los lenguajes scripting basados en Java. JSR-292: Fija los mecanismos para proporcionar un mejor soporte a los lenguajes dinmicos ejecutados sobre la JVM.

En este artculo nos centraremos principalmente en la especificacin JSR292, siendo esta la que ha fijado los estndares para este nuevo soporte a los lenguajes dinmicos en Java 7, aunque no podemos olvidar que ambas especificaciones son compatibles, es decir, un lenguaje scripting puede ser tambin dinmico. Un claro ejemplo de ello es Groovy, que puede ser un lenguaje de scripting a la vez que dinmico.

3. Especificacin JSR-292 y Java 7

Hasta ahora para traducir estos lenguajes con sintaxis dinmica a un bytecode esttico Java, se utilizaban tcnicas de reflexin o Reflection API. Con este API es posible invocar dinmicamente en tiempo de ejecucin a un mtodo cuya firma (nombre y tipo de parmetros que recibe) corresponde con los tipos de variables conocidos nicamente en el momento de su ejecucin. El problema radica en que el API Reflection, no es muy eficaz cuando se hace un www.javahispano.org

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos uso intensivo de la misma, es decir es bastante ms lento invocar a un mtodo de una clase a travs de este API que hacerlo directamente, quedando linkada en tiempo de compilacin. Como mencionamos anteriormente la adopcin de la especificacin JSR-292 en Java 7, sobre todo trasciende a nivel de bytecode, aunque tambin ha dado lugar a la inclusin de un nuevo paquete java.lang.invoke. Para un desarrollador Java, esta nueva especificacin solo le ofrece una forma ms eficiente de hacer reflection, pero donde realmente se explotar todo su potencial es en este tipo de lenguajes dinmicos, que sern capaces de generar bytecode optimizado para un mayor rendimiento sobre la JVM.

4. El paquete java.lang.invoke
En esta seccin repasaremos brevemente la definicin del paquete java.lang.invoke. Se trata de presentar de una forma muy simplificada las clases que componen dicho paquete, as como algunos de sus mtodos. Debe tener en cuenta que el API es algo ms complejo de lo que se representa en el presente documento. Aun as, no se preocupe si no termina entender las definiciones ilustradas tericamente, los ejemplos plasmados posteriormente le sern de gran ayuda para lograr una base de conocimientos bsicos de esta nueva funcionalidad: CallSite ser la clase que tomaremos de partida a la hora de implementar invocaciones dinmicas. Envolver a la clase MethodHandle utilizada para hacer referencia al objeto que se desea invocar (target). Se trata de una clase abstracta, y por lo tanto no se puede instanciar directamente, para ello utilizaremos alguna de sus tres implementaciones: ConstantCallSite: Usaremos esta clase para invocar a los mtodos, campos o constructores de un objeto. La peculiaridad es que la instancia del objeto no podr ser variada. MutableCallSite: Al contrario que la clase anterior, podremos modificar el target, cambiando la instancia del objeto con la que estamos trabajando. VolatileCallSite: Acta igual que las variables voltiles. Algunos de los mtodos que podemos encontrar en esta clase abstracta son: <MethodHandle> dynamicInvoker(): Linkar al objeto a instanciar (target) a travs de la nueva instruccin bytecode invokedynamic. A travs de este mtodo conseguiremos un mayor rendimiento en la invocacin de los mtodos y campos del objeto. <MethodHandle> getTarget(): Retorna una instancia de MethodHandle con la referencia al objeto target con el que estamos trabajando. <void> setTarget(MethodHandle newTarget): Configura un nuevo objeto sobre el que operar a travs de la clase MethodHandle. <MethodType> type(): Retorna una instancia MethodType donde se encuentran algunas de las caractersticas del target.

www.javahispano.org

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos MethodHandle: Utilizada para apuntar y ejecutar mtodos del target (instancia del objeto referenciada desde alguna de las implementaciones de la clase CallSite). Al tratarse de una clase abstracta, no podr instanciarse directamente, para obtener una referencia a la misma utilizaremos la clase MethodHandles. Entre los diferentes mtodos ofrecidos por esta clase, haremos espacial hincapi en los dos siguientes: <Object> invoke(Object... args): Invoca al mtodo manejado por la clase MethodHandle. Retornar el valor devuelto por el mismo. <Object > invokeExact(Object... args): Al igual que el caso anterior invoca al mtodo manejado por la clase MethodHandle, con la salvedad que ser necesarin realizar un cast al objeto exacto retornado por dicho mtodo. MethodHandles: A travs de ella ser posible obtener referencia a una instancia de MethodHandle que es capaz de ejecutar uno o varios mtodos del target referenciado. Por ejemplo es posible buscar un mtodo dentro de una clase dado un patrn o tratar el resultado de la ejecucin de uno de estos mtodos aplicndolo como parmetro a otro. Esta clase se compone exclusivamente de mtodos estticos. Entre ellos podemos destacar: <static MethodHandles.Lookup> lookup(): Retorna una instancia de MethodHandles.Lookup a travs de la cual podremos buscar campos, mtodos o constructores del target. La restricciones de acceso a los miembros del target sern las mismas que si tratsemos de acceder al objeto directamente en tiempo de compilacin (sin usar reflection ni el paquete java.lang.invoke). <static MethodHandles.Lookup> publicLookup(): Funcionalidad idntica a la anterior, con la salvedad de que en este caso solo ser posible acceder a los miembros pblicos del objeto con el que deseamos trabajar. <static MethodHandle> filterReturnValue(MethodHandle target, MethodHandle filter): Utilidad para procesar el resultado de la ejecucin de un mtodo a travs de otro mtodo manejado. MethodHandles.Lookup: Factora para crear las instancias de la clase MethodHandle. Entre todos sus mtodos podemos destacar: <MethodHandle> findConstructor(Class<?> refc, MethodType type): Utilidad para invocar a los constructores de una clase. <MethodHandle> findGetter(Class<?> refc, String name, Class<?> type): Utilidad para acceder en modo lectura al valor de un campo de la clase.. <MethodHandle> findSetter(Class<?> refc, String name, Class<?> type): Utilidad para acceder en modo escritura a un campo de la clase. <MethodHandle> findStatic(Class<?> refc, String name, MethodType type): Utilidad para invocar a los mtodos estticos de una clase. <MethodHandle> findStaticGetter(Class<?> refc, String name, Class<?> type): Utilidad para acceder en modo lectura a un campo esttico de una clase. <MethodHandle> findStaticSetter(Class<?> refc, String name, Class<?> type): Utilidad para acceder en modo escritura a un campo esttico de una clase. <MethodHandle> findVirtual(Class<?> refc, String name, MethodType type): Utilidad para invocar a cualquier mtodo de una clase.

www.javahispano.org

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos MethodHandleProxies: Clase compuesta por mtodos estticos que crean instancias de MethodHandle capaces de trabajar con otros tipos de elementos, como por ejemplo interfaces. Algunos de sus mtodos son: <<T> T> asInterfaceInstance(Class<T> intfc, MethodHandle target): Convierte la instancia de un objeto en la implementacin de un interface que originalmente no implementaba. Esta utilidad solo funcionar para interfaces de un nico mtodo. <boolean> isWrapperInstance(Object x): Determina si el objeto recibido como parmetro ha sido convertido a travs de la utilidad asInterfaceInstance. MethodType: Clase final a travs de la cual se definir la firma del mtodo a invocar, es decir, se establecern los tipos de datos de entrada y salida del mtodo. SwitchPoint: Clase para controlar el estado de ciertas ejecuciones dinmicas. WrongMethodTypeException: Envolver algunas de las excepciones producidas en el paquete.

4.1. Primeras prcticas con el paquete java.lang.invoke

Despus de haber realizado una breve presentacin de los principios de este nuevo paquete, es hora de comenzar a realizar algunas prcticas sencillas para terminar de entender los conceptos aqu presentados. Para nuestros experimentos tomaremos como base una clase que contiene un juego bastante variado de mtodos y campos con diferentes caractersticas:

package org.javahispano; public class TestClass { public String strCampoPublico = "HOLA MUNDO"; private String strCampoPrivado = "Hey"; public TestClass() { System.out.println("Ejecutando constructor sin parmetros"); } public TestClass(String saludo) { System.out.println("Ejecutando constructor " + saludo); this.strCampoPrivado = saludo; } protected void metodoSinRetornoNiParametros() { System.out.println("TestObj::Metodo sin retorno ni parametros"); } public void metodoParaThread() {

www.javahispano.org

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos

try { Thread.sleep(10000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("THREAD metodoSinRetornoNiParametros ID " + Thread.currentThread().getId()); System.out.println("THREAD metodoSinRetornoNiParametros ACTIVOS " + Thread.activeCount()); System.out.println("TestObj::Metodo sin retorno ni parametros"); } public String metodoConRetornoStringSinParametros() { System.out .println("TestObj::metodoConRetornoStringSinParametros::Retornamos " + this.strCampoPrivado); return strCampoPrivado; } public String metodoConRetornoYTresParametros(int param1, short param2, String param3) { System.out.println("TestObj::metodoConRetornoYTresParametross::"); System.out.println(" param1:>" + param1); System.out.println(" param2:>" + param2); System.out.println(" param3:>" + param3); return "Adios"; } public static void metodoEstaticoSinRetornoNiParams() { System.out .println("TestObj::Metodo estatico sin retorno ni parametros"); } private void metodoPrivado() { System.out.println("TestObj::Metodo privado"); } }
Listado 1.4 Clase de ejemplo

Prctica 1: Un ejemplo simple con invocador dinmico

En esta primera prctica comenzaremos invocando a uno de los mtodos ms sencillos de la clase anterior: metodoSinRetornoNiParametros, cuya nica peculiaridad es que se trata de un miembro protegido. Para nuestro ejemplo inicial este modificador de acceso no supondr ningn problema, ya que la clase ser ejecutada desde el mismo paquete. Para ello seguiremos los siguientes pasos: 1. Declaramos el target definiendo la instancia del objeto TestClass con la que trabajaremos: www.javahispano.org

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos

//CallSite que nos permitir variar el target CallSite name = new MutableCallSite(MethodType.methodType(TestClass.class); name.setTarget(MethodHandles.constant(TestClass.class, new TestClass()));

2. Creamos el invocador dinmico.

//invocador dinmico MethodHandle MH_name = name.dynamicInvoker();

3. Definimos los parmetros de entrada y salida del mtodo. En este caso, como el mtodo no recibe parmetros, solo nos vemos obligados a declarar el retorno.
//Parmetros de salida MethodType MT_void = MethodType.methodType(void.class);

4. Buscamos el mtodo a invocar.

MethodHandle MH_metodoSinRetornoNiParametros = MethodHandles.lookup(). findVirtual(TestClass.class, "metodoSinRetornoNiParametros", MT_void);

5. Invocamos al mtodo.
MH_metodoSinRetornoNiParametros = MethodHandles.filterReturnValue(MH_name, MH_metodoSinRetornoNiParametros); MH_metodoSinRetornoNiParametros.invokeExact( );

package org.javahispano; import java.lang.invoke.CallSite; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import java.lang.invoke.MutableCallSite; public class Ejemplo { public static void main(String[] args) throws Throwable{ new Ejemplo().test1(); } public void test1() throws Throwable{ //CallSite que nos permitir variar el target CallSite name = new MutableCallSite(MethodType.methodType(TestClass.class); name.setTarget(MethodHandles.constant(TestClass.class, new TestClass())); //invocador dinmico MethodHandle MH_name = name.dynamicInvoker(); //Parmetros de salida MethodType MT_void = MethodType.methodType(void.class);

www.javahispano.org

10

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos

//Lookup del mtodo MethodHandle MH_metodoSinRetornoNiParametros = MethodHandles.lookup(). findVirtual(TestClass.class, "metodoSinRetornoNiParametros", MT_void); //Invocar al mtodo a travs del invocador dinmico MH_metodoSinRetornoNiParametros = MethodHandles.filterReturnValue(MH_name, MH_metodoSinR etornoNiParametros); MH_metodoSinRetornoNiParametros.invokeExact( ); } }
Listado 1.5 Prctica 1

El resultado que obtendremos al ejecutar la clase anterior ser similar a la salida representada en la siguiente imagen:

Figura 1.1 Resultado prctica 1

Prctica 2: Diferencia entre lookup y publicLookup

Cuando hacemos el lookup del mtodo se tendrn en cuenta las condiciones de acceso normales, es decir, desde la clase ilustrada en el listado 1.5 podremos acceder a los mtodos pblicos y protegidos de TestClass, pero no tendremos acceso a sus miembros privados. Podemos variar este comportamiento si en vez de utilizar lookup usamos publicLookup, restringiendo as el acceso nicamente a los miembros pblicos:
MethodHandle MH_metodoSinRetornoNiParametros = MethodHandles .publicLookup().findVirtual(TestClass.class, "metodoSinRetornoNiParametros", MT_void);
Listado 1.6 Prctica 2: publicLookup

Incluyendo la lnea anterior en el listado 1.5, ahora obtendremos la siguiente excepcin en tiempo de ejecucin:

www.javahispano.org

11

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos

Figura 1.2 Resultado prctica 2

Prctica 3: Diferencia entre invoke() e invokeExact() en el retorno de parmetros.

En esta prctica veremos la diferencia entre los mtodos invoke() e invokeExact(), ambos tienen la funcionalidad de ejecutar el mtodo referenciado por la clase MethodHandle, con la salvedad de que invokeExact() ser necesario realizar un cast a tipo de dato exacto retornado por el mtodo, mientras que el mtodo invoke() permitir hacer un cast a otros tipos de datos ms genricos, por ejemplo a un Object. Para ver esto de una forma prctica trataremos de invocar al mtodo metodoConRetornoStringSinParametros de la clase de ejemplo, que como su nombre indica, retornar un mtodo de tipo String:

public void test3() throws Throwable{ //CallSite que nos permitir variar el target CallSite name = new MutableCallSite(MethodType.methodType(TestClass.class)); name.setTarget(MethodHandles.constant(TestClass.class, new TestClass(Adios))); //invocador dinmico MethodHandle MH_name = name.dynamicInvoker(); //Parmetro de retorno MethodType MT_string = MethodType.methodType(String.class); Lookup lookup = MethodHandles.lookup(); String nomMetodo = "metodoConRetornoStringSinParametros"; MethodHandle MH_metConRetSinParam = lookup.findVirtual(TestClass.class, nomMetodo , MT_string); MH_metConRetSinParam = MethodHandles.filterReturnValue(MH_name, MH_metConRetSinParam); System.out.println("Retorno del mtodo " + (String)MH_metConRetSinParam.invokeExact( )); }
Listado 1.7 Prctica 3: Mtodo con retorno

Podemos ver que el cdigo expuesto en esta prctica guarda bastantes similitudes con el listado 1.5, con la salvedad que en esta ocasin el mtodo a invocar retorna un dato de tipo www.javahispano.org

12

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos String mostrado por consola a travs de un System.out. Por lo tanto el resultado de la ejecucin de este listado debera ser igual al de la figura 1.3:

Figura 1.3 Resultado prctica 3

En la ltima lnea del listado 1.7 se realiza un cast al tipo de retorno correcto del mtodo invocado. Este cast es totalmente necesario, ya que si tratamos de omitirlo obtendremos un error:

// Omitimos el cast System.out.println("Retorno del mtodo " + MH_metConRetSinParam.invokeExact());

Listado 1.8 Prctica 3: Mtodo invokeExact() sin cast

Con modificacin anterior provocaremos el siguiente error:

Figura 1.4 Excepcin prctica 3

En cambio, es posible sustituir el mtodo invokeExact() por invoke(), evitando este tipo de errores: www.javahispano.org

13

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos

System.out.println("Retorno del mtodo " + MH_metConRetSinParam.invoke()); System.out.println("Retorno del mtodo " + (Object) MH_metConRetSinParam.invoke());
Listado 1.8 Prctica 3: Mtodo invoke()

Prctica 4: Diferencia entre MutableCallSite y ConstantCallSite.

Como explicbamos anteriormente, existen diferentes implementaciones de la clase abstracta CallSite, dos de ellas son MutableCallSite y ConstantCallSite. La principal diferencia entre ellas es que ConstantCallSite no permite variar su target para trabajar con otra instancia de un objeto. Por ejemplo, invocamos al mismo mtodo de dos instancias diferentes:

public void test4() throws Throwable { // CallSite que nos permitir variar el target CallSite name = new MutableCallSite( MethodType.methodType(TestClass.class)); name.setTarget(MethodHandles.constant(TestClass.class, new TestClass( "Adios"))); // invocador dinmico MethodHandle MH_name = name.dynamicInvoker(); // Parametro de retorno MethodType MT_string = MethodType.methodType(String.class); Lookup lookup = MethodHandles.lookup(); String nomMetodo = "metodoConRetornoStringSinParametros"; MethodHandle MH_metConRetSinParam = lookup.findVirtual(TestClass.class, nomMetodo, MT_string); MH_metConRetSinParam = MethodHandles.filterReturnValue(MH_name, MH_metConRetSinParam); System.out.println("Retorno del mtodo " + MH_metConRetSinParam.invoke()); // Variamos el target name.setTarget(MethodHandles.constant(TestClass.class, new TestClass( "Aupa!"))); System.out.println("Retorno del mtodo " + MH_metConRetSinParam.invoke()); }
Listado 1.9 Prctica 4: MutableCallSite

www.javahispano.org

14

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos Si ejecutamos el listado anterior vemos como variamos la instancia del objeto con la que estamos trabajando, al llamar dos veces al constructor de la clase y reescribir el target mediante el mtodo setTarget:

Figura 1.5 Resultado prctica 4: MutableCallSite

A continuacin trataremos de realizar lo mismo que en el listado 1.9, pero usando un target de tipo ConstantCallSite:

public void test4() throws Throwable { // CallSite que NO nos permitir variar el target // El constructor es algo distinto al del MutableCallSite CallSite name = new ConstantCallSite(MethodHandles.constant( TestClass.class, new TestClass("Adios"))); // invocador dinmico MethodHandle MH_name = name.dynamicInvoker(); // Parmetro de retorno MethodType MT_string = MethodType.methodType(String.class); Lookup lookup = MethodHandles.lookup(); String nomMetodo = "metodoConRetornoStringSinParametros"; MethodHandle MH_metConRetSinParam = lookup.findVirtual(TestClass.class, nomMetodo, MT_string); MH_metConRetSinParam = MethodHandles.filterReturnValue(MH_name, MH_metConRetSinParam); System.out.println("Retorno del mtodo " + MH_metConRetSinParam.invoke()); // Variamos el target name.setTarget(MethodHandles.constant(TestClass.class, new TestClass( "Aupa!"))); System.out.println("Retorno del mtodo " + MH_metConRetSinParam.invoke()); }
Listado 1.10 Prctica 4: ConstantCallSite

www.javahispano.org

15

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos Si ejecutamos el listado anterior, aparecer un error al tratar de variar el target:

Figura 1.6 Resultado prctica 4: ConstantCallSite

Prctica 5: Invocando a mtodos con parmetros de entrada y salida

A continuacin realizaremos un sencillo ejemplo donde invocaremos a un mtodo con varios parmetros de entrada y uno de salida, para ello tomaremos el mtodo metodoConRetornoYTresParametros de la clase TesClass:
public void test5() throws Throwable { CallSite name = new MutableCallSite( MethodType.methodType(TestClass.class)); name.setTarget(MethodHandles.constant(TestClass.class, new TestClass())); MethodHandle MH_name = name.dynamicInvoker(); // retorno, parametro1, parametro2, parametro3 MethodType MT_parametros = MethodType.methodType(String.class, int.class, short.class, String.class); Lookup lookup = MethodHandles.lookup(); String nomMetodo = "metodoConRetornoYTresParametros"; MethodHandle MH_CnRetCnPara = lookup.findVirtual(TestClass.class, nomMetodo, MT_parametros); // Insertamos los tres parmetros de entrada MH_CnRetCnPara = MethodHandles.insertArguments(MH_CnRetCnPara, 1, (int) 2, (short) 3, "Iep"); MH_CnRetCnPara = MethodHandles.filterReturnValue(MH_name, MH_CnRetCnPara); System.out.println("Retorno del mtodo " + (String) MH_CnRetCnPara.invokeExact()); }
Listado 1.11 Prctica 5: Paso de parmetros

www.javahispano.org

16

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos

El ejemplo anterior solo difiere de los vistos hasta ahora en dos aspectos: Cuando se declara el MethodType primero se define el parmetro de retorno y a continuacin los tipos de datos que recibir como parmetro. Nueva instruccin insertArguments para dar valor a los parmetros de entrada. La salida de ejemplo anterior ser similar a la siguiente:

Figura 1.7 Resultado prctica 5

Otra opcin para invocar a este mtodo con menos lneas de cdigo, consiste en olvidarnos del invocador dinmico y pasarle los parmetros al mtodo desde el invokeExact(), tal y como podemos ver en el siguiente listado:

public void test5_2() throws Throwable { Lookup lookup = MethodHandles.lookup(); String nomMetodo = "metodoConRetornoYTresParametros"; MethodHandle cat = lookup.findVirtual(TestClass.class, nomMetodo, MethodType.methodType(String.class, int.class, short.class, String.class)); System.out.println("=>" + (String) cat .invokeExact(new TestClass(), 2, (short) 3, "Iep")); }
Listado 1.12 Prctica 5: Paso de parmetros con invokeExact

www.javahispano.org

17

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos

Prctica 6: El mtodo filterReturnValue a fondo

El mtodo filterReturnValue lo hemos visto hasta ahora guardando relacin con el invocador dinmico, a continuacin lo veremos en otro mbito de aplicacin distinto, pero manteniendo su definicin: procesa el resultado de un mtodo referenciado a travs de un MethodHandle, con otro mtodo tambin referenciado por otro MethodHandle diferente. Lo veremos mejor en un sencillo ejemplo aplicado sobre la clase String, donde concatenaremos dos cadenas (concat), para posteriormente convertirlas en maysculas (toUpperCase):

public void test6() throws Throwable { // Mtodo concat - MethodType String,String MethodHandle cat = MethodHandles.lookup().findVirtual(String.class, "concat", MethodType.methodType(String.class, String.class)); // Mtodo toUpper - MethodType String MethodHandle toUpper = MethodHandles.lookup().findVirtual(String.class, "toUpperCase", MethodType.methodType(String.class)); // Concatenamos y luego convertimos MethodHandle f0 = MethodHandles.filterReturnValue(cat, toUpper); System.out.println((String) f0.invokeExact("hola ", "mundo")); }
Listado 1.13 Prctica 6

En el listado anterior es importante fijarse en la definicin de los parmetros de los mtodos (MethodType), que se corresponden segn el API:

String

concat(String str)
Concatenates the specified string to the end of this string.

MethodType.methodType(String.class, String.class)

www.javahispano.org

18

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos String toUpperCase()

Converts all of the characters in this String to upper case using the rules of the default locale.

MethodType.methodType(String.class) Si ejecutamos el listado 1.13 obtendremos los String pasados como parmetro al mtodo invokeExact(), concatenados y capitalizados:

Figura 1.8 Resultado prctica 6

Prctica 7: Invocar a constructores

Al igual que con este API podemos invocar mtodos, tambin ser posible trabajar sobre los constructores. El siguiente ejemplo ilustra como instanciar una clase a travs de su constructor vaco:

public void test7() throws Throwable { MutableCallSite name_constructor = null; name_constructor = new MutableCallSite( MethodType.methodType(TestClass.class)); MethodType MT_parametros = MethodType.methodType(void.class); Lookup lookup = MethodHandles.lookup(); MethodHandle MH_contructor = lookup.findConstructor(TestClass.class, MT_parametros); MH_contructor.invoke(); }
Listado 1.14 Prctica 7: Invocar a constructores

www.javahispano.org

19

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos El listado anterior difiere del resto de los ejemplos hasta ahora presentados, en el mtodo findConstructor. Si ejecutamos el listado anterior, obtendremos una salida similar a la siguiente:

Figura 1.9 Resultado prctica 7

Prctica 8: Acceder a las campos de la clase

A travs del API podremos hacer Get y Set de sus campos no privados:

public void test8() throws Throwable { MutableCallSite name = new MutableCallSite( MethodType.methodType(TestClass.class)); name.setTarget(MethodHandles.constant(TestClass.class, new TestClass())); // invocador dinmico MethodHandle MH_name = name.dynamicInvoker(); MethodHandle MH_fieldSet = MethodHandles.lookup().findSetter( TestClass.class, "strCampoPublico", String.class); MH_fieldSet = MethodHandles.filterReturnValue(MH_name, MH_fieldSet); // Asignamos valor al campo MH_fieldSet.invokeExact("Ke pasa!"); // Recogemos el valor del campo MethodHandle MH_field = MethodHandles.lookup().findGetter( TestClass.class, "strCampoPublico", String.class); MH_field = MethodHandles.filterReturnValue(MH_name, MH_field); System.out.println("El valor del campo " + (String) MH_field.invokeExact()); }
Listado 1.15 Prctica 8: Acceder a los campos de la clase

Como se puede observar en el listado anterior utilizamos los mtodos findGetter y findSetter para hacer Get y Set del campo de la clase. Si ejecutamos el listado anterior tendremos el siguiente resultado: www.javahispano.org

20

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos

Figura 1.10 Resultado prctica 8

Prctica 9: Mtodos estticos

En esta prctica veremos cmo es posible acceder a los mtodos estticos de una clase de forma sencilla. Trataremos de acceder al mtodo esttico metodoEstaticoSinRetornoNiParams:

public void test9() throws Throwable { Lookup lookup = MethodHandles.lookup(); String nomMetodo = "metodoEstaticoSinRetornoNiParams"; MethodType MT_void = MethodType.methodType(void.class); MethodHandle MH_metodoEstatico = lookup.findStatic(TestClass.class, nomMetodo, MT_void); MH_metodoEstatico.invokeExact(); }
Listado 1.16 Prctica 9: Mtodos estticos

En este caso al tratarse de un mtodo esttico nos olvidamos del CallSite, haciendo lookup directamente sobre la definicin de la clase.

Figura 1.11 Resultado prctica 9

www.javahispano.org

21

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos

Prctica 10: Trabajando con interfaces

Una caracterstica interesante de este nuevo API es que nos posibilita la opcin de convertir una instancia de una clase en una implementacin de una interfaz a la cual no implementaba en su definicin. Una de las limitaciones de esta utilidad es que la interfaz a la que se quiere implementar debe de contener nicamente un solo mtodo. El paso de convertir una instancia de una clase en la implementacin de una interfaz, lo realizaremos a travs la clase MethodHandleProxies, concretamente haciendo uso del mtodo asInterfaceInstance. Para ilustrar esta utilidad, utilizaremos nuestra clase de ejemplo TestClass convirtindola en una implementacin de la interfaz Runnable. Esta transformacin nos permitir ejecutar dicha clase como un Thread:

public void test10() throws Throwable { MutableCallSite name = new MutableCallSite( MethodType.methodType(TestClass.class)); name.setTarget(MethodHandles.constant(TestClass.class, new TestClass())); Lookup lookup = MethodHandles.lookup(); // invocador dinmico MethodHandle MH_name = name.dynamicInvoker(); MethodType MT_void = MethodType.methodType(void.class); MethodHandle MH_thread = lookup.findVirtual(TestClass.class, "metodoParaThread", MT_void); MH_thread = MethodHandles.filterReturnValue(MH_name, MH_thread); // Transformamos la instancia en una implementacin de Runnable Runnable runnable = MethodHandleProxies.asInterfaceInstance( Runnable.class, MH_thread); System.out.println("El thread del main " + Thread.currentThread().getId()); // Ejecutamos el thread Thread t = new Thread(runnable); System.out.println("El nuevo thread " + t.getId()); t.start(); System.out.println("FIN de test "); }
Listado 1.17 Prctica 10

Si se fija en el mtodo metodoParaThread definido en la clase TestClass (Listado 1.4), puede ver cmo hacemos un Thread.sleep() durante 10 segundos, para que a la hora de ejecutar podamos verificar que realmente estamos ejecutndolo sobre un nuevo hilo diferente al principal. Por lo tanto en la ejecucin del listado anterior, podemos ver en la consola la salida FIN de test antes de que se termine de ejecutar el mtodo metodoParaThread:

www.javahispano.org

22

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos

Figura 1.12 Resultado prctica 10

5. Conclusiones
Como hemos visto a lo largo de este tutorial, en Java 7 disponemos de un nuevo API que puede sustituir en parte a los antiguos mecanismos de hacer Reflection. Este API nos proporciona utilidades para trabajar con los diferentes miembros de una clase teniendo en cuenta los modificadores de acceso. Adems nos regala una interesante utilidad para manipular interfaces. En este documento, tan solo hemos realizado algunas de las operaciones ms bsicas que nos brinda este API, pero puede ser un buen punto de partida para profundizar en ella y descubrir muchas de las otras caractersticas en las que no nos hemos detenido. Tal vez la mayor transcendencia de este nuevo API, se oculte en las nuevas instrucciones bytecode que genera, que indudablemente sern llevadas a su mximo exponente por la nueva generacin de lenguajes dinmicos ejecutados sobre la mquina virtual Java.

www.javahispano.org

23

Roberto Montero Miguel

Java 7: Soporte a lenguajes dinmicos

6. Anexo: Referencias
Dynamic Programing Language: http://en.wikipedia.org/wiki/Dynamic_programming_language List of JVM languages: http://en.wikipedia.org/wiki/List_of_JVM_languages JSR-223: http://www.jcp.org/en/jsr/detail?id=223 JSR-292: http://jcp.org/en/jsr/detail?id=292 Oracle - Java Virtual Machine Support for Non-Java Languages: http://docs.oracle.com/javase/7/docs/technotes/guides/vm/multiple-languagesupport.html Oracle - Dynamic Language Support on the Java Virtual Machine: http://www.oracle.com/technetwork/issue-archive/2010/10-may/o30java-099612.html The Da Vinci Machine Project: http://openjdk.java.net/projects/mlvm/ A rough guide to JVM languages: http://radar.oreilly.com/2011/07/jvm-languages.html Book - Whats New in Java 7: http://my.safaribooksonline.com/book/-/9781449318581 Book - The Well-Grounded Java Developer: http://www.manning.com/evans/

www.javahispano.org

24

Roberto Montero Miguel