groovyAan de slag met groovy


Opmerkingen

Groovy is

  • is een optioneel getypte dynamische taal voor de Java Virtual Machine

  • bouwt voort op de sterke punten van Java, maar heeft extra krachtige functies geïnspireerd op talen zoals Python, Ruby en Smalltalk

  • stelt moderne programmeerfuncties beschikbaar voor Java-ontwikkelaars met een leercurve van bijna nul

  • biedt de mogelijkheid om statisch controle uit te voeren en uw code statisch te compileren voor robuustheid en prestaties

  • ondersteunt domeinspecifieke talen en andere compacte syntaxis zodat uw code gemakkelijk te lezen en te onderhouden is

  • maakt schrijven van shell en scripts eenvoudig met zijn krachtige verwerkingsprimitieven, OO-mogelijkheden en een Ant DSL

  • verhoogt de productiviteit van ontwikkelaars door steigercode te verminderen bij het ontwikkelen van web-, GUI-, database- of consoletoepassingen

  • vereenvoudigt testen door unit-testing te ondersteunen en out-of-the-box te bespotten

  • integreert naadloos met alle bestaande Java-klassen en bibliotheken

  • compileert rechtstreeks naar Java bytecode, zodat u het overal kunt gebruiken waar u Java gebruikt

versies

Hallo Wereld

De Groovy-versie van Hello World.

println 'Hello World!'
 

Hallo wereld in groovy

Het volgende voorbeeld illustreert de eenvoudigste Hello World in groovy met behulp van het script, plaats het volgende codefragment in een bestand, zeg helloWorld.groovy

println 'Hello World!'
 

Hoe uit te voeren: op de opdrachtregel, groovy helloWorld.groovy

Output: Hello World!

Hallo wereld Shebang (linux)

Gegeven een hello.groovy-bestand met inhoud:

#!/usr/bin/env groovy
println "Hello world"
 

Kan worden uitgevoerd vanaf de opdrachtregel als uitvoeringstoestemming is gegeven als

$ ./hello.groovy
 

Installatie of instellingen

Er zijn twee veel voorkomende manieren om Groovy te installeren.

Download

Het Groovy-binaire bestand kan worden gedownload op de downloadpagina van de Groovy-website. U kunt het archief uitpakken en een pad toevoegen aan %GROOVY_HOME%/bin/groovy.bat aan de omgevingsvariabele PATH-systeem, waarbij% GROOVY_HOME% de map is waarin Groovy is uitgepakt.

SDKMAN

De andere optie is om SDKMAN te gebruiken. Deze optie is snel in populariteit gegroeid en maakt het beheren van meerdere versies van Groovy erg eenvoudig. Het ondersteunt ook andere toepassingen in de ecosfeer "GR8". Deze optie werkt uitstekend op Linux en Mac, maar vereist Cygwin op Windows.

Volg de instructies op de Groovy-downloadpagina en voer de volgende stappen uit om SDKMAN te installeren.

$ curl -s get.sdkman.io | bash

Nadat SDKMAN is geïnstalleerd, hebt u nu toegang tot de opdracht sdk . Met deze opdracht kunt u veel nuttige dingen doen.

Groovy installeren

$ sdk install groovy

Hiermee wordt de nieuwste versie van Groovy geïnstalleerd.

Lijstversies van Groovy

$ sdk ls groovy

Hiermee kun je een Linux-stijl ls opdracht uitvoeren op de Groovy-software, met een lijst van alle beschikbare opties. Er is een * naast elke geïnstalleerde versie en een > om uw huidige versies aan te geven.

Schakel versies van Groovy

$ sdk use groovy 2.4.7

Hiermee wordt de huidige versie van Groovy gewijzigd in 2.4.7. Als u andere versies hebt geïnstalleerd, kunt u naar een van deze overschakelen.

U kunt de huidige versie van groovy weergeven met de opdracht groovy -version .

posh-GVM

De initiële naam van SDKMAN was GVM en posh-gvm is een poort van GVM voor de Windows Powershell. Dus als je je ontwikkelt op een Windows-machine en geen SDKMAN op Cygwin wilt gebruiken, is posh-gvm iets voor jou. Het werkt hetzelfde als SDKMAN, maar in plaats van sdk is het commando gmv . Zo

PS C:\Users\You> gmv install groovy
 

zal groovy installeren via posh-gvm op uw Windows-machine.

Groovy gebruiken op een Java-project

Groovy heeft toegang tot alle Java-klassen, in feite zijn Groovy-klassen Java-klassen en kunnen rechtstreeks door de JVM worden uitgevoerd. Als u aan een Java-project werkt, is het gebruik van Groovy als een eenvoudige scripttaal om met uw Java-code te communiceren geen probleem.

Om dingen nog beter te maken, kan bijna elke Java-klasse worden hernoemd naar .groovy en gecompileerd en uitgevoerd en werkt precies zoals het deed, groovy is bijna een superset van Java, dit is een verklaard doel van groovy.

Groovy heeft een REPL. groovysh geleverd met Groovy en kan worden gebruikt om een Java-klasse snel te instantiëren en te testen als je classpath correct is ingesteld. Als uw classpath bijvoorbeeld naar uw map "klassen / bin" van de eclipse groovysh , kunt u uw bestand opslaan in eclipse, naar groovysh springen en de klasse instantiëren om het te testen.

