• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Introduccion A Groovy
 

Introduccion A Groovy

on

  • 10,190 views

Presentación introductoria a Groovy en la primera reunión de la comunidad Springhispano.org

Presentación introductoria a Groovy en la primera reunión de la comunidad Springhispano.org

Statistics

Views

Total Views
10,190
Views on SlideShare
9,391
Embed Views
799

Actions

Likes
6
Downloads
171
Comments
0

16 Embeds 799

http://www.programundo.com 293
http://springhispano.org 164
http://www.springhispano.org 152
http://www.domix.org 123
http://www.jroller.com 22
http://www.slideshare.net 19
http://jroller.com 6
http://reyesmjm.org 6
https://twitter.com 4
http://xss.yandex.net 2
file:// 2
http://flavors.me 2
http://www.groovygrails.com 1
http://presentacion.org 1
https://springhispano.org 1
http://www.nofluffjuststuff.com 1
More...

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Introduccion A Groovy Introduccion A Groovy Presentation Transcript

    • 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
      • 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() )‏
      • }
      • }
    • 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 helloWorld = new HelloWorld()‏
      • helloWorld.setName( "Groovy" )‏
      • System.err.println( helloWorld.greet() )‏
      • }
      • }
    • 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()‏
      • { return "Hello " + name }
      • static void main( args ){
      • HelloWorld helloWorld = new HelloWorld()‏
      • helloWorld.setName( "Groovy" )‏
      • 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()‏
      • { return "Hello " + name }
      • static def main( args ){
      • def helloWorld = new HelloWorld()‏
      • helloWorld.setName( "Groovy" )‏
      • println( helloWorld.greet() )‏
      • }
      • }
    • 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()‏
      • helloWorld.setName( "Groovy" )‏
      • println( helloWorld.greet() )‏
      • }
      • }
    • 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()‏
      • helloWorld.setName( "Groovy" )‏
      • println( helloWorld.greet() )‏
      • }
      • }
      • // 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"
      • println( helloWorld.greet() )‏
      • }
      • }
    • 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í...
      • 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() )‏
      • }
      • }
    • ... 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 &quot;x:${x} y:${y} b:${b}&quot;
      • (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 &quot;list[$i] => $v&quot; }
      • // 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!&quot;
      • 1.upto(self-1) { s += &quot; boing!&quot; }
      • s + &quot;!&quot;
      • }
      • }
      • use ( Pouncer ){
      • assert 3.pounce() == “Boing! boing! boing!&quot;
      • }
    • Ejemplo con Metaclases
      • Integer. metaClass.pounce << { ->
      • def s = “Boing!&quot;
      • delegate.upto(delegate-1) { s += &quot; boing!&quot; }
      • s + &quot;!“
      • }
      • assert 3.pounce() == “Boing! boing! boing!&quot;
    • 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=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?>
      • <beans xmlns=&quot;http://www.springframework.org/schema/beans&quot; xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance xmlns:lang=&quot;http://www.springframework.org/schema/lang &quot;
      • xsi:schemaLocation=&quot;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 &quot;>
      • <lang:groovy id=&quot;messenger&quot; script-source=&quot; classpath:Messenger.groovy &quot;>
      • <lang:property name=&quot;message&quot; value=&quot;Hola Mundo!&quot; />
      • </lang:groovy>
      • <bean id=&quot;bookingService&quot; class=&quot;x.y.DefaultBookingService&quot;>
      • <property name=&quot;messenger&quot; ref=&quot;messenger&quot; />
      • </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=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?>
      • <beans xmlns=&quot;http://www.springframework.org/schema/beans&quot; xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance xmlns:lang=&quot;http://www.springframework.org/schema/lang &quot;
      • xsi:schemaLocation=&quot;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 &quot;>
      • <lang:groovy id=&quot;messenger&quot;>
      • <lang:inline-script>
      • class GroovyMessenger implements Messenger { String message }
      • </lang:inline-script>
      • <lang:property name=&quot;message&quot; value=&quot;Hola Mundo!&quot; />
      • </lang:groovy>
      • </beans>
    • Preguntas y Respuestas
    • Información adicional
      • Groovy, guías, ejemplos
        • http://groovy.codehaus.org
      • Groovy Eclipse Plugin
        • http://groovy.codehaus.org/Eclipse+Plugin
      • Noticias Groovy
        • http://aboutgroovy.com
        • http://groovyblogs.org
        • http://groovy.dzone.com
        • http://groovy.org.es
      • Mi blog sobre Groovy/Java/Swing
        • http://jroller.com/aalmiray
    • Gracias!