Groovy: anotacao @delegate

Para ir direto ao ponto, segue abaixo exemplo de uso da annotation delegate,
que resumidamente é um atalho para metodos e propriedades...

import groovy.lang.Delegate;

/**
 * Main 
 */
class Main {

 static main(args) {
  def pessoa = new Pessoa()
  pessoa.nome = "rafael"
  pessoa.carro = new Carro()
  pessoa.carro.marca = "fiat"
  
  // antes de existir o delegate
  println pessoa.nome // "rafael"
  println pessoa.carro.marca // "fiat"
  println pessoa.carro.getMarca() // "fiat"
  
  // após uso do delegate
  println pessoa.marca // "fiat" - eita! pessoa nao tem essa propriedade diretamente...
  println pessoa.getMarca() // "fiat" eita! pessoa nao tem esse metodo...
 }

}

/**
 * Class Pessoa
 */
class Pessoa {
 def nome
 
 @Delegate
 def Carro carro 
}

/**
 * Class Carro
 */
class Carro {
 def marca
 def getMarca() {
  return marca
 }
}

Brinque no GroovyConsole.

Dicas Rápidas de Grails para quem vem do Java - Controllers

Segue abaixo exemplo contendo várias informações sobre controllers.
Para ver documentação oficial, visite grails.org.

Se lhe foi útil, deixe um comentário (pode ser anônimo).


1. Basico de actions

class ToperaController {
def teste = {
render "Hello World"
}
}

Acessado via: http://localhost/minha-app/topera/teste


2. Tipos de encerramento de actions

class ToperaController {

// retornar HTML cru
def html = {
render "Hello World"
}

// requestDispatcher pra view gsp (traducao: manda os dados prum html externo)
// o gsp que será procurado pelo server é o views/topera/html2.gsp
def html2 = {
[msg: "Hello Crazy World!!"]
}
// e o gsp poderia ser "A mensagem recebida foi ${msg}"

// renderiza JSON, criando obj na hora
def json1 = {
render(contentType:"text/json") {
[nome: "rafael", idade:29]
}
}

// renderiza JSON, usando objeto pre-existente
def json2 = {
def pessoa = new Pessoa([nome: "rafael", idade:29])
render(contentType:"text/json") {pessoa}
}

// renderiza JSON (outra forma)
def json3 = {
render new Pessoa([nome: "rafael", idade:29]) as JSON
}  

/*
* Obs: os retornos em JSON podem ser lidos direto pelo javascript. Com jQuery seria assim:
* 
* $.getJSON("http://localhost/minha-app/topera/b2", function(pessoa){
*    alert("Nome pego no servidor foi " + pessoa.nome);
* });   
*/

// renderiza de acordo com tipo de url
// "topera/varios.json" pega json e "topera/varios.html" pega html
def varios = {
def pessoa = new Pessoa([nome: "rafael", idade: 29]);
withFormat {
html {render "Nome:  $pessoa.nome
Idade:  $pessoa.idade"}
json {render pessoa as JSON}
}
}

// monta html via objeto
def htmlObj = {
render {
div(id:"meuId"){
b ("Mensagem")
}
}
}

// retorna stream de arquivo binario
def figura = {
response.setContentType("image/jpeg")
response.outputStream << new File("D:/foto.jpg").readBytes()
}

// redireciona pra ToperaController.html() (dá um sendRedirect, isto é, browser recebe informacao para redirecionar)
def redirect1 = {
redirect controller: 'topera', action: 'html'
}

// redireciona pra action a, no mesmo controller
def redirect2 = {
redirect action: 'html'
}

// encaminha para outra action, SEM envolver client (browser)
def forward = {
forward action: 'html'
}

}

class Pessoa {def nome, idade}

Dicas Rápidas de Groovy para quem vem do Java

1. Basico

a) Nao precisa de ponto-e-virgula;
b) A ultima linha de um metodo é o que ele retorna. Mas botar o return ajuda a entender melhor;

2. Collections

// List
a = [1, 2, 2]
a.each {println it}
println a.class // imprime java.util.ArrayList
a = []; a << "foo"; (adiciona "foo" na lista)

// Set
a = [1, 2, 2] as Set
a.each {println it}
println a.class // imprime java.util.HashSet

// Map
a = ["um":1, "dois":2]
a.each {println "$it.key = $it.value"}
println a.class // retorna null (?)

3. Loops

l = 'a'..'c' // define array [a, b, c]

l.each {print it.toUpperCase()} // imprime ABC

l = l.collect {it = "x"}
// mesmo que each, mas RETORNA objeto alterado. O each nao.

