Introduccion A Groovy

Introducción a Groovy

Acerca del presentador

Desarrollador Java desde 1996

Fan de Groovy desde 2006 dado que a veces Java estorbaba

Miembro del equipo Groovy desde Agosto 2007

Fundador de proyectos como JideBuilder, GraphicsBuilder, WingSBuilder, Grapplet y Json-lib

Agenda

Qué es Groovy?

De Java a Groovy

Características I (cerca de casa)‏

Características II (explorando el vecindario)‏

Características III (al infinito y mas allá!)‏

Groovy & Spring

Que es Groovy?

Groovy es un lenguage ágil y dinámico para la Máquina Virtual de Java

Basado en los conceptos base del lenguage Java, incluye características inspiradas en otros lenguages como Python, Ruby y Smalltalk.

Habilita características de programación modernas con una curva de aprendizaje prácticamente plana para desarrolladores Java

Soporta Lenguages de Dominio Específico y otras carcaterísticas de syntaxis corta

Que es Groovy?

Simplifica el ciclo de pruebas dado que soporta pruebas unitarias y mocking desde el inicio.

Se integra sin problemas con cualquier objecto y/o librería Java existentes

Compila directamente a código byte (igual que Java) puede ser usado virtualmente en cualquier lugar donde Java puede serlo también

De Java a Groovy

HolaMundo en Java

public class HelloWorld {

String name;

public void setName(String name)‏

{ this.name = name; }

public String getName(){ return name; }

public String greet()‏

{ return “Hello “ + name; }

public static void main(String args[]){

HelloWorld helloWorld = new HelloWorld()‏

helloWorld.setName( “Groovy” )‏

System.err.println( helloWorld.greet() )‏

}

}

HolaMundo en Groovy

String name;

{ return “Hello “ + name; }

helloWorld.setName( “Groovy” )‏

}

}

Paso 1: Adios a lo obvio

Toda clase, método, campo en Groovy tiene acceso público a menos de que se especifique lo contrario

';' es opcional al final de línea en la mayoría de los casos

Paso 1: Resultado

class HelloWorld {

String name

void setName(String name)‏

{ this.name = name }

String getName(){ return name }

String greet()‏

{ return "Hello " + name }

static void main(String args[]){

helloWorld.setName( "Groovy" )‏

}

}

Paso 2: Adios a lo ceremonioso

Neal Ford proclama que el debate estático vs dinámico es en realidad ceremonia vs esencia

Según la convención JavaBeans, cada propiedad requiere de un par de métodos (get/set)‏

El método main() siempre require de String[] como parámetro

Imprimir a consola es muy común, acaso existe alguna manera mas corta?

Paso 2: Resultado

class HelloWorld {

String name

String greet()‏

static void main( args ){

println( helloWorld.greet() )‏

}

}

Paso 3: Tipos dinámicos

La palabra reservada def se usa cuando no es necesario indicar el tipo específico de una variable, método o campo (es como var en JavaScript)‏

Groovy averiguará el tipo correcto en tiempo de ejecución, esto habilita entre otras cosas lo que se conoce como duck typing

Paso 3: Resultado

class HelloWorld {

String name

def greet()‏

static def main( args ){

def helloWorld = new HelloWorld()‏

}

}

Paso 4: Usar interpolación de variables

Groovy permite la interpolación de variables a través de GStrings (similar a como lo hace Perl)‏

Basta con rodear una expresión con ${} en cualquier String

Paso 4: Resultado

class HelloWorld {

String name

def greet(){ return "Hello ${name}" }

static def main( args ){

def helloWorld = new HelloWorld()‏

}

}

Paso 5: Adios a otras palabras reservadas

La palabra return es opcional en muchos de los casos, el valor de retorno será el valor de la última expresión evaluada en el contexto

La palabra def no es necesaria cuando se trata de métodos estáticos

Paso 5: Resultado

class HelloWorld {

String name

def greet(){ "Hello ${name}" }

static main( args ){

def he new HelloWorld()‏

}

}

// OJO versiones anteriores del plugin de Groovy para Eclipse

// requieren que exista el método main definido de la siguiente

// manera

//

// static void main( String[] args )‏

Paso 6: POJOs con esteroides

Los POJOs (o POGOs en Groovy) tienen un constructor por omisión que acepta un Map, dando la impresión de usar parámetros con nombres

Los POGOs suportan la notación de arreglo (bean[prop]) o la notación de objeto (bean.prop) para acceder a sus propiedades (lectura/escritura)‏

Paso 6: Resultado

class HelloWorld {

String name

def greet(){ "Hello ${name}" }

static main( args ){

def helloWorld = new

HelloWorld(name: "Groovy" )‏

helloWorld.name = "Groovy"

helloWorld[ " name " ] = "Groovy"

}

}

