Hello Akka

Einstieg
Vorbereitungen
Das Programm HelloAkka
Complilieren und Ausführen von Hello Akka
Akka in einer bestehenden Anwendung

Einstieg

Akka ist zwar keine Programmiersprache, aber trotzdem bietet es sich an ein "Hello - World" - Programm zu schreiben. Ziel dieses Programms (hier "HelloAkka" genannt) ist es, mit möglichst geringen Aufwand Akka in Aktion zu erleben.

Entwickeln wollen wir HelloAkka mit einem simplen Texteditor (z.B. gedit, Notepad ...) und einer Kommandozeile zum compilieren und ausführen.

Weiter unten wird in diesem Kapitel noch die Programmierung eines Actor - Systems in eine bestehende Anwendung MyApplication vorgestellt.

Alles, was in diesem Kapitel beschrieben wird, dient nicht der Erklärung von Akka. Es werden lediglich Wege aufgezeigt, Akka in Verbindung mit Scala in Aktion zu erleben.

Vorbereitungen

In diesem Artikel setzen wir voraus, dass Java (in der Version 1.6 oder höher) und Scala (in einer 2.10er Version) auf dem Entwicklungsrechner installiert sind und das deren "bin-Verzeichnisse" sich im PATH befinden. Diese Voraussetzungen ermöglicht es uns, HelloAkka von der Kommandozeile aus zu compilieren und auszuführen.

Als ersten Schritt downloaden wir Akka aus dem Download - Bereich Flagge Großbritanien der Akka - Homepage . Wir benötigen hier die Standalone - Version von Akka, wobei in diesem einführenden Artikel die Version 2.2.3 (akka-2.2.3.zip) Anwendung findet.

Nach dem Download entpacken wir die Datei in ein beliebiges, temporäres Verzeichnis, welches später wieder gelöscht werden kann. Im Anschluss erzeugen wir ein Entwickungsverzeichnis (beliebig) in dem wir die zur Entwicklung benötigten Dateien ablegen.

In realen Projekte ist es sicher nicht Sinnvoll Quelltextdateien, Binärdateien und Bibliotheksdateien in ein und demselben Verzeichnis abzulegen. Für unser Einstiegsbeispiel wollen wir jedoch, der Einfachheit halber, diesen Weg wählen. Sammeln wir nun im ersten Schritt die benötigten Bibliotheksdateien (jars) ein und kopieren diese (ohne Verzeichnisunterstruktur) in unser Entwicklungsverzeichnis. Die benötigten Dateien sind aus der entpackten Akka Verzeichnisstruktur sind:

lib/scala-library.jar
lib/akka/akka-actor_2.10-2.2.3.jar
lib/akka/config-1.0.2.jar

Das Programm `HelloAkka`

Die notwendigen Vorarbeiten haben wir abgeschlossen. Programmieren wir nun unser HelloAkka Programm (siehe folgenden Quelltext) mit einem beliebigen Texteditor (z.B. gedit, Notepad) und speichern die Quelltextdatei im Entwicklungsverzeichnis unter dem Namen "HelloAkka.scala" ab.

import akka.actor.Actor
import akka.actor.Props

class HelloAkka extends Actor {
  
  override def preStart(): Unit = {
    val hello = context.actorOf(Props[Hello], "hello")
    hello ! "Hi" 
  }
  
  def receive = {
    case _ => context.stop(self)
  }
}
  
class Hello extends Actor {
  def receive = {
    case _ => println("Hi from Akka Actor!")
    sender ! ()
  }
}

itmapa.de - X2H V 0.21

Compilieren und Ausführen von "Hello Akka"

Die Vorbereitungen und die Definition des Quelltextes sind abgeschlossen. Bleibt uns also nur noch (sofern wir alles richtig gemacht haben) unser Programm zu compilieren und auszuführen.

Öffnen wir nun ein Terminal (Konsole, DOS-BOX, ...) und wechseln in das Entwicklungsverzeichnis. Um das Compilieren durchzuführen geben wir nun folgende Anweisung ein:

scalac ./HelloAkka.scala

Nun können wir unser erstes Akka - Programm in Aktion sehen. Dazu geben wir im Terminal unter Windows folgenden Befehl ein:

java -classpath .;akka-actor_2.10-2.2.3.jar;config-1.0.2.jar;scala-library.jar akka.Main HelloAkka

Unter Linux ersetzen wir die Semikolon durch einen Doppelpunkt zur Angabe des "Classpath".

java -classpath .:akka-actor_2.10-2.2.3.jar:config-1.0.2.jar:scala-library.jar akka.Main HelloAkka

Als Ergebnis erhalten wir den gewünschten Gruß von Akka im Terminal.

Hi from Akka Actor!
[INFO] [10/15/2013 09:51:26.902] [Main-akka.actor.default-dispatcher-4] [akka://Main/user/app-terminator] application supervisor has terminated, shutting down

Akka in einer bestehenden Anwendung

Nicht immer haben wir das Glück, eine Anwendung vom grünen Gras aus neu zu entwickeln. Es wird vielmehr ein seltenerer Fall sein. In den meisten Fällen arbeiten wir doch an bestehenden Projekten, die gehegt und gepflegt sein wollen. Möchten wir diese Projekte nun mit Akka aufwerten, können wir zumeist nicht einen neuen Einstiegspunkt mit Akka Aktoren ins Programm wählen.

Das nächste Beispielprogramm zeigt, wie wir an einem frei definierbaren Punkt (im Beispiel direkt in der main - Methode ein Akka - System anlegen können um einen bestimmten Teil des Programms mit Akka zur asynchronen Ausführung bringen können.

import akka.actor._

class MyActor extends Actor {

  override def receive = {
    case Messenger.ConcreteMessage(message: String) => {
      println("The message is: "+message)
    }
    case Messenger.MesseageFinished => {
      println("Stop the actor")
      context.stop(self)
    }
  }
}

object Messenger {   
  case class ConcreteMessage(message: String)
  case object MesseageFinished
}

object MyApplication {
  def main(args: Array[String]) {
    val system = ActorSystem("Main")
    val ac = system.actorOf(Props(classOf[MyActor]))
    ac ! Messenger.ConcreteMessage("Hohoho")
    ac ! Messenger.MesseageFinished
    
    Thread.sleep(1000)    
    sys.exit(0)
  }
}

itmapa.de - X2H V 0.21

Compilieren können wir das obige Programm mit dem Befehl scalac *.scala. Nachdem das Programm compiliert wurde können wir unsere Anwendung wie gewohnt von der Befehlszeile starten (Windows Anwender ersetzen den Doppelpunkt durch ein Semikolon).

scala -cp .:akka-actor_2.10-2.2.3.jar:config-1.0.2.jar:scala-library.jar MyApplication

Bitte beachten: Wir benutzen hier scala statt java zum Starten der Anwendung.

Die Ausführung des Programms führt zu folgender Ausgabe auf der Systemausgabe:

The message is: Hohoho
Stop the actor

Zurück

Inhalt

Weiter