Grails, Gravl, SAP e REST intro

Oi pessoal,

hoje eu vou fazer um pequeno post com algumas coisas que achei interessantes recentemente.

Primeiro, nosso amigo Glen Smith, novamente, faz um desafio a si mesmo em benfício da comunidade Grails. Essas comunidades open source são demais mesmo....

O Glen está implementando um pequeno sistema de blog, chamado de Gravl, em no máximo 1000 linhas de código (LOC), para mostrar algumas funcionalidade do Grails e seus plugins. Ele está usando algumas das últimas novidades das recentes versões do Grails, como Web Flow, GORM DSL, URL Mappings, RSS Plugin, Searchable Plugin, Ajax Upload com barra de progresso, entre outras coisas. O código fonte está disponível como um projeto open source do google code, e seu objetivo é ser uma aplicação de exemplo do Grails. Vale conferir. ( veja outros posts dele sobre este tema ).

Segundo, a SAP anunciou que estará usando o Grails 1.0 para o seu produto Composition on Grails, que é uma aplicação que provê facilidade para o rápido desenvolvimento de "aplicações compostas"(composite applications) no SAP NetWeaver 7.1 CE. Esta notícia é muito interessante por colocar o Grails como a opção escolhida por uma corporação de peso como a SAP para um de seus produtos. Excelente notícia para a comunidade Grails. Veja o post do Grame Rocher sobre isso.

E em terceiro, (sem ter uma relação direta com grails, mas que me fez pensar muito nas facilidade que o grails tem a respeito de REST) li outro dia um artigo introdutório sobre REST no InfoQ, que foi muito bom apesar de eu já ter lido outros sobre este tema. Mostra de maneira simples uma possível implementação dos conceitos de REST, e reforça esta alternativa light ao mundo de web services. E só pra não deixar passar, veja as facilidades para REST que o Grails tem (veja item 13.1).

Até a próxima...

Grails muito perto da release 1.0

Olá,

depois de tanto tempo lonje do meu blog, infelizmente, volto a campo para comentar algumas coisas.

Primeiro, estou tão longe assim devido (eu sei que não é desculpa, mas...) ao trabalho e muito também a minha filha. Manuela completará 1 ano daqui a duas semanas. E este primeiro ano de pai de filha única e menina, realmente eu fiquei muito babão e dedicando todo meu tempo livre a ela.

Em fim....

Depois de um período de trabalhos de consultoria, um pouco longe da mão na massa, tenho voltado a codificar, e naturalmente usando o Grails. Tendo usado o grails desde a versão 0.3, e isso já faz quase um ano, e passando pelas migrações para as versões 0.4.1, 0.4.2, 0.5 e agora 0.6, percebo o quanto valeu a pena ter escolhido o Grails para novas aplicações quando ainda era 0.3 Na época existia um questionamento muito grande se eu deveria ou não usar o Grails 0.3, quando ainda era muito no início do framework, quando a cada nova release era necessário alguma reengenharia devido a mudanças de API (eu senti muito migrande da 0.4.2 para a 0.6). Hoje, agradeço a mim mesmo por ter apostado no Grails naquela época.

Tenho uma aplicação que começou a ser desenvolvida lá traz com 0.3, e hoje roda em produção com grails 0.6 (ainda não migrei para 1.0-RC1). Estou muito satisfeito com a decisão de usar o grails desde o início, pois o granho de produtividade foi tanto, que hoje quando precisamos dar manutenção, evoluir e criar novas funcionalidades, penso em como seria custoso se não estivessemos usando o Grails. Acho que seria caro demais para meu cliente, ou então usaríamos uma solução em PHP (neste caso, deste cliente).

O Grails está na versão 1.0 RC1, faltando poucas semanas para a release final 1.0, finalmente. Muitas pessoas, e principalmente empresas, só irão assumir a aposta num novo framework caso ele tenha um release 1.0 estável. E agora o Grails já está quase lá.

A quantidade de facilidades que o grails 1.0 nos dá é enorme:
- Facilidades para Web Services (REST ou SOAP)
- Diversos plugins. Destaques para:


Não dá nem para citar tudo aqui. Só lendo mesmo, e principalmente, experimentando.

Falando em "lendo", numa discussão há algumas semanas, o pessoal da lista colocou a opinião de que era fundamental para uma boa adoção do grails (corporativa principalmente) a existência de uma documentação MUITO melhor, pois o site era razoável apenas. Em resposta a isso, o pessoal da G2One (empresa criada para dar suporte ao Groovy e Grails) escreveu o primeiro draft do Reference Guide. Que para uma primeira versão, está muito bom. Vale a leitura completa para conhecer diversos detalhes do framework.

O que me motivou para escrever este post de hoje foi uma mensagem enviada para a lista pelo Matt Raible. Ele é um consultor/arquiteto/desenvolvedor Java, com bastante experiência, e criador do AppFuse. Já usei muito o AppFuse, e se não fosse o Grails, estaria usando até hoje.
O Matt Raible mandou uma mensagem perguntando algumas coisas sobre performance do Grails, sobre o uso do FreeMarker com o Grails, sobre a possibilidade de criar um Struts2 plugin para o grails, e outras coisas. Ele perguntava essas coisas pois queria ter mais argumentos para conseguir "vender" o grails para algumas emoresas em que ele está prestando consultoria, empresas essas que usam essas tecnologias e cujos diretores gostariam de manter a tecnologia em uso para os próximos projetos. Os argumentos e dúvidas do Matt são de que o Grails permitiria a continuidade do uso dessas tecnologias, e ainda oferece um desenvolvido mais produtivo, etc, etc...

