Lo nuevo de Groovy 2.0

Recordaremos primero lo que llevaba Groovy 1.8:

– Mejores DSLs con command chains
 Una sintaxis mejorada en donde puedes eliminar puntos y paréntesis cuando encadenas varias llamadas a métodos.
– Mejoras en el rendimiento en tiempo de ejecución
– GPars está ya agrupado dentro de la distribución de Groovy
– Mejoras en las Closures
 Anotaciones con closures como parámetros y método memoize() en closures para cachear un número de invocaciones.
– Soporte mejorado para la producción, construcción e impresión de JSON
– Nuevas transformaciones AST
 4 loggers diferentes pueden ser inyectados (@Log, @Commons, @Log4j y @Slf4j) o posiblidad de implementar tu propia estrategia.

import groovy.util.logging.*

@Log
class Car{
  Car() {
     log.info 'Car constructed'
  }
}

def car = new Car()

@Field
@AutoClone y @AutoExternalizable
@Canonical
 @toString: para crear un método toString() a tus tipos.

import groovy.transform.ToString

@ToString
class Person {
  String name
  int age
}

println new Person(name:'Edu', age:31)
// => Person(Edu,31)

 @EqualsAndHashCode: para crear una implemetación por defecto de equals() y hashCode()

import groovy.transform.EqualsAndHashCode

@EqualsAndHashCode
class Coord {
  int x, y
}

def c1 = new Coord(x:20,y:10)
def c2 = new Coord(x:20,y:10)

assert c1==c2
assert c1.hashCode()==c2.hashCode()

 @TupleConstructor: crea un clásico constructor con todas las propiedades

import groovy.transform.TupleConstructor

class Person {
  String name
  int age
}

def person = new Person(name:'Edu', age:31)
assert person.name=='Edu'
assert person.age==31

Controlar la ejecución del código para cuando el código entra en un bucle infinito o consume muchos recursos. Se hace con las 3 nuevas anotaciones: @ThreadInterrupt, @TimeInterrupt y @ConditionalInterrupt.

import groovy.transform.ThreadInterrupt

@ThreadInterrupt
void main(){
  while(true){
    if(Thread.currentThread().isInterrupted())
      throw new InterruptedException()
    //eat lots of CPU
  }
}

@InheritConstructor: para que se pinten todos los constructores heredados
@WithReadLock y @WithWriteLock
@ListenerList

Lo nuevo de Groovy 2.0 (NO INCLUIDO EN GRAILS 2):

– Alineaciones con JDK 7: Proyecto Coin (Binary literals, Underscore en literales y Multicatch) y InvokeDynamic ()

//Ejemplo de Multicatch
  try{
      ...
  }catch(IOException | NullPointerException e){
    //Un bloque para tratar 2 excepciones
  }

– Continuan las mejoras de rendimiento en tiempo de ejecución
– Modularidad (todos los jars de Groovy pesan 6 Mb, con un pequeño core (3 Mb) y un pequeño jar por feature)
 console – jsr-223 – test – docgenerator – jmx – testng – groovydoc – sql – json – groovysh – swing – xml – ant – servlet – bsf – templates.
Dejaremos las dos más importantes features para el final: static type checking y static compilation.

@TypeChecked
Puede estar a nivel de clase o de método. Ayuda a comprobar errores de compilación (no en tiempo de ejecución). No todo el tiempo necesitas las features dinámicas. Comprueba tipos en métodos y variables, asignaciones erroneas, tipos devueltos erroneos y tipos heredados.

import  groovy.transform.TypeChecked

void  method() { ... }   

@TypeChecked  
test() {
  // No se puede encontrar el método  metthhoood()        
  metthhoood()          
  def  name  =  "Eduuuuuu"        
  // Variable  naamme  no está declarada       
  println  naamme 
}

La anotación @TypeChecked funciona en tiempo de compilación y no cambia el comportamiento del código. La mayoría de las features dinámicas no pueden ser @TypeChecked. Sin embargo, la metaprogramación funciona en tiempo de compilación.

@CompileStatic
Esto quiere decir que todo el código se compila estáticamente, es decir genera el mismo byte code que si lo compilásemos con javac.
Ventajas que consigues:
- Tipado seguro
- Código más rápido (casi a la altura de Java)
- Código inmune
- Byte code generado más pequeño
Desventajas
- Pierdes las features dinámicas
- Pierdes el método dispatch

import  groovy.transform.CompileStatic  

@CompileStatic
test() { ... }