Blog de Justo Aguilar

Pues sí, otro acrónimo más en el mundo Java, no sé por qué te extrañas. Y como ha pasado con muchos otros de su época, véase SOAP, el acrónimo ha pasado a ser el nombre oficial, nombre que en sus orígenes era Open Services Gateway initiative. Bueno, vamos al turrón.

Un módulo es un componente autocontenido dentro de un sistema mayor. ¿Autocontenido?, sí, que no necesita de referencias externas para su existencia y funcionamiento.

Bien, detrás de esta definición de módulo tan abstracta se esconden dos de los principios fundamentales de la programación : Alta Cohesión y Bajo Acoplamiento.

Todo módulo debe tener una responsabilidad y funcionalidad perfectamente delimitada dentro de un sistema mayor en el que se encuentre integrado (alta cohesión). Y debe evitar cualquier dependencia con el resto de módulos para realizar la tarea que tiene asignada (bajo acoplamiento). Evidentemente, siempre existirá un determinado grado de acoplamiento, que debe estar, en la medida de lo posible, articulado mediante conceptos abstractos, lo que en Java vienen a ser las interfaces.

Se podría decir que dentro de la plataforma Java la analogía de módulo sería un fichero JAR. Sin embargo, si conocemos el proceso mediante el cual es cargado un fichero jar en la JVM, podemos advertir una serie de carencias que invitan a pensar que la modularización en Java es una mera ilusión.

Actualmente, por defecto, una JVM tiene un único class loader (system class loader que es cargado por el bootstrap class loader escrito en código nativo) responsable de cargar en la JVM cualquier clase que se encuentre dentro del classpath de ejecución de una aplicación Java. Cuando existe un fichero jar en el classpath, se carga cada una de las clases que contenga ese JAR. Todo se carga en un espacio común, ahí, al montón.

Seguramente alguna vez habréis cargado el mismo jar dos o más veces, si es de la misma versión no pasa nada pero si usas distintas versiones puede que tengas un problema. Si tienes dependencias con diferentes versiones de un mismo JAR, que sepas que se cargará la clase del jar que aparezca primero en el classpath. Esto implica que no podamos usar diferentes versiones de una misma clase, al menos, con la aproximación que Java tiene por defecto, tendríamos que crear nuestro propio classloader para cargar una versión distinta de la misma clase.

[Extender este punto]

La Alianza OSGi empezó a definir allá por el año 1999 (diez añitos ya) una especificación que permitiera la construcción de aplicaciones modulares en Java.

La especificación OSGi propone una arquitectura montada sobre una JVM que permita la instalación, actualización y eliminación de módulos. Cada módulo podrá publicar las clases que serán visibles por otros módulos de la máquina virtual y podrá consumir cualquier clase que haya sido publicada por otros módulos de la VM. Entre los módulos cliente y proveedor existe un registro central, en el que los proveedores registran los servicios que desean hacer públicos al resto de módulos y los clientes solicitan los servicios que desean consumir. Evidentemente un módulo puede ser, a la vez, cliente y proveedor. Este paradigma es similar a la solución definida en SOA, por ello se dice que:

Dentro de la especificación OSGi, un módulo tiene el nombre de bundle. Un bundle OSGi es un fichero JAR con un conjunto de metadatos que especifican las características de bundle. Estos metadatos deben de incluidos dentro del fichero MANIFEST.MF, por tanto :

Un ejemplo de MANIFEST.MF adaptado para ser utilizado dentro de un entorno OSGi puede ser el siguiente :

Manifest-Version: 1.0
Export-Package: org.apache.commons.logging;version="1.1.1",org.apache.
 commons.logging.impl;version="1.1.1";uses:="javax.servlet,org.apache.
 avalon.framework.logger,org.apache.commons.logging,org.apache.log,org
 .apache.log4j"