Depois da release 1.0, com o nível de documentação que se está alcançando, com a comunidade ativa que o grails tem hoje...... Aí, quando eu leio o Matt defendendo o uso do Grails em empresas que ele dá consultoria, sinceramente é o último argumento que eu precisava. Não tem mais volta. Pra mim, aplicações web na plataforma java, só em grails.

Ah, em relação a minha aplicação que citei acima. É um site que tem mais de 200.000 usuários cadastrados, q tem 31.000 visitantes por dia, gerando aproximadamente 400.000 page views por dia. Há controle de login, processamento de imagens, envio de emails, módulo administrativo, geração de relatórios, etc, etc.
Vejam por si só:
http://www.noiteuniversitaria.com.br

Grande abraço e até a próxima.

Grails e ImageMagick, poderio em manipulação de imagens

Recentemente tive que lidar, mais uma vez, com manipulação de imagens numa aplicação web. O requsito era o clássico: usuário faz upload de uma imagem que a gente não sabe as dimensões, e a aplicação precisa criar um thumbnail (aquela versão bem reduzida da imagem para apresentar numa página junto com diversos outros elementos de página), e também um versão da imagem em tamanho grande pré-determinado.

Mas desta vez havia requisitos novos:
1) Era preciso adicionar uma marca d'água à foto grande, e;
2) Deveria ser possível fazer um upload de um arquivo zip com dezenas de fotos dentro, e a aplicação precisava processar todas as imagens do zip, criando o tumbnail, a foto grande e a marca d'água.

Uma das opções que surgiram no meio do caminho apareceu quando surgiu este assunto na lista do Grails e alguém fez com que eu conhecesse o ImageMagick. Esta biblioteca é uma biblioteca nativa de processamento de imagens...como se fosse um photoshop, porém sem interface gráfica, apenas por linha de comando. E o mais interessante é que ela realmente possui diversas funcionalidades de um photoshop, como filtros, transformações, conversões, ou seja, realmente edição de imagem. Vale a pena conhecer. Veja alguns exemplos aqui. Para exemplos de uso da API, veja aqui.

Ok....então passamos a conhecer o ImageMagic (IM). Ah, antes que eu esqueça, existem várias intefaces de acesso ao IM para várias linguagens. Há inclusive o JMagick, que é a API java para o IM. Porém, pesquisando a respeito no google a gente vê que em diversas situações o JMagick crasha (crash). Então, se a gente não pode ainda, ou não deve, usar o JMagick, a saída é usar o IM nativamente ( que deve ser o que o JMagick faz, mas não sabemos o que fizeram lá para ele entrar em crash né).

Portanto, finalmente, este post tem então o objetivo de mostar uma action de um controller grails que eu fiz num micro projetinho grails só pra testar o uso do IM usando groovy e executando o IM nativamente, seguindo as dicas do nosso amigo James Page da lista do grails.

O primeiro passo é instalar o ImageMagick na sua plataforma. Em windows há o instalador através de um arquivo .exe. No linux há o RPM. E é claro, você pode instalar a partir do fonte do ImageMagick também.

Depois de instalar, você pode testar facilmente pela linha de comando. Se funcionou, vamos para o mundo web com nosso grails.

Eu criei um projeto novo só pra testar. Para isso:

grails create-app


Chamei este projeto de "img". Após criar, vá para o diretório do projeto e

grails create-domain-class


Chamei esta classe de domínio de TaskFile (só porque em outro projeto eu tenho uma classe Task que possui diversos TaskFile).

class TaskFile { 
String name
Date uploaded = new Date()
String description
}



Em seguida gerei o controlador TaskFileController (com comando "grails generate-controller").

import org.springframework.web.multipart.MultipartFile;

class TaskFileController {
def index = { redirect(action:list,params:params) }
// .... todas as actions que o grails gera. Alterei a action save
// alem de alterar, criei metodos privados
def save = {
def taskFile = new TaskFile()
taskFile.properties = params

if(taskFile.save()) {
def f = request.getFile('taskFile')
if(!f.empty) {
def fileName = 'file_' + taskFile.id + getExtension(f)
f.transferTo( new File('imgs/' + fileName) )
processImg(fileName)
}
redirect(action:show,id:taskFile.id)
}
else {
render(view:'create',model:[taskFile:taskFile])
}
}

private void processImg(fileName){
final String original = 'imgs/' + fileName
def t = Thread.start {
def cmd = createCmd(original, '-thumbnail', createDimentions(100,0) , 'imgs/tumb_' + fileName)
def process = cmd.execute()
process.waitFor()

def cmdMain = createCmd(original, '-thumbnail', createDimentions(400,0) , 'imgs/main_' + fileName)
def processMain = cmdMain.execute()
processMain.waitFor()

def waterMarkCmd = ["cmd /c composite -compose atop watermark.png", 'imgs/main_' + fileName, 'imgs/wm_' + fileName]
waterMarkCmd.join(" ").execute()
}
}

private String getExtension(MultipartFile file){
String contentType = file.getContentType();
String fileExtension = null;
if (contentType.equalsIgnoreCase("image/pjpeg") || contentType.equalsIgnoreCase("image/jpeg")) {
fileExtension = ".jpg";
}
else if (contentType.equalsIgnoreCase("image/gif")) {
fileExtension = ".gif";
}
else if (contentType.equalsIgnoreCase("image/x-png")) {
fileExtension = ".png";
}

return fileExtension;
}




String createCmd(inpath, action, options ,outpath){
//@todo Need os specific code here... Remove c for Linux.....
def cmd = ['cmd','/c', 'convert', inpath, action , options, outpath]
return cmd.join(" ");
}

String createDimentions(width, height){
StringBuffer sb = new StringBuffer();
if(width > 0)
sb.append(width);

sb.append('x');
if(height > 0)
sb.append(height)

return sb.toString()
}
}





