Developers Blog

A simple ActiveMQ example

Tue, 28 Oct 2008 00:07:49 +0000

A small class to get started with ActiveMQ. Inspired by the examples contained in the ActiveMQ download.

MyFirstActiveMqQueue.java

   1:/*
   2: * Small class to get started with ActiveMQ. Inspired by the examples contained in the
   3: * ActiveMQ download. Gisbert Amm, 2008-10-28
   4: */
   5:package de.gisbertamm.activemqstart;
   6:
   7:import javax.jms.JMSException;
   8:import org.apache.activemq.ActiveMQConnectionFactory;
   9:import org.apache.activemq.broker.BrokerService;
  10:import javax.jms.Connection;
  11:import javax.jms.DeliveryMode;
  12:import javax.jms.Destination;
  13:import javax.jms.ExceptionListener;
  14:import javax.jms.Message;
  15:import javax.jms.MessageConsumer;
  16:import javax.jms.MessageListener;
  17:import javax.jms.MessageProducer;
  18:import javax.jms.Session;
  19:import javax.jms.TextMessage;
  20:import org.apache.activemq.ActiveMQConnection;
  21:
  22:/**
  23: *
  24: * @author gisbert.amm
  25: */
  26:public class MyFirstActiveMqQueue {
  27:
  28:    private static ActiveMQConnectionFactory connectionFactory;
  29:    private static Connection connection;
  30:    private static Session session;
  31:    private static Destination destination;
  32:    private static boolean transacted = false;
  33:
  34:    public static void main(String[] args) throws Exception {
  35:        BrokerService broker = new BrokerService();
  36:        broker.setUseJmx(true);
  37:        broker.addConnector("tcp://localhost:61616");
  38:        broker.start();
  39:
  40:        setUp();
  41:        createProducerAndSendAMessage();
  42:        System.out.println("Simulating a huge network delay :)");
  43:        Thread.sleep(4000);
  44:        createConsumerAndReceiveAMessage();
  45:
  46:        //TODO: Find out how to get rid of the exceptions thrown when stopping the broker
  47:        broker.stop();
  48:    }
  49:
  50:    private static void setUp() throws JMSException {
  51:        connectionFactory = new ActiveMQConnectionFactory(
  52:                ActiveMQConnection.DEFAULT_USER,
  53:                ActiveMQConnection.DEFAULT_PASSWORD,
  54:                ActiveMQConnection.DEFAULT_BROKER_URL);
  55:        connection = connectionFactory.createConnection();
  56:        connection.start();
  57:        session = connection.createSession(transacted, Session.AUTO_ACKNOWLEDGE);
  58:        destination = session.createQueue("mmy first active mq queue");
  59:    }
  60:
  61:    private static void createProducerAndSendAMessage() throws JMSException {
  62:        MessageProducer producer = session.createProducer(destination);
  63:        producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
  64:        TextMessage message = session.createTextMessage("Hello World!");
  65:        System.out.println("Sending message: " + message.getText());
  66:        producer.send(message);
  67:    }
  68:
  69:    private static void createConsumerAndReceiveAMessage() throws JMSException, InterruptedException {
  70:        connection = connectionFactory.createConnection();
  71:        connection.start();
  72:        MessageConsumer consumer = session.createConsumer(destination);
  73:        MyConsumer myConsumer = new MyConsumer();
  74:        connection.setExceptionListener(myConsumer);
  75:        consumer.setMessageListener(myConsumer);
  76:    }
  77:
  78:    private static class MyConsumer implements MessageListener, ExceptionListener {
  79:
  80:        synchronized public void onException(JMSException ex) {
  81:            System.out.println("JMS Exception occured.  Shutting down client.");
  82:            System.exit(1);
  83:        }
  84:
  85:        public void onMessage(Message message) {
  86:            if (message instanceof TextMessage) {
  87:                TextMessage textMessage = (TextMessage) message;
  88:                try {
  89:                    System.out.println("Received message: " + textMessage.getText());
  90:                } catch (JMSException ex) {
  91:                    System.out.println("Error reading message: " + ex);
  92:                }
  93:            } else  {
  94:                System.out.println("Received: " + message);
  95:            }
  96:        }
  97:    }
  98:}

