Apache Chemistry

Apache Chemistry Provee una implementación Open Source de Content Management Interoperability Services (CMIS) Pero que es CMIS? Bueno CMIS es una especificación de OASIS, para mejorar la interoperabilidad de los sistemas Enterprise Content Management (ECM)

CMIS es un conjunto de Web Services pensados para compartir información entre repositorios de contenidos y que buscan la interoperabilidad de los diferentes sistemas ECM.

CMIS está compuesto de los siguientes elementos:

• Un modelo de dominio, para definir los objetos y relaciones que pueden existir en el repositorio.
• Un conjunto de APIs de comunicación, Web Services y REST, que permiten a las aplicaciones conectarse, navegar, leer y crear contenidos en los diferentes repositorios.
• Un lenguaje de consultas, similar a SQL, capaz de definir criterios de búsqueda sobre propiedades, ubicación o "full-text" de los objetos.

Apache Chemistry consiste en los siguientes proyectos:

• OpenCMIS: CMIS librerias cliente y servidor para Java
• cmislib: CMIS librerias cliente y servidor para Python
• phpclient: CMIS librerias cliente y servidor para PHP
• DotCMIS: CMIS librerias cliente y servidor para .NET

Y Obviamente con Licencia Apache.

Dejo links:

http://chemistry.apache.org/

http://chemistry.apache.org/project/community.html

Maven!!!

Este post es para repasar un poco los aspectos de apache mave...

Maven es un framework de gestión de proyectos Java, basado en POM (Project Object Model), que nos proporciona funcionalidades desde la compilación hasta la distribución, despliegue y documentación de los proyectos.

Maven se basa en patrones y en estándares. Esto permite a los desarrolladores moverse entre proyectos sin la necesidad de aprender como compilar o empaquetar, mejorando de esta forma, el mantenimiento y la reusabilidad.

Que provee maven??

• Características generales de Maven

  • Convención sobre configuración

    • Si todos estamos de acuerdo en ciertas cosas ¿Para qué configurarlas? Démoslas por hechas y mantengamos la opción de configuración por si fuera necesario

  • Uso de buenas prácticas

    • Por ejemplo ejecutar los test unitarios antes de hacer un deploy o instalación

  • Un ciclo de vida extensible declarativamente basado en fases y goals

    • Facilita automatizar tareas sencillas o todo el proceso de construcción de forma rápida y simple, una única orden

  • Un modelo centralizado y transparente de gestión de dependencias

    • Se acabó el “Jar Hell”, el buscar jars por internet y las dependencias de estos jars, o casi del todo…

El principal objetivo de maven es permitir a un desarrollador comprender el estado completo del esfuerzo del desarrollo en el período más corto de tiempo. Para lograr este objetivo existen distintas áreas de las que maven se ocupa:

• Hacer el proceso de construcción sencillo.

• Proporcionar un sistema de construcción uniforme

• Proporcionar información de la calidad del proyecto.

• Proporcionar lineamientos a seguir para el desarrollo de las mejores prácticas.

• Permitir migraciones transparentes a nuevas características.

Maven utiliza el término artifact para denominar a la unidad mínima que maneja en su repositorio. Puede ser por ejemplo un jar, un ear, un zip, etc. Cuando Maven compila y empaqueta código, produce también artifacts que instala en el repositorio.

Los artifacts están agrupados bajo el id de grupo (groupId) y tienen un id propio (artifactId), una versión, un clasificador y una extensión.

Maven está basado en torno al concepto de ciclo de vida de build (build lifecycle). Esto significa que el proceso para construir y distribuir cualquier artifact (proyecto) está claramente definido.

Para la persona que construye un proyecto, esto significa que solo debe aprender un número pequeño de comandos para construir cualquier proyecto Maven.

Existen tres ciclos de vida built-in con Maven: default, clean y site.

Default	Administra hasta el proceso de deployment
Clean	Administra las tareas de reseteo del build anterior
Site	Administra la creación del sitio de publicación del proyecto

Cada uno de los ciclos de vida está definido por una lista de fases, donde cada fase representa una etapa en el ciclo de vida.

