Groovy - Rocks or Not?

von und mit Thorsten Kamann

Copyright 2006 Thorsten Kamann

Einleitung
Getting Started
Embedding
Die Syntax
Groovy Highlights
XML-Processing, Markup, GPath, Groovy Beans, RegEX...
Module
Grails, Gorm, Scriptom...
Testing
IDE-Support
Zusammenfassung/Links


Einle itung


Was ist Scripting?
Skriptsprachen sind Programmiersprachen, die vor allem für
kleine, überschaubare Programmieraufgaben gedacht sind


Was ist Scripting?
Kein Deklarationszwang für Variablen


Was ist Scripting?
automatische Speicherverwaltung


Was ist Scripting?
automatische Speicherverwaltung
werden in der Regel ohne getrennte Übersetzungsphase
ausgeführt (d. h. sie werden „interpretiert“)


Was ist Groovy?
Eine dynamische Sprache


Was ist Groovy?
Inspiriert von Ruby, Python, Smalltalk


Was ist Groovy?
Entwickelt für die Java-Plattform


Was ist Groovy?
Um sie Java-Entwicklern zugänglich zu machen


Was ist Groovy?
Um möglichst viel der Java-Syntax wieder verwenden zu
können


Was ist Groovy?
können
Um eine einfache Anbindung zu Enterprise-Systemen
anzubieten


Was ist Groovy?
können
Um eine einfache Anbindung zu Enterprise-Systemen
anzubieten
Das Ergebnis des JSR 241: The Groovy Programming Language


Ge tting
S ta rte d


Getting Started
Download des aktuellen Release von
http://groovy.codehaus.org


Getting Started
Entpacken des Archivs


Getting Started
Setzen der Umgebungsvariable GROOVY_HOME


Getting Started
Hinzufügen von %GROOVY_HOME%bin zur PATH-Variable


Getting Started
Hinzufügen von %GROOVY_HOME%bin zur PATH-Variable
Starten von groovyConsole und Eingabe von
println „Hallo Welt“
mit anschliessendem STRG-R


Getting Started


Embe dding


Embedding
Groovy kann auf 4 verschiedene Arten in Java-Anwendungen
eingebunden werden


Embedding mit dem BSF
Ist ein allgemeine Möglichkeit, jede beliebige Scriptsprache
in Java-Anwendungen einzubinden


Embedding mit dem BSF
Ist ein allgemeine Möglichkeit, jede beliebige Scriptsprache
in Java-Anwendungen einzubinden
Groovy bietet aber leichtgewichtigere und leistungsfähigere
Möglichkeiten der Einbindung


Embedding mit GroovyShell
GroovyShell bietet die Möglichkeit des Ein- und Auslesens
von Variablen mittels des Binding-Objekts


Embedding mit GroovyShell
GroovyShell bietet die Möglichkeit des Ein- und Auslesens
von Variablen mittels des Binding-Objekts

Binding binding = new Binding();
binding.setVariable(quot;fooquot;, new Integer(2));
GroovyShell shell = new GroovyShell(binding);

Object value = shell.evaluate(
quot;println 'Hello World!'; x = 123; return foo * 10quot;);
assert value.equals(new Integer(20));
assert binding.getVariable(quot;xquot;).equals(new Integer(123));


Embedding mit GroovyClassLoader
Der GroovyClassLoader lädt Groovy-Klassen dynamisch und
ermöglicht den direkten Zugriff auf deren Methoden



ClassLoader parent = getClass().getClassLoader();
GroovyClassLoader loader = new
GroovyClassLoader(parent);
Class groovyClass = loader.parseClass(
new File(quot;script.groovyquot;));
GroovyObject groovyObject =
(GroovyObject) groovyClass.newInstance();
Object[] args = {};
groovyObject.invokeMethod(quot;runquot;, args);



GroovyClassLoader gcl = new GroovyClassLoader();
Class clazz = gcl.parseClass(
myStringwithGroovyClassSource, quot;SomeName.groovyquot;);
Object aScript = clazz.newInstance();
MyInterface myObject = (MyInterface) aScript;
myObject.interfaceMethod();


Embedding mit GroovyScriptEngine
Dies ist die leistungsfähige Möglichkeit um Groovy-Skripte
auszuführen. Das Binding-Objekt befüllt dabei die Skripte
mit Daten


