Inception - O filme

Tirando a péssima tradução do nome ("A origem"? Nada a ver..), o filme é muito bom! É uma VM, rodando dentro de outra VM, rodando dentro de outra VM, rodando dentro... :-)

Groovy & Grails – Tutorial – Parte 5

Ontem falei de Strings. Hoje falarei sobre números. O GDK (Groovy Developers Kit – O equivalente ao JDK) fornece alguns métodos bem legais nos objetos que representam números. Como por exemplo os operadores plus, minus, abs, round… E mais alguns métodos bem mais interessantes:

• times: para repetições
• upTo: para uma sequência crescente de valores
• downTo: para uma sequência decrescente de valores
• step: para uma sequência crescente ou decrescente de valores.

Exemplo:

times:

def sequencia = ''

5.times{ //vai repetir o código abaixo 5 vezes

sequencia += 'x'

}

assert sequencia = 'xxxxx'

upTo:

def sequencia = ''

1.upTo(5) { numero –> //passa o valor como parâmetro

sequencia += numero

}

assert sequencia == '12345'

downTo:

def sequencia = ''

5.downTo(-2) { numero –> //passa o valor como parâmetro

sequencia += numero + ', '

}

assert sequencia == '5, 4, 3, 2, 1, 0, -1, -2, '

step:

def sequencia = ''

2.step(4, 0.5) { numero –> //passa o valor como parâmetro

sequencia += numero + ', '

}

assert sequencia == '2, 2.5, 3, 3.5, '

É… a princípio, é estranho você colocar uma chamada de método a partir de um número, como 2.upTo… Mas lembre-se que em Groovy todos elementos são objetos..

Groovy & Grails – Tutorial – Parte 4

1) Mais exemplos. Seguem abaixo alguns exemplos de manipulação de Strings em Groovy. Todos são verdadeiros (os asserts retornam true) e auto-explicativos:

saudacao = "Alo Groovy"

assert saudacao.startsWith('Alo')

assert saudacao.getAt(0) == 'A'

assert saudacao[0] == 'A'

assert saudacao.indexOf('Groovy') > 0

assert saudacao.contains('Groovy')

assert saudacao[4..9] == 'Groovy'

assert 'E ai? ' + saudacao – 'Alo ' == 'E ai? Groovy' //Este aqui é muito legal!!!

assert saudacao.count('o') == 3

Reparou que algumas Strings estão entre aspas simples, ao invés de aspas duplas, como estamos normalmente acostumados? As Strings com aspas simples não recebem tratamento de conteúdo por parte do Groovy. Explicando melhor (através de exemplo, de novo):

def nome = 'Groovy'

String oie = "Tutorial ${nome}" // resultado = "Tutorial Groovy”

String oie = 'Tutorial ${nome}' // resultado = "Tutorial ${nome}"

Entendeu? :-)

Groovy & Grails – Tutorial – parte 3.5

Mais Groovy:

1) Objetos, objetos, objetos...

Em Groovy, todas as variáveis são instâncias de java.lang.Object. Ou seja: mesmo os tipos primitivos são representados pelos seus Objects equivalentes (int -> Integer, etc...).

Em Java, se você tiver uma variável int x, você não pode fazer algo como x.toString();, pois o x não é um objeto. Em contrapartida, você não pode pegar a variável Integer y e utilizar um operador numérico sobre ela, como por exemplo y * 2. Em Groovy você pode fazer as duas coisas.

Isto traz alguns comportamentos bem interessantes. Por exemplo:

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 instâncias da classe Integer, mas em Groovy eu posso utilizá-las como se fossem do tipo int diretamente, sem precisar nenhum cast (ou unboxing). Todos os asserts acima são verdadeiros.

Hoje estou sem tempo, não deu para fazer um post maior... Fica para amanhã. :-)

Groovy & Grails – tutorial – parte 3

Vamos continuar vendo as principais características do Groovy:

1) Tratamento de Strings:

As strings do Groovy se comportam como as strings do Java, podendo ser utilizadas da mesma forma se você quiser. Mas elas têm algumas facilidades, que auxiliam a vida do desenvolvedor. As concatenações, por exemplo:

Em Java:

String anoModelo = carro.getAno() + “ modelo “ + carro.getModelo();

Em Groovy:

String anoModelo = “${carro.ano} modelo ${carro.modelo}”

Repare que aqui já se começa a fazer uso dos getters dinâmicos, que falei na parte 2 do tutorial. O Groovy interpreta o conteúdo entre ${ e } e obtém o valor da variável ali explícita. Se ela não for do tipo String, o Groovy vai chamar o método toString() da variável.

Outra funcionalidade das Strings em Groovy é o suporte a múltiplas linhas, como no Java, mas de uma forma mais facilmente visível para o desenvolvedor. Por exemplo:

Em Java:

String mensagem = “Tipo de dado inválido.\nO valor deve ser númerico.\nVocê deve preencher novamente o campo Ano de Fabricação.\n”;

