Introdução
Para falar de Grails precisamos começar um pouco antes, precisamos falar de Groovy, o que são essas 2 tecnologias, como se relacionam, por que você leitor deveria usá-las e como você pôde ter vivido sem elas até hoje. 🙂
Enquanto Groovy facilita o trabalho do programador, eliminando as dificuldades inerentes da linguagem Java, o Grails torna acessível todos os recursos da plataforma Java EE de uma forma nunca antes vista, para aqueles que desejam tirar proveito de suas principais vantagens: alta disponibilidade, escalabilidade, desempenho e robustez.
Groovy, o quê e por quê
Groovy foi criado com o objetivo de facilitar o desenvolvimento de aplicações para a JVM. Podemos dizer que resolve dois problemas fundamentais: ser compatível com o código Java existente, garantindo completo reaproveitamento de código e, ao mesmo tempo, resolver diversas das limitações existentes na própria linguagem Java.
Groovy é como um “Java++”: diversos novos recursos que só foram incluídos no Java 8 em 2014 já estavam presentes em Groovy desde sua introdução em 2004 como, por exemplo, closures, facilidades para lidar com tipos numéricos e diversas outras facilidades sintáticas que aumentam significativamente a produtividade do programador.
Groovy tem sua sintaxe muito parecida com Java, na verdade você pode escrever um código Java e compilar com o compilador Groovy e tudo estaria perfeito. Coisas simples como o caractere ; ou mesmo o uso de parênteses em chamadas de funções podem se tornam opcionais, assim como tantas outras “frescuras”, o que acaba gerando uma porta de entrada ao ecossistema Java muito mais hospitaleira. Você tem a liberdade de ir experimentando aos poucos conceitos que muitas vezes parecem assustadores, como tipagem dinâmica, programação funcional e tantos outros.
Existe uma certa resistência ao Groovy por ser visto como uma “mera linguagem de script” e que, portanto, não seria apropriada para a escrita de aplicações reais. Nada mais longe da verdade: Groovy tem sido usado em projetos gigantescos de imensa responsabilidade por todo o globo. Um exemplo é o projeto Asgard, desenvolvido pela Netflix que é o responsável por gerenciar todo o processo de deploy de suas aplicações na nuvem, além de diversos outros projetos. Outro exemplo legal? O mecanismo de build adotado por padrão para aplicações Android hoje é o Gradle, inteiramente implementado em… Groovy.
Estes são apenas alguns exemplos, mas não se assuste se um dia descobrir que já usa a linguagem há um bom tempo sem saber, visto que é componente de diversas bibliotecas e frameworks de sucesso entre programadores Java como, por exemplo, o Jasper Reports e o Spring.
Groovy é uma linguagem dinâmica: isto quer dizer que podemos alterar o comportamento do nosso código enquanto este é executado. Linguagens dinâmicas nos permitem executar tarefas em tempo de execução que em outras linguagens só são possíveis no momento da compilação ou através de padrões de projeto ou soluções arquiteturais que nem sempre são as mais amigáveis.
Adotar o paradigma funcional de programação também é mais fácil graças à presença das tão faladas closures, um recurso que só apareceu na versão 8 do Java.
Há melhorias sintáticas oferecidas pelo Groovy: há construtores que nos possibilitam, por exemplo, lidar com as coleções Java (a API Collections) de uma forma muito mais simples e eficiente.
Além disto, entram como agregados interessantes uma nova sintaxe para lidar com strings, a possibilidade de sobrecarregarmos operadores, lidar com números do tipo BigDecimal de forma mais natural, estruturas de controle aprimoradas e muitas outras facilidades que tornam a escrita de código uma tarefa muito mais prazerosa e simples do que a experiência que temos com o Java tradicional. Pense em todas as coisas na linguagem Java de que você não goste e as exclua: este é o Groovy.
Groovy vs. Java
A melhor forma de dar um gostinho do que é a linguagem é fazer um paralelo entre Java e Groovy. Há uma infinidade de melhorias e “mágicas” que Goovy nos dá e não vou me enveredar por todas mas deixo um aperitivo para abrir o apetite de curiosidade:
1) BigDecimal é uma classe particularmente morosa de lidar em Java, então vamos dar um pequeno exemplo:
Java
BigDecimal delta(BigDecimal a, BigDecimal b, Bigdecimal c) {
return b.mutiply(b).subtrct(new BigDecimal(4).mutiply(a).mutiply(c));
}
Groovy
BigDecimal delta(BigDecimal a, BigDecimal b, Bigdecimal c) {
(b*b) – (4*a*c)
}
2) Tipagem dinâmica é obviamente um trunfo, você pode criar um método de somar que soma qualquer tipo de numérico e que se encarrega de fazer a conversão automaticamente.
Groovy
def soma(a,b) {
return a + b
}
3) Strings e Groovy = amor
Interpolar variáveis em strings
int a = 3
def b = 5
def texto = “O valor da soma: ${a} + ${b} é ${a+b}”
println texto
//resulta em
// O valor da soma: 3 + 5 é 8
Chega de colocar + para dividir Strings em linhas diferentes na indentação
Java
String muitasLinhas = “Olá! \n”+ “Isso é muito legal. \n”+ “Mas muito trabalhoso”;
Groovy
String muitasLinhas = """Olá! Isso é muito legal. Mas muito trabalhoso""";
4) Em Groovy não é necessário criar construtores diferentes para casos específicos, basta passar chave:valor
class Pessoa { String nome String sobrenome boolean casada } Pessoa pessoa = new Pessoa (nome: “Rodrigo”, casado: false)
5) Incluindo novos métodos e atributos em classes preexistentes, você pode incluir métodos ou campos dinamicamente em classes preexistentes
Groovy and Grails as a next evolution of Java
Grails, o quê e por quê
Grails nos apresenta uma maneira diferente de manipularmos a plataforma Java EE, mais simples, menos burocrática e extremamente produtiva.
E sabem o que é mais interessante? Um modo de trabalho no qual o desenvolvedor simplesmente se esquece de estar lidando com o Java EE: você simplesmente a usa.
Não há como negar, o desenvolvimento de aplicações web na plataforma Java muitas vezes é uma atividade mais burocrática que o necessário. Grails remove este aspecto moroso ao nos oferecer um modelo de desenvolvimento baseado em convenções: arquivos de configuração agora somente quando for o desejo do programador, e não mais uma exigência da plataforma.
Grails é um framework para desenvolvimento de aplicações web profundamente influenciado pelo Ruby on Rails (seu primeiro nome sequer era Grails, mas sim “Groovy on Rails”). Para entender os ganhos que ele nos trouxe, primeiro é preciso lembrar do mundo em 2004 quando Rails chocou a todos nós.
Ao ser lançado em 2004, Ruby on Rails mudou para sempre a maneira com a qual estávamos acostumados a escrever aplicações web para a plataforma Java (e nem era voltado para Java!). Foi um tapa na cara de todos nós, desenvolvedores Java EE: de repente víamos diante dos nossos olhos como era possível desenvolver aplicações web sem a necessidade de enfrentar incontáveis arquivos de configuração, tal como estávamos acostumados a fazer.
Em vez disso, foi apresentado algo comum em outras plataformas: o desenvolvimento baseado em convenções e em uma linguagem dinâmica, no caso Ruby.
Grails é um framework de pilha completa (full stack), ou seja, o desenvolvedor não precisava se preocupar com a integração de suas diversas bibliotecas, como o Hibernate para persistência, Log4J para logging, Spring e muitas outras. Tínhamos ali todas as estrelas do Java finalmente integradas, prontas para o uso: o desenvolvedor podia começar a implementar sua lógica de negócio imediatamente.
A lista de vantagens é longa:
• O scaffolding que automaticamente gera para o desenvolvedor as camadas de visualização e controle tendo como base nossas classes de domínio.
• Injeção de dependências e inversão de controle baseada em Spring.
• Diversas das principais bibliotecas e frameworks Java prontamente integrados, de tal modo que não precisamos nos preocupar mais com isto.
• Uma arquitetura de plug-ins que nos permite modularizar nossos projetos e enriquecer o framework de uma forma bastante interessante.
• É baseado em uma das linguagens mais produtivas já criadas: Groovy.
• E não podemos esquecer de uma grande comunidade, tanto nacional quanto internacional.
O modo como lidamos com a persistência e validação de dados também é mais simples com Grails. Temos o GORM, nosso framework para persistência, que atualmente trabalha tanto com bases de dados relacionais como não relacionais, como o MongoDB. Não é necessário ao desenvolvedor se preocupar com anotações ou arquivos de mapeamento. O desenvolvedor só precisa lidar com o modo como suas classes são modeladas, como deveria ser desde o início.
O mais importante é que, finalizado seu projeto Grails, o resultado é uma aplicação Java EE completa, com os mesmos direitos que qualquer uma escrita para a plataforma possui: alta disponibilidade, escalabilidade, desempenho e robustez. E, como brinde, há também o fato de o código Grails ser altamente portável entre servidores de aplicação, evitando-lhe este tipo de dor de cabeça no futuro.
Grails usa princípios como:
• Convetion over Configuration: modelo de desenvolvimento que busca reduzir o número de escolhas que a equipe de programação precisa fazer durante a evolução do seu projeto. Não é mais necessário perder horas em XMLs de configuração, tudo já está configurado da forma mais simples e somente sair do padrão gera trabalho, e mesmo assim mínimo.
• DRY: Em um primeiro momento, parece que ele nos diz que simplesmente não devemos repetir código em nosso projeto. Na realidade, é algo mais que isso.
O que de fato nos é dito é que toda informação em um sistema deve ser representada de forma única e inequívoca. E que, além disso, esta informação também pode ser a fonte para a geração de diversos outros artefatos do sistema.
Grails te incentiva a começar botando a mão na massa, nada de desenhar base de dados e se preocupar com integração com SGBD especifico, basta modelar suas classes de domínio e como se relacionam, e com um comando você tem um protótipo CRUD pronto!
Conclusão
Grails, servindo-se do poder do Groovy e de estrelas do mundo Java integradas, é um dos mais sólidos, versáteis e produtivos frameworks do mercado, fazendo-se peça fundamental no leque de conhecimentos de qualquer desenvolvedor.
O que foi exposto nesse material não chega a arranhar a superfície das possibilidades que se fazem disponíveis àqueles que se interessaram em desenvolver de forma mais dinâmica, produtiva e agradável.
Onde estudar
A comunidade Grails é ampla e muito ativa, o site oficial é uma ótima fonte de material, sem falar no site da comunidade nacional.
Para explorar todo o potencial do Grails é bom saber o potencial do Groovy, mas por ser uma linguagem amigavel aos programadores Java basta algumas poucas pinceladas em Groovy e já é possível começar com o Grails, sendo que aos poucos a migração para Groovy se torna mais ativa.
O livro que usei nesse meu processo inicial é Falando de Grails da Casa do Código, didático que objetivo para quem não sabe nada de Groovy à quem já usa Grails.
Dois cookbooks de Grails se destacaram ao longo do meu aprendizado por terem exemplos implementados de solução inteligentes e explicativas:
1 – Grails Cookbook
2 – Haki – É possível não só consultar como adquirir os livros com o compêndio de todas as soluções do site, divididos em Groovy, Grails, Gradle e outros
3 – Otimização de código Grails
Busque mais
♦ An Introduction to Groovy for Java Developers
Comentários