Blog da Thânia Clair

E eu achando que não ia ter nada sobre Groovy no FISL… Na verdade não sobre a linguagem especificamente mas acabei de ler no blog do Urubatan que ele vai dar uma palestra sobre Grails (”Grails - Agilidade, produtividade e código bonito ao alcance de todos!”). Com certeza não vou perder, ainda não tive o prazer de conhecer o Grails adequadamente, vamos ver se vai dar pra ter uma visão geral de como funciona.

Pra quem se interessou será às 16hs do sábado (dia 19 de abril). Vamos lá, pessoal!

Valeu, Urubatan!

Fonte: http://www.urubatan.com.br/vou-palestrar-no-fisl-este-ano-d/

Hey!

Ultimamente estou encima do meu TCC mais do que nunca. Está ficando cada vez mais complicado, mais complexo, mais robusto… (ai, faltou adjetivos aí..) O pior de tudo é que realmente ainda tem muita coisa pra ser feita. o.O

Mesmo assim voltei a dar uma lidinha sobre a linguagem Groovy e achei interessante a forma com que ela trata os beans. Demorou, mas parece que todas as linguagens mais atuais notaram que fazer manualmente os getters e setters para toda variável de instância de uma classe não está com nada. Aleluia irmãos, mas existe o Eclipse pra que a gente possa gerar tudo automático. Era isso ou boa parte dos programadores Java estariam condenados a ter LER por conta do ocultamento de informação. Felizmente a linguagem Groovy reparou nesta falta de praticidade e trouxe características interessantes. Perfect!

GroovyBeans funcionam como os JavaBeans mas utilizando uma sintaxe mais simples (se piorasse, pra quê linguagem nova, né?!). Observe o exemplo abaixo em Groovy:

import java.util.Date

class Customer {

    Integer id
    String name
    Integer age

    static void main(args) 
    {
        def customer = new Customer(id:1, name:"Thania", age:21)
        println("Hello ${customer.name}")
    }
}

Saída:

Hello Thania

O código em Groovy acima é equivalente ao seguinte código Java:

import java.util.Date;

public class Customer {

    private Integer id;
    private String name;
    private Integer age;

    // Desce mais...

    public Integer getId() {
        return this.id;
    }

    // Mais um pouquinho...

    public String getName() {
        return this.name;
    }

    // Só mais algumas linhas...  

    public Integer getAge() {
        return this.age;
    }

    // Finalmente chegamos nos setters... 
    // Calma, a classe já tá acabando.

    public void setId(Integer id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    // Sim, rola o scroll só mais um pouquinho...

    public void setAge(Integer age) {
        this.age = age;
    }

    // Ufa! Achei que não ía achar esse main nunca... 

    public static void main(String[] args) {
        Customer customer = new Customer();
        customer.setId(1);
        customer.setName("Thania");
        customer.setAge(21);

        System.out.println("Hello " + customer.getName());
    }
}

Gostei!

Como comentei em outros posts, estou estudando Groovy nas horas vagas e comecei a dar uma olhada no tão famoso Grails. Estranhei quando vi a estrutura de diretórios padrão. Er.. HmMmm… Será que só eu que notei que não é muito parecida com a do Rails?! o.Ô

Rails:

project
    + app
       + controller
       + helpers
       + models
       + views
           + layouts
    + config
    + db
    + doc
    + lib
    + log
    + public
    + script
    + test
    + tmp
    + vendor
README
Rakefile

Grails:

%PROJECT_HOME%
    + grails-app
       + conf                 ---> location of configuration artifacts like data sources
           + hibernate              ---> optional hibernate config
           + spring                 ---> optional spring config
       + controllers          ---> location of controller artifacts
       + domain               ---> location of domain classes
       + i18n                 ---> location of message bundles for i18n
       + services             ---> location of services
       + taglib               ---> location of tag libraries
       + util                 ---> location of special utility classes (e.g., codecs, etc.)
       + views                ---> location of views
           + layouts              ---> location of layouts
   + lib
   + scripts                  ---> scripts
   + src
       + groovy               ---> optional; location for Groovy source files
                                   (of types other than those in grails-app/*)
       + java                 ---> optional; location for Java source files
   + test                     ---> generated test classes
   + web-app
       + WEB-INF

:O

Sinceramente esta estrutura me lembra um pouco uma típica aplicação web para Java.

Enfim, preciso me aprofundar mais, mas achei estranho. Só espero que “Grails” não seja apenas um nome para vender, isto é, espero seja realmente um bom framework como o Rails.

:/

Em Groovy, para declarar uma lista é simples assim:

def lista = ["thania", "clair"]
println lista.get(0)
println lista.get(1)

Para definir um intervalo:

def intervalo=0..10
println intervalo.size()
println intervalo.get(5)

Para criar um mapa:

def mapa = ["chave":"valor", "chave2":"valor2"]
mapa["nova"]="novo valor"
println mapa["chave"]
println mapa["nova"]

lista e intervalo são instâncias de java.util.List. Definir o objeto como intervalo preenche a lista criada com os valores desejados (podem ser utilizados caracteres). A definição de um mapa parece com a de uma lista, exceto pelo fato de serem passados dados no formato [ <chave> : <valor> ].

As coleções em Groovy possuem métodos bastante úteis para closures:

def lista = ["a", "b", "c"]
lista.each
{
  elemento -> println elemento;
}

lista.eachWithIndex 
{ 
    elemento, indice ->
            println indice + "O elemento é = " + elemento;
}

O método each retorna como parâmetro para a closure todos os membros da coleção, na ordem.

Tudo isso me lembra muito Ruby, por isto é legal. Preciso descobrir ainda como anda a produtividade ao utilizar esta linguagem. Não sei ao certo se muitas aplicações vêm sendo desenvolvidas em Groovy e porque utilizá-la ao invés de Java ou Ruby. A verdade é que já li algo respeito, mas ainda não me convenceu. Espero que não seja apenas uma outra linguagem.

Uma closure em Groovy é um bloco de código ou um ponteiro de método. É um pedaço de código que é definido em um dado momento e executado em um ponto posterior.

Exemplo de closure em Groovy:

def clos = { println "hello! }

println "Executing the closure:"
clos()  //  Imprime: "hello!"

No exemplo acima, note que “hello!” é impresso quando a closure é chamada, não quando ela é definida.

Os parâmetros da closure são listados antes de “->”, exemplo:

def clos = { a, b -> print a+b }
clos( 5, 7 )  // Imprime: "12"

O token “->” é opcional e pode ser omitido se sua definição de closure tem menos do que dois parâmetros.

Existe ainda uma variável implícita denominada “it”. Ela tem um significado especial. Se você tem uma closure que tem apenas um único argumento, você pode omitir a definição de parâmetro da closure, assim:

def clos = { print it }
clos("hi there") // Imprime: "hi there"

Além disso, quando um método tem uma closure como último parâmetro, você pode definir a closure inline. Observe:

def list = ['a','b','c','d']
def newList = []

list.collect( newList ) {
      it.toUpperCase()
}
println newList           //  ["A", "B", "C", "D"]

Mas há outra forma de fazer isso. No exemplo abaixo, veja que o método collect aceita não só uma lista como também uma closure como parâmetro.

def list = ['a','b','c','d']
def newList = []

def clos = { it.toUpperCase() }
list.collect( newList, clos ) 

assert newList == ["A", "B", "C", "D"]

Enjoy!

Fonte: http://groovy.codehaus.org