Construindo uma aplicação CRUD com o Grails – Parte II
Implementando uma busca de Carros com AJAX
Edite o arquivo “\exemplo\grails-app\controllers\CarroController.groovy” e adicione as seguintes actions no final do arquivo:
def search = {}
def doSearch = {
return [ carros: Carro.findAllByNomeLike("%"+params.nome+"%") ]
}
Note que o código acima define a action “search” sem corpo, apenas para redirecionar para o arquivo “/exemplo/grails-app/views/carro/search.gsp”. A página “search.gsp” possui um formulário, o qual faz um POST para a action “doSearch”. Neste momento que o Grails mostra um pouco da produtividade que se pode ter com linguagens mais dinâmicas. Note que o método “Carro.findAllByNomeLike” foi utilizado normalmente, porém não foi necessário implementar o método em lugar nenhum. E ainda a variável “carros” foi automaticamente adicionada na “request” da próxima página, que por convenção, se chama “doSearch.gsp”.
Crie o arquivo “/exemplo/grails-app/views/carro/search.gsp” conforme o código abaixo, e teste o exemplo. Note que não será necessário reiniciar o servidor!
A seguir a página “/exemplo/grails-app/views/carro/doSearch.gsp” que contém a lista com o resultado da busca:
Parte testar a busca acesse: http://localhost/exemplo/carro/search. Também é possível editar o arquivo “carro/list.jsp” para incluir a action “search” no menu, conforme abaixo:
O resultado pode ser visualizado abaixo:
Ao clicar em Search a tela abaixo pode ser visualizada. Observe que a busca utiliza AJAX.
O visual da tela também foi alterado para demonstrar um pouco da customizaçao do Grails. A imagem foi alterada no arquivo de layout gerenciado pelo Sitemesh, “exemplo/grails-app/views/layouts/main.gsp”, e o título em vermelho foi alterado no “/exemplo/web-app/css/main.css” na propriedade “h1”.
Entendendo o AJAX
A busca de carros implementada anteriormente utiliza AJAX. O Grails pode utilizar as bibliotecas Prototype, Yahoo UI ou Dojo toolkit para esta funcionalidade. Neste exemplo da busca, foi utilizado o Prototype.
Note que apenas 2 alterações são necessárias para utilizar AJAX, que são:
A taglib “formRemote” recebe a action que deve ser executada e o “id” dos divs onde o resultado será visualizado.
Customizando o layout
Os arquivos GSP (Groovy Server Pages) são os mais utilizados pelo Grails para a camada de visualização, devido a facilidade de executar expressões em Groovy na página. Mas páginas em JSP com JSTL/EL também poder ser utilizadas livremente.
Existem várias formas de customizar o layout da aplicaçao, uma delas é simplesmente editar o “css” gerado em “/exemplo/web-app/css/main.css”.
Mas provavelmente em uma aplicação mais complexa, será necessário ter um controle maior sobre todo o HTML gerado, e criar um “template” de página que possa ser reutilizado em toda a aplicação. Para atingir este objetivo, o Grails utiliza o framework Sitemesh do grupo Opensymphony.
Ainda é possível customizar o layout de forma específica para cada classe de Controle. Por exemplo, se criar o template “views/pessoa/pessoa.gsp”, todas as páginas controladas pelo PessoaController serão alteradas.
Utilizando a API iText para gerar PDF
Faça o download da API iText aqui: http://prdownloads.sourceforge.net/itext/itext-1.4.2.jar
Coloque o arquivo itext-1.4.2.jar no diretório “lib” do projeto.
Para tornar o exemplo mais modularizado, vamos implementar a geração do PDF em uma outra classe. Para isto pode ser utilizado uma classe Groovy, Java, ou um “Service”. Lembrando que classes Java podem ser criadas em “exemplo\src\java” e utilizadas normalmente no código.
Para este exemplo vamos criar um “Service”, que é uma classe que contém métodos com lógica de negócio. Para isto digite “grails create-service” no prompt, e entre com o nome “PdfService”:
> grails create-service…
create-service:
[input] Enter service name:
PdfService
Após isto, o arquivo “/exemplo/grails-app/services/PdfService.groovy” será criado. Edite o arquivo conforme abaixo:
import java.io.ByteArrayOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import com.lowagie.text.Document;
import com.lowagie.text.DocumentException;
import com.lowagie.text.Paragraph;
import com.lowagie.text.pdf.PdfWriter;
class PdfService {
boolean transactional = false
def createPDF() {
ByteArrayOutputStream b = null;
Document document = new Document();
try {
b = new ByteArrayOutputStream();
PdfWriter.getInstance(document, b);
document.open();
document.add(new Paragraph("PDF com Grails!"));
} catch (DocumentException de) {
System.err.println(de.getMessage());
}
document.close();
byte[] pdf = b.toByteArray();
return pdf;
}
}
Note que o código fonte é similar a linguagem Java, e isto é um dos grandes pontos fortes do Groovy.
Agora vamos criar o Controle que utiliza o PdfService, para isto abra um prompt e digite:
> grails create-controller
…
create-controller:
[input] Enter controller name:
PdfController
O arquivo “PdfController.groovy” sera criado na pasta “controller”, altere o código fonte conforme abaixo:
class PdfController {
PdfService pdfService;
def index = {
response.contentType = "application/pdf"
response.outputStream << pdfService.createPDF()
}
}
Para gerar o PDF reinicie o servidor e abra a aplicação em: http://localhost/exemplo/pdf
Note que não foi necessário criar uma nova instância de PdfService na classe PdfController. Isto é um conceito de IoC (Inversion of Control) para facilitar a programação e manutenção do código. O PdfService é gerenciado internamente pelo framework Spring.
Customizando o Hibernate (opcional)
Conforme mostrado neste artigo, o Grails pode integrar o Hibernate automaticamente para persistir as classes Groovy geradas com o comando “grails create-domain-class”.
Porém em projetos reais, pode ser que seja necessário utilizar um banco de dados legado, e para o qual os arquivos de configuração do hibernate (hibernate-cfg.xml e *.hbm.xml) já estejam mapeados. Neste caso, é possível configurar o Grails para utilizar as configurações já existentes do Hibernate, para isto, basta colocar os arquivos *.hbm.xml na pasta “hibernate” do projeto criado.
Ainda é posível utilizar classes com Java 5 e annotations, basta colocar as classes na pasta “src/java”.
Mesmo customizando a configuração do Hibernate, ainda é possível utilizar todos os métodos dinâmicos fornecidos pelo Grails, como a busca “findAllByNomeLike” implementada no exemplo deste artigo.
Integrando o Spring
Para integrar o Spring com sua aplicação, pode-se editar o arquivo “/spring/resources.xml” localizado no projeto.
Abaixo um exemplo simples de configuração:
Este componente gerenciado pelo Spring será automaticamente “injetado” na classe de Controller, se uma variável com o mesmo “id” configurado for encontrada, por exemplo:
class TesteController {
def testeBean
def list = {
render(testeBean.teste())
}
}
Para o código acima funcionar, a classe Java “teste.TesteImpl” precisa ser criada na pasta “/src/java”.
Conclusão
O segredo do Grails é utilizar frameworks consagrados como Hibernate, Spring e Sitemesh, e ainda utilizar ANT, HSQL e Jetty para deixar o ambiente de desenvolvimento simples e ágil.
A linguagem Groovy adiciona uma produtividade muito grande para desenvolver aplicações, devido a sua natureza dinâmica e simples. Ainda é possível utilizar APIs Java normalmente, conforme foi demonstrado no exemplo de criação de PDF.
O Grails está na versão 0.2, ainda muitas funcionalidades serão melhoradas e implementadas, mas com certeza ele é um projeto muito promissor e pode aumentar a produtividade com que aplicações Web são desenvolvidas.
Para ler a primeira parte deste artigo, acesse:
//www.devmedia.com.br/construindo-uma-aplicacao-crud-com-o-grails-parte-i/2445