Este ciclo de vida define la secuencia de fases que va desde validar la integridad hasta el despliegue (deploy).

Cuando se solicita la ejecución de una fase Maven ejecuta primero todas las fases anteriores siguiendo la secuencia y termina en la fase solicitada.

Las principales fases del ciclo de vida default de maven son:

validate	Valida si el proyecto es correcto y si tiene toda la información necesaria
compile	Compila el código fuente del proyecto
test	Corre los test utilizando el framework de unit test disponible
package	Toma las clases compiladas y recursos y crea un paquete (jar, war, ear).
integration-test	Procesa y despliega el paquete, para que corran las pruebas de integración.
verify	Ejecuta los chequeos necesarios para verificar que el paquete cumple los criterios de calidad.
install	Instala el paquete en el repositorio local para ser usado como dependencia por otros proyectos localmente
deploy	Copia el paquete a un repositorio remoto para ser compartido con otros usuarios y proyectos.

Las fases del cilo de vida clean:

pre-clean	Ejecuta los procesos necesarios, previos al clean
clean	Remueve todos los archivos generados en un build previo
post-clean	Ejecuta los procesos necesarios para finalizar el clean

Las fases del ciclo de vida site:

pre-site	Ejecuta los procesos necesarios, previos a la generación del site
site	Genera el site con la documentación del proyecto
post-site	Ejecuta los procesos necesarios para finalizar la creación del site
site-deploy	Realiza un deploy del site de documentación, en el web Server especificado.

Tener en cuenta que para el deploy del site, debemos configurar el web Server.

website
scp://www.mycompany.com/www/docs/project/

Bueno hasta aquí un maven, repaso general.

RichFaces

RichFaces es un framework web que combina las tecnologías Ajax con JSF. Lo cual permite hacer aplicaciones web con ajax de forma fácil sin preocuparse por mantener complicados métodos javascripts.
RichFaces es un proyecto open sources que permite agregar capacidades Ajax a su aplicación JSF sin escribir javascript por lo tanto sin preocuparse por la compatibilidad entre distintos browsers.

RichFaces provee 2 conjuntos de librerías:

• Core Ajax: Contiene componentes que son útiles para “ajaxiar” las paginas jsf y los componentes estándares de JSF. También provee componentes que generan recursos binarios como imágenes, pdfs, cvs, etc.
• UI: Es un conjunto avanzado de etiquetas Jsf que utilizan Ajax usados para agregar características de una interfaz rica de usuario en su aplicación. Estos componentes soportan Ajax y están perfectamente integrados a la librería Core. Además soportan skills y pueden ser totalmente adaptados a sus necesidades.

Otra característica de RichFace es Component Development Kit (CDK) el conjunto de herramientas usado para crear la libraría UI, y puede ser utilizado para crear nuevos componentes.

Este post explica solo un poco de RichFaces, en futuros post veremos como hacer una aplicación con este framework.

PHP for Android project (PFA)

PHP for Android project (PFA) es una plataforma que nos permite programar en PHP sobre Android. Y además nos provee de la documentación y herramientas

Además esta bajo Licencia Apache!!

Dejo links:

http://www.phpforandroid.net/manual/en/index
http://www.phpforandroid.net/
http://code.google.com/p/android-scripting/wiki/ApiReference

Erjang

Erjang no es otra cosa que una mv escrita para correr erlang sobre la plataforma java.

Como trabaja esto? Lo que permite erjang es pasar un .beam a un .class lo que permite que este corra en la jvm. Además también tiene una consola interactiva.

Este proyecto esta en pañales pero le veo mucho futuro.

Dejo links:
http://groups.google.com/group/erjang
https://github.com/trifork/erjang/wiki

JBoss Seam

JBoss Seam es un framework que integra y unifica los distintos standars de la plataforma Java EE 5.0, pudiendo trabajar con todos ellos siguiendo el mismo modelo de programación.
Ha sido diseñado intentado simplificar al máximo el desarrollo de aplicaciones, basando el diseño en Plain Old Java Objects (POJOs) con anotaciones. Estos componentes se usan desde la capa de persistencia hasta la de presentación, poniendo todas las capas en comunicación directa.

El núcleo principal de Seam está formado por las especificaciones Enterprise JavaBeans 3 (EJB3) y JavaServer Faces (JSF).
A grandes rasgos podemos definir EJB3 como una arquitectura para un sistema transaccional (como bases de datos) de objetos distribuidos basado en componentes que permite construir aplicaciones portables, reusables y escalables.
JSF es un framework de la capa de presentación que define componentes para el interfaz gráfico y "managed beans" para la lógica de la aplicación que interactúan a travé de un sistema de eventos.

Sin embargo, estos frameworks tienen algunas limitaciones y no han sido concebidos para trabajar juntos (esto pretende resolverse con la futura especificación web beans ); tienen distinto tipo de configuraciones (JSF usa archivos XML mientras que EJB3 usa anotaciones), distinto ciclo de vida y no pueden comunicarse directamente a nivel de framework.
Para hacerlos cooperar necesitaríamos escribir "clases fachada" y multitud de código de relleno que se encargase de pasar las llamadas de una capa de la aplicación a otra. Ahí es donde entra en juego Seam.
Seam elimina la barrera existente entre estas tecnologías, permitiendo usar EJBs directamente como "backing beans" de JSF y lanzar o escuchar eventos web.

El maldito libro de los descarrilados

Publico un tutorial de Ruby on Rails en castellano.

http://yottabi.com/mld.pdf

Saludos

El conocimiento cuando es compartido crece, va mejorando y se diversifica

Algunas veces me preguntan ¿porque el blog? , ¿que gano escribiendo esto? Y es difícil, muy difícil explicar en especial a gente que piensa “costo-beneficio” que el blog es solo compartir. Nunca gane ni un peso ni reconocimiento, ni nada y no es necesario ganar algo de esto para seguir.

Yo como muchos de ustedes usa framework open sources, o lee blog de otras personas. Y pienso que este blog es devolver un poco todo lo que recibo gratuitamente y solo porque gente quiere compartir su conocimiento.

Al compartir el conocimiento, leer un articulo y querer compartirlo, buscar que la gente se interese por la tecnología o lo que sea, crea una pequeña responsabilidad a mejorar, escribir cada vez mejor. Y a la vez cada vez que uno escribe fija mejor el conocimiento y aprende más, por mantener el blog se “obliga” a leer alga nuevo. Comparte su entusiasmo y siente que es un poco útil a la comunidad.

El conocimiento cuando es compartido crece, va mejorando y se diversifica; un ejemplo claro es Linux. En este pequeño post quiero aconsejarlos a que sean valientes escriban un blog, inicien un proyecto open source o participen en una comunidad. Y de paso agradezco que me lean, opinen, pidan nuevos post; esto es sumamente gratificante y ayuda a seguir escribiendo.

ActiveMQ con Spring

Vamos a crear dos aplicaciones con spring y maven. Una para publicar mensajes asincronos en ActiveMQ y un cliente para leerlo. Creamos 2 proyecto para que sea notoria la separación de cliente-servidor.

Primero creemos los proyectos con maven:

mvn archetype:create -DgroupId=org.assembly -DartifactId=creadorDeMensajes

mvn archetype:create -DgroupId=org.assembly -DartifactId=lectorDeMensajes

Ahora editemos los pom's para utilizar spring:

pom.xml de creadorDeMensajes:

4.0.0



org.assembly



creadorDeMensajes



1.0-SNAPSHOT



jar



creadorDeMensajes



http://maven.apache.org





 UTF-8











   org.springframework

    spring

   2.5.6.SEC02

 





 org.apache.activemq

  activemq-all

  5.4.2

pom.xml de LectorDeMensajes:

4.0.0



org.assembly



lectorDeMensajes



1.0-SNAPSHOT



jar



lectorDeMensajes



http://maven.apache.org





 UTF-8









  

   org.springframework

    spring

   2.5.6.SEC02

 





 org.apache.activemq

  activemq-all

  5.4.2

Importante que borren los test porque no tenemos la dependencia con jUnit vayan a la carpeta:
creadorDeMensajes/src/test/java/org/assembly y lectorDeMensajes/src/test/java/org/assembly y borren AppTest.java

