Desenvolvendo Relatorios Pro Fission A Is Com Ireport para Netbeans IDE

Edson Gonçalves
Desenvolvendo Relatórios
Profissionais com iReport™
para NetBeans IDE
o
çã
ra
st
on
em
D
Este livro é dedicado ao Samuel,
filho do Ângelo e de sua esposa Erica,
grandes amigos e agora pais.
o
çã
ra
st
on
em
D
AGRADECIMENTOS
Primeiramente quero agradecer a minha família, pelo apoio e compreen-
são da minha ausência.
Agradeço o apoio da Editora Ciência Moderna, em especial ao editor Pau-

lo André P. Marques, pelo incentivo e crédito em mais este livro.
Um agradecimento especial ao JUG Leader e Founding Java Champion,
o
Daniel deOliveira, pelo apoio que uma comunidade de grande peso como o
çã
DFJUG tem sobre meu trabalho. ra
st
on
em
D
PREFÁCIO
Nem bem havia feito um ano que meu primeiro livro sobre relatórios JasperRe-
ports usando iReport havia sido iniciado e, acompanhando o site oficial da ferra-
menta, recebo uma excelente notícia: o iReport irá rodar sobre o NetBeans IDE.
Na prática, isso significa que você, como desenvolvedor, poderá criar, testar e
utilizar seus relatórios diretamente na IDE, sem a necessidade de abrir outro aplica-
tivo. De fato, isso é um grande salto para as ferramentas gratuitas, que anos atrás,
não tinham essa característica.
Embora o iReport permaneça com sua estrutura, praticamente inalterada, hou-
o
veram mudanças visuais para que o mesmo se incorporasse ao NetBeans.
çã
Espero que gostem deste livro tanto quanto gostei de reescrevê-lo.
ra
st
on
em
D
INTRODUÇÃO AO DESENVOLVIMENTO DE
RELATÓRIOS COM IREPORT
Em 2001, nasceu o JasperReports, criado por Teodor Danciu, quando teve a ta-
refa de avaliar ferramentas de relatórios para um projeto que estava trabalhando.
As soluções existentes eram muito caras para o orçamento do projeto e, em uma
situação comum no mundo do desenvolvimento, ele decidiu escrever sua própria
ferramenta de relatórios, que ao liberá-la para a comunidade, ficou imensamente
popular em pouco tempo.
O JasperReports é uma biblioteca escrita em Java, de código fonte open source,
o
projetada para ajudar o desenvolvedor com a tarefa de criar relatórios para aplica-
çã
ções, tanto Desktop como Web, fornecendo uma API que facilita sua geração.
Embora o JasperReports tenha simplificado o desenvolvimento de relatórios, o

ra
desenvolvedor, além da necessidade de conhecer seu formato XML, utilizado para
st
criar os relatórios, também dependia de cálculos para determinar a posição de cada
componente no relatório de forma harmônica.
on
Em 09 de outubro de 2002, o italiano Giulio Toffoli lançou, de forma indepen-

dente, uma ferramenta para gerar relatórios visuais, chamando-a de iReport. Sua
em
característica era de desenvolver relatórios gerando o formato XML no padrão Jas-

perReports. Isso tornou mais acessível e intuitivo o uso dos relatórios escritos em
JasperReports.
D
Em 2005, com a popularidade do iReport, a JasperSoft (empresa mantenedora

do JasperReports) tornou esta ferramenta oficial na construção de relatórios para o
JasperReports.
Com seis anos de existência, o iReport é reescrito para trabalhar dentro do Ne-
tBeans IDE, após o seu criador ter visto uma palestra no JavaOne 2007 a respeito
de um desenvolvedor que estava criando tal ferramenta para gerar relatórios Jas-
perReports.
X | Desenvolvendo Relatórios Profissionais com iReport™ para NetBeans IDE
Este livro é a mais que uma orientação, é um guia que o ensinará a utilizar o iRe-
port para NetBeans para construir relatórios JasperReports, criando desde os mais
simples relatório até os mais sofisticados, utilizando desde uma linguagem SQL até
as mais sofisticadas linguagens orientadas a objetos como HQL do Hibernate e EJB
QL (Enterprise JavaBeans Query Language), passando por sub-relatórios, relatórios
com gráficos, crosstab, passagem de parâmetros e outros.
Também será visto a exportação para diversos formatos suportados pelo Jasper-
Reports, como PDF, MS Excel, RTF, ODF, entre outros.
O leitor também aprenderá a chamar seus relatórios através de aplicações

desktop e Web criadas unicamente no NetBeans.
o
çã
ra
st
on
em
D
Introdução | XI
QUEM DEVE LER ESTE LIVRO?

Este livro foi escrito para desenvolvedores com experiência na linguagem Java,
que possuem pouca ou nenhuma familiaridade com a construção de relatórios, seja
em JasperReports com iReport ou com outra ferramenta qualquer neste sentido.
É também desejável que o leitor esteja bem familiarizado tanto com o desen-
volvimento desktop Java Swing, como em aplicações Web envolvendo Servlets, JSP
e JavaServer Faces. O conhecimento de frameworks Java ORM, como o Hibernate
e TopLink, de EJB 3 e IoC, como o Spring, é importante para um melhor aproveita-
mento dos exemplos.
o
ANTES DE COMEÇAR çã
ra
Em algumas partes deste livro, você encontrará apenas o trecho do código pro-
st
duzido, focado no assunto em questão, possuindo uma simbologia indicativa de

que o restante não está sendo mostrado. Este símbolo é mostrado a seguir:
on
em
... Indica que acima ou abaixo contém mais código, mas que não está sendo exi-
bido, sendo necessário recorrer ao exemplo completo, para visualizá-lo na íntegra,
que pode ser baixado gratuitamente no site do autor.
D
OS SOFTWARES REQUERIDOS
Os aplicativos criados nesse livro não exigem software proprietário. Portanto ao
longo dos capítulos você não só aprenderá a usá-los, como também onde encontrá-
los na Internet, caso precise de uma atualização.
Esse livro não está focado especialmente em um sistema operacional, portanto

a sua escolha é livre neste sentido.
XII | Desenvolvendo Relatórios Profissionais com iReport™ para NetBeans IDE
HARDWARE REQUERIDO
Uma boa configuração de hardware se faz necessário para trabalhar com apli-
cações escritas em Java. Um computador para rodar bem o iReport para NetBeans
deve ter as seguintes configurações para uma confortável utilização, segundo o
autor:
Processador: Pentium 4 (similar) ou superior
Memória: 512 MB de RAM mínimo (recomendo 2 GB de RAM no uso do NetBe-

ans IDE completo)
HD: 100 MB de espaço livre (1GB caso esteja utilizando o NetBeans IDE)
o
çã
Monitor: 17 polegadas ou superior ra
CÓDIGOS DOS EXEMPLOS CRIADOS NO LIVRO
st
Todos os códigos dos exemplos criados se encontram no site do autor: http://

on
www.integrator.com.br.
Caso não encontre algum exemplo entre em contato pelo e-mail edson@integrator.
em
com.br.
D
Introdução | XIII
VISÃO GERAL DOS CAPÍTULOS

Embora este livro esteja completamente focado na utilização do iReport para
NetBeans, ainda assim, você terá ao longo desta obra alguns códigos para desenvol-
ver. Em grande parte, o código está sendo mostrado apenas no trecho que importa,
focado para funcionar em aplicativos. Os exemplos completos estão no SITE do
AUTOR, que possui a separação por capítulo, para sua melhor orientação.
O livro é completamente ilustrado, possuindo dezenas de figuras espalhadas ao

longo de todos os seus capítulos, incluindo sempre o foco em detalhes, para que
você não se perca. Dicas também são dadas para que o leitor possa ter uma melhor
o
compreensão do que está sendo desenvolvido, incluindo os passos para executar
cada exemplo.
çã
A seguir, você tem uma sinopse de cada um dos capítulos do livro, incluindo
ra
também o apêndice:
st
CAPÍTULO 1 - CONHECENDO O IREPORT PARA NETBEANS IDE

on
O iReport para NetBeans IDE é um programa Open Source, capaz de criar visual-
em
mente os mais complexos relatórios para aplicações Java no formato da biblioteca

JasperReports.
D
Através de uma interface gráfica intuitiva, o desenvolvedor é capaz de criar qual-

quer tipo de relatório de forma simples e rápida. Mesmo sabendo que o iReport
desenvolve um formato XML usado pelo JasperReports, o que não é difícil de ma-
nipular, há uma vantagem em usar esta ferramenta. Se o desenvolvedor é um usuá-
rio iniciante no formato XML do JasperReports, o iReport supre suas necessidades
evitando que seja necessário fazer modificações no código fonte. Caso seja expe-
riente neste formato, o iReport minimiza o tempo na criação dos mais complexos
relatórios.
Neste capítulo você aprenderá onde obter, os requerimentos necessários para

executar, como instalar e entender sobre algumas das mais importantes caracterís-
ticas do iReport.
XIV | Desenvolvendo Relatórios Profissionais com iReport™ para NetBeans IDE
CAPÍTULO 2 - INICIANDO NO IREPORT PARA NETBEANS

O iReport é uma ferramenta que está preparada para construir visualmente os
mais complexos relatórios dentro dos limites do JasperReports.
Embora o primordial de iReport seja de desenhar relatórios, existem também

suas características para configurações.
Este capítulo o introduzirá ao desenvolvimento básico de relatórios usando o

iReport para NetBeans, partindo de sua execução inicial e suas configurações bási-
cas.
o
CAPÍTULO 3 - ESTRUTURA DE UM RELATÓRIO E SEU
DESENVOLVIMENTO
çã
ra
Um relatório é uma maneira agradável de apresentar as informações vindas de
st
alguma base de dados com sua aparência formatada. Na maioria das vezes, relató-
on
rios são usados para agrupar as informações vindas de um conjunto de dados, rela-
cionados entre si, oriundos de diversas tabelas. Como resultado você tem apenas os
campos determinados na construção do seu relatório e exposto como tal de forma
em
a simplificar a compreensão das informações. Vindo em um formato padronizado

para imprimir, como um texto feito em um editor de textos, você só precisa mandar
para a impressão ou exportá-los para outro formato de uso maior.
D
Neste capítulo você irá conhecer a estrutura de um relatório JasperReports na

ferramenta iReport para NetBeans e suas propriedades.
CAPÍTULO 4 - CRIANDO UM RELATÓRIO SEM O USO DE

ASSISTENTES
Para uma maior compreensão dos diversos elementos que compõem um relató-
rio no JasperReports, através do iReport para NetBeans, é importante a um desen-
volvedor aprender a desenhá-lo manualmente, isto é, sem o uso de assistentes.
Introdução | XV
Neste capítulo você irá aprender a criar um relatório manualmente, adicionando

diversos elementos, configurando-os e trabalhando com banco de dados.
CAPÍTULO 5 - GERANDO RELATÓRIOS COM GRUPOS E

PASSAGEM DE PARÂMETROS
Os relatórios mais utilizados em aplicações, com toda certeza, são os dinâmi-
cos. Aqueles relatórios que transmitimos uma determinada informação e este nos
trazem determinados dados.
o
Neste capítulo você aprenderá a criar um relatório mais complexo, utilizando
çã
mais de uma entidade (tabela) no desenvolvimento, agrupando informações e fil-
trando-as através de parâmetros.
ra
st
CAPÍTULO 6 - CHAMANDO O RELATÓRIO POR UMA

on
APLICAÇÃO DESKTOP
Assim como criar um relatório, é muito fácil chamá-lo por uma aplicação. Este
em
capítulo utilizará uma aplicação desktop simples, com interface gráfica Swing, cria-
da no NetBeans IDE, apenas com o intuito de ensiná-lo a chamar sua aplicação.
D
CAPÍTULO 7 - SUB-RELATÓRIOS
Os sub-relatórios são relatórios dentro de outros, também conhecidos como
relatórios do tipo “mestre-detalhe”.
A idéia básica para a criação de um relatório mestre-detalhe é ter duas entidades

relacionadas.
Estes relatórios, embora possam parecer complexos, são simples de desenvolver

em JasperReports.
XVI | Desenvolvendo Relatórios Profissionais com iReport™ para NetBeans IDE
Neste capítulo você aprenderá a criar sub-relatórios em seus relatórios usando

o iReport para NetBeans e acesso a dados, conhecerá a band noData na prática e
depois o chamará através de uma aplicação Web com JSP e Servlets.
CAPÍTULO 8 - RELATÓRIOS COM HIBERNATE

Criar relatórios com o uso do Hibernate como camada de acesso a banco de
dados é um caso comum no desenvolvimento de aplicações Web.
O Hibernate é hoje o mais popular projeto de gerenciamento de dados per-
o
sistentes em Java e também o que possui uma gama de soluções para problemas
comuns.
çã
Neste capítulo você aprenderá a desenvolver seus relatórios utilizando o Hiber-
ra
nate para acessar os dados, incluindo um exemplo com sub-relatório.
st
CAPÍTULO 9 - RELATÓRIOS USANDO EJB QL

on
O uso de Java Persistence API se tornou muito intenso, e como não poderia
em
deixar de ser, o JasperReports possui suporte a esta especificação através de EJB QL.
Esta linguagem de queries possui uma semelhança à HQL do Hibernate e também a
tradicional instrução SQL.
D
Com a especificação do EJB3, na introdução da JPA, Java Persistence API, ficou

muito popular o uso de JPQL, Java Persistence Query Language, que é uma é uma
extensão da EJB QL (Enterprise JavaBeans Query Language).
Neste capítulo você vai aprender a configurar um arquivo de persistência e criar

um relatório com sub-relatório utilizando a EJB QL.
Introdução | XVII
CAPÍTULO 10 - GERANDO RELATÓRIOS COM OUTRAS

FONTES DE DADOS
O JasperReports é rico no fornecimento de outras fontes de dados acessíveis
para que possamos gerar relatórios.
Muitos sistemas costumam exportar diversos tipos de dados, sendo os mais

comuns o formato CSV e XML.
Este capítulo tratará de outras formas de acesso que não utilizam um banco de
dados diretamente.
o
çã
CAPÍTULO 11 - SIMPLIFICANDO RELATÓRIOS COM
ra
GROOVY
st
Groovy é uma linguagem dinâmica escrita para a plataforma Java, inspirada em

linguagens como Ruby, Python e Smalltalk. Embora seja simples de manipular e mui-
on
to similar as linguagens de scripting, Groovy é um pouco mais complexo. Aplicações

com Groovy podem ser pré-compiladas em bytecodes Java, para ser integrada à suas
em
aplicações Java.
Graças a um Java Specification Request (JSR-241), Groovy se tornou a segunda

linguagem oficial padrão do Java Virtual Machine (JVM), depois de Java, claro.
D
Desde a versão 0.6.6 do JasperReports, há suporte a linguagem Groovy. Com

isso, quem ganha é o desenvolvedor, que tem em suas mãos uma maior simplicida-
de no desenvolvimento de expressões em seus relatórios.
Neste capítulo você vai construir um relatório utilizando Groovy, trabalhando