l.eachWithIndex {item, i -> println "$i) $item"} // imprime 0) a 1) b 2) c

def linhas = """
rafael,29
joao
maria, 24
"""
linhas.eachLine {println it}

5.upto(10) {print it} // 5678910

5.downto(1) {print it} // 54321

3. Asserts/Try/Catch

try {
def quadrado = {it * it}(3)
quadrado-- // adicao de bug...
assert quadrado == 9: "o quadrado de 3 deve ser nove!!"
} catch (AssertionError e) {
print "Erro na asserção..."
}

-1. Bônus...

// pega ultimo elemento
print a[-1]

// Imitando JSON (quase-json, hehe)
def pessoas = [
['nome':'rafael', 'idade':29],
['nome':'joao', 'idade':23]
]
pessoas.each { p ->
println "$p.nome tem $p.idade anos"
}

// regex basico com if ternario
print "rafael" ==~ /r.*/ ? "Fez Match!" : "Nao fez..."

// operador elvis (?)
def a = "foo"
print a?.toUpperCase() // imprime FOO
a = null
print a?.toUpperCase() // imprime null, mas nao da nullpointer

// executa coisa no SO nativo (linha de comando)
print "ls".execute().text

// chama construtor e já poupula objeto
def p = new Pessoa([nome: "joao", idade: 23])

// metodo call()
def chamaPassandoQuatro (minhaClosure) {  minhaClosure.call(4) }
chamaPassandoQuatro({  print it * it })

Se lhe foi útil, deixe um comentário...não precisa de login...

Primeiros Erros no Grails - Dia 1

Vou listar aqui tudo o que deu de errado ao começar a usar o grails, caso lhe ajude algum dia...

Após algumas brigas com os correios, o livro de grails(*) chegou, mão na massa!
(*) "Em Busca do Grails", do Fernando Anselmo.

Abro terminalzinho linux e vamo lá:

$ cd /dados/topera/workspace/livrograils/
$ grails create-app olamundo

Primeiro comando, tudo ok, app criada.
Ok. Td certo.
(criou toda a estrutura necessaria)

1) HelloBug I

Botando a app pra rodar:

$ grails run-app

Tomei o erro:

/dados/topera/workspace/livrograils does not appear to be part of a Grails application.
The following commands are supported outside of a project: ...

Hm....quem sabe se eu ler a mensagem de erro....já sei!
Solucao: ENTRE na pasta da aplicacao primeiro, afinal ele nao vai adivinhar qual app vc quer rodar, hehe.

$ pwd
/dados/topera/workspace/livrograils/
$ cd olamundo
$ pwd
/dados/topera/workspace/livrograils/olamundo

2) HelloBug II

Tentativa numero 2!

$ grails run-app
(PAN! ERRO...pelo menos o erro mudou, já é algum progresso...hehe)
[native2ascii] Converting 13 files from /dados/topera/workspace/livrograils/olamundo/grails-app/i18n to /home/topera/.grails/1.3.7/projects/olamundo/resources/grails-app/i18n
Error executing script RunApp: : Error starting Sun's native2ascii:
...mais stacktrace...

Certo... sem desespero. Vamos adotar a tática da leitura...lá no final do stack aparece:

java.lang.ClassNotFoundException: sun.tools.native2ascii.Main

Certo. Uma classe java não foi encontrada. Quem sabe se eu parar de usar essa porcaria de
JVM que vem com o ubuntu 10.04 (java-6-openjdk), que já deu pau outras vezes, e trocar pra da sun...

Opa! Perae, meu JAVA_HOME ta setado pra:

$ export JAVA_HOME=/usr/lib/jvm/java-6-openjdk

Vou mudar pra JVM da sun:

$ export JAVA_HOME=/usr/lib/jvm/java-6-sun

Mesmo erro. Então, DESSA VEZ, a culpa não é da openjdk.
Outra tentativa:

$ export JAVA_HOME=/usr/lib/jvm/jdk1.6.0_24/

....

Server running. Browse to http://localhost:8080/olamundo

Aee! Conclusão: LEIA direito o livro. Na primeira página o autor já avisa que precisa de uma JDK (JRE não é suficiente).

Até a próxima.

APENDICE:

Aquilo que deu certo
1) Colocar variaveis de ambiente no final do /etc/profile

GRAILS_HOME=/pastaondebotouograils
PATH=$PATH:$GRAILS_HOME/bin
export GRAILS_HOME PATH
export JAVA_HOME=/usr/lib/jvm/jdk1.6.0_24/