Embedding mit GroovyScriptEngine
Dies ist die leistungsfähige Möglichkeit um Groovy-Skripte
auszuführen. Das Binding-Objekt befüllt dabei die Skripte
mit Daten

String[] roots = new String[] {quot;/my/groovy/script/pathquot;};
GroovyScriptEngine gse = new GroovyScriptEngine(roots);
Binding binding = new Binding();
binding.setVariable(quot;inputquot;, quot;worldquot;);
gse.run(quot;hello.groovyquot;, binding);
System.out.println(binding.getVariable(quot;outputquot;));


Embedding mit Ant
ANT-Task, mit dem eine beliebige Anzahl von Groovy-
Skripten ausgeführt werden können


Embedding mit Ant
GroovyC-Task, der Groovy-Skripte (Klassen) zu Java
Bytecode kompiliert


Embedding mit Ant
Bytecode kompiliert
Erstellen von Ant-Tasks mit Groovy und dem Markup-Builder


Embedding mit Ant
Bytecode kompiliert
Erstellen von Ant-Tasks mit Groovy und dem Markup-Builder
Erzeugen von Ant-Skripten


Embedding mit Maven 2
Maven 2 wird offiziell mittels des Maven2-Ant-Plugins
unterstützt


unterstützt
Es existiert aber ein Groovy-Maven-Plugin, mit dem
beliebige Groovy-Skripte ausgeführt werden können


unterstützt
In der Sandbox von http://mojo.codehaus.org/
existieren bereits Maven-Tools für direkte Unterstützung
von Groovy


unterstützt
von Groovy
Groovy-Compiler


unterstützt
von Groovy
Groovy-Compiler
Groovy-Archetype


unterstützt
von Groovy
Groovy-Compiler
Groovy-Archetype
Tools, um Maven-Plugins mit Groovy zu entwickeln

Embedding in Windows
Groovy kann direkt von der Eingabeaufforderung oder über
Start-->Ausführen mittels
groovy script.groovy [arguments]
ausgeführt werden


Embedding in Windows
Groovy kann direkt von der Eingabeaufforderung oder über
Start-->Ausführen mittels
ausgeführt werden
Alternativ kann über den Dialog
Ordneroptionen-->Dateitypen die Extension
*.groovy an groovy.bat gebunden werden.


Embedding in Linux
Groovy kann direkt von der Konsole mittels
ausgeführt werden


Embedding in Linux
Groovy kann direkt von der Konsole mittels
ausgeführt werden
Alternativ kann in die 1. Zeile eines Groovy-Skripts
#!/usr/bin/env groovy
eingefügt werden. So kann mit
chmod +x script.groovy
./script.groovy
das Skript ausgeführt werden


Die
S ynta x

Die Syntax: Closures
Closures
sind anonyme Codeblöcke


Closures
geben einen Wert zurück


Closures
referenzieren und verwenden Variablen


Closures
werden oft wie Anonyme Inner Classes in Java benutzt


Closures
werden erst ausgeführt, wenn call() auf der Closure
aufgerufen wird


Closures
werden erst ausgeführt, wenn call() auf der Closure
aufgerufen wird
können an eine Variable gebunden werden


Die Syntax: Closures (Beispiele)
Beispiele:

{ item++ }


Beispiele:

{ name -> println name }


Beispiele:

{String x, int y -> println quot;hey $x the value is $yquot;}


Beispiele:

{ reader ->
while (true) {
line = reader.readLine()
}
}


Die Syntax – Collections (Listen)
Listen erzeugen immer eine Instanz von java.util.List



def list = [5, 6, 7, 8]
assert list.get(2) == 7
assert list instanceof java.util.List



def emptyList = []
assert emptyList.size() == 0
emptyList.add(5)
assert emptyList.size() == 1


Die Syntax – Collections (Ranges)
Ranges erzeugen Listen mit sequentiellen Werten


Es gibt inklusive und exklusive Ranges



def range = 5..8
assert range.contains(6)



def range = 5..<8
assert !range.contains(8)


Die Syntax: Collections (Maps)
Maps basieren auf einer Implementierung von java.util.Map



def map = [name:quot;Gromitquot;, likes:quot;cheesequot;, id:1234]
assert map.get(quot;namequot;) == quot;Gromitquot;
assert map[quot;namequot;] == quot;Gromitquot;



def emptyMap = [:]
emptyMap.foo = 5
assert emptyMap.foo == 5


Die Syntax: Collections (Expando)
Expandos ermöglichen die Erzeugung von dynamischen
Objekten


