jueves, 3 de diciembre de 2020
jueves, 10 de octubre de 2019
Libros de Java geek
martes, 1 de octubre de 2013
Download Free ebook
|
jueves, 8 de marzo de 2012
Apache ServiceMix
Apache ServiceMix es un flexible ESB open source, que integra funcionalidad de diversos productos de Apache como Apache ActiveMQ, Camel, CXF, ODE y Karaf. Provee el funcionamiento de un ESB integrado a una herramienta OSGI.
Las características de Apache ServiceMix son:
- Mensajería segura gracias a Apache ActiveMQ
- Mensajería, enrrutamiento y patrones de integración para Empresas con Apache Camel
- ServiceMix NMR incluye eventos ricos, mensajería y auditoría lo que permite una integración con bajo acoplamiento.
- Completo WS-BPEL con Apache ODE.
- Basado en OSGI con la utilización Apache Karaf.
Además es licencia Apache 2.
Dejo Link:
http://servicemix.apache.org/
miércoles, 15 de febrero de 2012
Apache Apollo la nueva generación de mensajería!
ActiveMQ Apollo es más rapido, seguro, confiable y facil de mantener broker de mensajería. El cual fue construido a partir de Apache ActiveMQ. Los ingenieros de Apache le dieron una vuelta de rosca a ActiveMQ.
Apollo sólo soporta el protocolo STOMP pero al igual que ActiveMQ, ha sido diseñado para correr sobre varios protocolos. En futuras versiones se añadirá soporte OpenWirepor lo que puede ser compatible con ActiveMQ 5.x clientes JMS.
Entre los cambios de arquitectura podemos nombrar:
- Refactor basado en Thread Model
- Implementación para scala 2.8
- Protocolo agnóstico
- Administración basada en REST
Dejo links:
http://activemq.apache.org/apollo/
http://activemq.apache.org/apollo/documentation/architecture.html
http://activemq.apache.org/apollo/documentation/getting-started.html
viernes, 7 de octubre de 2011
Apache TomEE Certifico Web Profile Compatible
La idea es tener un Web Profile basado en Tomcat que no influya en este proyecto y basado en productos de apache. Veamos los productos que lo conforman:
CDI | Apache OpenWebBeans |
EJB | Apache OpenEJB |
Javamail | Apache Geronimo JavaMail |
JPA | Apache OpenJPA |
JSF | Apache MyFaces |
JSP | Apache Tomcat |
JSTL | Apache Tomcat |
JTA | Apache Geronimo Transaction |
Servlet | Apache Tomcat |
Además viene una versión plus que trae los siguientes servicios:
Connector | Apache Geronimo Connector |
JMS | Apache ActiveMQ |
Web Services | Apache CXF |
Dejo Links:
http://www.infoq.com/news/2011/10/apache-tomee
http://openejb.apache.org/3.0/apache-tomee.html
lunes, 24 de enero de 2011
ActiveMQ con Spring
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.
domingo, 16 de enero de 2011
Más de Apache ActiveMQ
![](https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjkywpu-F4P2snt1flrpjhGqFEBS1L24ikSbRCLDLHYBWYQiZ6081e7U6gNxl5ED5IDFBKy5KArTGbVgQHYshyphenhyphenBxztD6poxGSyaR-7TN_uFLxTMgoa8vTcdOdsLltlDiFeLI7mKyajFhNI/s320/Apache-activemq-logo.png)
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.
sábado, 8 de enero de 2011
Apache ActiveMQ
![](https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEisg2gucNtN-htdHRKyBZYXolhqL0ka-vr8LbGhuS5s_6FJcbUlIVRItcW99Ui7pTucG7cKxctIMf4W5FnkNqVvfK0LFrHNsDh7D-FmXykTK4fOmE-RyRYbvwjqHI1l5FxB7d4l_rmUe1M/s320/activemq-5.x-box-reflection.png)
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.
sábado, 4 de septiembre de 2010
FUSE
![](https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgRLU8g6f22TbVIkv3eSNGxTzVcV1_AW-h3QOo8oJYzdIFnCLMicFBcb1-9oXCoQMVkbQtOmxyCm7RNrRagUl2aiches-jd5l2f8sUTGlzzelQAa_oywCLu7vAkGBbWcV1QvhTPJfcTvY0/s320/fuse-logo.png)
FUSE es una comunidad que promueve el uso de productos Apache para el uso de SOA. La idea es crear una comunidad Open Source de uso de SOA, de esta forma poder compartir experiencias, conocimiento, etc.
Dejo el link: http://fusesource.com/
sábado, 13 de marzo de 2010
Apache ActiveMQ
Antes de comenzar a hablar de ActiveMQ debemos entender JMS. JMS trata sobre la comunicación de aplicaciones de forma asíncrona. Funciona de forma similar que un mail, JMS envía el mensaje a la aplicación sin esperar que la reciba la otra aplicación.
La vía indirecta es la clave de JMS. Cuando una aplicación envía información a otra mediante JMS, no hay vínculo 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: corredor de mensajes (message brokers) y destinos (destinations)
Apache ActiveMQ es un estupendo message brokers de código abierto y una maravillosa opción para la mensajería asíncrona con JMS. Aunque ActiveMQ comenzó como un proyecto de CodeHaus, se traslado a Apache.
Apache ActiveMQ es rápido, soporta varios lenguajes Java, C, C++, C#, Ruby, Perl, Python, PHP, soporte a Enterprise Integration Patterns, integración con spring, y se distribuye bajo licencia Apache 2.0 License
Dejo links: