Your SlideShare is downloading. ×
Introducción a Groovy
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Introducción a Groovy

1,385
views

Published on

Published in: Technology

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
1,385
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
43
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide
  • Java - Boiler Plate Code  (Sintaxis mas relajada) + Dynamic Typing (Duck typing) Optional typing Optional Compilation Meta-object Protoco + Closures (De verdad) Groovy Closures Como una funcion anonima. Pero usada en el ambito en el que se encuentra. + DSL + Builders + Metaprograming + GDK
  • Transcript

    • 1. Introducción a http://twitter.com/highwayman [email_address] http://linkd.in/davidsantamaria por David Santamaria
    • 2. Agenda
        • ¿Que es Groovy?
        • ¿Por que Groovy?
        • Goodies.
        • Mejoras respecto a Java.
        • Comenzamos.
        • Lenguaje Basicos.
    • 3. ¿Qué es Groovy?
      • Groovy es un lenguaje Dinamico para la JVM que permite el uso de caracteristicas de otros lenguajes como Ruby para la comunidad Java.
      • http://groovy.codehaus.org/
    • 4. ¿Qué mas es Groovy?
      • Groovy también es ...
      • agil, dinamico, compacto, sin curva de aprendizaje, con DSL, soporte de scripts, Totalmente OO, Integrado con Java (Sintaxis Java y Produce Bytecode).
    • 5. ¿Qué es Groovy? (para los developers)
      • Groovy es un "superset" de Java.
      • Groovy = Java - Boiler Plate Code
      •                 + Dynamic Typing
      •                 + Closures
      •                 + DSL
      •                 + Builders
      •                 + Metaprograming
      •                 + GDK
      •                 - Errores de compilacion
      •                 - Ligeramente mas lento
    • 6. ¿Por que Groovy?
        • Java Platform!
          • Se ejecuta en la JVM (si hay una JVM puedes ejecutar Groovy).
          • Usa librerias Java.
          • Embebida en Aplicaciones de Escritorio Java.
          • Embebida en aplicaciones J2EE
          • Test con JUnit
          • Debug con Eclipse, IntelliJ, Netbeans.
          • Code Coverage con Cobertura.
        • No requiere aprender nuevas APIS (Jython, JRuby,...)
        • Rhino es interesante pero es JavaScript :)
    • 7. Goodies
        • Tipado Dinamico y estatico.
        • Totalmente orientado a objetos. (Todo es un Objeto)
        • Closures.
        • Sobrecarga de operadores.
        • Multimethods.
        • Declaracion Literal de Listas (Arrays), maps, ranges, y expresiones regulares. (Soporte Nativo!)
        • Metaprogramación.
        • Y Mas...
          • GPath.
          • Builders.
          • Groovy Beans.
    • 8. HelloWorld.java
      • public class HelloWorld {
      • public static void main(String[] args){
      • HelloWorld hw = new HelloWorld();
      • hw.setNombre(" Groovy ");
      • System. out .println(hw.saluda());
      • }
      • String nombre ;
      • public String getNombre() {   return nombre ;  }
      • public void setNombre(String nombre) {  
      •              this . nombre = nombre; 
      •          }
      • public String saluda(){  return "Hola " + nombre ;}
      • }
    • 9. HelloWorld.groovy
      • public class HelloWorld {
      • public static void main(String[] args){
      • HelloWorld hw = new HelloWorld();
      • hw.setNombre(" Groovy ");
      • System. out .println(hw.saluda());
      • }
      • String nombre ;
      • public String getNombre() {   return nombre ;  }
      • public void setNombre(String nombre) {  
      •              this . nombre = nombre; 
      •          }
      • public String saluda(){  return "Hola " + nombre ;}
      • }
    • 10. HelloWorld.groovy
      • public class HelloWorld {
      • public static void main(String[] args){
      • HelloWorld hw = new HelloWorld()
      • hw.setNombre(" Groovy ")
      • System. out .println(hw.saluda())
      • }
      • String nombre ;
      • public String getNombre() {   return nombre  }
      • public void setNombre(String nombre) {  
      •              this . nombre = nombre
      •          }
      • public String saluda(){  return "Hola " + nombre }
      • }
      ; opcionales!
    • 11. HelloWorld.groovy
      • class HelloWorld {
      • static void main(String[] args){
      • HelloWorld hw = new HelloWorld()
      • hw.setNombre(" Groovy ")
      • System. out .println(hw.saluda())
      • }
      • String nombre ;
      • String getNombre() {   return nombre  }
      • void setNombre(String nombre) {  
      •              this . nombre = nombre
      •          }
      • String saluda(){  return "Hola " + nombre }
      • }
      public por defecto!
    • 12. HelloWorld.groovy
      • class HelloWorld {
      • static void main(String[] args){
      • HelloWorld hw = new HelloWorld()
      • hw.nombre(" Groovy ")
      • System. out .println(hw.saluda())
      • }
      • String nombre ;
      • String saluda(){  return "Hola " + nombre }
      • }
      getters and setters autogenerados!
    • 13. HelloWorld.groovy
      • class HelloWorld {
      • static void main(String[] args){
      • HelloWorld hw = new HelloWorld()
      • hw.nombre(" Groovy ")
      • System. out .println(hw.saluda())
      • }
      • String nombre ;
      • String saluda(){ "Hola " + nombre }
      • }
      return opcional!
    • 14. HelloWorld.groovy
      • class HelloWorld {
      • static void main(String[] args){
      • HelloWorld hw = new HelloWorld()
      • hw.nombre(" Groovy ")
      • System. out .println(hw.saluda())
      • }
      • def   nombre ;
      • def saluda(){ "Hola " + nombre }
      • }
      Tipado Dinamico!
    • 15. HelloWorld.groovy
      • class HelloWorld {
      • static void main(String[] args){
      • HelloWorld hw = new HelloWorld()
      • hw.nombre(" Groovy ")
      • println (hw.saluda())
      • }
      • def  nombre ;
      • def saluda(){ "Hola " + nombre }
      • }
      • Incluido por defecto:
        • java.io.*
        • java.lang.*
        • java.math.BigDecimal
        • java.math.BigInteger
        • java.net.*
        • java.util.*
        • groovy.lang.*
        • groovy.util.*
    • 16. HelloWorld.groovy
      • class HelloWorld {
      • static void main(String[] args){
      • HelloWorld hw = new HelloWorld()
      • hw.nombre(" Groovy ")
      • println(hw.saluda())
      • }
      • def  nombre
      • def saluda(){  "Hola ${nombre}" }
      • }
      GStrings!
    • 17. HelloWorld.groovy
      • HelloWorld hw = new HelloWorld()
      • hw.nombre(" Groovy ")
      • println(hw.saluda())
      • class  HelloWorld {
      • def  nombre
      • def saluda(){ "Hola ${nombre} " }
      • }
      Declaracion de clases opcional para Scripts!
    • 18. HelloWorld.groovy
      • HelloWorld hw = new HelloWorld()
      • hw.nombre " Groovy "
      • println hw.saluda()
      • class  HelloWorld {
      • def  nombre
      • def saluda(){ "Hola ${nombre} " }
      • }
      Parentesis opcionales en la mayoria de casos.
    • 19. HelloWorld.java
      • public class HelloWorld {
      • public static void main(String[] args){
      • HelloWorld hw = new HelloWorld();
      • hw.setNombre(" Groovy ");
      • System. out .println(hw.saluda());
      • }
      • String nombre ;
      • public String getNombre() {   return nombre ;  }
      • public void setNombre(String nombre) {  
      •              this . nombre = nombre; 
      •          }
      • public String saluda(){  return "Hola " + nombre ;}
      • }
    • 20. HelloWorld.groovy
      • HelloWorld hw =  new  HelloWorld()
      • hw.nombre " Groovy "
      • println hw.saluda()
      • class  HelloWorld {
      • def  nombre
      • def saluda(){ "Hola ${nombre} "  }
      • }
    • 21. Comenzamos!
        • Descargamos la ultima version de Groovy
      • http://groovy.codehaus.org/
        • Descomprimimos en un directorio.
        • Añadimos la variable de entorno GROOVY_HOME .
      • Y %GROOVY_HOME%/bin a la variable PATH .
        • Escribimos groovy -version
    • 22. Comenzamos! (II)
      • groovyconsole
      • println "Hola Mundo!"
      • Ctrl + R
    • 23. Lenguaje: Strings and GStrings.
        • Comillas Simples para Strings .
        • Comillas dobles para GStrings : Son como Strings pero soportan expresiones: ${expression}.
        • Strings multi-linea .
    • 24. Lenguaje: Strings and GStrings.
        • Slashy Strings : Como GStrings  con soporte para Expresiones Regulares.
        • - Muchas mas operaciones...
      http://groovy.codehaus.org/Strings+and+GString http://groovy.codehaus.org/JN1525-Strings
    • 25. Lenguaje: Numbers
      • Java:
        • Java soporta tipos primitivos y Objetos.
        • Tiene Wrappers para permitir la conversion.
        • Java 5+ hay autoboxing /autoUnboxing.
      • Groovy:
        • Todo es un objeto en el lenguaje.
          • El realiza el autoboxing cuando es mezclado con Java.
        • BigDecimal es el tipo por defecto (excepto Integers).
        • Sobrecarga de operadores.
      • http://groovy.codehaus.org/JN0515-Integers
      • http://groovy.codehaus.org/JN0525-Decimals
      • http://groovy.codehaus.org/JN0535-Floats
    • 26. Lenguaje: Numbers
    • 27. Lenguaje: Collections
      • Map map = new HashMap ()
      • map . put ( "nombre" , "David" )
      • map . put ( "edad" ,30);
      • map . get ( "valor" );
      • List list = new ArrayList (
      •      Arrays . asList (
      •      "primero" , "segundo" ));
      • list . add ( "tercero" );
      def map = [ nombre: &quot;David&quot; , edad: 30 ] map . valor map [ &quot;valor&quot; ] def list = [ &quot;primero&quot; , &quot;segundo&quot; ] list << &quot;tercero&quot; Syntaxis Nativa en colecciones: Java: Groovy:
    • 28. Lenguaje: Bucles
      • for ( String s: list ) {
      •      System . out . println ( s );
      • }
      • for ( int n = 1 ; n < 6 ; n ++){
      •      System . out . println ( n );
      • }
      list . each {      println it } l . upto 5 ,{      println it } Java: Groovy:
    • 29. Lenguaje: GDK
      • import java.io.* ;
      • public classReadFile {
      •      public static void main ( String [] args ){
      •          try{
      •              BufferedReader br = new BufferedReader (
      •                  new FileReader (
      •                      new File ( &quot;file.txt&quot; )));
      •              String line = null;
      •              while (( line = br . readLine ()) != null) {
      •                  System . out . println ( line );
      •              }
      •          } catch( IOException e ) {
      •              e . printStackTrace ();
      •          }
      • }
      new File ( file . txt ). echLine { String line ->      println line } Java: Groovy:
    • 30. Lenguaje: Closures
      • //suma
      • def sum  =   0
      • [ 1 ,   2 ,   3 ]. each   {  item -> sum  +=  item  }
      • println  &quot;Total ${sum}&quot;
      • // listar
      • def text  =  customers . collect {  item -> 
      •      item . name  }. join ( &quot;,&quot; )
      • // llamar a un Closure
      • def c  =   {  name  ->  println  &quot;Hola ${name}&quot; }
      • c ( &quot;David&quot; )
      Definición de Closures
    • 31. Lenguaje: Closures
      • //Simple Loops
      • 5 . times { print it }
      • -> 01234
      • //Strings
      • ' dog ' . each { c -> println c }
      • -> d
      • -> o
      • -> g
      • //Lists and Arrays
      • [ 1 , 2 ,' dog' ]. each { print it }
      • -> 12 dog
      • //Maps
      • [ ' rod ' : 33 , ' james' : 35 ]. each {
      •      print &quot;${it.key}=${it.value} &quot;
      • }
      • -> james = 35 rod = 33
      Iteración en Closures
    • 32. Lenguaje: GDK
        • String
          • contains(), count(), execute(), padLeft(), center(), padRight(), reverse(), tokenize(), each(), etc.
        • Collection
          • count(), collect(), join(), each(), reverseEach(), find/All(), min(), max(), inject(), sort(), etc.
        • File
          • eachFile(), eachLine(), withPrintWriter(), write(), getText(), etc.
    • 33. Lenguaje: MarkupBuilder
      • import groovy.xml.*
      • def page = new MarkupBuilder ()
      • page . html {
      •      head { title ' Hola ' }
      •      body {
      •          ul {
      •              1 . upto 5 , { li &quot;Mundo ${it}&quot; }
      •          }
      •      }
      • }
      <html>    <head>      <title> Hola </title>    </head>    <body>      <ul>        <li> Mundo 1 </li>        <li> Mundo 2 </li>        <li> Mundo 3 </li>        <li> Mundo 4 </li>        <li> Mundo 5 </li>      </ul>    </body> </html>
    • 34. Mas Groovy
      • - Groovy Doc:
      •      http://groovy.codehaus.org/
      • - Groovy Koans:
      •      https://github.com/cjudd/groovy_koans
    • 35.  
      • Preguntas...