Utilização das Ferramentas Jasperreports e Ireport Para a Geração

SILVIO COSTA MOREIRA
UTILIZAÇÃO DAS FERRAMENTAS JASPERREPORTS E IREPORT
PARA A GERAÇÃO DE RELATÓRIO EM APLICAÇÕES JAVA
Palmas
2005
i
SILVIO COSTA MOREIRA
UTILIZAÇÃO DAS FERRAMENTAS JASPERREPORTS E IREPORT
PARA A GERAÇÃO DE RELATÓRIO EM APLICAÇÕES JAVA
“Monografia
apresentada
como
requisito parcial para a obtenção de
nota na disciplina de Estágio
Supervisionado em Sistema de
Informação do curso de Sistemas de
Informação, orientado pelo Profº.
Fernando Luiz de Oliveira.”
Palmas
2005
ii
SILVIO COSTA MOREIRA
UTILIZAÇÃO DAS FERRAMENTAS JASPERREPORTS E IREPORT
PARA A GERAÇÃO DE RELATÓRIO EM APLICAÇÕES JAVA
“Monografia
apresentada
como
requisito parcial para a obtenção de
nota na disciplina de Estágio
Supervisionado em Sistema de
Informação do curso de Sistemas de
Informação, orientado pelo Profº.
Fernando Luiz de Oliveira.”
Aprovada em Dezembro de 2005
BANCA EXAMINADORA
_____________________________________________
Profº. M.Sc. Fernando Luiz de Oliveira
Centro Universitário Luterano de Palmas
_____________________________________________
Profº. M.Sc. Fabiano Fagundes
Centro Universitário Luterano de Palmas
_____________________________________________
Profº. Ricardo Marx Costa de Jesus
Centro Universitário Luterano de Palmas
Palmas
2005
iii
AGRADECIMENTOS
À Deus por te me dado a vida a minha familia; Aos meus pais: Salomão Barbosa Moreira e
Raimunda Ires costa Moreira por terem me dado oportunidade de chegar até aqui; Aos
meus irmãos: Viviane Costa Moreira, Fabiane Costa Moreira, Saulo Costa Moreira, Alinne
Costa Moreira e Lidianne Costa Moreira; Aos meus sobrinhos: Isabella, Samuel, Emanuel
por terem me dado espiração para buscar novos horizontes; Aos meus tios, primos,
cunhado.
Aos professores que no decorrer deste curso me transmitem conhecimento, ao
professor Fernando Luiz de Oliveira que me orientou na conclusão desse trabalho.
Enfim, colegas de sala que se tornaram parte da minha vida, aos funcionarios e
professores que trabalham na sala de produção de texto, aos funcionarios da biblioteca do
CEULP/ULBRA-TO que me ajudaram a encotrar bibliografias necessarias para o
desenvolvimento deste trabalho.
iv
SUMÁRIO
LISTA DE FIGURAS .....................................................................................................................................V
LISTA DE TABELAS................................................................................................................................... VI
1 INTRODUÇÃO ...........................................................................................................................................11
2 REVISÃO DE LITERATURA...................................................................................................................13
2.1 GERAÇÃO DE RELATÓRIO .......................................................................................................................13
2.1.1 Organização de um Relatório ........................................................................................................14
2.2 GERAÇÃO DE RELATÓRIOS UTILIZANDO A LINGUAGEM DE PROGRAMAÇÃO JAVA .................................15
2.3 JASPERREPORTS .....................................................................................................................................16
2.3.1 Projeto do Relatório ......................................................................................................................18
2.3.2 Origem dos Dados .........................................................................................................................19
2.3.3 Campos ..........................................................................................................................................19
2.3.4 Expressões .....................................................................................................................................20
2.3.5 Variáveis ........................................................................................................................................21
2.3.6 Seções do Relatório........................................................................................................................22
2.3.7 Parâmetros.....................................................................................................................................23
2.3.8 Principais Classes da Biblioteca JasperReports ...........................................................................24
2.4 IREPORT .................................................................................................................................................25
2.4.1 Criação de Projetos de Relatórios com iReport ............................................................................26
2.4.2 Origem dos Dados com iReport.....................................................................................................27
2.4.3 Criação de Parâmetros com iReport .............................................................................................28
2.4.4 Criação de Campos com iReport ...................................................................................................30
2.4.5 Criação de Variáveis com iReport.................................................................................................31
2.4.6 Criando Expressões com iReport...................................................................................................32
2.4.7 Seções com iReport ........................................................................................................................33
2.4.8 Testando e Visualizando o Projeto do Relatório no iReport..........................................................34
2.4.9 Código Gerado no IREPORT ........................................................................................................36
3 MATERIAIS E MÉTODOS .......................................................................................................................37
3.1 LOCAL E PERÍODO ..................................................................................................................................37
3.2 MATERIAIS .............................................................................................................................................37
3.2.1 Fontes Bibliográficas.....................................................................................................................37
3.2.2 Hardware .......................................................................................................................................38
3.2.3 Software .........................................................................................................................................38
3.2.4 Instalação e Configuração das Ferramentas.................................................................................38
3.2.4.1 Instalação e Configuração do J2SE 1.5.0 ............................................................................................... 38
3.2.4.2 Instalação e Configuração do IReport .................................................................................................... 43
3.2.4.3 Instalação e Configuração do JasperReports .......................................................................................... 44
3.3 METODOLOGIA .......................................................................................................................................45
4 RESULTADOS E DISCUSSÃO.................................................................................................................47
4.1 VISÃO GERAL DA APLICAÇÃO ................................................................................................................47
4.2 GERANDO RELATÓRIO ............................................................................................................................47
5 CONSIDERAÇÕES FINAIS......................................................................................................................61
6 REFERÊNCIAS BIBLIOGRÁFICAS.......................................................................................................62
ANEXOS .........................................................................................................................................................63
v
LISTA DE FIGURAS
Figura 1: Funcionamento da biblioteca JasperReports. (JASPERREPORTS, 2005). .....................................................17
Figura 2: Exemplo de um projeto do relatório. (JASPERREPORTS, 2005). ....................................................................18
Figura 3: Passagem de um objeto resultset para o relatório, através de uma classe Java..............................................19
Figura 4: Código de criação de um campo. (JASPERREPORTS, 2005)...........................................................................20
Figura 5: Código de criação de uma expressão. (JASPERREPORTS, 2005)...................................................................20
Figura 6: Código de criação de uma variável. (JASPERREPORTS, 2005) ......................................................................21
Figura 7: Código de criação de uma seção. (JASPERREPORTS, 2005) ..........................................................................23
Figura 8: Código de criação de um parâmetro. (JASPERREPORTS, 2005)....................................................................24
Figura 9: Tela principal do iReport - Menu Arquivo............................................................................................................26
Figura 10: Tela de configuração inicial do projeto do relatório.........................................................................................27
Figura 11: Tela principal, menu fonte de dados....................................................................................................................27
Figura 12: Telas de criação e configuração e teste de uma fonte de dados.......................................................................28
Figura 13: Tela principal do iReport, menu visualizar.........................................................................................................29
Figura 14: Telas de criação e configuração de parâmetros ................................................................................................29
Figura 15: Tela principal, menu ‘Visualizar’, ‘Campos do Relatório’...............................................................................30
Figura 16: Telas de criação e configuração de campo do projeto......................................................................................31
Figura 17: Tela principal, menu ‘Visualizar’, ‘Variáveis do Relatório’ ............................................................................31
Figura 18: Telas de criação e configuração de variável......................................................................................................32
Figura 19: Tela de criação e configuração de uma variável. ..............................................................................................33
Figura 20: Tela principal, página do projeto dividas em seções.........................................................................................34
Figura 21: Tela principal, menu ‘Criar (build)’, ‘Executa relatório (usando uma conexão ativa)’...............................35
Figura 22: Visualização do relatório na interface JasperViewer........................................................................................35
Figura 23: Tele de propriedades do sistema Windows 2000. ..............................................................................................39
Figura 24: Tele de criação e configuração das variáveis de ambiente. .............................................................................40
Figura 25: Tela de criação de uma variável de ambiente do usuário.................................................................................41
Figura 26: Tela de criação da variável de ambiente do usuário.........................................................................................42
Figura 27: Tela de criação da variável de ambiente do usuário.........................................................................................43
Figura 28: Tela de configuração.............................................................................................................................................44
Figura 29: Tela de adição de bibliotecas ao CLASSPATH .................................................................................................45
Figura 30: Tela de criação e configuração iniciais do projeto............................................................................................48
Figura 31 : Tela de criação e configuração da fonte de dados ...........................................................................................49
Figura 32: Tela de ativação da fonte de dados do projeto...................................................................................................50
Figura 33: Tela de criação e configuração de parâmetro para o projeto do relatório....................................................51
Figura 34: Barra de ferramentas do iReport .........................................................................................................................51
Figura 35: Inserção de um parâmetro dentro da seção title................................................................................................52
Figura 36: Inserção dos campos dentro da seção deitel da pagina do relatório ..............................................................53
Figura 37: Tela de configuração de um campo dentro da seção deitel da página do relatório......................................54
Figura 38: Tela de criação de variável...................................................................................................................................55
Figura 39: Inserção de uma variável na seção totalFooter .................................................................................................56
Figura 40: Visualização do relatório através da interface gráfica JasperVierwer...........................................................57
Figura 41: Executando o relatório na aplicação...................................................................................................................59
vi
LISTA DE TABELAS
Tabela 1: Cronograma das atividades....................................................................................................................................46
vii
RESUMO
A geração de relatórios corresponde a uma das tarefas mais comuns e necessárias em
sistemas de informação. Assim, por menor que seja o sistema, a geração de relatórios será
um de seus requisitos. Por ser um requisito necessário, as ferramentas tendem a agregar
funcionalidades que facilitem o trabalho dos desenvolvedores. Por exemplo, para a
linguagem de programação Java existem ferramentas que auxiliam este trabalho, tal como
a biblioteca de classe Java chamada JasperReports, que com o auxílio da ferramenta
iReport proporciona o desenvolvimento de relatórios para aplicações Java. O presente
trabalho tem a finalidade de expor conceitos envolvendo a geração de relatório em
aplicações Java, utilizando o JasperReports e iReport, bem como apresentar, na prática, sua
utilização através da geração de relatório para uma determinada aplicação desenvolvida em
Java.
Palavras-chaves: Desenvolvimento de Sistemas, JasperReports e iReport
viii
ABSTRACT
The generation of reports corresponds to one of the most common and necessary tasks in
information systems. Thus, despite the size of the system, the generation of reports will be
one of its requirements. As for being a necessary requirement, the tools tend to add
functionalities that facilitate the work of the developers.
For example, for the Java
programming language there are tools that help this work, such as the library of class
called Java JasperReports, with the help of the proportional tool iReport the report
development for Java applications. The present work has the purpose to display concepts
involving the generation of report in Java applications, using the JasperReports and
iReport, as well presenting, in practical, its use through the generation of report for one
determined application developed in Java.
Keywords: Development of Systems, JasperReports e iReport
11
1 INTRODUÇÃO
A geração de relatórios corresponde a uma das tarefas mais comuns e necessárias em
sistemas de informação. Assim, por menor que seja o sistema, a geração de relatórios será
um de seus requisitos, sendo que, basicamente, relatórios são compostos pelo design e pelo
mapeamento dos dados para os campos existentes em seu layout. Geralmente as linguagens
de programação dão suporte a essa tarefa, através do desenvolvimento de ferramentas que
auxiliam na construção de relatório para a apresentação de dados. Isto é necessário porque
criar relatórios sem estas ferramentas não é uma tarefa simples e requer um grande esforço
durante a fase de implementação da aplicação.
Para a linguagem de programação Java existem várias ferramentas que facilitam a
construção de relatórios para a apresentação de dados. Durante anos a ferramenta Cristal
Reports dominou o mercado. Porém, nos últimos anos, novas ferramentas foram
desenvolvidas, oferecendo o mesmo pacote de recursos, mas com a vantagem de serem
gratuitas, pois a ferramenta citada acima não é. Dentre essas ferramentas, merecem
destaque o JasperReports e iReport, pois, além de serem gratuitas, oferecem uma grande
quantidade de recursos para o desenvolvimento de relatórios, bem como são facilmente
utilizadas dentro do contexto da linguagem de programação Java.
O JasperReports é uma biblioteca de classe Java que tem como finalidade a geração
de relatórios em aplicações Java. As classes pertencentes a essa biblioteca vêm com um
conjunto de métodos que dão suporte ao desenvolvimento do relatório, ficando a cargo do
programador desenvolver o projeto do relatório e buscar os dados para o seu
preenchimento. Já o iReport é uma ferramenta que tem como finalidade auxiliar a criação
do projeto de relatório que será utilizado pela biblioteca JasperReports. O projeto de
relatório consiste em um arquivo XML, no qual é definido o design do relatório, assim
como a definição do mapeamento dos dados para os campos dentro do layout definido.
Esta ferramenta tem uma interface gráfica que torna o desenvolvimento do projeto de
12
relatório uma tarefa simples e rápida. Com a utilização da biblioteca JasperReports e da
ferramenta iReport é possível, em pouco tempo, desenvolver relatório com qualidade para
aplicações Java.
O presente trabalho tem a finalidade de expor os conceitos envolvendo a geração de
relatório em aplicações Java, utilizando as ferramentas JasperReports e iReport, assim
como apresentar os recursos oferecidos por essas duas ferramentas, demonstrando sua
utilização através do desenvolvimento de um relatório para uma determinada aplicação
desenvolvida na linguagem de programação Java.
Para tanto, este trabalho está estruturado da seguinte forma: no capítulo 2 são
apresentados os conceitos referentes às ferramentas JasperReports e iReport. No capítulo 3
são apresentados os materiais e métodos utilizados nos estudos das ferramentas e os
recursos de hardware e software utilizados para desenvolver esse trabalho. O capítulo 4
apresenta os resultados obtidos com o estudo, assim como a utilização dessas ferramentas.
E, por fim, no capítulo 5 são apresentadas as considerações finais acerca deste trabalho.
13
2 REVISÃO DE LITERATURA
Para que os propósitos desse trabalho fossem atingidos, foram realizados pesquisas e
estudos envolvendo conceitos e ferramentas referentes á geração de relatório em aplicações
Java. Parte destes estudos foi retirada dos tutoriais disponíveis em (JASPERREPORTS,
2005) e (IREPORT, 2005) e serão apresentados no decorrer dessa seção. Estes estudos são
necessários para fornecer uma fundamentação teórica para uma melhor compreensão do
objetivo desse trabalho, no que se refere à geração de relatório em aplicações Java, com
JasperReports e iReport.
2.1 Geração de Relatório
A geração de relatórios em um sistema de informação consiste basicamente na visualização
e impressão dos dados manipulados pelo sistema. Esta é a forma que o usuário tem para
visualizar os dados armazenados, sejam eles na tela do computador ou em papel impresso.
“Os relatórios em geral são impressos pelo sistema em formulários contínuos. Este
formulário é formado por folhas de papel que estão ligadas entre si”. (VILLAS, 1988). No
entanto, nem todo relatório será impresso, pois, em muitas situações, somente são
utilizados para consulta no próprio sistema de computador.
Os dados que são apresentados nos relatórios podem vir de várias origens, sendo
mais comum que os dados sejam proveniente de um Sistema de Gerenciamento de Banco
de Dados (SGBD). Como exemplos de relatórios podem ser citados: relatório de contas a
pagar, relatório de vendas, folha de pagamento de funcionários e vários outros de acordo
com o sistema desenvolvido.
14
2.1.1 Organização de um Relatório
Um relatório “é organizado em três níveis de controle” (VILLAS, 1988): nível de relatório, nível
de página e nível de campo, sendo que cada nível de controle está dividido em três partes
denominadas por: “cabeçalho, corpo e rodapé” (VILLAS, 1988). Estes níveis serão detalhados
abaixo:
Nível de Relatório: neste nível são tratadas as informações gerais sobre o relatório
gerado.”É dividido em três partes: cabeçalho, corpo e rodapé” (VILLAS, 1988).
cabeçalho: o cabeçalho do nível de relatório corresponde à identificação do sistema,
ou seja, o nome do sistema que gerou o relatório: o titulo do relatório.
corpo: o corpo deste nível corresponde às páginas do relatório.
rodapé: o rodapé deste nível indica a área onde são inseridos os totais gerais de
todos os dados apresentados no relatório, e também as informações gerais.
Nível de Página: neste nível são tratadas as informações que compõem uma página do
relatório.”São divididos em três partes: cabeçalho, corpo e rodapé” (VILLAS, 1988).
cabeçalho: o cabeçalho deste nível é a primeira informação que compõe uma
página. Como exemplo de cabeçalho pode-ser citado o título da página.
corpo: o corpo deste nível refere-se à área reservada para a apresentação das
informações que estão dentro dos campos. Esta área e conhecida como detail
(detalhe).
rodapé: o rodapé deste nível corresponde à área reservada onde deverão ser
inseridos os totais gerais de todos os dados apresentados na página do relatório, e
também informações gerais sobre a página.
Nível de Campo: cada informação exibida em uma página do relatório é chamada de
campo. Um campo pode conter informação de vários tipos de dados, e também são
divididos em três partes: “cabeçalho, corpo e rodapé” (VILLAS, 1988).
cabeçalho: o cabeçalho do nível de campo corresponde ao nome do campo.
corpo: o corpo do nível de campo corresponde às informações que compõem o
campo e que devem ser impressas na página.
15
rodapé: o rodapé do nível de campo é a área reservada para apresentação dos totais
gerais das informações apresentadas nos campos.
2.2 Geração de Relatórios Utilizando a Linguagem de Programação Java
A geração de relatórios está presente na maioria dos sistemas de informação que
processam dados. Geralmente as linguagens de programação dão suporte a esta
funcionalidade, desenvolvendo ferramentas que auxiliam os programadores na realização
desta tarefa. Para a linguagem de programação Java existem ferramentas comerciais como
Cristal Reports , “que, com o passar do tempo, tornou-se cada vez mais robusto no que diz
respeito a novas funcionalidades, com o suporte a diferentes tipos de fontes de dados”
(PAIXÃO, 2005). Existem também ferramentas e bibliotecas de classes gratuitas, como,
por exemplo, JasperReports, que com o auxílio da ferramenta iReport facilitam a criação
de relatórios para aplicações Java. As classes da biblioteca JasperReports oferecem um
conjunto de métodos que já estão implementadas para criar os relatórios, exigindo do
programador apenas a definição do design do relatório, que pode ser criado através do
iReport, e a definição dos dados que serão exibidos.
A linguagem de programação Java oferece aos programadores a reutilização de
classes que já tenham sido implementadas e testadas, ou seja, pode-se construir uma nova
classe Java a partir de outras classes. Além das bibliotecas disponibilizadas no J2SDK1 (kit
de desenvolvimento Java), existe uma variedade de classes Java desenvolvidas em vários
paises, as quais são disponibilizadas em bibliotecas de classes, organizadas em pacotes.
Essas bibliotecas são criadas e utilizadas em aplicações específicas e têm como objetivo
ajudar os programadores Java nas tarefas de programação, como, por exemplo: gerar
relatório, manipulação de datas e várias outras finalidades.
“As bibliotecas de classes são fornecidas principalmente por fornecedores de
compiladores, mas muitas bibliotecas de classes são fornecidas por fornecedores
independes de software (ISV-independent software vendor). Da mesma Forma,
muitas bibliotecas de classes estão disponíveis a partir da Internet e da World
Wide Web como freeware ou shareware.” (DEITEL,
1
2003).
Possui as ferramentas necessárias para o desenvolvimento de aplicações Java. Disponível para download
em: http://java.sun.com/j2se/1.5.0/download.jsp.
16
A reutilização dessas classes é uma prática nova em programação, chamada de
desenvolvimento baseado em componentes, que agiliza o processo de desenvolvimento e
“desta forma, a complexidade no desenvolvimento é reduzida, assim como os custos,
através de reutilização de componentes exaustivamente testados” (GABRIEL, 2005).
Atualmente, JasperReports e iReport vêm se destacando no mercado como
ferramentas que geram relatórios para aplicações Java por dois motivos: primeiro, elas dão
suporte à geração de relatório de uma forma simples e rápida; segundo, por serem
gratuitas. Estas ferramentas serão descritas nas seções seguintes.
2.3 JasperReports
O JasperReports2 é uma biblioteca Java, ou seja, é um conjunto de pacotes compostos por
classes Java, desenvolvido por um fornecedor independente chamado JasperSoft3. Esta
biblioteca tem como finalidade à geração de relatório em aplicações Java.
A geração de relatório consiste na apresentação de dados armazenados e
manipulados por um sistema de informação. JasperReports permite a apresentação desses
dados, sejam eles provenientes de um SGBD, collections ou de um arrays de objeto. Para
criar um relatório utilizando esta biblioteca é necessária a existência de um projeto de
relatório, onde são inseridos e configurados todos os elementos que comporão o relatório:
seções, campos, variáveis, parâmetros, expressões, base de dados, imagens e figuras
geométricas, gráficos, entre outros. O projeto é definido através de um arquivo
desenvolvido segundo os conceitos da eXtensible Markup Language (XML), através da
especificação de tags XML e expressões Java.
Para gerar um relatório utilizando essa biblioteca é necessário passar pelos
seguintes processos: processo de compilação, preenchimento e visualização em um
formato definido. Todos estes processos são realizados por classes pertencentes à própria
biblioteca JasperReports.
O processo de compilação consiste na verificação das tags XML e das expressões
Java contidas no projeto do relatório. É realizado pela classe
net.sf.JasperReports.engine.JasperManag, disponível na biblioteca JasperReports,
2
3
Disponível para download em: http://sourceforge.net/projects/jasperreports
Mais informação sobre o jaspeSorft é encontrado em: http://www.jaspersoft.com/
17
através do método compileRepor, que retorna um objeto “.jasper” que pode ser salvo em
disco com a extensão “.jasper”. O objeto “jasper” é o relatório propriamente dito, pronto
para receber os dados e parâmetros.
O processo de preenchimento consiste na alimentação do relatório com os dados
recuperados de uma origem. A função de preenchimento é realizada pela classe
sf.JasperReportss.engine.JasperManager,
através
do
método
JasperFillManager.fillReport, que recebe: o objeto gerado no processo de compilação
“jasper”, parâmetros, conexão com banco de dados ou resultset. Este último corresponde a
um objeto gerado a partir da execução de métodos de conexão e recuperação de dados
próprios da linguagem utilizada que, no caso da linguagem de programação Java, utiliza o
à biblioteca de classe java.sql.*, para fazer conexões com banco de dados.
Após passar por todos esses processos, o relatório estará pronto para ser visualizado
na tela do computador, salvo em disco, impresso ou ser exportado para vários formatos:
pdf, html, xsl, csv, xml. O relatório é apresentado em uma interface gráfica, o
JasperViewer, que é uma classe da biblioteca JasperReports, ou em outros formatos
suportado pela biblioteca. A Figura 1 ilustra o funcionamento da biblioteca JasperReports,
os processos necessários para a criação, preenchimento e apresentação do relatório.
Figura 1: Funcionamento da biblioteca JasperReports. (JASPERREPORTS, 2005).
18
2.3.1 Projeto do Relatório
O projeto do relatório é definido por um arquivo XML, onde será especificado o design do
relatório, assim como será definido o mapeamento dos dados para os campos dentro do
layout do relatório. Neste arquivo são inseridas as seções, a localização dos campos,
variáveis, a base de dados, linhas, imagens, figuras geométricas, dentro de uma seção. “O
projeto de relatórios é definido em um arquivo XML através de tags XML que obedecem a
uma estrutura, vocabulário e restrições declarados em um Document Type Definition
(DTD), denominado “JasperReports.dtd” (JASPERREPORTS, 2005). Esse arquivo passa
por um processo de compilação dando origem a um objeto “jasper” que pode ser salvo em
disco com a extensão “.jasper”. A Figura 2 apresenta o código para um exemplo de projeto
de relatório.
1. <?xml version="1.0"?>
2. <!DOCTYPE jasperReport
PUBLIC "-//JasperReports//DTD Report Design//EN"
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">
3. <jasperReport name="Relatorio" ... >
...
4. </jasperReport>
Figura 2: Exemplo de um projeto do relatório. (JASPERREPORTS, 2005).
Na linha 1 (da Figura 2) é definido o cabeçalho XML, especificando a versão
utilizada no arquivo. A linha 2 é indicado o DTD que estrutura o arquivo XML
(JasperReports.dtd) da biblioteca JasperReports e na linha 3 apresenta a tag de abertura do
relatório e na linha 4 a tag de fechamento correspondente.
19
2.3.2 Origem dos Dados
Para a construção de um relatório é necessária a existência de uma origem de dados para
que o relatório possa ser preenchido com os dados provenientes desta origem. A biblioteca
JasperReports dá sustentação a vários tipos de origem de dados e usa uma relação chamada
JRDataSource, que é uma “representação abstrata de uma origem dos dados de
JasperReports” (JASPERREPORTS, 2005). Os dados podem ser provenientes de um
SGBD, collections ou de um arrays de objetos. O mais comum é que os dados do relatório
sejam provenientes de um SGBD, podendo ser passados para o relatório através de uma
conexão ou um Resultset, que é um objeto gerado pela execução de uma instrução SQL, e
contém dados extraídos de uma fonte de dados. A Figura 3 apresenta o código para um
exemplo de passagem de um objeto resultset para operação de preenchimento do relatório
através de uma classe Java.
1.JRResultSetDataSource jrRS = new JRResultSetDataSource(result);
2.JasperPrint impressao =
JasperFillManager.fillReport(layoutJarper,parametros,jrRS );
Figura 3: Passagem de um objeto resultset para o relatório, através de uma classe Java.
Na linha 1 (da Figura 3), é realizada a conversão de um objeto resultset, gerado por
uma instrução SQL, para um formato entendido pela biblioteca através da classe
JRResultSetDataSorce. Já na linha 2 é realizada a operação de preenchimento, que deve
conter o projeto compilado, parâmetros e o resultset convertido.
2.3.3 Campos
Somente por meio dos campos definidos dentro do layout do relatório é que se pode
apresentar os dados provenientes de uma determinada origem. Se a origem dos dados for
20
um resultset, os campos do relatório devem relacionar as colunas correspondentes ao
objeto resultset, ou seja, devem ter o mesmo nome e o mesmo tipo que as colunas do
objeto. A Figura 4 apresenta o código para um exemplo de campo dentro do projeto do
relatório.
1. <field name="codigo" class="java.lang.Integer"/>
2. <field name="nome_cidade" class="java.lang.String"/>
3. <field name="data" class="java.util.Date"/>
Figura 4: Código de criação de um campo. (JASPERREPORTS, 2005).
Na linha 1 (da Figura 4) é definida a tag de criação de um campo dentro do projeto
do relatório, contendo as seguintes configurações: name = “código” e o tipo de dados que
este campo suporta, ou seja, do tipo Integer. Da mesma forma, a linha 2 e 3 definem outros
campos a serem apresentados neste relatório de exemplo.
2.3.4 Expressões
As expressões permitem a utilização de elemento da linguagem Java dentro do projeto de
relatório.“São utilizadas para especificar o conteúdo de campos de texto, na realização de
cálculos freqüentes, por exemplo. Todas elas são expressões Java que podem conter em
sua sintaxe: campos, parâmetros e variáveis de relatório” (PAIXÃO, 2005). A Figura 5
apresenta o código para um exemplo de criação de uma expressão dentro do projeto.
1. <textFieldExpression>
2. “Sr.(a) ”+ $F{Cliente} + " realizou um total de compras no valor de "
+ $V{ValorTotalCompraSum} + " no dia "
+ (new SimpleDateFormat("dd/MM/yyyy")).format($F{DataCompra}) + "."
3. </textFieldExpression>
Figura 5: Código de criação de uma expressão. (JASPERREPORTS, 2005).
21
Na linha 1 (da Figura 5) é definida a tag de abertura de uma expressão dentro de
um campo do projeto do relatório. Já na linha 2 é criada a expressão com os campos:
‘Cliente’, ‘DataCompra’ e uma variável ‘ValorTotalCompraSum’. A linha 3 é apresenta a
tag de fechamento da expressão.
2.3.5 Variáveis
As variáveis podem ser usadas para simplificar o projeto do relatório. Através de uma
variável é possível declarar somente uma expressão, que pode ser usada durante todo o
projeto do relatório para armazenar o resultado de cálculos, tais como: contagem, soma,
menor, maior e vários outros. Uma variável deve conter uma expressão para executar
cálculos, assim como um campo ou um conjunto de campos do relatório sobre os quais os
cálculos serão realizados. A Figura 6 apresenta o código para um exemplo de criação de
uma variável dentro do projeto.
1. <variable name="QuantitySum" class="java.lang.Double"
resetType="Page" calculation="Sum">
2. <variableExpression>$F{Quantity}</variableExpression>
3. <initialValueExpression>new Double(0)
4. </initialValueExpression>
5. </variable>
Figura 6: Código de criação de uma variável. (JASPERREPORTS, 2005)
Na linha 1 (da Figura 6) é definida a tag de abertura para a definição de uma
variável dentro do projeto do relatório contendo as seguintes configurações: name =
“QuantitySum” nome da variável, class = “Java.lang.Double” indica que a variável
conterá dados do tipo Double, reseType = “Page” nível que é executada a operação de
cálculo, ou seja, calcula os valores contidos em cada página separadamente, e o tipo de
cálculo definido por calculation = “Sum”, significa que será executada uma soma com os
valores do campo “QuantitySum”. A linha 2 é mostrada a tag de abertura da expressão dae
22
uma variável, que contém o campo que será calculado. Já na linha 3 é especificada a tag de
abertura do valor de inicialização da expressão. Na linha 4 é apresentada a tag de
fechamento da inicialização da expressão e, na linha 5, por sua vez, a tag de fechamento
da variável.
2.3.6 Seções do Relatório
Um relatório é composto por páginas que recebem os dados a serem apresentados. As
páginas são divididas em seções, tais como:
background: esta seção é usada para definir uma cor de fundo para as páginas do
relatório.
title: esta seção corresponde ao cabeçalho do relatório. É impresso somente uma vez e
na primeira página do relatório.
pageHeader: esta seção corresponde ao cabeçalho de uma página. É impresso em cada
página.
columnHeader: esta seção corresponde ao cabeçalho da coluna de uma página. É
impresso em cada página que contém uma seção detail. Se uma página for dividida em
uma ou mais colunas, esta seção será impressa em cada coluna da página.
detail: esta seção corresponde ao corpo de uma página; nela são impressos os dados
recuperados de uma fonte de dados através dos campos.
columnFooter: esta seção corresponde ao rodapé da coluna de uma página. É impresso
em cada página que contém uma seção detail. Se uma página for dividida em uma ou
mais colunas, esta seção é impressa em cada coluna da página.
pageFooter: esta seção corresponde ao rodapé de uma página E é impressa em cada
página do relatório.
summary: esta seção corresponde ao rodapé do relatório. É impressa somente uma
vez, no fim do relatório, podendo ser impressa em uma página separada.
As seções são parte de uma página do relatório que tem uma altura e uma largura
especificadas, e pode conter objetos do relatório como linhas, retângulos, imagens, campos
23
de texto, variáveis entre outros. A Figura 7 apresenta o código exemplo para a criação de
uma seção dentro do projeto, assim como suas configurações e objetos inseridos.
1. <pageHeader>
2.
<band height="30">
3.
<staticText>
4.
<reportElement x="0" y="0" width="555" height="25"/>
5.
<textElement textAlignment="Center">
6.
<font fontName="Helvetica" size="18"/>
7.
</textElement>
8.
<text>Texto do elemento de texto</text>
9.
</staticText>
10.
</band>
11. </pageHeader>
Figura 7: Código de criação de uma seção. (JASPERREPORTS, 2005)
Na linha 1 (da Figura 7) é definida a tag de criação de uma seção pageHeader. A
linha 2 é apresenta a tag que configura o tamanho de uma seção dentro da página. Já na
linha 3 é especificada a tag para a criação de um elemento de texto dentro de uma seção.
Na linha 4 é definida a tag que especifica a posição e o tamanho do elemento de texto
dentro da seção. A linha 5 apresenta a tag de configuração do elemento de texto dentro da
seção. Já na linha 6 é definida a tag de configuração da fonte do elemento de texto da
seção e na linha 7 e fechada a tag de configurações do elemento de texto. A linha 8
apresenta a tag de abertura e inserção do texto, assim como a tag de fechamento do texto
do elemento de texto. Na linha 9 o elemento de texto tem sua tag fechada. Nas linhas 10 e
11 é apresentada a tags de fechamento da configuração do tamanho que a seção ocupará na
página e do fechamento da seção dentro do projeto do relatório.
2.3.7 Parâmetros
Os paramentos são referências passadas ao relatório nas operações de preenchimento. Com
isso o relatório torna-se dinâmico, pois é possível passar dados que não estão presentes na
origem de dados para o relatório. “Uma forma de utilização dos parâmetros é usá-los para
mudar dinamicamente uma instrução SQL, em tempo de execução do relatório, como, por
exemplo: select * from funcionário where nome = ‘$P!{nome}’” (PAIXÃO, 2005).
24
Também podem ser usadas para a passagem de títulos, imagens e outras. A Figura 8
apresenta o código exemplo para a criação de um parâmetro dentro do projeto do relatório.
1. <parameter name="Titulo" class="java.lang.String"/>
2. <parameter name="Codigo" class="java.lang.Integer"/>
3. <parameter name="Imagem" class="java.awt.Image"/>
Figura 8: Código de criação de um parâmetro. (JASPERREPORTS, 2005)
Na linha 1 (da Figura 8) é definida a tag de criação de um parâmetro dentro do
projeto,
contendo as seguintes configurações: name = “Titulo”, define o nome do
parâmetro, classe = “Java.lang.String”, define o tipo de dados que este campo suporta no
caso String. Da mesma forma, as linhas 2 e 3 definem outros campos a serem apresentados
neste relatório.
2.3.8 Principais Classes da Biblioteca JasperReports
Um relatório é gerado através de classes pertencentes a bibliotecas JasperReports, tendo
como base o projeto do relatório e cada classe tem uma função específica. As principais
classes da biblioteca JasperReports, assim como suas funções, serão descritas a seguir:
net.sf.JasperReports.engine.JasperManager: responsável por fazer a compilação do
projeto, que consiste na verificação das tags XML e expressões Java nele contidas que
obedecem as regras e restrições do “jasperreports.dtd” da biblioteca.
net.sf.JasperReports.engine.design.JasperDesign: responsável pela construção do
design do relatório, com base no que foi definido no projeto.
net.sf.JasperReports.engine.JasperReports: representa o design do relatório com seus
objetos: campos, variáveis, parâmetros, imagens, figuras geométricas e outras,
deixando assim o relatório pronto para preenchimento das informações a partir da base
de dados.
25
net.sf.JasperReports.engine.JasperPrint: esta classe permite ver o preenchimento
completo do relatório nos mais diferentes formatos: pdf, html, xsl, csv, xml, conforme
for definido.
net.sf.JasperReports.view.JasperViewer: responsável pela exibição do relatório
preenchido em uma interface gráfica chamada JasperViewer. Contém uma interface
para a exibição dos dados do relatório na tela do computador com a opção de importar
o relatório preenchido para os formatos suportados pelo JasperReports.
2.4 iReport
Desenvolver projetos de relatório para a biblioteca JasperReports é uma tarefa que exige
conhecimento em XML, assim como das regras e tags definidas no DTD
(JasperReports.dtd) da biblioteca JasperReports que estrutura o documento XML e que
representa o projeto do relatório.“Esse foi um dos problemas que, no início, tornava
inviável a utilização da biblioteca JasperReports, pois para um programador desenvolver
um projeto de relatório utilizando a biblioteca, era necessário o conhecimento da
linguagem XML e das regras contida no DTD da biblioteca JasperReports
(JasperReports.dtd)” (PAIXÃO, 2005).
Para resolver esse problema foram criadas ferramentas GUI (Interface Gráfica com
Usuário) para o desenvolvimento do projeto do relatório e suas configurações. Existem
várias ferramentas que oferecem uma interface gráfica para o desenvolvimento do projeto
de relatório para a biblioteca JasperReports, sendo que o iReport é uma dessas.
O iReport4 é um programa desenvolvido totalmente em Java, e tem como finalidade
desenvolver projetos de relatórios de uma forma simples e rápida, através de uma interface
gráfica. Assim, sem ter nenhum conhecimento em XML e das regras definidas em seu
DTD, o usuário pode criar projetos de relatório utilizando a interface gráfica do iReport,
além de criar os projetos de relatórios. Também é permitida a visualização do relatório e
realização de testes antes de utilizá-lo em uma aplicação. O que diferencia o iReport de
outras ferramentas, que têm como finalidade oferecer uma interface gráfica para a
construção do projeto de relatório para a biblioteca JasperReports, é que o iReport é de
fácil utilização e, além de tudo, é gratuito.
26
2.4.1 Criação de Projetos de Relatórios com iReport
Para criar um projeto de relatório com o iReport é necessário executá-lo através do
ireport.bat, acionar o menu ‘Arquivo’, ‘novo documento’, que um novo projeto será criado,
pronto para ser configurado e inseridos os elementos que compõem um relatório. A Figura
9 apresenta a tela principal do iReport, (menu ‘Arquivo’, ‘Novo Documento’).
Figura 9: Tela principal do iReport - Menu Arquivo
Ao acionar o menu ‘Arquivo’, ‘novo documento’, será exibida uma tela de criação
e configurações iniciais do projeto de relatório, com: nome do relatório, tamanho das
páginas do relatório e outras. A Figura 10 apresenta a tela de criação de um projeto do
relatório com as configurações iniciais.
4
Disponível para download em: http://sourceforge.net/project/showfiles.php?group_id=64348
27
Figura 10: Tela de configuração inicial do projeto do relatório
2.4.2 Origem dos Dados com iReport
Para criar um relatório é necessária a definição de uma origem de dados para o seu
preenchimento. A Figura 11 apresenta a tela onde se pode configurar a origem dos dados
no iReport (menu ‘Fonte de Dados’, ‘Conexão / Fonte de Dados’).
Figura 11: Tela principal, menu fonte de dados
28
Ao acionar o menu ‘Fontes de Dados’, ‘Conexão / Fonte de Dados’, serão abertas
as telas de criação e configuração da origem de dados do projeto de relatório, onde é
possível escolher o tipo de origem e a fonte de dado do relatório. Nesta mesma área é
possibilitado realizar o teste da conexão criada. A Figura 12 apresenta as telas de criação e
configuração de uma fonte de dados no iReport.
Figura 12: Telas de criação e configuração e teste de uma fonte de dados.
2.4.3 Criação de Parâmetros com iReport
Os parâmetros são usados para passagem de valores ao relatório que não estão presentes na
origem dos dados, isso atribui ao relatório uma maior dinamicidade. A Figura 13 apresenta
a tela principal do iReport, (menu ‘Visualizar’, ‘Parâmetros do Relatório’).
29
Figura 13: Tela principal do iReport, menu visualizar
Ao acionar o menu ‘Visualizar’, ‘Parâmetros do Relatório’, serão exibidas as telas
de criação de parâmetros. Cada parâmetro possui um nome e um tipo de dados que ele
suporta, assim como um valor opcional de inicialização. A Figura 14 apresenta as telas de
criação de parâmetros com iReport.
Figura 14: Telas de criação e configuração de parâmetros
30
2.4.4 Criação de Campos com iReport
Somente através da definição dos campos é que se pode relacionar os dados de uma fonte
para o layout do relatório. Para um campo receber os valores de uma coluna de uma tabela,
ele deve ter o mesmo nome e o mesmo tipo de dados da coluna. A Figura 15 apresenta a
tela principal do iReport, (menu ‘Visualizar’, ‘Campos do Relatório’).
Figura 15: Tela principal, menu ‘Visualizar’, ‘Campos do Relatório’
Ao acionar o menu ‘Visualizar’, ‘Campos do Relatório’, serão apresentadas as telas
de criação e configuração de campo dentro do projeto, onde cada campo terá um nome e
um tipo de dados que ele suporta e a seção em que ele está localizado. A Figura 16
apresenta as telas de criação e configuração dos campos com iReport.
31
Figura 16: Telas de criação e configuração de campo do projeto.
2.4.5 Criação de Variáveis com iReport
As variáveis são usadas para simplificar o projeto de relatório, possibilitando a efetuação
de cálculos em um campo, onde o resultado desse cálculo é armazenado na mesma
variável, com o auxilio de uma expressão. A Figura 17 tela principal do iReport, (menu
‘Visualizar’, ‘Variáveis do Relatório’).
Figura 17: Tela principal, menu ‘Visualizar’, ‘Variáveis do Relatório’
32
Ao acionar o menu ‘Visualizar’, ‘Variáveis do Relatório’, serão apresentadas as
telas de criação e configuração das variáveis no iReport, onde será definido um nome, um
tipo de dados e, uma expressão para a variável criada. A Figura 18 apresenta as telas de
criação e configuração de uma variável com iReport.
Figura 18: Telas de criação e configuração de variável
2.4.6 Criando Expressões com iReport
As expressões podem ser criadas em um campo, em um parâmetro, em uma variável ou em
campos estáticos do relatório. A Figura 19 apresenta a criação de uma expressão dentro de
uma variável no iReport.
33
Figura 19: Tela de criação e configuração de uma variável.
Uma expressão é criada dentro de uma variável através do campo = ‘variable
expression’ do formulário de criação da variável.
2.4.7 Seções com iReport
Um relatório é composto por páginas, uma página é dividida em seções, ou seja, uma seção
é parte de uma página e possui altura e largura especificada e pode conter elementos do
relatório como: linhas, retângulos, imagens ou campos do texto, variáveis, parâmetros e
outros. Uma página de relatório pode conter as seguintes seções: backgroun, title,
pageHeader, columnHeader, detail, groupFooter, columnFoter, pageFooter, summary. A
Figura 20 apresenta uma página do relatório dividida em seções no iReport.
34
Figura 20: Tela principal, página do projeto dividas em seções.
2.4.8 Testando e Visualizando o Projeto de Relatório com iReport
Após ter criado o projeto do relatório com iReport, é possível testar e visualizar o relatório
antes de usá-lo em uma aplicação. Para testar e visualizar o relatório gerado, é preciso
compilar e executar o projeto do relatório, onde é possível visualizar o relatório preenchido
com os dados e também obter o arquivo com extensão ‘.jasper’ que será salvo em disco. A
Figura 21 apresenta a tela principal do iReport, (menu ‘Criar (build))’, ‘(Executar relatório
(usar uma conexão ativa)’).
35
Figura 21: Tela principal
Ao acionar o menu ‘Criar (build)’, ‘Executa relatório (usando uma conexão ativa)’,
o projeto será compilado, executado e visualizado no formato definido. A Figura 22
apresenta a visualização do relatório na interface gráfica JasperViewer da biblioteca
JasperReports, com iReport.
Figura 22: Visualização do relatório na interface JasperViewer
36
2.4.9 Código Gerado com IREPORT
Quando o projeto do relatório é salvo no disco é gerado um arquivo com extensão ‘.jrxml’,
que corresponde ao projeto do relatório, ou seja, o arquivo XML que obedece as regras e às
restrições do (JasperReports.dtd). O projeto pode ser também compilado, a fim de gerar o
arquivo com extensão ‘.jasper’, que será salvo no disco e estará proto para receber
parâmetros e dados na operação de preenchimento do relatório.
37
3 MATERIAIS E MÉTODOS
Para o desenvolvimento desse trabalho foram utilizados diversos recursos bibliográficos,
além de hardware e software, que aliados às orientações permitiram a finalização do
mesmo.
3.1 Local e Período
Este trabalho foi desenvolvido durante o segundo semestre de 2005, como parte da
disciplina: “Estágio Supervisionado em Sistema de Informação”. Os locais utilizados para
sua elaboração foram os laboratórios de informática do curso de Sistemas de Informação,
sendo que os mais utilizados foram os Laboratórios de Informática (Labin I) e (Labin III)
do Centro Universitário Luterano de Palmas.
3.2 Materiais
Os recursos utilizados para o desenvolvimento do trabalho foram disponibilizados pelo
próprio curso, Sistemas de Informação do CEULP/ULBRA em seus laboratórios, tais
como hardware e software licenciados. As demais ferramentas free foram adquiridas via
Internet.
3.2.1 Fontes Bibliográficas
Publicações Científicas;
Artigos;
Site do JASPERREPORTS (JASPERREPORTS, 2005);
Site do IREPORT (IREPORT, 2005);
Sites diversos.
38
3.2.2 Hardware
Pentium III, 750 Mhz e 128 Mb de RAM (Disponível no laboratório);
Pentium IV, 2.4 Ghz e 256 Mb de RAM (Disponível no laboratório);
3.2.3 Software
Microsoft Windows 2000 Professional;
Microsoft Office 2000 Professional;
Internet Explorer 6.0;
Acrobat Reader 7.0;
IREPORT 0.5.0;
JASPERREPORTS 0.6.0;
JCreatorV3 LE
3.2.4 Instalação e Configuração das Ferramentas
Esta seção visa auxiliar os desenvolvedores Java que queiram utilizar a biblioteca
JasperReports e a ferramenta iReport para a geração de relatório em suas aplicações. Para
tanto, as instruções de instalação e configurações das ferramentas: J2SE 1.5.0, iReport
0.5.0 e JasperReports 0.6.7 são descritas, passa a passo, com ilustrações.
3.2.4.1 Instalação e Configuração do J2SE 1.5.0
Para programar em Java é preciso fazer o download do J2SE 1.5.0 (Java 2 Platform
Standard Edition 1.5.0)5, ou outras versões. O J2SE corresponde à plataforma de
desenvolvimento Java e vem com dois ambientes:
5
Disponível para download em: http://java.sun.com/j2se/1.5.0/download.jsp.
39
J2SDK 1.5.0: é o kit de desenvolvimento Java que contém as ferramentas necessárias
para programar na linguagem Java, contendo: compilador (javac), interpretador (java),
documentação (javadoc), bibliotecas de classes Java e outras ferramentas.
J2RE 1.5.0: possui ferramentas para tornar possível a execução de programas Java em
um computador.
Para configurar o J2SE 1.5.0 em um sistema operacional é necessário criar
variáveis de ambiente: JAVA_HOME, CLASSPATH, PATH. Essas variáveis são
necessárias para a utilização de todos os recursos do J2SE 1.5.0, como: javac (compilador
Java), javadoc (gerador de documentação das classes Java), java (interpretador dos
batycody Java) e vários outros. Para criar variável de ambiente no sistema operacional
Windows 2000 é necessário seguir os seguintes passos: Meu computador, Propriedades,
Avançado, Variáveis de ambiente. A Figura 23 apresenta a tela Propriedades do Sistema
Operacional Windows 2000.
Figura 23: Tele de propriedades do sistema Windows 2000.
40
Ao ser acionando o botão ‘variáveis de ambiente’ serão apresentadas as telas de
criação e configuração das variáveis de ambiente no Windows 2000. A Figura 24 apresenta
a tela de criação e configuração destas variáveis.
Figura 24: Tele de criação e configuração das variáveis de ambiente.
Para criar variável de ambiente do usuário, é preciso acionar o botão ‘Nova’, que
será apresentada a tela de criação das variáveis do usuário, onde são atribuídos um nome e
um valor para a variável.
A
variável
JAVA_HOME
deve
conter
os seguintes
valores: nome
=
“JAVA_HOME” e valor = “C:\j2sdk 1.5.0”. A Figura 25 ilustra a criação da variável de
ambiente do usuário JAVA_HOME no Windows 2000.
41
Figura 25: Tela de criação de uma variável de ambiente do usuário.
A variável de ambiente do usuário CLASSPATH deve conter os seguintes valores:
nome = “CLASSPATH” e valor = “.:JAVA_HOME”. A Figura 26 ilustra a criação da
variável de ambiente do usuário CLASSPATH e seus respectivos valores.
42
Figura 26: Tela de criação da variável de ambiente do usuário
O próximo passo é definir a variável de ambiente do usuário PATH, que deve
conter os seguintes valores: nome = “PATH” e valor = “C:\j2sdk1.5.0\bin”. A Figura 27
ilustra a criação da variável de ambiente PATH e seus respectivos valores.
43
Figura 27: Tela de criação da variável de ambiente do usuário
3.2.4.2 Instalação e Configuração do IReport
O iReport é uma ferramenta que possibilita a criação do projeto de relatório para a
biblioteca JasperReports, através de uma interface gráfica. Sua instalação consiste na
descompactação dos arquivos adquiridos na página web do iReport em uma determinada
pasta. Necessita que o J2SE 1.5.0 esteja instalado no computador onde ele será executado.
Para configurar o iReport é necessário executá-lo através do ‘iReport.bat’ no
Windows e ‘iReport.sh’ no LINUX, acionar o menu ‘tool’, ‘opções’, onde será exibida a
tela de configuração. Na aba External Programs deve-se configurar da mesma forma que
está configurado na figura abaixo. A Figura 28 ilustra a configuração do iReport.
44
Figura 28: Tela de configuração.
3.2.4.3 Instalação e Configuração do JasperReports
O JasperReports é uma biblioteca de classe Java que possibilita a criação de relatório em
aplicações Java. Está presente no diretório lib do iReport e também está disponível na
página web do JasperReports. Para fazer sua configuração é necessário adicioná-la ao
CLASSPATH do editor de classes Java utilizado, e também as seguintes bibliotecas que
estão presentes no diretório lib do iReport: ‘JasperReportss-1.0.1.jar’, ‘commonsbeanutils-1.5.jar’, ‘commons-collections-2.1.jar’, ‘commons-digester-1.7.jar’, ‘commonslogging-1.0.2.jar’, ‘commons-logging-api-1.0.2.jar’, ‘iReport.jar’. Esta configuração é
necessária para que o editor possa importa as classes da biblioteca e utilizá-la em outras
aplicações. A Figura 29 ilustra a adição das bibliotecas ao CLASSPATH do editor de classe
Java (JCreator LE V3.50).
45
Figura 29: Tela de adição de bibliotecas ao CLASSPATH
3.3 Metodologia
Para o desenvolvimento deste trabalho foi necessário, inicialmente, a realização de um
estudo sobre os conceitos de relatório, biblioteca JasperReports e a ferramenta iReport no
sentido de recolher informações referentes ao domínio do trabalho desenvolvido, de
maneira que permitisse oferecer uma sustentação teórica necessária para a sua conclusão.
Assim, foram abordados conceitos e técnicas alusivas ao escopo do trabalho, para que
fosse possível o desenvolvimento de um relatório para a aplicação Java, como forma de
concretização de parte do que foi explanado na Revisão de Literatura.
46
Após o levantamento teórico, aplicou-se na prática o desenvolvimento do relatório
para a aplicação Java, com o objetivo de demonstrar as facilidades de uso das ferramentas
estudadas. A Tabela 1 apresenta o cronograma das atividades desenvolvidas no trabalho.
Tabela 1: Cronograma das atividades
Data inicial
Tarefa
23/08
02/09
16/09
17/10
07/11
08/11
17/11
19/11
23/11
26/11
Revisão de Literatura: JasperReports.
Revisão de Literatura: iReport.
Revisão de Literatura: Geração de Relatório.
Revisão de Literatura: Geração de Relatório em Aplicações Java.
Materiais e Métodos: Local Período.
Materiais e Métodos: Materiais.
Resultados e Discussão: Visão Geral da Ferramenta.
Resultados e Discussão: Gerando Relatório.
Considerações Finais.
Revisão final do trabalho.
47
4 RESULTADOS E DISCUSSÃO
Esta seção tem o objetivo de apresentar o desenvolvimento de relatório para a uma
aplicação Java que necessite de relatórios e que mostre, na prática, a utilização das
ferramentas JasperReports e iReport.
4.1 Visão Geral da Aplicação
O SENAR – TO é uma empresa privada sem fins lucrativos que ministra treinamentos,
palestras e outros eventos, exclusivamente, para o homem do campo, visando sua
qualificação. Assim, identificou-se a necessidade do armazenamento das informações
relativas a estes treinamentos, palestras e eventos, através de um sistema que auxiliasse
tanto no armazenamento, como no gerenciamento destas atividades. Este trabalho utiliza
este estudo de caso, ou seja, o desenvolvimento de um Sistema de Gerenciamento de
Eventos – SGE, para demonstrar a utilização do JasperReports e do iReport na geração de
um relatórios envolvido.
4.2 Gerando Relatório
Esta seção visa demonstrar o desenvolvimento do relatório para o sistema descrito na seção
anterior e sua utilização na aplicação, utilizando a biblioteca JasperReports e a ferramenta
iReport. Para tanto, as demonstrações são descritas passo a passo com ilustrações.
Para gerar um relatório utilizando a biblioteca JasperReports é necessário criar um
projeto de relatório. Esse projeto é criado através do iReport. Para uma melhor
compreensão de como é desenvolvido o projeto do relatório é necessária a demonstração
da criação, assim como de sua execução, tanto no iReport, como na aplicação. O relatório a
48
ser desenvolvido deverá atender ao seguinte requisito: listar todas as despesas de um
determinado evento, calculando o valor total das despesas geradas por este evento.
Assim, o primeiro passo para se construir este relatório é executar o iReport através
do ‘ireport.bat’, acione o menu ‘Arquivo’, ‘Novo documento’, onde será exibida a tela de
criação de um projeto de relatório contendo suas configurações iniciais. A Figura 30
apresenta a tela de criação de um projeto de relatório com as suas configurações iniciais.
Figura 30: Tela de criação e configuração iniciais do projeto
O próximo passo é definir a base de dados que será usada para obtenção dos dados
para o preenchimento do relatório. No caso, foi criado um driver ODBC chamado
“eventos”. Feito isso, o próximo passo é configurar a fonte de dados no projeto do
relatório através do iReport. A Figura 31 apresenta a tela de configuração da fonte de
dados para o projeto do relatório.
49
Figura 31 : Tela de criação e configuração da fonte de dados
Esta tela permite a criação e a configuração de uma fonte de dados para o projeto, a
qual foi preenchida com os seguintes valores: Type of connection/datasource = “database
JDBC
connection”,
name
=
“despesas”,
JDBC
Drive
=
“sun.jdbc.odbc.JdbcOdbcDriver”, JDBC URL = “jdbc:odbc:eventos”. Após esta
configuração, acione o botão “Save” e, em seguida, o botão “Teste” para verificar se a
conexão está funcionando corretamente.
Após ter criado a fonte de dados deve-se ativá-la, para que essa fonte possa ser
usada no projeto em desenvolvimento. Para ativar uma fonte de dados é necessário acionar
o menu ‘criar (build)’, ‘Definir conexão ativa’ na tela principal do iReport. A Figura 32
apresenta a tela que proporciona a ativação de uma fonte de dados para o projeto.
50
Figura 32: Tela de ativação da fonte de dados do projeto
Para a ativar a fonte de dados é necessário selecioná-la e acionar o botão “ok“.
Assim, a fonte de dados estará ativada.
O próximo passo refere-se à criação do parâmetro necessário para o projeto. Esse
parâmetro será usado para a passagem do título do relatório através da aplicação, que é
responsável por gerar o relatório. Para criar um parâmetro deve-se acionar o menu
‘Visualizar’, ‘Parâmetro do Relatório’ na tela principal do iReport. A Figura 33 apresenta a
tela de criação e configuração de parâmetro para o projeto do relatório.
51
Figura 33: Tela de criação e configuração de parâmetro para o projeto do relatório
Na primeira tela estão os parâmetros internos. Para criar um novo parâmetro é
necessário acionar o botão ‘Novo’. Para o exemplo analisado, os valores do formulário
devem estar preenchidos da seguinte forma: Parameter name = “Titulo”, Parameter class
type = “Java.lang.String” e Default value expression = “Relatório de Despesa de
Evento”, tal como é apresentado na Figura 34. Esse parâmetro é colocado na seção title da
página, através do botão “F” da barra de ferramenta do iReport. A Figura 34 apresenta a
barra de ferramentas do iReport, botão “F”.
Figura 34: Barra de ferramentas do iReport
Para inserir um parâmetro dentro de uma seção da página, deve-se acionar o botão
“F” da barra de ferramenta do iReport, clicar com o mouse e arrastar para dentro da seção
title da página. Ao colocá-lo dentro da seção é necessário fazer a seguinte modificação:
52
$F{Titulo} para $P{Titulo}. A Figura 35 demonstra a inserção de um parâmetro dentro da
seção title da página.
Figura 35: Inserção de um parâmetro dentro da seção title
Os dados recuperados de uma fonte de dados através de uma instrução SQL são
agrupados em um resultset. A única forma de imprimir esses dados no relatório é através
de campos dentro da seção detail da página do relatório, devendo obedecer a seguinte
restrição: os campos devem ter o mesmo nome e o mesmo tipo de dados das colunas do
objeto resultset. Para criar um campo e inseri-lo dentro da seção detail é necessário acionar
o botão “F” da barra de ferramenta do iReport, clicar sobre a seção detail e arrastar. Neste
caso são criados 5 campos: “Evento”, “Fornecedor”, “Data”, “Valor” e “Descrição”,
cada um deles referência uma coluna do objeto resultSet. A Figura 36 apresenta inserção
de campos dentro da seção detail da página do relatório.
53
Figura 36: Inserção dos campos dentro da seção detail da pagina do relatório
Para configurar um campo é necessário dar um duplo click sobre ele que será
apresentada à tela de configuração, onde é possível configurar sua fonte e a coluna do
objeto resultset que ele irá corresponder. A Figura 37 apresenta a tela de configuração de
um campo.
54
Figura 37: Tela de configuração de um campo dentro da seção detail da página do
relatório
Após a criação dos campos que receberão os dados contidos no resultset, é
necessário criar uma variável para armazenar o cálculo efetuado sobre o campo “Valor”.
Para criar uma variável aciona-se o menu ‘Visualizar’, ‘Variável do relatório’, onde serão
apresentadas as telas de criação e configuração da variável. A Figura 38 apresenta a tela
de criação e configuração de uma variável.
55
Figura 38: Tela de criação de variável
O formulário apresentado acima (Figura 38) deve estar preenchido da seguinte
forma: variable name = “valor_total”, variable class type = “Java.lang.Double”,
Calculation type = “sun” (que indica o tipo de cálculo que a variável realiza, ou seja, uma
soma), reset type = “Report” (indica o nível que será realizado o cálculo, no caso, o
cálculo será realizado em nível de relatório), Variable expression = “$F{Valor}” (indica o
campo que será calculado).
Depois de criada a variável, é necessário fazer a sua inserção dentro da seção
totalFooter da página. Para inserir uma variável em uma seção, aciona-se o botão “F” da
barra de ferramentas do iReport, clicar em cima da seção e arrastar. Após passar por estes
processos
deve-se
fazer
a
seguinte
modificação:
“$F{valor_total}”
para
“$V{valor_total}”. A Figura 39 ilustra a inserção de uma variável na seção totalFooter da
página.
56
Figura 39: Inserção de uma variável na seção totalFooter
O iReport proporciona testar o relatório antes de utilizá-lo na aplicação. Para testar
o projeto de um relatório é necessário acionar o menu ‘Criar (build)’, ’Executar relatório
(usar conexão ativa)’, que o projeto será executado e compilado dando origem a um
arquivo com a extensão “.jasper” que estará apto a receber os dados. A Figura 40 apresenta
a execução do relatório.
57
Figura 40: Visualização do relatório através da interface gráfica JasperVierwer
Depois de construído, testado, compilado e gerado o arquivo com extensão
‘.jasper’, o projeto do relatório está pronto para ser utilizado na aplicação. A Figura 41
apresenta o código para um exemplo de execução do relatório dentro de uma classe Java.
58
1.
2.
3.
4.
5.
6.
7.
8.
9.
import
import
import
import
import
import
import
import
import
net.sf.jasperreports.engine.*;
net.sf.jasperreports.view.*;
java.sql.*;
java.util.*;
java.awt.*;
javax.swing.*;
SGE.Conexao.*;
SGE.Despesa.*;
SGE.Evento.*;
public class relatorio
{
10. private Connection objBD;
11. private Statement objSQL;
12. conexao obj = new conexao();
13. adicionar add = new adicionar();
14. private static final String projeto= "eventos.jasper";
15. public relatorio(){}
16. public void fechar()
{
17. try
{
18. objSQL.close();
19. obj.fecharConexao();
}catch(SQLException e)
{
System.out.println("Erro ao fechar a conexão: " + e);
}
20. }
//consutar despesa de um determinado evento
21. public ResultSet consultarDespesaEvento(String evento)
{
22. obj.abrirConexao("eventos", "", "");
23. String sql = "SELECT * FROM despesa WHERE evento =
'"+evento+"'";
24. return add.pesquisarDados(sql, obj);
25. }// fim do metodo buscar fornecedor
59
26. public void geraRelatorio(String evento, String Titulo) throws
Exception
{
27. String titulo = "Evento " + Titulo;
28. Map parametros = new HashMap();
29. parametros.put("Titulo", titulo);
//
30. JRResultSetDataSource jrRS = new
JRResultSetDataSource(consultarDespesaEvento(evento));
31. JasperPrint impressao =
JasperFillManager.fillReport(projeto,parametros,jrRS );
32. JasperViewer
viewer = new JasperViewer(impressao, false);
33. viewer.setTitle("Sistema de Gerenciamento de Eventos");
34. viewer.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
35. viewer.show();
36. fechar();
}//fim do método gerar relatório
}//fim da classe relatório
Figura 41: Executando o relatório na aplicação
Nas linhas de 1 a 9 (da Figura 41) acontece a importação dos pacotes necessários
para a geração de relatório na aplicação, inclusive alguns pacotes
da
biblioteca
JasperReports (linha 1 e 2) e nas linhas 10 e 11 é declarada a variável utilizada para fazer a
conexão com o banco de dados. Já na linha 12 é instanciada a classe responsável por fazer
a conexão com o banco de dados e na linha 13 é instanciada a classe responsável por
executar a operação de consulta no banco de dados. A linha 14 declara-se a variável que
faz referência ao projeto do relatório compilado, que está salvo em disco. Na linha 15 é
definido o método construtor da classe relatório. Já nas linhas 16 a 20 são definidos os
métodos responsáveis por fechar a conexão com o banco de dados e nas linhas 21 a 25 o
método responsável por fazer a consulta ao banco de dados, retornando um resultset. Na
linha 26 é apresentado o método responsável por gerar o relatório, recebendo como
60
parâmetro o nome do evento e o título do relatório. A linha 27 é declara-se a variável
‘titulo’, que será passada ao relatório na operação de preenchimento. Já na linha 28 é
instanciada a classe da biblioteca JasperReports que possibilita a criação do parâmetro. A
linha 29 onde é criado o parâmetro que recebe o conteúdo da variável ‘titulo’. Na linha 30
é realizado a instanciação da classe da biblioteca JasperReports que cria o resultset para o
preenchimento do relatório. Essa classe recebe como parâmetro um objeto resultset que, no
caso, é o retorno da função ‘consultarDespesaEvento(evento)’. Já na linha 31 é definida a
operação de preenchimento do relatório com os dados do objeto resultset convertido, com
os parâmetros e o projeto compilado. Nas linhas 32 a 35 é realizada a visualização do
relatório na interface gráfica da biblioteca JasperReports, o ‘JasperViewer’. Por fim, na
linha 36 é realizado o encerramento da conexão com o banco de dado, através do método
‘fechar()’ da classe relatório.
61
5 CONSIDERAÇÕES FINAIS
As ferramentas JasperReports e iReport mostram ser uma boa solução para o
desenvolvimento de relatórios em aplicações Java, porque oferecem um pacote de recurso
variado de fácil utilização dentro do contexto da linguagem Java, proporciona a geração de
relatórios tanto para aplicações desktop como para aplicações web, e ainda com a vantagem
de serem gratuitas.
É recomendada a utilização dessas ferramentas em relatórios pequenos e médios,
pois existem algumas limitações de recursos que só as ferramentas comerciais como
Cristal Reports oferece. Uma limitação encontrada foi a falta de documentação disponível
para o estudo dos recursos oferecidos pelas ferramentas JasperReports e iReport. Existem
tutoriais em suas páginas web, mas são todos em inglês e só podem ser adquiridas
mediante pagamento, são ferramentas recentes no mercado e pouco estudadas.
Este trabalho descreveu o desenvolvimento de relatórios para aplicações
desenvolvidas em Java, utilizando a biblioteca de classe Java JasperReports com o auxílio
da ferramenta iReport. É importe ressaltar que existem outras ferramentas que têm a
mesma finalidade. Porém, as ferramentas JasperReports e iReport foram escolhidas por
serem fáceis de utilizar dentro do ambiente de programação Java, além de serem gratuitas.
Como sugestão para trabalhos futuros recomenda-se uma comparação entre estas
ferramentas com outras existentes, gratuitas ou pagas, abordando as potencialidades de
cada uma.
62
6 REFERÊNCIAS BIBLIOGRÁFICAS
(IREPORT, 2005)
IREPORT.
Setembro
de
2005.
Disponível
em:
<
http://ireport.sourceforge.net/index.php?p_module=page&pageid=11
>. Acesso em: 08/09/2005.
(JASPERREPORTS, 2005) JASPERREPORTS. Setembro de 2005. Disponível em: <
http://jasperreports.sourceforge.net/tutorial/index.html >. Acesso
em: 05/09/2005.
(PAIXÃO, 2005)
PAIXÃO,
Carlos
Feliz.
Geração
de
Relatório
com
JasperReports e iReport. Belém PA: GUJ (Grupo de Usuários
Java),
2005.
Disponível
em:
<http://www.guj.com.br/content/articles/reports/JasperReportsIR
eport.pdf>. Acesso em 02/10/2005.
(GLÁUCIA, 2005)
(VILLAS, 1988)
GABRIEL, Gláucia. O Processo de Desenvolvimento Baseado
em Componentes: O impulso das novas tecnologias. Portal
Java,
2005.
Disponível
em:<
http://www.portaljava.com/home/modules.php?name=Content&p
a=showpage&pid=97>. Acessado em 17/11/2005.
VILLAS, Marcos Viana.; VILLASBOAS Luiz Felipe P.
Programação Técnicas e Linguagens. Rio de Janeiro-RJ.
Campos. 1988.
63
ANEXOS
64
●
Código do Projeto do Relatório
<?xml version="1.0" encoding="UTF-8" ?>
<!-- Created with iReport - A designer for JasperReports -->
<!DOCTYPE jasperReport PUBLIC "//JasperReports//DTD Report Design//EN"
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">
<jasperReport
name="eventos"
columnCount="1"
printOrder="Vertical"
orientation="Portrait"
pageWidth="595"
pageHeight="842"
columnWidth="535"
columnSpacing="0"
leftMargin="30"
rightMargin="30"
topMargin="20"
bottomMargin="20"
whenNoDataType="NoPages"
isTitleNewPage="false"
isSummaryNewPage="false">
<property name="ireport.scriptlethandling" value="0" />
<import value="java.util.*" />
<import value="net.sf.jasperreports.engine.*" />
<import value="net.sf.jasperreports.engine.data.*" />
<parameter name="Titulo" isForPrompting="false"
class="java.lang.String">
<defaultValueExpression ><![CDATA["Relatorio de Despesa de
Eventos"]]></defaultValueExpression>
</parameter>
<parameter name="Categoria" isForPrompting="false"
class="java.lang.String">
<defaultValueExpression
><![CDATA["Bebidas"]]></defaultValueExpression>
</parameter>
<queryString><![CDATA[SELECT * FROM despesa]]></queryString>
<field name="Descricao" class="java.lang.String"/>
<field name="Fornecedor" class="java.lang.String"/>
<field name="Valor" class="java.lang.Double"/>
<field name="Data" class="java.lang.String"/>
<field name="Evento" class="java.lang.String"/>
<variable name="total_geral" class="java.lang.Double"
resetType="Report" calculation="Sum">
<variableExpression><![CDATA[$F{Valor}]]></variableExpression>
<initialValueExpression><![CDATA[new
java.lang.Double(0)]]></initialValueExpression>
</variable>
<group name="total" isStartNewColumn="false"
isStartNewPage="false" isResetPageNumber="false"
isReprintHeaderOnEachPage="false" minHeightToStartNewPage="0" >
<groupExpression><![CDATA[null]]></groupExpression>
<groupHeader>
<band height="0" isSplitAllowed="true" >
</band>
</groupHeader>
65
<groupFooter>
<band height="25" isSplitAllowed="true" >
<staticText>
<reportElement
mode="Opaque"
x="302"
y="4"
width="98"
height="20"
forecolor="#000000"
backcolor="#FFFFFF"
key="staticText"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Right"
verticalAlignment="Middle" rotation="None" lineSpacing="Single">
<font fontName="SansSerif"
pdfFontName="Helvetica" size="12" isBold="true" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="CP1252"
isStrikeThrough="false" />
</textElement>
<text><![CDATA[Total Geral:]]></text>
</staticText>
<textField isStretchWithOverflow="false"
pattern="#,##0.00" isBlankWhenNull="false" evaluationTime="Now"
hyperlinkType="None" hyperlinkTarget="Self" >
<reportElement
mode="Opaque"
x="406"
y="7"
width="113"
height="16"
forecolor="#000000"
backcolor="#FFFFFF"
key="textField"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Right"
verticalAlignment="Middle" rotation="None" lineSpacing="Single">
<font fontName="SansSerif"
pdfFontName="Helvetica" size="12" isBold="true" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="CP1252"
isStrikeThrough="false" />
</textElement>
66
<textFieldExpression
class="java.lang.Double"><![CDATA[$V{total_geral}]]></textFieldExpression
>
</textField>
<line direction="TopDown">
<reportElement
mode="Opaque"
x="6"
y="3"
width="520"
height="0"
forecolor="#000000"
backcolor="#FFFFFF"
key="line"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<graphicElement stretchType="NoStretch"
pen="Thin" fill="Solid" />
</line>
</band>
</groupFooter>
</group>
<background>
<band height="0" isSplitAllowed="true" >
</band>
</background>
<title>
<band height="50" isSplitAllowed="true" >
<rectangle radius="5" >
<reportElement
mode="Opaque"
x="36"
y="3"
width="465"
height="41"
forecolor="#000000"
backcolor="#FFFFFF"
key="rectangle-1"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<graphicElement stretchType="NoStretch"
pen="Thin" fill="Solid" />
</rectangle>
<textField isStretchWithOverflow="false"
pattern="" isBlankWhenNull="false" evaluationTime="Now"
hyperlinkType="None" hyperlinkTarget="Self" >
<reportElement
mode="Opaque"
x="166"
y="10"
width="208"
height="28"
67
forecolor="#003333"
backcolor="#FFFFFF"
key="textField-1"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Center"
verticalAlignment="Middle" rotation="None" lineSpacing="Single">
<font fontName="Arial"
pdfFontName="Helvetica" size="18" isBold="true" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="Cp1252"
isStrikeThrough="false" />
</textElement>
<textFieldExpression
class="java.lang.String"><![CDATA[$P{Titulo}]]></textFieldExpression>
</textField>
</band>
</title>
<pageHeader>
<band height="0" isSplitAllowed="true" >
</band>
</pageHeader>
<columnHeader>
<band height="0" isSplitAllowed="true" >
</band>
</columnHeader>
<detail>
<band height="137" isSplitAllowed="true" >
<textField isStretchWithOverflow="false"
pattern="" isBlankWhenNull="false" evaluationTime="Now"
hyperlinkType="None" hyperlinkTarget="Self" >
<reportElement
mode="Opaque"
x="5"
y="24"
width="161"
height="31"
forecolor="#000000"
backcolor="#FFFFFF"
key="textField"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Left"
verticalAlignment="Middle" rotation="None" lineSpacing="Single">
68
<font fontName="Times New Roman"
pdfFontName="Helvetica" size="12" isBold="false" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="CP1252"
isStrikeThrough="false" />
</textElement>
<textFieldExpression
class="java.lang.String"><![CDATA[$F{Evento}]]></textFieldExpression>
</textField>
<textField isStretchWithOverflow="false"
pattern="#,##0.00" isBlankWhenNull="false" evaluationTime="Now"
hyperlinkType="None" hyperlinkTarget="Self" >
<reportElement
mode="Opaque"
x="471"
y="24"
width="52"
height="22"
forecolor="#000000"
backcolor="#FFFFFF"
key="textField"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Right"
verticalAlignment="Middle" rotation="None" lineSpacing="Single">
<font fontName="Times New Roman"
pdfFontName="Helvetica" size="12" isBold="false" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="CP1252"
isStrikeThrough="false" />
</textElement>
<textFieldExpression
class="java.lang.Double"><![CDATA[$F{Valor}]]></textFieldExpression>
</textField>
<textField isStretchWithOverflow="false"
pattern="" isBlankWhenNull="false" evaluationTime="Now"
hyperlinkType="None" hyperlinkTarget="Self" >
<reportElement
mode="Opaque"
x="366"
y="24"
width="97"
height="22"
forecolor="#000000"
backcolor="#FFFFFF"
key="textField-2"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
69
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Left"
verticalAlignment="Top" rotation="None" lineSpacing="Single">
<font fontName="Times New Roman"
pdfFontName="Helvetica" size="12" isBold="false" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="Cp1252"
isStrikeThrough="false" />
</textElement>
<textFieldExpression
class="java.lang.String"><![CDATA[$F{Data}]]></textFieldExpression>
</textField>
<textField isStretchWithOverflow="false"
pattern="" isBlankWhenNull="false" evaluationTime="Now"
hyperlinkType="None" hyperlinkTarget="Self" >
<reportElement
mode="Opaque"
x="168"
y="24"
width="192"
height="32"
forecolor="#000000"
backcolor="#FFFFFF"
key="textField-3"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Left"
verticalAlignment="Top" rotation="None" lineSpacing="Single">
<font fontName="Times New Roman"
pdfFontName="Helvetica" size="12" isBold="false" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="Cp1252"
isStrikeThrough="false" />
</textElement>
<textFieldExpression
class="java.lang.String"><![CDATA[$F{Fornecedor}]]></textFieldExpression>
</textField>
<textField isStretchWithOverflow="false"
pattern="" isBlankWhenNull="false" evaluationTime="Now"
hyperlinkType="None" hyperlinkTarget="Self" >
<reportElement
mode="Opaque"
x="10"
y="59"
width="511"
height="55"
forecolor="#000000"
backcolor="#FFFFFF"
key="textField-4"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
70
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Left"
verticalAlignment="Top" rotation="None" lineSpacing="Single">
<font fontName="Times New Roman"
pdfFontName="Helvetica" size="12" isBold="false" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="Cp1252"
isStrikeThrough="false" />
</textElement>
<textFieldExpression
class="java.lang.String"><![CDATA["Descrição
:\n"+$F{Descricao}]]></textFieldExpression>
</textField>
<staticText>
<reportElement
mode="Opaque"
x="5"
y="4"
width="125"
height="16"
forecolor="#000000"
backcolor="#FFFFFF"
key="staticText-1"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Left"
verticalAlignment="Top" rotation="None" lineSpacing="Single">
<font fontName="Arial"
pdfFontName="Helvetica" size="10" isBold="false" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="Cp1252"
isStrikeThrough="false" />
</textElement>
<text><![CDATA[Evento :]]></text>
</staticText>
<staticText>
<reportElement
mode="Opaque"
x="169"
y="5"
width="125"
height="16"
forecolor="#000000"
backcolor="#FFFFFF"
key="staticText-2"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
71
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Left"
verticalAlignment="Top" rotation="None" lineSpacing="Single">
<font fontName="Arial"
pdfFontName="Helvetica" size="10" isBold="false" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="Cp1252"
isStrikeThrough="false" />
</textElement>
<text><![CDATA[Fornecedor]]></text>
</staticText>
<staticText>
<reportElement
mode="Opaque"
x="366"
y="5"
width="92"
height="13"
forecolor="#000000"
backcolor="#FFFFFF"
key="staticText-3"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Left"
verticalAlignment="Top" rotation="None" lineSpacing="Single">
<font fontName="Arial"
pdfFontName="Helvetica" size="10" isBold="false" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="Cp1252"
isStrikeThrough="false" />
</textElement>
<text><![CDATA[Data :]]></text>
</staticText>
<staticText>
<reportElement
mode="Opaque"
x="478"
y="3"
width="50"
height="16"
forecolor="#000000"
backcolor="#FFFFFF"
key="staticText-4"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
72
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Left"
verticalAlignment="Top" rotation="None" lineSpacing="Single">
<font fontName="Arial"
pdfFontName="Helvetica" size="10" isBold="false" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="Cp1252"
isStrikeThrough="false" />
</textElement>
<text><![CDATA[Valor :]]></text>
</staticText>
<staticText>
<reportElement
mode="Opaque"
x="3"
y="117"
width="527"
height="14"
forecolor="#000000"
backcolor="#FFFFFF"
key="staticText-5"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Left"
verticalAlignment="Top" rotation="None" lineSpacing="Single">
<font fontName="Arial"
pdfFontName="Helvetica" size="10" isBold="false" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="Cp1252"
isStrikeThrough="false" />
</textElement>
<text><![CDATA[----------------------------------------------------------------------------------------------------------------------------------------------------------------------------]]></text>
</staticText>
</band>
</detail>
<columnFooter>
<band height="0" isSplitAllowed="true" >
</band>
</columnFooter>
<pageFooter>
<band height="29" isSplitAllowed="true" >
<rectangle radius="0" >
<reportElement
mode="Opaque"
x="89"
y="6"
width="435"
height="20"
73
forecolor="#FFFFFF"
backcolor="#CCCCCC"
key="rectangle"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<graphicElement stretchType="NoStretch"
pen="Thin" fill="Solid" />
</rectangle>
<textField isStretchWithOverflow="false"
pattern="" isBlankWhenNull="false" evaluationTime="Now"
hyperlinkType="None" hyperlinkTarget="Self" >
<reportElement
mode="Transparent"
x="282"
y="8"
width="192"
height="17"
forecolor="#000000"
backcolor="#FFFFFF"
key="textField"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Right"
verticalAlignment="Middle" rotation="None" lineSpacing="Single">
<font fontName="SansSerif"
pdfFontName="Helvetica" size="12" isBold="false" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="CP1252"
isStrikeThrough="false" />
</textElement>
<textFieldExpression
class="java.lang.String"><![CDATA["Página " + $V{PAGE_NUMBER} + " de
"]]></textFieldExpression>
</textField>
<textField isStretchWithOverflow="false"
pattern="" isBlankWhenNull="false" evaluationTime="Report"
hyperlinkType="None" hyperlinkTarget="Self" >
<reportElement
mode="Transparent"
x="476"
y="8"
width="45"
height="17"
forecolor="#000000"
backcolor="#FFFFFF"
key="textField"
stretchType="NoStretch"
positionType="FixRelativeToTop"
isPrintRepeatedValues="true"
74
isRemoveLineWhenBlank="false"
isPrintInFirstWholeBand="false"
isPrintWhenDetailOverflows="false"/>
<box topBorder="None"
topBorderColor="#000000" leftBorder="None" leftBorderColor="#000000"
rightBorder="None" rightBorderColor="#000000" bottomBorder="None"
bottomBorderColor="#000000"/>
<textElement textAlignment="Left"
verticalAlignment="Top" rotation="None" lineSpacing="Single">
<font fontName="SansSerif"
pdfFontName="Helvetica" size="12" isBold="false" isItalic="false"
isUnderline="false" isPdfEmbedded ="false" pdfEncoding ="CP1252"
isStrikeThrough="false" />
</textElement>
<textFieldExpression
class="java.lang.String"><![CDATA["" +
$V{PAGE_NUMBER}]]></textFieldExpression>
</textField>
</band>
</pageFooter>
<summary>
<band height="0" isSplitAllowed="true" >
</band>
</summary>
</jasperReport>
●
Código da Aplicação Responsável por Fazer a Conexão com o Banco de Dados
/* autor: Silvio Costa Moreira*/
package SGE.Conexao;
import java.sql.*;
public class conexao
{
public Connection conn;
public conexao()
{}
public String abrirConexao(String _driver, String login, String
senha)
{
String retorno = "OK";
String driver = "jdbc:odbc:"+_driver;
String converte = "";
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
}
catch (Exception e1){
//System.out.println("Erro ao abrir a conexão! Erro: "
+ e1);
retorno = converte.valueOf(e1);
}
75
try{
conn = DriverManager.getConnection(driver, login,
senha);
}
catch (Exception e1){
//System.out.println("Erro ao abrir o BD! Erro: " +
e1);
//retorno = e1;
retorno = converte.valueOf(e1);
}
return retorno;
}//fim do metodo abriConexao
public void fecharConexao()
{
try{
conn.close();
}
catch(SQLException e){
}
}//fim do metodo fecharConexao
}//fim da class
●
Código da Aplicação Responsável por Fazer a as Operações (cadastrar, alterar
pesquisar, excluir) no Banco de Dados
/* Silvio Costa Moreira*/
package SGE.Conexao;
import java.sql.*;
import java.util.*;
import java.util.Date;
public class adicionar
{
//variaveis para fazer a conexão com o banco.
private Connection objBD;
private Statement objSQL;
76
//meto construtor vazio
public adicionar()
{
}
//metodo utizado para adicionar dados a base de dados
public void adicionarDados(String instrucao, conexao obj)
{
try
{
objSQL = obj.conn.createStatement();
objSQL.execute(instrucao);
}
catch(SQLException e)
{
System.out.println("Erro ao executar a SQL! Erro: " + e);
}
catch(Exception e)
{
System.out.println("Houve um erro ao tentar consultar os materiais!
Erro: " + e);
}
finally
{
//objSQL.close();
obj.fecharConexao();
}
}//fim do metodo adicionar
// metodo de atualizar dados da base de dados
public void atualizarDados(String instrucao, conexao conet)
{
Statement stmt = null;
try
{
stmt = conet.conn.createStatement();
stmt.execute(instrucao);
stmt.close();
conet.fecharConexao();
}
catch(SQLException e){
System.out.println("Erro ao executar a SQL! Erro: " + e);
77
}
}//fim do metodo atualizar dados
//metodo pesquisar dados da base de dados.
public ResultSet pesquisarDados(String instrucao, conexao obj)
{
ResultSet objRS = null;
try
{
objSQL = obj.conn.createStatement();
objRS = objSQL.executeQuery(instrucao);
//objSQL.close();
//obj.fecharConexao();
}
catch(SQLException e)
{
System.out.println("Erro ao executar a SQL! Erro: metodo " + e);
}
return objRS;
}// fim do metodo buscar fornecedor
// metodo para excluir um registro na tabela
public void ExcluirDados(String instrucao, conexao conet)
{
Statement stmt = null;
try
{
stmt = conet.conn.createStatement();
//String strSQL = " DELETE FROM oficios WHERE numero =
'"+_numero+"'";
stmt.execute(instrucao);
stmt.close();
conet.fecharConexao();
}
catch(SQLException e){
System.out.println("Erro ao executar a SQL! Erro: " + e);
}
78
}//fim do metodo alterarProduto
}
●
Código da Aplicação Responsável por Gerar os Relatórios para a Aplicação
/*Silvio Costa Moreira*/
package SGE.Relatorio;
import net.sf.jasperreports.engine.*;
import net.sf.jasperreports.view.*;
import java.sql.*;
import java.util.*;
import java.awt.*;
import javax.swing.*;
import SGE.Conexao.*;
import SGE.Despesa.*;
import SGE.Evento.*;
public class relatorio {
private Connection objBD;
private Statement objSQL;
conexao obj = new conexao();
adicionar add = new adicionar();
private static final String layout = "eventos.jrxml";
private static final String layoutJarper = "eventos.jasper";
public relatorio()
{
}
//consultar todos os documentos
//consulta do relatorio
public ResultSet consultarTodos()
{
79
obj.abrirConexao("eventos", "", "");
String sql = "SELECT * FROM despesa";
return add.pesquisarDados(sql, obj);
}// fim do metodo buscar fornecedor
public ResultSet consultarEvento(String evento)
{
obj.abrirConexao("eventos", "", "");
String sql = "SELECT * FROM despesa WHERE evento = '"+evento+"'";
return add.pesquisarDados(sql, obj);
}// fim do metodo buscar fornecedor
public void fechar()
{
try
{
objSQL.close();
obj.fecharConexao();
}
catch(SQLException e)
{
System.out.println("Erro ao fechar a conexão: " + e);
}
}
public void geraRelatorio(String evento, String nomeEvento) throws Exception {
//JasperReport relatorio = JasperCompileManager.compileReport(layout);
String titulo = "Evento " + nomeEvento;
//
// executa o relatório com o resultado da consulta
Map parametros = new HashMap();
parametros.put("Titulo", titulo);
parametros.put("Categoria", categoria);
JRResultSetDataSource jrRS = new
JRResultSetDataSource(consultarEvento(evento));
80
JasperPrint impressao =
JasperFillManager.fillReport(/*relatorio*/layoutJarper,parametros,jrRS );
//System.out.println(jrRS);
//exibe o resultado da impressão na previsualização padrão Swing
JasperViewer viewer = new JasperViewer(impressao, false);
viewer.setTitle("Sistema de Gerenciamento de Eventos");
viewer.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
viewer.show();
fechar();
}//fim gerar relatorio*/
//gera relatorio de todos os documentos cadastrados
public void geraRelatorioTodos() throws Exception {
//Jdesktop dt = new Jdesktop();
//JasperReport relatorio = JasperCompileManager.compileReport(layout);
String titulo = "Relatorio de Despesas de Eventos";
//
// executa o relatório com o resultado da consulta
Map parametros = new HashMap();
parametros.put("Titulo", titulo);
parametros.put("Categoria", categoria);
JRResultSetDataSource jrRS = new JRResultSetDataSource(consultarTodos());
JasperPrint impressao =
JasperFillManager.fillReport(/*relatorio*/layoutJarper,parametros,jrRS );
//System.out.println(jrRS);
//exibe o resultado da impressão na previsualização padrão Swing
JasperViewer viewer = new JasperViewer(impressao, false);
//dt.setJD(viewer);
//System.out.println(viewer.getDefaultCloseOperation());
viewer.setTitle("Sistema de Gerenciamento de Eventos");
//viewer.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
viewer.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
//viewer.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
viewer.show();
81
fechar();
}
}