Implementation-Title: Jakarta Commons Logging
Implementation-Version: 1.1.1
Bundle-Classpath: .
Built-By: dlg01
Specification-Vendor: Apache Software Foundation
Bundle-Name: Apache Commons Logging
Created-By: Apache Maven
X-Compile-Source-JDK: 1.2
Implementation-Vendor: Apache Software Foundation
Bundle-Vendor: SpringSource
Implementation-Vendor-Id: org.apache
Build-Jdk: 1.4.2_16
Bundle-Version: 1.1.1
Specification-Title: Jakarta Commons Logging
Bundle-ManifestVersion: 2
Import-Package: javax.servlet;version="[2.1.0, 3.0.0)";resolution:=opt
 ional,org.apache.avalon.framework.logger;version="[4.1.3, 4.1.3]";res
 olution:=optional,org.apache.log;version="[1.0.1, 1.0.1]";resolution:
 =optional,org.apache.log4j;version="[1.2.15, 2.0.0)";resolution:=opti
 onal
Bundle-SymbolicName: com.springsource.org.apache.commons.logging
Specification-Version: 1.0
Extension-Name: org.apache.commons.logging
Archiver-Version: Plexus Archiver
X-Compile-Target-JDK: 1.2

El código anterior correponde al fichero MANIFEST.MF contenido en el JAR de Apache Commons Logging 1.1.1 descargado del repositorio OSGi de SpringSource.

De todas las cabeceras (headers) que componen el fichero vamos a explicar las más significativas:

• Bundle-SymbolicName : Única cabecera obligatoria y que debe identificar unívocamente dentro de la VM al bundle.
• Bundle-Version: Versión del bundle. La dupla (Bundle-SymbolycName,BundleVersion) permite referenciar una versión de un bundle.
• Export-Package : Lista de paquetes que el bundle publica para que puedan ser consumidos por otros bundles dentro de la misma VM.
• Import-Package : Lista de paquetes que el bundle necesita consumir y que por tanto deben ser exportados por otros bundles.
• Bundle-Classpath : Lista de rutas donde se encuentran las clases del bundle

Como habréis notado, todas las referencias a paquetes van acompañadas de un rango de versiones, no es obligatorio pero si recomendable. Por ejemplo, este bundle consume, de manera opcional, el paquete javax.servlet desde la versión 2.1.0 en adelante y menor a la 3.0.0. Esto permite a un bundle importar paquetes de varias versiones de un bundle, lo que puede ser necesario en ocasiones cuando tengamos dependencias con sistemas antiguos y que tengan dependencias con versiones antiguas mientras que la parte nueva del desarrollo esté vinculada a las versiones más modernas.

Otra ventaja es la posibilidad publicar únicamente lo que quiero que sea público a otros bundles sin necesidad de utilizar modificadores de ámbito a nivel de código como private, protected o package.

Por último os dejo con la definición que Craig Walls hace en su libro, Modular Java.

OSGi is a component framework specification that brings modularity to
the Java platform. OSGi enables the creation of highly cohesive, loosely
coupled modules that can be composed into larger applications. What’s
more, each module can be individually developed, tested, deployed,
updated, and managed with minimal or no impact to the other modules.

Craig Walls,
Modular Java

Próximamente más.

Actualmente estoy trabajando en un proyecto en el que OSGi va a jugar un papel determinante. En próximos posts hablaré sobre OSGi, y sobre que papel juega dentro de las aplicaciones Java.

Cuando se habla de OSGi, se habla de programación modular donde un módulo es un fichero JAR (Java ARchive). En OSGi un módulo tiene el nombre de bundle.

Para poder entender este post se requieren conocimientos de :

• Maven 2
• Spring Framework
• Eclipse, Equinox
• OSGi
• Spring Dynamic Modules (Spring DM)

La prueba de concepto que vamos a describir a continuación, paso a paso, es la siguiente:

• Crear un bundle e instalarlo en Equinox.
• Asociar al bundle una clase BundleActivator para comprobar que el bundle ha sido inicializado correctamente.
• Instalar el bundle Extender de Spring DM y sus dependencias dentro de Equinox.
• Configurar el bundle para que arranque un ApplicationContext de Spring.