Pragmatische Visualisierung einer Architektur

Mon, 29 Sep 2008 14:59:49 +0000

Die einfachste und schnellste Methode ein bestehendes System zu visualisieren liegt in der Auswertung der Membervariablen jeglicher Klasse und die Erzeugung eines gerichteten Graphen. Natürlich werden hier Objekte die per Übergabe in Methoden verwendet werden nicht betrachtet sowie auch Singleton Klassen auf die man über die static Methoden zugreift. Aber wie gesagt, die Vorgehensweise verschafft einen ersten Einblick.

Das Resultat zum nachfolgenden Beispiel:

Dabei wird mit Hilfe von Reflection und Graphviz einem Tool zur grafischen Darstellung von Hierarchien und Netzwerken ein Architekturbild im gewünschten Format erzeugen. Graphviz eignet sich vor allem deswegen, weil ab einer gewissen größe eines System, das manuelle Layout nicht mehr einfach ist. Die Layoutalgorithmen von Graphviz können auch mehr als 100 oder 1000 Knoten noch immer transparent darstellen.

Folgende Vorgehensweise wird hier durchgeführt:

Auslesen aller Klassen eines definierten Source-Verzeichnisses.
Über eine Schleife werden alle MemberVariablen über die Methode
```
classloader.loadClass(name).getDeclaredFields()
```
ausgelesen.
Jeder Schleifendurchlauf schreibt die Memeberbeziehung zu einer anderen Klasse in ein DOT-File (Graphvizformat)<./li>

Beispiel:
Drei Klassen, wobei jede die anderen kennt.

test2.java

   1:public class Class1 {
   2:    private Class2 class2;
   3:    private Class3 class3;
   4:}
   5:
   6:public class Class2 {
   7:    private Class1 class1;
   8:    private Class3 class3;
   9:}
  10:
  11:public class Class3 {
  12:    private Class2 class2;
  13:    private Class1 class1;
  14:}

Klasse, welche die Klassen ausliest und per Reflection die Beziehung zwischen diesen identifiziert sowie das DOT-File erezugt.

