Let’s groove with Groovy

Thorsten Kamann ● thorsten.kamann@itemis.de 1

Agenda
Was ist Groovy? Testing
Getting started Grails
Syntax Groovy Module
GroovyBeans IDE-Support
XML-Processing Links
Groovy Builder


Was ist Scripting?
• Skriptsprachen sind Programmiersprachen, die vor
allem für kleine, überschaubare
Programmieraufgaben gedacht sind
• Kein Deklarationszwang für Variablen
• Automatische Speicherverwaltung
• Werden in der Regel ohne getrennte
Übersetzungsphase ausgeführt (d. h. sie werden
„interpretiert“)


Was ist Groovy?
• Eine dynamische Sprache
• Inspiriert von Ruby, Python, Smalltalk
• Entwickelt für die Java-Plattform
– Um sie Java-Entwicklern zugänglich zu machen
– Um möglichst viel der Java-Syntax wieder
verwenden zu können
– Um eine einfache Anbindung zu Enterprise-
Systemen anzubieten


Getting started
• Download des aktuellen Release von
http://groovy.codehaus.org
• Entpacken des Archivs
• Setzen der Umgebungsvariable GROOVY_HOME
• Hinzufügen von %GROOVY_HOME%bin zur PATH-
Variable
• Starten von groovyConsole und Eingabe von
println „Hallo Welt“
mit anschliessendem STRG-R


Getting started
•

•
•
•

•


Getting started: Embedding

Java-
Anwendung

Bean-Scripting-
Groovy- Groovy- Groovy ANT
Framework
Shell Classloader ScriptEngine Maven
(BSF)

Groovy
Script



– Ist ein allgemeine Möglichkeit, jede beliebige
Scriptsprache in Java-Anwendungen einzubinden

– Groovy bietet aber leichtgewichtigere und
leistungsfähigere Möglichkeiten der Einbindung



– Groovy-Shell 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 == 20;
assert binding.getVariable(quot;x„) == 123;



– 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);



– Lädt Groovy-Klassen dynamisch und ermöglicht
den direkten Zugriff auf deren Methoden
GroovyClassLoader gcl = new GroovyClassLoader();
Class clazz = gcl.parseClass(
myStringwithGroovyClassSource,
quot;SomeName.groovyquot;);
Object aScript = clazz.newInstance();
MyInterface myObject = (MyInterface) aScript;
myObject.interfaceMethod();



– Dies ist die leistungsfähige Möglichkeit, um
Groovy-Skripte auszuführen.
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;));



– ANT-Task, mit dem eine beliebige Anzahl von
Groovy-Skripten ausgeführt werden kann
– GroovyC-Task, der Groovy-Skripte (Klassen) zu
Java Bytecode kompiliert
– Erstellen von Ant-Tasks mit Groovy und dem
Ant-Builder
– Erzeugen von Ant-Skripten



– Unterstützung mittels des M2-Ant-Plugins
– Auf http://mojo.codehaus.org/ existieren bereits Maven-
Tools für direkte Unterstützung von Groovy:
• Groovy-Compiler
• Groovy-Archetype
• Tools, um Maven-Plugins mit Groovy zu entwickeln



– Groovy kann direkt von der Eingabeaufforderung
groovy script.groovy [arguments]
ausgeführt werden
– Alternativ kann über den Dialog
Ordneroptionen-->Dateitypen die Extension
*.groovy an groovy.bat gebunden werden.



– Groovy kann direkt von der Konsole mittels
groovy script.groovy [arguments]
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 Syntax: Groovy vs. Java

– Package-, Import-Mechanismus
– Class und Method Definition
– Kontrollstrukturen (ausser for(init;test,inc))
– Operatoren, Ausdrücke und Zuweisungen
– Exeption Handling
– Literale
– Instantiierung, Referenzen



