Nos hemos mudado!!!

El nuevo blog es http://puesenmiordenadorfunciona.blogspot.com 😉

Cómo incluir información del proyecto con Maven

Si nuestro proyecto utiliza Maven, podemos añadir información del proyecto dentro del pom.xml. La información que podemos añadir es:

1) Licencias

<licenses>
  <license>
    <name>Apache 2</name>
    <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
    <distribution>repo</distribution>
    <comments>A business-friendly OSS license</comments>
  </license>
</licenses>

Las licencias son documentos legales que definen como y cuando se debe usar un proyecto o partes de él. Sólo se deben añadir las licencias que se aplican directamente al proyecto y no las aplicadas a dependencias del proyecto.

2) Organización

<organization>
    <name>Codehaus Mojo</name>
    <url>http://mojo.codehaus.org</url>
</organization>

3) Desarrolladores

<developers>
    <developer>
      <id>eric</id>
      <name>Eric</name>
      <email>eredmond@codehaus.org</email>
      <url>http://eric.propellors.net</url>
      <organization>Codehaus</organization>
      <organizationUrl>http://mojo.codehaus.org</organizationUrl>
      <roles>
        <role>architect</role>
        <role>developer</role>
      </roles>
      <timezone>-6</timezone>
      <properties>
        <picUrl>http://tinyurl.com/prv4t</picUrl>
      </properties>
    </developer>
</developers>

4) Contribuidores

<contributors>
    <contributor>
      <name>Noelle</name>
      <email>some.name@gmail.com</email>
      <url>http://noellemarie.com</url>
      <organization>Noelle Marie</organization>
      <organizationUrl>http://noellemarie.com</organizationUrl>
      <roles>
        <role>tester</role>
      </roles>
      <timezone>-5</timezone>
      <properties>
        <gtalk>some.name@gmail.com</gtalk>
      </properties>
  </contributor>
</contributors>

Los contribuidores son personas que resuelven un bug, añaden algo de documentación, etc…

Referencia: http://maven.apache.org/pom.html#More_Project_Information

Cómo crear la web para tu proyecto con Maven

En posts anteriores hemos visto cómo incluir la información de nuestro proyecto (desarrolladores, licencias, organización, …) y el entorno de desarrollo (control de versiones, listas de correo, etc…) en nuestro pom.xml . También hemos visto cómo crear un proyecto multimódulo con Maven.

¿No estaría bien que nuestro proyecto tuviese una web con toda esta información? ¿Y si además os dijera que la podamos hacer de una manera muy sencilla con Maven? Con el plugin maven-site-plugin podemos hacerlo. Pero vamos paso por paso.

1) Creamos el proyecto

Primero necesitamos un proyecto con el que poder trastear. Para este ejemplo voy a utilizar un projecto opensource de Github. En concreto, el proyecto de una empresa poco conocida… Twitter creo que se llama ;D Vosotros podéis utilizar otros proyectos de ejemplo, o crearos uno propio, lo que más os apetezca. Yo me voy a descargar  el proyecto Twitter4J.

2) Añadimos el plugin maven-site-plugin en el pom.xml

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-site-plugin</artifactId>
      <version>3.0</version>
      <configuration>
      <port>9000</port>
      <tempWebappDirectory>${basedir}/target/site/tmp</tempWebappDirectory>
      <locales>en,es</locales>
      <reportPlugins>
        <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-project-info-reports-plugin</artifactId>
           <version>2.2</version>
           <reports>
             <report>index</report>
             <report>project-team</report>
             <report>license</report>
             <report>mailing-list</report>
             <report>dependencies</report>
             <report>plugin-management</report>
             <report>cim</report>
             <report>issue-tracking</report>
             <report>scm</report>
             <report>summary</report>
           </reports>
         </plugin>
       </reportPlugins>
     </configuration>
   </plugin>
 </plugins>
</build>

Ver pom.xml completo del proyecto.

3) Desplegamos la web

En una ventana de comandos ejecutamos:

>> mvn install -Dmaven.test.skip=true
>> mvn site:run

Accedemos a http://localhost:9000 y vemos que nuestro proyecto ya tiene una web!!!

 

Cómo desplegar una aplicación en GlassFish 3.1.2