De redenen om Groovy te gebruiken om dit te doen in plaats van alleen Java zijn: De classloader is GEWELDIG bij het oppakken van nieuwe klassen terwijl deze worden gecompileerd. Over het algemeen hoef je groovysh niet te verlaten / opnieuw te starten terwijl je ontwikkelt.

De syntaxis is TERSE. Dit is niet geweldig voor onderhoudbare code, maar voor scripts en tests kan het je code aanzienlijk verlagen. Een van de grote dingen die het doet, is het uitschakelen van aangevinkte uitzonderingen (of, beter gezegd, zet alle aangevinkte uitzonderingen om in niet-aangevinkte uitzonderingen). Dit wordt code als volgt (Hallo afdrukken na één seconde):

class JavaClass {
    public static void main(String[] args) {
        try {
            Thread.sleep(1000);
        } catch(InterruptedException e) {
            // You shouldn't leave an empty catch block, but who cares if this was interrupted???
        }
        System.out.println("Hello!");
    }
}
 

in Groovy's:

Thread.sleep(1000)
print "Hello!"
 

Groovy heeft ook een zeer strakke initialisatiesyntaxis. Hiermee kunt u gegevens opgeven zoals u wilt, zonder erover na te denken:

In Java om een kaart te initialiseren, moet u waarschijnlijk zoiets doen:

String[] init = { "1:Bill", "2:Doug", "3:Bev" };
// Note the rest of this can be put in a function and reused or maybe found in a library, but I always seem to have to write this function!
Map m = new HashMap<Integer, String>();
for(String pair : int) {
    String[] split = pair.split(":");
    m.put(new Integer(split[0]), split[1])
}
 

Dit is niet slecht, maar het is iets anders om te onderhouden. In groovy zou je gewoon gebruiken:

Map map = { 1 : "Bill", 2 : "Doug", 3 : "Bev" }
 

En je bent klaar. Lijstsyntaxis is net zo eenvoudig.

Het andere echt grote voordeel is de syntaxis van groovy voor sluiting. Het is verbazingwekkend kort en leuk, iets moeilijker te onderhouden, maar voor scripts is dat geen prioriteit. Als voorbeeld is hier een aantal groovy code om alle .txt bestanden te vinden die het woord Hello bevatten in de huidige map:

println new File('.').files.findAll{ it.name.endsWith('.txt') && it.text.contains('Hello') }.collect{ it.name }
 

In dit voorbeeld worden enkele "Groovy" -trucs gebruikt:

  • .files verwijst naar de methode getFiles() - groovy kan naar getFiles() schakelen tussen getter / setter en eigenschappensyntaxis

  • it. verwijst naar het huidige element van een iteratie. { it } is een snelkoppeling voor { it -> it } , bijvoorbeeld:

    [1, 2, 3] .collect {it ^ 2} == [1, 4, 9]

  • it.text (waar it een bestand is) gebruikt een groovy-methode die aan File wordt toegevoegd om de volledige tekst van het bestand op te halen. Dit is ongelooflijk nuttig in scripts.

Inject () gebruiken op lijst om CSV-tekenreeks te maken

In Groovy is de methode inject () een van de cumulatieve methoden waarmee we nieuwe functionaliteit kunnen toevoegen (of injecteren) in elk object dat de methode inject () implementeert. In het geval van een verzameling kunnen we een afsluiting uniform toepassen op een verzameling objecten en vervolgens de resultaten samenvoegen tot een enkele waarde. De eerste parameter voor de methode inject () is de beginwaarde van de cumulatie en de tweede parameter is de afsluiting.

In dit voorbeeld nemen we een lijst met tekenreeksen als parameter en voeren we de waarden uit van die tekenreeksen gescheiden door komma's. Ik heb deze functionaliteit gebruikt om een zoeklijst aan een REST-queryreeks toe te voegen en, als u deze een beetje wijzigt, heb ik deze gebruikt om waarden in een SQL-instructie op te nemen als onderdeel van een IN-clausule. Hier is de code om dit te doen:

public String convertToCSV( List<String> list ) {
    if (list == null) {
        return ""
    }
    return list.inject( '' ) { result, item ->
        result + ( result && item ? ',' : '' ) + ( item ? "${item.trim()}" : '' )
    }
}

assert convertToCSV( null ) == ""
assert convertToCSV( ["aaa", "bbb  ", null, "  ccc  "] ) == "aaa,bbb,ccc" 
 

In dit voorbeeld is de eerste parameter voor de methode inject () een tekenreeks met lengte nul, wat betekent dat bij het verwerken van het eerste element van de lijst het resultaat ook een tekenreeks met lengte nul is. Dit lost op in de eerste ternaire evaluatie en daarom krijgen we geen komma aan het begin van de string. Met elke opeenvolgende iteratie door de elementen van de lijst, wordt het resultaat de aaneenschakeling van zichzelf, een komma en vervolgens het volgende item totdat we het laatste item in de lijst bereiken.

Het voordeel van deze aanpak is dat u geen variabele buiten een lusconstructie nodig hebt om het aaneengeschakelde String-resultaat te bevatten. De implicatie is dat dit kan leiden tot bijwerkingen in uw code. Met de methode inject () wordt dit gedrag geïnjecteerd en verzamelt de verzameling het resultaat van de oproepen voor de sluiting. Het nadeel van deze benadering kan de leesbaarheid zijn. Maar met enige ervaring wordt het gemakkelijker om te lezen en te begrijpen, en ik hoop dat dit voorbeeld u helpt dat doel te bereiken.