Etiqueta: eclipse

Apache Camel: Qué es un productor y un consumidor

En el post anterior creamos un componente en Camel, y ahora vamos a ver en detalle qué es un productor y un consumidor, mirando el código de nuestro proyecto.

  • Productor (HelloWorldProducer.java)
public void process(Exchange exchange) throws Exception {
   System.out.println(exchange.getIn().getBody());
}

En este ejemplo el productor simplemente muestra el body del mensaje por pantalla. Si por ejemplo quisiéramos enviar el mensaje a un sistema remoto, tendríamos que conectarnos a él y enviar el mensaje en un formato «entendible» por la transmisión.

Un ejemplo de productor es FileProducer, que se encarga de convertir el cuerpo del mensaje Camel en un fichero.

En resumen, cuando en Camel se mandan mensajes a un endpoint, es el productor el que hace el trabajo «duro» para poder interactuar adecuadamente con el sistema externo.

  • Consumidor (HelloWorldConsumer.java)

Un consumidor se encarga de introducir mensajes en una ruta Camel. Es decir, son la fuente de mensajes dentro de una ruta.

@Override
protected int poll() throws Exception {
   Exchange exchange = endpoint.createExchange();
   // create a message body
   Date now = new Date();
   exchange.getIn().setBody("Hello World! The time is " + now);

En una ruta Camel, los mensajes fluyen de un procesador a otro. Para entenderlo mejor, podemos ver una ruta como nodos interconectados, cada uno asociado a un procesador, y en el que la salida de un procesador es la entrada del siguiente.

// send message to next processor in the route
getProcessor().process(exchange);

Referencia: Camel in Action

Apache Camel: Qué es un endpoint

En el post anterior creamos un componente en Camel, y ahora vamos a aprender qué es un endpoint mirando además el código de nuestro proyecto.

  • Endpoint (HelloWorldEndpoint.java)

Un endpoint es la interface a través de la cual los sistemas externos pueden enviar y recibir mensajes, permitiendo así la integración de sistemas en Camel.

La función de un endpoint es crear productores y consumidores, lo que nos permite usar este endpoint como to y from dentro de una ruta Camel.

public Producer createProducer() throws Exception {
   return new HelloWorldProducer(this);
}
public Consumer createConsumer(Processor processor)
                              throws Exception {
   return new HelloWorldConsumer(this, processor);
}

Si queremos que nuestro componente sólo tenga por ejemplo un productor, se recomienda lanzar una excepción, en este caso al querer crear un consumidor:

public Consumer createConsumer() throws Exception {
   throw new UnsupportedOperationException(
     "No puede recibir mensajes el endpoint:" + getEndpointUri());
}

Se configuran mediante URIs siguiendo el siguiente formato:

[componente]:[contexto]?[opciones]

Ejemplo URI: file:data/inbox

En este ejemplo, Camel comprueba que file es el nombre asociado al componente FileComponent. Entonces, se le «avisa» a este componente de que tiene que crear un FileEndpoint utilizando el resto de la URI. En este caso, data/inbox sería la carpeta dónde se tendrían que leer/escribir  los ficheros (from/to en una ruta respectivamente).

Referencia: Camel in Action

Apache Camel: Qué es un componente

En el post anterior creamos un componente en Camel, y ahora vamos a ver en detalle qué es un componente, mirando el código de nuestro proyecto.

  • Componente (HelloWorldComponent.java)

Para extender Camel podemos crear un componente, que nos permite interactuar con diferentes APIs, protocolos, etc… Su principal función es crear endpoints.

protected Endpoint createEndpoint(String uri,
                      String remaining, Map<String,
                      Object> parameters) throws Exception {
   Endpoint endpoint = new HelloWorldEndpoint(uri, this);
   setProperties(endpoint, parameters);
   return endpoint;
}

El método setProperties permite asignar propiedades a un endpoint. Veamos un ejemplo:

componente:endpoint?prop1=val1&prop2=val2

En este ejemplo, el método setProperties trataría de invocar setProp1(«val1») y setProp2(«val2») sobre el endpoint.

A los componentes se les asocia un nombre que se usa en la URI que define un endpoint. Podemos ver esta asociación en el fichero helloworld (en src/main/resources/META-INF/services/org/apache/camel/component)

class=com.wordpress.anadreamy.HelloWorldComponent

Con esta simple asociación podriamos utilizar helloworld (el nombre del fichero) como el nombre del componente dentro de la URI.

from("helloworld://foo")
 .to("helloworld://bar")

Referencia: Camel in Action

Cómo crear un componente en Apache Camel

Cómo ya vimos en un post anterior, Camel nos proporciona diferentes arquetipos Maven para crear fácilmente el esqueleto de nuestros proyectos. Para crear nuestro componente Camel vamos a utilizar el arquetipo camel-archetype-component.

1) Creamos el proyecto desde línea de comandos

