{"id":2820,"date":"2014-05-16T14:39:52","date_gmt":"2014-05-16T12:39:52","guid":{"rendered":"http:\/\/www.tutego.de\/blog\/javainsel\/?p=2820"},"modified":"2014-05-16T14:39:52","modified_gmt":"2014-05-16T12:39:52","slug":"inselraus-groovy","status":"publish","type":"post","link":"https:\/\/www.tutego.de\/blog\/javainsel\/2014\/05\/inselraus-groovy\/","title":{"rendered":"Inselraus: Groovy"},"content":{"rendered":"

Groovy (http:\/\/groovy.codehaus.org\/) ist eine objektorientierte Skriptsprache, die auf einer JVM l\u00e4uft und vollen Zugriff auf alle Java-Bibliotheken bietet. Die Sprache hat viele interessante Eigenschaften, die sie zu Java X machen. Groovy setzt auf der Standard-Java-Syntax auf und erweitert diese.[1] Einige H\u00f6hepunkte:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Groovy-Feature<\/strong><\/td>\nBeispiel<\/strong><\/td>\n<\/tr>\n<\/thead>\n
Statt System.out.print(\u2026)\/println(\u2026) reicht ein print bzw. println, und dann muss das Argument auch nicht in runden Klammern stehen.<\/td>\nprintln 1 + 2
\nprint „Wow“<\/td>\n<\/tr>\n
Anweisungen m\u00fcssen nicht immer mit einem Semikolon abgeschlossen werden, sondern nur dann, wenn mehrere Anweisungen in einer Zeile stehen.<\/td>\nprint „Wow“
\nprint „Wow“; print „Wow“<\/td>\n<\/tr>\n
Variablen m\u00fcssen nicht mit einem Typ deklariert werden, das gilt auch bei catch oder Methoden\/Konstruktoren.<\/td>\ndef age = 40
\ndef greet( name ) { print „Hallo “ + name }
\ntry { } catch ( e ) { }<\/td>\n<\/tr>\n
Zeichenketten lassen sich mit einfachen oder doppelten Anf\u00fchrungszeichen angeben. Einzelne Zeichen (char\/Character) m\u00fcssen besonders aufgebaut werden.<\/td>\nprint „Ja“ == ‚Ja‘\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ true
\ndef sign = „-“ as char<\/td>\n<\/tr>\n
Strings in doppelten Anf\u00fchrungszeichen sind besondere GStrings: Enthalten sie $variable bzw. ${ausdruck}, so wird der Inhalt der Variablen bzw. der ausgewertete Ausdruck eingesetzt.<\/td>\ndef one = 1
\nprint „$one plus $one macht ${1+1}“
\n\/\/ 1 plus 1 macht 2<\/td>\n<\/tr>\n
Strings k\u00f6nnen \u00fcber mehrere Zeilen laufen, wenn sie in „““ oder “‘ eingeschlossen sind \u2013 folgt ein Backslash am Ende der Zeile, wird kein Zeilenumbruchzeichen eingef\u00fcgt.<\/td>\nprint „““
\nZeile 1
\nZeile 2\\
\nWeiter mit Zeile 2
\n„““<\/td>\n<\/tr>\n
Alles ungleich 0 und null ist true.<\/td>\nif ( 1 ) print ‚Zweig wird genommen‘<\/td>\n<\/tr>\n
Groovy definiert einen neuen Datentyp f\u00fcr Bereiche (engl. ranges).<\/td>\ndef numbers1 = 0..9
\ndef numbers2 = 0..<10<\/td>\n<\/tr>\n
Erweiterte Z\u00e4hlschleife unter Ber\u00fccksichtigung von Bereichen, bzw. rechts von in steht ein Iterable wie beim erweiterten for.<\/td>\nfor ( i in 0..<10 )
\nprint i\u00a0 \/\/ 0123456789<\/td>\n<\/tr>\n
== bei Referenzen bedeutet equals(\u2026)-gleich; ein Identit\u00e4tsvergleich realisiert is(\u2026).<\/td>\ndef heinz = ‚Heinz‘
\nprint heinz == ‚Heinz‘\u00a0 \/\/ true<\/td>\n<\/tr>\n
Operatoren k\u00f6nnen \u00fcberladen werden, und die Anwendung von Operatoren entspricht Methodenaufrufen, etwa + von plus(\u2026), ++ von next(\u2026) oder [] von getAt(\u2026).<\/td>\nprintln 1 + 2 * 3 \/\/ 7
\nprintln 1.plus(2).multiply(3) \/\/ 9
\nprintln 1.plus(2.multiply(3)) \/\/ 7<\/td>\n<\/tr>\n
Alle Comparable-Objekte (und damit etwa String, BigInteger, BigDecimal) k\u00f6nnen mit ==, !=, <, >, <= und >= verglichen werden. Die Ordnung liefert compareTo(\u2026).<\/td>\ndef heinz = ‚Heinz‘
\nprint heinz < ‚Werner‘\u00a0 \/\/ true<\/td>\n<\/tr>\n
Ist in Java nur java.lang standardm\u00e4\u00dfig importiert, ist es bei Groovy viel mehr, etwa noch java.io, java.util, java.net und noch einige.<\/td>\nprint new File(‚file.txt‘).exists()<\/td>\n<\/tr>\n
Statt explizit auf Datenstrukturklassen f\u00fcr Listen und Mengen zur\u00fcckzugreifen, bietet Groovy eine spezielle Syntax.<\/td>\ndef primes = [ 2, 3, 5, 7]
\nprint primes[ 0 ]
\ndef dic = [ ‚rot‘ : ‚red‘, ‚blau‘ : ‚blue‘ ]
\nprint dic[‚rot‘]\u00a0 \/\/ red<\/td>\n<\/tr>\n
Die Operatoren ?. und ?: (Elvis-Operator) verhindern null-Zugriffe.<\/td>\ndef name = ‚Chris‘
\nprintln name ?: ‚Kein Name‘\u00a0 \/\/ Chris
\nname = null
\nprintln name ?: ‚Kein Name‘\u00a0 \/\/ Kein Name<\/td>\n<\/tr>\n
Der Zugriff auf Zeichen \u00fcber [] ist bei den Zeichenkettenklassen String, StringBuffer, StringBuilder m\u00f6glich.<\/td>\ndef s = ‚Ooog‘
\nprint s[0]\u00a0\u00a0 \/\/ O<\/td>\n<\/tr>\n
Der Zugriff \u00fcber [] l\u00e4sst auch Bereiche zu.<\/td>\ndef s = „tutego“
\nprint s[ 0, 1, 3..5 ] \/\/ tugeo
\ndef t = new StringBuilder( „tutego“ )
\nt[ 1..4 ] = „X“
\nprint t\u00a0 \/\/ tXo<\/td>\n<\/tr>\n
Der Operator << h\u00e4ngt Dinge an Strings (R\u00fcckgabe ist dann StringBuffer), Listen oder Dateien an.<\/td>\ndef s = ‚oger‘
\ndef sb = ‚Das ist ‚ << s << ‚ oder?‘
\nprint sb\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ Das ist oger oder?
\ndef file = new File(„out.txt“)
\nfile << „Zeile 1“<\/td>\n<\/tr>\n
Regul\u00e4re Ausdr\u00fccke werden mit einer eigenen Syntax direkt von der Sprache unterst\u00fctzt; =~ ist ein find, ==~ ein match.<\/td>\nprint ‚2010‘ ==~ \/\\d+\/<\/td>\n<\/tr>\n
erweitertes switch-case etwa mit regul\u00e4ren Ausdr\u00fccken und Bereichen<\/td>\nswitch ( 42 ) {
\ncase 0..100\u00a0 : println ‚ist zwischen 0..100‘; break
\ncase Integer : println ‚ist Integer‘; break
\ncase { it % 2 == 0 }: println ‚ist gerade‘; break
\ncase ~\/\\d\\d\/: println ’42 passt auf das Pattern‘; break
\n}<\/td>\n<\/tr>\n
Datentyp f\u00fcr Dauer und spezielle Eigenschaften f\u00fcr Datumswerte und \u00fcberladene Operatoren zum leichten Rechnen mit dem Paket groovy.time<\/td>\nuse ( groovy.time.TimeCategory ) {
\ndef today = new Date()
\ndef tomorrow = today + 1.day
\nprint „Morgen: $tomorrow, n\u00e4chstes Jahr ${today + 1.year}“
\n}<\/td>\n<\/tr>\n
Closures als Codebl\u00f6cke werden unterst\u00fctzt und finden \u00fcberall in der Groovy-API Anwendung.<\/td>\nnew File( „file.txt“ ).eachLine {
\nprintln it
\n}
\ndef names = [ „Charisma“, “\u00a0 „, „Tina“, „“ ]
\nprint names.findAll { ! it.trim().isEmpty() }
\n\/\/ [Charisma, Tina]<\/td>\n<\/tr>\n
Setter\/Getter m\u00fcssen nicht aufgerufen werden; beim Zugriff ref.property wird automatisch der Setter\/Getter aufgerufen.<\/td>\ndef p = new Point( 10, 20 )
\nprint p.location.x\u00a0 \/\/ 10.0<\/td>\n<\/tr>\n
In Methoden mit R\u00fcckgabe kann das Schl\u00fcsselwort return entfallen.<\/td>\ndef add( a, b ) { a + b }<\/td>\n<\/tr>\n
Default-Parameter bei Methodendeklarationen<\/td>\nstatic tax( cost, taxRate = 19 ) {
\ncost * taxRate \/ 100
\n}
\nprintln tax( 100 )\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ 19
\nprintln tax( 100, 7 )\u00a0\u00a0\u00a0 \/\/ 7<\/td>\n<\/tr>\n
Methoden und Klassen sind standardm\u00e4\u00dfig public, nicht paketsichtbar wie bei Java. Groovy erstellt automatisch Setter\/Getter.<\/td>\nclass Person { def\u00a0 name }<\/td>\n<\/tr>\n
Mit der Klassenannotation @Immutable wird ein Typ unver\u00e4nderbar, mit @Singleton ein Singleton mit einem privaten Konstruktor und \u00f6ffentlichem Attribut instance f\u00fcr die eine Instanz.<\/td>\n@Immutable class Pair { String val1, val2 }
\n@Singleton class AppWindow { }<\/td>\n<\/tr>\n
Diverse Builder-Klassen erleichtern den Aufbau von hierarchischen XML- oder Swing-B\u00e4umen ebenso wie Ant-Build-Skripten.<\/td>\nimport groovy.xml.MarkupBuilder
\ndef writer = new StringWriter()
\nnew MarkupBuilder( writer ).html {
\nhead { title ‚Z\u00e4hlen mit Graf Zahl‘ }
\nbody {
\nh1 ( ‚Willkommen‘ )
\np {
\nul { (1..10).each { li it } }
\na(\u00a0href:“’http:\/\/stupidedia.org\/stupi\/Graf_Zahl“‘,
\n‚Graf Zahl‘ )
\n}
\n}
\n}
\nprintln writer<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eigenschaften von Groovy mit Beispiel<\/em><\/p>\n

Groovy-Skripte in Eclipse ausf\u00fchren<\/h4>\n

Um Groovy-Skripte und Programme auszuf\u00fchren, bieten sich drei Wege an:<\/p>\n

    \n
  • \u00fcber eine spezielle Kommandozeile, die Groovy-Shell<\/li>\n
  • \u00fcber das Eclipse-Plugin<\/li>\n
  • \u00fcber die javax.script-API<\/li>\n<\/ul>\n

    Das Eclipse-Plugin unter http:\/\/groovy.codehaus.org\/Eclipse+Plugin leistet gute Arbeit und wird st\u00e4ndig weiterentwickelt. Auf der Webseite ist der Update-Link genannt, sodass Groovy-Eclipse \u00fcber den Update-Manager installiert werden kann.<\/p>\n

      \n
    1. W\u00e4hle dazu Eclipse Help \u2022 Install New Software\u2026<\/li>\n
    2. In der Dialogbox f\u00fclle das Textfeld bei Work with mit dem Link http:\/\/dist.springsource.org\/release\/GRECLIPSE\/e4.3\/ (bzw. anderen Versionen je nach Eclipse-Version), und aktiviere Add\u2026<\/li>\n
    3. Aktiviere anschlie\u00dfend Groovy-Eclipse, und f\u00fchre die Installation mit Next usw. zu Ende.<\/li>\n<\/ol>\n

      Ist Eclipse neu gestartet und das Plugin installiert, kann jedes Java-Projekt um Groovy-Unterst\u00fctzung erweitert werden. Bei einem Java-Projekt aktiviert die Aktion Configure \u2022 Convert to Groovy Project im Kontextmen\u00fc genau diese Groovy-Unterst\u00fctzung, sodass im Projektbaum die Groovy-Bibliotheken auftauchen.<\/p>\n

      File \u2022 New \u2022 Other\u2026 erm\u00f6glicht zum einen im Zweig Groovy das Erstellen eines neuen Groovy-Projekts (durch die Konvertierung eines existierenden Java-Projekts ist das nicht mehr n\u00f6tig) und zum anderen mit Groovy Class das Erstellen einer Groovy-Klasse. Bei dieser Option l\u00e4sst sich ein Paket- und Klassenname eingeben (etwa com.tutego.insel.script und GroovyBabe), und dann \u00f6ffnet Eclipse den Groovy-Editor.<\/p>\n

      L\u00f6schen wir die Klassendeklaration und setzen nur die zwei Zeilen in die Datei:<\/p>\n

      package\u00a0com.tutego.insel.script<\/pre>\n
      print\u00a0„Hallo\u00a0Groovy“<\/p>\n
      Ausgef\u00fchrt wird das Groovy-Skript im Kontextmen\u00fc (oder Run-Men\u00fc) mit Run As \u2022 Groovy Skript.<\/p>\n
      Groovy\u00a0\u00fcber die Skript-API ausf\u00fchren<\/h4>\n
      Um Groovy\u00a0als Skriptsprache aus einem Java-Programm heraus zu nutzen, k\u00f6nnen wir wieder auf die Skript-API zur\u00fcckgreifen. Wenn es sich bei Eclipse schon um ein Groovy-Projekt handelt, ist ein JAR schon im Klassenpfad eingebunden, und es ist nichts zu tun. Andernfalls bekommen wir von der Webseite http:\/\/groovy.codehaus.org\/Download unter Download zip: Binary Release ein fast 30 MiB gro\u00dfes ZIP-Archiv wie groovy-binary-2.2.2.zip, wo groovy-all-2.2.2.jar im Ordner embeddable liegt und das wir in den Klassenpfad mit aufnehmen.<\/p>\n
      Ein kleines Beispiel:<\/p>\n
      ScriptEngine\u00a0engine\u00a0=\u00a0new\u00a0ScriptEngineManager().getEngineByName(\u00a0\"groovy\"\u00a0);<\/pre>\n
       System.out.println(\u00a0engine.eval(\u00a0\"(1g..42g.gcd(56g)).sum()\"\u00a0)\u00a0);\u00a0\/\/\u00a0105<\/pre>\n
      [1]\u00a0\u00a0\u00a0 Bis auf sehr kleine Ausnahmen ist jedes Java-Programm ein Groovy-Programm.<\/pre>\n","protected":false},"excerpt":{"rendered":"
      Groovy (http:\/\/groovy.codehaus.org\/) ist eine objektorientierte Skriptsprache, die auf einer JVM l\u00e4uft und vollen Zugriff auf alle Java-Bibliotheken bietet. Die Sprache hat viele interessante Eigenschaften, die sie zu Java X machen. Groovy setzt auf der Standard-Java-Syntax auf und erweitert diese.[1] Einige H\u00f6hepunkte: Groovy-Feature Beispiel Statt System.out.print(\u2026)\/println(\u2026) reicht ein print bzw. println, und dann muss das Argument […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","_links_to":"","_links_to_target":""},"categories":[11],"tags":[],"class_list":["post-2820","post","type-post","status-publish","format-standard","hentry","category-insel"],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/2820","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/comments?post=2820"}],"version-history":[{"count":1,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/2820\/revisions"}],"predecessor-version":[{"id":2821,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/2820\/revisions\/2821"}],"wp:attachment":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/media?parent=2820"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/categories?post=2820"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/tags?post=2820"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}