Percebam que no código do controlador, o interessante foi o uso de uma Thread separada para o processamento das imagens. Já que processar imagens pode levar algum tempo em determinados casos, não é necessário deixar o usuário final esperando isso. Assim, criei uma nova thread que faz este trabalho enquanto a thread do request já manda o response direto pro usuário. Neste exemplo, eu faço 3 coisas: salvo o arquivo original, crio o thumbnail, crio a imagem grande que chamei de main, e por último crio a imagem grande com a marca d'água (watermark). Tudo isso é feito no método processImg(fileName). Percebam que este método faz uso do método execute() do groovy, que executa um comando no sistema operacional e retorna um java.lang.Process.

Depois disso foi só gerar as views (grails generate-views). Alterei a create.gsp para que tivesse o upload do meu arquivo:

           <g:form action="save" method="post" enctype="multipart/form-data">
<div class="dialog">
<table>
<tbody>



<tr class='prop'><td valign='top' class='name'><label for='description'>Description:</label></td><td valign='top' class='value ${hasErrors(bean:taskFile,field:'description','errors')}'><input type='text' name='description' value="${taskFile?.description?.encodeAsHTML()}" /></td></tr>

<tr class='prop'><td valign='top' class='name'><label for='name'>Name:</label></td><td valign='top' class='value ${hasErrors(bean:taskFile,field:'name','errors')}'><input type='text' name='name' value="${taskFile?.name?.encodeAsHTML()}" /></td></tr>

<tr class='prop'><td valign='top' class='name'><label for='taskFile'>taskFile:</label></td><td valign='top' class='value ${hasErrors(bean:taskFile,field:'uploaded','errors')}'><input type="file" name="taskFile" /></td></tr>

</tbody>
</table>
</div>
<div class="buttons">
<span class="formButton">
<input type="submit" value="Create"></input>
</span>
</div>
</g:form>


E só isso. Até a próxima. Abcs.

Grails plugins mostrando sua força

O projeto Grails lançou recentemente sua versão 0.5.
A evolução tem sido bastante rápida, com o objetivo de chegar na versão 1.0 até o fim deste ano. Já dise uma vez e vou dizer de novo: estar na versão 0.5 ( ou qualquer uma que ainda não seja 1.0) não significa que não possa ser usado para sistemas em produção, significa apenas que a API pode ser alterada ao longo do caminho, forçando as aplicações a se atualizarem junto com a evolução do Grails.

Uma das novidades recentes é a API de Plugins do Grails....ok ok, eu sei que já falei disso.

Neste post que quero apenas comprovar como o Grails Plugins pode ser bastante poderoso. O Graeme Rocher enviou recentemente um post no seu blog demonstrando a beleza dos plugins ao criar um plugin para integrar o Wicket ao Grails.

Vale a pena olhar para quem tem interesse neste crescente projeto que é o Wicket.

Abcs
Felipe

Grails: Controller para download de arquivo em diretório

Eu tenho colocado ultimamente posts que são pequenos e possuem código fonte de algumas pequenas coisas. Hoje vou colocar aqui uma action de um controller que faz download de um arquivo qualquer de um diretório no sistema de arquivos.
Eu acho interessante ter estes pequenos posts de exemplos pois servem de referência para dúvidas futuras, inclusive minhas. Alguém acha ruim este tipo de post? Preferem os posts mais elaborados (porém demandam mais tempo né)?
Em fim, segue o código.

def downloadBook = {
def file = new File("c:/temp/onliso.pdf")
response.setHeader("Content-Type", "application/octet-stream;")
response.setHeader("Content-Disposition", "attachment;filename=\" onlisp.pdf\"")
response.setHeader("Content-Length", "${file.size()}")
response.outputStream << file.text.bytes
}


É simples ou não é desenvolver vom grails e groovy. Olha o tamanho deste código. QUal seria a alternativa em Java? Quantas linhas a mais? Não quero criticar não, eu adoro Java, mas ter uma linguagem de script como Groovy na plataforma Java é muito bom, MUITO BOM.

Até a próxima.
[]s
Felipe

Aplicação Swing em Groovy para Regular Expressions