com expressões e aprenderá como rodar o relatório criado em suas aplicações tam-
bém usando Groovy.
XVIII | Desenvolvendo Relatórios Profissionais com iReport™ para NetBeans IDE
CAPÍTULO 12 - CRIANDO GRÁFICOS E SUBDATASET EM

SEUS RELATÓRIOS
Como todo bom relatório, não poderia faltar os gráficos. Simples e eficazes, os
gráficos exibem uma situação visualmente impactante, possibilitando um entendi-
mento muito maior, mais rico, do que apenas números e textos.
O JasperReports possui suporte a geração de gráficos, facilitando o desenvolvi-

mento do relatório, através da biblioteca JFreeChart.
Neste capítulo será apresentado como criar gráficos em um relatório JasperRe-

ports usando o iReport para NetBeans, além de aprender a trabalhar com consultas
o
diferentes no mesmo relatório, o que chamamos de Subdataset.
çã
ra
CAPÍTULO 13 - INTERNACIONALIZANDO RELATÓRIOS
st
Aplicações internacionalizadas são muito comuns no mundo do desenvolvimen-

on
to. Não seria diferente no caso dos relatórios. O JasperReports introduziu esta ca-
racterística na versão 0.6.2 e desde então seu suporte foi acrescentado ao iReport,
facilitando mais ainda seu desenvolvimento.
em
Neste capítulo será criada uma aplicação Java desktop simples, pelo NetBeans,
para ser usada com um relatório internacionalizado gerado pelo iReport.
D
CAPÍTULO 14 - CROSSTABS
Crosstabs (cross-tabulation), no JasperReports, são tabelas cruzadas, comuns no
desenvolvimento de relatórios com a utilização de planilhas eletrônicas, também
conhecidas por tabelas dinâmicas ou tabelas de referências cruzada.
Diferente dos demais relatórios criados até o momento no livro, um relatório

crosstab possui uma tabela contendo um número de linhas e colunas que não se
conhece em tempo de design.
Introdução | XIX
Graças ao iReport, você pode contar com o uso de um assistente, tornando esta
tarefa não muito complicada.
Neste capítulo você aprenderá a criar crosstabs no iReport, modificar, formatar

e usar também subdatasets para relatórios mais complexos.
CAPÍTULO 15 - OUTRAS CARACTERÍSTICAS DA GERAÇÃO

DE RELATÓRIOS
Neste capítulo você conhecerá outras características da ferramenta iReport, além
o
do JasperReports, que não foram apresentadas até o momento, sendo passadas em
çã
formato de dicas, como adicionar um trecho da query em um relatório, minimizar o
consumo de memória, imagem de fundo no relatório e outras.
ra
st
CAPÍTULO 16 - SCRIPTLET
on
Um scriptlet é uma classe Java desenvolvida unicamente para executar durante

a geração da impressão do relatório na tela. O scriptlet possui métodos que são
em
invocados na geração de relatórios possibilitando manipulá-los, como a ocorrência

da criação de uma nova página ou o acesso a um determinado parâmetro.
Neste capítulo será visto como escrever um simples scriptlet, qual a sua utilida-
D
de e como usá-lo em seu relatório.
CAPÍTULO 17 - DESENVOLVENDO SEUS PRÓPRIOS

TEMPLATES
Quando usamos um assistente de criação de relatórios, na última etapa fazemos
uso de templates. Algumas vezes pode ser útil criar um ou vários templates para
usar no assistente.
Neste capítulo você vai aprender a criar seus próprios templates e utilizá-los no
iReport.
XX | Desenvolvendo Relatórios Profissionais com iReport™ para NetBeans IDE
APÊNDICE A - EXPORTANDO PARA OUTROS FORMATOS

Este apêndice é uma referência sobre a API do JasperReports na exportação para
outros formatos através de sua aplicação, seja desktop ou Web.
Os formatos discutidos aqui são os mais utilizados para exportação pelo Jasper-
Reports: RTF, XLS, CSV, HTML e ODF.
PARA DOWNLOAD: APÊNDICES B, C, D E E
o
Para Download, veja “CÓDIGOS DOS EXEMPLOS CRIADOS NO LIVRO”, além dos
arquivos referentes aos exemplos contidos no livro, há também os seguintes apên-
dices:
çã
ra
APÊNDICE B – O MYSQL
st
on
APÊNDICE C – CONTEXTO DE DESENVOLVIMENTO WEB

em
EM JAVA
D
APÊNDICE D – TRABALHANDO COM DATAS EM JAVA
APÊNDICE E – O TOMCAT
SUMÁRIO
Capítulo 1 - Conhecendo o iReport para NetBeans IDE ........................................... 1
Antes de utilizar o iReport para NetBeans IDE .............................................. 3
Obtendo e instalando o Java SE .................................................................... 3
A instalação no Windows .............................................................................. 4
Em Windows versão 9x ................................................................................. 5
A instalação no Linux .................................................................................... 5
Obtendo e instalando o iReport para NetBeans IDE ..................................... 7
Algumas características do iReport para NetBeans IDE................................. 8
o
Instalando o iReport .................................................................................... 9
No Windows com instalador ......................................................................... 9
çã
No Windows e Linux sem instalador ........................................................... 10
Como instalar o plug-in iReport for NetBeans............................................. 10
ra
Compilando o fonte do iReport para NetBeans .......................................... 11
st
Capítulo 2 - Iniciando no iReport para NetBeans ................................................... 13

on
Abrindo o iReport para NetBeans pela primeira vez......................................... 15

Um relatório com iReport para NetBeans ......................................................... 16
O banco de dados usado ............................................................................. 16
em
O primeiro relatório no iReport para NetBeans na versão Standalone ....... 17

Visualizando o primeiro relatório ............................................................... 21
Configurando o iReport para NetBeans ............................................................ 21
D
A compilação do iReport para NetBeans no preview ........................................ 22

A versão do iReport para NetBeans como plug-in ............................................ 22
O arquivo de propriedades do iReport como plug-in.................................. 23
Abrindo um relatório no iReport para NetBeans ......................................... 23
iReport para NetBeans em inglês ................................................................ 24
Capítulo 3 - Estrutura de um relatório e seu desenvolvimento.............................. 25

A estrutura do relatório .................................................................................... 27
Title ............................................................................................................. 29
Page Header ................................................................................................ 29
Column Header ........................................................................................... 30
Detail ........................................................................................................... 30
XXII | Desenvolvendo Relatórios Profissionais com iReport™ para NetBeans IDE
Column Footer ............................................................................................ 31

Page Footer ................................................................................................. 31
Last Page Footer .......................................................................................... 32
Summary ..................................................................................................... 32
Background ................................................................................................. 33
noData ......................................................................................................... 33
Compreendendo as propriedades de um relatório ........................................... 33
Dimensões de um relatório ......................................................................... 34
Capítulo 4 - Criando um relatório sem o uso de assistentes .................................. 45

Iniciando um relatório manualmente .......................................................... 47
o
A janela Palette ............................................................................................ 47
Adicionando uma conexão a um relatório vazio ......................................... 49
çã
Criando a query do relatório ....................................................................... 51
Os elementos da query registrados no JasperReports ................................ 55
ra
Desenhando o relatório............................................................................... 56
Os símbolos para exibir o formato de números .......................................... 63
st
Conhecendo melhor o Text Field ................................................................ 64

on
Criando o efeito zebra em seu relatório ..................................................... 65

Estilos no JasperReports .............................................................................. 67
Exibindo imagens em seu relatório ............................................................. 68
em
Um pouco mais sobre o elemento image .................................................... 69

Adicionando links em elementos ................................................................ 74
Contando registros e exibindo na band Summary ...................................... 77
D
Salvando em outros formatos ..................................................................... 78
Capítulo 5 - Relatórios com grupos e passagem de parâmetros ............................ 79

O relatório que será desenvolvido .............................................................. 81
Gerando o relatório ..................................................................................... 81
Criando a query do relatório ....................................................................... 83
Criando o grupo .......................................................................................... 85
No arquivo JasperReports ............................................................................ 86
Adicionando os elementos na band PedidoGroupHeader ........................... 87
Padrões para datas ...................................................................................... 88
Criando variáveis com cálculos .................................................................. 89
Adicionando os elementos na band detail ................................................. 90
Sumário | XXIII
Totalizando por pedido .............................................................................. 92

Finalizando a aparência do relatório ........................................................... 93
Adicionando parâmetros ao relatório ......................................................... 94
Capítulo 6 - Chamando o relatório por uma aplicação desktop ............................. 97

A aparência final do aplicativo .................................................................... 99
As bibliotecas necessárias para obter o relatório...................................... 100
A biblioteca JDBC para a conexão com o banco de dados ........................ 100
O projeto no NetBeans IDE para executar o relatório ............................... 101
Executando o relatório .............................................................................. 103
Executando o projeto ................................................................................ 111
o
Capítulo 7 - Sub-relatórios.................................................................................... 113
çã
O relatório mestre-detalhe que será desenvolvido ................................... 115
Criando e configurando o relatório principal ............................................ 116
ra
Gerando a query ........................................................................................ 117
Definindo a posição dos campos............................................................... 118
st
O formato para a exibição do número de páginas .................................... 120

on
Adicionando conteúdo na band noData .................................................... 120

Gerando o sub-relatório ............................................................................ 121
Configurando a aparência do sub-relatório ............................................... 121
em
Modificando a query do sub-relatório....................................................... 123

Adicionando o sub-relatório ao relatório .................................................. 124
No arquivo JasperReports .......................................................................... 125
D
Alterando as propriedades do sub-relatório ............................................. 127

Retornando valores do sub-relatório ......................................................... 128
Chamando o relatório por uma aplicação web ........................................ 131
Criando marcadores para o relatório em PDF ........................................... 137
Capítulo 8 - Relatórios com Hibernate ................................................................. 141

O Hibernate ............................................................................................... 143
Criando um projeto usando Hibernate no NetBeans IDE .......................... 144
As bibliotecas do JasperReports e MySQL JDBC ........................................ 145
Criando as entidades ................................................................................. 145
Mapeando as tabelas ................................................................................. 147
Configurando o Hibernate......................................................................... 151
XXIV | Desenvolvendo Relatórios Profissionais com iReport™ para NetBeans IDE
Compilando o projeto ............................................................................... 154

Sobre Hibernate Annotations no iReport .................................................. 154
Configurando o Hibernate no iReport para NetBeans ............................... 154
Criando a conexão com o Hibernate no iReport para NetBeans ............... 155
Desenvolvendo o relatório ........................................................................ 156
Criando um relatório com sub-relatório usando Hibernate ...................... 157
A aplicação usando o Hibernate ................................................................ 161
Finalizando o projeto no NetBeans com Hibernate e o relatório criado .. 162
Relatório usando o Hibernate através do Spring ...................................... 167
Capítulo 9 - Relatórios usando EJB QL .................................................................. 169
o
O conceito da API de persistência ............................................................. 171
Sobre Java Annotations ............................................................................. 172
çã
Criando as entidades ................................................................................. 173
O relacionamento ...................................................................................... 178
ra
Onde encontrar o TopLink......................................................................... 182
Criando a conexão EJBQL no iReport ........................................................ 182
st

on
O sub-relatório .......................................................................................... 186

Adicionando o sub-relatório ao relatório mestre ...................................... 188
Adicionando o parâmetro especial para manter a sessão ......................... 188
em
Selecionando apenas alguns objetos com EJB QL ..................................... 190

Como visualizar um relatório com EJB QL no seu aplicativo ..................... 191
Alterando o relatório para utilizar no projeto do NetBeans IDE ............... 192
D
Finalizando o projeto no NetBeans IDE .................................................... 192
Capítulo 10 - Gerando relatórios com outras fontes de dados ............................ 197

Usando XML para criar relatórios .............................................................. 199
Criando um relatório com XML ................................................................. 199
Relatórios com XML remoto ...................................................................... 204
Usando CSV para criar relatórios............................................................... 204
Registrando os campos de um arquivo CSV .............................................. 206
Relatórios sem fonte de dados .................................................................. 207
Relatórios usando JavaBeans como fonte de dados .................................. 208
Relatórios usando uma fonte de dados personalizada.............................. 213
Sumário | XXV
Capítulo 11 - Simplificando relatórios com Groovy.............................................. 219

Criando um relatório usando Groovy ........................................................ 221
Iniciando o desenvolvimento do relatório ................................................ 221
O design do relatório ................................................................................ 223
Resultado final do relatório com Groovy ................................................... 226
Chamando seu relatório com Groovy ........................................................ 226
Criando um projeto no NetBeans com Groovy ......................................... 226
Capítulo 12 - Criando gráficos e subdataset em seus relatórios .......................... 231

Criando um gráfico simples ....................................................................... 233
Links em seu gráfico .................................................................................. 238
o
Subdatasets ............................................................................................... 238
Utilizando Subdatasets em seu gráfico ..................................................... 241
çã
Gráficos de linhas ...................................................................................... 244
Utilizando Gráficos em um relatório com Hibernate ................................ 248
ra
Capítulo 13 - Internacionalizando relatórios ........................................................ 249
st
Criando seu relatório internacionalizado .................................................. 251

on
Capítulo 14 - Crosstabs......................................................................................... 257

Criando seu primeiro relatório Crosstab ................................................... 259
em
No JasperReports ....................................................................................... 263

Compreendendo a disposição da Crosstab ............................................... 263
Modificando uma célula na Crosstab ........................................................ 264
D
Adicionando grupos de linhas e colunas ................................................... 265

Compreendendo as Measures ................................................................... 268
Criando uma Crosstab com Subdataset..................................................... 269
Capítulo 15 - Outras características da geração de relatórios .............................. 275

Tratando relatórios grandes ...................................................................... 277
Trechos SQL no relatório ........................................................................... 279
Adicionando uma imagem de fundo ......................................................... 280
Exibindo somente um grupo por página ................................................... 281
Reiniciando o número de páginas ............................................................. 281
Alinhamento de objetos no design do relatório ....................................... 281
Formatação entre textos no seu relatório ................................................. 281
XXVI | Desenvolvendo Relatórios Profissionais com iReport™ para NetBeans IDE
Data atual no relatório .............................................................................. 284

Stored Procedures e Functions.................................................................. 284
Erros na compilação .................................................................................. 284
Capítulo 16 - Scriptlet .......................................................................................... 287

A classe JRAbstractScriptlet ....................................................................... 289
Um exemplo da utilização de Scriptlets .................................................... 292
A classe Scriptlet ....................................................................................... 293
O projeto no NetBeans para usar Scriptlet em um relatório ..................... 295
A conexão com o arquivo CSV................................................................... 296
o
Adicionando o scriptlet ao relatório ......................................................... 297
Criando as variáveis do relatório ............................................................... 298
çã
Editando a query do relatório ................................................................... 299
Criando o design do relatório ................................................................... 299
ra
Como evitar valores repetidos em um relatório........................................ 301
Forçando o valor a aparecer ao menos uma vez em cada página ............. 301
st
Criando métodos personalizados com Scriptlets ...................................... 302

on
Capítulo 17 - Desenvolvendo seus próprios Templates........................................ 303