mvn archetype:generate \
-DarchetypeGroupId=org.apache.camel.archetypes \
-DarchetypeArtifactId=camel-archetype-component \
-DarchetypeVersion=2.9.1 \
-DgroupId=com.wordpress.anadreamy \
-DartifactId=myCustomComponent

También podríamos crear el proyecto directamente desde Eclipse utilizando el plugin m2e de Maven.

2) Importamos el proyecto desde Eclipse con ‘File->Import’

Una vez importado el proyecto vamos a ver con ayuda del código generado:

Una vez que hemos visto en detalle las partes de un componente, nos faltaría testearlo. Para ello sólo tenemos que ejecutar como JunitTest la clase HelloWorldComponentTest.java 🙂

Referencia: Camel in Action

Nuestro primer proyecto con Apache Camel

Apache Camel

Apache Camel es un framework open-source que nos permite integrar sistemas fácilmente. Podemos definir reglas de enrutamiento que indiquen las fuentes desde las que queremos recibir mensajes, cómo procesarlos y dónde terminar enviándolos. Implementa los Patrones EIP (Enterprise Integration Patterns).

Tiene una comunidad muy activa detrás, como por ejemplo Claus Ibsen, autor del libro «Camel in Action».

Para empezar a trabajar con Camel no necesitamos instalar nada diferente a lo que ya usamos a diario en nuestro trabajo. Con Maven y uno de los arquetipos de Camel podemos crear nuestro primer proyecto de una manera muy sencilla.

Para ello abrimos una ventana de comandos y ejecutamos:

mvn archetype:generate \
-DarchetypeGroupId=org.apache.camel.archetypes \
-DarchetypeArtifactId=camel-archetype-java \
-DarchetypeVersion=2.9.1 \
-DgroupId=com.examples \
-DartifactId=myCamelExample

Este comando nos creará una carpeta llamada myCamelExample, con la estructura típica de un proyecto Maven y todo lo necesario para empezar a programar.

Si queremos trabajar desde Eclipse, sólo tendremos que importar el proyecto ‘Import -> Maven -> Existing Maven Projects’ seleccionando la carpeta myCamelExample.

En este post hemos aprendido como crear la estructura de un proyecto Camel con Maven. En siguientes posts seguiremos trasteando con Camel 🙂

Aumentar la memoria de Eclipse

Si estamos trabajando con Eclipse y nos sale el error PermGen, en el fichero eclipse.ini podemos aumentarle la memoria en la siguiente línea:

-XX:MaxPermSize=512m

Una vez que le hemos puesto la memoria que necesitemos, reiniciamos Eclipse.

Probando el plugin eclipse de Spring Roo

¿Os apetece crear una aplicación Java en unos pocos minutos?

Con Spring Roo es posible 🙂 En este post vamos utilizar el plugin eclipse de Roo para crear la la web de una pizzería, siguiendo la documentación de Roo.

Software que he utilizado

  • Spring Roo 1.2 M1
  • Eclipse Indigo (3.7)
  • SpringSource Tool Suite for Eclipse Indigo
  • Java 6
  • Maven 3.0.3
  • Tomcat 7

 Diagrama de clases

Probando el plugin eclipse de Spring Roo

Requisitos de instalación

Probando el plugin eclipse de Spring Roo

Creación de la aplicación web

1) Creamos un nuevo proyecto Roo (File >> New >> Project… >> Spring Roo Project)

2) Le asignamos un nombre y un paquete

Probando el plugin eclipse de Spring Roo

3) Abrimos la shell de Roo pinchando con el botón derecho sobre el proyecto y seleccionando «Spring Tools >> Open Roo Shell»

4) Empezamos configurando la persistencia desde la shell de la siguiente manera:

jpa setup --provider HIBERNATE --database HYPERSONIC_IN_MEMORY
Probando el plugin eclipse de Spring Roo

  • Creamos las entities que tiene el diagrama de clases
entity --class ~.domain.Base --testAutomatically
field string --fieldName name --sizeMin 2 --notNull
entity --class ~.domain.Topping --testAutomatically
field string --fieldName name --sizeMin 2 --notNull
entity --class ~.domain.Pizza --testAutomatically
field string --fieldName name --notNull --sizeMin 2
field number --fieldName price --type java.math.BigDecimal
field set --fieldName toppings --type ~.domain.Topping
field reference --fieldName base --type ~.domain.Base
entity --class ~.domain.PizzaOrder --testAutomatically
field string --fieldName name --notNull --sizeMin 2
field string --fieldName address --sizeMax 30
field number --fieldName total --type java.math.BigDecimal
field date --fieldName deliveryDate --type java.util.Date
field set --fieldName pizzas --type ~.domain.Pizza
  • Le añadimos la parte web