Corremos:
mvn clean install
mvn eclipse:eclipse

para los dos proyectos, es decir entramos en la carpeta: creadorDeMensajes y corremos los comandos y luego hacemos lo mismo para lectorDeMensajes. Lo cual nos bajara los jars necesarios.

Creador De Mensajes
Antes que nada es recomendable utilizar una ide yo estoy usando eclipse. Para importar los proyectos a eclipse vea el siguiente link:

http://united-coders.com/phillip-steffensen/maven-2-part-3-configuring-eclipse-for-apache-maven-2-projects

Vamos a centrarnos en este proyecto, que va a crear los mensajes para luego ser leídos por el lector.
En el la carpeta creadorDeMensajes/src/main/resources (si no existe la crean) vamos a generar el archivo xml para configurar los beans que vamos a utilizar para enviar mensajes. Creamos el archivo spring-context.xml con el siguiente contenido:

El primer bean que definimos es la fabrica de conecciones a ActiveMQ, como piedad definimos la URL del corredor de mensajes. EL segundo bean es el destino que como parametro se pasa un nombre de destino. El terser bean es el objeto Template que nos hace la vida más facil a la hora de programar con ActiveMQ es una clase de spring y se configura la fabrica de conección. El cuarto bean es nuestra clase que envia mensajes.

Necesitamos una interfaz que describa el servicio, la llamamos EnviadorDeMensajes.java :

package org.assembly;



/**

* @author emanuel

*

*/

public interface EnviadorDeMensajes {



void enviarUnMensaje();



}

Luego programamos la implementación EnviadorDeMensajesImpl.java:

package org.assembly;



import javax.jms.Destination;

import javax.jms.JMSException;

import javax.jms.MapMessage;

import javax.jms.Message;

import javax.jms.Session;



import org.springframework.jms.core.JmsTemplate;

import org.springframework.jms.core.MessageCreator;



/**

* @author emanuel

*

*/

public class EnviadorDeMensajesImpl implements EnviadorDeMensajes {



private static final String MENSAJE = "Hoy te escribo una carta mi pequeña Maria, " +

                               "yo que tanto te quiero y que todos los días me acuerdo de ti, " +

                               "yo me acuerdo de ti.";



private JmsTemplate jmsTemplate = null;



// usado por spring para inyectar el jms template.

public void setJmsTemplate(JmsTemplate jmsTemplate) {

this.jmsTemplate = jmsTemplate;

}





private Destination destino = null;



// usado por spring para inyectar el destino.

public void setDestino(Destination destino) {

this.destino = destino;

}





/**

* @see org.assembly.EnviadorDeMensajes#enviarUnMensaje()

*/

@Override

public void enviarUnMensaje() {

jmsTemplate.send(

  this.destino,

  new MessageCreator() {



    @Override

    public Message createMessage(Session session) throws JMSException {

     MapMessage mensaje = session.createMapMessage();

   

     mensaje.setString("mensaje", MENSAJE);

   

     return mensaje;

    }

   }

  );

}



}

La Clase envía el mensaje gracias a JmsTemplate.

Y ahora programamos la aplicación llamada AppCreador.java :

package org.assembly;



import org.springframework.beans.factory.BeanFactory;

import org.springframework.beans.factory.xml.XmlBeanFactory;

import org.springframework.core.io.FileSystemResource;





public class AppCreador

{

 public static void main( String[] args )

 {

  BeanFactory fabricaDeBeans = new XmlBeanFactory(new FileSystemResource("src/main/resources/spring-context.xml"));



  EnviadorDeMensajes enviador = (EnviadorDeMensajes) fabricaDeBeans.getBean("miEnviadorDeMensajes");



  enviador.enviarUnMensaje();

 }

}

Utilizamos a spring como fabrica de beans y le pedimos que cree el enviador; luego con el enviamos un mensaje.

Para probar esto hay que subir activeMQ, para subirlo hay que hacer:
activemq console (en sistemas Unix-Like)
activemq (en Windows)
Luego podemos ejecutar el AppCreador.