Criando um relatório modelo .................................................................... 305
em
Configurando o template criado no iReport ............................................. 307

O uso do template no assistente do iReport ............................................. 308
Imagem de preview do template no assistente......................................... 308
D
Apêndice - Exportando para outros formatos................................................. 311

Exportando para o formato RTF ................................................................ 313
Exportando para o formato Excel .............................................................. 313
Exportando para HTML ............................................................................. 314
Exportando para CSV ................................................................................ 314
Exportando para ODF ................................................................................ 315
Sumário | XXVII
Bibliografia ...................................................................................................... 317

Livros Nacionais .............................................................................................. 319
Livros Internacionais ....................................................................................... 319
Sites ................................................................................................................ 319
Acesso para pesquisa ...................................................................................... 320
Tutoriais .......................................................................................................... 320
o
çã
ra
st
on
em
D
1
CONHECENDO O IREPORT PARA
o
çã
NETBEANS IDE
ra
st
on
em
D
“Começar já é metade de toda a ação.”

provérbio grego
Capítulo 1 | 3
O iReport para NetBeans IDE é um programa Open Source, capaz de criar visual-
mente os mais complexos relatórios para aplicações Java no formato da biblioteca
JasperReports.
Através de uma interface gráfica intuitiva, o desenvolvedor é capaz de criar qual-
quer tipo de relatório de forma simples e rápida. Mesmo sabendo que o iReport
desenvolve um formato XML usado pelo JasperReports, o que não é difícil de ma-
nipular, há uma vantagem em usar esta ferramenta. Se o desenvolvedor é um usuá-
rio iniciante no formato XML do JasperReports, o iReport supre suas necessidades
evitando que seja necessário fazer modificações no código fonte. Caso seja expe-
riente neste formato, o iReport minimiza o tempo na criação dos mais complexos
relatórios.
o
Neste capítulo você aprenderá onde obter, os requerimentos necessários para
çã
executar, como instalar e entender sobre algumas das mais importantes caracterís-
ticas do iReport.
ra
st
ANTES DE UTILIZAR O IREPORT PARA NETBEANS IDE

on
O iReport para NetBeans IDE, por ser uma ferramenta Java, precisa do Sun Java
2 SDK 1.5 instalado em sua máquina, ou superior. Perceba que não é apenas a JVM
(Java Virtual Machine) que deve estar instalada. Isso porque, para compilar os arqui-
em
vos jasper, é necessária a instalação da distribuição do Java SE, sendo impossível

somente com a JRE (Java Runtime Environment).
D
OBTENDO E INSTALANDO O JAVA SE

Atualmente, o JDK (Java ™ SE Development Kit) está em sua versão 6 e possui
suporte para as seguintes plataformas:
Microsoft Windows
Linux
Sun Solaris
Mac Os
Entre outros
4 | Desenvolvendo Relatórios Profissionais com iReport™ para NetBeans IDE
A página Web oficial sobre a linguagem Java da Sun se encontra no endereço

http://java.sun.com.
A Sun publica periodicamente releases do JDK e costuma numerá-los através do
que chamam atualmente de updates.
Para obter o Kit de Desenvolvimento Java, que até o momento em que este livro
é escrito está na versão 6 update 6 (JDK 6u6), conhecido como Java SE 6.0, acesse o
endereço: http://java.sun.com/javase/downloads/index.jsp.
Na página de download do Java SE 6.0, existem vários produtos para download.
Logo a seguir há uma descrição de alguns dos produtos do qual você encontra para
download:
o
• JDK 6 Update 6 – Este é o kit de desenvolvimento Java. Este kit consiste em
çã
um compilador (javac), uma ferramenta de execução (java), uma ferramenta para
geração de documentação (javadoc), um conjunto de bibliotecas prontas para o uso
e etc.
ra
• Java Runtime Environment (JRE) 6 Update 6 – Este é o ambiente runtime do
st
Java, usado apenas para executar os programas feitos em Java.

• Java SE 6 Documentation – A documentação do J2SE. Esta documentação
on
contém as informações sobre todas as bibliotecas do Java.

Clique no botão-link Download. Para efetuar o download do JDK, você deve
em
aceitar os termos de uso do Java SE, clicando na opção “Accept”. Após a página
recarregar, haverá a possibilidade de baixar a versão que você precisa para a sua pla-
taforma. Observe que na página de Downloads existem diversos Java SE. Existe Java
D
SE para a plataforma Windows, Linux, Solaris SPARC, Solaris x86 e Linux AMD64.
Efetue o download do Java SE para o seu sistema operacional clicando sobre o link
do produto que utilizará para instalação.
A INSTALAÇÃO NO WINDOWS
Tendo em vista que o Windows no qual será descrito está na versão XP ou supe-
rior, inicie o assistente com um duplo clique sobre o arquivo executável, que como
tantos outros desta plataforma, basta avançar até concluir.
Para configurar qualquer variável de ambiente em um sistema Windows na ver-
são NT, você deve entrar no Painel de Controle, Sistema e na guia Avançado clique no
botão Variáveis de Ambiente.
Capítulo 1 | 5
As variáveis de ambiente são seqüências de caracteres que contêm informações

como unidade, caminho ou nome de arquivo. As variáveis de ambiente controlam
o comportamento de vários programas. Como exemplo de variáveis de ambiente:
PATH, CLASSPATH, USER, TEMP, JAVA_HOME e etc.
Estas variáveis de ambiente são utilizadas por muitos programas, para definir
um espaço em memória principal (RAM), onde alguns processamentos serão exe-
cutados
Em Variáveis do sistema, clique em Nova. Adicione o nome da variável como
JAVA_HOME e no valor o caminho onde você instalou o JDK.
A variável JRE_HOME é similar a anterior, mudando apenas para o valor onde se
o
encontra a máquina virtual Java.
çã
Na variável PATH, você tem que adicionar a variável JAVA_HOME, acrescida do
caminho para os binários. Após o último valor, coloque um ponto-e-vírgula (“;”) e
adicione %JAVA_HOME%\bin.
ra
Ao confirmar as caixas de diálogo, teste se o Java está funcionando na sua má-
st
quina em um prompt de comando, como mostrado a seguir:

on
java -version
em
EM WINDOWS VERSÃO 9X
Você deve editar o arquivo autoexec.bat, encontrado em C:\autoexec.bat e adi-
cionar as variáveis como o exemplo a seguir:
D
set JAVA_HOME= C:\jdk1.6.0_06
Onde o local indicado no exemplo, é onde você tem instalado o JDK.
A INSTALAÇÃO NO LINUX
No momento em que este livro está sendo escrito, a versão baixada para o siste-
ma operacional Linux é a jdk-6u6-linux-i586.bin.
Entre no terminal do seu Linux, após baixar o arquivo, e mude para o usuário
Root ou administrativo do sistema e altere a permissão do arquivo para executável,
assim você poderá instalá-lo:
shell# chmod +x jdk-6u6-linux-i586.bin
Execute o arquivo:
shell# ./jdk-6u6-linux-i586.bin
Assim como ocorre em sistemas operacionais Windows, você terá um assistente

para instalação, só que com a diferença de não ser gráfico.
Entre no arquivo profile em /etc/profile e adicione as linhas em seu final:
o
çã
JAVA_HOME=/jdk1.6.0_06
JRE_HOME=/jdk1.6.0_06/jre
export JAVA_HOME
ra
export PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/lib
export MANPATH=$MANPATH:$JAVA_HOME/man
st
As variáveis usadas são explicadas rapidamente a seguir, dando a você noção do

que cada uma faz:
on
JAVA_HOME - Diretório onde a JDK está instalada

em
JRE_HOME - Diretório onde a máquina virtual está instalada

PATH - Diretório dos executáveis, onde inclui o do Java
CLASSPATH - Diretório das libs
D
MANPATH - Diretório do manual, acessível por man javac.
Faça logout no sistema e logon e execute no terminal o seguinte comando:
java -version
Surgindo as informações mostradas a seguir, a instalação foi feita com sucesso.
java version “1.6.0_06”

Java(TM) SE Runtime Environment (build 1.6.0_06-b02)
Capítulo 1 | 7
Figura 1.1 – Verificando a versão de instalação do Java no Linux
o
OBTENDO E INSTALANDO O IREPORT PARA NETBEANS IDE
çã
Para baixar o iReport para NetBeans IDE, entre no endereço oficial http://www.
ra
jasperforge.org/ireport ou http://ireport.sourceforge.net/. Até o momento em que
este livro é escrito a versão atual do iReport para NetBeans IDE está em 3.1.2. Esta
st
versão tem suporte completo ao JasperReports 3.1.2.

Clique no link Download iReport para ser redirecionado ao SourceForge.net,
on
onde está alocado para baixar. Clique no item iReport-nb-3.1.2 e confirme no botão
Browse Package. Copie o link existente em Location e o cole na barra de endere-
em
ços.
Se você estiver usando o sistema operacional Microsoft Windows, baixe a versão
iReport-nb-3.1.2-windows-installer.exe, ao qual inclui um instalador, ou o arquivo
D
iReport-nb-3.1.2.zip, sem instalador. Para os demais sistemas operacionais, incluin-

do Linux, baixe a versão iReport-nb-3.1.2.tar.gz. O código fonte pode ser encontra-
do baixando-se o arquivo iReport-nb-3.1.2-src.zip.
Se estiver utilizando o NetBeans e desejar apenas incluir o plug-in, selecione
iReport Plugin for NetBeans e baixe o arquivo iReport-nb-3.1.2-plugin.zip.
Atenção: As explicações neste tópico estão atreladas a versão atual do site, no

momento em que este livro é escrito.
ALGUMAS CARACTERÍSTICAS DO IREPORT PARA NETBEANS IDE

O iReport possui diversas características que o tornam uma ferramenta de de-
senvolvimento de relatórios profissional, no mesmo padrão de outros do mesmo
tipo consagrados pelo mundo do desenvolvimento. A seguir você tem algumas de
suas principais características que fazem deste programa visual o Oficial para desen-
volvimento de relatórios JasperReports:
• Suporte a 100% das tags XML do JasperReports;
• Editor WYSIWYG para criação de relatórios, possuindo ferramentas que in-
cluem desenhos de retângulos, linhas, elipses, caixas de texto, rótulos, gráfi-
cos, sub-relatórios, códigos de barras e etc.;
o
• Um editor para escrever as expressões incluindo destaques (highlights) nas
sintaxes;
çã
• Suporte para Unicode e línguas não latinas como: Russo, Chinês, Japonês,
ra
Coreano entre outras;
• Integração para compilar e exportar;
st
• Suporte para todos os bancos de dados acessíveis pela ponte JDBC;

on
• Suporte virtual para todos os tipos de DataSources;

• Assistentes para criar relatórios rapidamente;
em
• Suporte para sub-relatórios;

• Backup para o código fonte;
D
• Suporte para modelos de documentos (templates);

• Suporte para fontes TrueType;
• Extensão através de plug-ins;
• Suporte integrado para scriptlets;
• Suporte a gráficos;
• Gerenciamento de bibliotecas de objetos padrão tais como numeração de
páginas;
• Arrastar e Soltar (Drag’n Drop);
• Ilimitados Desfazer e Refazer;
• Biblioteca de estilos e etc.
Capítulo 1 | 9
INSTALANDO O IREPORT
Como há mais de uma forma de instalar o iReport para NetBeans, você verá to-
das aqui. A primeira forma de instalação que será mostrada é no sistema operacio-
nal Windows com o assistente. A segunda forma será sem o uso de assistente, neste
caso tanto no sistema operacional Windows como no Linux será mostrada.
A última forma será no NetBeans IDE, em forma de plug-in.
NO WINDOWS COM INSTALADOR

O assistente para instalar o iReport para NetBeans no Windows é similar aos
o
demais utilizados em outros programas neste sistema operacional. Dê um duplo
çã
clique no arquivo iReport-nb-3.1.2-windows-installer.exe para iniciar o processo de
instalação pelo assistente.
ra
1. Na primeira etapa você tem a tela inicial do iReport nb-3.1.2. Clique no botão
Next para prosseguir.
st
2. Na segunda etapa do assistente você deve aceitar a licença de uso do iReport

nb-3.1.2. Caso você não conheça a licença GNU (General Public License), reco-
on
mendo lê-la antes de prosseguir. Clique no botão I Agree para continuar.

3. Na terceira etapa você define os componentes que serão instalados. Como no
em
caso há apenas um, clique no botão Next para prosseguir.

4. A quarta etapa é o local onde será instalado o iReport. Por padrão ele é de-
D
finido dentro do diretório JasperSoft\iReport-nb-3.1.2 em Arquivos de pro-

gramas do seu sistema operacional Windows. Caso precise mudar, clique no
botão Browse e selecione o novo local em que deseja instalar. Para prosseguir,
clique no botão Next.
5. No quinto passo você define o local de acesso no menu Iniciar do Windows.
Caso concorde com a atual configuração, basta clicar no botão Install para
iniciar o processo de instalação. Caso deseje alterar o acesso, basta digitar no
local selecionado, em JasperSoft\iReport-nb-3.1.2.
6. Após a instalação, a opção Run iReport nb-3.1.2 estará selecionada. Clicando
no botão Finish, abrirá imediatamente o iReport para trabalhar. O instalador
também criará um atalho na área de trabalho para acesso rápido ao programa,
através do arquivo iReport.exe.
Atenção: O instalador cria, além do arquivo ireport.exe, um arquivo chamado ire-

port_w.exe, que inicializa o iReport para NetBeans com o prompt de comando.
NO WINDOWS E LINUX SEM INSTALADOR

Caso você prefira a versão sem instalador, existem os dois arquivos compacta-
dos iReport-nb-3.1.2.zip (recomendável para o sistema operacional Windows) ou
iReport-nb-3.1.2.tar.gz (para o sistema operacional Linux). Descompacte o de sua
preferência em um local desejado.
No Linux, você deve executar antes o comando para descompactação:
o
shell# tar –xpvzf iReport-nb-3.1.2.tar.gz
çã
Ao descompactar o iReport, entre no diretório e execute a permissão de execução:
ra
shell# cd iReport-nb-3.1.2/
shell# chmod +x ireport
st
Para o Windows existem os arquivos ireport.exe e ireport_w.exe para inicializar,

on
bastando um duplo clique. No sistema operacional Linux, basta entrar no terminal

e executar o Shell, como mostrado a seguir:
em
shell# ./ireport
D
COMO INSTALAR O PLUG-IN IREPORT FOR NETBEANS

Caso já exista o NetBeans IDE instalado em sua máquina, não há a necessidade
de instalação separada do iReport.
O plug-in do iReport se integra a ferramenta, suavizando o trabalho com seus
aplicativos sem necessitar abrir outra IDE para criar relatórios.
Baixe o arquivo iReport-nb-3.1.2.nbms.zip para obter apenas o plug-in e des-
compacte-o.
Para o exemplo, será instalado o plug-in no NetBeans IDE 6.5 beta, a versão mais
atual no momento em que este livro é escrito.
Capítulo 1 | 11
1. No seu NetBeans IDE, vá ao menu Tools>Plugins e clique na guia Downloaded.