test2.java

   1:package org.developersblog.PragmaticVisualizeArchiteture;
   2:
   3:import java.io.File;
   4:import java.io.FileWriter;
   5:import java.io.IOException;
   6:import java.lang.reflect.Field;
   7:import java.util.ArrayList;
   8:import java.util.List;
   9:
  10:public class MemberExtractionAndDotGeneration {
  11:
  12:    public static void getClassNames(String prefix, 
  13:            List<String> classnames,
  14:            String dir) {
  15:        File dirFile = new File(dir);
  16:        for (File file : dirFile.listFiles()) {
  17:            if (file.isDirectory()) {
  18:                if (prefix.length() > 0) {
  19:                    getClassNames(prefix + "." + 
  20:                            file.getName(), 
  21:                            classnames,
  22:                            file.getAbsolutePath());
  23:                } else {
  24:                    getClassNames(file.getName(), classnames, 
  25:                            file.getAbsolutePath());
  26:                }
  27:            } else {
  28:                if (file.getName().endsWith(".java")) {
  29:                    if (prefix.length() > 0) {
  30:                        String name = prefix + "." + file.getName().
  31:                                replaceAll(".java", "");
  32:                        classnames.add(name);
  33:                    } else {
  34:                        String name = 
  35:                                file.getName().replaceAll(".java", "");
  36:                        classnames.add(name);
  37:                    }
  38:                }
  39:            }
  40:        }
  41:    }
  42:
  43:    /**
  44:     * @param args
  45:     * @throws ClassNotFoundException
  46:     * @throws SecurityException
  47:     * @throws IOException
  48:     */
  49:    public static void main(String[] args) throws SecurityException,
  50:            ClassNotFoundException, IOException {
  51:        FileWriter writer = new FileWriter(new File(
  52:                "/home/rafsob/Desktop/graph.dot"));
  53:        writer.write("digraph G {\r\nedge [len=2];\r\n");
  54:        ClassLoader cl = MemberExtractionAndDotGeneration.
  55:                class.getClassLoader();
  56:        List<String> classnames = new ArrayList<String>();
  57:        //Klassen aus dem src Verzeichnis holen
  58:        getClassNames("", classnames,
  59:          "/home/rafsob/Desktop/workspace/" +
  60:          "PragmaticVisualizeArchiteture/src/main/java");
  61:        //Klassenreferenzen identifizieren
  62:        for (String name : classnames) {
  63:            System.out.println("check class with name: " + name);
  64:            for (Field field : cl.loadClass(name).getDeclaredFields()) {
  65:                if (classnames.contains(field.getType().getCanonicalName()) && 
  66:                    !name.equals(field.getType().getCanonicalName())) {
  67:                    
  68:                    int lastFirst = name.lastIndexOf('.');
  69:                    int lastSecond = field.getType().
  70:                            getCanonicalName().lastIndexOf('.');
  71:                    //Knotenbeziehung in DOT defnieren
  72:                    writer.write(" \"" + name.substring(lastFirst + 1) + "\" -> \"" + 
  73:                            field.getType().getCanonicalName().
  74:                            substring(lastSecond + 1) + "\";\r\n");
  75:                }
  76:            }
  77:        }
  78:        writer.write("}");
  79:        writer.close();
  80:        //Neato für die Darstellung von Graphen starten
  81:        Process p = Runtime.getRuntime().exec(
  82:                "/usr/bin/neato " +
  83:                "-Tpng /home/rafsob/Desktop/graph.dot " +
  84:                "-o /home/rafsob/Desktop/graph.png");
  85:        System.out.println("end");
  86:    }
  87:}
  88:
  89:

Viele Grüße Rafael Sobek

OSGI Embedded Container

Wed, 17 Sep 2008 22:17:32 +0000

Ich habe mich vor kurzem mit dem Thema OSGI-Einbindung des Felix- bzw. Equinoxcontainers beschäftigt. Anwendungsfelder können Applikationen sein, die sich gerade in der Refaktorisierungsphase Richtung OSGI-Komponentenapplikation befinden oder z.B. Servletapplikationen, die die Komponentenarchitektur in Form von OSGI-Bundles realisieren sollen.

Weiterhin könnte auch die Anforderung existieren, einen OSGI-Container per Trigger auf der Quellcode Ebene zu initialisieren.

Euqinox kann über die EclipseStarter-Klasse initilisiert werden (startup.jar), hier Beispielhaft:

test.java

   1:String args[] = { "-console", "2000" }; 
   2:BundleContext ctx = org.eclipse.core.runtime.adaptor.EclipseStarter.startup( args, null );
   3:Bundle b = ctx.installBundle("file://home/rafsob/bundlerepository/testbundle.jar");
   4:b.start();

Eine ausführliche Beschreibung der Einbettung des Felix OSGI Server's kann man auf der Apache Felix Seite finden Launching and Embedding Apache Felix.

Zusammenfassend kann ich sagen, dass die Einbettung des Equinoxservers kaum dokumentiert ist. Bzw. ich nicht die Richtige Stelle im Internet gefunden habe. :-)

Der Felixcontainer scheint mir hier einfacher und besser dokumentiert.

Viele Grüße
Rafael Sobek

Camel-Routen visualisieren

Mon, 15 Sep 2008 21:16:58 +0000

1. Neuesten Stand der Camel-Sourcen holen und bauen