– Vereinfachter Zugriff auf Java-Objekte mit neuen
Ausdrücken und Operatoren
– Zusätzliche Möglichkeiten, um Objekte zu
erstellen
– Neue Konstrollstrukturen
– Neue Datentypen
– Alles ist ein Objekt



– groovy.lang.*, groovy.util.*

– java.lang.*, java.util.*, java.net.*, java.io.*

– java.math.BigInteger, java.math.BigDecimal


Die Syntax

assert(true)

assert 1 == 1

def x = 1
assert x == 1

def y=1; assert y == 1


Die Syntax: Datentypen

– Alles ist ein Objekt
– Keine primitiven Datentypen
– Automatisches Wrapping (Boxing/Unboxing)
– Optionales Typing
– Statisches/Dynamisches Typing



Typ Beispiel
java.lang.Integer 15, 0x1234ffff
java.lang.Long 100L, 100l
java.lang.Float 1.23F, 1.23f
java.lang.Double 1.23D, 1.23d
java.math.BigInteger 123g, 456G
java.math.BigDecimal 1.23, 4.56, 1.4E4, 2.8e4, 1.23g, 1.23G



– Whole word Matcher
– Find Matcher
– Count
– Foreach
– Replace
– Split



//Finder
assert „Hello Groovy!“ =~ /o.G/

//Matcher
assert „Hello Groovy!“ ==~ /HellosGroovy!/

//Replace
assert „Hello Groovy!“.replaceAll(/Hello/, „Hi“)
== „Hi Groovy!“

//Split
assert „Hello Groovy!“.split(/ /).size == 2



– Basieren auf einfachen Strings
– Bieten allerdings eine erweiterte Funktionalität
– Sie müssen in doppelten Anführungszeichen
definiert werden
– Unterstützen Platzhalter
• ${expression}
• $expression



me = „Thorsten“
age = 34
location = „Neuss“
line = „Ich heisse $name, bin $age und wohne in $location“

assert line == „Ich heisse Thorsten, bin 34 und wohne in
Neuss“
assert line instancof java.lang.String



Start/End Zeichen Beispiel GString? Backslash?
Einfache Anführungszeichen ‚Hallo Thorsten„  
Doppelte Anführungszeichen „Hallo $name“  
Dreifache Anführungszeichen „„„----------------  
Total: $0.02
---------------„„„
Dreifache doppelte “““---------------  
Anführungszeichen Line with text
--------------“““
Forward Slash /x(d*)y/  



greeting = „Hello Groovy!“

assert greeting[0] == „H“
assert greeting [6..11] == „Groovy“
assert ‚Hi‘ + greeting – ‚Hello‘ == „Hi Groovy!“
assert greeting.count(„o“) = 3

assert „x“.padLeft(3) == „ x“
assert „x“.padRight(3) == „x „
assert „x“.center(3) == „ x „
assert „x“ * 3 == „xxx“


Die Syntax: Datentypen (collective)

List list = []
assert list.size == 0

list = [‚a‘, ‚b‘, ‚c‘]
assert list.size == 3 && list[1] = ‚b‘

list << ‚d‘

list += ‚e‘

assert list – ‚d‘ == [‚a‘, ‚b‘, ‚c‘, ‚e‘]



– Sind Listen mit einem definierten Anfangs- und
Endwert
– Nahezu jedes Objekt kann in einer Range
verwaltet werden
• Methoden next und previous müssen implementiert
werden
• Das Interface java.lang.Comparable muss
implementiert werden



def range = 0..10
assert range.contains(0)

range = 0..<10
assert !range.contains(10)



Map map = [:]
assert map.size == 0

map = [a:1, b:2,c:3]
assert map.size = 3
assert map.get(„a“) == 1
assert map[‚b‘] == 2
assert map.c == 3

map.e = 4
assert map.e == 4



– Expandos ermöglichen die Erzeugung von
dynamischen Objekten
def player = new Expando()
player.name = “Thorstenquot;
player.greeting = { quot;Hello, my name is $player.namequot; }