2. Clique no botão Add Plugins e selecione todos os arquivos encontrados na
descompactação do iReport-nb-3.1.2.nbms.zip.
o
çã
ra
st
Figura 1.2 – Selecionando os arquivos do plug-in iReport for NetBeans

on
3. Clique no botão Install para iniciar a instalação do plug-in na ferramenta.

em
4. Ao surgir a caixa de diálogo NetBeans IDE Installer clique em Next. Aceite os

termos de licença em I accept the terms in all of the license agreements e
confirme no botão Install.
D
Se a caixa de diálogo Verify Certificate surgir, apenas clique em Continue para

prosseguir com a instalação do plug-in.
Após a instalação, você encontra o plug-in ireport-designer, na guia Installed.
COMPILANDO O FONTE DO IREPORT PARA NETBEANS

O projeto do iReport para NetBeans foi criado na versão 6.0 da ferramenta Ne-
tBeans IDE. Isso significa que você deve baixar esta versão para abrir o projeto e,
somente então, compilá-lo.
A versão do NetBeans utilizado está no arquivo platform.properties, expandin-

do iReport>Important Files, dando um duplo clique em NetBeans Platform Config.
A última linha, mais especificamente em nbplatform.active, antes de compilar, deve
ter o valor substituído para default.
Para compilar, clique com o direito do mouse sobre iReport, na janela Projects,
e selecione Build ZIP Distribution, no menu de contexto. No source do iReport,
surgirá um arquivo “zipado” dentro do diretório dist.
o
çã
ra
st
on
em
D
Figura 1.3 – Projeto do iReport aberto no NetBeans IDE 6.0

2
INICIANDO NO IREPORT PARA
o
NETBEANS çã
ra
st
on
em
D
“Especialize-se em um setor determinado e procure

conhecer mais sobre ele que qualquer outra pessoa“.
Joseph Murphy
Capítulo 2 | 15
O iReport é uma ferramenta que está preparada para construir visualmente os

mais complexos relatórios dentro dos limites de JasperReports.
Embora o primordial de iReport seja de desenhar relatórios, existem também
suas características para configurações.
Este capítulo o introduzirá ao desenvolvimento básico de relatórios usando o iRe-
port para NetBeans, partindo de sua execução inicial e suas configurações básicas.
ABRINDO O IREPORT PARA NETBEANS PELA PRIMEIRA VEZ

Quando o iReport executa pela primeira vez ele carrega informações de con-
o
figurações regionais de seu sistema operacional e cria um diretório chamado de
.ireport no diretório do usuário em home no Linux, em Document and Settings de
çã
seu Windows XP ou AppData\Roaming no seu usuário em Windows Vista. Neste
diretório você encontra diversos arquivos.
ra
st
on
em
D
Figura 2.1 – Símbolo do iReport
Suas configurações pessoais e as configurações do programa estão gravados

neste diretório, em seu arquivo ireport.properties, dentro de .ireport/dev/config/
Preferences/com/jaspersoft.
Atenção: Se não for criado o diretório .ireport, alguns problemas indesejáveis

podem ocorrer na execução do programa, além da impossibilidade de gravação
das configurações personalizadas.
UM RELATÓRIO COM IREPORT PARA NETBEANS

Antes de continuar nas configurações do iReport, você vai se ambientar na ferra-
menta, criando um primeiro relatório. Isso possibilitará uma melhor compreensão
da geração de relatórios JasperReports.
Para a geração deste relatório, você vai utilizar o assistente de relatórios existen-
te na ferramenta. Isso facilitará na velocidade do desenvolvimento.
O BANCO DE DADOS USADO

O MySQL 5 será o gerenciador de banco de dados usado neste livro para a exe-
o
cução dos exemplos de relatórios. Apesar de ser o MySQL, os exemplos mostrados
çã
poderão ser feitos em Oracle, SQL Server, PostgreSQL e etc.
O banco de dados chamado de relatorios será usado em todos os capítulos ao lon-
ra
go do livro, sendo as tabelas que o compõe são apresentadas na Figura 2.2 a seguir.
st
on
em
D
Figura 2.2 – Diagramação do banco de dados usado no livro

Capítulo 2 | 17
Observação: As tabelas foram baseadas no banco de dados de exemplo Nor-

thwind, encontrado no MS Office Access ® e no banco de dados MS SQL Server
®, ambos da Microsoft (MS).
Atenção: O arquivo relatorios.sql contendo o banco de dados relatorios e suas ta-

belas devidamente populadas se encontra no site do autor, citado no início deste
livro, em “Códigos dos exemplos criados no livro”.
O PRIMEIRO RELATÓRIO NO IREPORT PARA NETBEANS NA VERSÃO
o
STANDALONE
çã
O banco de dados a ser criado é composto por cinco entidades, sendo quatro
delas principais para o cenário proposto. Para o exemplo, você vai criar o primeiro
ra
relatório usando apenas a tabela de produtos.
Vá ao menu File do iReport para NetBeans e selecione no menu o item Report
st
Wizard.
on
em
D
Figura 2.3 – Selecionando o item de menu Report Wizard
Ao surgir à caixa de diálogo do assistente, chamada de New Report, você deverá

seguir os seguintes passos para criar seu relatório:
1. Para a primeira etapa, coloque o nome do seu relatório em Report name.
Chame de PrimeiroRelatorio se quiser ter um nome similar ao do livro. No botão
Browse você pode alterar a localização de onde será salvo o relatório. Clique no
botão Next para prosseguir.
2. A segunda etapa necessita da criação de uma conexão com o banco de dados.
Como ainda não fora feito nenhuma, clique no botão New, ao lado do campo Con-
nections/Data Sources.
a. Na caixa de diálogo de Datasource selecione o item Database JDBC connec-

tion. Clique no botão Next para prosseguir.
b. Como o driver JDBC usado é do MySQL, por padrão, a segunda etapa das pro-
priedades de conexão surgirá com esta opção selecionada no campo JDBC Driver,
contendo com.mysql.jdbc.Driver. Não há necessidade, neste caso, de se adicionar
a biblioteca JDBC na sua aplicação.
c. No campo Name digite relatorios. No campo JDBC URL complete deixando
jdbc:mysql://localhost/relatorios. Coloque o nome de usuário no campo User Name
e sua respectiva senha em Password. Marque a opção Save password.
o
çã
ra
st
on
em
D
Figura 2.4 – Definindo as propriedades de conexão
d. Clique no botão Test para verificar se a conexão foi estabelecida com sucesso.
Caso apareça a mensagem “Connection test successful!”, significa que você configu-
rou tudo corretamente e que agora há uma comunicação com o banco de dados.
e. Salve as informações de conexão com o banco de dados através do botão Save
da caixa de diálogo.
Capítulo 2 | 19
Onde o iReport armazena minha conexão?

O iReport guarda as informações da configuração da conexão no diretório .ireport/
dev/config/Preferences/com/jaspersoft, dentro do arquivo ireport.properties.
Neste arquivo há a propriedade connection seguida por um “ponto” e um núme-
ro, que indica a conexão, onde a primeira é zero, a segunda é um e assim por dian-
te. A string que existe como valor possui um XML, contendo uma compatibilidade
com a versão do iReport que não está sobre a plataforma NetBeans.
f. Retornando ao assistente de relatório, na segunda etapa, concluída a conexão,

você só precisa definir a tabela e dados que serão exibidos. No campo Query (SQL)
o
digite a instrução SQL, a seguir, que selecionará somente a tabela de produtos e, em
seguida, clique no botão Next para prosseguir:
çã
ra
SELECT * FROM produtos
st
on
em
D
Figura 2.5 – Criando a consulta SQL na segunda etapa do assistente
3. Na terceira etapa do assistente, em Fields, adicione todos os campos exceto

CategoriaID (utilizando o botão “>”) e clique no botão Next.
o
çã
ra
Figura 2.6 – Seleção de campos para a geração do relatório
st
4. Na quarta etapa simplesmente avance clicando no botão Next.

on
5. Na quinta etapa, você vai selecionar o layout que deseja utilizar em seu rela-
tório. Mantenha na opção Columnar layout e clique no botão Next.
em
6. Na última etapa, clique simplesmente no botão Finish para concluir o assistente.
Ao final você terá um relatório gerado com os campos selecionados em formato

D
tabular, contendo sua visualização apenas estrutural.
Figura 2.7 - Estrutura do relatório gerado pelo assistente

Capítulo 2 | 21
Observação: O driver JDBC do MySQL já vem com o iReport, no diretório ide8/

modules/ext de sua instalação. Caso você deseje utilizar outro banco de dados ou
atualizar a versão JDBC da biblioteca do MySQL, que se encontra na versão mysql-
connector-java-5.0.7-bin.jar, adicione neste diretório.
VISUALIZANDO O PRIMEIRO RELATÓRIO

Antes de iniciar qualquer alteração, você vai visualizar o relatório da forma bruta
como foi criado.
Clique em Preview (ou pelo menu View>Editors>Preview) e aguarde a rende-
o
rização do relatório.
çã
O visualizador de relatórios para o formato JasperReports está embutido no
iReport para NetBeans, diferente do que acontecia em versões que não utilizam a
plataforma NetBeans.
ra
st
CONFIGURANDO O IREPORT PARA NETBEANS

on
Agora com a criação de um relatório básico, você está preparado para configurar
o iReport para NetBeans em algumas de suas características.
em
Vá ao menu Tools e clique no item Options.

Ao surgir à caixa de diálogo Options, as configurações iniciais são do iReport.
Como principais itens de configuração você tem:
D
Na guia General:
• Default unit – Indica a unidade utilizada para o trabalho com os relatórios.
Podem ser: mm, cm, pixels e polegadas.
• Limit the number of records – Quando selecionado, você pode definir o número
máximo de relatórios que podem ser exibidos, alterando em Max number of reports.
• Report locale – Define a localização atual da sua máquina, exibindo de forma
correta certos padrões numéricos como números, moedas e datas.
• Report timezone – Define a timezone da região, pegando automaticamente a
configuração do sistema operacional.
• Ignore pagination – Ignora a paginação de dados na geração dos relatórios.

• Use virtualizer – Será visto mais adiante, em outro capítulo.
• Report defaults
o Language – A linguagem utilizada como padrão para os relatórios. Por pa-
drão é Java, mas podemos usar nesta versão Groovy e JavaScript.
o Chart theme – Tema para o gráfico. Será visto mais adiante, em outro capítulo.
Em Classpath você pode adicionar bibliotecas e classes não disponíveis pelo iReport
para compilar relatórios com acesso a dados de forma específica. Essa guia será utiliza-
da mais adiante quando utilizar outras formas de conexão com o banco de dados.
o
çã
Na guia Viewers você pode selecionar cada um dos programas que deseja uti-
lizar como visualizadores quando compilar e exportar o relatório em um determi-
nado formato. Depois, para visualizar no formato desejado, dentro do programa
ra
selecionado, você seleciona no menu Preview.
st
Adicione um programa que deseja utilizar para cada tipo de arquivo, principal-
mente o PDF que será muito utilizado ao longo do livro.
on
A COMPILAÇÃO DO IREPORT PARA NETBEANS NO

em
PREVIEW
Por padrão, o iReport utiliza o seu diretório corrente do arquivo .jrxml, aberto
D
do seu relatório, para guardar os arquivos compilados.

Se determinar outro programa como preview, ele exibirá tanto internamente
como abrirá o programa configurado para exibir o formato desejado.
A VERSÃO DO IREPORT PARA NETBEANS COMO PLUG-IN

Diferente do que acontece com a versão Standalone, o plug-in iReport for NetBeans exi-
ge a criação de um projeto, seja Web ou Desktop, para que seja possível criar um relatório.
Primeiro, antes de criar o relatório, selecione um diretório ou pacote onde vai
criá-lo. Ao criar um novo arquivo, New File, você seleciona em Categories o item
Report e, em File Types, novamente Report para o assistente de relatórios.
Capítulo 2 | 23
Ao avançar, você define o nome do relatório, só que desta vez deve manter a
extensão, como por exemplo: PrimeiroRelatorio.jrxml.
Na etapa de conexões siga os mesmos procedimentos feitos no passo número
2 da versão Standalone. Como extra, você pode selecionar uma conexão ativa já
existente do NetBeans IDE, com a opção NetBeans Database JDBC connection.
O ARQUIVO DE PROPRIEDADES DO IREPORT COMO PLUG-IN

Diferente da versão Standalone, a versão plug-in armazena o arquivo ireport.pro-
perties no diretório de configurações do NetBeans IDE. Neste caso, ele costuma se en-
contrar no diretório de usuário da sua máquina com o nome de .netbeans. O caminho
o
para o arquivo é /.netbeans/dev/config/Preferences/com/jaspersoft/ireport.properties.
çã
ra
ABRINDO UM RELATÓRIO NO IREPORT PARA NETBEANS
Um relatório criado em nosso idioma possui muitos acentos em rótulos, devido
st
a nossa língua. Entretanto, no NetBeans, ainda na versão utilizada pelo iReport e

on
não corrigida até o momento que este livro é escrito, há o problema com a codifica-
ção de caracteres no sistema operacional Windows, que inicializa trabalhando com
o padrão iso-8859-1.
em
Como o tipo aceito pelo iReport é UTF-8, o programa precisa criar arquivos
neste padrão. Se isso não ocorrer, quando abrir um relatório com a codificação
diferente de UTF-8, verá o erro mostrado na Figura 2.8.
D
Figura 2.8 – Erro ao ler um relatório criado com acentos

Para corrigir este problema, basta alterar o atalho que inicializa o programa,
transmitindo o seguinte parâmetro: -J-Dfile.encoding=UTF-8.
Você pode resolver este problema simplesmente criando um arquivo .bat, no
diretório bin da instalação do iReport, da seguinte forma:
ireport.exe -J-Dfile.encoding=UTF-8
Porém, pode ser que você acredite que esta solução seja muito ruim e quer algo
mais profissional. Neste caso, basta alterar o arquivo de configurações chamado -
que é o mesmo do NetBeans (netbeans.conf), porém, com outro nome.
Altere no arquivo, que se encontra no diretório etc, no local da instalação do seu
o
iReport, na seguinte linha:
çã
default_options=”-J-Xms24m -J-Xmx64m -J-Dfile.encoding=UTF-8”
ra
Ao inicializar o iReport, ele carregará estas configurações, encontradas nesta
linha, e inicializará os arquivos com essa codificação.
st
on
IREPORT PARA NETBEANS EM INGLÊS

O suporte para o idioma nativo encontrado no sistema operacional é automático
em
no NetBeans em que o iReport foi desenvolvido. Se desejar tê-lo somente em inglês,

adicione as seguintes informações no arquivo ireport.conf, em default_options,
junto aos demais parâmetros:
D
default_options=”-J-Duser.language=en -J-Duser.country=US …”
3
ESTRUTURA DE UM RELATÓRIO E SEU
o
DESENVOLVIMENTO çã
ra
st
on
em
D
“A única hora que você não pode falhar é na última

vez que tentar”.
Charles Kettering
Capítulo 3 | 27
Um relatório é uma maneira agradável de apresentar as informações vindas de

