Tuesday January 3, 2012 10:47

Comenzar con ActiveMQ y Maven

Posted by admin as Java, JMS, Maven

Luego de mucho tiempo sin siquiera mirar ActiveMQ, me decidí a volver a probarlo y, para eso, como era de esperar luego de tanto tiempo, tuve que comenzar desde cero.

Aprovechando que Maven ya se ha hecho “popular”, cosa que no ocurría cuando yo probé/usé ActiveMQ, pues me he decidido por probar ambos.

La idea es:

Iniciar una instancia de ActiveMQ.
Crear un generador de mensajes (un “producer”).
Crear un cliente que reciba dichos mensajes (“consumer”).

Primero, deberé crear la estructura de carpetas donde estaran los proyectos de Maven, uno para cada alternativa a desarrollar. Eso se puede lograr ejecutando los siguientes comandos:

mvn --batch-mode archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart -DgroupId=net.leyba.amqtest -DartifactId=producer -Dversion=0.1
 
mvn --batch-mode archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart -DgroupId=net.leyba.amqtest -DartifactId=consumer -Dversion=0.1
 
mvn --batch-mode archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart -DgroupId=net.leyba.amqtest -DartifactId=mq -Dversion=0.1

Ahora iré a la carpeta mq y editaré el archivo pom para que quede como se puede ver abajo:

 
<project xmlns="http://maven.apache.org/POM/4.0.0"
		 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  		xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelversion>4.0.0</modelversion>
    <groupid>net.leyba.amqtest</groupid>
    <artifactid>mq</artifactid>
    <packaging>jar</packaging>
    <version>0.1</version>
    <name>mq</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupid>junit</groupid>
            <artifactid>junit</artifactid>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupid>org.apache.activemq.tooling</groupid>
                <artifactid>maven-activemq-plugin</artifactid>
                <version>5.1</version>
                <configuration>
                    <configuri>xbean:file:./conf/activemq.xml</configuri>
                    <fork>false</fork>
                    <systemproperties>
                        <property>
                            <name>javax.net.ssl.keyStorePassword</name>
                            <value>password</value>
                        </property>
                        <property>
                            <name>org.apache.activemq.default.directory.prefix</name>
                            <value>./target/</value>
                        </property>
                    </systemproperties>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupid>org.springframework</groupid>
                        <artifactid>spring</artifactid>
                        <version>2.5.5</version>
                    </dependency>
                    <dependency>
                        <groupid>org.mortbay.jetty</groupid>
                        <artifactid>jetty-xbean</artifactid>
                        <version>6.1.11</version>
                    </dependency>
                    <dependency>
                        <groupid>org.apache.camel</groupid>
                        <artifactid>camel-activemq</artifactid>
                        <version>1.1.0</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>
</project>

Para terminar con esto, solo hace falta crear un archivo de configuración de ActiveMQ. Para esto, deberemos crear una carpeta “conf” en la raíz del proyecto (del proyecto mq, obviamente), y luego crear un fichero llamado “activemq.xml” tal cual se muestra aquí abajo:

< ?xml version="1.0"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:amq="http://activemq.apache.org/schema/core"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
  http://activemq.apache.org/schema/core
  http://activemq.apache.org/schema/core/activemq-core.xsd
  ">
  <broker xmlns="http://activemq.apache.org/schema/core" brokerName="localhost" dataDirectory="./data">
    <!-- The transport connectors ActiveMQ will listen to -->
    <transportconnectors>
      <transportconnector name="openwire" uri="tcp://localhost:61616"/>
    </transportconnectors>
  </broker>
</beans>

Ahora ya tenemos todo listo y podemos arrancar el servicio de ActiveMQ con el siguiente comando:

mvn org.apache.activemq.tooling:maven-activemq-plugin:5.2.0:run

Pasaremos ahora a trabajar con el generador de mensajes (producer), por lo que deberemos movernos a la carpeta “producer”.

Nuevamente, deberemos editar el archivo pom.xml para que quede de la siguiente manera:

 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelversion>4.0.0</modelversion>
    <groupid>net.leyba.amqtest</groupid>
    <artifactid>producer</artifactid>
    <packaging>jar</packaging>
    <version>0.1</version>
    <name>producer</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupid>junit</groupid>
            <artifactid>junit</artifactid>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupid>javax.jms</groupid>
            <artifactid>jms</artifactid>
            <version>1.1</version>
        </dependency>
        <dependency>
            <groupid>org.apache.activemq</groupid>
            <artifactid>activemq-core</artifactid>
            <version>5.2.0</version>
        </dependency>
    </dependencies>
 
    <repositories>
        <repository>
            <id>jboss</id>
            <url>http://repository.jboss.com/maven2</url>
            <releases>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>    
