Ein häufiges Anwendungsfeld für Script-Sprachen ist die Analyse von Text, und weil Groovy unter anderem auch als Script-Sprache einsetzbar ist, kann man erwarten, dass sich Groovy bei dieser Art von Anwendung als nützliche Erweiterung von Java beweist.

Stellen wir uns vor, wir wollten eine Fremdsprache erlernen und die wichtigsten Vokabeln auswendig lernen. Am wichtigsten sind sicher die Worte, die in einem Text am häufigsten vorkommen. Diese wollen wir mithilfe eines kleinen Groovy-Scripts ermitteln.

Der Einfachheit halber sei unser Text wie in Listing 1 in einem String gespeichert. Wer meint, das sei unrealistisch und man sollte solche Information lieber aus einem File lesen, kann die erste Zeile durch def text = new File('data.txt').text ersetzen. So einfach ist das in Groovy.

1. def text =
2. """
3. It takes two to program, two to program,
4. till you really get the feeling for your test case,
5. two to program, two to program,
6. through the bands of code.
7. """
9. def words = text.split(/\W/).grep(~/\w+/)
10. def frequencies = [:]
12. words.each { word ->
13. frequencies[word] = frequencies.get(word,0) + 1
14. }
15. def wordList = frequencies.keySet().toList()
16. wordList.sort { frequencies[it] }
18. def statistic = "\n"
19. wordList[-1..-4].each { word ->
20. statistic += word.padLeft(8) + ': '
21. statistic += frequencies[word] + "\n"
22. }
24. assert statistic ==
25. """
26. program: 4
27. two: 4
28. to: 4
29. the: 2
30. """

Als Text dient uns eine Abwandlung des Klassikers "It takes two to tango". Die vier häufigsten Worte in diesem Text lassen sich wie folgt in einer Statistik zusammenfassen:

1. assert statistic ==
2. """
3. program: 4
4. two: 4
5. to: 4
6. the: 2
7. """

Diese Groovy Assertion dient uns bei der Entwicklung als Unit-Test, der direkt Teil unseres Programms ist, was man auch als "Inline-Unit-Test" bezeichnet.

In typischer XP-Manier gehen wir rückwärts vor und überlegen uns, wie wir solch einen String erzeugen könnten. Angenommen, wir hätten eine nach Häufigkeit sortierte Wortliste und die Häufigkeit jedes Worts in einer Map gespeichert, dann könnten wir die letzen vier Worte in der Liste so in die Statistik einfließen lassen.

1. def statistic = "\n"
2. wordList[-1..-4].each { word ->
3. statistic += word.padLeft(8) + ': '
4. statistic += frequencies[word] + "\n"
5. }

Interessant sind hier die negativen Indizes, um das letzte respektive das viertletzte Element zu lokalisieren. Der damit beschriebene Range ist implizit "umgekehrt" (reversed), und die Subliste der letzen vier Elemente wird daher in umgekehrter Reihenfolge von each durchlaufen.

Die initiale Wortliste zu erzeugen ist ein Einzeiler. Wir spalten den Text an allen Nicht-Wort-Tokens (\W), und aus der resultierenden Liste behalten wir nur die Einträge, die ausschließlich aus Wort-Tokens bestehen und länger als ein Token sind (\w+). Die Map der Häufigkeiten ist initial leer und wird gefüllt, indem über alle Worte in der Liste iteriert und der jeweilige Wert in der Map inkrementiert wird. Bei der Ermittlung des Werts sorgt die get(word,0)-Methode dafür, dass unbekannte Worte die Häufigkeit 0 haben. Zu guter Letzt sortieren wir die Worte nach der ermittelten Häufigkeit.

1. def words = text.split(/\W/).grep(~/\w+/)
3. def frequencies = [:]
4. words.each { word ->
5. frequencies[word] = frequencies.get(word,0) + 1
6. }
7. def wordList = frequencies.keySet().toList()
8. wordList.sort { frequencies[it] }

Die sort-Methode ist erstaunlich flexibel. Sie wird optional mit einer Closure parametrisiert, die beim Sortieren für den Elementvergleich herangezogen wird. Das kann auf zwei Arten geschehen, je nachdem, ob die Closure ein oder zwei Parameter deklariert. Bei einem Parameter (in unserem Fall implizit der it-Parameter) wird die Closure auf beide zu vergleichenden Elemente angewendet, und die Resultate werden verglichen. Bei zwei Parametern werden beide Elemente an die Closure übergeben und diese wirkt als Comparator, z.B. list.sort{a,b-> a<=>b}. In unserem Fall können wir damit sehr leicht die Sortierlogik auf Inhalte der Häufigkeits-Map abstützen, obwohl wir die Wortliste, also eine ganz andere Datenstruktur, sortieren.

