domingo, 30 de enero de 2011

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.

lunes, 24 de enero de 2011

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:

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.

sábado, 22 de enero de 2011

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:


NAMESPACEPREFIX 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




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.

jueves, 20 de enero de 2011

lunes, 17 de enero de 2011

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.

domingo, 16 de enero de 2011

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.

sábado, 8 de enero de 2011

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.