Paso 7: Groovy soporta scripts

A pesar de que Groovy compila a código byte, soporta programas tipo script, los cuales también se compilan a código byte

Todo Script permite definir clases en cualquier parte

Todo script soporta definición de paquetes (package) puesto que al fin y al cabo también son clases Java

Paso 7: Resultado

class HelloWorld {

String name

def greet() { "Hello $name" }

}

def helloWorld = new HelloWorld(name : " Groovy" )‏

println helloWorld.greet()‏

Venimos desde aquí...

String name;

{ return "Hello " + name; }

}

}

... hasta acá

class HelloWorld {

String name

def greet() { "Hello $name" }

}

def helloWorld = new HelloWorld(name : " Groovy" )‏

println helloWorld.greet()‏

Características I

(cerca de casa)‏

El lema es ...

Java es Groovy, Groovy es Java

Groovy ofrece una curva de aprendizaje sencilla para desarrolladores Java. Puedes empezar con sintaxis Java y moverte poco a poc a la sintaxis Groovy

98% de código Java es código Groovy, virtualmente podrías renombar un archivo *.java a .groovy y compilaría

Problemas comunes

La sintaxis de Groovy no es un super-conjunto exacto de la sintaxis de Java dado que no soporta

Inicializadores literales de arreglos

int[] arreglo = { 1,2,3 }

definición de clases internas

instanciar clases internas no estáticas

A.B ab = instanciaA.new B()‏

Características I - JDK5

Groovy soporta anotaciones (JSR 175) iguales a las de Java, es mas, es el segundo lenguage en la JVM que las soporta.

hasta el momento no es definir anotaciones con Groovy

Groovy soporta Enums también

Por último también tiene habilitado el soporte de tipos genéricos, iguales a los de Java.

Características I - JDK5

Es posible hacer uso de número de argumentos variables (varargs) mediante dos formas

notación triple punto (JDK5)‏

último argumento es de tipo Object[]

Varargs en acción

class Calculator {

def addAllGroovy( Object[] args ){

int total = 0

for( i in args ) { total += i }

total

}

def addAllJava( int... args ){

int total = 0

for( i in args ) { total += i }

total

}

}

Calculator c = new Calculator()‏

assert c.addAllGroovy(1,2,3,4,5) == 15

assert c.addAllJava(1,2,3,4,5) == 15

Características II

(explorando el vecindario)‏

Miscelaneos

Parámetros con valor por omisión (PHP)‏

Parámetros con nombre (Ruby), en realidad no hay tales, pero se puede reusar el truco del constructor por omisión de los POGOs)‏

Sobrecarga de operadores através de convención de nombres

+ plus()‏

[] getAt() / putAt()‏

<< leftShift()‏

Closures

Closures pueden ser interpretadas como bloques de código reusable, probablemente las hayas visto en otros lenguages como JavaScript o Ruby

Closures substituyen a las clases internas en la mayoría de los casos

Groovy permite “forzar el tipo” de una Closure a una interface de 1 solo método (proxy)‏

Una closure tendrá un parámetro por omisión llamado it si es que no se defined parámetros para la misma

Ejemplos de Closures

def greet = { name -> println “Hello $name” }

greet( “Groovy” )‏

// prints Hello Groovy

def greet = { println “Hello $it” }

greet( “Groovy” )‏

// prints Hello Groovy

def iCanHaveTypedParametersToo = { int x, int y ->

println “coordinates are ($x,$y)”

}

def myActionListener = { event ->

// do something cool with event

} as ActionListener

Currying

Currying es una técnica de programación que transforma una función (o closure) de número de parámetros m a otra función con número de parámetros n , donde m > n, es decir reduce el número de parámetros, el valor de cada parámetro reducido queda fijado y no puede cambiarse

Currying en acción

// un closure con 3 parámetros, el tercero es opcional dado

// que define un valor por omisión

def getSlope = { x, y, b = 0 ->

println "x:${x} y:${y} b:${b}"

(y - b) / x

}

assert 1 == getSlope( 2, 2 )‏

def getSlopeX = getSlope.curry(5)‏

assert 1 == getSlopeX(5)‏

assert 0 == getSlopeX(2.5,2.5)‏

// prints

// x:2 y:2 b:0

// x:5 y:5 b:0

// x:5 y:2.5 b:2.5

Iteradores por doquier

Asi como en Ruby, puedes hacer uso de iteradores prácticamente en cualquier contexto

Los iteradores dependen del poder que otrogan las closures, básicamente todos soportan el uso de closures como parámetros

Los iteradores literalmente dejan obsoletos a las operaciones de ciclos