Eine vergleichbare Implementierung in reinem Java ist massiv aufwendiger. Groovy unterstützt uns hier durch die leichte Verwendbarkeit von regulären Ausdrücken (split, grep), den leichtgewichtigen Umgang mit den Datentypen String, List, und Map sowie den zusätzlichen Methoden (get, sort) aus dem GDK. Groovy ist aber beileibe nicht auf textlastige Applikationen beschränkt. Man kann auch sehr leicht clientseitige GUIs bauen und mit Fern-Datenbeständen verbinden.

Rich Client für flickr

Als Nächstes bauen wir einen Bildbetrachter für die heute interessantesten Bilder bei flickr [1]. flickr hat seine eigene Meinung davon, welche Bilder interessant sind, und wir werden uns dieser Meinung anschließen. Wer sich bei flickr registriert, kann mithilfe seines persönlichen Schlüssels die URLs der interessantesten Bilder mittels eines REST-Services ermitteln. Diese wollen wir mithilfe eines minimalen Swing User Interface anzeigen, und zwar so, dass nach einem Klick auf das Bild das nächste Bild angezeigt wird. Abbildung 1 gibt einen Eindruck, wie dieses Interface aussehen kann. Sie werden natürlich andere Bilder sehen, denn diese ändern sich jeden Tag.

1. import groovy.swing.SwingBuilder
2. import javax.swing.*
4. key = 'KEY HIER EINTRAGEN'
5. counter = 1
7. def updateButton(button) {
8. counter++
9. def apiUrl = "http://www.flickr.com/services/rest/?" +
10. "method=flickr.interestingness.getList&per_page=1&" +
11. "page=$counter&api_key=$key"
12. def rsp = new XmlParser().parse(apiUrl)
13. def photo = rsp.photos.photo[0]
14. def imageUrl = "http://static.flickr.com/" +
15. "${photo.'@server'}/${photo.'@id'}_${photo.'@secret'}_m.jpg"
16. button.icon = new ImageIcon(imageUrl.toURL())
17. button.text = photo.'@title'
18. return button
19. }
21. def frame = new SwingBuilder().frame(
22. title: 'Groovy Flickr Viewer',
23. defaultCloseOperation: WindowConstants.EXIT_ON_CLOSE) {
24. updateButton( button (
25. horizontalTextPosition: SwingConstants.CENTER,
26. verticalTextPosition: SwingConstants.BOTTOM,
27. actionPerformed: { event -> updateButton(event.source) }
28. ))
29. }
30. frame.pack()
31. frame.visible = true

Listing 1 enthält die vollständige Lösung. Fangen wir mit der Beschreibung des Swing GUI an: Groovys SwingBuilder erlaubt eine sehr einfache Beschreibung eines Frame-Objekts, das genau einen Button enthält. Das Gerüst sieht so aus:

1. new SwingBuilder().frame {
2. button()
3. }

Damit das Ganze etwas ansprechender aussieht, werden die Builder-Methoden frame und button noch mit Argumenten für Titel, Positionierung etc. aufgerufen [2]. Speziell ist das Attribut actionPerformed. Es wird mit einer Closure initialisiert, die fortan als ActionListener für diesen Button registriert ist. Sie ruft die updateButton-Methode auf und übergibt den Event Source, also eine Referenz, auf den Button selbst. Das Event-Objekt wird beim Auslösen des Events an die Closure geschickt.

Die Methode updateButton setzt das Icon des Buttons auf das aktuelle flickr-Bild und den Button-Text auf den Text des Bildes. Das ist bei der initialen Darstellung des GUI zu tun und anschließend bei jedem Klick auf den Button. Damit ist das User Interface fertig.

Die Beschaffung der Bild-Informationen über den REST-Service ist denkbar einfach. Wir arbeiten mit jeweils nur einem Bild pro Seite, und damit wird die Seitennummer zur Bildnummer. Beides lässt sich in dem URL als Parameter angeben. Groovys XML Parser übernimmt den Verbindungsaufbau, das Empfangen des Ergebnisses und natürlich das Zerlegen in Objekte. Mithilfe eines GPath-Ausdrucks lokalisieren wir das erste (und einzige) <photo/>-Element. Von diesem benötigen wir die Attribute server, id, secret und title, um den effektiven Bild-URL zu ermitteln und den Button entsprechend zu befüllen.

