El concepto de Reflection en lenguajes orientados a objetos no tiene nada que ver con el conocido efecto gráfico que muestra un reflejo de un componente.
Se trata una técnica de programación que permite crear clases, invocar métodos y acceder a variables incluso cuando no sabemos los nombres de las clases,
métodos o propiedades hasta el momento de la ejecución.
Utilizando Reflection podemos crear componentes totalmente genéricos, que funcionen con cualquier tipo de objeto.
Si eres programador de java, seguramente te suene el paquete java.lang.Reflect que se utiliza para hacer este tipo de cosas.
Vamos a ver los conceptos básicos de las técnicas de Reflection en ActionScript y un sencillo ejemplo para que veáis en código cómo se hace.
Las funciones básicas para realizar reflection en actionscript se encuentran en el paquete flash.utils y nos permiten recuperar un xml que contiene toda la información del objeto:
- Nombre de la clase del objeto
- Clase de la que hereda
- Si se trata de un objeto dynamic, final o static
- Las variables del objeto
- Los métodos de acceso (comunmente llamados getters y setters)
- Métodos del objeto
- ... etc
También contamos con técnicas para crear clases cuyos nombres no conocemos hasta el momento de la ejecución. Así como invocar métodos o acceder a propiedades. Todo ello recuperando la información en tiempo de ejecución.
Con esta técnica podemos hacer componentes y aplicaciones totalmente genéricas y aplicables a cualquier tipo de objeto.
Muchos componentes del framework de flex utilizan algunas técnicas de reflection, por ejemplo el DataGrid.
Un datagrid no conoce el tipo de objeto que va a albergar hasta el momento de la ejecución.
Nosotros le indicamos en tiempo de compilación los dataField (los nombres de las propiedades).
Es en el momento de la ejecución cuando el datagrid recupera esas propiedades de los objetos que contiene,
independientemente de la clase de los objetos.
En actionScript, recuperar el valor de una variable de un objeto es realmente sencillo. Basta con tratar el objeto como si se tratase de un array asociativo, donde el índice es el nombre de la propiedad:
objeto ["nombreVariable"]
Recuperar información sobre un objeto es un poco más complicado. La función flash.utils.describeType devuelve un XML con información sobre el objeto
describeType (objeto)
Veamos un ejemplo. Tenemos la siguiente clase:
package com.gonzalopezzi.asreflection.vos
{
public class Persona
{
public function Persona () {
_id = (new Date ()).time;
}
private var _id : Number; // Esta propiedad es de sólo lectura (ver getter)
public var nombre : String;
public var apellidos : String;
public var nif : String;
public var fechaNacimiento : Date;
public var telefono : String;
public var prioridad : Number;
public function get id () : Number {
return _id;
}
public function dummy (a : Number, b : String) : String {
return "dummy";
}
}
}
Veamos qué ocurre si invocamos la función describeType con una instancia de esa clase. Obtenemos el siguiente xml:
<type name="com.gonzalopezzi.asreflection.vos::Persona" base="Object" isDynamic="false" isFinal="false" isStatic="false">
<extendsClass type="Object"/>
<variable name="fechaNacimiento" type="Date"/>
<variable name="nif" type="String"/>
<variable name="apellidos" type="String"/>
<method name="dummy" declaredBy="com.gonzalopezzi.asreflection.vos::Persona" returnType="String">
<parameter index="1" type="Number" optional="false"/>
<parameter index="2" type="String" optional="false"/>
</method>
<variable name="prioridad" type="Number"/>
<variable name="telefono" type="String"/>
<variable name="nombre" type="String"/>
<accessor name="id" access="readonly" type="Number" declaredBy="com.gonzalopezzi.asreflection.vos::Persona"/>
</type>
Con ese objeto XML y con la ayuda de sencillos operadores E4X, podemos conocer de forma instantánea toda la información que necesitamos de un objeto en tiempo de ejecución.
Pero nos falta algo. Todavía no sabemos cómo instanciar un objeto de una clase cuyo nombre no conocemos hasta el momento de la ejecución. Es sencillo. Veamos:
var clase : Class = getDefinitionByName(nombreClase) as Class;
var p : Object = new clase ();
¡Pero cuidado! Aquí nos encontramos con una gran limitación. Si intentamos ejecutar esto y le pasamos un nombre de clase que no se referencia en ningún lugar de la aplicación, vamos a obtener
un error. ¿Por qué ocurre esto? El compilador intenta economizar el peso del swf compilado. Para ello, no incluirá en la compilación las clases que no se usen, aunque estén dentro de nuestra carpeta de fuentes.
Típica pregunta: ¿Y si pongo un import para importar esa clase? ... así no hacemos nada. Aunque tengamos el import, si no hemos instanciado una variable de esa clase, no conseguiremos nada.
La solución: crear una clase con variables de los tipos que sabemos que podremos instanciar en tiempo de ejecución e instanciar esa clase en algún lugar de nuestro código. (ver clase ClassLinker en el ejemplo)
Aquí tenéis un pequeño ejemplo para que podáis ver todo esto en acción.
Las posibilidades de este tipo de técnicas son muy variadas y potentes. Podemos mejorar la productividad de nuestro equipo de desarrollo si creamos componentes y código que utilice objetos de forma genérica. Podremos crear también, aplicaciones mucho más flexibles y adaptables orientando nuestro desarrollo a la creación de interfaces con métodos bien definidos, enlazando las clases de implementación de las interfaces en tiempo de ejecución. Este tipo de técnicas constituyen un punto de partida esencial para motores de inyección de dependencias (también conocido como IoC, o Inversión de Control).
El desarrollo de aplicaciones web vuelve a ser divertido. Disfrutad.