Die Syntax: Collections (Expando)
Expandos ermöglichen die Erzeugung von dynamischen
Objekten

def player = new Expando()
player.name = quot;Peterquot;
player.greeting = { quot;Hello, my name is $player.namequot; }
assert player.greeting() == quot;Hello, my name is Peterquot;


Die Syntax: Collections (each)
Iterator mittels einer Closure


Die Syntax: Collections (each)
Iterator mittels einer Closure

[1, 2, 3].each { item -> print quot;${item}-quot; }


Die Syntax: Collections (collect)
Erzeugt eine neue Liste mit dem Ergebnis der Closure


Die Syntax: Collections (collect)
Erzeugt eine neue Liste mit dem Ergebnis der Closure

def value = [1, 2, 3].collect { it * 2 }
assert value == [2, 4, 6]


Die Syntax: Collections (find)
Gibt das erste Element einer Collection zurück, welches der
Expression in der Closure entspricht


Die Syntax: Collections (find)
Gibt das erste Element einer Collection zurück, welches der
Expression in der Closure entspricht

def value = [1, 2, 3].find { it > 1 }
assert value == 2


Die Syntax: Collections (findAll)
Gibt eine Collection mit allen Elementen, die denen der
Expression in der Closure entsprechen, zurück


Die Syntax: Collections (findAll)
Gibt eine Collection mit allen Elementen, die denen der
Expression in der Closure entsprechen, zurück

def value = [1, 2, 3].findAll { it > 1 }
assert value == [2, 3]


Die Syntax: Collections (inject)
Fügt einen zusätzlichen Wert zu einer Iteration hinzu


Die Syntax: Collections (inject)
Fügt einen zusätzlichen Wert zu einer Iteration hinzu

