Tu banner alternativo

Apache Groovy

Apache Groovy è un argomento che ha catturato l'attenzione di milioni di persone in tutto il mondo. Dalla sua comparsa fino ad oggi, Apache Groovy ha suscitato grande interesse e dibattito nella società. Con opinioni diverse e posizioni contrastanti, questo tema è stato protagonista di numerosi studi, indagini e analisi. Dalle sue origini fino alla sua evoluzione, Apache Groovy ha lasciato un segno significativo nella storia e ha influenzato diversi aspetti della vita quotidiana. In questo articolo esploreremo a fondo Apache Groovy e analizzeremo il suo impatto sulla società moderna.

Tu banner alternativo
Disambiguazione – "Groovy" rimanda qui. Se stai cercando l'album di Red Garland, vedi Groovy (album).
Apache Groovy
linguaggio di programmazione
AutoreGuillaume Laforge
Data di origine2003
Ultima versione5.0.3 (30 novembre 2025)
UtilizzoGeneral purpose
ParadigmiOrientato agli oggetti, imperativa, scripting
TipizzazioneForte, Dinamica
Estensioni comunigroovy, gvy, gsh e gy
Influenzato daJava, Python, Ruby, Perl, Smalltalk, Objective-C
Implementazione di riferimento
Sistema operativoMultipiattaforma
LicenzaApache v. 2.0
Sito webgroovy-lang.org e groovy.apache.org/
Modifica dati su Wikidata · Manuale

Apache Groovy, fino al 2015 solo Groovy, è un linguaggio di programmazione a oggetti per la Piattaforma Java alternativo al linguaggio Java. È un linguaggio sia statico che dinamico, può quindi essere utilizzato sia come linguaggio di programmazione che come linguaggio di scripting. Presenta caratteristiche simili a quelle di Python, Ruby e Smalltalk. A volte ci si riferisce a Groovy con il nome alternativo di JSR 241.

Caratteristiche

Groovy usa una sintassi simile a quella di Java, basata su parentesi graffe, viene compilato in bytecode per la Java Virtual Machine, ed interagisce in modo trasparente con altro codice Java e con le librerie esistenti. Il compilatore di Groovy può essere usato per generare bytecode Java standard che può quindi essere usato da qualsiasi progetto Java. Groovy può anche venire usato come linguaggio di scripting dinamico.

Altre caratteristiche:

Confronto della sintassi

Standard Java (Java 5+)
for (String item : new String  {"Rod", "Carlos", "Chris"}) {
    if (item.length() <= 4) System.out.println(item);
}
Groovy
.findAll { it.size() <= 4 }.each { println it }

Getter, setter e visibilità

Rispetto a Java, Groovy consente di ridurre la dimensione del codice scritto generando automaticamente i metodi getter e setter per ogni classe e impostando la visibilità "public" di default, senza richiedere che venga specificata ogni volta.

Per creare una proprietà in sola lettura sarà sufficiente implementare il metodo getter omettendo il setter.

Un altro vantaggio è l'assenza del punto e virgola (;) come terminatore di linea.

Standard Java (Java 5+)
public class Libro {

    private String titolo;
    private String autore;

    public void setTitolo(String valore) {
        this.titolo = valore;
    }

    public String getTitolo() {
        return this.titolo;
    }

    // La proprietà 'author' non ha un metodo setter
    // ed è quindi in sola lettura

    public String getAutore() {
        return this.autore;
    }
}
Groovy
class Libro {

    String titolo
    String autore

    // La proprietà 'autore' definisce un metodo getter esplicito
    // che la rende in sola lettura

    String getAutore() {
        return autore
    }
}

Null Safe

Groovy definise degli operatori di confronto che riescono a gestire valori Null senza generare una eccezione[1]. Ad esempio: 

if (100 > null) {
    // Ritorna 'true' ed eseguirà il codice nel blocco
}

if (null > 100) {
    // Ritorna 'false' e NON eseguirà il codice nel blocco
}

Inoltre con la "Groovy Truth"[2] è possibile semplificare le espressioni che ritornano un valore booleano. Ad esempio le seguenti espressioni daranno come risultato sempre 'false': 