Lector De Mensajes
El lector es similar al enviador, veamos el spring-context.xml:

Ahora configuramos el destino como default en jmsTemplate para no pasarlo al lector y de esta forma es más ágil.
Necesitamos una interfaz para el lector:

package org.assembly;



import javax.jms.JMSException;



public interface LectorDeMensajes {



String leer() throws JMSException;



}

Y la implementación:

package org.assembly;



import javax.jms.Destination;

import javax.jms.JMSException;

import javax.jms.MapMessage;

import javax.jms.Message;

import javax.jms.Session;



import org.springframework.jms.core.JmsTemplate;

import org.springframework.jms.core.MessageCreator;



/**

* @author emanuel

*

*/

public class LectorDeMensajesImpl implements LectorDeMensajes {



private JmsTemplate jmsTemplate = null;



// usado por spring para inyectar el jms template.

public void setJmsTemplate(JmsTemplate jmsTemplate) {

this.jmsTemplate = jmsTemplate;

}





/**

* @throws JMSException

* @see org.assembly.EnviadorDeMensajes#enviarUnMensaje()

*/

@Override

public String leer() throws JMSException {

MapMessage mensaje = (MapMessage) jmsTemplate.receive();

return mensaje.getString("mensaje");

}





}

Ahora creamos la aplicación lectora:

package org.assembly;



import javax.jms.JMSException;



import org.sprin

gframework.beans.factory.BeanFactory;

import org.springframework.beans.factory.xml.XmlBeanFactory;

import org.springframework.core.io.FileSystemResource;



/**

* Hello world!

*

*/

public class AppLector

{

 public static void main( String[] args ) throws JMSException

 {

  BeanFactory fabricaDeBeans = new XmlBeanFactory(new FileSystemResource("src/main/resources/spring-context.xml"));



  LectorDeMensajes lectorDeMensajes = (LectorDeMensajes) fabricaDeBeans.getBean("miLectorDeMensajes");

  System.out.println(lectorDeMensajes.leer());

 }

}

Si ejecutamos esta aplicación devolvera el mensaje enviado por el creadorDeMensajes.
Este es un pequeño ejemplo del uso de Apache Active con spring espero que les sirva.

Facelets framework.

¿Que es Facelets?
Cuando JSF fue ideado, la intención fue reutilizar JSP como principal tecnología para la creación de paginas web, dado que es un estándar en la comunidad web.
La idea fue hacer natural la adopción de JSF por medio de etiquetas naturales que ya tienen una adopción el el mundo java.

Desafortunadamente JSP y JSF no se complementan entre si. JSP se usa para crear paginas web dinámicas pero no para crear arboles de componentes. En JSP los elementos son procesados desde el principio de la pagina hasta el final. JSF, sin embargo, tiene un ciclo de vida mucho más complejo, generación de componentes, y una generación separada en faces claras.

Si se mezcla JSP con JSF, el JSF se renderizara a medida que se vaya encontrando, en cambio los componentes JSF tiene cada uno su propio renderizado. Esto puede traer ciertos problemas.

Facelets llena el gap entre JSP y JSF. Esta centrado en la creación de arboles de componentes y el entrelazamiento de contenido con el complejo ciclo de vida de JSF. Facelets remplaza a JSP con una muy simple API que es el reflejo de principios simples y esto incorpora numerosas características que facilitan el desarrollo.

¿Porque utilizar Facelets?
Hay muchas razones por las que usar Facelts antes que JSP para el desarrollo de JSF:

• No depende del contenedor, Facelts puede trabajar con cualquier implementación y versión de JSF.
• La interacción entre JSP y JSF puede traer problemas.
• Facelets provee templates, que pueden ser reutilizados
• Su simpleza maximiza la reutilización, es extensible y escalable.
• Facets soporta EL (Unified Expression Language)
• Facets no requiere ninguna librería especial para el renderizado.

Descargar Facelets.
Facelets se puede descargar de la siguiente URL: http://facelets.dev.java.net/
El jar que se necesita para trabajar con Facelets es jsf- facelets.jar y las dependencias puede ser buscadas en el directorio lib.

