Usando la API de reflexión de Java

Dentro de la infinidad de posibilidades que nos ofrece la API de Java, una de las más raritas es la denominada API de reflexión. Esta potente herramienta nos permite, en tiempo de ejecución, acceder desde un programa a absolutamente toda la información de sí mismo, así como de la API del lenguaje y de las librerías a las que tenga acceso. Y no sólo nos permite acceder a dicha información, sino también manipularla.

Para que os hagáis una idea, esta API nos permite invocar dinámicamente métodos (incluidos constructores) de otra clase u objeto. De esta forma podemos hacer cosas que van desde saltarnos los modificadores de acceso de una definición de clase, hasta hacer que dos objetos intercambien información de atributos privados sin que medien métodos getter y/o setter.

Por supuesto, no todo iba a ser bonito. En primer lugar, esta API es algo compleja, según los estándares de la propia API de Java. Además, el hecho de trabajar con objetos dinámicamente en nuestro código, hace que el control de errores en tiempo de compilación no funcione en muchas ocasiones; y que el control de errores en tiempo de ejecución se complique también en cierta medida.

Vamos a ver un ejemplo sencillo de cómo se usaría esta API. Supongamos que tenemos una clase de tipo Factory (patrón de diseño Abstract Factory) llamada ConnectionFactory, que dispone del siguiente método:

public static Connection getConnection(String type);

Por otro lado, Connection es una interfaz que es implementada en varias clases: HttpConnection, FtpConnection, SambaConnection, etc. Los constructores de estas clases tienen la siguiente pinta:

public Clase(String url, HashMap<String,Object> parameters);

Por supuesto, la solución clásica y fácil es hacer que el método getConnection de ConnectionFactory tenga una serie de sentencias de control “if” anidadas para determinar el tipo de conexión a instanciar, y devolverla. La pega es que, si añadimos a nuestro programa nuevos tipos de conexiones, tenemos que modificar igualmente el código de la clase Factory.

Como ya estaréis imaginando, gracias a la API de reflexión, es posible implementar el método getConnection de forma que no haya que modificarlo al añadir nuevos tipos de conexión a nuestra API. Además, vamos a hacer que el nuevo objeto de la conexión se devuelva al código llamante ya inicializado desde la clase Factory. Veamos cómo:

public static Connection getConnection(String type, HashMap<String,Object> parameters){
// Obtenemos el objeto de tipo Class
Class cl = Class.forName(type);
// Creamos los vectores de parámetros y tipos
Class[] paramType = new Class[2];
Object[] param = new Object[2];
// Especificamos el tipo de parámetros
paramType[0] = String.class;
paramType[1] = HashMap.class;
// Especificamos los parámetros
param[0] = (String) parameters.remove(“url”);
param[1] = parameters;
// Obtenemos el constructor
Constructor co = cl.getConstructor(paramType);
// Instanciamos el objeto
Object obj = co.newInstance(param);
// Obtenemos el método de inicialización
Method m = cl.getMethod(“init”);
// Invocamos al método
m.invoke(obj);
// Devolvemos el objeto instanciado
return (Connection) obj;
}

Creo que en este ejemplo se resume, de forma sencilla, cómo instanciar objetos e invocar métodos de forma dinámica, gracias a la API de reflexión de Java. Para obtener información más detallada, podéis echar un vistazo a este tutorial de Sun.