alguma base de dados com sua aparência formatada. Na maioria das vezes, relató-
rios são usados para agrupar as informações vindas de um conjunto de dados, rela-
cionados entre si, oriundos de diversas tabelas. Como resultado você tem apenas os
campos determinados na construção do seu relatório e exposto como tal de forma
a simplificar a compreensão das informações. Vindo em um formato padronizado
para impressão, como um texto feito em um editor de textos, você só precisa man-
dar para a impressão ou exportá-los para outro formato de uso maior.
Neste capítulo você irá conhecer a estrutura de um relatório JasperReports na
ferramenta iReport para NetBeans e suas propriedades.
o
A ESTRUTURA DO RELATÓRIO
çã
Um relatório no JasperReports possui diversas seções, separadas por linhas ho-
ra
rizontais ao qual são chamadas de Bands (bandas).
O comportamento de cada Band depende da funcionalidade para a qual está pre-
st
parada. Quando o relatório se junta aos dados para rodar a impressão, estas seções
on
são impressas na tela de diferentes maneiras, com diferentes tempos. Por exemplo,
o cabeçalho da página (pageHeader) é repetido em todas as páginas, uma vez em
cada página, enquanto que os detalhes onde serão exibidos os dados (detail), é
em
gerado em uma seqüência elaborada de acordo com os dados existentes (query ou

datasource), repetindo-se uma vez para cada registro, incorporando-se ao desenho
do relatório.
D
As bands de um relatório JasperReports é dividido em dez seções pré-definidas

para que novos grupos possam ser adicionados.
Capítulo 3 | 39
• Summary on a new page - esta opção é similar a anterior (Title on a new

page), mas com a diferença de ser a banda summary que será impressa como
a última página.
• Floating column footer - as bandas columnFooter são impressas por padrão
no fim das páginas. Se na impressão do relatório não houver dados suficientes
para preencher uma página, um espaço em branco aparecerá entre a coluna e
o rodapé da coluna (columnFooter). Se você quer que o texto encontrado na
banda columnFooter seja impresso logo após a impressão da coluna, marque a
opção Floating column footer. Esta opção permite forçar a impressão da banda
columnFooter imediatamente após a última interação da banda detail e não do
término de todas as colunas. Esta opção é geralmente usada quando você quer
o
criar tabelas usando os elementos de relatórios.
çã
• Ignore pagination - ignora a paginação ao preencher o relatório, impossibi-
litando a visualização das demais páginas caso haja mais que uma. Quando
ra
ativa, esta opção implica até mesmo na visualização correta dos dados caso
haja mais de uma coluna.
st
• Print order - a ordem de impressão determina como os dados impressos na pági-

na serão organizados em mais de uma coluna. O padrão para a ordem de impres-
on
são é Vertical. Com a ordem Vertical, primeiro os dados são impressos um em-
baixo do outro, passando para uma nova coluna somente quando a coluna está
em
totalmente preenchida no final da página. Na ordem Horizontal os dados são

preenchidos em linha. Os dados passam por todas as colunas, adicionando uma
nova linha somente quando a última coluna da página foi preenchida naquela
D
determinada linha. A Figura 3.5 a seguir ilustra as duas ordens de impressão.
Figura 3.5 – Ordem de impressão na Vertical e na Horizontal

4
CRIANDO UM RELATÓRIO SEM O USO DE
o
ASSISTENTES çã
ra
st
on
em
D
“A imaginação é mais poderosa que o conhecimento. Ela

alarga a visão, estimula a inteligência, desafia o impos-
sível. Sem a imaginação, o pensamento estagnará.”
Albert Einstein
Capítulo 4 | 47
Para uma maior compreensão dos diversos elementos que compõem um relató-
rio no JasperReports, através do iReport para NetBeans, é importante a um desen-
volvedor aprender a desenhá-lo manualmente, isto é, sem o uso de assistentes.
No capítulo anterior foram apresentadas as bandas e as configurações iniciais
de um relatório em branco através de suas propriedades. Neste capítulo você irá
aprender a criar um relatório manualmente, adicionando diversos elementos, confi-
gurando-os e trabalhando com banco de dados.
INICIANDO UM RELATÓRIO MANUALMENTE

Para iniciar, crie um novo relatório. Na propriedade do relatório (selecione re-
o
port name na janela Report Inspector) dê um nome para o seu relatório. Os tama-
nhos predefinidos serão mantidos.
çã
ra
Dica: Caso queira visualizar o Grid para desenhar o relatório, vá ao menu
st
View>Report Designer Grid e clique em Show Grid.

on
A JANELA PALETTE
em
O iReport para NetBeans na lateral direita a janela Palette. Esta janela contém
doze elementos que são muito usados na construção de um relatório. Estes ditos
“elementos” são objetos gráficos que podem compor um relatório, como uma linha,
D
rótulo ou uma elipse.

A Figura 4.1 apresenta as principais ferramentas que podem ser usadas tanto
para a criação de elementos, como também para sua manipulação, em um relatório
JasperReports.
Figura 4.1 - Ferramentas para a criação de elementos no relatório

1. Break – Quebra a página a partir dele.

2. Ellipse – Desenha elipses no relatório.
3. Line – Em um relatório JasperReports uma linha é definida por um elemento
retangular com uma linha diagonal. A linha pode ser desenhada em uma reta
perfeita, na horizontal, vertical ou em ângulo se pressionada a tecla <Shift>
antes de arrastar. A linha segue o grid.
4. Static Text – Utilizado para criar rótulos de relatórios.
5. Chart – Gera um gráfico através de valores determinados transmitidos. Mais
adiante haverá um capítulo exclusivamente para gráficos.
6. Frame – Cria quadros que podem conter outros elementos em seu interior,
o
com bordas ao seu redor.
çã
7. Rectangle – Usado para desenhar retângulos ao redor de outros elementos,
criando destaques como uma formatação de parágrafo de um programa de
ra
edição de textos, este elemento pode também conter retângulos com cantos
arredondados.
st
8. Subreport – Cria um relatório dentro de outro, o que chamamos de mestre-deta-

on
lhe. Mais adiante haverá um capítulo abordando exclusivamente este assunto.

9. Crosstab – Desenvolve o que chamamos em programas de planilhas eletrô-
em
nicas de tabela dinâmica (referência cruzada), muito utilizado em relatórios

gerenciais (Business Intelligence). Mais adiante também haverá um capítulo
abordando exclusivamente este assunto.
D
10. Image – Utilizado para exibir imagens em seu relatório. Podem ser imagens
dinâmicas (preenchidas por um banco de dados, por exemplo) ou estáticas.
11. Round Rectangle – Gera o elemento rectangle, porém, com a propriedade
Radius já pré-definida com um valor.
12. Text Field – Utilizado para criar os campos dinâmicos dos relatórios. É neste
elemento que você se conecta a um determinado campo do banco de dados
para exibir suas informações, por exemplo.
Capítulo 4 | 57
Figura 4.9 – Barra de ferramentas Formatação de Texto
1. Font – Altera a fonte do texto encontrado no elemento.

2. Font Size – Altera o tamanho da fonte do texto encontrado no elemento, em
uma seleção numérica ou digitada (pressione <ENTER> para confirmar).
3. Increase Font Size – Altera o tamanho da fonte do texto encontrado no ele-
mento aumentando sempre em dois pontos (2pt).
o
çã
4. Decrease Font Size – Altera o tamanho da fonte do texto encontrado no ele-
mento diminuindo sempre em dois pontos (2pt).
ra
5. Bold – Aplica negrito ao texto encontrado no elemento.
6. Italic – Aplica itálico ao texto encontrado no elemento.
st
7. Underlined – Sublinha o texto encontrado no elemento.

on
8. Strikethrough – Desenha uma linha no meio do texto encontrado no elemen-

to (tachado).
em
9. Align Left – Alinha o texto à esquerda em relação à área do elemento.

10. Align Justify – Alinha o texto às margens esquerda e direita da área do ele-
mento.
D
11. Align Center – Alinha o texto ao centro em relação à área do elemento.

12. Align Right – Alinha o texto à direita em relação à área do elemento.
13. Align Top – Alinha o texto na parte superior vertical em relação à área do
elemento.
14. Align Vertical Axis – Alinha o texto no centro vertical em relação à área do
elemento.
15. Align Bottom – Alinha o texto à parte inferior vertical em relação à área do
elemento.
Adicionando os textos estáticos

Antes de iniciar a criação do desenho, você tem na Figura 4.10 como será o
resultado final.
o
çã
Figura 4.10 – Design final do relatório
ra
Para criar a aparência vista na Figura 4.10, os seguintes passos serão feitos:
1. Na janela Palette, clique na ferramenta Static Text e arraste um tamanho qual-
st
quer na band pageHeader.

on
2. Dê um duplo clique neste elemento desenhado e digite: Produtos Cadastrados.

Na barra de ferramentas formatação altere em Font Size para 24 e clique no
em
botão Bold. Textos estáticos são representados pelo elemento JasperReports

<staticText />. Alguns sub-elementos são comuns a todos, porém não serão
apresentados aqui.
D
<staticText>
...
<textElement>
<font
size=”24”
isBold=”true” />
</textElement>
<text><![CDATA[Produtos Cadastrados]]></text>
</staticText>
O sub-elemento <textElement />, de <staticText />, determina as configu-

rações da fonte. Todas estas configurações de fonte são feitas em <font />. Este
elemento, por sua vez, possui alguns atributos que determinam o comportamento
Capítulo 4 | 65
CRIANDO O EFEITO ZEBRA EM SEU RELATÓRIO

Embora o relatório esteja funcionando, temos um problema estético. Compare
seu atual relatório com o da Figura 4.15 mostrado a seguir. Veja que é bem mais
simples de visualizar as várias linhas encontradas no relatório quando este possui o
efeito de cores alternadas.
o
çã
ra
st
Figura 4.15 – Relatório com o efeito zebra

on
A exibição de cores de linhas alternadas, conhecido como efeito zebra, é a me-

em
lhor maneira de exibir um relatório tabular como o criado. Ajuda na rápida identifi-
cação de linhas, além do design agradável.
Na janela Report Inspector, em Styles, clique com o direito do mouse e selecio-
D
ne no menu de contexto o item Add Style.

Com o estilo criado e selecionado, vá até a janela Properties e digite Zebra em
Name.
Retornando a janela Report Inspector, clique com o direito do mouse sobre o es-
tilo Zebra e selecione no menu de contexto o item Add Conditional Style. Selecione
o item que surgirá (<No condition set>) e digite a expressão mostrada a seguir, em
Condition Expression:
new Boolean( $V{REPORT_COUNT}.intValue() % 2 == 0 )

EXIBINDO IMAGENS EM SEU RELATÓRIO

A última modificação que será feita em seu relatório manual é da adição de ima-
gens. Seu relatório ficará similar a Figura 4.17 mostrada a seguir.
o
çã
ra
st
Figura 4.17 – Imagens no relatório com dados da tabela

on
Para essa alteração, salve (Save As) com outro nome, por exemplo: Relatorio-
em
ManualComImagem. Perceba que foi retirado o elemento Frame deste exemplo.

Porém, no seu, não será necessário, caso deseje.
Apague o Text Field da imagem e o substitua pelo elemento Image. Ajuste a
D
imagem para que ela tenha a Height (Altura) de 70 e a Width (Largura) de 85, em
Properties. Ainda na janela Properties, em Image, clique no botão com três pontos
da propriedade Image Expression.
Na caixa de diálogo Image Expression, coloque entre “aspas” o caminho para o di-
retório onde se encontram as imagens que deseja exibir. Depois, concatene (em Java
é o sinal de “+”) com o campo imagem do banco de dados, que já está com o nome
de cada produto armazenado. Por exemplo, no caso do livro, as imagens estarão em
um diretório chamado de imagens, onde você deverá ter a seguinte expressão:
“imagens/”+$F{Imagem}
5
RELATÓRIOS COM GRUPOS E PASSAGEM
o
DE PARÂMETROS çã
ra
st
on
em
D
“Tudo que uma pessoa pode imaginar, outras podem tornar real.”
Júlio Verne
Capítulo 5 | 81
Os relatórios mais utilizados em aplicações, com toda certeza, são os dinâmi-

cos. Aqueles relatórios que transmitimos uma determinada informação e este nos
trazem determinados dados.
Neste capítulo você aprenderá a criar um relatório mais complexo, utilizando
mais de uma entidade (tabela) no desenvolvimento, agrupando informações e fil-
trando-as através de parâmetros.
O RELATÓRIO QUE SERÁ DESENVOLVIDO

O relatório final será composto por quatro tabelas, resultando em um grupo
formado por pedidos efetuados com seus respectivos produtos adquiridos. A Figura
o
5.1 ilustra o resultado final do relatório.
çã
ra
st
on
em
D
Figura 5.1 – Exemplo final do relatório com grupos
GERANDO O RELATÓRIO
Para começar, pegue o relatório zebrado feito no capítulo anterior. Salve como
RelatorioAgrupado. Na janela Report Inspector, clique no primeiro item da árvore
de componentes e digite em Report name, na Properties, Relatorio_Agrupado.
Apague os itens existentes e mantenha apenas os elementos das bands pageHe-
ader, columnHeader e pageFooter. Em detail mantenha apenas o Frame.
Em pageHeader altere o rótulo para Pedidos Efetuados. Quanto aos quatro rótu-
los encontrados na band columnHeader altere como mostra a Tabela 5.1 a seguir.
Veja os campos selecionados na Figura 5.3.
o
çã
ra
st
Figura 5.3 – Criando a query visualmente através do Query designer

on
Para completar a query, você deverá adicionar uma ordenação pelo código do
pedido (PedidoID). Clique com o direito no campo PedidoID, no desenho da query
em
do primeiro quadro, e selecione no menu de contexto o item add to order-by. Con-

firme a caixa de diálogo logo após.
D
Figura 5.4 – Adicionando uma ordenação através do query designer

ADICIONANDO PARÂMETROS AO RELATÓRIO

Antes de construirmos um aplicativo para chamar o relatório, você vai criar um
parâmetro para exibir um determinado pedido.
Assim como adicionar variáveis, vá até a janela Report Inspector e clique com o
direito do mouse em Parameters.
Na janela Properties digite PAR_PEDID no campo Name. Selecione java.lang.
Integer em Parameter Class. Isso significa que até o momento você terá um parâme-
tro chamado PAR_PEDID com o tipo Integer. Como precisamos testar o relatório,
você vai manter selecionado o item Use as a prompt. Isso fará com que um prompt
apareça para que você digite o código do pedido para testá-lo.
o
Existe um campo chamado Default Value Expression. É a opção padrão para
çã
o valor do prompt, caso não se lembre de nenhum código de pedido. Neste caso,
você vai adicionar o número do pedido 10248 como padrão. Por se tratar de um int,
ra
converta para java.lang.Integer, digitando neste campo o detalhe a seguir:
st
new Integer( 10248 )

on
Caso queira completar com uma descrição para o parâmetro criado, basta adi-
em
cioná-lo no campo Parameter Description como é mostrado na Figura 5.11. Esta