En un post anterior aprendimos cómo instalar GlassFish. En este post vamos a ver cómo podemos desplegar una aplicación. Para ello podemos utilizar el fichero .war que creamos en el post de Spring Roo, en el post de Richfaces, o cualquier otro que queráis.

1) Arrancamos GlassFish

$ sudo [directorio-glassfish]/bin/asadmin start-domain

Un ejemplo de [directorio-glassfish] es /home/ana/glassfish3

2) Desplegamos la aplicación

$ sudo [directorio-glassfish]/bin/asadmin deploy myFirstRFApp-1.0-SNAPSHOT.war

3) Accedemos a la aplicación

http://localhost:9090/myFirstRFApp-1.0-SNAPSHOT/

El formato de esta URL es: http://localhost:[puerto-glassfish]/[nombre-fichero-war]

Bonus Track

También podemos desplegar la aplicación desde la consola web de GlassFish

http://localhost/4848

Cómo instalar GlassFish 3.1.2 en Ubuntu 12.04

En este post vamos a instalar GlassFish, un servidor de aplicaciones opensource compatible con JavaEE. Para ello sólo necesitamos seguir los siguientes pasos:

1) Descargamos el instalador de GlassFish

$ wget http://download.java.net/glassfish/3.1.2/release/glassfish-3.1.2-unix.sh

2) Le damos permisos de ejecución

$ chmod +x glassfish-3.1.2-unix.sh

3) Ejecutamos el instalador

$ sh ./glassfish-3.1.2-unix.sh

Seleccionamos «Instalación Típica» ya que no queremos instalar el GlassFish en un entorno de producción, de momento sólo queremos trastear con él 😉 El resto de la instalación es sencillo.

4) Comprobamos que funciona!!!

Al instalar GlassFish hemos creado un dominio por defecto llamado domain1. Para probar qué funciona podemos arrancar y parar el dominio:

$ sudo [directorio-glassfish]/bin/asadmin start-domain domain1
$ sudo [directorio-glassfish]/bin/asadmin stop-domain domain1

Al final de la ejecución de ambos comandos tenemos que ver «executed successfully».

Como de momento sólo tenemos un dominio, podríamos ejecutar estos 2 comandos sin indicar domain1 al final y se seguirían ejecutando correctamente.

Un ejemplo de [directorio-glassfish] es /home/ana/glassfish3.

Bonus Track

Teniendo el dominio arrancado, podemos administrar GlassFish desde un navegador entrando en la URL:

http://localhost:4848

GlassFish

En siguientes posts veremos cosas tan interesantes como desplegar una aplicación en GlassFish o debuguear la aplicación desde Eclipse, …

Cómo configurar el entorno de desarrollo con Maven

En nuestros proyectos de desarrollo solemos utilizar herramientas de seguimiento de incidencias (Bugzilla, Jira, Mantis, …), integración continua (Jenkins, Hudson, Bamboo, …), listas de correo del proyecto, etc… Este entorno de trabajo podemos incluirlo con Maven dentro del pom.xml del proyecto:

1) Herramientas de seguimiento

<issueManagement>
    <system>Jira</system>
    <url>http://example.com/jira/browse/XXX</url>
</issueManagement>

2) Integración continua

<ciManagement>
   <system>jenkins</system>
   <url>http://localhost:8080/jenkins</url>
   <notifiers>
      <notifier>
         <sendOnError>true</sendOnError>
         <sendOnFailure>true</sendOnFailure>
         <sendOnSuccess>true</sendOnSuccess>
         <sendOnWarning>true</sendOnWarning>
      </notifier>
   </notifiers>
</ciManagement>

3) Listas de correo

<mailingLists>
    <mailingList>
      <name>User List</name>
      <subscribe>user-subscribe@example.com</subscribe>
      <unsubscribe>user-unsubscribe@example.com</unsubscribe>
      <post>user@example.com</post>
      <archive>http://example.com/user/</archive>
    </mailingList>
</mailingLists>

4) Control de versiones

<scm>
   <url>https://github.com/user/project</url>
   <connection>scm:git:git://github.com/user/project.git</connection>
   <developerConnection>scm:git:git://github.com/user/project.git</developerConnection>
</scm>

Referencia: http://maven.apache.org/pom.html#Environment_Settings

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