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.