web mvc setup
web mvc all --package ~.web
  • Generamos el archivo .war
perform package

5) Desplegamos el .war en nuestro servidor ¡Y ya tendríamos nuestra aplicación web lista!!!

Probando el plugin eclipse de Spring Roo

Como hemos comprobado, con Spring Roo podemos crear una aplicación Java en pocos minutos, acelerando así muchísimo el tiempo normal de creación de un proyecto Java de estas características.

Si creáramos la aplicación desde línea de comandos, en vez de usar el plugin, ejecutando ‘perform eclipse’ ya lo tendríamos preparado para importar el proyecto a nuestro eclipse y empezar con el desarrollo.

Referencia: Spring Roo

Librerías en Eclipse

Si somos desarrolladores software, es normal que utilicemos muy a menudo librerías comunes en todos nuestros proyectos. Por ello,  Eclipse permite definir unas variables de estas librerías que se comparten entre todos nuestros proyectos y las podemos añadir siempre que las necesitemos.

Para crear una variable, pinchamos en Window > Preferences > Java > Build Path > Classpath Variables

Una vez que tenemos nuestra variable creada, podemos añadirla a nuestro proyecto haciendo click con el botón derecho sobre él y pinchando en Build Path > Configure Build Path… > Add Variable…

Android: Crear AVDs

Android nos proporciona un emulador de dispositivos Android, permitiéndonos desarrollar y testear una aplicación Android cómodamente desde nuestro ordenador. Este emulador puede simular tantos dispositivos como necesitemos, y a cada uno de ellos se les llama Android Virtual Device (AVD).

La primera vez que ejecutemos una aplicación Android desde Eclipse, si todavía no hemos creado ningún AVD, nos dirá que creemos una para poder ejecutar la aplicación. Por eso, vamos a ver cómo crear nuestro primer AVD:

1) Pinchamos en «Window > Android SDK and AVD Manager > New…»

2) Nos aparecerá una ventana donde indicaremos:

  • El nombre del AVD (ej. MyFirstAVD)
  • La versión de Android que se ejecutará en el dispositivo virtual (ej. Android 3.0 – API Level 11)
  • Dónde se van a almacenar los datos de usuario y el tamaño de la SD Card (ej. 32 MiB)
  • La resolución y apariencia del dispositivo (ej. Default (WXGA))
  • Si se va a necesitar hardware, como por ejemplo una cámara o un teclado.

A partir de la versión 3.0 de Android, para mejorar el tiempo de inicio del emulador, se ha añadido la posibilidad de realizar snapshots. De esta manera, cuando cerramos el emulador se guarda un snapshot del estado del AVD y ésta se usa la siguiente vez que se inicia. Esto acelera el inicio pero hace que el cierre del emulador se vuelva más lento, por tener que hacer ese snapshot. Por eso Google recomienda desactivar ‘Save to snapshot’ después de que ya tengamos un snapshot inicial.

3) Terminamos pinchando en ‘Create AVD’

Para testear nuestra aplicación, deberíamos crear varios AVD’s con distintas configuraciones, por ejemplo, con diferentes versiones de Android. Así comprobamos que nuestra aplicación funciona correctamente en cada una de ellas.

Referencia: http://developer.android.com/guide/developing/devices/index.html

Android: Configurando el entorno

Para empezar a programar con Android, primero es necesario configurar el entorno de desarrollo. Para ello, vamos a ver de una manera rápida y esquemática los pasos que hay que seguir:

1) Descargamos el SDK de Android

2) Instalamos el plugin ADT (Android Development Tool) para Eclipse:

  • Pinchamos en «Help > Install New Software… > Add» y añadimos un nuevo site llamado ‘ADT Plugin’ con URL: https://dl-ssl.google.com/android/eclipse/
  • Seleccionamos el checkbox que ha aparecido junto a «Developer Tools» y pinchamos ‘Next’ hasta que tengamos que aceptar los ‘License agreements’. Para terminar, pinchamos en ‘Finish’.
  • Cuando se termine de instalar el plugin, pinchamos ‘Ok’ en el mensaje que nos aparecerá y reiniciamos Eclipse.

3) Pinchamos en ‘»Window > Preferences > Android» y seleccionamos la carpeta donde hemos descargado el SDK.

4) Pinchamos en «Window > Android SDK and AVD Manager > Available packages» e instalamos los paquetes que necesitemos: SDK Platform-tools, SDK Platform, Documentation, Samples, etc…

Si queremos debugear nuestra aplicación, existe la herramienta Dalvik Debug Monitor Server (DDMS). Para utilizarlo en Eclipse, pinchamos en «Window > Open Perspective > Other…» y la seleccionamos.