Hoje um usuário (Jeremy Rayner) da lista do Grails nos enviou uma pequena aplicação desktop escrita em Groovy que pode ser bastante útil para testar Regular Expressions. É tão pequena que vou colocar o código fonte abaixo. Esta aplicação faz o highlight das partes de um texto que você colocar de acordo com a expressão regular inserida. Veja screen shot abaixo. Para executar basta salvar este código num script RegexCoach.groovy e executar o comando: groovy RegexCoach

// Groovy Regex Coach - Copyright 2007 Jeremy Rayner
// inspired by http://weitz.de/regex-coach/
import java.awt.*
import java.awt.event.*
import java.util.regex.*
import javax.swing.*
import javax.swing.text.DefaultHighlighter
import groovy.swing.SwingBuilder

// define the view
def swing = new SwingBuilder()
def gui = swing.frame(title:'The Groovy Regex Coach', location:[20,40], size:[600,500], defaultCloseOperation:WindowConstants.EXIT_ON_CLOSE) {
panel(layout:new BorderLayout()) {
splitPane(orientation:JSplitPane.VERTICAL_SPLIT, dividerLocation:150) {
panel(layout:new BorderLayout()) {
label(constraints:BorderLayout.NORTH, text:'Regular expression:')
scrollPane(constraints:BorderLayout.CENTER) {textPane(id:'regexPane')}
}
panel(layout:new BorderLayout()) {
label(constraints:BorderLayout.NORTH, text:'Target string:')
scrollPane(constraints:BorderLayout.CENTER) {textPane(id:'targetPane')}
panel(constraints:BorderLayout.SOUTH, layout:new FlowLayout()) {
button('<<-', id:'scanLeft')
button('->>', id:'scanRight')
}
}
}
}
}
def highlighter = new RegexHighlighter(swing:swing)
swing.regexPane.addKeyListener(highlighter)
swing.targetPane.addKeyListener(highlighter)
swing.scanLeft.addActionListener(highlighter)
swing.scanRight.addActionListener(highlighter)
gui.show()

class RegexHighlighter extends KeyAdapter implements ActionListener {
def swing // reference to the view
int scanIndex // how many times to execute matcher.find()
def orange = new DefaultHighlighter.DefaultHighlightPainter(Color.ORANGE)
def yellow = new DefaultHighlighter.DefaultHighlightPainter(Color.YELLOW)
def red = new DefaultHighlighter.DefaultHighlightPainter(Color.RED)

// react to user actions
public void actionPerformed(ActionEvent event) {
if (event.actionCommand == '<<-') {scanIndex = Math.max(scanIndex - 1, 0)}
if (event.actionCommand == '->>') {scanIndex++}
doHighlights()
}
public void keyReleased(KeyEvent event) {
scanIndex = 0
doHighlights()
}

// the main regex logic
private void doHighlights() {
try {
swing.regexPane.highlighter.removeAllHighlights()
swing.targetPane.highlighter.removeAllHighlights()
def regex = swing.regexPane.text
def target = swing.targetPane.text
def matcher = (target =~ regex)
int scan = 0
while (scan < scanIndex) {
matcher.find()
scan++
}
if (matcher.find()) {
int i = 0
while (i++ < matcher.groupCount()) {
swing.targetPane.highlighter.addHighlight(matcher.start(i), matcher.end(i), orange)
}
swing.targetPane.highlighter.addHighlight(matcher.start(), matcher.end(), yellow)
} else {
scanIndex = Math.max(scan - 1, 0)
if (scanIndex > 0) {doHighlights()}
}
} catch (PatternSyntaxException e) {
swing.regexPane.highlighter.addHighlight(e.index, e.index + 2, red)
}
}
}




Bind de coleção de objetos com Grails

Muitas vezes os frameworks ágeis de programação web como Grails e Ruby on Rails ajudam muito nas operações CRUD simples. Você consegue rapidamente fazer criar, obter, alterar e apagar objetos de domínio com forms simples. Mas nas aplicações reais, fora dos "Hello World" usados nos exemplos, a gente se depara algumas vezes com a necessidade de fazer operações de CRUD em forms mais elaborados. Às vezes há casos que queremos reunir mais de um objeto de domínio num mesmo form, e há outros casos em que queremos reunir o mesmo objeto de domínio mais de uma vez: um exemplo seria salvar vários objetos Endereço de uma só vez.

Há uma maneira simples, usando o Grails, de se fazer o bind de uma coleção de objetos do mesmo tipo. Vamos a ela:

Neste exemplo, digamos que a gente queira salvar vários objetos Person de uma só vez, recebendo um post de um form único.

Crie um objeto helper em Groovy (um objeto comum que irá lhe ajudar nesta tarefa) como se segue:

class MyForm {
def personList = [new Person(), new Person()]
}



No arquivo GSP que terá o form, faça assim:
<input name="personList[0].firstname" value="Fred" />
<input name="personList[0].surname" value="Jones" />
<input name="personList[1].firstname" value="Bob" />
<input name="personList[1].surname" value="Smith" />


No controlador que irá receber o POST, você só precisará fazer o bind desta forma:
def form = new MyForm()
bind(form, params)



Pronto, simples assim. Desta forma você continua aproveitando o BIND automático do Grails (no fundo é Bind do Spring) e simplificando o código do seu controller.

[]s
Felipe

