Groovy Introduction

- Groovy

    Visão Geral:
        Produtividade
        Economia de tempo
        Menor esforço de codificação
        Entregas constantes
        Prototipagem dinâmica
        Linguagens Tradicionais
            Quantidade de código para tarefas simples
            Tipos primitivos
            Suporte a coleções
            Funcionalidades avançadas
            Suporte a scripts
        Características
            Linguagem sucinta e breve
            Legibilidade sintática
            Groovy Development Kit
            Grails, Gradle, Griffon, Spock, EasyB
        Groovy x Java
            Groovy foi desenvolvido com o princípio "Least Surprise" em mente, especificamente para facilitar o aprendizado por parte dos desenvolvedores Java
            O código escrito em Java pode ser compilado e executado em groovy
            Para aproveitar o máximo da linguagem é recomendado utilizar "The Groovy Way"
    Introdução
        Vários Imports
            groovy.lang.*, groovy.util.*, java.lang.*, java.util.*, java.net.*, java.io.*
            java.math.BigDecimal, java.math.BigInteger
        Ponto e vírgula
            Opcional entre comandos em linhas distintas
                println "Hello"
            Obrigatório entre comandos na mesma linha
                println "Hello"; println "World"
        Parênteses
            Opcionais em expressões não aninhadas
                println Math.sqrt 100 // erro!
                println Math.sqrt(100) // ok
        Sintaxe opcionais
            Getters and Setters
                GroovyBeans
                gerados automaticamente
                podem ser sobrescritos
                campos podem ser acessados diretamente
                    operador .@
                métodos podem ser acessados como closures
                    operador .&
                ex:
                    class Pessoa {
                        String nome, sobrenome
                        def getNome() {
                            nome + ' ' + sobrenome
                        }
                        static main(args) {
                            def p = new Pessoa()
                            p.nome = 'Leandro'
                            p.sobrenome = 'Lourenzoni'
                            assert p.nome == 'Leandro Lourenzoni' //acessa o getNome
                            assert p.@nome == 'Leandro'    // acessa o nome.
                        }
                    }
            Modificadores de acesso
                Métodos e campos são public por padrão
                @PackageScope
            Checked Exceptions
                Não é obrigatório o tratamento de Exceptions
                Todas as Exceptions são transformadas em RuntimeExceptions
            Closure
                Bloco de código que pode ser passado como parâmetro e executado
                {arg1, arg2, ... -> statements}
                //Simple closure with no arguments
                def clos1 = { println "hello world!" }
                //Calling the closure
                clos1()

                //A closure with arguments
                def clos2 = {arg1,arg2 -> println arg1+arg2}
                clos2(3,4)

                //A closure defined inside a method.
                def method1(book){
                    def prefix = "The title of the book is: "
                    return {println prefix + book}
                }
                def clos3 = method1("Groovy")
                clos3()
         
                def raise1 = {salary -> (salary * 1.5)}
            Coleções
                Arrays
                    def a = [item1, item2, item3].toArray()
                    def a = new Object[4] // tamanho obrigatorio
                    int[] a = [1,2,3]
                Listas
                    ArrayList
                    Sintaxe simplificada []
                    Instanciação
                        def a = [item1, item2, item3]
                Maps
                    HashMap
                    Sintaxe simplificada [:]
                    Instanciação
                        def a = [key1: value1, key2: value2]
                        def map = ['name':'Bashar','age':26,skills:['Java','Groovy'], 'author':true]
                        map += ['city':'Tucson']
                        assert map.size() == 4
                Ranges
                    Sequência com início e fim
                    def range = start..end
                    def range = 1..10
                    assert range == [1,2,3,4,5,6,7,8,9,10]
                    range = 'a'..'c'
                    assert range == ['a','b','c']

            Tipo Opcional
                Tipos "estáticos" e dinâmicos
                Tipo estático
                    Declaração explícita do tipo
                    Escolha do tipo em tempo de compilação
                Tipo dinâmico
                    Declaração com a palavra chave def
                    Escolha do tipo em tempo de execução baseado no conteúdo atribuído à variável
            Sobrecarga de Operadores
                Todos os operadores em Groovy são chamadas a métodos
                Assim, qualquer operador pode ser sobrescrito com métodos customizados
            XML Builder
                <!-- XML -->
                <authors>
                  <author name='Lourenzoni'>
                    <book title='Groovy Rocks' edition='1' />
                  </author>
                  <author name='He-man'>
                    <book title='Holy Grails' edition='2' />
                  </author>
                </authors>

                // Groovy
                def builder = new groovy.xml.MarkupBuilder()
                builder.authors {
                    author (name: 'Lourenzoni') {
                        book (title: 'Groovy Rocks', edition: 1)
                    }
                    author (name: 'He-man') {
                        book (title: 'Holy Grails', edition: 2)
                    }
                }
        Estruturas de Dados
            Strings
            Regex
                Operadores
                    Pattern operator: ~pattern (devolve um pattern)
                    Find operator: =~ (devolve um matcher)
                    Match operator: ==~ (verdadeiro ou falso)
                    Match
                    Extract
                    (?m) multiline mode
            Numbers
            List
            Map
            Range
        Metaprogramação
            Expando
                Adiciona campo e atributos
                String.metaClass.swapCase = { ->
                    def sb = new StringBuffer()
                    delegate.each { sb <<
                        (Character.isUpperCase(it as char) ?
                        Character.toLowerCase(it as char) :
                        Character.toUpperCase(it as char))
                    }
                    sb.toString()
                }
        Interceptação de métodos
            invokeMethod(String name, args)
            methodMissing(String name, args)
            propertyMissing
        Expression Value
            "$var"
                def doAction(animal, action) {
                    animal."$action"()
                }
            Eval.me('2*4 + 2'
        Test with mock
            def classMocked = new MockFor(ClassMocked)
            classMocked.demand.methodMock( ssn -> xxxxxxx }

  - Safe Graph navigation (Use o ?)
If the object is null the program does not throw a exception, but return "".

Code used in Java

  public String getPostcode(Person person) {
      String ans= null;
      if (person != null) {
        Name nm= person.getName();
        if (nm!= null) {
          ans= nm.getPostcode();
        }
      }
      return ans
    } 

With this: 

public String getFirstName(Person person) {
      return person?.getName()?.getGivenName();
    } 

Returns

return person == null ? "" 
    : person.getName() == null ? "" 
        : person.getName().getGivenName();