Iremos criar um novo projeto no NetBeans, só que agora do tipo Web e vamos configurá-lo com base no que já foi feito anteriormente neste tutorial no projeto desktop.
CRIAÇÃO DO PROJETO
No NetBeans, vá em File -> New Project.
No assistente de criação de projetos, escolha “Java Web” na lista de categorias e
na lista de tipos de projetos, escolha “Web Application”. Clique em “Next”.
Em “Project Name” dê o nome do projeto, sugerindo “TutorialRelatoriosWeb” (sem
as aspas).
Em “Project Location” escolha onde o projeto vai ser salvo.
Marque a opção “Use Dedicated Folder for Storing Libraries” e deixe o valor padrão
(.\lib).
Se quiser, marque a opção “Set as Main Project”. Clique em “Next”.
Na escolha do servidor, usaremos o Tomcat mas se seu NetBeans tiver somente o
Glassfish, pode seleciona-lo também.
Deixe desmarcada a opção “Use dedicated library folder for server JAR files”.
Em “JavaEE version”, deixe escolhida a versão padrão, pois não precisamos nos
preocupar com isso no nosso projeto de testes.
Em “Context Path” deixe o valor sugerido. No caso deste projeto é
/TutorialRelatoriosWeb”.
Não será usado nenhum framework MVC, logo clique em “Next” e o projeto será
criado e aberto no NetBeans.
CONFIGURANDO O PROJETO
Com o projeto criado, acesse suas propriedades clicando com botão direito na raiz do projeto e escolhendo a opção “Properties”, que é a última da lista.
Em “Categories” procure pelo item “Run” e selecione-o.
Desmarque a opção “Deploy on Save” para evitar que seja feito um deploy a cada
Adicione a biblioteca para MySql em seu projeto, com o botão direito em cima da pasta Bibliotecas > Adicionar Bibliotecas procure a “Driver JDBC do MySql” e adicione.
Já que estamos aqui, vamos aproveitar para configurar as bibliotecas. Essa
configuração é feita da mesma forma que neste tutorial foi feito na criação do projeto Desktop. Portanto, caso não tenha feito, siga os passos a partir da página 5 deste tutorial.
Ainda na janela de propriedades, procure a categoria “Sources” (primeira) e
selecione-a. Vamos criar agora o diretório onde guardaremos os nossos fontes do relatório. Na tabela “Source Package Folders”, clique no botão “Add Folder…”. Serão exibidas os diretórios contidos no projeto. Crie então uma nova pasta, chamada “relatorios” (sem acentos e sem aspas), selecione-a e clique em “Open”. A pasta será referenciada na tabela. Clique duas vezes na célula correspondente à coluna “Label” da pasta, preencha com “Relatórios” (sem as aspas) e tecle <ENTER> para trocar o “Label” da pasta. Esse “Label” vai ser utilizado para mostrar a pasta de relatórios na árvore do projeto.
Por fim, ainda na janela de propriedades, selecione a categoria “Packaging”, dentro
da categoria “Build”. Em “Exclude From WAR File”, adicione uma vírgula e o valor “**./*.jrxml” (sem as aspas). Isso fará com que os nossos arquivos fonte de relatórios não sejam empacotados no arquivo WAR. O valor final do campo deve ficar assim: “**/*.java,**/*.form, **/*.jrxml” (sem as aspas). Pronto! Clique em OK na janela de propriedades e aguarde o NetBeans escanear as novas configurações do projeto.
A próxima etapa seria a criação do relatório. Iremos aproveitar o relatório de clientes que foi criado no projeto desktop (caso você não tenha criado, siga os passos deste tutorial para criação do relatório – PARTE 2, pág. 15):
Abra o projeto desktop anterior, vá na pasta de “Relatórios” dele, copie o arquivo
“Clientes.jrxml” e cole na pasta “Relatórios” do novo projeto. Ainda não feche o
projeto anterior.
Se o relatório for renderizado e os dados aparecerem é porque está tudo ok.
Até agora nenhuma novidade. Criamos e configuramos o novo projeto e copiamos e testamos o arquivo de relatório que já fizemos para o novo projeto. Na próxima etapa, faremos o diferencial para o projeto web.
CRIAÇÃO DO SERVLET
Vamos criar um Servlet que vai ser responsável em pegar os possíveis dados do request
que serão usados como parâmetros para os relatórios e invocar o JasperReports para criar o relatório. O funcionamento é parecido com o que fizemos no nosso programa desktop, entretanto agora não iremos mais criar um JFrame para exibir os relatórios, pois estaremos usando um navegador.
O que o nosso Servlet vai fazer é criar diretamente um arquivo .pdf do relatório e mandar exibir no navegador – caso haja algum plugin para leitura de PDF instalado – ou então o navegador vai sugerir que você faça o download do arquivo gerado.
Em “Source Packages”, crie três pacotes: “jdbc”, “servlets” e “util” (todos sem as
aspas).
Vá no projeto anterior (desktop), copie a classe “Conexao” e cole no pacote “jdbc”
do novo projeto.
No novo projeto web, vá na pasta “util” e crie uma classe com o nome de
“ReportUtils” (sem as aspas). Ainda não vamos implementar nada nela.
Feito isso, clique com o botão direito no pacote “servlets”, vá em New -> Servlet. Se
a opção Servlet não estiver sendo exibida, selecione “Other” e em “Categories” selecione “Web” e em “File Types” escolha “Servlet” e clique em “Next”.
O assistente para criar um novo Servlet será exibido. Em “Class Name” preencha
com “RelatorioServlet” (sem as aspas) e clique em “Next”. Tanto “Servlet Name”
quanto “URL Pattern” vão ser deixados da forma que o NetBeans sugeriu, ou seja, “RelatorioServlet” e “/RelatorioServlet” respectivamente. Clique em “Finish”.
O NetBeans vai gerar por padrão uma implementação padrão do método
protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
OutputStream out = null;
// AQUI GERAMOS O RELATÓRIO
if ( out != null ) { out.close(); }
}
Note que ainda não implementamos o método processRequest(…). Vamos agora criar um
método utilitário na classe ReportUtils que vai ser responsável em gerar o relatório.
Segue a implementação comentada da classe ReportUtils.java
import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.sql.Connection; import java.util.Map; import javax.servlet.http.HttpServletResponse; import net.sf.jasperreports.engine.JRException; import net.sf.jasperreports.engine.JRExporter; import net.sf.jasperreports.engine.JRExporterParameter; import net.sf.jasperreports.engine.JasperFillManager; import net.sf.jasperreports.engine.JasperPrint; import net.sf.jasperreports.engine.export.JRPdfExporter;
public class ReportUtils { /**
* Gera o relatório em PDF. *
* @param inputStream InputStream que contém o relatório. * @param parametros Parâmetros utilizados pelo relatório. * @param conexao Conexão utilizada para a execução da query.
* @param response HttpServletResponse que será usado como base para * gerar o relatório.
* @return O OutputStream do HttpServletResponse passado.
* @throws JRException Caso ocorra algum problema na geração do relatório. * @throws IOException Caso ocorra algum problema na obtenção do
* OutputStream. */
public static OutputStream createPDFReport(
Connection conexao,
HttpServletResponse response ) throws JRException, IOException {
// configura o content type do response
response.setContentType( "application/pdf" );
// obtém o OutputStream para escrever o relatório
OutputStream out = response.getOutputStream();
/*
* Cria um JasperPrint, que é a versão preenchida do relatório, * usando uma conexão.
*/
JasperPrint jasperPrint = JasperFillManager.fillReport (inputStream, parametros, conexão);
// Exporta em PDF, escrevendo os dados no output stream do response.
JRExporter exporter = new JRPdfExporter();
exporter.setParameter( JRExporterParameter.JASPER_PRINT, jasperPrint ); exporter.setParameter( JRExporterParameter.OUTPUT_STREAM, out ); // gera o relatório exporter.exportReport(); // retorna o OutputStream return out; } }
Observe que o método createPDFReport(…) da classe ReportUtils gera um relatório em
PDF e o escreve no OutputStream do response do Servlet. Caso vocês queiram outros tipos de exportação, basta mudar o tipo do exportador.
No link (http://jasperreports.sourceforge.net/api/net/sf/jasperreports/
engine/JRExporter.html) pode-se ver a documentação da interface
JRExporter e de todas as classes que a implementam. Note que ao mudar o exportador, você também precisa alterar o content type do response para refletir o tipo de arquivo gerado.
Vamos agora atualizar o nosso Servlet. O método processRequest(…) ficará desta forma:
protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
OutputStream out = null;
// obtém o relatório compilado
InputStream inputStream = getClass().getResourceAsStream("/RelatorioClientes.jasper");
// preenche o mapa de parâmetros
Map<String, Object> parametros = new HashMap<>(); try {
// gera o relatório e atribui o OutputStream gerado
out = ReportUtils.createPDFReport( inputStream, parametros,
Conexao.getConexao(), response );
} catch ( JRException exc ) { exc.printStackTrace(); } finally {
// se não aconteceu nenhum problema, fecha o output stream
if ( out != null ) { out.close(); } } }
Com isso feito, rode a aplicação, no caso o servlet. Use o atalho SHIFT + F6.
Por padrão o Tomcat usado em desenvolvimento no NetBeans roda na porta 8084. Certifique-se que o seu está rodando nesta porta e se não estiver, use a porta correta.
Se você seguiu corretamente o tutorial até aqui, será gerado então um .pdf com todos os clientes.
PASSAGEM DE PARÂMETROS E OUTRAS EXPORTAÇÕES
No caso de se passar parâmetros para a geração do relatório (como indicado neste tutorial na PARTE 4), podemos incluir uma linha no servlet logo após a criação do mapa de parâmetros:
Map<String, Object> parametros = new HashMap<>();
parametros.put( "primeiroNome", "D%" );
Neste caso, será gerado então um relatório com todos os clientes que tenham o primeiro nome iniciando com a letra “D” (veja o parâmetro “primeiroNome” passado para o relatório).
Note que agora, para passar parâmetros para o relatório, basta você obter os parâmetros pelo request e então adicionar os parâmetros desejados no mapa de parâmetros do relatório.
Se quiser outros tipos de exportação, por exemplo, para Excel, basta criar um novo método na classe ReportUtils, que configura o content type apropriado (“application/ms-excel”) e o exportador necessário (JRXlsExporter ou JRXlsxExporter).
Tanto a passagem de parâmetros quanto a geração de outros tipos de arquivos ficam como exercício para você. O servlet RelatorioServlet pode ser generalizado também, permitindo que o nome do arquivo do relatório a ser gerado seja passado via request.
ANEXO
Nas propriedades do relatório, você possui o grupo Page size. Neste grupo você pode definir a largura da página (Page width) e a altura da página (Page height), bem como a Orientação (Orientation). Em Orientation, temos Portrait (Retrato) ou Landscape (Paisagem).
Embora as dimensões sejam as mais importantes para a construção de um relatório, a unidade de medidas usada pelo iReport e JasperReports é em pixels (com uma resolução de 75 dpi). Para que você possa se orientar em um arquivo JRXML do JasperReports, a seguir a Tabela a seguir mostra o padrão da página e seu valor em pixels.
No grupo Columns você pode definir quantas colunas seu relatório possuirá em uma página, no
item Columns. Column Width automaticamente se altera quando você adiciona mais de uma coluna, dividindo sem o valor em partes iguais. Column Spacing determina o espaçamento entre colunas, que também influi em Column Width automaticamente.
No grupo “More...” é possível especificar instruções para a impressão do relatório. Nele se encontram:
• Scriptlet Class - Onde você define um scriptlet, que nada mais é que uma classe Java cujos métodos são executados conforme são especificados os eventos durante a criação do relatório, como o início de uma nova página ou o fim de um grupo.
• Resource Bundle - É o nome do pacote de recursos usado para internacionalizar um relatório. É o Resource Bundle do Java, onde você define em um arquivo os textos traduzidos como rótulos. Cada linguagem corresponde a um arquivo específico.
• When Resource Missing Type – Se um pacote de recurso (Resource Bundle) não está disponível, você escolhe uma das opções na caixa de combinação. Representa o atributo
• whenResourceMissingType no JasperReports. Neste caso, você tem as seguintes opções:
1. Type Null (Nulo) – Imprime a string “Null”. Esta é a opção padrão.
2. Type Empty (Vazio) – Não imprime nada. Recebe como valor Empty no atributo
whenResourceMissingType de JasperReports.
3. Type the Key (Chave) – Imprime o nome chave que falta. Recebe como valor Key
no atributo whenResourceMissingType de JasperReports.
4. Rise an Error (Erro) – Lança uma exceção parando o processo. Recebe como valor
Error no atributo whenResourceMissingType de JasperReports.
• Query Text – Determina a query criada para o relatório.
• Query Language – Determina a linguagem utilizada para a instrução. Pode ser: SQL,
• HQL(Hibernate Query Language), XPath, EJBQL, MDX e XMLA-MDX.
• Properties – Determina as propriedades para o objeto selecionado.
• Title on a new page - Quando ativa, especifica se a banda title será impressa e em seguida criada uma nova página, gerando uma “quebra de página”.
• Summary on a new page - Esta opção é similar a anterior (Title on a new page), mas com a diferença de ser a banda summary que será impressa como a última página.
• Floating column footer - As bandas columnFooter são impressas por padrão no fim das páginas. Se na impressão do relatório não houver dados suficientes para preencher uma página, um espaço em branco aparecerá entre a coluna e o rodapé da coluna (columnFooter).
• Se você quer que o texto encontrado na banda columnFooter seja impresso logo após a impressão da coluna, marque a opção Floating column footer. Esta opção permite forçar a
impressão da banda columnFooter imediatamente após a última interação da banda detail
e não do término de todas as colunas. Esta opção é geralmente usada quando você quer criar tabelas usando os elementos de relatórios.
• Ignore pagination - Ignora a paginação ao preencher o relatório, impossibilitando a visualização das demais páginas caso haja mais que uma. Quando ativa, esta opção implica até mesmo na visualização correta dos dados caso haja mais de uma coluna.
• Print Order - A ordem de impressão (Print Order) determina como os dados impressos na página serão organizados em mais de uma coluna. O padrão para a ordem de impressão é
Vertical. Com a ordem Vertical, primeiro os dados são impressos um embaixo do outro, passando para uma nova coluna somente quando a coluna está totalmente preenchida no final da página. Na ordem Horizontal os dados são preenchidos em linha. Os dados passam por todas as colunas, adicionando uma nova linha somente quando a última coluna da página foi preenchida naquela determinada linha.
• When no data - Quando o número de dados para a impressão é vazio (query SQL sem dados, por exemplo), o relatório pode ter comportamentos diferentes para apresentar a página ao usuário. Neste caso existem quatro opções, listadas a seguir:
1. Type No Pages (Sem Páginas)– O padrão. O resultado final é um buffer vazio.
2. Type a Blank Page (Páginas em branco) – Exibe uma página em branco caso não haja dados.
3. Type All Sections, No Detail (Todas as seções, nenhum detalhe) – Mostra todas as seções existentes no relatório, menos os detalhes da banda detail.
4. Type “No Data” section – Seção sem dados. Utiliza a band noData, ou seja, você adiciona um conteúdo estático (ou dinâmico sem usar o banco de dados) neste local.
5. Caso não haja dados em uma determinada pesquisa ou sem conexão com o banco
de dados, esta seção será exibida.
• Language – Determina a linguagem a ser utilizada no relatório. Neste caso, somente as duas linguagens oficiais do JVM são possíveis, por enquanto: Java ou Groovy.
• Format Factory Class - Recebe uma string com o nome da classe de formatos, habilitando o uso de datas personalizadas e formatos de números. Representa o atributo
formatFactoryClass de JasperReports e implementa a interface