if (null) { ...    // null -> false
if (0) { ...       // 0 -> false
if ('') { ...      // Blank String -> false
if () { ...      // Empty List -> false
if () { ...     // Empty Map -> false

Traits

Groovy rende possibile l'ereditarietà multipla attraverso i 'traits'[3] 

trait Volatile {
    void vola() {
        println 'Sto volando!'
    }
}

trait Quadrupede {
    void trotta() {
        println 'Sto trottando!'
    }
}

class AnimaleFantastico implements Quadrupede, Volatile {
    void parla() {
        println 'Sto parlando :)'
    }
}

def miniPony = new AnimaleFantastico()
miniPony.trotta()
miniPony.vola()
miniPony.parla()

Esecuzione:
Sto volando!
Sto trottando!
Sto parlando :)

Supporto per linguaggi markup

Una caratteristica di Groovy che vale la pena sottolineare è il suo supporto nativo per vari linguaggi di markup come XML ed HTML. Questa caratteristica permette di definire e manipolare molti tipi di dati eterogenei con una sintassi ed una metodologia di programmazione uniformi.

Per esempio il seguente codice Groovy: 

    import groovy.xml.MarkupBuilder
    def myXMLDoc = new MarkupBuilder()
    myXMLDoc.workbook {
       worksheet(caption:"Employees") {
          row(fname:"John", lname:"McDoe")
          row(fname:"Nancy", lname:"Davolio")
       }
       worksheet(caption:"Products") {
          row(name:"Veeblefeetzer", id:"sku34510")
          row(name:"Prune Unit Zappa", id:"sku3a550")
       }
    }
    println myXMLDoc

Produce questo XML: 

    <workbook>
       <worksheet caption='Employees'>
          <row fname="John" lname="McDoe" />
          <row fname="Nancy" lname="Davolio" />
       </worksheet>
       <worksheet caption='Products'>
          <row name="Veeblefeetzer" id="sku34510" />
          <row name="Prune Unit Zappa" id="sku3a550" />
       </worksheet>
    </workbook>

Storia

James Strachan parlò per la prima volta dello sviluppo di Groovy sul suo blog nell'agosto 2003[4]. Diverse versioni furono pubblicate tra il 2004 ed il 2006. Dopo l'inizio del processo di standardizzazione JCP, la numerazione delle versioni fu cambiata e la versione chiamata "1.0" fu pubblicata martedì 2 gennaio 2007.

Dopo varie versioni beta e release candidate numerate come 1.1, il 7 dicembre 2007 Groovy 1.1 Final è stato pubblicato e rinumerato come Groovy 1.5, per evidenziare i grandi miglioramenti fatti rispetto alla precedente versione.

Versioni

Di seguito la lista delle versioni:[5][6]

  • 1.0 uscita a gennaio 2007, richiede JDK 1.4
  • 2.0 uscita a giugno 2012, richiede almeno JDK 1.5 e introduce la compilazione statica e il type checking statico.
  • 2.4 uscita a gennaio 2015, richiede almeno JDK 1.6, dalla versione 2.4.4 il linguaggio Groovy viene pubblicato dalla Apache Software Foundation e diventa Apache Groovy[7]
  • Groovy 2.5 è uscito a maggio 2018, richiede almeno JDK 1.7
  • Groovy 3.0 è uscito a febbraio 2020, richiede almeno JDK 1.8 e introduce un nuovo parser più flessibile (chiamato "Parrot")[8]
  • Groovy 4.0 è uscito a gennaio 2022, richiede almeno JDK 1.8, implementa un supporto migliorato per JPMS ed è la prima versione a utilizzare "org.apache.groovy" come coordinata Maven[9]
  • Dalla versione 5.0 il requisito minimo è JDK 11 [10]

Note

  1. ^ Operatori di confronto Null-Safe, su docs.oracle.com.
  2. ^ Groovy Truth, su groovy-lang.org.
  3. ^ Groovy Traits, su groovy-lang.org.
  4. ^ (EN) James Strachan's Weblog, su radio.weblogs.com (archiviato dall'url originale il 5 aprile 2007).
  5. ^ Changelog delle versioni di Apache Groovy, su groovy-lang.org.
  6. ^ Versioni JDK richieste in base alla versione di Groovy, su groovy.apache.org.
  7. ^ Comunicazione ufficiale nella mailing list di sviluppo, su lists.apache.org.
  8. ^ 3.0 Release Notes, su groovy-lang.org.
  9. ^ 4.0 Release Notes, su groovy-lang.org.
  10. ^ 5.0 Release Notes, su groovy-lang.org.

Voci correlate

Altri progetti

Collegamenti esterni

Controllo di autoritàLCCN (EN) sh2007001244 · J9U (EN, HE) 987007549666405171
Enciclo
Wikious
Sapientia
Scientia
Boobota
Anandapedia
Sagapedia
Wikithot