groovy
chiusure

Chiusura con parametri espliciti

def addNumbers = { a, b -> a + b }
addNumbers(-7, 15) // returns 8

Chiusura con parametri impliciti

['cat', 'dog', 'fish'].collect { it.length() }

it è il nome predefinito del parametro se si dispone di un singolo parametro e non chiami in modo esplicito il parametro. Puoi anche dichiarare il parametro facoltativamente.

['cat', 'dog', 'fish'].collect { animal -> animal.length() }

Conversione dei metodi in chiusure

Un metodo può essere convertito in una chiusura usando l'operatore & .

def add(def a, def b) { a + b }    

Closure addClosure = this.&add
assert this.add(4, 5) == addClosure(4, 5)

Chiusura con target personalizzato per chiamate di metodo con ricevitore implicito

class MyHello {
  def sayHello() {
    "Hello, world"
  }
}

def cl = { sayHello() }
cl() // groovy.lang.MissingMethodException    
cl.delegate = new MyHello()
cl(); // "Hello, world"

Utilizzato estesamente da Groovy DSL.

Avvolgimento del comportamento attorno a una chiusura con un metodo

Ci sono schemi comportamentali frequenti che possono comportare un sacco di codice boilerplate. Dichiarando un metodo che accetta una Closure come parametro, è possibile semplificare il programma. Ad esempio, è uno schema comune per recuperare una connessione al database, avviare una transazione, eseguire il lavoro, quindi eseguire il commit della transazione o eseguire il rollback della connessione (in caso di errore), quindi chiudere la connessione:

def withConnection( String url, String user, String pass, Closure closure) {
    Connection conn = null
    try {
        conn = DriverManager.getConnection( url, user, pass )
        closure.call( conn )
        conn.commit()
    } catch (Exception e) {
        log.error( "DB Action failed", e)
        conn.rollback()
    } finally {
        conn?.close()
    }
}


withConnection( DB_PATH, DB_USER, DB_PASS ) { Connection conn ->
    def statement = conn.createStatement()
    def results = statement.executeQuery( 'SELECT * FROM users' )
    // ... more processing ...
}

Crea chiusure, assegna a proprietà e chiama

Creiamo una mappa e una chiusura per stampare ciao

def exMap = [:]

def exClosure = {
    println "Hello"
}

Assegna chiusura a una proprietà sulla mappa

exMap.closureProp = exClosure

Chiamare la chiusura

exMap.closureProp.call()

Produzione

Hello

Un altro esempio: consente di creare una classe con proprietà di base e assegnare la stessa chiusura a un oggetto

class Employee {
    def prop
}

def employee = new Employee()

employee.prop = exClosure

Chiama la chiusura attraverso quella proprietà

employee.prop.call()

Produzione

Hello