assert player.greeting() == quot;Hello, my name is Thorstenquot;


Die Syntax: Closures

– Codeblöcke
– Können einen Wert/Objekt zurückgeben
– Referenzieren und verwenden Variablen
– call()(implizit/explizit) führt die Closure aus
– Können an eine Variable gebunden werden
– Ähneln Java Inner Classes



List list = [1, 2, 3]

list.each{ entry ->
println „entry $entry“
}

Ausgabe:
entry 1
entry 2
entry 3



public void each(Closure closure){
for (it: listItems){
closure(it).call();
}
}



Class MethodClosureSample(){
boolean validate(String value){
return StringUtils.isNotEmpty(value);
}
}

MethodClosureSample sample = new MethodeClosureSample()
List success = [„Hello“, „World“, „!“]
List fails = [„Hello“, „“, „World“, „!“]

assert success.each(sample.&validate)
assert !fails.each(sample.&validate)



– Transformiert eine Closure mit vielen Parametern
in eine Closure mit weniger Parametern
– Dabei werden Parameter mit Werten vorbelegt
def adder = {x, y -> return x+y}
def addOne = adder.curry(1)

assert addOne(5) == 6



Closure Beschreibung
collect Sammelt Objekte und fügt sie in eine neue Liste ein
each Führt für jedes Element aus
find Findet ein Element
findAll Findet alle Elemente anhand von Kriterien
min(Comparator) Gibt den min. Wert aus der Collection zurück
max(Comparator) Gibt den max. Wert aus der Collection zurück
sort(Comparator) Sortiert die Collection (Comparator ist optional)
unique Entfernt doppelte Werte aus der Collection


Die Syntax: Kontrollstrukturen
•
Runtime type Evaluation criterion required for truth
Boolean Booleanwert muss true sein
Matcher Der reguläre Ausdruck muss mindestens 1 Treffer haben
Collection Die Collection darf nicht leer sein
Map Die Map darf nicht leer sein
String Der String darf ebenfalls nicht leer sein
Number Muss ungleich 0 sein
Alles andere Die Objektreferenz muss ungleich null sein


Die Syntax: If-Statement
•
If (true) assert true
Else assert false

If (1){ assert true
}else{ assert false
}

If (0) assert false
Else if (1) assert true
Else assert false

(1 > 0)? assert true: assert False


Die Syntax: Kontrollstrukturen

– Kann mit jedem Datentyp verwendet werden
switch (10){
case 0 : assert false; break;
case 0..9 : assert false; break;
case [8,9,11] : assert false; break;
case Float : assert false; break;
case {it%3==0} : assert false; break;
case ~/../ : assert true; break;
default : assert false; break;
}


Die Syntax: Looping

def list = [1, 2, 3, 4, 5]
while (list){
list.remove()
}
assert list == []

while (list.size() < 3){
list << list.size()+1
}
assert list == [1, 2, 3]


Die Syntax: Looping

for (String i in ‘a‘..‘c‘) store += i
assert store == ‘abc‘

for (i in [1, 2, 3]){ store += i}
assert store == ‘123‘

def myString = ‘Hello Groovy!‘
for (i in 0..myString.size()){ store += myString[i]}
assert store == myString

Entspricht dem Java Equivalent:
for (int i=0;i<upperBound;i++){}


Die Syntax: Return/Break/Continue

Boolean someMethod(){
if (false){
return false
}
return true
}



while (true){
if (someCondition){
break
}
}



for(item in items){
if (someCondition){
continue
}
}


Die Syntax: Exception

– Ähnliche Unterstützung wie in Java
• try-catch-finally
• try-catch
• try-finally
– Checked-Exception werden als Runtime-
Excpetion hochgereicht


Die Syntax: OO und Groovy

– Identisch mit Klassen in Java
– Können Felder, Konstruktoren, Methoden
enthalten
– Konstruktoren und Methoden können lokale
Variablen verwenden