def value = [quot;Javaquot;, quot;C#quot;, quot;C++quot;, quot;VBquot;]
.inject(quot;Languages: quot;){str, item -> str+quot; quot;+item}
assert value == „Languages: Java C# C++ VB“


Die Syntax: Collections (every)
Gibt true zurück, wenn alle Werte in der Collection der
Expression in der Closure entsprechen



def value = [1, 2, 3].every { it < 5 }
assert value



def value = [1, 2, 3].every { item -> item < 3 }
assert !value


Die Syntax: Collections (any)
Gibt true zurück, wenn mindestens ein Wert in der
Collection der Expression in der Closure entspricht



def value = [1, 2, 3].any { item -> item > 3 }
assert value == false



def value = [1, 2, 3].any { it > 2 }
assert value


Die Syntax: Collections (max/min)
Gibt den maximalen Wert einer Collection zurück. Die
Objekte in dieser Collection müssen Comparable sein



def value = [9, 4, 2, 10, 5].max()
assert value == 10



def value = [9, 4, 2, 10, 5].min()
assert value == 2



def value = ['x', 'y', 'a', 'z'].min()
assert value == 'a'


Die Syntax: Collections (join)
Fügt einen String zu den Werten einer Collection hinzu


Die Syntax: Collections (join)
Fügt einen String zu den Werten einer Collection hinzu

def value = [1, 2, 3].join('-')
assert value == '1-2-3'


Die Syntax: Collections (Beispiele)
Ranges verwenden, um Teile von Listen zu extrahieren

def list = 100..200
def sub = list[1, 3, 20..25, 33]
assert sub == [101, 103, 120, 121, 122, 123, 124, 125, 133]


Rückwärts gerichtete Ranges

def text = quot;nice cheese gromit!quot;
def name = text[3..1]
assert name == quot;eciquot;


Negative Ranges – Index beginnt beim letzten Zeichen

def x = text[-1]
assert x == quot;!quot;


Negative Ranges – Index beginnt beim letzten Zeichen


def name = text[-7..-2]
assert name == quot;gromitquot;


Die Syntax: Looping (while)
Groovy unterstützt das aus Java bekannte while{..}
Konstrukt


Die Syntax: Looping (while)
Groovy unterstützt das aus Java bekannte while{..}
Konstrukt

def x = 0
def y = 5
while ( y-- > 0 ) {
x++
}
assert x == 5


Die Syntax: Looping (for)
Die for-Schleife ist einfacher und arbeitet mit Arrays und
Collections


Collections

def x = 0
for ( i in 0..9 ) {
x += i
}
assert x == 45


Collections

x = 0
for ( i in [0, 1, 2, 3, 4] ) {
x += i
}
assert x == 10


Die Syntax: Looping (each)
each ist eine Closure. Dadurch ist eine sehr kompakte
Abarbeitung von Schleifen möglich



def stringList = [quot;javaquot;, quot;pythonquot;, quot;rubyquot;, quot;c#quot;, quot;groovyquot;]
stringList.each() { print quot; ${it}quot; };
// java python ruby c# groovy



def stringMap = [quot;Suquot; : quot;Sundayquot;, quot;Moquot; : quot;Mondayquot;]
stringMap.each() { key, value ->
println quot;${key} == ${value}quot; };
// Su == Sunday
// Mo == Monday


Die Syntax: Looping (eachWithIndex)
Unterscheidet sich vom Looping mit each dadurch, dass ein
Index mitgeführt wird



def stringList = [quot;javaquot;, quot;pythonquot;, quot;rubyquot;, quot;c#quot;, quot;groovyquot;]
stringList.eachWithIndex() {
obj, i -> println quot; ${i}: ${obj}quot; };
// 0: java 1: python 2: ruby 3: c# 4: groovy



def stringMap = [quot;Suquot; : quot;Sundayquot;, quot;Moquot; : quot;Mondayquot;]
stringMap.eachWithIndex() {
obj, i -> println quot; ${i}: ${obj}quot; };
// 0: Su=Sunday
// 1: Mo=Monday


Die Syntax: Conditions (if...else)
Groovy unterstützt die aus Java bekannten if...else
Konstrukte


Die Syntax: Conditions (if...else)
Groovy unterstützt die aus Java bekannten if...else
Konstrukte

def x = (y > 1) ? quot;workedquot; : quot;failedquot;

if (x){
...
}else{
...
}


Die Syntax: Conditions (switch)
Das switch-Statement unterstützt Klassenvergleiche,
Inhalte von Collections (Lists, Ranges), reguläre Ausdrücke
und equals Vergleiche


Die Syntax: Conditions (switch)
Das switch-Statement unterstützt Klassenvergleiche,
Inhalte von Collections (Lists, Ranges), reguläre Ausdrücke
und equals Vergleiche

switch ( x ) {
case („foo“): ...
case (20..30): ...
case (Integer): ...
default: ...
}


XML
Proc e s s ing


XML-Processing
Groovy bietet reichhaltige Unterstützung für das XML-
Processing


XML-Processing


XML-Processing
Processing
Gpath (Xpath) Ausdrücke erlauben schnelle Navigation im
XML-Dokument


XML-Processing
Processing
Gpath (Xpath) Ausdrücke erlauben schnelle Navigation im
XML-Dokument
DOMCategory stellt mächtige Navigationselemente zur
Verfügung


XML-Processing
DOM Klasse Methode Beschreibung
Element .'child' .getElementsByTagName('child')
Element .child .getElementsByTagName('child')
Element .'*' .getElementsByTagName('*')
Element .'@attr' .getAttribute('attr')
Element .text() .firstChild.nodeValue
Element .name() .nodeName
Element .parent() .parentNode
Element .children() .childNodes
NodeList .size() .length
NodeList .list()
NodeList [n] .item(n)
NodeList .text() .collect{ it.text() }
NodeList .child .getElementsByTagName('child')


XML-Processing mit XML-Parser
def records = new
XmlParser().parseText(XmlExamples.CAR_RECORDS)

def allRecords = records.car.size()
assert allRecords == 3

def allNodes = records.depthFirst().size()
assert allNodes == 10


XML-Processing mit DOMCategory
def reader = new StringReader(XmlExamples.CAR_RECORDS)
def doc = DOMBuilder.parse(reader)
def records = doc.documentElement

use (DOMCategory) {
assert 9 == records.'*'.size()
def cars = records.'car'
assert cars[0].parent() == records
assert 3 == cars.size()
}


Groovy
Ma rkup


GroovyMarkup
Groovy bietet Unterstützung für die Arbeit mit Markup-
Languages:
XML, HTML, SAX, W3C DOM, Ant Tasks, Swing UI's


GroovyMarkup
Languages:
GroovyMarkup bietet eine einheitliche Schnittstelle
Elemente sind Closures
Attribute sind Maps


GroovyMarkup
Languages:
GroovyMarkup bietet eine einheitliche Schnittstelle
Elemente sind Closures
Attribute sind Maps
Vollständige Integration anderer Groovy-Features
Collections, Arrays, Conditions, ...


GroovyMarkup (Beispiel)
builder = new MarkupBuilder(writer)
builder.person() {
name(first:quot;Meganquot;, last:quot;Smithquot;) {
age(quot;33quot;)
}
}


GroovyMarkup (Beispiel)
builder = new MarkupBuilder(writer)
builder.person() {
name(first:quot;Meganquot;, last:quot;Smithquot;) {
age(quot;33quot;)
}
}

<person>
<name first=“Megan“ last=“Smith“>
<age>33</age>
</name>
</person>


GPath

GPath
Ist eine Expression-Language für Daten mit Baumstrukturen


GPath
Implementierung für XML


GPath
Pfade zu einem Element können spezifiziert werden
a.b.c findet alle <c>-Elemente innerhalb aller <b>
innerhalb aller <a>


GPath
Pfade zu einem Element können spezifiziert werden
a.b.c findet alle <c>-Elemente innerhalb aller <b>
innerhalb aller <a>
Auch Attribute können spezifiziert werden
a[quot;@hrefquot;] -> findet alle href-Attribute in <a>-
Elementen
a.@href -> eine Alternativ-Syntax dazu


Groovy
Be a ns

GroovyBeans
GroovyBeans sind wie JavaBeans, nur einfacher zu
definieren


GroovyBeans
definieren
Customer.groovy:
class Customer {
int id
String name
}


GroovyBeans
definieren
Customer.groovy: Customer.java:
class Customer { public class Customer {
int id private int id = 0;
String name private String name;
}
public int getId(){
return id;
}

public void setId(int id){
this.id = id;
}
...
}

GroovyBeans
Regeln für Properties:
Wenn eine Property als private gekennzeichnet ist,
wird ein Java Field benutzt, um diese Property zu
repräsentieren


GroovyBeans
Wenn eine Property als public oder protected
gekennzeichnet wird, werden Getter- und Setter-
Methoden mit der gleichen Sichtbarkeit und ein Feld mit
der Sichtbarkeit private auf Bytecode-Ebene erzeugt


GroovyBeans
Wenn keine Getter- oder Setter-Methoden für Properties
mit der Sichtbarkeit public oder protected deklariert
wurden, werden fehlende Getter- und Setter-Methoden
mit der gleichen Sichtbarkeit automatisch auf Bytecode-
Ebene erzeugt


GroovyBeans
Mit selbst deklarierten Getter- und Setter-Methoden
können die von der Groovy-Runtime generierten
Methoden überschrieben werden


Re gEx


Reguläre Ausdrücke
Reguläre Ausdrücke werden von Groovy nativ unterstützt


Die ~quot;...quot; Expression wird automatisch in ein Java-Pattern
Objekt kompiliert


Objekt kompiliert
=~ Create Matcher


Objekt kompiliert
assert quot;cheesecheesequot; =~ /cheese/


Objekt kompiliert
==~ Matches Regex


Objekt kompiliert
==~ Matches Regex
assert quot;cheesecheesequot; ==~ /.*ees.*/


Gra ils


Grails
Grails ist ein Webapplication-Framework


Grails
Es vereinfacht die Entwicklung von Webanwendungen durch
das Coding By Convention-Paradigma


Grails
die Verwendung von Spring/Hibernate


Grails
die Verwendung von Spring/Hibernate
eigene GSP (Groovy Server Pages) mit dynamischen
TagLibraries


Grails (Screenshots)


Grails
Die zentrale Komponente ist die Domänenklasse (Entity)


Grails
Daraus können der Controller und die Views für eine CRUD-
Anwendung generiert werden


Grails
Anbindung an Enterprise-Systeme kann über SpringBeans
erfolgen


Grails
erfolgen
Als View-Technologie ist zur Zeit JSP und GSP vorgesehen


Grails
erfolgen
Eclipse Integration ist in Arbeit


Grails
erfolgen
Eclipse Integration ist in Arbeit
Sehr leichte Integration in eine MDSD-Umgebung


Gorm


GORM
Ist der OR-Mapper für Grails


GORM
Unter der Haube wird Hibernate 3 verwendet


GORM
Die Konfiguration wird komplett in den Groovy-Files
vorgenommen


GORM
vorgenommen
Alle Features von Hibernate werden unterstützt


GORM
vorgenommen
Alle Features von Hibernate werden unterstützt
In Verbindung mit Spring ist es möglich, Transaktionen in
Grails-Anwendungen flexibel zu verwalten


Groovle ts


Groovlets
Groovlets sind Java-Servlets in Groovy geschrieben


Groovlets
Groovlets sind Java-Servlets in Groovy geschrieben
Es gibt ein GroovyServlet, welches Groovy-Skripte
automatisch kompiliert, ausführt und cached


Groovlets
Implizite Variablen:
Variable Gebunden an Bemerkung
Request ServletRequest
Response ServletResponse
Context ServletContext
Application ServletContext
Session getSession(false)
Out response.getWriter() Können nicht re-assigned werden
Cout response.getOutputStream() Können nicht re-assigned werden
Html new MarkupBuilder(out) Können nicht re-assigned werden


GS QL


GSQL
Vereinfacht das Arbeiten mit SQL


GSQL
Unterstützung von SQL-Queries und -Statements


GSQL
Closures bieten komfortables Arbeiten mit den ResultSets


GSQL

def sql = Sql.newInstance(quot;urlquot;, quot;userquot;,quot;pwdquot;, quot;driverquot;)
sql.eachRow(quot;select * from FOOD where type=${foo}quot;) {
println quot;Gromit likes ${it.name}quot;
}


GSQL

def sql = Sql.newInstance(quot;urlquot;, quot;userquot;,quot;pwdquot;, quot;driverquot;)
def food = sql.dataSet('FOOD')
def cheese = food.findAll { it.type == 'cheese' }
cheese.each { println quot;Eat ${it.name}quot; }


Ant-
S c ripting

Ant-Scripting
Bietet eine Schnittstelle, um Ant-Tasks per Groovy-Script zu
erstellen und zu benutzen


Ant-Scripting

ant = new AntBuilder()
ant.echo(message:quot;mapping it via attribute!quot;)
ant.echo(quot;Hello World!quot;)


Ant-Scripting

ant = new AntBuilder()
try{
ant.javac(srcdir:quot;/srcquot;, destdir:quot;/dest/quot; )
}catch(Throwable thr){
ant.mail(mailhost:quot;hostquot;, subject:quot;build failurequot;){
from(address:quot;buildmaster@anywhere.comquot;),
to(address:quot;dev-team@anywhere.comquot;)
message(quot;Unable to compile sources.quot;)
}
}


Groovy
Te mpla te s


Groovy Templates
Bietet ein Framework, um eine eigene Template-Engine zu
entwickeln


Groovy Templates
Bietet ein Framework, um eine eigene Template-Engine zu
entwickeln
Enthalten ist die SimpleTemplateEngine, die JSP-like
mittels Scripts, Scriptlets und EL parameterisierte Texte
generieren kann


Groovy Templates (Beispiel)
def text = 'Dear quot;${firstname} ${lastname}quot;,nSo nice to
meet you in <% print city %>.'

def binding = [quot;firstnamequot;:quot;Peterquot;, quot;lastnamequot;:quot;Schulzequot;,
quot;cityquot;:quot;Dortmundquot;]

def engine = new SimpleTemplateEngine()
template = engine.createTemplate(text).make(binding)

def result = 'Dear quot;Peter Schulzequot;,nSo nice to meet you in
Dortmund.'
assert result == template.toString()


S ic he rhe it


Sicherheit
Groovy-Skripte können innerhalb des Java Security-
Managers ausgeführt werden


Sicherheit

security.policy:
grant codeBase quot;file:/serverCodeBase/restrictedClientquot; {
permission java.security.AllPermission;
};


Sicherheit

security.policy:
grant codeBase quot;file:/serverCodeBase/restrictedClientquot; {
permission java.security.AllPermission;
};

Java-Code:
new GroovyShell().evaluate(
new GroovyCodeSource(
clientscriptStr,
quot;RestrictedScriptquot;,
quot;/serverCodeBase/restrictedClientquot;)


S c riptom


Scriptom
Scriptom ist ein optionales Modul für die Verwendung mit
dem Windows Scripting Host oder OLE COM Automation


Scriptom

import org.codehaus.groovy.scriptom.ActiveXProxy

def explorer = new
ActiveXProxy(quot;InternetExplorer.Applicationquot;)
explorer.Visible = true
explorer.AddressBar = true
explorer.Navigate(quot;http://www.itemis.de/quot;)


Scriptom

import org.codehaus.groovy.scriptom.ActiveXProxy
import java.io.File

def word = new ActiveXProxy(quot;Word.Applicationquot;)
word.Documents.Open(new File(args[0]).canonicalPath)
word.ActiveDocument.SaveAs(new File(args[0] - quot;.docquot; +
quot;.htmlquot;).canonicalPath, 8)
word.Quit()


We ite re
Module

Weitere Module
Gant

Gant ist ein Build-Tool auf Basis von Ant. Anstatt XML zu
verwenden, wird ein Groovy-Dialekt benutzt, um die Ant-
Targets und -Tasks zu konfigurieren.


Weitere Module
Google Data Support

Google bietet den Zugriff auf seine Services. Mit Google
Data Support wird der Zugriff darauf wesentlich
vereinfacht.


Weitere Module
Gram

Gram unterstützt bei der Verwendung von Xdoclet-Tags und
Annotations in Groovy-Scripts.


Weitere Module
Groovy Jabber-RPC

Damit können XML-RPC Aufrufe über das Jabber-Protokol
abgesetzt werden. Bietet die Möglichkeit sowohl einen
Server als auch einen Client zu erstellen.


Weitere Module
Groovy Monkey

Groovy Monkey ist ein Port des Eclipse-Monkey Projekts.
Damit kann Eclipse über Groovy-Scripts automatisiert
werden.


Weitere Module
Groovy SOAP

Damit können sowohl ein Soap-Server als auch ein Soap-
Client erstellt werden.


Weitere Module
GroovySWT

Auch SWT-UI's können mittels Groovy erstellt werden.


Weitere Module
Process

Wird auch GrooSH – Groovy Shell – genannt. Hiermit ist es
möglich Funktionen einer (Unix-)Shell nachzubilden.


Weitere Module
XMLRPC

Ermöglicht XML-RPC Calls an lokale oder enfernte RPC-
Server abzusetzen.


Te s ting


Testing


Testing - jUnit-Testing
Basiert auf jUnit und erweitert die Asserts


Testing - jUnit-Testing
Basiert auf jUnit und erweitert die Asserts
 assertArrayEquals(Object[] expected, Object[] value)
 assertLength(int length, char[] array)
 assertLength(int length, int[] array)
 assertLength(int length, Object[] array)
 assertContains(char expected, char[] array)
 assertContains(int expected, int[] array)
 assertToString(Object value, String expected)
 assertInspect(Object value, String expected)
 assertScript(final String script)
 shouldFail(Closure code)
 shouldFail(Class clazz, Closure code)


IDE
S upport

IDE-Support


IDE-Support (Groovy Monkey)
Groovy Monkey ist ein Aufsatz auf Eclipse Monkey


Damit kann Eclipse geskriptet werden


Nützlich für
Automatisierungs-Task (Quelltext-Suche, Erstellen von
Tasks)


Nützlich für
Tasks)
Erstellen von LaunchManagern


Nützlich für
Tasks)
Prototyping von Plugins


Nützlich für
Tasks)
Prototyping von PlugIns
Basiert auf dem Eclipse-Job API


Zus a mme n-
Fa s s ung


Zusammenfassung
Groovy ist schon sehr weit fortgeschritten


Zusammenfassung
Es gibt eine grosse Anzahl an zusätzlichen Modulen, die die
meisten Anwendungsfälle abdecken


Zusammenfassung
Durch die Standardisierung (JSR 241) ist auch eine gewisse
Zukunftssicherheit gewährleistet


Zusammenfassung
Groovy ist leicht erlernbar, da sehr viele Ähnlichkeiten mit
der Java-Syntax bestehen


Zusammenfassung
Groovy ist leicht erlernbar, da sehr viele Ähnlichkeiten mit
der Java-Syntax bestehen
Neben dem leistungsfähigen API von Groovy steht die
gesamte API von Java zur Verfügung


Links


Links
Groovy Homepage
http://groovy.codehaus.org/
JSR 241
http://www.jcp.org/en/jsr/detail?id=241
Grails
http://grails.codehaus.org/
Artikel über Groovy
http://groovy.codehaus.org/Articles
Webseite des Autors
http://www.planetes.de/thorsten-kamann


Groovy - Rocks or Not?

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (19)

Similar to Groovy - Rocks or Not?

Similar to Groovy - Rocks or Not? (8)

More from Thorsten Kamann

More from Thorsten Kamann (13)

Groovy - Rocks or Not?