La idea de este post es mostrar de manera rápida el proceso de configuración, por ello no voy a explicar detalladamente el conjunto de herramientas y plugins utilizados a lo largo del proceso. Esto quedará pendiente para próximos posts.

Creamos un nuevo proyecto Java dentro de nuestro espacio de trabajo de Eclipse. En mi caso, es.jmac.springdm

Mavenizamos ese proyecto, yo he usado el plugin de Sonatype M2Eclipse, pero vamos puede hacerse a mano, basta crear un fichero pom.xml.

La información del fichero Maven de configuración del proyecto será la siguiente :

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

  <modelVersion>4.0.0</modelVersion>
  <groupId>es.jmac</groupId>
  <artifactId>springdm</artifactId>
  <packaging>jar</packaging>
  <name>springdm</name>
  <version>1.0.0-SNAPSHOT</version>
  <description>Prueba de concepto de Spring Dynamic Modules sobre Equinox</description>

</project>

Creamos una nueva source folder, src/main/java.

Al final del proceso, nuestro proyecto en Eclipse debería tener una estructura similar a la siguiente:

Estructura inicial del proyecto

Una vez que tenemos nuestro proyecto Java mavenizado vamos a incorporarle la información necesaria que lo identifique como un bundle OSGi.

Al inicio del post se ha comentado que un bundle OSGi es un fichero JAR. Sin embargo no basta con eso. Ese fichero JAR debe contener un información concreta que permita a la plataforma OSGi identificar ese fichero como un bundle OSGi. Esta información viene especificada en el fichero MANIFEST.MF. Esa será nuestra siguiente tarea generar ese fichero con la información necesaria para ser identificado como un bundle OSGi.

Bueno, ahora hay que generar el MANIFEST.MF. Hay varias formas de hacerlo, se puede hacer mano, si se conocen el conjunto de cabeceras OSGi o bien a través de alguna herramienta. En mi caso he utilizado un plugin para Maven que permite realizar varias operaciones sobre bundles OSGI, maven-bundle-plugin. Como he comentado anteriormente, no voy a explicar como funciona el plugin, os indico que hay que poner en el pom.xml y la orden que hay que lanzar.

Actualizar el pom.xml con el siguiente código :

...
<packaging>bundle</packaging>
...
<build>
  <plugins>
    <plugin>
      <groupId>org.apache.felix</groupId>
      <artifactId>maven-bundle-plugin</artifactId>
      <version>2.0.0</version>
      <extensions>true</extensions>
      <configuration>
        <instructions>
	  <Bundle-SymbolicName>${groupId}.${artifactId}</Bundle-SymbolicName>
	  <Bundle-Version>${pom.version}</Bundle-Version>
	</instructions>
      </configuration>
    </plugin>
  </plugins>
</build>
...

ATENCIÓN : No olvidéis cambiar el valor de elemento packaging a bundle.

Ejecutad por consola o a través de Eclipse, el siguiente comando Maven :

mvn clean package -Declipse.pde

Esta orden generará un fichero JAR con nuestro proyecto, que por ahora no tiene nada, y que contendrá un fichero MANIFEST.MF con las cabeceras necesarias para ser reconocido como un bundle OSGi. Lo que tenéis que hacer es iros a la carpeta target donde se ha copiado el fichero JAR y sacar de él fichero MANIFEST.MF para copiarlo a vuestro proyecto en Eclipse, ojo, dentro de la carpeta META-INF. Ya sé que no es muy sutil, pero es rápido.

...
<plugin>
  <groupId>org.apache.felix</groupId>
  <artifactId>maven-bundle-plugin</artifactId>
  <version>2.0.0</version>
  <extensions>true</extensions>
  <configuration>
    <manifestLocation>META-INF</manifestLocation>
    <instructions>
      <Bundle-SymbolicName>${groupId}.${artifactId}</Bundle-SymbolicName>
      <Bundle-Version>${pom.version}</Bundle-Version>
    </instructions>
  </configuration>
  <executions>
    <execution>
      <id>genera-manifest</id>
      <phase>generate-resources</phase>
      <goals>
        <goal>manifest</goal>
      </goals>
    </execution>
    <execution>
      <id>genera-bundle</id>
      <phase>package</phase>
      <goals>
        <goal>bundle</goal>
      </goals>
    </execution>
  </executions>