– Lokale Variablen und Felder müssen deklariert
werden
– Java Modifiers werden verwendet:
• private, protected, public, final, static
• Bei fehlendem Modifier wird eine Property erzeugt



def map = [a:[b:[c:1]]]

assert map.a.b.c == 1

try{
assert map a.x.c == null
}catch (NullPointerException npe){ Fängt die NPE
}

assert map?.a.?x?.c == null


Groovy Beans

– Sind wie JavaBeans
– Getter/Setter werden zur Laufzeit erzeugt
– Event-Support wird mit vereinfachten Methoden
ermöglicht


Groovy Beans

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;
}
...
}


Groovy Beans

– Wenn eine Property als private gekennzeichnet
ist, wird ein Java Field benutzt, um diese Property
zu repräsentieren


Groovy Beans

– 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


Groovy Beans

– 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


Groovy Beans

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


Groovy Beans

Groovy: Java:
def button = new JButton(Push me!”) final JButton button =
new Jbutton(„Push me!“);
button.actionPerformed = {event -> button.addEventListener(
println button.text new IActionListener(){
} public void actionPerformed(
ActionEvent event){
System.out.println(
button.getText());
}
});


XML-Processing
XML-Support

Edit Create
XML-Parser MarkupBuilder

XMLSlurper NodeBuilder

DOMCategroy

DOM StAX DOM4J JAXEN DOM DOM4J

SAX XOM JDOM XPATH XOM JDOM


XML-Processing

– Groovy bietet reichhaltige Unterstützung für das
XML-Processing
– GPath (Xpath) Ausdrücke erlauben schnelle
Navigation im XML-Dokument
– DOMCategory stellt mächtige
Navigationselemente zur Verfügung


XML-Processing

DOM Element Expression Beschreibung
Element .elementName Alle Kindelemente mit dem
.„elementName„ angegebenen Namen
Element [index] Kindelement mit dem [index]
Element .@attrName Attribut mit den angebenen Namen
.„@attrName„
.[„@attrName„]
Element .name() Name des aktuellen Elements
Element .parent() Das Elternelement
Element .text() Der Textinhalt des Elements


XML-Processing
//XML-Parser
def xml = new XmlParser().parseText(SOME_XML_TEXT)

//XML-Slurper
def xml = new XmlSlurper().parseText(SOME_XML_TEXT)

//DOMCategory
def reader = new StringReader(SOME_XML_TEXT)
def doc = DOMBuilder.parse(reader)
def records = doc.documentElement

use (DOMCategory) {
//do something
}


Groovy Builder

– Groovy bietet Unterstützung für die Arbeit mit
Baumartige Strukturen:
• XML, HTML, Ant Tasks, Swing UI's, SWT UI„s
Your
XML HTML ANT Swing SWT
Builder

GroovyObjectSupport

BuilderSupport


Groovy Builder

– eine einheitliche Schnittstelle
• Elemente sind Closures
• Attribute sind Maps
– Vollständige Integration anderer Groovy-Features
• Collections
• Arrays
• Conditions
• ...


Groovy Builder

builder = new <person>
MarkupBuilder(writer) <name first=“Thorsten“
builder.person() { last=“Kamann“>
name(first:“Thorstenquot;, <age>34</age>
last:“Kamannquot;) { </name>
age(quot;34quot;) </person>
}
}


Groovy Builder

def writer = new FileWriter(“markup.html“)
def html = new groovy.xml.MarkupBuilder(writer)
html.html{
head{
title ‘Hello Groovy!‘
}
body{
h1 ‘Hello Groovy‘
p(style:‘font-weight: bold;‘,
‘This is built by Groovy.‘)
}
}


Groovy Builder


Groovy Builder