Damit ist unsere zweite kleine Applikation fertig. Sie kombiniert verschiedene Aspekte der Groovy-Sprache und Laufzeitumgebung zu einer idiomatischen Lösung: das Builder Pattern, GStrings, um die URLs zu bauen, Groovy Beans inklusive Event Handling, XML plus Remoting und GPath sowie die Verwendung bestehender Java-Funktionalität (ImageIcon), und das Ganze als ausführbares Script, das keiner vorherigen Kompilation bedarf.

Groovy SOAP

REST-Services sind schön und gut und gerade in der dynamischen Welt der Script-Sprachen oftmals eine angemessene Lösung. Im Bereich der kommerziellen Softwareentwicklung sind typorientierte Protokolle allerdings stärker verbreitet, mit SOAP als dem bekanntesten Vertreter.

Groovy ist für die Arbeit mit SOAP-Services bestens geeignet, sowohl auf der Client- wie auch auf der Serverseite, und erleichtert nicht nur das Testen und Prototyping von Applikationen, sondern ist auch reif für den produktiven Einsatz. Schon mit den üblichen "Bordmitteln" von Groovy kann man gut mit Web Services arbeiten [4], noch eleganter wird das Ganze jedoch mit dem Einsatz des GSOAP-Moduls, das man auf der Groovy-Website findet [3].

Mithilfe dieses Moduls kann man von Groovy aus sehr einfach einen Web Service aufrufen. Das momentane Wetter in Hamburg kann man z.B. so anfragen:

1. import groovy.net.soap.SoapClient
3. def url = 'http://www.webservicex.net/WeatherForecast.asmx?WSDL'
4. def proxy = new SoapClient(url)
5. def result = proxy.GetWeatherByPlaceName('Hamburg')
7. println result.latitude
8. println result.details.weatherData[0].weatherImage

und bekommt das Ergebnis 40.5487976 http://www.nws.noaa.gov/weather/images/fcicons/fg.jpg Einen SOAP-Service auf Serverseite bereitzustellen ist genauso einfach. In Groovy braucht man dafür keinerlei Definitionen bereitzustellen. Diese werden automatisch erzeugt. Es reicht, die Serviceimplementierung als einfaches Script anzulegen, zum Beispiel für einen Service, der Rechenoperationen zur Verfügung stellt, in etwa so:

1. double add(double op1, double op2) {
2. return (op1 + op2)
3. }
5. double square(double op1) {
6. return (op1 * op1)
7. }

Man braucht noch nicht einmal eine Klassendefintion und muss dieses Script auch nicht kompilieren. Es ist ausreichend, diesen Script-Code in der Datei MathService.groovy zu speichern, damit sie vom Server wie folgt verwendet werden kann:

1. import groovy.net.soap.SoapServer
2. def server = new SoapServer("localhost", 6990)
3. server.setNode("MathService")
4. System.out.println("start Math Server")
5. server.start()

Schneller und einfacher ist der Umgang mit SOAP kaum denkbar. GSOAP ist darüber hinaus ein Beispiel dafür, wie leicht man mit Groovy ein extrem einfaches API über zugrunde liegende Fremdkomponenten legen kann. GSOAP basiert auf XFire, ist aber deutlich einfacher zu verwenden. Analoges gilt für Groovys Scriptom Modul, dass Visual Basic-ähnlichen Zugriff auf Windows-Komponenten erlaubt und auf der Java-COM Bridge (jacob) basiert. In all diesen Fällen ist es das Groovy-Meta-Objekt-Protokoll, mit dessen Hilfe am API Methoden dynamisch verfügbar gemacht werden.

... und so geht's weiter

Groovy ermöglicht an vielen Stellen einen einfachen und direkten Zugang zu bestehenden Java-Funktionalitäten. Dies gilt vor allem auch für Javas reichhaltige Unterstützung für Webapplikationen, das Spring Framework und OR Mapping z.B. mit Hibernate.

Wir haben hier drei Anwendungsbeispiele von Groovy gesehen, aber natürlich gibt es eine unerschöpfliche Menge weiterer Anwendungen. Groovy ist an keine Anwendungsdomäne gebunden und eignet sich für alle Arten dynamischer Programmierung. Viel Spaß beim Einsatz von Groovy und dem Erforschen neuer und spannender Einsatzgebiete!

Links & Literatur

1. http://www.flickr.com
2. http://groovy.codehaus.org