Um Benchmark para Grails e Ruby on Rails, e escalabilidade

Nesta semana o líder do projeto Grails, Graeme Rocher, criou um benchmark para comparar a performance de uma aplicação implementada com Grails e com Rails. O resultado inicial demonstra uma performance melhor para o Grails. Os resultados podem ser vistos aqui.

Ainda acho cedo para chegar a conclusões com 100% de certeza, vamos aguardar o pessoal do Rails se pronunciar. Acredito que o objetivo não foi o de se vangloriar em relação ao Rails, mas apenas o de mostrar para a própria comunidade Grails que o framework tem uma performance bem razoável.

É interessante apontar que no início do post do Graeme, ele faz questão de dizer: "A realidade deste benchmark é que ele é mais para Rails vs Groovy + SpringMVC + Hibernate + Sitemesh. O grails pode até receber algum crédito, mas o trabalho pesado é feito principalmente por Spring e Hibernate.".

Eu acho esse tipo de benchmark importante para acalmar os ânimos dos usuários do Grails que têm grande preocupação com performance. No fim das contas, estamos comparando uma solução que roda na plataforma Java, que utiliza alguns frameworks conhecidos (Spring, Hibernate, etc), com uma solução do Rails. E o resultado, por enquanto, fala por si só. Eu, particularmente, fico ainda mais confortável de seguir utilizando Grails nos meus novos projetos.

Em seguida ao post, a discussão na maillist continuou, e o assunto escalabilidade surgiu, como não poderia deixar de ser. Afinal, performance != escalabilidade.

Para uma aplicação Grails ganhar em escalabilidade, que no fundo é uma aplicação que roda na JVM, há sempre a possibilidade de se colocar esta aplicação sobre o Terracotta (que recentemente ficou open source lançando o Open Terracotta) ou então o Coherence.

Por outro lado, foi sugerida uma solução bem mais simples que pode dar conta da escalabilidade até um certo ponto. Basta colocar o Squid na frente do servidor, recebendo as requisições, e fazendo com que a aplicação Grails retorne corretamente os headers para o Squid. Se precisar de mais escalabilidade, pode-se aumentar o número servidores com Squid. Até um único servidor com Squid, Grails e Tomcat (ou Jetty, ou...) pode ser usado logo de início. Para resumir, esta solução usa o Squid como um Proxy Reverso de cache para fazer um cache do conteúdo de uma aplicação Grails. No fundo poderia ser uma aplicação Grails, PHP, Rails, ....

Por último, mas não menos importante, já que estamos falando de Grails, e consequentemente de Hibernate, um cache para o hibernate usando o EhCache pode também trazer grandes resultados.

Até a próxima...

[]s
Felipe

Aplicação pública feita em Grails com código fonte disponível

Parece que o ano realmente só começa depois do carnaval. Este mês de fevereiro foi bastante movimentado, e março também começou bem agitado. Já se passou mais de um mês desde meu último post. Prometo tentar colocar novos posts com mais frequência.

Algumas coisas que me chamaram a atenção nas últimas semanas foram:
1) Glen Smith criou o site groovyblogs.org . Ested site é uma aplicação feita em Grails, e foi feita como parte do projeto de "desafio 20h". Ele queria ver o que poderia produzir com Grails em 20h. Acabou fazendo este site legal que agrega blogs sobre groovy e grails. Parece brincadeira, mas em 20h ele produziu bastante funcionalidade se olharmos o que é preciso fazer para ter um site com estes requisitos no ar: autenticação, cadastro de usuários, busca do conteúdo dos blogs cadastrados através de seus feeds RSS, varredura da maillist do Grails, entre outros detalhes.

Mais uma vez é a prova do alta produtividade do Grails aliada ao poder de Java e seus projetos open-source. Por exemplo, para buscar os feeds nos diversos blogs cadastrados, ele usou o Apache Commons Http, o que facilitou bastante a vida dele.

Além disso tudo, o site tem seu próprio código fonte disponível, servindo de um belo exemplo de aplicação grails. Download do código aqui. Lá você verá tbem a possibilidade de download do Groogle, que é a solução que o Glen Smith deu para integrar uma aplicação Grails com um mecanismo de busca utilizando o Lucene.


Depois vou falar um pouco sobre outras coisas que vi por aí:


Tanta coisa pra falar....tão pouco tempo.


Abcs
Felipe

Versão 0.4 do Grails Liberada

Hoje, dia 31/01 a versão 0.4 foi liberada pela equipe de desenvolvimento do Grails. É uma versão muito importante por acertar diversos pequenos bugs, e por implementar novas funcionalidades importantes. Download aqui.

Uma delas é o suporte a Reloading para classes de Serviços, por exemplo. Além de outros artefatos que antes não se fazia reloading. Portanto, você pode desenvolver sem ter que fazer deploy novamente, sem dar stop no container web. Vai agilizar muito o desenvolvimento iterativo.

Outra é a novidade do Grails Plugins. Agora você pode criar plugins para ó Grails, e utilizar este seu plugin em outras aplicações Grails. Por exemplo, já implementaram o XFire plugin para quem quer utilizar o XFire para gerar Web Services na sua aplicação Grails. Fizeram também o Laszlo Plugin. Um outro usuário comentou que você pode, numa grande aplicação sendo desenvolvida, implementar os módulos desta aplicação como plugins do Grails. Assim, você pode fazer um deploy usando alguns módulos, e em outro caso, não usar determinados módulos. Muito intererssante. Vale conferir!