Iteradores en acción

def printIt = { println it }

// 3 ways to iterate from 1 to 5

[1,2,3,4,5].each printIt

1.upto 5, printIt

(1..5).each printIt

// compare to a regular loop

for( i in [1,2,3,4,5] ) printIt(i)‏

// same thing but use a Range

for( i in (1..5) ) printIt(i)‏

[1,2,3,4,5].eachWithIndex { v, i -> println "list[$i] => $v" }

// list[0] => 1

// list[1] => 2

// list[2] => 3

// list[3] => 4

// list[4] => 5

Características III

(al infinito y mas allá!)‏

La palabra reservada as

Permite “Groovy casting” , es decir, convertir un valor de tipoA a tipoB

def intarray = [1,2,3] as int[ ]

Permite forzar ( coerce ) un closure a una implemnetación anónima de una interface de un solo método

Permite forzar ( coerce ) un Map a una implementación de interface, clase abstracta o concreta

Permite crear alias en sentencias de importación

Algunos ejemplos de as

import javax.swing.table.DefaultTableCellRenderer as DTCR

def myActionListener = { event ->

// do something cool with event

} as ActionListener

def renderer = [

getTableCellRendererComponent: { t, v, s, f, r, c ->

// cool renderer code goes here

}

] as DTCR

// Nota esta técnica es similar a crear objetos en JavaScript

// con la notación JSON

Nuevos operadores

?: (elvis) - un refinamiento del operador ternario

?. referencia segura – permite navegar un grafo de objetos sin temor a NPE

<=> (spaceship) – compara dos valores

* (spread) – expande el contenido de una lista

*. (spread-dot) – aplica el método a todos los elementos de una lista

Navegando grafos de objetos

GPath es a objetos lo que XPath es a XML

*. y ?. son bastante útiles en esta situación

Escribir expresiones Gpath es muy sencillo dado que los POGOs aceptan notación de punto y arreglo

Ejemplos de GPath

class Person {

String name

int id

}

def persons = [

new Person( name: 'Duke' , id: 1 ),

[name: 'Tux' , id: 2] as Person

]

assert [1,2] == persons.id

assert [ 'Duke' , 'Tux' ] == persons*.getName()‏

assert null == persons[2]?.name

assert 'Duke' == persons[0].name ?: 'Groovy'

assert 'Groovy' == persons[2]?.name ?: 'Groovy'

Metaprogramación

Puedes agregar métodos y propiedades a un objeto en tiempo de ejecución

Puedes interceptar llamadas a métodos o acceso de propiedades (similar a AOP pero sin tanto problema)‏

Esto significa que Groovy ofrece un concepto similar a las clases abiertas en Ruby, es mas Groovy extiende clases finales como String e Integer

Ejemplo con categorías

class Pouncer {

static pounce( Integer self ){

def s = “Boing!"

1.upto(self-1) { s += " boing!" }

s + "!"

}

}

use ( Pouncer ){

assert 3.pounce() == “Boing! boing! boing!"

}

Ejemplo con Metaclases

Integer. metaClass.pounce << { ->

def s = “Boing!"

delegate.upto(delegate-1) { s += " boing!" }

s + "!“

}

assert 3.pounce() == “Boing! boing! boing!"

Groovy y Spring

Varias Alternativas

Compilar el código Groovy a código byte

Usar el módulo lang para referencia un archivo/script groovy

Insertar un script en la definición del contexto de aplicación (XML)‏

1. Compilar Groovy

El compilador de Groovy puede ser invocado de distintas maneras

comando groovyc

mediante una tarea de Ant (Groovyc)‏

mediante Gmaven, plugin para Maven2

Usando Gant (Groovy + Ant)‏

plugins para IDEs (Eclipse, IDEA, NetBeans)‏

2. El módulo lang

Requiere el uso del schema spring-lang

Se recomienda usar ApplicationContext , también se puede usar BeanFactory pero hay mas trabajo manual que realizar

La Inyección de Dependencias funciona de la misma manera

Referencia a clase Groovy

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance xmlns:lang="http://www.springframework.org/schema/lang "

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-2.5.xsd ">

<lang:groovy id="messenger" script-source=" classpath:Messenger.groovy ">

<lang:property name="message" value="Hola Mundo!" />

</lang:groovy>

<bean id="bookingService" class="x.y.DefaultBookingService">

<property name="messenger" ref="messenger" />

</bean>

</beans>

3. Scripts en línea

Requiere las mismas características que la opción anterior

Útil para crear implementaciones de clases ayundates como validadores

Ejemplo

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance xmlns:lang="http://www.springframework.org/schema/lang "

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-2.5.xsd ">