descrição aparecerá na caixa de diálogo que será exibida quando chamar o relatório
pelo iReport.
D
Figura 5.11 – A adição do parâmetro PAR_PEDID

6
CHAMANDO O RELATÓRIO POR UMA
o
APLICAÇÃO DESKTOP çã
ra
st
on
em
D
“A disciplina é a parte mais importante do sucesso.”

Truman Capote
Capítulo 6 | 99
Assim como criar um relatório, é muito fácil chamá-lo por uma aplicação. Este
capítulo utilizará uma aplicação desktop simples, com interface gráfica Swing, cria-
da no NetBeans IDE, apenas com o intuito de ensiná-lo a chamar sua aplicação.
A APARÊNCIA FINAL DO APLICATIVO

Para melhor compreender o exemplo deste capítulo, você tem a Figura 6.1 que
exibe a aparência final do simples aplicativo Swing que será criado. Observe que ha-
verá uma caixa de combinação e um botão. A caixa de combinação receberá valores
da tabela de pedidos para que você escolha qual pedido deseja visualizar.
o
çã
ra
st
on
em
D
Figura 6.1 – Aparência do aplicativo Swing para exibição do relatório

7
SUB-RELATÓRIOS
o
çã
ra
st
on
em
D
“Ter problemas na vida é inevitável,

ser derrotado por eles é opcional.”
Roger Crawford
Capítulo 7 | 115
Os sub-relatórios são relatórios dentro de outros, também conhecidos como

relatórios do tipo “mestre-detalhe”.
A idéia básica para a criação de um relatório mestre-detalhe é ter duas entidades
relacionadas.
Estes relatórios, embora possam parecer complexos, são simples de desenvolver
em JasperReports.
Neste capítulo você aprenderá a criar sub-relatórios em seus relatórios usando
o iReport para NetBeans e acesso a dados, conhecerá a band noData na prática e
depois o chamará através de uma aplicação Web com JSP e Servlets.
o
O RELATÓRIO MESTRE-DETALHE QUE SERÁ DESENVOLVIDO
çã
O relatório com sub-relatório, a ser desenvolvido, possui como semelhança do
Capítulo 5 sua estrutura, uma vez que fará uso das mesmas tabelas, mas em uma
ra
situação completamente diferente. Antes, você criou o relatório com agrupamento;
desta vez, será criado com um sub-relatório. A Figura 7.1 ilustra o resultado do
st
relatório com o sub-relatório que será desenvolvido.

on
em
D
Figura 7.1 – Exemplo final do relatório mestre-detalhe

DEFININDO A POSIÇÃO DOS CAMPOS

Embora não seja nada obrigatório, uma vez que o design do relatório fica por
conta de cada desenvolvedor, vamos dar a você um similar ao feito no Capítulo 5,
mas com algumas mudanças.
o
çã
ra
Figura 7.4 – A estrutura do relatório
st
A Figura 7.4 exibe como deverá ficar o formato do relatório principal. Estes ele-
on
mentos são listados a seguir, conforme é mostrado na imagem:

1. Na band pageHeader arraste um Static Text ocupando de preferência de uma
em
margem a outra da página e digite Relatório de Pedidos Efetuados. Clique

com o direito do mouse sobre o texto estático e selecione no menu de con-
texto o item Padding and borders. Na caixa de diálogo vá em Borders e se-
D
lecione na caixa abaixo, a parte superior e inferior, representando a borda

superior e inferior. Em Line width altere para 1 Point. Escolha em Line Style o
estilo desejado e a cor em Line color. Veja na Figura 7.5 como poderá ficar a
configuração final das bordas.
Capítulo 7 | 123
Ajuste seu relatório de modo a ficar com alinhamento dos valores exibidos. Como
o relatório não sofreu mudanças ainda na query, você pode executá-lo para visualizar
sua aparência. A Figura 7.8 lhe dará uma visão melhor do que pode ser feito.
o
çã
ra
st
on
Figura 7.8 – Resultado da estrutura e exibição final do sub-relatório criado

em
MODIFICANDO A QUERY DO SUB-RELATÓRIO

Para finalizar este sub-relatório, por enquanto, você vai alterar a query desenvol-
D
vida inicialmente para a geração do assistente. Esta mudança possibilitará assim a

transmissão do número do pedido, referente ao relatório mestre, ao sub-relatório.
Clique com o direito do mouse sobre o primeiro item de Report Inspector e
selecione o item Edit Query. Adicione a cláusula WHERE na sua query, como mos-
trado a seguir:
...
WHERE
PedidoID = $P{PAR_PEDIDOID}
Capítulo 7 | 131
o
Figura 7.14 – Resultado final com a adição do retorno da variável para o relatório mestre
çã
CHAMANDO O RELATÓRIO POR UMA APLICAÇÃO WEB
ra
No Capítulo 6, foi ensinado como configurar as bibliotecas do JasperReports na IDE
st
NetBeans através de uma aplicação Swing. Agora você vai criar um projeto, para a Web,
chamando o relatório desenvolvido para ser exibido em formato PDF.
on
A estrutura de sua aplicação Web

em
A seguinte estrutura demonstra a organização dos arquivos em sua aplicação

Web Java:
D
RelatoriosNaWeb/
|_ WEB-INF/
||_ lib/
|||_Arquivos JAR (JasperReports e MySQL)
||_ classes/
|||_ br/
|||_ com/
|||_ integrator/
|||_ Relatorio.class
||_ relatorios/
|||_ RelatorioMestreDetalhe.jasper
|||_ SubRelatorio.jasper
||_ web.xml
|_ index.jsp
As bibliotecas encontradas no diretório lib foram omitidas, uma vez que você
já as conhece.
Capítulo 7 | 137
o
çã
ra
st
Figura 7.16 – Relatório em PDF gerado pelo Servlet e exibido no navegador

on
CRIANDO MARCADORES PARA O RELATÓRIO EM PDF

em
Para colocar na prática o uso de Hyperlinks explicado no Capítulo 4 deste livro,

você vai criar os marcadores para o relatório, uma vez que seu resultado é composto
por muitas páginas e seria importante tê-los marcados para facilitar a navegação.
D
Iremos marcar os números dos pedidos, mas se desejar pode marcar os nomes,
embora a saída se torne repetitiva.
Clique com o direito do mouse sobre o Text Field que representa o nome do
cliente. Selecione no menu de contexto o item Hyperlink.
No campo Anchor Name Expression, utilize o Expression Editor e digite o cam-
po $F{PedidoID}.toString(). Por se tratar de um campo numérico, você deverá con-
vertê-lo para string, uma vez que esta opção só aceita este tipo. Clique no botão
Apply para confirmar.
Capítulo 7 | 139
o
çã
ra
Figura 7.18 – Destaque da utilização dos marcadores no Adobe Acrobate®
st
on
em
D
8
RELATÓRIOS COM HIBERNATE
o
çã
ra
st
on
em
D
“Na teoria, não há diferença entre

teoria e prática. Mas na prática há.”
Jan L. A. van de Snepscheut
Capítulo 8 | 143
Criar relatórios com o uso do Hibernate como camada de acesso a banco de

dados é um caso comum no desenvolvimento de aplicações Web.
O Hibernate é hoje o mais popular projeto de gerenciamento de dados persisten-
tes em Java e também o que possui uma gama de soluções para problemas comuns.
Neste capítulo você aprenderá a desenvolver seus relatórios utilizando o Hiber-
nate para acessar os dados, incluindo um exemplo com sub-relatório.
O HIBERNATE
Hibernate é um projeto audacioso que procura ter uma completa solução para
o
o problema de gerenciamento de dados persistentes em Java. O Hibernate é um
framework que se relaciona com o banco de dados, onde esse relacionamento é co-
çã
nhecido como mapeamento objeto/relacional para Java, deixando o desenvolvedor
livre para se concentrar em problemas da lógica do negócio. Sua simplicidade em
ra
configuração, dá ao desenvolvedor algumas regras para que sejam seguidas como
padrões de desenvolvimento ao escrever sua lógica de negócios e suas classes per-
st
sistentes. De resto, o Hibernate se integra suavemente ao seu sistema se comuni-

on
cando com o banco de dados como se fosse diretamente feito por sua aplicação.
Uma mudança de banco de dados, nesse caso, não se torna traumática, alterando
apenas um ou outro detalhe nas configurações do Hibernate.
em
Atenção: Este capítulo, nem mesmo o livro, tem a intenção de ensinar o uso do
D
Hibernate. Além de ser um assunto complexo, exigindo até mesmo um livro so-
mente sobre ele, o foco do livro se baseia na criação de relatórios usando o iRe-
port para NetBeans.
CRIANDO UM PROJETO USANDO HIBERNATE NO NETBEANS IDE

Diferente do que foi feito nos capítulos anteriores, desta vez você terá que pri-
meiro criar um projeto dentro do NetBeans IDE e configurar o Hibernate, mapeando
suas tabelas antes de criar um relatório no iReport.
Crie um novo projeto Web Application no NetBeans IDE. Coloque o nome de
ProjTrabComHibernate. Na última etapa, selecione o framework Hibernate 3.2.5.
Ao selecionar o item Hibernate 3.2.5, você terá disponível dois itens: Database
Connection e Database Dialect.
Execute os passos a seguir para criar uma conexão em Database Connection:
1. Selecione no menu de contexto o item New Database Connection;
o
çã
2. Na caixa de diálogo New Database Connection altere para MySQL (Connec-
tor /J driver) em Name. Preencha os demais itens conforme as configurações
feitas no seu banco de dados relatorios. Veja na Figura 8.1 como deverá ficar
ra
preenchida a caixa de diálogo. Confirme no botão OK;
st
on
em
D
Figura 8.1 – Configurações da conexão JDBC para o banco de dados relatorios no MySQL
Capítulo 8 | 145
3. Retornando a caixa de diálogo New Web Application, você terá as opções Da-
tabase Connection e Database Dialect configuradas com o dialeto do MySQL.
Confirme no botão Finish.
o
çã
ra
st
on
Figura 8.2 – Configuração completa da conexão e dialeto usado pelo projeto com o Hibernate
em
Automaticamente o NetBeans IDE adicionará as bibliotecas do Hibernate neces-

sárias para o desenvolvimento do relatório e aplicação que o utilizará.
D
AS BIBLIOTECAS DO JASPERREPORTS E MYSQL JDBC

Antes de continuar no projeto, adicione as bibliotecas do JasperReports e MyS-
QL JDBC no projeto.
CRIANDO AS ENTIDADES
Para o exemplo proposto, você terá um pacote em sua aplicação chamado de
br.com.integrator.model, que possuirá as entidades Categoria e Produto.
Fora dos pacotes, você possui os arquivos XML que mapeiam as entidades junto
ao arquivo que configura o Hibernate.
DESENVOLVENDO O RELATÓRIO
O relatório final utilizando o Hibernate será similar ao mostrado na Figura 8.5.
No caso, será feito sem o uso de assistentes.
o
çã
ra
Figura 8.5 – Resultado final do primeiro relatório com Hibernate
st
Gerando a query HQL

on
Vá até a janela Report Inspector e clique com o direito do mouse sobre o primeiro
item, selecionando no menu de contexto a opção Edit Query. Na caixa de diálogo Re-
em
port query, selecione em Query language o item Hibernate Query Language (HQL).
Digite a query para selecionar todos os campos da entidade Produto:
D
from Produto
Caso você não tenha experiência com o Hibernate, saiba que ele usa uma linguagem
própria para selecionar dados, similar às cláusulas SQL, só que simplificado. Quando é
adicionada a query from Produto, é o mesmo que dizer ao Hibernate em SQL:
SELECT * FROM produtos
De todos os objetos que surgirão, selecione categoria e unidadesEmEstoque

para excluir teclando <DELETE>. Confirme logo após.
Capítulo 8 | 165
Duas taglibs são adicionadas nesta página, uma vez que se utiliza a JSTL. A URI
do primeiro cabeçalho chama as tags CORE e o segundo cabeçalho são as tags de
formatação.
A tag <c:forEach /> varre o List enviado pelo Servlet através de requestScope,
transmitido pelo Servlet criado, ao qual repassa à página JSP.
<c:forEach var=”lista” items=”${ requestScope. categoriasList }”>
A primeira coluna terá a exibição do ID da categoria, a segunda o nome da

categoria e a terceira a descrição. Na quarta coluna, há um link ao Servlet com a
query string: id=NÚMERO DO ID DA CATEGORIA. Esse Servlet será o responsável
por exibir o relatório criado. Clicando nesse link, você submete ao Servlet o ID da
o
categoria que deseja visualizar.
çã
Por fim, crie na página índex.jsp, um link que chamará o Servlet ServletCatego-
ria, contendo por entre as tags <body/>:
ra
<a href=”ServletCategoria”>Visualizar Categorias para Relatório</a>
st
Adicione ao projeto a biblioteca JSTL, clicando com o direito do mouse em Li-

on
braries, na janela Projects, do NetBeans, selecionando o item Add Library no menu

de contexto.
em
D
Figura 8.11 – Página que chamará o Servlet que fará a geração do relatório
9
RELATÓRIOS USANDO EJB QL
o
çã
ra
st
on
em
D
“Nunca ande pelo caminho traçado, pois ele

conduz somente até onde os outros foram.”
Alexandre Graham Bell
Capítulo 9 | 171
O uso de Java Persistence API se tornou muito intenso, e como não poderia
deixar de ser, o JasperReports possui suporte a esta especificação através de EJB QL.
Esta linguagem de queries possui uma semelhança à HQL do Hibernate e também a
tradicional instrução SQL.
Com a especificação do EJB3, na introdução da JPA, Java Persistence API, ficou
muito popular o uso de JPQL, Java Persistence Query Language, que é uma é uma
extensão da EJB QL (Enterprise JavaBeans Query Language).
Neste capítulo você vai aprender a configurar um arquivo de persistência e criar
um relatório com sub-relatório utilizando a EJB QL.
o
O CONCEITO DA API DE PERSISTÊNCIA
çã
Até a versão J2EE 1.4, a plataforma Java não possuía uma forma simples de ma-
pear objetos em um banco de dados. Uma forma mais complexa podia ser utilizada,
ra
exigindo um container EJB, utilizando EJB QL (que foi introduzida como parte da es-
pecificação EJB2.0). Com a introdução de JPA (Java Persistence API), definida na JSR-
st
220 (Enterprise JavaBeans, Version 3.0), houve uma padronização no mapeamento

on
de objeto/relacional na plataforma Java. No EJB3, as sentenças são expressas através

da JPQL (Java Persistence Query Language). A JPQL é uma extensão da EJB QL, como
já foi dito na introdução deste capítulo.
em
Apesar de descrita na especificação do EJB 3, a JPA não depende de um container