Algumas bibliotecas foram atualziadas, como Spring 2.0, Hibernate 3.2 e Groovy 1.0.

Grails está mais estável do que nunca. A versão 0.4 poderia facilmente ser chamada de 1.4 se os desenvolvedores se preocupassem um pouco mais com marketing. 0.4 não significa instável ou incompleta. Podem usar em produção!

Tudo que foi implementado pode ser visto aqui.

Aplicações públicas usando Grails que estão em produção são:
- Site da Pepsi Co, http://www.copellafruitjuices.co.uk/ .
- TV Voting: http://www.tvvoting.com/

[]s
Felipe

Mais envio de email: Autenticação SMTP, GroovyTemplates e integração com Spring

Escrevi um pequeno tutorial no wiki do Grails sobre como enviar emails com autenticação a um servidor Smtp. O conteúdo do email é Html, e é gerado dinamicamente com GroovyTemplates. O envio é feito pelas classes do Spring, e a configuração ficou de tal forma que possibilita, sem alterar nenhuma classe, o envio com autenticação, sem, para diferentes ambientes, etc.

Como tem muito mais código do que texto, não traduzi para o português.

Ficou interessante: veja aqui o tutorial.

[]s
Felipe

Geração de boletos com JBoleto e Grails

Um dos projetos que venho desenvolvendo atualmente, e o único usando Grails, tem me dado muitas agradáveis surpresas. Precisei implementar um busca no sistema: usei o Lucene, como descrevi aqui. Agora precisei gerar boletos bancários na mesma aplicação. Em 30 min implementei isso, usando o JBoleto. É muito bom usar Java pois a comunidade é extremamente criativa, produtiva e compartilha muita coisa em projetos open source.

O JBoleto é um pequeno projeto em java que ajuda na geração de boletos bancários. Por sorte, eu precisava gerar boletos do Banco do Brasil. O jboleto já está pronto para o Banco do Brasil. Bastou eu configurar para os dados da conta, e pronto, eu tinha boletos sendo gerados para os pedidos da loja virtual sendo desenvolvida neste projeto. Outros bancos também já têm suporte: Itáu, Bradesco, Sudameris, Santander. E do jeito que foi feito, você pode facilmente criar novos boletos para novos bancos usando o JBoleto.

Parabéns para a comunidade Java. É muito bom fazer parte dela.

E para não deixar de fazer meus elogios ao Grails, é muito bom poder usar os projetos open source em Java dentro de uma aplicação Grails. Fica tudo tão simples! :-)

[]s
Felipe

Grails eBook disponível

É muito importante, em qualquer projeto de framework open-source hoje dia, ter uma boa documentação e uma comunidade ativa e bem receptiva. A comunidade o Grails já tem, e a documentação está ganhando corpo.

Mais um livro foi plublicado, agora com versão eBook gratuita.
Veja aqui no infoQ. O livro é sonsiderado um Mini Book, e acompanha código fonte dos exemplos.

[]s
Felipe

Grails no mundo Corporativo?

Um leitor do meu blog me enviou um e-mail perguntando:
"Acha que este framework representa um ponto de virada na programação? Irá ser muito usado em empresas? Pra grandes projetos ... é aconselhavel?"

Estas perguntas são perigosas de serem respondidas, pois afinal são previsões do futuro, ou uma opinião pessoal baseada no sentimento ou no gosto de cada um. É sempre melhor ter fatos para podermos elaborar em cima dos mesmos.

Apesar disso, vou me arriscar e, ao invés de afirmar, vou apenas emitir minha opinião.

Resposta 1: Acho que o Grails conseguiu juntar duas características difícieis de serem unidas: simplicidade para o desenvolvedor, que é um ser humano que gosta de coisas simples (sempre tem as exceções, calro); e flexibilidade, poder e robustez tecnológica. Como o Grails é implementado em Groovy, a linguagem fornece muita simplicidade para o desenvolvedor, aumentando bastante a produtividade de codificação. Além de Groovy, sendo o Grails um framework MVC para web do jeito que foi feito, ele facilita muito a implementação de operações rotineiras no desenvolvimento web: operações CRUD, validação, uso de Ajax, e por aí vai. Então, o nível de abstração subiu bastante em relação a frameworks MVC integrados com soluções de persistência como o Hibernate. Desenvolver em Graisl comparado com SpringMVC + Hibernate, é muito mais simples (com Grails). MUITO MAIS SIMPLES! E com o MESMO poder!!! Pois usa SpringMVC + Hibernate por baixo dos panos.
Ok, ok. E a resposta? Vamos lá.....Acho que sim: acredito que os desenvolvedores irão perceber as vantagens que o Grails oferece em relação a Struts, WebWork, SpringMVC da mesma forma que percebram as vanagens do uso do Struts em relação aos frameworks caseiros. O Struts foi um marco no desenvolvimento web em Java. Acho que o Grails será um marco no desenvolvimento web na plataforma Java. Com certeza!