</plugin>
...

<manifestLocation />

Vuestro fichero MANIFEST.MF debería contener algo parecido a esto:

Manifest-Version: 1.0
Built-By: justo
Created-By: Apache Maven Bundle Plugin
Import-Package: es.jmac.springdm,org.osgi.framework;version="1.3"
Export-Package: es.jmac.springdm;uses:="org.osgi.framework"
Bundle-Version: 1.0.0.SNAPSHOT
Bundle-Name: springdm
Bundle-Description: Prueba de concepto de Spring Dynamic Modules sobre
 Equinox
Build-Jdk: 1.5.0_19
Private-Package: es.jmac.springdm,
Bundle-ManifestVersion: 2
Bundle-SymbolicName: es.jmac.springdm
Tool: Bnd-0.0.311

Ya hemos creado un bundle OSGi, ahora vamos a ver si lo hemos creado correctamente. Para ello, vamos a lanzar una instancia de Equinox y especificaremos que dentro de esa instancia se cargue nuestro bundle recien creado.

Nos vamos al menún Run –> Run Configurations… de Eclipse

Run Configurations...

Selecciónamos OSGi Framework y pulsando el botón derecho seleccionamos New…

New OSGi Framework

En la parte derecha de la ventana aparecerán la lista de bundles que tenemos actualmente, dividos en dos grupos, los bundles creados en nuestro workspace y los bundles instalados en la Target Platform, que suele ser $ECLIPSE_HOME/plugins.

Lista de Bundles

Los siguientes pasos serán seleccionar nuestro bundle, deseleccionar todos los bundles de la sección Target Platform y pichar sobre el botón Add Required Bundles, es nos marcará un único bundle el core de OSGi, org.eclipse.osgi. Pinchamos en Apply para salvar los cambios y pichamos en Run.

A continuación se debe abrir la ventana de Console en la que aparecerá el shell de OSGi, algo como :
osgi>
Para comprobar si nuestro bundle ha sido inicializado correctamente, introducimos el comando ss y pulsamos intro. Debería aparecer lo siguiente, si no, algo hemos mal :

Short Status (ss)

Acabamos de ejecutar nuestro bundle dentro de Equinox. Tampoco tiene mucho mérito porque es un bundle vacío, pero bueno, vamos poco a poco.

Una clase activator se encarga de inicializar/liberar un bundle. Esta pequeña clase nos avisará que el bundle ha sido inicializado/parado correctamente.

La clase debe implementar la interfaz BundleActivator definida en la API de OSGi. Para que nuestro código compile correctamente será necesario añadir un par de dependencias a nuestro pom.xml. Basta con añadir el siguiente fragmento de código:

<dependencies>
  ...
  <dependency>
    <groupId>org.osgi</groupId>
    <artifactId>osgi_R4_core</artifactId>
    <version>1.0</version>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>org.osgi</groupId>
    <artifactId>osgi_R4_compendium</artifactId>
    <version>1.0</version>
    <scope>provided</scope>
  </dependency>
...
</dependencies>

El código de la clase SpringDMActivator es el siguiente:

package es.jmac.springdm;

import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;

/**
 * @author Justo Aguilar
 * Creation date : 20/07/2009
 *
 * <p>
 */
public class SpringDMActivator implements BundleActivator {

	public void start(BundleContext context) throws Exception {
		System.out.println("Arrancando bundle " + context.getBundle().getSymbolicName() + "...");
	}

	public void stop(BundleContext context) throws Exception {
		System.out.println("Parando bundle " + context.getBundle().getSymbolicName() + "...");
	}
}

Un último paso necesario es añadir al fichero MANIFEST.MF la siguiente línea:

Bundle-Activator: es.jmac.springdm.SpringDMActivator

con la ruta de nuestro clase BundleActivator.