para funcionar, sendo possível usar e testar soluções apenas com o Java SE.
D
A JPA é baseada no conceito POJO (Plain Old Java Object), algo como “Bom e
Velho Objeto Java”, que incorpora idéias de renomados frameworks de persistência
para padronizar o mapeamento O/R em Java.
Na JPA, os objetos persistentes são denominados entidades (Entities). Uma entidade
é um objeto simples (POJO), que representa um conjunto de dados persistido no banco.
Como entidades são definidas por classes Java comuns, sem relação com frameworks
ou bibliotecas, elas podem ser abstratas ou herdar de outras classes, sem restrições.
A chave primária, indicada como um conceito importante nas entidades, possui
uma identificação e estado, sendo seu ciclo de vida independente do tempo de
duração da aplicação.
Capítulo 9 | 175
Retornando a caixa de diálogo New Entity Classes from Database, altere os no-
mes de Class Name para o singular, mantendo o padrão de nomes de entidades.
Em Package digite o nome do pacote em que estas entidades serão colocadas. No
livro foi usado br.com.integrator.entities. Veja a Figura 9.4 para melhor compreensão.
o
çã
ra
st
on
Figura 9.4 – Alteração do nome das entidades e criação do pacote

em
Na quarta e última etapa, em Mapping Options, altere para lazy, em Association

D
Fetch e java.util.Set, em Collection Type. Clique no botão Finish.

Observe que o NetBeans criará duas classes (em Source Packages) e o arquivo
persistence.xml, em Configuration Files.
A entidade Categoria
A entidade Categoria, criada pelo NetBeans, já possui todas as anotações neces-
sárias para o reconhecimento no iReport. Para sua melhor compreensão, temos a
Listagem 9.1 mostrando como ela pode estar:
Capítulo 9 | 183
Na segunda etapa, digite o nome de sua conexão, no campo Name e, no campo

Persistence Unit Name, o nome dado em seu arquivo de persistência (no caso foi
relatorios). Clique no botão Test e caso a conexão tenha sido bem sucedida, con-
firme e Salve.
o
çã
ra
st
on
Figura 9.5 – Criando e testando a conexão EJBQL

em
Esta conexão é armazenada no arquivo ireport.properties do iReport para Ne-

tBeans (diretório .ireport) e utiliza a classe it.businesslogic.ireport.connection.
EJBQLConnection.
D
O relatório que será criado é com sub-relatório. Infelizmente o iReport para
NetBeans não suporta o uso de assistente para criar o sub-relatório. Portanto você
deverá criar os dois relatórios manualmente e depois chamar o sub-relatório, atra-
vés da ferramenta subreport.
Capítulo 9 | 185
Nota: O livro não se aprofundará neste assunto, uma vez que está focado no de-
senvolvimento de relatórios JasperReports com o uso do iReport para NetBeans.
De todos os objetos que surgirão, selecione class e produtos (na parte inferior,
em Field name) e tecle <DELETE>. Confirme logo após.
o
çã
ra
st
on
em
Figura 9.7 – A query EJBQL para selecionar os itens da entidade Categoria
A composição final do relatório mestre

D
Apenas para que você possa examinar, seu relatório mestre, quando executado,
poderá ser semelhante ao mostrado na Figura 9.8 mostrada a seguir.
Capítulo 9 | 187
Gerando a query EJBQL do sub-relatório

Execute o Report Query. Na caixa de diálogo Report query, selecione em Query
language o item EJBQL.
Digite a query para selecionar todos os campos da entidade Produto, com a
condição estabelecida por categoriaID, filtrando com o parâmetro recém criado
PAR_CATID, como mostrado a seguir:
SELECT p FROM Produto p JOIN p.categoria c

WHERE c.categoriaID = $P{PAR_CATID}
o
A Figura 9.9 a seguir mostra o resultado final da query escrita no Report query.
çã
ra
st
on
em
D
Figura 9.9 – A query criada para o sub-relatório
O design final do sub-relatório

Quanto aos campos, apenas o Nome do Produto (produtoNome), o Preço (pre-
co) e Quantidade em Estoque (unidadesEmEstoque) serão exibidos. A Figura 9.10 a
seguir ilustra o design final.
SELECIONANDO APENAS ALGUNS OBJETOS COM EJB QL

No caso de precisar de apenas alguns objetos retornados pelo EJB QL, você não
pode utilizar a criação de “apelidos” nos campos retornados. Uma instrução como
a mostrada a seguir:
select c.nome,
p.pedidoID,
p.dataPedido
from Pedido p join p.cliente c
Retorna três campos/colunas, que são nomeados pelo iReport para NetBeans como
COLUMN_x, onde x é o número da coluna/objeto na ordem existente na instrução.
o
çã
ra
st
on
em
D
Figura 9.13 – Uma query com apenas alguns objetos/valores

10
GERANDO RELATÓRIOS COM OUTRAS
o
çã
FONTES DE DADOS
ra
st
on
em
D
“Nunca ande pelo caminho traçado, pois ele

conduz somente até onde os outros foram.”
Alexandre Graham Bell
Capítulo 10 | 199
O JasperReports é rico no fornecimento de outras fontes de dados acessíveis

para que possamos gerar relatórios.
Muitos sistemas costumam exportar diversos tipos de dados, sendo os mais
comuns o formato CSV e XML.
Este capítulo tratará de outras formas de acesso que não utilizam um banco de
dados diretamente.
USANDO XML PARA CRIAR RELATÓRIOS

Atualmente o XML (EXtensible Markup Language) é praticamente um padrão no
o
desenvolvimento interoperativo de sistemas. Com a popularidade dos Web Servi-
ces em 2004, a linguagem XML fincou sua bandeira na transmissão de dados. Isso
çã
significa que diversos sistemas e gerenciadores de banco de dados exportam neste
formato. Por ser uma linguagem extensível, seu formato tem como característica
ra
principal sua semelhança em tags e atributos como o HTML (HyperText Markup
Language). Mas a semelhança para por ai, pois o XML não contém tags pré-defini-
st
das, possibilitando que cada fornecedor crie suas próprias tags. Mas graças a sua
on
semântica de não poder conter tags desordenadas, sua leitura é de fácil acesso.
O iReport suporta o uso de XML como datasource desde a versão 0.4.0, graças
ao suporte do JasperReports.
em
CRIANDO UM RELATÓRIO COM XML

D
Para a criação de um relatório usando XML, você tem o seguinte formato encon-
trado em um arquivo chamado produtos.xml, como mostrado na Listagem 10.1.
Listagem 10.1 – O arquivo produtos.xml

<?xml version=”1.0” encoding=”UTF-8”?>
<produtos>
<produto id=”1”>
<nome>Chopp e Pêssego DRAFT & FRUIT</nome>
<categoria>1</categoria>
<preco>1.99</preco>
<qdtEmEstoque>39</qdtEmEstoque>
<imagem>chopp_pessego.jpg</imagem>
</produto>
<produto id=”2”>
Expanda o nó de produtos e, em produto, clique com o direito do mouse. Sele-

cione Set record node (generate xPath), no menu de contexto (Figura 10.2). Obser-
ve que foi adicionada a expressão XPath:
/produtos/produto
o
çã
ra
st
on
em
Figura 10.2 – Adicionando o nó de pesquisa através do XPath
O que é XPath?
D
O XPath (XML Path Language) é uma linguagem de consulta usada para pesquisar
e recuperar informações contidas nos nós de um documento XML. As consultas
do XPath são formadas como expressões e são usadas para se referir às várias
partes de um documento XML. Esta linguagem exibe um documento XML como
uma árvore com tipos de nós diferentes. Suas expressões identificam esses nós
no documento XML com base no seu tipo, nome e valores, bem como a relação
de um nó com outros nós do documento.
Para definir os campos, clique com o direito do mouse sobre cada elemento e
selecione, no menu de contexto, o item Add node as field (Figura 10.3).
o
çã
Figura 10.5 – Definindo as características do arquivo CSV
ra
st
REGISTRANDO OS CAMPOS DE UM ARQUIVO CSV

on
No Report query, você possui a guia CSV Datasource. Basta clicar no botão Get
fields from datasource. Os campos aparecem na parte inferior. Como ocorre com o
arquivo XML, você pode definir a mudança de um tipo pois o iReport registra todos
em
como java.lang.String.
D
Figura 10.6 – Definindo os campos de um arquivo CSV

11
SIMPLIFICANDO RELATÓRIOS COM
o
çã
GROOVY
ra
st
on
em
D
“O duro e rijo quebra. O

flexível prepondera.”
Tao Te Ching
Capítulo 11 | 221
Groovy é uma linguagem dinâmica escrita para a plataforma Java, inspirada em

linguagens como Ruby, Python e Smalltalk. Embora seja simples de manipular e mui-
to similar as linguagens de scripting, Groovy é um pouco mais complexo. Aplicações
com Groovy podem ser pré-compiladas em bytecodes Java, para ser integrada à suas
aplicações Java.
Graças a um Java Specification Request (JSR-241), Groovy se tornou a segunda
linguagem oficial padrão do Java Virtual Machine (JVM), depois de Java, claro.
Desde a versão 0.6.6 do JasperReports, há suporte a linguagem Groovy. Com
isso, quem ganha é o desenvolvedor, que tem em suas mãos uma maior simplicida-
de no desenvolvimento de expressões em seus relatórios.
o
Neste capítulo você vai construir um relatório utilizando Groovy, trabalhando
com expressões e aprenderá como rodar o relatório criado em suas aplicações tam-
bém usando Groovy.
çã
ra
CRIANDO UM RELATÓRIO USANDO GROOVY
st
Crie um relatório e, selecionando na janela Report Inspector, o nome do relató-

on
rio, vá até a propriedade (janela Properties) Language e selecione o item Groovy.

Graças a esta pequena mudança, você já valerá do uso de Groovy em seu rela-
em
tório.
O iReport para NetBeans possui em seu diretório de instalação, em modules/
ext, o arquivo groovy-all-1.5.5.jar.
D
O arquivo JasperReports usando Groovy

No arquivo JasperReports aberto, em XML, você possui no elemento raíz <jas-
perReport/> o atributo language, com o valor groovy.
<jasperReport
language=”groovy”
...
INICIANDO O DESENVOLVIMENTO DO RELATÓRIO

Mantenha apenas as bands Page Header, Column Header, detail e Page Footer.
Deixe a conexão como sendo a de SQL.
12
CRIANDO GRÁFICOS E SUBDATASET EM
o
SEUS RELATÓRIOS çã
ra
st
on
em
D
“Uma imagem vale por mil palavras.”

Provérbio Chinês
“Um bom esboço vale mais que um longo discurso.”

Napoleão Bonaparte
Capítulo 12 | 233
Como todo bom relatório, não poderia faltar os gráficos. Simples e eficazes, os
gráficos exibem uma situação visualmente impactante, possibilitando um entendi-
mento muito maior, mais rico, do que apenas números e textos.
O JasperReports possui suporte a geração de gráficos, facilitando o desenvolvi-
mento do relatório, através da biblioteca JFreeChart.
Neste capítulo será apresentado como criar gráficos em um relatório JasperRe-
ports usando o iReport para NetBeans, além de aprender a trabalhar com consultas
diferentes no mesmo relatório, o que chamamos de Subdataset.
CRIANDO UM GRÁFICO SIMPLES
o
O primeiro exemplo na geração de relatórios com gráficos um gráfico no forma-
çã
to de pizza 3D (Pie 3D). A Figura 12.1 a seguir ilustra o resultado final.
ra
st
on
em
D
Figura 12.1 – Relatório gerado completo

Capítulo 12 | 243
Como o gráfico é de barras, você terá como categorias os nomes dos clientes
e os valores o total encontrado das compras efetuadas por cada um no respectivo
período. Observe que Series expression é o mesmo que Value axis label expression.
Confirme tudo e dê um Preview.
o
çã
ra
st
on
Figura 12.6 – Resultado final do relatório utilizando um tema padrão do iReport

em
D
GRÁFICOS DE LINHAS
Por último, o relatório que será criado utilizará um gráfico de linhas para repre-
sentar a demanda de vendas 4 de um determinado produto. A Figura 12.7 demons-
tra o resultado do relatório final.
o
çã
ra
st
on
em
D
Figura 12.7 – Resultado final do relatório utilizando um gráfico de linhas
4
Baseado no livro Excel Avançado 2003/2007 Forecast – Análise de Previsão de Demanda (veja bibliografia)
13
INTERNACIONALIZANDO RELATÓRIOS
o
çã
ra
st
on
em
D
“Informação é a matéria prima mais

importante da humanidade.”
Waldez Ludwig
Capítulo 13 | 251
Aplicações internacionalizadas são muito comuns no mundo do desenvolvimen-

to. Não seria diferente no caso dos relatórios. O JasperReports introduziu esta ca-
racterística na versão 0.6.2 e desde então seu suporte foi acrescentado ao iReport,
facilitando mais ainda seu desenvolvimento.
Neste capítulo será criada uma aplicação Java desktop simples, pelo NetBeans,
para ser usada com um relatório internacionalizado gerado pelo iReport.
CRIANDO SEU RELATÓRIO INTERNACIONALIZADO

Para ilustrar o seu desenvolvimento crie um projeto Java no NetBeans IDE, onde
há também instalado o plugin do iReport.
o
Em seu projeto, crie um pacote, se não o tiver feito ao criar a classe Main, cli-
çã
cando com o direito do mouse sobre Source Packages e selecionando no menu de
contexto o item New>Java Package. Se preferir seguir o exemplo do livro, digite
ra
br.com.integrator no campo Package Name, da caixa de diálogo New Java Package.
A internacionalização da aplicação exigirá a geração de um arquivo .properties.
st
Crie um novo arquivo, clicando com o direito do mouse sobre o pacote br.com.in-
on
tegrator (ou o gerado por você). No menu de contexto, selecione New>Other. Na

caixa de diálogo New File, selecione Other>Properties File.
em
Ao avançar no assistente, digite rotulos (sem acento) e clique no botão Finish

para confirmar.
D
Atenção: Adicione as bibliotecas do JasperReports e do JDBC do banco de dados

MySQL.
Adicionando as chaves e valores do arquivo

O NetBeans exibirá em seu editor o arquivo recém criado. Altere-o como mostra-
do a seguir, na Listagem 13.1, e salve clicando no botão Save.
14
CROSSTABS
o
çã
ra
st
on
em
D
Fazendo o melhor neste momento o colo-

ca na melhor situação para o próximo.”
Oprah Winfrey
Capítulo 14 | 259
Crosstabs (cross-tabulation), no JasperReports, são tabelas cruzadas, comuns no

desenvolvimento de relatórios com a utilização de planilhas eletrônicas, também
conhecidas por tabelas dinâmicas ou tabelas de referências cruzada.
Diferente dos demais relatórios criados até o momento no livro, um relatório
crosstab possui uma tabela contendo um número de linhas e colunas que não se
conhece em tempo de design.
Graças ao iReport, você pode contar com o uso de um assistente, tornando esta
tarefa não muito complicada.
Neste capítulo você aprenderá a criar crosstabs no iReport, modificar, formatar
e usar também subdatasets para relatórios mais complexos.
o
çã
CRIANDO SEU PRIMEIRO RELATÓRIO CROSSTAB
O design não necessitará da maioria das bands, uma vez que apenas a band
ra
Summary será usada neste primeiro exemplo.
st
Crie um novo relatório, sem o uso do assistente.