def ant = new groovy.util.AntBuilder()
ant.mkdir(dir:myDir)
ant.copy(todir:myDir) {
fileset(dir:quot;src/testquot;) {
include(name:quot;**/*.groovyquot;)
}
}


Groovy Builder

def swing = new groovy.swing.SwingBuilder()
def frame = swing.frame(title:'Password'){
passwordField(columns:30, actionPerformed: {event ->
println event.source.text
System.exit(0)
})
}
frame.pack()
frame.show()


Groovy Builder


Groovy Builder

bb = new grails.spring.BeanBuilder()
bb.beans{
CustomerService(org.x.y.z.CustomerServiceImpl){
customerDao = CustomerDao
}
CustomerDao(org.x.y.z.CustomerDaoImpl){
sessionFactory = MySessionFactory
}

ApplicationContext context =
bb.createApplicationContext()
}


Testing
Groovy Testing

TPTP

Unit Coverage UI-Test Webservice-Test

jUnit Corbertura
SoapUI
Mocks HTML Unit Canoo Webtest
Stubs


Testing

– jUnit ist in der Groovy-Runtime verankert
– Zusätzliche Assert-Statements
– Leicht integrierbar mit Ant und Maven
– Groovy liefert auch Groovy Mocks


Testing

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)


Testing

import groovy.mock.interceptor.MockFor

def mocker = new MockFor(Collaborator.class)
mocker.demand.one(1..2) { 1 }
mocker.demand.two() { 2 }

mocker.use {
def caller = new Caller()
assertEquals 1, caller.collaborateOne()
assertEquals 1, caller.collaborateOne()
assertEquals 2, caller.collaborateTwo()
}


Testing

– Resourcen (*.xml, Spring) können zur Laufzeit
erzeugt werden
– Zugriffe auf private Java-Ressourcen sind
einfacher (kein Reflection)
– Stubs und Mocks sind einfacher
– 100%ige Integration in den Buildprozess (Ant,
Maven)


Grails

– MVC-Framework
• Basierend auf Spring-MVC und Hibernate
– JSP oder GSP
– Einfache AJAX-Integration
– Sehr performant
– Integrierter Job-Scheduler


Grails

– Domänenklassen (mit GORM)
– Controller
– Services
– Jobs
– CRUD-Anwendung in No-Time
– AJAX (Dojo, Yahoo, Scriptacolous, Prototype)
– Vollständig integriert


Groovy Module

class Client{
String name Einfache Properties
String email
Address address 1:1 Beziehung
static hasMany = [orders: Order]
1:* Beziehung
static constraints = { static belongsTo=Client
name(blank:false,size:5..20)
email(email:true)
}
Constraints
}


Groovy Module


IDE-Support

– Assistenten für Groovy-Klassen und –Unittests
– Komplette Integration in Eclipse
– Syntax-Coloring
– Syntax-Checking
– Word-Completion
– Duck-Typing


IDE-Support
Instance variable Method completion as
completion Groovy Properties

Complex
completion


IDE-Support
Typed local variable Duck-Typing


Links und Ressourcen

Groovy in Action
von Dierk Koenig, Andrew Glover, Paul King,
Guillaume Laforge

- Taschenbuch: 696 Seiten
- Verlag: Manning (Januar 2007)
- Sprache: Englisch
- ISBN-10: 1932394842
- ISBN-13: 978-1932394849


Links und Ressourcen
• Groovy Webseite
http://groovy.codehaus.org/

• Groovy Series Podcast
http://groovy.codehaus.org/Groovy+Series

• Groovy Blogs
http://www.groovyblogs.org/

• Webseite des Referenten (Blog, Wiki)
http://www.thorsten-kamann.de


Let’s groove with Groovy

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Andere mochten auch

Andere mochten auch (20)

Ähnlich wie Let’s groove with Groovy

Ähnlich wie Let’s groove with Groovy (16)

Mehr von Thorsten Kamann

Mehr von Thorsten Kamann (13)

Let’s groove with Groovy