Resposta 2: As empresas, principalmente as grandes e as médias, vêm investindo muito há anos na capacitação de suas equipes. Ainda hoje, se vê muitos anúncios de oportunidades para desenvolvedores com experiência em Struts. Mas porque Struts? Será que Struts é o que há de melhor hoje em dia no que diz respeito a frameworks MVC para web em java? Uns podem dizer que sim. Para mim, não. E olha que já usei muito o Struts, e ainda uso (infelizmente). Ele não é o melhor atualmente, mas possui uma base de desenvolvedores que o conhecem muito grande. Possui uma comunidade ativa enorme. Possui livros e livros publicados, cursos sendo vendidos, equipes inteiras com seu conhecimento. E aí? Vai tudo pro lixo porque Grails surgiu? Certamente que não. Porém, as empresas que estiverem dispostas a experimentar novas tecnologias ou frameworks estarão dispostas a investir em determinado caminho. Como tal, poderão ter um retorno alto ou não. É um risco que se corre. Tem gente que ganha muito dinheiro na bolsa de valores, mas é arriscado. Aqueles que partirem para o uso do Grails, na minha opinião, terão uma vantagem competitiva, pois se preocuparão menos com detalhes de baixo nível das APIs de Java, e terão mais tempo para pensar na solução de negócios dos seus clientes. Isso pois, a produtividade com Grails é MUITO maior que com os demais frameworks MVC para web em java. Respondendo então: acho que sim, mas isso levará tempo. Aos que forem pioneiros, os resultados dirão.

Resposta 3: grandes projetos? O que são grandes projetos? Se forem projetos que usam persistência, log, web services, tarefas agendadas, geram relatórios, busca textual indexada, etc, etc. A resposta é sim. Se para estes projetos você usa Java com Struts ou WebWork ou SpringMVC, Hibernate ou iBatis, Log4j, Quartz, Acegi, JasperReports, XFire ou Axis, Lucene ou Compass... Se você usa isso tudo, porque não usar Grails? Afinal você pode continuar usando isso tudo, mas de uma maneira MUITO MAIS SIMPLES. Se projetos grandes são projetos com um número de usuários muito grande, e se para estes projetos você usa um sistema web em Java. Porque não usar Grails? Afinal, no final das contas, tudo é bytecode sendo executado pela JVM. Então você pode continuar usando seu servidor de aplicações java que você já usa. Pode continuar fazendo o balanceamento de carga que você já faz. O que muda é o nível de abstração em tempo de desenvolvimento.

Minhas opiniões foram influenciadas por este post.

Um abraço e até a próxima.

Enviando e-mail em Html com Grails, Spring e GroovyTemplate

Uma tarefa comum em aplicações web é o envio de e-mail. Vou mostrar um exemplo simples, bem prático, para envio de e-mails com o Grails, usando algumas classes de suporte a emails do Spring.

O GroovyTemplate é um template engine, estilo Velocity Templates, escrito em groovy e disponível para nós em aplicações baseadas no Grails.

O exemplo é de uma loja virtual que ao final do pedido deve enviar um email de confirmação de pedido para o cliente.

Crie o seu template

Eu criei um template para ser processado pelo GroovyTemplate em /WEB-INF/orderNotification.gtpl
(eu inventei este gtpl para ser Groovy Template, mas poderia ser qualquer extensão).

Este arquivo seria algo do tipo:

<body style="font-family:Verdana, Arial, Helvetica, sans-serif;font-size:11px">

<div align="center">
<strong>Loja Virtual</strong><br />
Rua XXxxxxxx <br />
Rio de Janeiro/RJ - Brasil
</div>

<div style="height:1px;clear: both;margin-bottom: 15px;margin-top: 15px; border-top: 1px solid #FBC8A2;"></div>
Número do Pedido: <strong>${order.number}</strong>

<div>Obrigado pela compra. Este é o e-mail de confirmação de sua compra, efetuada na loja online.</div>


<div style="float:left">
Compra efetuada em nome de: <strong>${order.clientName}</strong>
</div>
<div style="float:right">Data da Compra: <strong>${order.ordered}</strong></div>


<div style="height:1px;clear: both;margin-bottom: 15px;margin-top: 15px; border-top: 1px solid #FBC8A2;"></div>

<div>
<strong>Dados do Pedido</strong>
<p>
<strong>Endereço de Entrega:</strong> ${order.shippStreet} ${order.shippNumber} / ${order.shippComplement}<br />
${order.shippSuburb} - ${order.shippCity} - ${order.shippState}
CEP: ${order.shippZip} - ${order.shippCountry}
</p>
<table width="100%" border="1" cellspacing="0" cellpadding="0" bordercolor="#FBC8A2">
<tr>
<td><strong>Produto</strong></td>
<td><strong>Quantidade</strong></td>
<td><strong>Preço Unitário</strong></td>
<td><strong>Preço Total</strong></td>
</tr>
<% order.orderItems.each { %>
<tr>
<td>${it.name}</td>
<td>${it.quantity}</td>
<td>${it.price}</td>
<td>${it.price * it.quantity}</td>
</tr>
<% } %>
</table>
<p>
<strong>Sub-total:</strong> ${order.subTotal}
<strong><br />
Valor do Frete:</strong> ${order.shippingCost}
<strong><br />
Total do Pedido:</strong> ${order.subTotal + order.shippingCost} </p>
</div>