La próxima vez que arranquemos la instancia del OSGi Framework creada anteriormente debería aparecer el mensaje definido por el método start de la clase SpringDMActivator.

4. Spring DM entra en juego

En este post se hace un uso trivial e insignificante de Spring DM. En próximos post se mostrará la verdadera potencia de integrar Spring Framework con OSGi.

Nuestro objetivo en este último paso es inicializar un ApplicationContext de Spring al iniciar un bundle en OSGi.

Lo primero que haremos será crear un POJO para referenciarlo posteriormente en el fichero applicationContext.xml de Spring. Yo he creado una clase Entity :

package es.jmac.springdm.domain;

import java.io.Serializable;

/**
 * @author Justo Aguilar
 * Creation date : 20/07/2009
 *
 */
public class Entity implements Serializable {

	/** Identificador de Serialización  */
	private static final long serialVersionUID = 147003001012587224L;

	/** Identificador de la entidad */
	private Long id;

	/** Nombre de la entidad */
	private String name;

	/**
	 * Constructor de Entity. Necesita el identificador.
	 * @param id Identificador de la entidad.
	 */
	public Entity(Long id) {
		this.id = id;
		System.out.println("Creando entidad con id : " + id);
	}

}

A continuación hay que crear y definir el fichero applicationContext.xml de Spring. Este fichero se situará dentro de una carpeta spring que a su vez debe estar contenida en la carpeta META-INF del proyecto.

Proyecto
|__META-INF
    |__spring
        |__applicationContext.xml

Este fichero contendrá la siguiente información :

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans   

http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="entity" class="es.jmac.springdm.domain.Entity">
      <constructor-arg><value>1</value></constructor-arg>
    </bean>
</beans>

Ahora es cuando entra en juego Spring DM. Evidentemente, por si solo, Equinox no tiene ni idea para que sirve la carpeta spring creada bajo META-INF ni los ficheros contiene ésta, por tanto si volvemos a arrancar Equinox veremos que no sucede nada nuevo. Para dar un tratamiento especial a este tipo de bundles, Spring-Powered bundle según la documentación de Spring DM, es necesario que alguién esté pendiente de cuando se inicializa o se para este tipo de bundles. Ese alguien es conocido como Extender. Extender no es más que un bundle que está a la escucha del ciclo de vida del restos de bundles, cuando un bundle se inicializa o se para, comprueba si se trata de un Spring-Powered bundle para realizar la tarea de inicialiar/parar el ApplicationContext asociado al éste.

Por tanto será necesario instalar el bundle Extender y todos sus dependencias dentro de la Target Platform y marcarlos para que se ejecuten dentro de Equinox. Bueno, vamos por pasos.

Primero, nos descargamos todos los bundles que necesitamos. Para ello acudimos al repositorio de springsource, http://www.springsource.com/repository/app/ y nos descargamos el jar org.springframework.osgi.extender, en mi caso la versión 1.2.0. En la parte inferior de esa ventana aparece una sección plegada que dice Required Dependencies (9), la desplegamos y nos bajamos cada uno de los bundles que ahí se indican.

Dependencias Bundle Extender de Spring DM

Segundo, copiamos los JARs descargados al directorio de nuestra Target Platform, si no sabes a lo que me refiero, no lo habrás cambiado asi que el directorio es $INSTALACION_ECLIPSE/plugins. Reiniciamos Eclipse.

Tercero, abrimos la ventana Run Configurations… y comprobamos que entre los bundles de la sección Target Platform se encuentran los que acabamos de copiar. Marcamos el bundle de Extender y volvemos a pinchar en Add Required Bundles, veremos como se seleccionan el resto de bundles copiados en el paso anterior. Aplicamos y ejecutamos.

Si no os aparece el mensaje definido en el constructor del POJO, algo habréis hecho mal.

Enlaces relacionados:

• ¿Qué es OSGi … y para qué sirve?
• OSGi Foundation
• Spring Dynamic Modules
• Equinox
• Apache Maven
• Spring Framework
• Eclipse
• maven-bundle-plugin
• Apache Felix
• BND
• Pax