Wir werden jetzt kleinere Features von Camel benutzen, die es im Release 1.4.0 noch nicht gibt (z.B. den Ablageort des Camel-Contextes zu konfigurieren). Deshalb ist es Zeit, die Camel-Sourcen auszuchecken und die aktuelle Version selbst zu bauen:

svn co https://svn.apache.org/repos/asf/activemq/camel/trunk camel
set MAVEN_OPTS=-Xmx512m -XX:MaxPermSize=128m
mvn install -Dtest=false
(vgl. http://activemq.apache.org/camel/building.html)

Das dauert eine Weile. In der Zwischenzeit können wir unser Projekt anpassen.

2. POM anpassen

Zunächst zentralisieren wir die Camel-Versionsangabe an einer Stelle, damit wir bei der nächsten Versionsänderung nur diese anpassen müssen. Dazu fügen wir der POM auf Hauptebene diesen Eintrag hinzu:

property.xml

   1:<properties>
   2:        <camel.version>1.5-SNAPSHOT</camel.version>
   3:</properties>

Nun können wir alle Vorkommen der Camel-Versionsnummer durch eine Referenz auf diese Property (${camel.version}) ersetzen, im vi z.B. mittels
%s,1.4.0,${camel.version},g

Wir ergänzen folgende Dependency, damit das Maven Camel-Plugin den Spring-Kontext laden kann:

dependency.xml

   1:<dependency>
   2:        <groupId>org.apache.camel</groupId>
   3:        <artifactId>camel-spring</artifactId>
   4:        <version>${camel.version}</version>
   5:</dependency>
   6:

In den <build><plugins>-Abschnitt fügen wir diese Konfiguration ein:

plugin-eintrag-build.xml

   1:<plugin>
   2:        <groupId>org.apache.camel</groupId>
   3:        <artifactId>camel-maven-plugin</artifactId>
   4:        <version>${camel.version}</version>
   5:        <configuration>
   6:                <fileApplicationContextUri>src/main/webapp/WEB-INF/spring-context.xml</fileApplicationContextUri>
   7:        </configuration>
   8:</plugin>
   9:

Der Parameter <fileApplicationContextUri> ist einer der Gründe, warum Camel 1.5 benötigt wird (dieser Code wurde von den Camel-Entwicklern am 1. September 2008 eingebaut).

Außerdem fügen wir einen Reporting-Abschnitt ein:

plugin-eintrag-reporting.xml

   1:<reporting>
   2:        <plugins>
   3:                <plugin>
   4:                        <groupId>org.apache.camel</groupId>
   5:                        <artifactId>camel-maven-plugin</artifactId>
   6:                        <version>${camel.version}</version>
   7:                </plugin>
   8:        </plugins>
   9:</reporting>
  10:

Damit sind die Vorbereitungen abgeschlossen und wir können die Visualisierung der Route erstellen.

3. Visualisierung der Route mit GraphViz

Sobald Maven mit dem Kompilieren und Installieren von Camel 1.5-SNAPSHOT fertig ist, können wir mit mvn camel:dot eine graphische Repräsentation der Route erstellen. Dazu muss dot auf dem Rechner installiert sein (Doku dazu findet sich unter http://activemq.apache.org/camel/camel-maven-plugin.html und http://activemq.apache.org/camel/visualisation.html). Die graphische Darstellung der Route wird nach target/site/cameldoc generiert und sieht zunächst so aus:

Das ist weder sehr schön noch besonders praktikabel; aber da Camel GraphViz benutzt, kann man die Routen mit relativ wenig Aufwand nachbearbeiten. Die Datei target/site/cameldoc/routes.dot sieht etwa so aus:

routes.dot

   1:digraph CamelRoutes {
   2:
   3:node [style = "rounded,filled", fillcolor = yellow, fontname="Helvetica-Oblique"];
   4:
   5:subgraph cluster_0 {
   6:label = "Camel Routes";
   7:color = grey;
   8:style = "dashed";
   9:URL = "Camel Routes.html";
  10:
  11:
  12:node1 [
  13:label = "cxf:bean:helloEndpoint"
  14:tooltip = "cxf:bean:helloEndpoint"
  15:URL = "http://activemq.apache.org/camel/message-endpoint.html"
  16:];
  17:
  18:
  19:node2 [
  20:label = "Interceptor Ref"
  21:tooltip = "Interceptor Ref: Delegate(DeadLetterChannel[Delegate(TraceInterceptor[To[bean:myCamelProcessor]]), RecipientList[log:org.apache.camel.DeadLetterChannel?level=error], RedeliveryPolicy[maximumRedeliveries=5, initialRedeliveryDelay=1000, maximumRedeliveryDelay=60000, useExponentialBackOff=false, backOffMultiplier=2.0, useCollisionAvoidance=false, collisionAvoidanceFactor=0.15]])"
  22:URL = "http://activemq.apache.org/camel/interceptor-ref.html"
  23:shape = "box"
  24:];
  25:
  26:node1 -> node2 [
  27:];
  28:
  29:node3 [
  30:label = "bean:myCamelProcessor"
  31:tooltip = "bean:myCamelProcessor"
  32:URL = "http://activemq.apache.org/camel/message-endpoint.html"
  33:];
  34:
  35:node2 -> node3 [
  36:label = "Delegate(DeadLetterChannel[Delegate(TraceInterceptor[To[bean:myCamelProcessor]]), RecipientList[log:org.apache.camel.DeadLetterChannel?level=error], RedeliveryPolicy[maximumRedeliveries=5, initialRedeliveryDelay=1000, maximumRedeliveryDelay=60000, useExponentialBackOff=false, backOffMultiplier=2.0, useCollisionAvoidance=false, collisionAvoidanceFactor=0.15]])"
  37:];
  38:
  39:}
  40:
  41:}

Die Labels sind etwas geschwätzig; das läßt sich jedoch leicht ändern, indem man den Text großzügig kürzt. Außerdem kann man von http://activemq.apache.org/camel/images/eip/ die passenden Bildchen herunterladen und mit image = "<Pfad im Dateisystem> in die Grafik einarbeiten (GraphViz kann leider aktuell nicht mit HTTP-URLs umgehen). Die resultierende Datei sieht z.B. so aus:

routes.dot

   1:digraph CamelRoutes {
   2:
   3:node [fontname="Helvetica-Oblique", fontsize="10", fontcolor="red"];
   4:
   5:subgraph cluster_0 {
   6:label = "Camel Routes";
   7:color = grey;
   8:style = "dashed";
   9:URL = "Camel Routes.html";
  10:
  11:
  12:node1 [
  13:label = "cxf:bean:helloEndpoint"
  14:labelloc = "t"
  15:tooltip = "cxf:bean:helloEndpoint"
  16:URL = "http://activemq.apache.org/camel/message-endpoint.html"
  17:shape = "box"
  18:image = "images/MessageEndpointIcon.png"
  19:];
  20:
  21:
  22:node2 [
  23:label = "Interceptor Ref"
  24:tooltip = "TraceInterceptor"
  25:URL = "http://activemq.apache.org/camel/interceptor-ref.html"
  26:shape = "box"
  27:image = "images/WireTapIcon.png"
  28:];
  29:
  30:node1 -> node2 [
  31:label = "Logging"
  32:];
  33:
  34:node3 [
  35:label = "bean:myCamelProcessor"
  36:tooltip = "bean:myCamelProcessor"
  37:URL = "http://activemq.apache.org/camel/message-endpoint.html"
  38:shape = "box"
  39:image = "images/MessageTranslatorIcon.png"
  40:];
  41:
  42:node2 -> node3 [
  43:];
  44:
  45:}
  46:
  47:}

Und das Bildchen, das dabei herauskommt, kann sich schon eher sehen lassen.