En esta practica vamos a
familiarizarnos con la arquitectura del sistema extensible a base de
plug-ins. El objetivo de la practica es:
- Realizar un checkout del repositorio
- Entender la arquitectura
- Escribir un plug-in muy simple
Ejercicio 1: Checkout y ejecución de la arquitectura.
Lo primero que vamos a hacer es obtener una copia local de la
arquitectura del sistema. Para ello vamos a utilizar un cliente de
subversion. En un primer tiempo vamos a hacer esto desde la
línea de comandos, y posteriormente lo haremos desde Eclipse.
Teclea svn --help para ver las distintas opciones que ofrece el cliente
subversion.
Primero vamos a ver un listado del repositorio:
$svn
ls svn://www.humbertocervantes.net
proyecto
$svn ls
svn://www.humbertocervantes.net/proyecto
trunk
branches
tags
$ svn ls svn://www.humbertocervantes.net/proyecto/trunk
build.xml
lib/
doc/
src/
|
Ahora vamos a hacer un checkout del trunk del proyecto:
$svn
checkout svn://www.humbertocervantes.net/proyecto/trunk
A trunk/doc
A trunk/lib
A trunk/src
A trunk/src/mx
A trunk/src/mx/uam
A trunk/src/mx/uam/ingsoft
...
A trunk/src/mx/uam/ingsoft/manejoproyecto
A
trunk/src/mx/uam/ingsoft/manejoproyecto/ManejadorProyectoImpl.java
A trunk/res
A trunk/res/manifest.mf
A trunk/build.xml
Checked out revision 12.
$ cd trunk
$ ls
build.xml doc lib res src
|
Una vez que nos hayamos traido la versión actual, ya podemos
compilarla.
$ant
...
run:
[java] Lista de plugins instalados:
[java] ----------------------------
|
En ese momento aparece una ventana con la aplicación. Al
aprtetar Opciones>Plugins se puede apreciar una ventana que muestra
la lista de plugins:
Ejercicio 2: Instalación
de un Plug-In
Un Plug-In se materializa
cómo un archivo JAR que contiene código ejecutable
así como un conjunto de informaciones necesarias a la
aplicación y que serán descritas más adelante. Una
vez que hemos instalado la
aplicación, es posible añadirle plug-ins de dos maneras
distintas:
- Manual: copiando un plugin en el directorio plugins
- A través de la aplicación: usando el boton
Instalar...
Instalar de cualquiera de los dos modos el plugin disponible en la
dirección siguiente:
http://www.humbertocervantes.net/plugins/pluginsimple.jar
- Ir a la lista de opciones (ahora debe aparecer un plug-in)
- Activarlo
- Ver que el plug-in introduce un menu en la
aplicación principal.
Ejercicio 3: Comprensión de
la arquitectura
Algunas de las clases
más importantes de la arquitectura son:
Clase Principal
La clase principal se encarga
de instanciar las diferentes
implementaciones de las interfaces y de conectarlas entre ellas.
Clase ControladorImpl
Esta clase contiene una
referencia hacia los modulos principales. A
traves del controlador, los distintos módulos podrán
controlar a la interfaz de usuario.
Clase AdministradorPluginsImpl
Esta clase es la clave de la
infraestructura. Permite realizar la
instalación, retiro, activación y desactivación de
Plugins.
- La clase recibe a traves de su constructor un directorio
donde se almacenarán los plugins instalados.
- La clase contiene un registro de plugins instalados
- La clase permite instalar un plugin desde un URL, que puede
representar desde un archivo local hasta un archivo en un sitio web
distante.
Clase PluginInfo
Esta clase representa un
plugin que esta cargado durante la
ejecución de la aplicación, independientemente de si
está activo o no. La clase permite obtener la información
del plug-in que se define en su Manifest (ver adelante)
Abre las distintas clases y
trata de entender la estructura a partir de
la arquitectura descrita en clase. Comprueba lo visto en clase:
- Existe un package común para todas las interfaces
- Existe un package para cada modulo, dentro de este package
se encuentra una implementación de la interfase
- Convenciones de códificación, de versiones,
etc...
Ejercicio 4: Plug-ins
En este momento ya haz
instalado un plug-in dentro del sistema. El
siguiente ejercicio consiste en hacer tu mismo un plug-in. Como se dijo
anteriormente un plug-in contiene lo siguiente en un archivo JAR:
- Código fuente
- Recursos asociados (por ejemplo íconos, etc...)
- Meta-informaciones
Meta-informaciones
Las Meta-Informaciones son
informaciones que proveer información del plug-in y le permiten
a la aplicación instanciarlo. Estas informaciones se describen
en un archivo de texto llamado un manifest.
El manifest siempre se incluye en un archivo JAR (cuando no se incluye
es generado de forma automática) y contiene conjuntos de
atributos con un nombre y un valor. Los atributos que se deben
especificar para un plug-in son los siguientes:
- Nombre-Plugin: atributo
obligatorio que identifica al
plug-in dentro de la aplicación
- Clase-Plugin: atributo
obligatorio que identifica la clase
principal del plug-in (la clase que implementa la interfaz Plugin)
- Autor-Plugin: atributo
opcional que describe al autor del
plug-in
- Version-Plugin: atributo
opcional que describe la version
del plug-in
- Inicia-Activo: atributo
opcional que define si el plugin es
activado al arrancar la aplicación.
Nombre-Plugin: PluginSimple
Clase-Plugin: mx.uam.plugin.PluginSimple
Autor-Plugin: Humberto Cervantes
Version-Plugin: 1.0.0
Inicia-Activo: false
|
Ejemplo de archivo manifest.mf
NOTA: Recuerda que en la
práctica 2 vimos un ejemplo de cargado tardío en donde
nosotros pasabamos a la aplicación un nombre de clase como
argumento al momento de ejecución y eso permitia a la
aplicación cargar la clase. El atributo Clase-Plugin cumple
exactamente con el mismo propósito.
Clase principal
La clase principal del plugin es una clase que implementa la interfaz
Plugin que tiene los metodos siguientes:
public interface Plugin
{
/**
* El metodo inicializa le da al plugin un
contexto
* que le permite interactuar con la
aplicación
*
* @param ctxt El contexto
*/
public void inicializa(Contexto ctxt);
/**
* El metodo activa hace que las
funcionalidades del
* plug-in esten accesibles
*
*/
public void activa();
/**
* El metodo desactiva hace que las
funcionalidades del
* plug-in no esten accesibles
*
*/
public void desactiva();
} |
Ciclo de vida del plugin
Un plugin es inicializado una sola vez, pero puede ser activado y
desactivado multiples veces durante la ejecución.
- Incializa: Al
arrancar la aplicación, el metodo inicializa es llamado si el
plug-in está instalado. El contexto
que recibe el plug-in le permite interactuar con la aplicación,
por ejemplo para mostrar un mensaje o incluir un menu.
- activa: El metodo
activa es llamado si se pide que se active el plug-in o al principio si
el atributo Inicia-Activo tiene como valor true.
- desactiva: El
metodo desactiva es llamado si se pide que se desactive el plugin o
bien si la aplicación va a ser apagada.
A hacer:
El ejercicio de esta práctica consiste en hacer un plug-in
simple. Para ello debes efectuar los pasos siguientes:
- Crear un nuevo proyecto que tenga directorios src, lib, doc
y su build.xml
- En el directorio lib, incluir el archivo comun.jar
- Crear un package para la clase de implementación del
plugin
- Crear una clase que implemente la interfaz Plugin. En un
primer tiempo, la implementación puede sólo mostrar
trazas usando la instrucción System.out.println
- Crear un archivo manifest.mf que contenga los atributos
asociados a un plugin
- Modificar tu target package
para que, a parte de los binarios, se incluya el manifest y que a la
salida genere un JAR que será el plugin
- Lanzar el ejecutable de la arquitectura y probar que tu
plugin funciona (aparecen las trazas en la consola).
- Modificar el plugin para que muestre los mensajes dentro de
la ventana de la aplicación. Para ello, checar la clase Contexto
que recibe el plug-in, de ahi obtener una referencia hacia la interfaz
de usuario (ver la interface asociada) y utilizar sus métodos
- Intentar modificar el plugin para que incluya un menu en la
aplicación. Metodo agregaMenu de la interfaz de usuario.
A entregar: archivo .jar obtenido a partir del target
dist.
Síntesis:
En esta práctica hemos realizado:
- Checkout de svn
- Comprehensión de la arquitectura
- Creación de un plug-in
