Diego Silva

Breve Introdução

Groovy é uma linguagem ágil e dinâmica para a plataforma Java com muitas características
inspiradas em linguagens como Python, Ruby e Smalltalk, disponibilizando-as para os
desenvolvedores utlizando uma sintaxe similar à de Java.

Porque estudar Groovy?

Sou programador java e gosto muito desta linguagem, porém estava buscando algo novo, dentre tantas linguagens mais modernas que visam código mais limpo e produtivo encontrei o groovy que se encaixa perfeitamente com o java, podendo até trabalhar com as duas na mesma plataforma, afinal groovy é java. Então resolvi estudá-la para ver como ela se comporta e aumentar minha visão com relação a poder analisar novas soluções no cotidiano desenvolvimento de aplicações JEE.

Neste primeiro post vou passar uma breve introdução a linguagem, nos pots seguintes vamos aprofundando cada vez mais.

Classes

Como Groovy é orientado a objetos igual ao Java, ele possui a declaração de classes, abaixo um exemplo de uma classe em Groovy que possui a declaração de um atributo de instância, um construtor utilizando este atributo e um método getTitulo,  note que é tudo muito parecido com Java exceto pela falta de modificadores de acesso, no Groovy os métodos são públicos por padrão.

class Livro {
private String titulo;

Livro(String titulo) {
this.titulo = titulo;
}
String getTitulo(){
return titulo;
}
}

Existem detalhes sobre as porcas e parafusos da declaração de classes em groovy que serão explicados mais a frente.

Utilizando scripts

Scripts são arquivos de texto, normalmente com uma extensão. Groovy, que podem ser executados a partir de comandos vis prompt, ex:

>groovy meuarquivo.groovy

Podemos executar o código fonte diretamente que ele é compilado em tempo de execução.

Crie um arquivo com o nome TesteLivro.groovy, no mesmo diretorio que nossa classe Livro.groovy e dentro dele coloque o seguinte conteudo:

Livro livro = new Livro("teste");
assert livro.getTitulo() == "teste"
assert getTituloAoContrario(livro) == "etset"

String getTituloAoContrario(Livro livro){
String titulo = livro.getTitulo();
return titulo.reverse();
}

Observe como podemos invocar o método getTituloAoContrario antes que ele seja declarado, essa é uma diferença fundamental entre Groovy e outras linguagens de script como Ruby. O script Groovy é todo analisado e compilado antes de ser executado. Outra observação importante é que não precisamos compilar a classe livro para que façamos uso dela no nosso script, basta que ela esteja no classpath que o groovy compila em tempo de execução.

GroovyBeans

GroovyBeans é similiar ao JavaBeans porem com alguns facilitadores:

• Geração de métodos de acesso
• Acesso simplificado a todos os JavaBeans e GroovyBeans
• Simplificação no registro de eventos

Ex:

class Book {
String title
}
def groovyBook = new Book()
groovyBook.setTitle('Groovy conquers the world')
assert groovyBook.getTitle() == 'Groovy conquers the world'
groovyBook.title = 'Groovy'
assert groovyBook.title == 'Groovy'

No exemplo acima temos a classe Book, observe que por nao definirmos o atributo title privado o Groovy criou automaticamente os métodos setTitle de getTitle, o script acima é perfeitamente válido e pode ser executado normalmente, mesmo que tenhamos a declaração de uma classe dentro dele.
<h2>Manipulação de Texto</h2>
Assim como no Java, Groovy trata textos utilizando a classe java.lang.String, porém no Groovy existe alguns ajustes para tornar isto mais fácil, com mais opções para trabalhar com String e mais alguns operadores.

Ex:

 def nick = 'Diego'
def book = 'Groovy'
assert "$nick is $book" == 'Diego is Groovy'

No exemplo acima podemos ver que o Groovy permite a utilização de aspas duplas e simples, e que a concatenação de Strings pode ser feita dentro de uma String, veremos também em detalhes a manipulação de textos em posts posteriores.

Números

Números são objetos em Groovy, não existem tipos primitivos como no Java, todo número criado automaticamente se torna um objeto, e mesmo sendo objetos é permitido a utilização de operadores para cálculos ex:

 def x = 1
def y = 2
assert x + y == 3
assert x.plus(y) == 3
assert x instanceof Integer

As variáveis x e y são convertidas automaticamente em tipos java.lang.Integer

Listas Mapas e Intervalos

Trabalhar com Listas em Groovy é extremamente simples, ele permite utilizar os mesmos tipos de acesso para todas as listas e a declaração é bem simples, como arrays em java, ex:

 def roman = ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII'] //Declarando uma lista
assert roman[4] == 'IV' //acessando pelo indice
roman[8] = 'VIII' //expandindo a lista
assert roman.size() == 9

Com mapas não é diferente, a maneira de declaração e acesso são bastante simples:

def http = [
100 : 'CONTINUE',
200 : 'OK',
400 : 'BAD REQUEST' ]
assert http[200] == 'OK'
http[500] = 'INTERNAL SERVER ERROR'
assert http.size() == 4

Observe como a meneira de declaração e acesso são parecidas entre mapas e listas, as mudanças são mínimas, desta forma fica fácil se lembrar na hora da utilização.

No Groovy é possível utilizar intervalos na declaração de objetos, observem abaixo como é simples:

def x = 1..10
assert x.contains(5)
assert x.contains(15) == false
assert x.size() == 10
assert x.from == 1
assert x.to == 10
assert x.reverse() == 10..1

Esse tipo de declaração pode ser útil com outros conceitos do Groovy que vamos ver mais a frente.

Closures

Closures não é um conceito novo, porém é mais utilizado em linguagens funcionais, ele consiste basicamente em passar um bloco de código em tempo de execução e esse bloco de código é executado retornando ou iterando dentro de variáveis locais do contexto atual. Em java isso muitas vezes é feito utilizando classes internas ou interfaces, como exemplo do método java.io.File.list(FilenameFilter) que recebe uma implementação da interface FilenameFilter que possui um único método que permite que os arquivos retornados pela lista sejam filtrados enquanto vão sendo gerados. Mas desta maneira é necessário uma implementação de uma interface o que talvez seria desnecessário se essa regra fosse exclusiva deste momento, poderiamos resolver esse tipo de problema utilizando classes internas, mas mesmo assim é necessário um código extra para que isso seja possível.

Um exemplo simples de uso de closures em Groovy:

[1,2,3].each {entrada -> println entrada }

Estruturas de Controle e Condicionais

O Groovy possui todas as estruturas de controle e condicionais que as linguagens tem hoje, if, else, for, while, try catch finally, essas estruturas de controle possuem suas paticularidas que serão abordadas em posts posteriores, por enquanto só alguns pequenos exemplos delas:

if (false) assert false //if de uma linha

if (null) //null é false
{
assert false
}
else
{
assert true
}

def i = 0
while (i < 10) { //while clássico
i++
}
assert i == 10

def clinks = 0
for (remainingGuests in 0..9) { //for em intervalos
clinks += remainingGuests
}
assert clinks == (10*9)/2
def list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for (j in list) { //for em uma lista
assert j == list[j]
}
list.each() { item -> //método each com closure
assert item == list[item]
}
switch(3) { //swithc clássico
case 1 : assert false; break
case 3 : assert true; break
default: assert false
}

Conclusão

Então neste post foi apresentado apenas conceitos básicos desta linguagem, em posts posteriores vamos aprofundar nestes conceitos.

Referências

Groovy em Action