on
Criando a query
em
Em seu relatório, crie uma query contendo apenas o nome do cliente (clientes.
nome), o código do pedido (pedidos.PedidoID) e a data do pedido (pedidos.data-
Pedido).
D
Sua query será similar a mostrada a seguir:
SELECT
clientes.nome,
pedidos.dataPedido,
pedidos.PedidoID
FROM
clientes INNER JOIN pedidos
ON clientes.ClienteID = pedidos.ClienteID
Como a tabela criada tem uma área exclusiva, também não poderia deixar de
possuir características próprias para sua manipulação.
1. Na janela Report Inspector é possível visualizar os parâmetros, grupos, mea-
sures e demais itens que compõem a crosstab gerada.
2. No Designer da crosstab, podemos alterar a largura, altura, formatação de
cada componente selecionando-o e modificando-o através da janela Properties.
3. Na janela Properties há um pequeno conjunto de propriedades próprias para
o elemento crosstab.
Se você executar o relatório, em Preview, observará melhor sua disposição,
como mostrada na Figura 14.4.
o
Na parte superior haverá os anos em que cada cliente efetuou sua compra e na la-
çã
teral seus respectivos nomes. Os dados agrupados, contam o número de pedidos efe-
tuados em cada ano. Ao final, você possui o total de pedidos efetuados por cliente.
ra
st
on
em
D
Figura 14.4 – Relatório Crosstab (agrupado por clientes e pedidos por ano)
Capítulo 14 | 267
Arraste PedidoIDMeasure para Detail /Mes, expandindo Measures na janela Report

Inspector. Formate com cor de fundo para a célula, alinhamentos de texto e alterações
de borda. Na célula Mestotal header, adicione um elemento Static Text e digite Total.
Na última linha, desta coluna, adicione na célula que resta a measure da janela
Report Inspector chamada de PedidoIDMeasure. Esta variável irá contar o período
de todos os meses do ano e o adicionará no relatório. Como os demais, formate.
o
çã
Figura 14.9 – Resultado final do exemplo desenvolvido
ra
st
Ao executar o relatório, você terá um resultado similar ao mostrado na Figura

14.10 a seguir:
on
em
D
Figura 14.10 – Resultado final na execução do relatório

Capítulo 14 | 269
CRIANDO UMA CROSSTAB COM SUBDATASET

Vamos partir da hipótese que você deseja visualizar um relatório contendo as com-
pras efetuadas por cada cliente, agrupados por produto, como mostra a Figura 14.11.
o
çã
ra
st
on
em
D
Figura 14.11 – Relatório contendo Crosstab e Subdataset
Crie um novo relatório e mantenha apenas as bands: Title, Page Header, Detail
e Page Footer.
Os elementos que serão adicionados são: Static Texts e Text Fields. Apenas os
detalhes necessários para criar o assunto deste tópico serão apresentados.
Aos demais, a Figura 14.12 mostra o resultado final do design do seu relatório.
15
OUTRAS CARACTERÍSTICAS DA GERAÇÃO
o
DE RELATÓRIOSçã
ra
st
on
em
D
“Nós somos o que repetidamente fazemos. Exce-

lência, então, não é um ato, mas um hábito.”
Aristóteles
Capítulo 15 | 277
Neste capítulo você conhecerá outras características da ferramenta iReport,

além do JasperReports, que não foram apresentadas até o momento, sendo passa-
das como dicas.
TRATANDO RELATÓRIOS GRANDES

O virtualizador de relatórios é uma forma de minimizar a criação de relatórios
JasperReports grandes. Esta opção ajuda a minimizar a limitação física, economizan-
do na memória usada e empregando outras formas avaliadas (geralmente o disco rí-
gido) para salvar páginas completas durante a impressão de um relatório. Isso evita
que relatórios grandes recebam a mensagem de exceção “Out of Memory”.
o
Para configurar o Report Virtualizer, vá ao menu Tools e clique em Options. Na
çã
guia Virtualizer, você possui o grupo Report Virtualizer. Em Use this virtualizer
você possui três opções que estão destinadas a configuração de três tipos de virtua-
ra
lizadores fornecidos pelo JasperReports (iReport): JRFileVirtualizer (File Virtualizer),
JRSwapFileVirtualizer (Single Swap/File Virtualizer) e JRGzipVirtualizer.JRFileVirtu-
st
alizer (GZIP In-memory Virtualizer).

on
em
D
Figura 15.1 – Onde configurar a virtualização de relatórios grandes no iReport

16
SCRIPTLET
o
çã
ra
st
on
em
D
“Mude seu modo de pensar e você mudará seu mundo.”

Norman Vincent Peale
Capítulo 16 | 289
Um scriptlet é uma classe Java desenvolvida unicamente para executar durante

a geração da impressão do relatório na tela. O scriptlet possui métodos que são
invocados na geração de relatórios possibilitando manipulá-los, como a ocorrência
da criação de uma nova página ou o acesso a um determinado parâmetro.
Neste capítulo será visto como escrever um simples scriptlet, qual a sua utilida-
de e como usá-lo em seu relatório.
A CLASSE JRABSTRACTSCRIPTLET
Para implementar um scriptlet em seus relatórios, primeiro você deve criar uma
classe estendendo a classe JRAbstractScriptlet, de net.sf.jasperreports.engine. Esta
o
classe expõe todos os métodos abstratos que manipulam os eventos que ocorrem
çã
durante a geração de um relatório e fornece estrutura de dados para acessar todas
as variáveis, campos e parâmetros presentes no relatório.
ra
O JasperReports fornece uma implementação bem simples através da classe JR-
DefaultScriptlet (veja a Listagem 16.1), estendendo a classe abstrata JRAbstractS-
st
criptlet.
on
Listagem 16.1 – A classe JRDefaultScriptlet

em
package net.sf.jasperreports.engine;
/**
* @author Teodor Danciu (teodord@users.sourceforge.net)
* @version $Id: JRDefaultScriptlet.java,v 1.3 2004/06/01 20:28:22 teodord Exp $
D
*/
public class JRDefaultScriptlet extends JRAbstractScriptlet
{
public JRDefaultScriptlet() { }
public void beforeReportInit() throws JRScriptletException
{
}
public void afterReportInit() throws JRScriptletException
{
}
public void beforePageInit() throws JRScriptletException
{
}
public void afterPageInit() throws JRScriptletException
{
}
public void beforeColumnInit() throws JRScriptletException
{
Conforme o já visto no Capítulo 10, podemos trabalhar diretamente com arqui-
vos CSV, simplesmente informando o arquivo e sua estrutura para a leitura.
O relatório proposto possui o design tabular, conforme a Figura 16.2 ilustra
após executado.
o
çã
ra
st
Figura 16.2 – Preview do relatório criado usando CSV e Scriptlet

on
Portanto, dentro do seu projeto no NetBeans IDE, no mesmo pacote criado, gere
em
um novo relatório sem o uso de assistentes.

D
A CONEXÃO COM O ARQUIVO CSV

Para preparar o relatório, inicialmente, você terá que ler o Scriptlet e também
o arquivo CSV.
O arquivo CSV, chamado de pedidos.csv, se encontra nos arquivos que você já
fez download, no diretório arquivos/csv.
Crie uma conexão CSV, conforme ilustrado no Capítulo 10, onde, na guia Se-
parators, você deverá marcar Semicolon em Field separator (char) e, New line, em
Row separator.
Capítulo 16 | 301
COMO EVITAR VALORES REPETIDOS EM UM RELATÓRIO

Como dica, caso queira evitar valores repetidos no relatório, como ocorre na co-
luna Produto, você pode selecionar o Text Field, no Designer, e desmarcar a opção
Print Repeated Values.
o
çã
ra
st
on
Figura 16.6 – Relatório exibindo dados sem campos repetidos

em
No JasperReports, você verá o elemento <reportElement /> com a propriedade

D
isPrintRepeatedValues contendo o valor false (o padrão é true).
<textField ...>
<reportElement isPrintRepeatedValues=”false” ...>
...
</reportElement>
</textField>
FORÇANDO O VALOR A APARECER AO MENOS UMA VEZ EM CADA PÁGINA

Se colocarmos um determinado campo para não repetir valores, logo percebe-
remos um problema, se este campo estiver em uma segunda página, não teremos
como saber de qual se trata sem olhar a página anterior (ou anteriores).
Para evitar isso, basta forçar sua impressão na primeira vez que a band for usada
na página. Nas propriedades, marque Print In First Whole Band.
17
DESENVOLVENDO SEUS PRÓPRIOS
o
TEMPLATES çã
ra
st
on
em
D
“Nossa maior fraqueza está em desistir. O caminho mais seguro para o

sucesso é sempre tentar apenas uma vez mais.”
Thomas Edison
Capítulo 17 | 305
Quando usamos um assistente de criação de relatórios, na última etapa fazemos

uso de templates. Algumas vezes pode ser útil criar um ou vários templates para
usar no assistente.
Neste Capítulo você vai aprender a criar seus próprios templates e utilizá-los no
iReport.
CRIANDO UM RELATÓRIO MODELO

Para a geração de um template é necessário apenas criar um relatório vazio, sem
dados, usando no máximo quatro grupos.
o
Na criação do relatório base, que servirá como template, você deve estar atento
ao detalhe do nome do arquivo/relatório. Este nome deve terminar com C de Colu-
çã
mnar ou com T de Tabular. É assim que o iReport diferenciará o template colunar ou
tabular na opção de layout do seu assistente de criação de relatório.
ra
No exemplo, o Template mostrado na Figura 17.1 utiliza um formato colunar,
o que o fez ser chamado de TemplateExemploC.jrxml, onde você pode observar o
st
término do nome do arquivo com “C” maiúsculo.

on
Para começar, mantenha apenas as bands: Title, Detail e PageFooter.

Na band Title adicione um Static Text e coloque o texto Template de Exemplo.
em
Altere sua cor de fundo e fonte se achar necessário.

D
Figura 17.1 – Template criado para o exemplo deste capítulo

Capítulo 17 | 309
o
çã
ra
st
Figura 17.3 – Resultado final do template e seu preview no assistente de relatório

on
em
D
APÊNDICE
EXPORTANDO PARA OUTROS FORMATOS
o
çã
ra
st
on
em
D

Desenvolvendo Relatorios Pro Fission A Is Com Ireport para Netbeans IDE

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Desenvolvendo Relatorios Pro Fission A Is Com Ireport para Netbeans IDE

Enviado por

Direitos autorais:

Formatos disponíveis

Edson Gonçalves

filho do Ângelo e de sua esposa Erica,

grandes amigos e agora pais.

Agradeço o apoio da Editora Ciência Moderna, em especial ao editor Pau-

Um agradecimento especial ao JUG Leader e Founding Java Champion,

Embora o iReport permaneça com sua estrutura, praticamente inalterada, hou-

O JasperReports é uma biblioteca escrita em Java, de código fonte open source,

Embora o JasperReports tenha simplificado o desenvolvimento de relatórios, o

Em 09 de outubro de 2002, o italiano Giulio Toffoli lançou, de forma indepen-

característica era de desenvolver relatórios gerando o formato XML no padrão Jas-

Em 2005, com a popularidade do iReport, a JasperSoft (empresa mantenedora

O leitor também aprenderá a chamar seus relatórios através de aplicações

QUEM DEVE LER ESTE LIVRO?

duzido, focado no assunto em questão, possuindo uma simbologia indicativa de

Esse livro não está focado especialmente em um sistema operacional, portanto

Processador: Pentium 4 (similar) ou superior

Memória: 512 MB de RAM mínimo (recomendo 2 GB de RAM no uso do NetBe-

Todos os códigos dos exemplos criados se encontram no site do autor: http://

VISÃO GERAL DOS CAPÍTULOS

O livro é completamente ilustrado, possuindo dezenas de figuras espalhadas ao

CAPÍTULO 1 - CONHECENDO O IREPORT PARA NETBEANS IDE

mente os mais complexos relatórios para aplicações Java no formato da biblioteca

Através de uma interface gráfica intuitiva, o desenvolvedor é capaz de criar qual-

Neste capítulo você aprenderá onde obter, os requerimentos necessários para

CAPÍTULO 2 - INICIANDO NO IREPORT PARA NETBEANS

Embora o primordial de iReport seja de desenhar relatórios, existem também

Este capítulo o introduzirá ao desenvolvimento básico de relatórios usando o

a simplificar a compreensão das informações. Vindo em um formato padronizado

Neste capítulo você irá conhecer a estrutura de um relatório JasperReports na

CAPÍTULO 4 - CRIANDO UM RELATÓRIO SEM O USO DE

Neste capítulo você irá aprender a criar um relatório manualmente, adicionando

CAPÍTULO 5 - GERANDO RELATÓRIOS COM GRUPOS E

CAPÍTULO 6 - CHAMANDO O RELATÓRIO POR UMA

A idéia básica para a criação de um relatório mestre-detalhe é ter duas entidades

Estes relatórios, embora possam parecer complexos, são simples de desenvolver

Neste capítulo você aprenderá a criar sub-relatórios em seus relatórios usando

CAPÍTULO 8 - RELATÓRIOS COM HIBERNATE

O Hibernate é hoje o mais popular projeto de gerenciamento de dados per-

CAPÍTULO 9 - RELATÓRIOS USANDO EJB QL

Com a especificação do EJB3, na introdução da JPA, Java Persistence API, ficou

Neste capítulo você vai aprender a configurar um arquivo de persistência e criar

CAPÍTULO 10 - GERANDO RELATÓRIOS COM OUTRAS

Muitos sistemas costumam exportar diversos tipos de dados, sendo os mais

Groovy é uma linguagem dinâmica escrita para a plataforma Java, inspirada em

to similar as linguagens de scripting, Groovy é um pouco mais complexo. Aplicações

Graças a um Java Specification Request (JSR-241), Groovy se tornou a segunda

Desde a versão 0.6.6 do JasperReports, há suporte a linguagem Groovy. Com

Neste capítulo você vai construir um relatório utilizando Groovy, trabalhando

CAPÍTULO 12 - CRIANDO GRÁFICOS E SUBDATASET EM

O JasperReports possui suporte a geração de gráficos, facilitando o desenvolvi-

Neste capítulo será apresentado como criar gráficos em um relatório JasperRe-

Aplicações internacionalizadas são muito comuns no mundo do desenvolvimen-

Diferente dos demais relatórios criados até o momento no livro, um relatório

Neste capítulo você aprenderá a criar crosstabs no iReport, modificar, formatar

CAPÍTULO 15 - OUTRAS CARACTERÍSTICAS DA GERAÇÃO

Um scriptlet é uma classe Java desenvolvida unicamente para executar durante

invocados na geração de relatórios possibilitando manipulá-los, como a ocorrência

de e como usá-lo em seu relatório.

CAPÍTULO 17 - DESENVOLVENDO SEUS PRÓPRIOS

APÊNDICE A - EXPORTANDO PARA OUTROS FORMATOS

PARA DOWNLOAD: APÊNDICES B, C, D E E

APÊNDICE C – CONTEXTO DE DESENVOLVIMENTO WEB

APÊNDICE D – TRABALHANDO COM DATAS EM JAVA