Si usan maven la dependencia es:

 com.sun.facelets

 jsf-facelets

 1.1.6

Configuración
Para configurar un proyecto web para que use Facelets en necesario configurar el Web Descriptor (web.xml) agregando lo siguiente:

..............





 javax.faces.DEFAULT_SUFFIX

 .xhtml

De esta forma indicamos que nuestras paginas van a finalizar con el subfijo xhtml.
Además como cualquier proyecto JSF hay que agregar el servlet y el servlet-mapping

 Faces Servlet

 javax.faces.webapp.FacesServlet

 1





 Faces Servlet

 /faces/*

Además es necesario crear un archivo Configuración de Faces Descriptor (faces-config.xml) como cualquier proyecto JSF, donde es necesario remplazar el ViewHandler traido por defecto por:
com.sun.facelets.FaceletViewHandler de la siguiente manera:

 

   com.sun.facelets.FaceletViewHandler

 

En faces-config.xml también se define las reglas de navegación.

 

     home

     /index.xhtml

 





 

     parrot

     /parrot.xhtml

 





 

     eagle

     /eagle.xhtml

 

Como se puede ver se define cada uno de los links a que htmlx debe ir.


Tags
Es necesario que las paginas Facelets sean un XML valido, cuando se utiliza una librería es necesario que se declare como un namespace, donde podemos mapear la URI a un prefijo como se puede apreciar en el siguiente ejemplo:

En el ejemplo usamos 3 librerías, una XML sin prefijo, otra para Facetlet tag con el prefijo ui y otra básica de JSF con el prefijo h.
En la siguiente tabla se puede ver los namespace más comunes:

NAMESPACE	PREFIX LIBRARY	XHTML
http://www.w3.org/1999/xhtml	--	Facelets Templating
http://java.sun.com/jsf/facelets	ui	JSF Core
http://java.sun.com/jsf/core	f	JSF HTML
http://java.sun.com/jsf/html	h	MyFaces Tomahawk
http://myfaces.apache.org/tomahawk	t	MyFaces Tomahawk
http://myfaces.apache.org/sandbox	s	Sandbox
http://myfaces.apache.org/trinidad	tr	MyFaces Trinidad
http://java.sun.com/jstl/core	c	JSTL Core
http://java.sun.com/jsp/jstl/fmt	fn	JSTL Functions

Si se agrega un componente pero no se agrega el espacio de nombre correspondiente para el componente, habrá un error en el momento de compilación de la pagina.

Carga de las librerías de Tags
Facelets usa la siguiente estrategia para cargar las librerías de etiquetas. Primero, busca las librerías en la carpeta /META-INF dentro de los jars. Intenta cargar los archivos que tienen la siguiente forma *.taglib.xml. De esta forma se cargan librería de etiquetas estándares.
Luego, facelets chequea las librerías definidas en web.xml, inicializado como parámetros facelets.LIBRARIES. Esta estrategia es ideal para cuando se desea cargar una librería de etiquetas propia.

Varias librerías de etiquetas ya son incluidas en el jar de facelets:

• Templating library: Contiene las etiquetas para la creación de plantillas.
• JSF libraries: Dos librerías de etiquetas las cuales son incluidas por la especificación de JSF, son librerías incluidas por defecto por Facelets.
• JSTL: Facelets provee soporte parcial a etiquetas de JavaServer Pages Standard Tag
• Library (JSTL). Mientras la librería Function es totalmente soportada, La Core es parcialmente soportada, las etiquetas soportadas son: c:if, c:forEach, c:catch y c:set.

Otras Librerías
Para incluir otra librería de etiquetas se debe agregar la misma en la carpeta /META-INF y además se debe incluir el import del Taglib dentro de la aplicación.

Creación de plantillas
En las plantillas nosotros definimos básicamente el layout de la pagina, y los estilos. Con la etiqueta ui:insert podemos definir las áreas en la pagina que pueden ser sobreescritas, por las paginas que usan la plantilla (clientes). Para usar esta etiqueta es necesario el espacio de nombre: http://java.sun.com/jsf/facelets
El cliente usa este template con los tags ui:component, ui:composition, ui:fragment, o ui:decorate. Veamos un ejemplo de plantilla:

 

 





 

     
The Happy Birds Directory

     


         

     

     

         Welcome to the nest!

     

 

La pagina que utilice esta plantilla sera algo así:

 

     

         Hola Mundo!!

     

 

Es usada la etiquete ui:composition para referenciar la plantilla utilizada. La etiqueta ui:define es utilizada para indicar a Facelts cual area se va a redefinir.
Las plantillas no están limitadas a un nivel, es posible tener varios niveles de plantillas, de este modo un cliente para un template puede ser un template para otro cliente.

Tutorial básico de Java EE

En javahispano publicaron un tutorial de Java EE. Muy buena oportunidad para aprender, dejo el link:

http://www.javahispano.org/contenidos/es/tutorial_basico_de_java_ee__por_abraham_otero/?menuId=jH

Saludos!!

WOA (Web-oriented architecture)

Web-oriented architecture (WOA), como SOA, tiene varias definiciones. Algunos ven a WOA como un estilo arquitectonico y un subestilo de SOA basado en aplicaciones web, más liviano que SOA. Otra definición es el uso de REST para construir servicios web usando tecnología web como HTTP y documentos XML.

Si buscamos una definición rapida podemos decir que :

SOA + Web 2.0 = WOA

El uso de REST y la separación de la interfaz (concebida de forma web pero que consulta los servicios por javascript expuestos mediante REST) dio nacimiento a este estilo arquitectónico.

Este enfoque mucho más orientado a la Web es algo que muchos han llamado Web-Oriented Architecture (WOA) y se basa en la enorme fuerza de tracción de la World Wide Web en sí y sus fundamentos arquitectónicos subyacentes. Y se basa en los conceptos básicos y los resultados que han hecho de la Web con mucho, la mayor red abierta en el planeta, así como el mayor SOA actualmente en existencia. En el extremo principal de esto es la historia de mashups de web con aplicaciones híbridas empresariales es una de las importantes mejoras en el entorno de TI que se anuncia la WOA.

Más de Apache ActiveMQ

Siguiendo con la serie de post de Apache ActiveMQ en el post anterior hablamos de JMS. Ahora
empecemos con ActiveMQ. Como ya dijimos Apache ActiveMQ es un estupendo corredor de mensajes de código abierto y una maravillosa opción para mensajería asíncrona JMS. ActiveMQ comenzó siendo un proyecto de codehaus pero luego se traslado a Apache.

Antes de empezar es conveniente que se bajen el proyecto desde el siguiente link:
http://activemq.apache.org/download.html

Luego de bajar ActiveMQ, debe descomprimirlo. En el directorio base se van a encontrar un jar llamado activemq-all-version.jar donde versión es la versión del producto que descargo por ejemplo activemq-all-5.4.2 es para la versión 5.4.2. Éste jar es el que necesitara para añadir a la ruta de clase de la aplicación para poder utilizar la API de ActiveMQ

En el directorio bin, podrá encontrar un script llamado activemq el cual inicia ActiveMQ de la siguiente manera:

activemq console (en sistemas Unix-Like)
activemq (en Windows)

Si todo salio bien el servidor estará levantado en http://localhost:8161/.De esta forma ActiveMQ esta listo para recibir nuestros mensajes.

Veamos un poco la estructura de directorios de ActiveMQ, si vemos la carpeta base podremos identificar los siguientes archivos:

• README.txt, NOTICE y LICENSE: Documentación, información de licencias y la licencia del producto.
• WebConsole-README.txt: Contiene información del uso de la consola web.
• activemq-all-5.3.0.jar: Jar que contiene todas las clases necesarias para utilizar Apache ActiveMQ
• bin: directorio que contiene archivos binarios y ejecutables; además scripts para detener, iniciar y restablecer el servidor.
• conf: directorio que contiene todos los archivos necesarios para configurar Apache ActiveMQ
• data: es el directorio donde los archivos de log y archivos de datos son guardados.
• docs: contiene un archivo index.html que hace referencia a la documentación.
• example: contiene ejemplos.
• lib: contiene las librerías que necesita Apache ActiveMQ para funcionar.
• user-guide.html: documentación necesaria para empezar con ActiveMQ y además como correr un ejemplo.
• webapps: directorio necesario para que funcione Apache ActiveMQ web Consola y otros demos web relacionados.

Esto fue una pequeña introducción a Apache ActiveMQ, más adelante veremos como utilizarlo.

Apache ActiveMQ

Antes de empezar a leer este post miren este otro que sirve de introducción:

http://emanuelpeg.blogspot.com/2010/03/apache-activemq.html

Bueno, antes de empezar con ActiveMQ es necesario entender algunos conceptos de JMS.

Cuando necesitamos comunicar 2 aplicaciones por medio de una red, se hace prioritario que las dos aplicaciones estén disponibles, por ejemplo cuando una aplicación se comunica con otra por medio llamados a procedimientos remotos (COM, CORBA, DCE y EJB) la aplicación receptora del mensaje debe estar activa, si esto no es así no recibirá nunca el mensaje. En ocasiones es poco probable poder realizar una comunicación sincrónica. La mensajería asíncrona es una forma de enviar mensajes indirectamente de una aplicación a otra sin esperar una respuesta.

JMS ofrece a las aplicaciones Java la opción de comunicarse de forma asíncrona. Cuando los mensajes se envían de forma asíncrona, el cliente no tiene que esperar a que el servicio procese el mensaje, ni a que el mensaje sea entregado. El cliente envía si mensaje y después continua con la suposición de que el servicio finalmente lo recibirá y procesará.

Cuando nosotros enviamos una carta no la enviamos por nuestros propios medios sino que la enviamos por medio del servicio postal. Ponemos la dirección la estampilla y listo. De forma similar, la vía indirecta el la clave de JMS. Cuando una aplicación envía información a otra mediante JMS, no hay vinculo directo entre ambas aplicaciones. En su lugar, la aplicación emisora coloca el mensaje en manos de un servicio que garantiza su entrega a la aplicación receptora. Hay dos conceptos principales en JMS: corredores de mensaje (message brokers) y destinos.

Cuando una aplicación envía un mensaje, lo entrega a un corredor de mensajes. El corredor de mensajes es la respuesta JMS a la oficina de correos. EL corredor de mensajes se asegurará de que el mensaje sea entregado en el destino especificado, dejando que el emisor siga con sus asuntos.

Cuando enviamos un correo es importante poner la dirección para que el servicio postal sepa dónde debe ser entregada. De igual forma, en JMS, los mensajes tienen una dirección con un destino. Los destinos son como los buzones donde se colocan los mensajes hasta que alguien llega a recogerlos.

No obstante, a diferencia de las direcciones postales, que indican una persona especifica o una calle, los destinos son menos específicos. A los destinos solo les incumbe donde sera recogido el mensaje, no quien lo recogerá. De esta forma los destinos son como enviar una carta dirigida “al residente”.

En JMS, hay dos tipos de destinos: colas y temas. Cada uno de estos está asociado a un modelo de mensajería concreto, bien de punto a punto (para colas) o bien de emisor a suscriptor (para temas)

Punto a Punto: cada mensaje tiene exactamente un emisor y un receptor. Cuando se entrega el mensaje al corredor de mensajes, este lo pone en una cola, cuando el receptor pide el mensaje este es eliminado de la cola.

Emisor a suscriptor: El mensaje es enviado a un tema todos los suscriptores del tema recibiran una copia del mensaje.

• La comunicación asíncrona a través de JMS ofrece diversas ventajas sobre la comunicación sincrónica:
• La comunicación sincrónica implica una espera.
• El cliente no esta acoplado a la disponibilidad del servicio
• El cliente no esta acoplado a la ubicación del servicio

El post casi completo fue solo para JMS, en una segunda parte voy a profundizar ActiveMQ.

Feliz 2011!!!

Un año transcurrió juntos, les deseo que se cumplan todos sus anhelos. En el 2011 espero que me sigan acompañando.

Feliz 2011 a todos!!!