Em Groovy:

String mensagem = """Tipo de dado inválido.

O valor deve ser numérico.

Você deve preencher novamente o campo Ano de Fabricação."""

Ou seja: Utilizando aspas triplas, o Groovy obedece a formatação que você faz no texto.

2) Construtores dinâmicos:

Volte lá na parte 2 do tutorial e veja a classe Veiculo que está lá definida. Ela não tem nenhum constructor declarado, apenas o padrão, sem parâmetros.

Mas a classe Veiculo pode ser chamada desta forma:

Veiculo veiculo = new Veiculo(fabricante:"Ferrari", anoFabricacao:2010)

O Groovy vai chamar automaticamente os setters dos atributos passados como parâmetro.

Esta funcionalidade é muito utilizada no Grails.

Bacana, não?

Groovy & Grails – Tutorial – parte 2

Antes de falar no Grails, vamos primeiro ver como funciona a linguagem Groovy, na qual o Grails foi escrito.

As principais diferenças do Groovy em relação ao Java são:

1) Ponto e vírgula opcional:

Não é mais obrigatório colocar um ponto-e-vírgula no final de cada comando do Groovy. As duas linhas a seguir são válidas:

String nome = "Groovy";

String nome = "Groovy"

2) Palavra-chave "return" opcional:

O Groovy assume o valor do último comando de uma função como sendo o valor a ser retornado, quando não é utilizada palavra-chave return. Por exemplo, a seguinte função em Java:

String getNomeCompleto() {

return nome + " " + sobrenome;

}

Em Groovy fica:

String getNomeCompleto() {

nome + " " + sobrenome

}

3) Valor booleano True:

Além das expressões booleanas que o Java já tem, o Groovy assume qualquer valor diferente de null como sendo verdadeiro. Por exemplo:

Em Java:

if (valor != null) {

}

Em Groovy:

if (valor) {

}

4) Java Beans/Groovy Beans:

O Groovy possui uma forma simplificada de representação de Beans. Não é necessário criar os getters e setters para cada atributo do Bean. Por exemplo:

Em Java:

public class Veículo {

String fabricante;

Integer anoFabricacao;

public void setFabricante(String fabricante) {

this.fabricante = fabricante;

}

public String geFabricante() {

return this.fabricante;

}

public void setAnoFabricacao(Integer anoFabricacao) {

this.anoFabricacao = anoFabricacao;

}

public Integer getAnoFabricacao() {

return this.anoFabricacao;

}

Em Groovy:

public class Veiculo {

String fabricante

Integer anoFabricacao

}

Os getters e setters são dinamicamente gerados pelo Groovy, em tempo de execução. Se você quiser um comportamento específico para algum destes métodos que não seja o padrão (apenas setar ou retornar valores), pode escrever o método normalmente:

public class Veiculo {

String fabricante

Integer anoFabricacao

public void setFabricante(String fabricante) {

fabricante = "Fabricado por: " + fabricante

}

}

Na próxima parte veremos as demais características do Groovy. Até lá!

Groovy & Grails - Tutorial

Lá vou eu de novo… depois daquele tutorial de BPMN que postei aqui, resolvi fazer mais um. Estou aprendendo Groovy & Grails e, enquanto for aprendendo, vou repassando para vocês ao mesmo tempo. Então, é bem provável que eu acabe escrevendo algumas besteiras, mas fiquem à vontade para me corrigir sempre que necessário, ok?

A linguagem Groovy é uma linguagem script para a JVM, desenvolvida e patrocinada pela codehaus. “Linguagem script para JVM” quer dizer que ela gera arquivos .class como os arquivos Java geram e estes arquivos são executados diretamente pela JVM padrão da Sun (ou seria Oracle agora?).

O Grails é um framework para desenvolvimento web que segue a mesma filosofia do Ruby on Rails, mas ao invés de utilizar a linguagem Ruby, utiliza Groovy. Como já estou acostumado com o Java, achei o Grails muito mais fácil de ser utilizado, já que não preciso aprender mais uma linguagem, apenas me adaptar ao Groovy.

Recentemente o Grails foi assumido pela SpringSource, responsável pelo framework Spring, entre outros.

O Grails é um framework que utiliza vários componentes que são padrões de mercado, como:

• Hibernate para acesso às bases de dados;
• Log4j para tratamento de logs;
• Spring container para injeção de dependências e gerenciamento dos controllers;
• Tomcat como servlet container;

Além deste citados, utiliza o Groovy Server Pages (GSP) como visualização padrão (outros podem ser utilizados).

Através da utilização de plugins, ele é muito extensível. Já são mais de 350 plugins existentes para as mais diversas funcionalidades (segurança, ajax, JSF, Workflow, etc..). A lista completa pode ser vista aqui.

Na próxima parte, vou começar com as funcionalidades básicas do Groovy, para depois falar do Grails.