</project>

El generador estará compuesto por dos clases diferentes:

package net.leyba.amqtest;
 
import javax.jms.ConnectionFactory;
import org.apache.activemq.ActiveMQConnectionFactory;
 
/**
 * Hello world!
 *
 */
public class App 
{
    public static String brokerURL = "tcp://localhost:61616";
 
    public static void main( String[] args ) throws Exception
    {
        // setup the connection to ActiveMQ
        ConnectionFactory factory = new ActiveMQConnectionFactory(brokerURL);
 
        Producer producer = new Producer(factory, "test");
        producer.run();
        producer.close();
    }
}

 
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package net.leyba.amqtest;
 
 
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Session;
 
/**
 *
 * @author p165014
 */
public class Producer {
 
private ConnectionFactory factory;
    private Connection connection;
    private Session session;
    private MessageProducer producer;
 
    public Producer(ConnectionFactory factory, String queueName) throws JMSException
    {
        this.factory = factory;
        connection = factory.createConnection();
        connection.start();
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Destination destination = session.createQueue(queueName);
        producer = session.createProducer(destination);
    }
 
    public void run() throws JMSException
    {
        for (int i = 0; i < 100; i++)
        {
            System.out.println("Creating Message " + i);
            Message message = session.createTextMessage("Hello World!");
            producer.send(message);
        }
    }
 
    public void close() throws JMSException
    {
        if (connection != null)
        {
            connection.close();
        }
    }    
 
}

Ahora, podemos ejecutar nuestro generador de mensajes con el siguiente comando:

mvn clean compile exec:java -Dexec.mainClass=net.timico.messaging.App

Ahora solo queda terminar nuestro cliente. Para eso, debemos ir a la carpeta consumer.

Nuevamente, deberemos editar el aerchivo pom.xml.

 
 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelversion>4.0.0</modelversion>
    <groupid>net.leyba.amqtest</groupid>
    <artifactid>consumer</artifactid>
    <packaging>jar</packaging>
    <version>0.1</version>
    <name>consumer</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupid>junit</groupid>
            <artifactid>junit</artifactid>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupid>javax.jms</groupid>
            <artifactid>jms</artifactid>
            <version>1.1</version>
        </dependency>
        <dependency>
            <groupid>org.apache.activemq</groupid>
            <artifactid>activemq-core</artifactid>
            <version>5.2.0</version>
        </dependency>    
    </dependencies>
</project>

Luego, editaremos la clase que tiene nuestro código para que quede de la siguiente manera:

 
package net.leyba.amqtest;
 
 
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;
 
import org.apache.activemq.ActiveMQConnectionFactory;
 
/**
 * Hello world!
 *
 */
public class App implements MessageListener
{
 
    public static String brokerURL = "tcp://localhost:61616";
 
    private ConnectionFactory factory;
    private Connection connection;
    private Session session;
    private MessageConsumer consumer;
 
    public static void main( String[] args )
    {
        App app = new App();
        app.run();
    }
 
    public void run()
    {
        try
        {
            ConnectionFactory factory = new ActiveMQConnectionFactory(brokerURL);
            connection = factory.createConnection();
            connection.start();
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            Destination destination = session.createQueue("test");
            consumer = session.createConsumer(destination);
            consumer.setMessageListener(this);
        }
        catch (Exception e)
        {
            System.out.println("Caught:" + e);
            e.printStackTrace();
        }
    }
 
    public void onMessage(Message message)
    {
        try
        {
            if (message instanceof TextMessage)
            {
                TextMessage txtMessage = (TextMessage)message;
                System.out.println("Message received: " + txtMessage.getText());
            }
            else
            {
                System.out.println("Invalid message received.");
            }
        }
        catch (JMSException e)
        {
            System.out.println("Caught:" + e);
            e.printStackTrace();
        }
    }
}

Ahora ya tenemos todo listo y solo resta ejecutar nuestro cliente mediante el siguiente comando:

 mvn clean compile exec:java -Dexec.mainClass=net.timico.messaging.App

Este post esta inspirado en el siguiente post (en inglés):

Playing with ActiveMQ using Maven

Blog.Leyba.com.ar

Comenzar con ActiveMQ y Maven

2 Responses to Comenzar con ActiveMQ y Maven

Comment Form

Categories

Links