</body>



Perceba que há o uso do GString (quando usamos ${order.algumaCoisa} ), e o uso de scriptlets <= algum groovy script >. Isso torna o nosso template totalmente dinâmico para fazermos o que bem ententer em termos de formatação.

Como a variável order chegou até o template para ser processada? Veremos a seguir:

Crie o Controller

seu controlador terá uma action como (o exemplo abaixo está simplificado, sem tratamento de erros do processamento):


def orderProcessed = {
def order = orderService.processOrder(params)
if(order) sendNotificationEmail(order)
}

private sendNotificationEmail(Orderr order){
File tplFile = grailsAttributes.getApplicationContext().getResource( File.separator + "WEB-INF" + File.separator + "orderNotification.gtpl").getFile();
def binding = ["order": order]
def engine = new SimpleTemplateEngine()
def template = engine.createTemplate(tplFile).make(binding)
def body = template.toString()


def email = [
to: [ "felipenasc@gmail.com" ], // "to" expects a List, NOT a single email address
subject: "Pedido realizado pelo site",
text: body
]
emailerService.sendEmail(email)
}


Aqui, pode-se ver o uso do Spring, integrado ao Grails. Primeiro eu usei o getResource() para ter facilmente um File com meu arquivo de template. Depois, eu processo o template com SimpleTemplateEngine de groovy. Em seguida monto um mapa com os dados do meu email e passo para o serviço de envio de email, que veremos a seguir.



Crie o Serviço de Envio de Email

O serviço é auto explicativo e eu coloco na íntegra abaixo:


import org.apache.log4j.Logger;
import org.springframework.mail.MailException
import org.springframework.mail.MailSender
import org.springframework.mail.MailMessage
import org.springframework.mail.javamail.MimeMessageHelper
import org.springframework.mail.javamail.MimeMessagePreparator
import javax.mail.internet.MimeMessage

/**
* Simple service for sending emails.
*
*/
class EmailerService {
boolean transactional = false
MailSender mailSender
Logger log = Logger.getLogger(this.class.name)

def sendEmail(mail) {

MimeMessage mimeMessage = mailSender.createMimeMessage()
MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true, "ISO-8859-1");
helper.setFrom("seuemail@seila.com.br");
helper.setTo(mail.to);
helper.setSubject(mail.subject);
helper.setText(mail.text, true);

try {
log.info("about to send messages to:\n${mail.to}")
mailSender.send(mimeMessage)
} catch (MailException ex) {
log.error("Failed to send emails", ex)
}
}
}




Mais um exemplo simples e poderoso do Grails, se integrando com o Spring. Opa....faltou a confirguracao do spring.

Configure o seu bean de Mailer do Spring:
Na raiz do seu projeto/spring/resources.xml, adicione:

<bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
<property name="host">
<value>smtp.moebius.com.br</value>
</property>
</bean>


Abcs e até a próxima.

Grails: simplicidade e poder.

Depois de comprar o livro (e ler inteiro) "The Definitive Guide to Grails", e depois de implementar dois projetos usando o Grails, cada vez mais fico impressionado com este framework. É muito simples. Tudo fica mais simples. A velocidade de desenvolvimento aumenta MUITO, sem comprometer a qualidade do que está sendo desenvolvido.

Ontem tive que dar manutenção num sistema feito usando SpringMVC, Hibernate, Sitemesh (ou seja, tudo que o grails usa), e foi muito penoso. E olha que o sistema está super bem feito, com as camadas tradicionais de Serviços, DAOs, todas as devidas interfaces, etc... O problema é que eu achava isso bom ( e continuo achando na verdade, caso não se tenha outra opção), mas depois do Grails, tudo fica muito complicado demais.

Para exemplificar a simplicidade, Glen Smith, um desenvolvedor participativo na lista do Grails, enviou um post em seu blog fornecendo um pequeno projeto grails que implementa um mecanismo de busca textual no sitema usando o Lucene. Para quem não conhece, o Lucene é um "Indexing and Search Engine". Ele fornece APIs que permitem implementar uma busca estilo Google no seu site/sistema.

Com esta ajuda do Glen, em apenas 15 minutos eu implementei a busca que eu precisava para um sistema que estou desenvolvendo. Ficou perfeito. Foi extremamente simples de implementar, e ficou extremamente podereoso, pois utiliza o que há de melhor e robusto em search engine em Java.

Glen vai empacotar o que ele fez num Grails Plugin, para facilitar ainda mais seu uso.

Para quem gosta e conhece o Compass (que usa o Lucene por baixo), Maurice Nicholson enviou um outro post com um excelente tutorial de integração Compass + Grails. É uma outra forma de implementar um mecanismo de busca em seu sistema, usando Grails.

Dá vontade de reimplementar todos os sitemas que eu dou manutenção (em Java ou PHP), pois fica tudo mais simples, divertido, e podereoso. E sobra tempo para pensar na aplicação em si, no que é melhor para solucionar o problema do cliente, ao invés de ter que ficar se debatendo com APIs de baixo nível, difíceis de serem integradas, usadas, etc, mas que são poderosas e são elas que temos que usar.