JasperReports教程

原创 yBmZlQzJ 2023-03-28

3799

JasperReports教程

Jasper报表是一个开源的Java报表引擎，是基于Java的，它没有自己的表达式语法。

由于JasperReports是一个Java类库，而不是针对最终用户，而是有针对那些需要报表功能添加到自己的应用程序的Java开发人员。

读者

本教程为Java开发那些愿意充实自己的报表技术而编制。完成本教程后，对JasperReports熟悉程序达到中等水平。

前提条件

在继续本教程，应该对Java编程语言的一个很好的理解。还需要对Apache Ant的基本理解，因为所有的例子都被编译和执行中使用ANT。

1 - Java教程

如果想学习JAVA入门，推荐以下教程

Java教程

2 - ANT教程

如果想使用Apache Ant，那么可以通过以教程学习。

ANT教程

JasperReports入门，JasperReports是什么？ - JasperReports教程

什么是报表

报表是从数据库中的数据有意义和良好汇总信息。通常情况下，日常活动是自动化和数据汇总到一个决策支持的格式“报告”。报表作为奇迹，当一般的杂乱数据转换成迷人的图表，图形和其他图形表示转换。

报表模板

一般有以下报表布局之后是许多商业报告生成工具来生成报告。

Report Template

以下是图中提到的每个元件的描述。

元素	描述
title	标题包含该报告的标题。它只会出现一次，在报告的一开始，例如，“Yiibai教程报告”。
pageHeader	PageHeader可能包含日期和时间的信息和/或组织的名称。这出现在每个页面的顶部。
columnHeader	ColumnHeader列出了要在报表中显示，例如，“作者姓名”，“启动时间”，“完成时间”具体字段，“工作时间”和“日期”等的名称。
detail	详细信息在这里显示的特定字段（在的columnHeader列表）条目，例如部分"Manisha", "9:00", "18:00", "9", "10.02.2013".
columnFooter	ColumnFooter可以显示的任何字段的总和，例如，"Total Hours Worked: 180"
pageFooter	PageFooter可能包含页面计数信息。它出现在每个页面的底部，例如，"1/23".
summary	摘要包含从“细节”部分推断出的信息，例如，工作小时为每个作者的数量列表，总工时为每个作者可以把视力表像饼图，曲线图等，为更好的比较。

Jasper报表

报表开发过程中面临的常见故障归纳在以下几点：

核心变化：为了反映业务发生变化或改进它通常以改变报告的核心逻辑。
结果输出：有各种各样的格式，报表可导出到如：HTML，文本，PDF，MS Excel，RTF，ODT，逗号分隔值，XML或图像。
复杂报表：子报表和交叉表报告是很好的例子。
图表报表：视觉图为例。图，饼图，XY折线图，条形图，仪表和时间序列

为了消除上述点的开销，并促进报告过程中，很多框架，工具，库和第三方应用进行了介绍。Jasper Report 报表是其中之一。

Jasper Report 是一个开源的Java报表引擎，它不像其他的报表工具，例如Crystal报表是基于Java的，没有自己的表达式语法。JasperReports有提供丰富的内容到屏幕上，到打印机，或转换成PDF，HTML，XLS，RTF，ODT，CSV，TXT和XML文件的能力。因为它不是一个独立的工具，它不能被安装在其自身。相反，它是由包括它在应用程序的CLASSPATH库嵌入到Java应用程序。

JasperReports是一个Java类库，而不是针对最终用户，而是有针对性的对谁需要的报表功能添加到自己的应用程序的Java开发人员。

JasperReports的特点

一些主要的 JasperReport 的功能包括：

具有灵活的报表布局。
它可以用文字或图形显示数据。
开发人员可以通过多种方式提供数据。
它可以接受来自多个数据源的数据。
它可以生成水印（水印是这样的方式被放置在主图像的副图像）
它可以生成子报表。
它能够导出报表到多种格式的。

JasperReport环境设置 - JasperReports教程

JasperReport是一个纯Java库，而不是一个独立的应用程序。它不能单独运行，因此它需要被嵌入到另一个客户端或服务器端的Java应用程序。因为它是基于Java，它可以在任何支持Java的平台（JDK1.3及以上）上运行。所有JasperReports的功能是聚集在一个JAR文件中，一般名称为：jasperreports-x.x.x.jar。JasperReport库链接：这个JAR文件必需及可选库（压缩文件）可以从网站上下载。下载最新的版本。

ZIP文件包含JasperReports源代码，相关JAR和大量的实例演示JasperReport功能以及JasperReportsJAR文件。

JasperReport环境配置

要开始创建我们需要设置环境准备。解压缩下载的JasperReport ZIP文件到任何位置（在我们的例子中，我们已经提取到C: oolsjasperreports-5.0.1）。解压缩文件的目录结构如下图示：

Jasper directory structure

下面是所有目录的详细信息：

build: 包含已编译的JasperReport类文件。
demo: 包含演示JasperReports功能几个方面的各种例子。
dist: 包含的JasperReports-x.x.x.jar文件。将这个JAR文件添加到CLASSPATH。
docs: 包含了JasperReports的文档的本地副本。
lib: 包含所需的所有JAR文件，这样既可以建立JasperReports，并把它用在我们的应用程序。
src: 包含了JasperReports的源代码。
build.xml: Ant构建文件构建JasperReports的源代码。如果不打算修改JasperReports，并不需要使用这个文件，因为JasperReports发布成已编译的形式。
changes.txt: 一个文本文件解释的JasperReports类库的当前和以前版本之间的差异。
license.txt: 包含LGPL（较宽松通用公共许可证）许可的全文文本文档。
readme.txt: 一个文本文件包含有关如何建立和执行提供的示例说明。

基本上，我们只使用jasperreports-x.x.x.jar 在lib目录下的路程和JAR下生成报表。由于Jasper报表作为一个开源的工具，如果任何缺陷或错误执行的jasperreports-x.x.x.jar中是公认的，我们可以修复它并使用build.xml文件再次生成的JAR文件。

设置CLASSPATH

要使用JasperReport，需要设置下列文件到CLASSPATH中：

jasperreports-x.x.x.jar, 其中x.x.x是JasperReports的版本。此目录下找到 C: oolsjasperreports-x.x.xdist).
lib子目录中的所有JAR文件 (C: oolsjasperreports-x.x.xlib).

在安装的时候，我们使用JasperReport5.0.1版本。在“我的电脑”右键单击并选择“属性”，“高级”选项卡下单击“环境变量”按钮。现在有了这个更新的“路径”变量添加：C: oolsjasperreports-5.0.1distjasperreports-5.0.1.jar;C: oolsjasperreports-5.0.1lib;. 现在，可以创建报表了。

> 在本教程中的所有例子中，已经使用Ant任务来生成报告。构建文件会自己负责，包括所有所需的JAR生成报告。因此，设定上述的CLASSPATH只会帮助生成报表，而无需使用ANT。

生成安装

在本教程中的所有例子：

使用简单的文本编辑器写入。
已保存的目录下 C: oolsjasperreports-5.0.1 estsrccomyiibai.
已编译并从命令提示符下执行，使用Apache Ant。我们将使用它我们将在Ant build.xml文件中的后续章节中导入abaseBuild.xml文件。将此文件保存到C: oolsjasperreports-5.0.1 est. 以下是baseBuild.xml文件的内容：

<?xml version="1.0" encoding="UTF-8"?>
<project name="JasperReportExample" basedir=".">
<description>Previews our JasperReport XML Design</description>
<property name="file.name" value="jasper_report_template" />

<property name="jasper.dir" value="../" />
<property name="dist.dir" value="${jasper.dir}/dist" />
<property name="lib.dir" value="${jasper.dir}/lib" />
<property name="src.dir" value="src" />
<property name="classes.dir" value="classes" />
<property name="main-class" value="com.yiibai.HelpMe" />

<path id="classpath">
<pathelement location="./" />
<pathelement location="${classes.dir}" />
<fileset dir="${lib.dir}">
<include name="**/*.jar" />
</fileset>
<fileset dir="${dist.dir}">
<include name="**/*.jar" />
</fileset>
</path>

<target name="compile" depends="clean-sample">
<mkdir dir="${classes.dir}"/>
<javac srcdir="${src.dir}" destdir="${classes.dir}"
classpathref="classpath" />
</target>

<target name="run" depends="compile">
<echo message="Running class : ${main-class}"/>
<java fork="true" classname="${main-class}">
<classpath>
<path refid="classpath" />
</classpath>
</java>
</target>
<target name="clean-sample">
<delete dir="${classes.dir}" />
<delete file="./${file.name}.jasper" />
<delete file="./${file.name}.jrprint" />
</target>
</project>

此文件具有所有必需的目标，比如清除目录，编译java文件，并执行类文件。

以下是baseBuild.xml提到的细节不同的目录。假设当前目录是 C: oolsjasperreports-5.0.1 est):

jasper.dir: 是 C: oolsjasperreports-5.0.1 directory
lib.dir: 是 C: oolsjasperreports-5.0.1lib directory
src.dir: 是 C: oolsjasperreports-5.0.1 estsrc
classes.dir: 是 C: oolsjasperreports-5.0.1 estclasses
main-class: com.yiibai.HelpMe. 这个类执行，如果没有类文件名是在命令行中通过一个简单的类。将此文件保存到 C: oolsjasperreports-5.0.1 estsrccomyiibai.

package com.yiibai;

public class HelpMe {
public static void main(String[] args) {
System.out.println("This is the default class executed."
+ "Please pass the fully qualified class"
+ " name to be executed as command line"
+ " parameter, for example,"
+ " com.yiibai.HelpMe ");
}
}

Jasper 管理类

还有的类，它们将被用来编译JRXML报表设计，以填补报表，打印报表，导出为PDF，HTML和XML文件，查看生成的报表和报表设计序号。

Manager Classes 这些类的列表是：

net.sf.jasperreports.engine.JasperCompileManager: 用于编译JRXML报表模板。
net.sf.jasperreports.engine.JasperFillManager: 用于填充一个报表，从数据源的数据
net.sf.jasperreports.engine.JasperPrintManager: 用于打印的JasperReports类库生成的文件
net.sf.jasperreports.engine.JasperExportManager: 用于获取PDF，HTML或XML内容以供报表填充过程中产生的文件
net.sf.jasperreports.view.JasperViewer: 它代表了一个简单的Java Swing应用程序，可以加载和显示报表。
net.sf.jasperreports.view.JasperDesignViewer: 用于在设计时预览报表模板。

设置Apache ANT

我们将构建所有的例子使用Apache Ant。所以请检查ANT - 设置Apache Ant环境。

JasperReport生命周期 - JasperReports教程

JasperReports的主要目的是为了在一个简单而灵活的方式创建页面为导向，准备好打印文档。下面的流程图描述了一个典型的工作流程，同时创建报表。

Jasper Compilation Process

如在图片的生命周期具有以下明显的阶段

设计报表在这一步中，我们创建JRXML文件，该文件是包含的报表布局定义的XML文档。我们可以使用任何文本编辑器或iReportDesigner手动创建它。如果iReportDesigner使用的布局被设计成可视化的方式时，JRXML实际的结构可以被忽略。
编译报表在这一步中JRXML被编译为二进制对象称为Jasper文件(*.jasper)。做此编译是出于性能方面的考虑。Jasper文件是什么？它需要随应用程序以运行报表。
执行报表（数据填充到报表）在该步骤中从应用程序数据被填充在已编译的报表。类net.sf.jasperreports.engine.JasperFillManager提供了必要的功能，填补了报告中的数据。Jasper打印文件 (*.jrprint) 被创建，它可以用来打印或者导出报告。
导出报表到所需的格式在这一步中，我们可以导出在上一步中使用JasperExportManager任何格式创建的Jasper打印文件。由于Jasper 提供各种形式的导出，因此具有相同的输入，我们可以创建数据的多种表示形式。

上述每个步骤的详细介绍将在以后的章节中解释。

JasperReport报表设计 - JasperReports教程

在JRXML模板（或JRXML文件）中的JasperReport 都是标准的 XML文件，以.JRXML扩展。所有JRXML文件包含标签<jasperReport>，作为根元素。这反过来又包含许多子元素（所有这些都是可选的）。JasperReport框架，可以处理不同类型的数据源。在本教程中，我们将展示如何生成一个基本的报表，只是通过传递Java数据对象（使用Java Bean）集合传给JasperReport引擎。最后报表应显示的人的名单的名字和国家。

本章介绍如何设计一个JasperReport。下面的步骤将在本章中：

创建一个JRXML报表模板。
预览XML报表模板。

创建一个JRXML报表模板

创建JRXML文件，该文件是jasper_report_template.jrxml使用文本编辑器，并保存此文件按照我们的环境设置，在 C: oolsjasperreports-5.0.1 est 。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE jasperReport PUBLIC "//JasperReports//DTD Report Design//EN"
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports
http://jasperreports.sourceforge.net/xsd/jasperreport.xsd"
name="jasper_report_template" language="groovy" pageWidth="595"
pageHeight="842" columnWidth="555" leftMargin="20" rightMargin="20"
topMargin="20" bottomMargin="20">
<queryString>
<![CDATA[]]>
</queryString>
<field name="country" class="java.lang.String">
<fieldDescription><![CDATA[country]]></fieldDescription>
</field>
<field name="name" class="java.lang.String">
<fieldDescription><![CDATA[name]]></fieldDescription>
</field>
<columnHeader>
<band height="23">
<staticText>
<reportElement mode="Opaque" x="0" y="3" width="535"
height="15" backcolor="#70A9A9" />
<box>
<bottomPen lineWidth="1.0" lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]> </text>
</staticText>
<staticText>
<reportElement x="414" y="3" width="121" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Country]]></text>
</staticText>
<staticText>
<reportElement x="0" y="3" width="136" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Name]]></text>
</staticText>
</band>
</columnHeader>
<detail>
<band height="16">
<staticText>
<reportElement mode="Opaque" x="0" y="0" width="535"
height="14" backcolor="#E5ECF9" />
<box>
<bottomPen lineWidth="0.25" lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]> </text>
</staticText>
<textField>
<reportElement x="414" y="0" width="121" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$F{country}]]>
</textFieldExpression>
</textField>
<textField>
<reportElement x="0" y="0" width="136" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle" />
<textFieldExpression class="java.lang.String">
<![CDATA[$F{name}]]>
</textFieldExpression>
</textField>
</band>
</detail>
</jasperReport>

下面是在上述报表模板主要字段的详细信息：

<queryString>: 这是空的（因为我们传递的数据通过Java Beans）。通常包含以检索报表结果的SQL语句。
<field name>: 此元素用于从数据源或查询数据映射到报表模板。name是重复使用到报表主体（它们大小写敏感）。
<fieldDescription>: 此元素的映射字段名称与XML文件中的相应元素。
<staticText>: 这个定义不依赖于任何数据源，变量，参数或报表表达式静态文本。
<textFieldExpression>: 这定义结果字段的外观。
$F{country}: 这是一个包含结果的预定义字段的标签<field name>的变量的值。
<band>: 包含显示在报表中的数据。

一旦报表设计已准备就绪，将其保存在C: 目录。

预览XML报表模板

有提供的实用工具net.sf.jasperreports.view.JasperDesignViewer在JasperReports的JAR文件，这有助于预览报表设计，而无需编译或填充它。此实用程序是一个独立的Java应用程序，因此可以使用ANT执行。

让我们来写一个Ant目标viewDesignXML查看JRXML。因此，让我们在C: oolsjasperreports-5.0.1 est目录创建和保存build.xml（应放置在JRXML在同一个目录下）。这里是build.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<project name="JasperReportTest" default="viewDesignXML" basedir=".">

<import file="baseBuild.xml" />
<target name="viewDesignXML" description="Design viewer is launched
to preview the JXML report design.">
<java classname= "net.sf.jasperreports.view.JasperDesignViewer"
fork="true">
<arg value="-XML" />
<arg value="-F${file.name}.jrxml" />
<classpath refid="classpath" />
</java>
</target>

</project>

接下来，让我们打开命令提示符并转到build.xml文件放置的目录。执行命令ant（由于viewDesignXML是默认的目标）。输出如下：

C: oolsjasperreports-5.0.1 est>ant
Buildfile: C: oolsjasperreports-5.0.1 estuild.xml

viewDesignXML:
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.engine.xml.JRXmlDigesterFactory).
[java] log4j:WARN Please initialize the log4j system properly.

Log4j的警告可以忽略，如上面执行的结果，一个标有“JasperDesignViewer”窗口打开，显示我们的报表模板的预览。

Jasper Design Viewer

正如我们看到获得的数据只报表表达式显示，作为JasperDesignViewer没有获得实际的数据源或报表参数。通过关闭窗口或按下Ctrl-C在命令行窗口终止JasperDesignViewer。

JasperReport编译报表设计 - JasperReports教程

我们在前面的章节中产生的JasperReport模板（JRXML文件）。这个文件不能直接用于生成报告。它必须被编译成JasperReport的“本地二进制"格式，称为Jasperfile。在编制我们把JasperDesign对象转换成JasperReport的对象：

Jasper Report Compiling

接口net.sf.jasperreports.engine.design.JRCompiler编译过程中起着核心的一部分。这个接口有根据用于报表表达式语言，它可以只要编译器可以实现在运行时计算它被用Java编写的，Groovy，JavaScript的或任何其他脚本语言的几个实现。我们可以通过以下两种方式编译JRXML文件：

提供编程编译。
编译通过ANT任务。

JRXML提供编程编译

JasperReports的API提供了一个门面类net.sf.jasperreports.engine.JasperCompileManager用于编译JasperReport。这个类包含几个公共静态方法编制的报告模板。模板的源可以从文件，输入流，内存中的对象。

该jrxml文件（jasper_report_template.jrxml）的内容如下。它被保存在目录 C: oolsjasperreports-5.0.1 est:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE jasperReport PUBLIC "//JasperReports//DTD Report Design//EN"
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports
http://jasperreports.sourceforge.net/xsd/jasperreport.xsd"
name="jasper_report_template" language="groovy" pageWidth="595"
pageHeight="842" columnWidth="555" leftMargin="20" rightMargin="20"
topMargin="20" bottomMargin="20">

<queryString>
<![CDATA[]]>
</queryString>
<field name="country" class="java.lang.String">
<fieldDescription><![CDATA[country]]></fieldDescription>
</field>
<field name="name" class="java.lang.String">
<fieldDescription><![CDATA[name]]></fieldDescription>
</field>
<columnHeader>
<band height="23">
<staticText>
<reportElement mode="Opaque" x="0" y="3" width="535"
height="15" backcolor="#70A9A9" />
<box>
<bottomPen lineWidth="1.0" lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]> </text>
</staticText>
<staticText>
<reportElement x="414" y="3" width="121" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Country]]></text>
</staticText>
<staticText>
<reportElement x="0" y="3" width="136" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Name]]></text>
</staticText>
</band>
</columnHeader>
<detail>
<band height="16">
<staticText>
<reportElement mode="Opaque" x="0" y="0" width="535"
height="14" backcolor="#E5ECF9" />
<box>
<bottomPen lineWidth="0.25" lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]> </text>
</staticText>
<textField>
<reportElement x="414" y="0" width="121" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$F{country}]]>
</textFieldExpression>
</textField>
<textField>
<reportElement x="0" y="0" width="136" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle" />
<textFieldExpression class="java.lang.String">
<![CDATA[$F{name}]]>
</textFieldExpression>
</textField>
</band>
</detail>
</jasperReport>

下面的代码演示了上述jasper_report_template.jrxml文件的编译。

package com.yiibai;

import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperCompileManager;

public class JasperReportCompile {

public static void main(String[] args) {
String sourceFileName = "C://tools/jasperreports-5.0.1/test" +
"/jasper_report_template.jrxml";

System.out.println("Compiling Report Design ...");
try {
/**
* Compile the report to a file name same as
* the JRXML file name
*/
JasperCompileManager.compileReportToFile(sourceFileName);
} catch (JRException e) {
e.printStackTrace();
}
System.out.println("Done compiling!!! ...");
}
}

模板编译

至于下一步，让我们保存上面的文件内容：C: oolsjasperreports-5.0.1 estsrccomyiibaiJasperReportCompile.java 并导入baseBuild.xml在为下面的build.xml文件。baseBuild.xml已经编译和运行的目标：

<?xml version="1.0" encoding="UTF-8"?>
<project name="JasperReportTest" default="run" basedir=".">

<import file="baseBuild.xml"/>

</project>

接下来，让我们打开命令行窗口并转到build.xml文件放置的目录。最后执行的命令ant -Dmain-class=com.yiibai.JasperReportCompile 如下:

C: oolsjasperreports-5.0.1 est>ant -Dmain-class=com.yiibai.JasperReportCompile
Buildfile: C: oolsjasperreports-5.0.1 estuild.xml
compile:
[javac] C: oolsjasperreports-5.0.1 estaseBuild.xml:27:
warning: 'includeantruntime' was not set, defaulting to
build.sysclasspath=last;set to false for repeatable builds
[javac] Compiling 1 source file to C: oolsjasperreports-5.0.1 estclasses

run:
[echo] Runnin class : com.yiibai.JasperReportCompile
[java] Compiling Report Design ...
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.engine.xml.JRXmlDigesterFactory).
[java] log4j:WARN Please initialize the log4j system properly.
[java] Done compiling!!! ...

BUILD SUCCESSFUL
Total time: 8 seconds

正如上文编译的结果，会看到jasper_report_template.jasper得到了语言生成的模板文件在C: oolsjasperreports-5.0.1 est 目录。

预览编译报表模板

net.sf.jasperreports.view.JasperDesignViewer 正如在前面的章节中讨论可用来预览编译报告模板以及JRXML模板。

为了进一步推动，让我们添加一个新的目标viewDesign上述build.xml文件，这将让我们先看盾编译报告。下面是修改后build.xml：导入文件 - baseBuild.xml做好环境设置，并应放置在同一目录中的build.xml。

<?xml version="1.0" encoding="UTF-8"?>
<project name="JasperReportTest" default="viewDesign" basedir=".">

<import file="baseBuild.xml" />
<target name="viewDesign" description="Design viewer is launched
to preview the compiled report design.">
<java classname="net.sf.jasperreports.view.JasperDesignViewer"
fork="true">
<arg value="-F${file.name}.jasper" />
<classpath refid="classpath" />
</java>
</target>

</project>

让我们执行命令：ant（viewDesign是默认的目标），在命令提示符下。 JasperDesignViewer窗口打开显示Jasper文件如下：

Jasper Design Viewer

通过ANT任务编译

报告模板编译更像是比一个运行时的工作设计时的工作，JasperReport库具有一个自定义ANT任务。因为当在运行时创建JRXML文件某些情况下，不能使用此ANT任务。自定义ANT任务被称为JRC和由类实现：net.sf.jasperreports.ant.JRAntCompileTask。其语法和行为是非常相似的内置<javac> ANT任务。

模板编译

让我们添加新的目标编译报表设计，以我们现有的build.xml。这里使用与文件集的嵌套<src>标签中指定的源文件夹。嵌套的源标签允许编译器，可通过许多不同的地点分散，在一个单一的根报表源文件夹不进行分组报告模板。下面是修改后的build.xml：

<?xml version="1.0" encoding="UTF-8"?>
<project name="JasperReportTest" default="compilereportdesing" basedir=".">
<import file="baseBuild.xml" />
<target name="viewDesign" description="Design viewer is launched
to preview the compiled report design.">
<java classname="net.sf.jasperreports.view.JasperDesignViewer"
fork="true">
<arg value="-F${file.name}.jasper" />
<classpath refid="classpath" />
</java>
</target>

<target name="compilereportdesing" description="Compiles the JXML
file and produces the .jasper file.">
<taskdef name="jrc"
classname="net.sf.jasperreports.ant.JRAntCompileTask">
<classpath refid="classpath" />
</taskdef>
<jrc destdir=".">
<src>
<fileset dir=".">
<include name="*.jrxml" />
</fileset>
</src>
<classpath refid="classpath" />
</jrc>
</target>

</project>

接下来，让我们打开命令提示符并转到build.xml文件放置的目录。执行命令ant（compilereportdesing是默认的目标）输出为如下：

C: oolsjasperreports-5.0.1 est>ant
Buildfile: C: oolsjasperreports-5.0.1 estuild.xml

compilereportdesing:
[jrc] Compiling 1 report design files.
[jrc] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.engine.xml.JRXmlDigesterFactory).
[jrc] log4j:WARN Please initialize the log4j system properly.
[jrc] log4j:WARN See
http://logging.apache.org/log4j/1.2/faq.htmll#noconfig
for more info.
[jrc] File :
C: oolsjasperreports-5.0.1 estjasper_report_template.jrxml ... OK.

BUILD SUCCESSFUL
Total time: 5 seconds

文件jasper_report_template.jasper是在文件系统（在我们的例子中为 C: oolsjasperreports-5.0.1 est目录）产生的。这个文件是相同的通过调用net.sf.jasperreports.engine.JasperCompileManager.compileReportToFile()程序生成一个。我们可以预览这个 jasper文件，执行ant viewDesign。

JasperReport填充报表 - JasperReports教程

任何报告工具的主要目的是为了生产出高品质的文档。举报填充过程有助于报告工具通过操纵数据集来实现这一目标。需要报表填充过程的主要输入是：

报表模板：这是实际的JasperReport文件
报告参数：这些所传递的报表填充时间给引擎基本上都是命名的值。我们将在报表参数章节讨论。
数据源：我们可以从一系列像一个SQL查询，XML文件，CSV文件，一个HQL（Hibernate查询语言）查询，Java Beans的集合等数据源的填补Jasper这个文件将详细讨论在报表数据源的篇章。

这个过程产生的输出。jrprint是一个文档随时查看，打印或导出为其他格式。外观类net.sf.jasperreports.engine.JasperFillManager通常用于填充一个报表模板与数据。这个类有各种fillReportXXX()方法，填补报表模板（模板可以位于磁盘上，从输入流采集，或直接提供的内存）。

主要有两类在此外观类fillReportXXX()方法：

第一种类型，接收java.sql.Connection对象作为第三个参数。大多数情况下报表都充满了从关系数据库中的数据。这是通过：
- 通过JDBC连接到数据库。
- 包括报表模板中的SQL查询。
- JasperReports引擎使用传入的连接并执行SQL查询。
- 因此，一个报表数据源产生填充的报告。
第二类，收到net.sf.jasperreports.engine.JRDataSource对象，当提供其他形式的数据来填补。

填充报告模板

让我们来写一个报表模板。在JRXML文件(C: oolsjasperreports-5.0.1 estjasper_report_template.jrxml) 的内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE jasperReport PUBLIC "//JasperReports//DTD Report Design//EN"
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports
http://jasperreports.sourceforge.net/xsd/jasperreport.xsd"
name="jasper_report_template" language="groovy" pageWidth="595"
pageHeight="842" columnWidth="555" leftMargin="20" rightMargin="20"
topMargin="20" bottomMargin="20">

<queryString>
<![CDATA[]]>
</queryString>
<field name="country" class="java.lang.String">
<fieldDescription><![CDATA[country]]></fieldDescription>
</field>
<field name="name" class="java.lang.String">
<fieldDescription><![CDATA[name]]></fieldDescription>
</field>
<columnHeader>
<band height="23">
<staticText>
<reportElement mode="Opaque" x="0" y="3" width="535"
height="15" backcolor="#70A9A9" />
<box>
<bottomPen lineWidth="1.0" lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]> </text>
</staticText>
<staticText>
<reportElement x="414" y="3" width="121" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Country]]></text>
</staticText>
<staticText>
<reportElement x="0" y="3" width="136" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Name]]></text>
</staticText>
</band>
</columnHeader>
<detail>
<band height="16">
<staticText>
<reportElement mode="Opaque" x="0" y="0" width="535"
height="14" backcolor="#E5ECF9" />
<box>
<bottomPen lineWidth="0.25" lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]> </text>
</staticText>
<textField>
<reportElement x="414" y="0" width="121" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$F{country}]]>
</textFieldExpression>
</textField>
<textField>
<reportElement x="0" y="0" width="136" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle" />
<textFieldExpression class="java.lang.String">
<![CDATA[$F{name}]]>
</textFieldExpression>
</textField>
</band>
</detail>
</jasperReport>

接下来，让我们通过Java数据对象（Java bean）集合，到Jasper报表引擎，填补了这一编译报告。

写一个POJO DataBean.java表示数据对象（Java bean）。这个类定义了两个字符串对象名称和国家。把它保存到目录 C: oolsjasperreports-5.0.1 estsrccomyiibai.

package com.yiibai;

public class DataBean {
private String name;
private String country;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getCountry() {
return country;
}

public void setCountry(String country) {
this.country = country;
}
}

编写一个类DataBeanList.java具有业务逻辑生成java bean对象的集合。这是进一步传递到报表引擎，生成报表。在这里，我们添加在列表 DataBean进行对象。把它保存到目录C: oolsjasperreports-5.0.1 estsrccomyiibai.

package com.yiibai;

import java.util.ArrayList;

public class DataBeanList {
public ArrayList<DataBean> getDataBeanList() {
ArrayList<DataBean> dataBeanList = new ArrayList<DataBean>();

dataBeanList.add(produce("Manisha", "India"));
dataBeanList.add(produce("Dennis Ritchie", "USA"));
dataBeanList.add(produce("V.Anand", "India"));
dataBeanList.add(produce("Shrinath", "California"));

return dataBeanList;
}

/**
* This method returns a DataBean object,
* with name and country set in it.
*/
private DataBean produce(String name, String country) {
DataBean dataBean = new DataBean();
dataBean.setName(name);
dataBean.setCountry(country);
return dataBean;
}
}

编写一个类DataBeanList.java具有业务逻辑生成java bean对象的集合。这是进一步传递到Jasper报表引擎，生成报告。在这里，我们添加在列表4 DataBean进行对象。把它保存到目录 C: oolsjasperreports-5.0.1 estsrccomyiibai.

package com.yiibai;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;

public class JasperReportFill {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
String sourceFileName =
"c://tools/jasperreports-5.0.1/test/jasper_report_template.jasper";
DataBeanList DataBeanList = new DataBeanList();
ArrayList<DataBean> dataList = DataBeanList.getDataBeanList();

JRBeanCollectionDataSource beanColDataSource =
new JRBeanCollectionDataSource(dataList);

Map parameters = new HashMap();
try {
JasperFillManager.fillReportToFile(
sourceFileName,
parameters,
beanColDataSource);
} catch (JRException e) {
e.printStackTrace();
}
}
}

生成报表

现在，我们将编译并使用我们的定期Ant构建过程执行这些文件。 build.xml文件如下图所示：

> 导入文件 - baseBuild.xml环境设置，并应放置在同一目录中的build.xml。

<?xml version="1.0" encoding="UTF-8"?>
<project name="JasperReportTest" default="executereport" basedir=".">
<import file="baseBuild.xml"/>

<target name="executereport" depends="compile,compilereportdesing,run">
<echo message="Im here"/>
</target>
<target name="compilereportdesing"
description="Compiles the JXML file and
produces the .jasper file.">
<taskdef name="jrc"
classname="net.sf.jasperreports.ant.JRAntCompileTask">
<classpath refid="classpath" />
</taskdef>
<jrc destdir=".">
<src>
<fileset dir=".">
<include name="*.jrxml" />
</fileset>
</src>
<classpath refid="classpath" />
</jrc>
</target>
</project>

接下来，让我们打开命令行窗口并转到build.xml文件放置的目录。最后，执行命令ant -Dmain-class=com.yiibai.JasperReportFill （executereport是默认的目标），如下所示：

C: oolsjasperreports-5.0.1 est>ant -Dmain-class=com.yiibai.JasperReportFill
Buildfile: C: oolsjasperreports-5.0.1 estuild.xml

compile:
[javac] C: oolsjasperreports-5.0.1 estaseBuild.xml:27:
warning: 'includeantruntime' was not set, defaulting to
build.sysclasspath=last; set to false for repeatable builds
[javac] Compiling 1 source file to
C: oolsjasperreports-5.0.1 estclasses

run:
[echo] Runnin class : com.yiibai.JasperReportFill
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.extensions.ExtensionsEnvironment).
[java] log4j:WARN Please initialize the log4j system properly.

BUILD SUCCESSFUL
Total time: 8 seconds

如上述执行结果的文件jasper_report_template.jrprint是在同一目录中为 .jasper文件（在这种情况下，它是产生在 C: oolsjasperreports-5.0.1 est).

JasperReport查看和打印报告 - JasperReports教程

报表填充过程JasperPrint对象的输出可以使用内置的浏览器组件来查看，打印或导出到更多的流行的文件格式，如PDF，HTML，RTF，XLS，ODT，CSV或XML。Jasper文件查看和打印将包括在本章中。导出将包括在下一章导出报表.

查看报表

JasperReport提供了一个内置的浏览器观看原始格式生成的报表。这是一个基于Swing的组件和其他Java应用程序可以无需将文档导出为其他格式，以便查看或打印此集成组件。net.sf.jasperreports.view.JRViewer类表示这个可视组件。这个类也可以被定制为每个应用程序的需要，通过继承它。

JasperReports也有用来查看报表的可视化组件Swing应用程序。此应用程序可以帮助在相同的格式查看报表为*.jrprint就产生了。这个Swing应用程序是在类net.sf.jasperreports.view.JasperViewer实现。要使用此功能，我们可以把这个包成一个Ant目标，以查看报表。

查看生成的报告

下面的示例演示如何查看使用JasperViewer类的报表。

让我们来写一个报告模板。在JRXML文件(C: oolsjasperreports-5.0.1 estjasper_report_template.jrxml)的内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE jasperReport PUBLIC "//JasperReports//DTD Report Design//EN"
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports
http://jasperreports.sourceforge.net/xsd/jasperreport.xsd"
name="jasper_report_template" language="groovy" pageWidth="595"
pageHeight="842" columnWidth="555" leftMargin="20" rightMargin="20"
topMargin="20" bottomMargin="20">

<queryString>
<![CDATA[]]>
</queryString>
<field name="country" class="java.lang.String">
<fieldDescription><![CDATA[country]]></fieldDescription>
</field>
<field name="name" class="java.lang.String">
<fieldDescription><![CDATA[name]]></fieldDescription>
</field>
<columnHeader>
<band height="23">
<staticText>
<reportElement mode="Opaque" x="0" y="3" width="535"
height="15" backcolor="#70A9A9" />
<box>
<bottomPen lineWidth="1.0" lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]> </text>
</staticText>
<staticText>
<reportElement x="414" y="3" width="121" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Country]]></text>
</staticText>
<staticText>
<reportElement x="0" y="3" width="136" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Name]]></text>
</staticText>
</band>
</columnHeader>
<detail>
<band height="16">
<staticText>
<reportElement mode="Opaque" x="0" y="0" width="535"
height="14" backcolor="#E5ECF9" />
<box>
<bottomPen lineWidth="0.25" lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]> </text>
</staticText>
<textField>
<reportElement x="414" y="0" width="121" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$F{country}]]>
</textFieldExpression>
</textField>
<textField>
<reportElement x="0" y="0" width="136" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle" />
<textFieldExpression class="java.lang.String">
<![CDATA[$F{name}]]>
</textFieldExpression>
</textField>
</band>
</detail>
</jasperReport>

接下来，让我们通过Java数据对象（Java bean）的集合，到Jasper报表引擎，填补了这一编译报告。

写一个POJO DataBean.java表示数据对象（的Java bean）。这个类定义了两个字符串对象name和country。把它保存到目录 C: oolsjasperreports-5.0.1 estsrccomyiibai.

编写一个类DataBeanList.java具有业务逻辑生成java bean对象的集合。这是进一步传递到Jasper 报表引擎，生成报告。在这里，我们添加在列表中的4个DataBean进行对象。把它保存到目录C: oolsjasperreports-5.0.1 estsrccomyiibai.

写一个主类文件JasperReportFill.java，它从类（DataBeanList）得到的java bean的集合，并将其传递到Jasper报表引擎，填补了报告模板。把它保存到目录 C: oolsjasperreports-5.0.1 estsrccomyiibai.

package com.yiibai;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;

public class JasperReportFill {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
String sourceFileName =
"c://tools/jasperreports-5.0.1/test/jasper_report_template.jasper";
DataBeanList DataBeanList = new DataBeanList();
ArrayList<DataBean> dataList = DataBeanList.getDataBeanList();

JRBeanCollectionDataSource beanColDataSource =
new JRBeanCollectionDataSource(dataList);

Map parameters = new HashMap();
try {
JasperFillManager.fillReportToFile(
sourceFileName,
parameters,
beanColDataSource);
} catch (JRException e) {
e.printStackTrace();
}
}
}

让我们来写一个目标viewFillReport的build.xml文件。 build.xml文件如下所示：

> 导入文件 - baseBuild.xml环境设置，并应放置在同一目录中的build.xml。

<?xml version="1.0" encoding="UTF-8"?>
<project name="JasperReportTest" default="viewFillReport" basedir=".">
<import file="baseBuild.xml"/>

<target name="viewFillReport" depends="compile,compilereportdesing,run"
description="Launches the report viewer
to preview the report stored in the .JRprint file.">
<java classname="net.sf.jasperreports.view.JasperViewer" fork="true">
<arg value="-F${file.name}.JRprint" />
<classpath refid="classpath" />
</java>
</target>
<target name="compilereportdesing"
description="Compiles the JXML file and
produces the .jasper file.">
<taskdef name="jrc"
classname="net.sf.jasperreports.ant.JRAntCompileTask">
<classpath refid="classpath" />
</taskdef>
<jrc destdir=".">
<src>
<fileset dir=".">
<include name="*.jrxml" />
</fileset>
</src>
<classpath refid="classpath" />
</jrc>
</target>
</project>

接下来，让我们打开命令行窗口并转到build.xml文件放置的目录。最后执行的命令 ant -Dmain-class=com.yiibai.JasperReportFill（viewFillReport是默认的目标）。因此，我们看到一个JasperViewer窗口，如下面的屏幕：

Jasper Report Viewer

打印报表

我们可以使用net.sf.jasperreports.engine.JasperPrintManager类打印的JasperReports类库生成的文件（在他们的专有格式i.eJasperPrint对象）。这是依赖于Java2 API打印一个假象类。我们还可以打印文档，一旦JasperReport的文档导出为其他格式，如HTML或PDF。

打印生成的报告

下面的代码演示报表的打印。让我们更新现有的类JasperReportFill。我们将使用JasperPrintManager.printReport()方法。此方法需要源文件名.jrprint（这里我们通过我们在上一步生成的使用方法JasperFillManager.fillReportToFile()）作为第一个参数。第二个参数是布尔值，用于显示标准打印对话框（我们将其设置为true这里）。

现在，让我们将此文件保存到目录C: oolsjasperreports-5.0.1 estsrccomyiibai. 我们将使用ANT编译并执行此文件.build.xml文件的内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<project name="JasperReportTest" default="executereport" basedir=".">
<import file="baseBuild.xml"/>

<target name="executereport"
depends="compile,compilereportdesing,run">
<echo message="Im here"/>
</target>
<target name="compilereportdesing"
description="Compiles the JXML file and
produces the .jasper file.">
<taskdef name="jrc"
classname="net.sf.jasperreports.ant.JRAntCompileTask">
<classpath refid="classpath" />
</taskdef>
<jrc destdir=".">
<src>
<fileset dir=".">
<include name="*.jrxml" />
</fileset>
</src>
<classpath refid="classpath" />
</jrc>
</target>
</project>

接下来，让我们打开命令提示符并转到build.xml文件放置的目录。最后，执行命令 ant -Dmain-class=com.yiibai.JasperReportPrint. 因此，会出现一个打印对话框。单击确定以打印文档。

JasperReport导出报表 - JasperReports教程

我们已经看到在前面的章节中，如何打印和查看的JasperReport生成的文档。在这里，我们将看到如何在其他格式，如PDF，HTML和XLS转换或导出这些报告。 Facade类net.sf.jasperreports.engine.JasperExportManager提供实现这一功能。导出方式转变JasperPrint对象（.jrprint文件）导入到不同的格式。

下面的代码（JasperReportExport.java）演示了JasperReport文档的导出过程。该JasperExportManager提供的方法将报表导出成PDF，HTML和XML。导出到使用的类net.sf.jasperreports.engine.export.JRXlsExporter的XLS格式。此代码生成以下三个文件：

sample_report.pdf
sample_report.htmll
sample_report.xls

导出为其他格式

让我们来写一个报表模板。在JRXML文件的内容 (C: oolsjasperreports-5.0.1 estjasper_report_template.jrxml) 如下:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE jasperReport PUBLIC "//JasperReports//DTD Report Design//EN"
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports
http://jasperreports.sourceforge.net/xsd/jasperreport.xsd"
name="jasper_report_template" language="groovy" pageWidth="595"
pageHeight="842" columnWidth="555" leftMargin="20" rightMargin="20"
topMargin="20" bottomMargin="20">

<queryString>
<![CDATA[]]>
</queryString>
<field name="country" class="java.lang.String">
<fieldDescription><![CDATA[country]]></fieldDescription>
</field>
<field name="name" class="java.lang.String">
<fieldDescription><![CDATA[name]]></fieldDescription>
</field>
<columnHeader>
<band height="23">
<staticText>
<reportElement mode="Opaque" x="0" y="3" width="535"
height="15" backcolor="#70A9A9" />
<box>
<bottomPen lineWidth="1.0" lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]> </text>
</staticText>
<staticText>
<reportElement x="414" y="3" width="121" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Country]]></text>
</staticText>
<staticText>
<reportElement x="0" y="3" width="136" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Name]]></text>
</staticText>
</band>
</columnHeader>
<detail>
<band height="16">
<staticText>
<reportElement mode="Opaque" x="0" y="0" width="535"
height="14" backcolor="#E5ECF9" />
<box>
<bottomPen lineWidth="0.25" lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]> </text>
</staticText>
<textField>
<reportElement x="414" y="0" width="121" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$F{country}]]>
</textFieldExpression>
</textField>
<textField>
<reportElement x="0" y="0" width="136" height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle" />
<textFieldExpression class="java.lang.String">
<![CDATA[$F{name}]]>
</textFieldExpression>
</textField>
</band>
</detail>
</jasperReport>

接着，POJO文件 C: oolsjasperreports-5.0.1 estsrccomyiibaiDataBean.java 的内容如下：

文件 C: oolsjasperreports-5.0.1 estsrccomyiibaiDataBeanList.java 的内容如下：

写一个主类文件JasperReportFill.java，它从类（DataBeanList）获取java bean集合，并将其传递到Jasper 报表引擎，填补了报表模板。把它保存到目录 C: oolsjasperreports-5.0.1 estsrccomyiibai.

package com.yiibai;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JRExporterParameter;
import net.sf.jasperreports.engine.JasperExportManager;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.export.JRXlsExporter;

public class JasperReportFill {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
String sourceFileName = "c://tools/jasperreports-5.0.1/"
+ "test/jasper_report_template.jasper";
String printFileName = null;
DataBeanList DataBeanList = new DataBeanList();
ArrayList <databean>dataList = DataBeanList.getDataBeanList();
JRBeanCollectionDataSource beanColDataSource =
new JRBeanCollectionDataSource(dataList);

Map parameters = new HashMap();
try {
printFileName = JasperFillManager.fillReportToFile(sourceFileName,
parameters, beanColDataSource);
if (printFileName != null) {
/**
* 1- export to PDF
*/
JasperExportManager.exportReportToPdfFile(printFileName,
"C://sample_report.pdf");

/**
* 2- export to HTML
*/
JasperExportManager.exportReportToHtmlFile(printFileName,
"C://sample_report.htmll");

/**
* 3- export to Excel sheet
*/
JRXlsExporter exporter = new JRXlsExporter();

exporter.setParameter(JRExporterParameter.INPUT_FILE_NAME,
printFileName);
exporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME,
"C://sample_report.xls");

exporter.exportReport();
}
} catch (JRException e) {
e.printStackTrace();
}
}
}</databean>

在这里，我们已经包括了逻辑Jasper 打印文件导出到PDF，HTML和XLS格式。

生成报表

让我们用我们的常规Ant构建过程编译和执行上述文件。 build.xml文件如下图所示：

进入命令提示符，然后转到目录C: oolsjasperreports-5.0.1 est，其中build.xml已放置。最后执行的命令 ant -Dmain-class=com.yiibai.JasperReportFill. 输出如下所示：

C: oolsjasperreports-5.0.1 est>ant -Dmain-class=com.yiibai.JasperReportFill
Buildfile: C: oolsjasperreports-5.0.1 estuild.xml

clean-sample:
[delete] Deleting directory C: oolsjasperreports-5.0.1 estclasses
[delete] Deleting: C: oolsjasperreports-5.0.1 estjasper_report_template.jasper
[delete] Deleting: C: oolsjasperreports-5.0.1 estjasper_report_template.jrprint

compile:
[mkdir] Created dir: C: oolsjasperreports-5.0.1 estclasses
[javac] C: oolsjasperreports-5.0.1 estaseBuild.xml:28:
warning: 'includeantruntime' was not set, defaulting t
[javac] Compiling 4 source files to C: oolsjasperreports-5.0.1 estclasses

compilereportdesing:
[jrc] Compiling 1 report design files.
[jrc] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.engine.xml.JRXmlDigesterFactory).
[jrc] log4j:WARN Please initialize the log4j system properly.
[jrc] log4j:WARN See http://logging.apache.org/log4j/1.2/faq.htmll#noconfig for more info.
[jrc] File : C: oolsjasperreports-5.0.1 estjasper_report_template.jrxml ... OK.

run:
[echo] Runnin class : com.yiibai.JasperReportFill
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.extensions.ExtensionsEnvironment).
[java] log4j:WARN Please initialize the log4j system properly.

executereport:
[echo] Im here

BUILD SUCCESSFUL
Total time: 32 seconds

正如上面执行的结果，会发现三个文件sample_report.pdf，sample_report.htmll，sample_report.xls已生成在 C: 目录.

JasperReport报表参数 - JasperReports教程

填充一个报表的主要输入是：报表模板，参数和数据源。本章将介绍这些参数，并在接下来的章节中，我们将介绍数据源。

参数是在报表填充操作传递给报表引擎的对象引用。参数传递有用的数据到报表引擎，它可以不通过数据源来传递的数据是有用的。如作者姓名，报告等的标题数据，可以通过参数传递。 Jasper报表模板或JRXML模板可以包含零个或多个参数的元素。

参数声明

参数声明很简单，如下所示：

name属性

parameter>元素的name属性是强制性的。它通过名称引用的参数在报表表达式。参数名应该是一个单词。它不应该包含任何特殊字符，如句号或逗号。

class属性

class属性也是强制性的，它指定了参数值的类名。它的默认值是java.lang.String。这是可以改变的，以在运行时可用任何类。不论报表参数的类型，引擎采用构造于$P{}标记是用来报表表达，从而使手工投射不必要。

内置参数

以下是预定义的报表参数，准备在表达式中使用：

Parameter Name	描述
REPORT_PARAMETERS_MAP	包含所有用户定义和内置参数映射
REPORT_CONNECTION	这指向用于JDBC数据源的用户提供java.sql.Connection中
REPORT_DATA_SOURCE	这是JRDataSource代表任一用户提供的实例中的内置的数据源类型或用户定义
REPORT_MAX_COUNT	这是一个java.lang.Integer的值，从而允许用户从数据源限制记录。
REPORT_SCRIPTLET	这指向net.sf.jasperreports.engine.JRAbstractScriptlet和包含报表的scriptlet，由用户提供的一个实例
REPORT_LOCALE	这是一个java.util.Locale的实例，包含资源包所需的语言环境
REPORT_RESOURCE_BUNDLE	这指向java.util.ResourceBundle对象和包含本地化的消息
REPORT_TIME_ZONE	这是一个java.util.TimeZone的实例，用于日期格式
REPORT_VIRTUALIZER	这是net.sf.jasperreports.engine.JRVirtualizerobject一个实例，以及用于网页的虚拟化（优化内存消耗）
REPORT_CLASS_LOADER	这是在报告充填过程中使用的加载，如图像，字体和子报表模板资源java.lang.ClassLoader的实例
IS_IGNORE_PAGINATION	如果设置为java.lang.Boolean.TRUE报告将在一个很长的网页和分页符来产生不会发生

例子

让我们通过ReportTitle和 Author报表（由JasperReportFill.java生成）。经修订的文件C: oolsjasperreports-5.0.1 estsrccomyiibaiJasperReportFill.java 如下：

package com.yiibai;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;

public class JasperReportFill {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
String sourceFileName =
"C://tools/jasperreports-5.0.1/test/jasper_report_template.jasper";

DataBeanList DataBeanList = new DataBeanList();
ArrayList<DataBean> dataList = DataBeanList.getDataBeanList();

JRBeanCollectionDataSource beanColDataSource =
new JRBeanCollectionDataSource(dataList);

Map parameters = new HashMap();
/**
* Passing ReportTitle and Author as parameters
*/
parameters.put("ReportTitle", "List of Contacts");
parameters.put("Author", "Prepared By Manisha");

try {
JasperFillManager.fillReportToFile(
sourceFileName, parameters, beanColDataSource);
} catch (JRException e) {
e.printStackTrace();
}
}
}

POJO文件的内容 C: oolsjasperreports-5.0.1 estsrccomyiibaiDataBean.java 如下所示：

文件 C: oolsjasperreports-5.0.1 estsrccomyiibaiDataBeanList.java 的内容如下：

让我们添加参数<ReportTitle>和<AUTHOR>我们现有的报告模板（章报表设计）。报告标题和作者将在报表的开头显示。修订后的报告模板（jasper_report_template.jrxml）如下。将其保存到 C: oolsjasperreports-5.0.1 est 目录:

报表生成

编译和执行使用常规Ant构建过程上面的文件。 build.xml文件中的内容（根据目录保存C: oolsjasperreports-5.0.1 est）情况如下。

> 导入文件 - baseBuild.xml可以从环境设置章节中了解，并应放置在同一目录中的build.xml。

<?xml version="1.0" encoding="UTF-8"?>
<project name="JasperReportTest" default="viewFillReport" basedir=".">
<import file="baseBuild.xml" />
<target name="viewFillReport"
depends="compile,compilereportdesing,run"
description="Launches the report viewer to preview
the report stored in the .JRprint file.">
<java classname="net.sf.jasperreports.view.JasperViewer"
fork="true">
<arg value="-F${file.name}.JRprint" />
<classpath refid="classpath" />
</java>
</target>
<target name="compilereportdesing"
description="Compiles the JXML file and
produces the .jasper file.">
<taskdef name="jrc"
classname="net.sf.jasperreports.ant.JRAntCompileTask">
<classpath refid="classpath" />
</taskdef>
<jrc destdir=".">
<src>
<fileset dir=".">
<include name="*.jrxml" />
</fileset>
</src>
<classpath refid="classpath" />
</jrc>
</target>
</project>

接下来，让我们打开命令行窗口并转到build.xml文件放置的目录。最后执行的命令 ant -Dmain-class=com.yiibai.JasperReportFill （viewFullReport是默认的目标），如下所示：

C: oolsjasperreports-5.0.1 est>ant -Dmain-class=com.yiibai.JasperReportFill
Buildfile: C: oolsjasperreports-5.0.1 estuild.xml

clean-sample:
[delete] Deleting directory C: oolsjasperreports-5.0.1 estclasses
[delete] Deleting: C: oolsjasperreports-5.0.1 estjasper_report_template.jasper
[delete] Deleting: C: oolsjasperreports-5.0.1 estjasper_report_template.jrprint

compile:
[mkdir] Created dir: C: oolsjasperreports-5.0.1 estclasses
[javac] C: oolsjasperreports-5.0.1 estaseBuild.xml:28: warning:
'includeantruntime' was not set, defaulting to build.sysclasspath=last;
set to false for repeatable builds
[javac] Compiling 7 source files to C: oolsjasperreports-5.0.1 estclasses

compilereportdesing:
[jrc] Compiling 1 report design files.
[jrc] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.engine.xml.JRXmlDigesterFactory).
[jrc] log4j:WARN Please initialize the log4j system properly.
[jrc] log4j:WARN See http://logging.apache.org/log4j/1.2/faq.htmll#noconfig
for more info.
[jrc] File : C: oolsjasperreports-5.0.1 estjasper_report_template.jrxml ... OK.

run:
[echo] Runnin class : com.yiibai.JasperReportFill
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.extensions.ExtensionsEnvironment).
[java] log4j:WARN Please initialize the log4j system properly.

viewFillReport:
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.extensions.ExtensionsEnvironment).
[java] log4j:WARN Please initialize the log4j system properly.

BUILD SUCCESSFUL
Total time: 18 seconds

正如上文编译的结果，JasperViewer窗口打开如下面的屏幕：

Jasper Report Viewer

在这里，我们看到的是，报表头 "List Of Contacts"，并着有"Prepared By Manisha" 显示在报表的开头。

JasperReports报表数据源 - JasperReports教程

数据源的结构数据容器。同时生成报告，Jasper报表引擎获得来自数据源的数据。数据可以从数据库，XML文件，对象数组和集合中的对象来获得。我们将在本章填充报告所看到的fillReportXXX()方法，预计将收到该报告的数据源其以填充，在net.sf.jasperreports.engine.JRDataSource对象或一个java.sql.Connection中的形式（当报表数据在关系数据库中找到）。

JRDataSource接口只有两个方法，这应该被实现：

public boolean next() throws JRException;
public Object getFieldValue(JRField jrField) throws JRException;

从数据源中检索数据的唯一方法是通过使用报表字段。有一个JRDataSource接口的几个默认的实现，根据不同的数据源中的记录被获得的方式。

数据源的实现

下表总结了数据源和它们的实现类。

Datasource	Implementation Class
JDBC	net.sf.jasperreports.engine.JRResultSetDataSource
JavaBean	net.sf.jasperreports.engine.data.JRBeanCollectionDataSource, net.sf.jasperreports.engine.data.JRBeanArrayDataSource
Map-based	net.sf.jasperreports.engine.data.JRMapArrayDataSource, net.sf.jasperreports.engine.data.JRMapCollectionDataSource
TableModel	net.sf.jasperreports.engine.data.JRTableModelDataSource
XML	net.sf.jasperreports.engine.data.JRXmlDataSource
CSV	net.sf.jasperreports.engine.data.JRCsvDataSource
XLS	net.sf.jasperreports.engine.data.JRXlsDataSource
Empty	net.sf.jasperreports.engine.JREmptyDataSource

JDBC数据源

JRResultSetDataSource类关联入一个java.sql.ResultSet对象。这是当报表数据从关系数据库中提取最常用的数据源实现。如果ajava.sql.Connection传递给引擎来代替，它首先执行相关的查询，并将该返回java.sql.ResultSet中的对象在一个JRResultSetDataSource实例。

JAVABEAN数据来源

JRBeanArrayDataSource类和JRBeanCollectionDataSource表示实现，可以分别包装的JavaBean对象的数组或集合。数组或集合中的每个对象都将被视为对这种类型的数据源中的一个记录。一个特定的JavaBean属性和相应的报表字段之间的映射是通过命名约定进行。报表字段的名称必须是相同的所指定的JavaBeans的规范JavaBean属性的名称。

> 在本教程中的所有例子中，我们使用JRBeanCollectionDataSource。

基于MAP的数据来源

如果父级应用程序已经存储在内存中的java.util.Map对象提供的申报数据的实现类JRMapArrayDataSource和JRMapCollectionDataSource非常有用。被包装的数组或集合中的每个映射对象被认为是数据源中的一个虚拟的记录，每个报表字段的值从映射中使用报表字段名作为键提取。

TableModel的数据来源

在许多客户端应用程序，数据以表格形式显示。在许多应用中常见的需求是允许用户打印该表格形式的报告。实现类JRTableModelDataSource使生成的表格格式的Swing应用程序报告的任务。这个类封装了一个javax.swing.table.TableModel对象。列在包装的TableModel对象可以通过他们的名字或他们的基于0索引来访问。

XML数据源

类JRXmlDataSource是基于DOM，它使用XPath表达式来选择XML文档数据的数据源的实现。 XML数据源中的记录是通过XPath表达式选择的节点元素表示。字段值是由每个记录使用由字段描述（JRXML<fieldDescription>元素）所提供的XPath表达式检索。

> XPath是用于导航XML文档的属性和元素的语言。有关XPath更多信息可以在这里找到http://www.w3.org/TR/xpath.

CSV数据来源

JRCsvDataSource 代表了从结构化文本文件中检索其数据的数据源的实现，通常为CSV。字段值是正在使用他们的列索引检索。

xls数据来源

JRXlsDataSource 代表其检索的Excel文件的数据的数据源的实现。报表字段映射为这个数据源的实现也是基于字段列索引。

空数据来源

类JREmptyDataSource，模拟与内部虚拟空的记录给定数量的数据源。它是由用户界面的工具来提供基本的报表预览功能，或在特殊报告模板，或用于测试和调试目的。

重绕数据源

net.sf.jasperreports.engine.JRRewindableDataSource扩展的基本JRDataSourceinterface。它增加了只有一个方法为MoveFirst()到接口。这种方法的目的是将光标移动到数据源中的第一个元素。

与放置在带内子报表不允许拆分由于isSplitAllowed=“false”的设定，并且没有足够的空间，在当前页上对要呈现的子报表工作时，重绕的数据源是有用的。

以上所有数据源的实现是可回退除JRResultSetDataSource，因为它不支持移动记录指针回来。这对只有当该数据源是用它传递给子报表之前手动换一个java.sql.ResultSet中的一个问题。这是没有问题，如果SQL查询驻留在子报表模板，该引擎将在下一个页面上重新启动子报表时，再次执行它。

数据源提供者

JasperReports库有一个接口net.sf.jasperreports.engine.JRDataSourceProvider。这有助于创建和处理数据源对象。当创建使用GUI工具报表模板，则需要自定义报表的数据源的特殊工具。JRDataSourceProvider是为了堵塞自定义数据源到设计工具的标准方法。自定义实现该接口应实现以下方法，使创建和配置数据源对象和方法，上面列出数据源如果可能的话，里面可用的报表字段：

public boolean supportsGetFieldsOperation();

public JRField[] getFields(JasperReport report)
throws JRException, UnsupportedOperationException;

public JRDataSource create(JasperReport report) throws JRException;

public void dispose(JRDataSource dataSource) throws JRException;

JasperReports报表字段 - JasperReports教程

报表字段是代表数据源和报表模板之间的数据映射元素。字段可以在报告中的表达式进行组合，以获得所需的输出。报表模板可以包含零个或更多的<field>元素。当声明报表字段，数据源应提供相应的数据到所有在报告模板中定义的字段。

字段声明

字段声明做如下：

name属性

<field>元素的name属性是强制性的。它通过名称引用的报表表达的字段。

class属性

class属性指定的字段值的类名。它的默认值是java.lang.String。这是可以改变的，以在运行时可用任何类。不论一个报表字段的类型，引擎采用铸造于该$ F{}标记用于报表表达式，从而使手工投射不必要。

字段描述

<fieldDesciption>元素是可选元素。实现自定义的数据源，例如，当这是非常有用的。我们可以存储一个密钥或一些信息，使用它我们可以在运行时自定义数据源中检索字段的值。通过使用<fieldDesciption>元素而不是字段名，可以检索从数据源中的字段值时容易克服字段命名约定的限制。

下面是一段代码从我们现有的jrxml文件（第二章报告的设计）。在这里我们可以看到name, class 和 fieldDescription 元素的使用。

排序字段

数据的排序是必要的，数据源实现不支持它（如CSV数据源），JasperReports的支持在内存领域为基础的数据源排序。排序可以使用的报表模板的一个或多个<sortField>元素来完成。

如果指定ATLEAST1排序字段，在报告填充过程中的数据源传递给JRSortableDataSource实例。这反过来从获取数据源中的所有记录，根据指定的字段进行排序的内存中，并替换原来的数据源。

排序字段名称应该是相同的报表字段名称。用于排序的字段应该具有实现java.util.Comparable类型。进行自然顺序排序的所有字段除外java.lang.String类型（对于字符串类型，对应报告的填充区域自动分页使用）。当有多个排序字段指定，排序将使用的字段进行中它们出现在报告模板的顺序排序键。下面的例子demonstartes显示排序功能。

Sorted Report 例子

sortField>元素添加到我们现有的报告模板（第报表设计）。让我们排序字段country 降序排列。修订后的报告模板（jasper_report_template.jrxml）如下。将其保存到C: oolsjasperreports-5.0.1 est directory:

<?xml version="1.0"?>
<!DOCTYPE jasperReport PUBLIC
"//JasperReports//DTD Report Design//EN"
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">

<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="jasper_report_template" pageWidth="595" pageHeight="842" columnWidth="515" leftMargin="40" rightMargin="40" topMargin="50" bottomMargin="50">
<parameter name="ReportTitle" class="java.lang.String"/>
<parameter name="Author" class="java.lang.String"/>
<queryString>
<![CDATA[]]>
</queryString>
<field name="country" class="java.lang.String">
<fieldDescription><![CDATA[country]]></fieldDescription>
</field>
<field name="name" class="java.lang.String">
<fieldDescription><![CDATA[name]]></fieldDescription>
</field>
**<sortField name="country" order="Descending"/>
<sortField name="name"/>**
<title>
<band height="70">
<line>
<reportElement x="0" y="0" width="515"
height="1"/>
</line>
<textField isBlankWhenNull="true" bookmarkLevel="1">
<reportElement x="0" y="10" width="515"
height="30"/>
<textElement textAlignment="Center">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$P{ReportTitle}]]>
</textFieldExpression>
<anchorNameExpression><![CDATA["Title"]]>
</anchorNameExpression>
</textField>
<textField isBlankWhenNull="true">
<reportElement x="0" y="40" width="515" height="20"/>
<textElement textAlignment="Center">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$P{Author}]]>
</textFieldExpression>
</textField>
</band>
</title>
<columnHeader>
<band height="23">
<staticText>
<reportElement mode="Opaque" x="0" y="3"
width="535" height="15"
backcolor="#70A9A9" />
<box>
<bottomPen lineWidth="1.0"
lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]>
</text>
</staticText>
<staticText>
<reportElement x="414" y="3" width="121"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Country]]></text>
</staticText>
<staticText>
<reportElement x="0" y="3" width="136"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Name]]></text>
</staticText>
</band>
</columnHeader>
<detail>
<band height="16">
<staticText>
<reportElement mode="Opaque" x="0" y="0"
width="535" height="14"
backcolor="#E5ECF9" />
<box>
<bottomPen lineWidth="0.25"
lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]>
</text>
</staticText>
<textField>
<reportElement x="414" y="0" width="121"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$F{country}]]>
</textFieldExpression>
</textField>
<textField>
<reportElement x="0" y="0" width="136"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle" />
<textFieldExpression class="java.lang.String">
<![CDATA[$F{name}]]>
</textFieldExpression>
</textField>
</band>
</detail>
</jasperReport>

在java代码报告填充保持不变。该文件 C: oolsjasperreports-5.0.1 estsrccomyiibaiJasperReportFill.java 的内容如下：

package com.yiibai;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;

public class JasperReportFill {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
String sourceFileName =
"C://tools/jasperreports-5.0.1/test/jasper_report_template.jasper";

DataBeanList DataBeanList = new DataBeanList();
ArrayList<DataBean> dataList = DataBeanList.getDataBeanList();

JRBeanCollectionDataSource beanColDataSource =
new JRBeanCollectionDataSource(dataList);

Map parameters = new HashMap();
/**
* Passing ReportTitle and Author as parameters
*/
parameters.put("ReportTitle", "List of Contacts");
parameters.put("Author", "Prepared By Manisha");

try {
JasperFillManager.fillReportToFile(
sourceFileName, parameters, beanColDataSource);
} catch (JRException e) {
e.printStackTrace();
}
}
}

POJO文件C: oolsjasperreports-5.0.1 estsrccomyiibaiDataBean.java的内容如下：

文件 C: oolsjasperreports-5.0.1 estsrccomyiibaiDataBeanList.java 的内容如下：

报表生成

我们将编译和执行使用我们常规Ant构建过程上面的文件。 build.xml文件（目录下保存的内容 C: oolsjasperreports-5.0.1 est) 如下：

> 导入文件 - baseBuild.xml从环境设置章节中了解，并应放置在同一目录中的build.xml。

<?xml version="1.0" encoding="UTF-8"?>
<project name="JasperReportTest" default="viewFillReport" basedir=".">
<import file="baseBuild.xml" />
<target name="viewFillReport"
depends="compile,compilereportdesing,run"
description="Launches the report viewer to preview
the report stored in the .JRprint file.">
<java classname="net.sf.jasperreports.view.JasperViewer"
fork="true">
<arg value="-F${file.name}.JRprint" />
<classpath refid="classpath" />
</java>
</target>
<target name="compilereportdesing"
description="Compiles the JXML file and
produces the .jasper file.">
<taskdef name="jrc"
classname="net.sf.jasperreports.ant.JRAntCompileTask">
<classpath refid="classpath" />
</taskdef>
<jrc destdir=".">
<src>
<fileset dir=".">
<include name="*.jrxml" />
</fileset>
</src>
<classpath refid="classpath" />
</jrc>
</target>
</project>

接下来，打开命令行窗口并转到build.xml文件放置的目录。最后执行命令 ant -Dmain-class=com.yiibai.JasperReportFill （viewFullReport是默认的目标），如下所示：

C: oolsjasperreports-5.0.1 est>ant -Dmain-class=com.yiibai.JasperReportFill
Buildfile: C: oolsjasperreports-5.0.1 estuild.xml

clean-sample:
[delete] Deleting directory C: oolsjasperreports-5.0.1 estclasses
[delete] Deleting: C: oolsjasperreports-5.0.1 estjasper_report_template.jasper
[delete] Deleting: C: oolsjasperreports-5.0.1 estjasper_report_template.jrprint

compile:
[mkdir] Created dir: C: oolsjasperreports-5.0.1 estclasses
[javac] C: oolsjasperreports-5.0.1 estaseBuild.xml:28: warning:
'includeantruntime' was not set, defaulting to build.sysclasspath=last;
set to false for repeatable builds
[javac] Compiling 7 source files to C: oolsjasperreports-5.0.1 estclasses

compilereportdesing:
[jrc] Compiling 1 report design files.
[jrc] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.engine.xml.JRXmlDigesterFactory).
[jrc] log4j:WARN Please initialize the log4j system properly.
[jrc] log4j:WARN See http://logging.apache.org/log4j/1.2/faq.htmll#noconfig
for more info.
[jrc] File : C: oolsjasperreports-5.0.1 estjasper_report_template.jrxml ... OK.

run:
[echo] Runnin class : com.yiibai.JasperReportFill
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.extensions.ExtensionsEnvironment).
[java] log4j:WARN Please initialize the log4j system properly.

viewFillReport:
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.extensions.ExtensionsEnvironment).
[java] log4j:WARN Please initialize the log4j system properly.

BUILD SUCCESSFUL
Total time: 18 seconds

正如上文编译的结果，一个JasperViewer窗口打开如下面的屏幕：

Jasper Report Viewer

在这里，我们可以看到，country排列的字母顺序降序排列。

JasperReports报表表达式 - JasperReports教程

报表表达式是JasperReports使我们能够显示在报表上的数据计算的强大功能。计算出数据不是一个静态数据，并且不受特别的报表参数或数据源字段传递的数据。报表表达式是由组合报表参数，字段和静态数据。默认情况下，Java语言是用于编写报表的表达式。其他脚本语言如Groovy脚本语言，JavaScript或BeanShell脚本，报表表达式是由JasperReports编译器支持。

本章将解释如何报表表达式工作假设他们一直只用Java语言编写的。在JRXML报表模板，那里有定义表达式几个元素，如下所示：

<variableExpression>
<initialValueExpression>
<groupExpression>
<printWhenExpression>
<imageExpression>
<textFieldExpression>

声明表达式

基本上，所有的报表表达式是可以参考的报表字段，报表变量和报表参数Java表达式。

字段引用表达式

使用在表达式中一个报表字段参考，字段的名称必须放在$F{ 和 }字符序列之间，如下图所示。

下面是一段代码从我们现有的jrxml文件，从报表设计章节中了解：

变量引用表达式

引用在表达式中的变量，我们必须把像在下面的例子中的变量名放在$V {和}之间：

<textfieldexpression>
"Total height : " + $V{SumOfHeight} + " ft."
</textfieldexpression>

参数参考表达

引用在表达式中的一个参数，该参数的名称应放在$ P{和}之间，如下面的例子：

<textfieldexpression>
"ReportTitle : " + $P{Title}
</textfieldexpression>

下面是一段代码从现有的jrxml文件，这用来表示参数在表达式中引用。

正如在上面看到，参数，字段和变量引用，其实是真正的Java对象。从参数，字段或在报表模板所作的变量声明知道他们的类，甚至可以在表达式中调用的对象引用的方法。

下面的示例演示如何提取并显示java.lang.String报表字段的第一个字母 "Name":

<textFieldExpression>
$F{Name}.substring(0, 1)
</textFieldExpression>

资源包参考表达

引用在表达式中的资源，关键要$R{和}之间放像下面的例子：

<textfieldexpression>
$R{report.title}
</textfieldexpression>

基于运行时提供的语言环境和report.title键，报表模板相关的资源包加载。因此，报表标题是从资源包中提取字符串值显示。更多关于国际化可以在国际化一章中找到。

计算器

计算器是JasperReports，其计算表达式和增量变量或数据集在报表填充时间的实体。在编译过程中，信息被产生并存储在由编译器在编译报表。在报表，填充时间此信息用于构建net.sf.jasperreports.engine.fill.JRCalculator类的一个实例。

Java源文件生成，并通过对飞基于Java的报表编译器编译。这个生成的类是JRCalculator子类，并通过将其编译产生的字节码存储在JasperReport对象的内部。bytcode被加载在报表填充时间和由此产生的类被实例化，以获得所需的表达式求值计算器对象。

条件表达式

定义变量表达式时，Jasper报表不支持if-else语句。相反，可以使用三元运算符{cond}？ {语句1}：{语句2}。可以嵌套这个操作符Java表达式里面获得基于多个条件所需的输出。

在报表条件表达式的示例

让我们修改现有报告的模板（第报表设计），并增加对country条件表达式。修订后的报表模板（jasper_report_template.jrxml）如下。将其保存到 C: oolsjasperreports-5.0.1 est 目录:

<?xml version="1.0"?>
<!DOCTYPE jasperReport PUBLIC
"//JasperReports//DTD Report Design//EN"
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">

<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="jasper_report_template" pageWidth="595" pageHeight="842" columnWidth="515" leftMargin="40" rightMargin="40" topMargin="50" bottomMargin="50">
<parameter name="ReportTitle" class="java.lang.String"/>
<parameter name="Author" class="java.lang.String"/>
<queryString>
<![CDATA[]]>
</queryString>
<field name="country" class="java.lang.String">
<fieldDescription><![CDATA[country]]></fieldDescription>
</field>
<field name="name" class="java.lang.String">
<fieldDescription><![CDATA[name]]></fieldDescription>
</field>
<sortField name="country" order="Descending"/>
<sortField name="name"/>
<title>
<band height="70">
<line>
<reportElement x="0" y="0" width="515"
height="1"/>
</line>
<textField isBlankWhenNull="true" bookmarkLevel="1">
<reportElement x="0" y="10" width="515"
height="30"/>
<textElement textAlignment="Center">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$P{ReportTitle}]]>
</textFieldExpression>
<anchorNameExpression><![CDATA["Title"]]>
</anchorNameExpression>
</textField>
<textField isBlankWhenNull="true">
<reportElement x="0" y="40" width="515" height="20"/>
<textElement textAlignment="Center">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$P{Author}]]>
</textFieldExpression>
</textField>
</band>
</title>
<columnHeader>
<band height="23">
<staticText>
<reportElement mode="Opaque" x="0" y="3"
width="535" height="15"
backcolor="#70A9A9" />
<box>
<bottomPen lineWidth="1.0"
lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]>
</text>
</staticText>
<staticText>
<reportElement x="414" y="3" width="121"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Country]]></text>
</staticText>
<staticText>
<reportElement x="0" y="3" width="136"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Name]]></text>
</staticText>
</band>
</columnHeader>
<detail>
<band height="16">
<staticText>
<reportElement mode="Opaque" x="0" y="0"
width="535" height="14"
backcolor="#E5ECF9" />
<box>
<bottomPen lineWidth="0.25"
lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]>
</text>
</staticText>
<textField>
<reportElement x="414" y="0" width="121"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<textFieldExpression class="java.lang.String"> **<![CDATA[$F{country}.isEmpty() ? "NO COUNTRY" : $F{country}]]>**
</textFieldExpression>
</textField>
<textField>
<reportElement x="0" y="0" width="136"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle" />
<textFieldExpression class="java.lang.String">
<![CDATA[$F{name}]]>
</textFieldExpression>
</textField>
</band>
</detail>
</jasperReport>

Java代码填充报表如下。该文件的内容 C: oolsjasperreports-5.0.1 estsrccomyiibaiJasperReportFill.java 如下所述。

package com.yiibai;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;

public class JasperReportFill {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
String sourceFileName =
"C://tools/jasperreports-5.0.1/test/jasper_report_template.jasper";

DataBeanList DataBeanList = new DataBeanList();
ArrayList<DataBean> dataList = DataBeanList.getDataBeanList();

JRBeanCollectionDataSource beanColDataSource =
new JRBeanCollectionDataSource(dataList);

Map parameters = new HashMap();
/**
* Passing ReportTitle and Author as parameters
*/
parameters.put("ReportTitle", "List of Contacts");
parameters.put("Author", "Prepared By Manisha");

try {
JasperFillManager.fillReportToFile(
sourceFileName, parameters, beanColDataSource);
} catch (JRException e) {
e.printStackTrace();
}
}
}

POJO文件的内容 C: oolsjasperreports-5.0.1 estsrccomyiibaiDataBean.java 情况如下：

将增加country字段在Java bean列表为空的新纪录。该文件的内容C: oolsjasperreports-5.0.1 estsrccomyiibaiDataBeanList.java 情况如下：

package com.yiibai;

import java.util.ArrayList;

public class DataBeanList {
public ArrayList<DataBean> getDataBeanList() {
ArrayList<DataBean> dataBeanList = new ArrayList<DataBean>();

dataBeanList.add(produce("Manisha", "India"));
dataBeanList.add(produce("Dennis Ritchie", "USA"));
dataBeanList.add(produce("V.Anand", "India"));
dataBeanList.add(produce("Shrinath", "California")); **dataBeanList.add(produce("Tanmay", ""));**
return dataBeanList;
}

/**
* This method returns a DataBean object,
* with name and country set in it.
*/
private DataBean produce(String name, String country) {
DataBean dataBean = new DataBean();
dataBean.setName(name);
dataBean.setCountry(country);
return dataBean;
}
}

报表生成

我们将编译和执行使用我们常规Ant构建过程上面的文件。build.xml文件中的内容（根据目录保存：C: oolsjasperreports-5.0.1 est）情况如下。导入文件 - baseBuild.xml，并应放置在同一目录build.xml。

<?xml version="1.0" encoding="UTF-8"?>
<project name="JasperReportTest" default="viewFillReport" basedir=".">
<import file="baseBuild.xml" />
<target name="viewFillReport"
depends="compile,compilereportdesing,run"
description="Launches the report viewer to preview
the report stored in the .JRprint file.">
<java classname="net.sf.jasperreports.view.JasperViewer"
fork="true">
<arg value="-F${file.name}.JRprint" />
<classpath refid="classpath" />
</java>
</target>
<target name="compilereportdesing"
description="Compiles the JXML file and
produces the .jasper file.">
<taskdef name="jrc"
classname="net.sf.jasperreports.ant.JRAntCompileTask">
<classpath refid="classpath" />
</taskdef>
<jrc destdir=".">
<src>
<fileset dir=".">
<include name="*.jrxml" />
</fileset>
</src>
<classpath refid="classpath" />
</jrc>
</target>
</project>

C: oolsjasperreports-5.0.1 est>ant -Dmain-class=com.yiibai.JasperReportFill
Buildfile: C: oolsjasperreports-5.0.1 estuild.xml

clean-sample:
[delete] Deleting directory C: oolsjasperreports-5.0.1 estclasses
[delete] Deleting: C: oolsjasperreports-5.0.1 estjasper_report_template.jasper
[delete] Deleting: C: oolsjasperreports-5.0.1 estjasper_report_template.jrprint

compile:
[mkdir] Created dir: C: oolsjasperreports-5.0.1 estclasses
[javac] C: oolsjasperreports-5.0.1 estaseBuild.xml:28:
warning: 'includeantruntime' was not set, defaulting to build.sysclasspath=last;
set to false for repeatable builds
[javac] Compiling 3 source files to C: oolsjasperreports-5.0.1 estclasses

compilereportdesing:
[jrc] Compiling 1 report design files.
[jrc] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.engine.xml.JRXmlDigesterFactory).
[jrc] log4j:WARN Please initialize the log4j system properly.
[jrc] log4j:WARN See
http://logging.apache.org/log4j/1.2/faq.htmll#noconfig for more info.
[jrc] File : C: oolsjasperreports-5.0.1 estjasper_report_template.jrxml ... OK.

run:
[echo] Runnin class : com.yiibai.JasperReportFill
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.extensions.ExtensionsEnvironment).
[java] log4j:WARN Please initialize the log4j system properly.

viewFillReport:
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.extensions.ExtensionsEnvironment).
[java] log4j:WARN Please initialize the log4j system properly.

BUILD SUCCESSFUL
Total time: 5 minutes 5 seconds

C: oolsjasperreports-5.0.1 est>

正如上文编译的结果，JasperViewer窗口打开如下面的屏幕：

Jasper Report Viewer

在这里，可以看到，因为没有通过该字段country任何数据的最后一条记录，“NO COUNTRY”正在打印。

JasperReports报表变量 - JasperReports教程

报表变量是建立在报表表达式之上的特殊对象。报表变量简化以下任务：

报表，其中大量使用在整个报告模板表达式。这些表达式可以通过使用报表变量只能声明一次。
计数，求和，平均，最低，最高，方差等：报表变量可以基于像对应的表达式的值执行各种计算

如果变量是在报表设计定义，那么这些可以通过在表达式中的新变量引用。因此，在该变量是在报表设计中声明的顺序是非常重要的。

变量声明

变量声明如下：

如上面所看到的，<variable>元素包含属性的数量。这些属性总结如下：

name属性

类似的参数和字段，</variable>元素的name属性是强制性的。它允许引用由它的声明的名称在报表表达式中的变量。

class属性

class属性也是强制性的，它指定了变量值的类名。它的默认值是java.lang.String。这是可以改变的，在classpath可用的任何类无论是在报表编译时间和报告充填时间。无论报告值的类型，引擎采用该$V {}标记是用来报告表达，从而不必要手动投射。

计算方法

这个属性决定的变量填充报表时要执行什么计算。下面的小节描述所有的<variable>元素的计算属性的可能值。

Average: 变量的值是变量表达式的每一个非空值的平均值。有效期仅为数值变量。
Count: 该变量的值是变量表达式非空实例的数量。
First: 变量的值是变量表达式的第一个实例的值。随后的值将被忽略。
Highest: 变量的值是变量表达式的最高值。
Lowest: 该变量的值是变量表达式在报表中的最低值。
Nothing: 不进行计算的变量。
StandardDeviation: 该变量的值是所有非空值匹配报表表达式的标准偏差。有效期仅为数值变量。
Sum: 该变量的值是由报表表达式返回所有非空值的总和。
System: 该变量的值是一个自定义计算（计算该变量自己的值，使用JasperReports小脚本功能）
Variance: 该变量的值是一个报表变量的表达式求值返回的所有非空值的方差。

增量FACTORYCLASS

此属性确定填充报表上的当前记录时，用于计算变量的值的类。默认值是任何类实现net.sf.jasperreports.engine.fill.JRIncrementerFactory。工厂类将被用于由发动机来实例化对象的增量在运行时根据该变量中设置的计算属性。

INCREMENTTYPE

这个决定何时重新计算变量的值。此属性使用的值，如下：

Column: 该变量的值重新计算各列的结尾
Group: 当指定incrementGroup改变该组的变量值重新计算。
None: 该变量的值重新计算每个记录。
Page: 该变量的值被重新计算在每一页的末尾。
Report: 该变量的值被重新计算一次，在报表的末尾。

INCREMENTGROUP

这决定了该变量的值被重新计算，当incrementType是组的名称。这需要在JRXML报表模板中声明的任何组的名称。

RESETTYPE

这决定了当一个变量的值被复位。此属性使用的值，如下：

Column: 该变量的值复位在每一列的开头。
Group: 该变量的值是当指定incrementGroup修改组复位。
None: 该变量的值不会被重置。
Page: 该变量的值复位在每一页的开头。
Report: 该变量的值复位只有一次，在报表的开头。

RESETGROUP

这决定了该变量的值复位，当resetType是组的名称。该属性的值是在JRXML报表模板中声明的任何组的名称。

内置报表变量

有一些内置的系统变量，准备在表达式中使用，如下所示：

Variable Name	描述
PAGE_NUMBER	这个变量的值是它的当前页码。它可以被用来同时显示当前页面的数量和使用JasperReports文本字段的元素，evaluationTime属性的一种特殊的功能的总页数。
COLUMN_NUMBER	这个变量包含了当前的列号
REPORT_COUNT	此报表变量包含的处理记录的总数。
PAGE_COUNT	这个变量包含了生成当前页面时所处理的记录数。
COLUMN_COUNT	这个变量包含了生成当前列时所处理的记录数。
GroupName_COUNT	这个变量的名称是从它所对应的组，后缀为_COUNT序列的名称派生的。这个变量包含的记录在当前组的数量。

例子

让一个变量（countNumber）加入到现有的报表模板（第报表设计）。我们将前缀数到每个记录。修订后的报告模板（jasper_report_template.jrxml）如下。将其保存到C: oolsjasperreports-5.0.1 est 目录:

<?xml version="1.0"?>
<!DOCTYPE jasperReport PUBLIC
"//JasperReports//DTD Report Design//EN"
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">

<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports
http://jasperreports.sourceforge.net/xsd/jasperreport.xsd"
name="jasper_report_template" pageWidth="595"
pageHeight="842" columnWidth="515"
leftMargin="40" rightMargin="40" topMargin="50" bottomMargin="50">
<parameter name="ReportTitle" class="java.lang.String"/>
<parameter name="Author" class="java.lang.String"/>

<queryString>
<![CDATA[]]>
</queryString>

<field name="country" class="java.lang.String">
<fieldDescription>
<![CDATA[country]]>
</fieldDescription>
</field>

<field name="name" class="java.lang.String">
<fieldDescription>
<![CDATA[name]]>
</fieldDescription>
</field> **<variable name="countNumber" class="java.lang.Integer" calculation="Count">
<variableExpression>
<![CDATA[Boolean.TRUE]]>
</variableExpression>
</variable>**
<title>
<band height="70">
<line>
<reportElement x="0" y="0" width="515"
height="1"/>
</line>
<textField isBlankWhenNull="true" bookmarkLevel="1">
<reportElement x="0" y="10" width="515"
height="30"/>
<textElement textAlignment="Center">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$P{ReportTitle}]]>
</textFieldExpression>
<anchorNameExpression>
<![CDATA["Title"]]>
</anchorNameExpression>
</textField>
<textField isBlankWhenNull="true">
<reportElement x="0" y="40" width="515" height="20"/>
<textElement textAlignment="Center">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$P{Author}]]>
</textFieldExpression>
</textField>
</band>
</title>

<columnHeader>
<band height="23">
<staticText>
<reportElement mode="Opaque" x="0" y="3"
width="535" height="15"
backcolor="#70A9A9" />
<box>
<bottomPen lineWidth="1.0"
lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]>
</text>
</staticText>
<staticText>
<reportElement x="414" y="3" width="121"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Country]]></text>
</staticText>
<staticText>
<reportElement x="0" y="3" width="136"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Name]]></text>
</staticText>
</band>
</columnHeader>

<detail>
<band height="16">
<staticText>
<reportElement mode="Opaque" x="0" y="0"
width="535" height="14"
backcolor="#E5ECF9" />
<box>
<bottomPen lineWidth="0.25"
lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]>
</text>
</staticText>
<textField>
<reportElement x="414" y="0" width="121"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$F{country}]]>
</textFieldExpression>
</textField>
<textField>
<reportElement x="0" y="0" width="136"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle" />
<textFieldExpression class="java.lang.String"> **<![CDATA[" " + String.valueOf($V{countNumber}) +"."+$F{name}]]>**
</textFieldExpression>
</textField>
</band>
</detail>
</jasperReport>

在java代码报表充填保持不变。文件C: oolsjasperreports-5.0.1 estsrccomyiibaiJasperReportFill.java内容如下：

package com.yiibai;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;

public class JasperReportFill {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
String sourceFileName =
"C://tools/jasperreports-5.0.1/test/jasper_report_template.jasper";

DataBeanList DataBeanList = new DataBeanList();
ArrayList<DataBean> dataList = DataBeanList.getDataBeanList();

JRBeanCollectionDataSource beanColDataSource =
new JRBeanCollectionDataSource(dataList);

Map parameters = new HashMap();
/**
* Passing ReportTitle and Author as parameters
*/
parameters.put("ReportTitle", "List of Contacts");
parameters.put("Author", "Prepared By Manisha");

try {
JasperFillManager.fillReportToFile(
sourceFileName, parameters, beanColDataSource);
} catch (JRException e) {
e.printStackTrace();
}
}
}

POJO文件的内容 C: oolsjasperreports-5.0.1 estsrccomyiibaiDataBean.java的内容如下：

该文件 C: oolsjasperreports-5.0.1 estsrccomyiibaiDataBeanList.java 的内容如下：

报表生成

我们将编译和执行使用我们常规Ant构建过程上面的文件。 build.xml文件中的内容（根据目录保存在C: oolsjasperreports-5.0.1 est）如下。

<?xml version="1.0" encoding="UTF-8"?>
<project name="JasperReportTest" default="viewFillReport" basedir=".">
<import file="baseBuild.xml" />
<target name="viewFillReport"
depends="compile,compilereportdesing,run"
description="Launches the report viewer to preview
the report stored in the .JRprint file.">
<java classname="net.sf.jasperreports.view.JasperViewer"
fork="true">
<arg value="-F${file.name}.JRprint" />
<classpath refid="classpath" />
</java>
</target>
<target name="compilereportdesing"
description="Compiles the JXML file and
produces the .jasper file.">
<taskdef name="jrc"
classname="net.sf.jasperreports.ant.JRAntCompileTask">
<classpath refid="classpath" />
</taskdef>
<jrc destdir=".">
<src>
<fileset dir=".">
<include name="*.jrxml" />
</fileset>
</src>
<classpath refid="classpath" />
</jrc>
</target>
</project>

接下来，打开命令行窗口并转到build.xml文件放置的目录。最后执行的命令 ant -Dmain-class=com.yiibai.JasperReportFill （viewFullReport默认的目标），如下所示：

C: oolsjasperreports-5.0.1 est>ant -Dmain-class=com.yiibai.JasperReportFill
Buildfile: C: oolsjasperreports-5.0.1 estuild.xml

clean-sample:
[delete] Deleting directory C: oolsjasperreports-5.0.1 estclasses
[delete] Deleting: C: oolsjasperreports-5.0.1 estjasper_report_template.jasper
[delete] Deleting: C: oolsjasperreports-5.0.1 estjasper_report_template.jrprint

compile:
[mkdir] Created dir: C: oolsjasperreports-5.0.1 estclasses
[javac] C: oolsjasperreports-5.0.1 estaseBuild.xml:28: warning:
'includeantruntime' was not set, defaulting to build.sysclasspath=last;
set to false for repeatable builds
[javac] Compiling 7 source files to C: oolsjasperreports-5.0.1 estclasses

compilereportdesing:
[jrc] Compiling 1 report design files.
[jrc] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.engine.xml.JRXmlDigesterFactory).
[jrc] log4j:WARN Please initialize the log4j system properly.
[jrc] log4j:WARN See http://logging.apache.org/log4j/1.2/faq.htmll#noconfig
for more info.
[jrc] File : C: oolsjasperreports-5.0.1 estjasper_report_template.jrxml ... OK.

run:
[echo] Runnin class : com.yiibai.JasperReportFill
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.extensions.ExtensionsEnvironment).
[java] log4j:WARN Please initialize the log4j system properly.

viewFillReport:
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.extensions.ExtensionsEnvironment).
[java] log4j:WARN Please initialize the log4j system properly.

BUILD SUCCESSFUL
Total time: 18 seconds

正如上文编译的结果，一个JasperViewer窗口打开如下面的屏幕：

Jasper Report Viewer

在这里，我们看到，计数前缀为每个记录。

JasperReports报表区段 - JasperReports教程

我们将在本章开始，一个简单的报表模板的结构看。依样画葫芦JasperReports的结构报表模板归类到多个区段。部分是有规定的高度，并且可以包含像直线，矩形，图像或文本字段对象报表的部分。

通过提供的报表数据源的虚拟记录的报表引擎遍历，在报表填充的时候。根据每个部分的定义的行为，引擎则呈现每个报表节在适当的时候。举例来说，细节部分的数据源中呈现为每个记录。当页中断，页眉和页面页脚节在需要时提供。

在JasperReports术语，报表区段也被称为报表带区。部分是由一个或多个频段。这些部分在报告生成时间反复填充并写在文件最后。

主要章节

在JasperReports报表模板主要有以下几个部分：

下表总结了每个部分：

Section	描述
Title	本节中只出现一次在报表的开头。
Page Header	这部分出现在每一页的开头生成的文档中。
Column Header	这部分显示在生成的文档中的每一列的开头。如果报表只有一个定义列，那么列标题和脚注部分被忽略。
Group Header	这部分是由一个报告组（组章）引入。每次分组表达式改变其值，组页眉部分上面印的细节部分。在情况下，如果超过一个组被定义，组页眉打印在组定义的顺序。
Detail	这部分是重复的报表的数据源提供的数据的每一行。细节部分可以由多个频段。
Group Footer	这部分是由一个报告组（组章）引入。该组页脚节印下的分组表达式的值更改前的细节部分。组页脚始终打印在数据源的数据的最后一行。在情况下，如果超过一个组被定义，组页脚打印在组定义的顺序相反。
Column Footer	本节将出现在每一列的底部。如果报告的列数为1，则列标题和脚注部分被忽略。
Page Footer	本节出现在每个页面的底部。
Last Page Footer	这部分取代了报表的最后一页上的常规页页脚。在情况下，摘要部分也存在，那么这可能不是该文件的最后一页。这部分有时是有用的，当汇总信息具有在最后一页的底部显示。
Summary	本节中只出现一次在报告的末尾。
No Data	这部分被打印时，当无资料打印报表属性设置为无数据段。如果<noData>部在报告模板中定义，并且如果数据源是空的，那么<noData>部分将是唯一一个在填充时考虑，其含量将产生报表输出。
Background	背景部分会显示每一页上，并不能溢出到下一个页面。放在这一部分的元素在页面初始化的时候求值，并显示在背景中。所有其他的页面对象被显示在背景上对象的顶部。这部分是用于创建页面水印有用。

部分，元素和属性的关系

下图显示的元素和属性在报表中的部分关系。

Report Sections

section元素

所有上述报表部分都是可选的。但任何报表模板将至少有一个这样的部分。每一节都包含一个单一的<band>元素作为其唯一的子元素。一个<band>可以包含零个或多个下列子元素：

, , , , , , or

这些元素都必须包含一个<reportElement>作为其第一个元素（除了elementGroup）。一个<reportElement>决定了数据是如何奠定了该特定元素。与变量和参数，不要求报表内容有一个名字，因为通常不需要获得一个报表模板内的任何单个元素。

下表总结了<reportElement>属性：

属性	描述	有效值
x	指定频带元件的x坐标。	一个整数值，表示以像素为单位的元素的x坐标。此属性是必需的。
y	指定频带元件的y坐标。	一个整数值，表示在y以像素为元素的坐标。此属性是必需的。
width	指定频带元件的宽度。	一个整数值，表示该元素的宽度以像素为单位。此属性是必需的。
height	指定频带元件的高度。	一个整数值，表示以像素为元素的高度。此属性是必需的。
key	带元素的唯一标识符。	唯一字符串值。
stretchType	指定包含带延伸当元素如何延伸	NoStretch (default): 该元素不会延长。RelativeToTallestObject: 该元素将伸展以适应它的组的最高的对象。RelativeToBand: 该元素将延伸到适合带的高度。
positionType	指定当频带延伸元素的位置。	Float: 元素将取决于周围元件的尺寸移动。FixRelativeToTop (default): 该元素将保持一个固定的位置相对于带的顶部。FixRelativeToBottom: 该元素将保持一个固定的位置相对于带的底部。
isPrintRepeatedValues	如果指定的值重复打印。	true (default): 重复的值将被打印出来。false: 重复的值将不被打印出来。
mode	指定元素的背景模式	不透明的，透明的
isRemoveLineWhenBlank	如果指定了当它是空白，并有在相同的水平空间没有其他元素的元素应被删除。	true, false
isPrintInFirstWholeBand	如果指定的元素必须打印在整个频段，也就是说，未被报表的页面或列之间分割的波段。	true, false
isPrintWhenDetailOverFlows	指定是否当频带溢出到新页或列中的元素将被打印出来。	true, false
printWhenGroupChanges	指定在指定的组改变元素将被打印。	string值
forecolor	指定元素的前景色。	无论前面加上＃字符，或以下预定义值中的一个十六进制RGB值：black, blue, cyan, darkGray, gray, green, lightGray, magenta, orange, pink, red, yellow, white.
backcolor	指定元素的背景颜色。	同样作为有效值的前景色

段属性

以下是报表的部分属性：

高度

该部分的高度指定高度，该特定部分的像素，是非常重要的在整体报表设计。

打印当表达式

布尔表达式，确定该部分是否应打印或不打印。

SPLIT ALLOWED

一个标志，指示该部分是否允许分裂时，它不适合在当前页面上。如果为true，该部分将被转移到下一个页面。注意，如果一节不适合下页上，那么将会考虑该标志的值的拆分。 splitType可以利用以下值：

splitType="Stretch" : 拆分拉伸内容。如果该部分在当前页上延伸（如果可用空间小于宣高度），这是添加到原始高度的区域是否允许分割到下页
splitType="Prevent" : 避免在第一次尝试分割。如果部分不适合在下一页中，分割通常发生，预防频带分割是有效的只有在第一次分割尝试。
splitType="Immediate" : 立即绘制。该频段允许的任何地方，除了分割高于其最顶端的元素。

例子

为演示开始每个部分让我们编写报表模板（jasper_report_template.jrxml）。将此文件保存到C: oolsjasperreports-5.0.1 est目录。在这个文件中，我们将显示在每个部分的文本（上面所讨论的）。该文件的内容如下所述：

<?xml version="1.0" encoding="UTF-8"?>
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports
http://jasperreports.sourceforge.net/xsd/jasperreport.xsd"
name="jasper_report_template" pageWidth="300" pageHeight="300" columnWidth="300"
leftMargin="0" rightMargin="0" topMargin="0" bottomMargin="0" >

<title>
<band height="50">
<textField>
<reportElement x="100" y="16"
width="100" height="20"/>
<textElement/>
<textFieldExpression>
<![CDATA["Title"]]>
</textFieldExpression>
</textField>
</band>
</title>
<pageHeader>
<band height="40">
<textField>
<reportElement mode="Opaque" x="100" y="10"
width="90" height="20"/>
<textElement>

</textElement>
<textFieldExpression>
<![CDATA["Page Header"]]>
</textFieldExpression>
</textField>
</band>
</pageHeader>
<columnHeader>
<band height="40">
<textField>
<reportElement x="100" y="10" width="90"
height="20"/>
<textElement>

</textElement>
<textFieldExpression>
<![CDATA["Column Header"]]>
</textFieldExpression>
</textField>
</band>
</columnHeader>
<detail>
<band height="40">
<textField>
<reportElement mode="Opaque" x="100" y="10" width="90"
height="20" backcolor="#99CCFF"/>
<textElement/>
<textFieldExpression>
<![CDATA["Report Details"]]>
</textFieldExpression>
</textField>
</band>
</detail>
<columnFooter>
<band height="40">
<textField>
<reportElement x="100" y="10" width="90"
height="20"/>
<textElement/>
<textFieldExpression>
<![CDATA["Column Footer"]]>
</textFieldExpression>
</textField>
</band>
</columnFooter>
<pageFooter>
<band height="40">
<textField>
<reportElement x="100" y="10"
width="90" height="20"/>
<textElement/>
<textFieldExpression>
<![CDATA["Page Footer"]]>
</textFieldExpression>
</textField>
</band>
</pageFooter>
<lastPageFooter>
<band height="40">
<textField>
<reportElement x="100" y="10" width="90"
height="20"/>
<textElement/>
<textFieldExpression>
<![CDATA["Last Page Footer"]]>
</textFieldExpression>
</textField>
</band>
</lastPageFooter>
<summary>
<band height="40">
<textField>
<reportElement x="100" y="10" width="90"
height="20"/>
<textElement/>
<textFieldExpression>
<![CDATA["Summary"]]>
</textFieldExpression>
</textField>
</band>
</summary>
</jasperReport>

java代码填写并生成报告如下。保存这个文件JasperReportFill.java 到 C: oolsjasperreports-5.0.1 estsrccomyiibai 目录.

package com.yiibai;

import net.sf.jasperreports.engine.JREmptyDataSource;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperFillManager;

public class JasperReportFill {
public static void main(String[] args) {
String sourceFileName =
"C://tools/jasperreports-5.0.1/test/" +
"jasper_report_template.jasper";

try {
JasperFillManager.fillReportToFile(sourceFileName, null,
new JREmptyDataSource());
} catch (JRException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}

在这里，我们填充报表时，以模拟一个数据源，在这一个记录使用JREmptyDataSource的实例，但与所有在这个单一记录为null的字段。

报表生成

将编译和执行使用常规Ant构建过程上面的文件build.xml文件中的内容（根据目录保存：C: oolsjasperreports-5.0.1 est）情况如下。(saved under directory C: oolsjasperreports-5.0.1 est) 如下.

<?xml version="1.0" encoding="UTF-8"?>
<project name="JasperReportTest" default="viewFillReport" basedir=".">
<import file="baseBuild.xml" />
<target name="viewFillReport"
depends="compile,compilereportdesing,run"
description="Launches the report viewer to preview
the report stored in the .JRprint file.">
<java classname="net.sf.jasperreports.view.JasperViewer"
fork="true">
<arg value="-F${file.name}.JRprint" />
<classpath refid="classpath" />
</java>
</target>
<target name="compilereportdesing"
description="Compiles the JXML file and
produces the .jasper file.">
<taskdef name="jrc"
classname="net.sf.jasperreports.ant.JRAntCompileTask">
<classpath refid="classpath" />
</taskdef>
<jrc destdir=".">
<src>
<fileset dir=".">
<include name="*.jrxml" />
</fileset>
</src>
<classpath refid="classpath" />
</jrc>
</target>
</project>

接下来，让我们打开命令行窗口并转到build.xml文件放置的目录。最后执行的命令 ant -Dmain-class=com.yiibai.JasperReportFill（viewFullReport是默认的目标），如下所示：

C: oolsjasperreports-5.0.1 est>ant -Dmain-class=com.yiibai.JasperReportFill
Buildfile: C: oolsjasperreports-5.0.1 estuild.xml

clean-sample:
[delete] Deleting directory C: oolsjasperreports-5.0.1 estclasses
[delete] Deleting: C: oolsjasperreports-5.0.1 estjasper_report_template.jasper
[delete] Deleting: C: oolsjasperreports-5.0.1 estjasper_report_template.jrprint

compile:
[mkdir] Created dir: C: oolsjasperreports-5.0.1 estclasses
[javac] C: oolsjasperreports-5.0.1 estaseBuild.xml:28:
warning: 'includeantruntime' was not set, defau
[javac] Compiling 1 source file to C: oolsjasperreports-5.0.1 estclasses

compilereportdesing:
[jrc] Compiling 1 report design files.
[jrc] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.engine.xml.JRXmlDigesterFac
[jrc] log4j:WARN Please initialize the log4j system properly.
[jrc] log4j:WARN See http://logging.apache.org/log4j/1.2/faq.htmll#noconfig for more info.
[jrc] File : C: oolsjasperreports-5.0.1 estjasper_report_template.jrxml ... OK.

run:
[echo] Runnin class : com.yiibai.JasperReportFill
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.extensions.ExtensionsEnviro
[java] log4j:WARN Please initialize the log4j system properly.

viewFillReport:
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.extensions.ExtensionsEnviro
[java] log4j:WARN Please initialize the log4j system properly.

BUILD SUCCESSFUL
Total time: 18 minutes 22 seconds

正如上文编译的结果，JasperViewer窗口打开如下面的屏幕：

Jasper Report Viewer

在这里，我们可以在每个文本被打印的部分看到。但应当注意的是，作为JRXML包含<lastPageFooter>元件，它将被显示在报表，而不是所显示的<pageFooter>元素的最后一页。如果有多个列的<columnHeader>和<columnFooter>元素将只显示在报告中。

JasperReports报表组 - JasperReports教程

组在JasperReports的协助组织对报告的数据以逻辑方式。报告组代表连续记录的数据源中有一些共同点，比如某个报表字段的值的序列。报告组由<group>元素定义。一个报表可以有任意数量的组。一旦声明，群体可以在整个报告中提到的。

报告组有三个要素：

Group expression: 这表示必须改变，以启动一个新的数据组中的数据。
Group header section: 帮助位置标签在分组数据的开始。
Group footer section: : 帮助位置标签在分组数据的末尾。

在截至于若该组表达变化，一组发生断裂和相应的<groupFooter>和<groupHeader>部分的值插入到生成的文档中报告充填时数据源的迭代。

> 报表组的机制不执行由数据源所提供的资料的任何排序。数据分组按预期工作，只有当数据源中的记录按照报告中使用的组表达式已经下令。

属性组

<group>元素包含属性，使我们能够控制分组的数据是如何布局。属性概括于下表：

属性	描述
name	这是强制性的。它通过名称引用该组中的报表表达式。它遵循相同的命名约定我们，我们提到的报告参数，字段和报表变量。它可以在其他JRXML属性被用于当想引用一个特定的报告组。
isStartNewColumn	当设置为true时，每个数据组将开始一个新的列。默认值是false
isStartNewPage	当设置为true时，每个数据组将开始一个新的页面上。默认值是false
isResetPageNumber	当设置为true，该报告页码将每一个新组开始时被重置。默认值是false
isReprintHeaderOnEachPage	当设置为true时，组头会被重印每一页上。默认值是false
minHeightToStartNewPage	定义在列的底部，以便将组头当前列所需要的垂直空间最小量。被指定在报告单位的数量。
footerPosition	呈现在页面上的组页脚的位置，以及其有关的报告的部分它后面的行为。它的值可以是: Normal, StackAtBottom, ForceAtBottom, CollateAtBottom.默认值是 Normal
keepTogether	当设置为true，将阻止该集团从分割它第一次突破的尝试

例子

让我们添加一个组（CountryGroup）现有的报告模板（章报表设计）。每个国家的次数进行计数，计数显示为组页脚。在组头中每个记录的计数前缀。修订后的报告模板（jasper_report_template.jrxml）如下。将其保存到 C: oolsjasperreports-5.0.1 est 目录：

<?xml version="1.0"?>
<!DOCTYPE jasperReport PUBLIC
"//JasperReports//DTD Report Design//EN"
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">

<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports
http://jasperreports.sourceforge.net/xsd/jasperreport.xsd"
name="jasper_report_template" pageWidth="595"
pageHeight="842" columnWidth="515"
leftMargin="40" rightMargin="40" topMargin="50" bottomMargin="50">
<parameter name="ReportTitle" class="java.lang.String"/>
<parameter name="Author" class="java.lang.String"/>

<queryString>
<![CDATA[]]>
</queryString>

<field name="country" class="java.lang.String">
<fieldDescription><![CDATA[country]]></fieldDescription>
</field>

<field name="name" class="java.lang.String">
<fieldDescription><![CDATA[name]]></fieldDescription>
</field>
<sortField name="country" order="Descending"/>
<sortField name="name"/>
<variable name="CountryNumber" class="java.lang.Integer"
incrementType="Group" incrementGroup="CountryGroup"
calculation="Count">
<variableExpression><![CDATA[Boolean.TRUE]]></variableExpression>
</variable> **<group name="CountryGroup" minHeightToStartNewPage="60">
<groupExpression><![CDATA[$F{country}]]></groupExpression>
<groupHeader>
<band height="20">
<textField evaluationTime="Group" evaluationGroup="CountryGroup"
bookmarkLevel="1">
<reportElement mode="Opaque" x="0" y="5" width="515"
height="15" backcolor="#C0C0C0"/>
<box leftPadding="10">
<bottomPen lineWidth="1.0"/>
</box>
<textElement/>
<textFieldExpression class="java.lang.String">
<![CDATA[" " + String.valueOf($V{CountryNumber}) + ". "
+ String.valueOf($F{country})]]>
</textFieldExpression>
<anchorNameExpression>
<![CDATA[String.valueOf($F{country})]]>
</anchorNameExpression>
</textField>
</band>
</groupHeader>
<groupFooter>
<band height="20">
<staticText>
<reportElement x="400" y="1" width="60" height="15"/>
<textElement textAlignment="Right"/>
<text><![CDATA[Count :]]></text>
</staticText>
<textField>
<reportElement x="460" y="1" width="30" height="15"/>
<textElement textAlignment="Right"/>
<textFieldExpression class="java.lang.Integer">
<![CDATA[$V{CountryGroup_COUNT}]]>
</textFieldExpression>
</textField>
</band>
</groupFooter>
</group>**
<title>
<band height="70">
<line>
<reportElement x="0" y="0" width="515"
height="1"/>
</line>
<textField isBlankWhenNull="true" bookmarkLevel="1">
<reportElement x="0" y="10" width="515"
height="30"/>
<textElement textAlignment="Center">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$P{ReportTitle}]]>
</textFieldExpression>
<anchorNameExpression><![CDATA["Title"]]>
</anchorNameExpression>
</textField>
<textField isBlankWhenNull="true">
<reportElement x="0" y="40" width="515" height="20"/>
<textElement textAlignment="Center">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$P{Author}]]>
</textFieldExpression>
</textField>
</band>
</title>

<columnHeader>
<band height="23">
<staticText>
<reportElement mode="Opaque" x="0" y="3"
width="535" height="15"
backcolor="#70A9A9" />
<box>
<bottomPen lineWidth="1.0"
lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]>
</text>
</staticText>
<staticText>
<reportElement x="414" y="3" width="121"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Country]]></text>
</staticText>
<staticText>
<reportElement x="0" y="3" width="136"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<text><![CDATA[Name]]></text>
</staticText>
</band>
</columnHeader>

<detail>
<band height="16">
<staticText>
<reportElement mode="Opaque" x="0" y="0"
width="535" height="14"
backcolor="#E5ECF9" />
<box>
<bottomPen lineWidth="0.25"
lineColor="#CCCCCC" />
</box>
<textElement />
<text><![CDATA[]]>
</text>
</staticText>
<textField>
<reportElement x="414" y="0" width="121"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle">

</textElement>
<textFieldExpression class="java.lang.String">
<![CDATA[$F{country}]]>
</textFieldExpression>
</textField>
<textField>
<reportElement x="0" y="0" width="136"
height="15" />
<textElement textAlignment="Center"
verticalAlignment="Middle" />
<textFieldExpression class="java.lang.String">
<![CDATA[$F{name}]]>
</textFieldExpression>
</textField>
</band>
</detail>
</jasperReport>

在java代码报表填充保持不变。该文件的内容 C: oolsjasperreports-5.0.1 estsrccomyiibaiJasperReportFill.java 如下：

package com.yiibai;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;

public class JasperReportFill {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
String sourceFileName =
"C://tools/jasperreports-5.0.1/test/jasper_report_template.jasper";

DataBeanList DataBeanList = new DataBeanList();
ArrayList<DataBean> dataList = DataBeanList.getDataBeanList();

JRBeanCollectionDataSource beanColDataSource =
new JRBeanCollectionDataSource(dataList);

Map parameters = new HashMap();
/**
* Passing ReportTitle and Author as parameters
*/
parameters.put("ReportTitle", "List of Contacts");
parameters.put("Author", "Prepared By Manisha");

try {
JasperFillManager.fillReportToFile(
sourceFileName, parameters, beanColDataSource);
} catch (JRException e) {
e.printStackTrace();
}
}
}

该POJO文件的内容 C: oolsjasperreports-5.0.1 estsrccomyiibaiDataBean.java 如下：

该文件的内容C: oolsjasperreports-5.0.1 estsrccomyiibaiDataBeanList.java 如下：

报表生成

我们将编译和执行使用我们常规Ant构建过程上面的文件.build.xml文件中的内容（根据目录保存 C: oolsjasperreports-5.0.1 est）如下：

<?xml version="1.0" encoding="UTF-8"?>
<project name="JasperReportTest" default="viewFillReport" basedir=".">
<import file="baseBuild.xml" />
<target name="viewFillReport"
depends="compile,compilereportdesing,run"
description="Launches the report viewer to preview
the report stored in the .JRprint file.">
<java classname="net.sf.jasperreports.view.JasperViewer"
fork="true">
<arg value="-F${file.name}.JRprint" />
<classpath refid="classpath" />
</java>
</target>
<target name="compilereportdesing"
description="Compiles the JXML file and
produces the .jasper file.">
<taskdef name="jrc"
classname="net.sf.jasperreports.ant.JRAntCompileTask">
<classpath refid="classpath" />
</taskdef>
<jrc destdir=".">
<src>
<fileset dir=".">
<include name="*.jrxml" />
</fileset>
</src>
<classpath refid="classpath" />
</jrc>
</target>
</project>

接下来，让我们打开命令行窗口并转到build.xml文件放置的目录。最后执行的命令ant -Dmain-class=com.yiibai.JasperReportFill （viewFullReport是默认的目标），如下所示：

C: oolsjasperreports-5.0.1 est>ant -Dmain-class=com.yiibai.JasperReportFill
Buildfile: C: oolsjasperreports-5.0.1 estuild.xml

clean-sample:
[delete] Deleting directory C: oolsjasperreports-5.0.1 estclasses
[delete] Deleting: C: oolsjasperreports-5.0.1 estjasper_report_template.jasper
[delete] Deleting: C: oolsjasperreports-5.0.1 estjasper_report_template.jrprint

compile:
[mkdir] Created dir: C: oolsjasperreports-5.0.1 estclasses
[javac] C: oolsjasperreports-5.0.1 estaseBuild.xml:28: warning:
'includeantruntime' was not set, defaulting to build.sysclasspath=last;
set to false for repeatable builds
[javac] Compiling 7 source files to C: oolsjasperreports-5.0.1 estclasses

compilereportdesing:
[jrc] Compiling 1 report design files.
[jrc] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.engine.xml.JRXmlDigesterFactory).
[jrc] log4j:WARN Please initialize the log4j system properly.
[jrc] log4j:WARN See http://logging.apache.org/log4j/1.2/faq.htmll#noconfig
for more info.
[jrc] File : C: oolsjasperreports-5.0.1 estjasper_report_template.jrxml ... OK.

run:
[echo] Runnin class : com.yiibai.JasperReportFill
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.extensions.ExtensionsEnvironment).
[java] log4j:WARN Please initialize the log4j system properly.

viewFillReport:
[java] log4j:WARN No appenders could be found for logger
(net.sf.jasperreports.extensions.ExtensionsEnvironment).
[java] log4j:WARN Please initialize the log4j system properly.

BUILD SUCCESSFUL
Total time: 18 seconds

正如上文编译的结果，JasperViewer窗口打开如下面的屏幕：

Jasper Report Viewer

在这里，我们看到，各个国家分组和发生每个国家的计数显示在每个组页脚。

教程

「喜欢这篇文章，您的关注和赞赏是给作者最好的鼓励」

关注作者

读者
前提条件
1 - Java教程
2 - ANT教程
JasperReports入门，JasperReports是什么？ - JasperReports教程
- 什么是报表
- 报表模板
- Jasper报表
- JasperReports的特点
JasperReport环境设置 - JasperReports教程
- JasperReport环境配置
- 设置CLASSPATH
- 生成安装
- Jasper 管理类
- 设置Apache ANT
JasperReport生命周期 - JasperReports教程
JasperReport报表设计 - JasperReports教程
- 创建一个JRXML报表模板
- 预览XML报表模板
JasperReport编译报表设计 - JasperReports教程
- JRXML提供编程编译
  - 模板编译
  - 预览编译报表模板
- 通过ANT任务编译
JasperReport填充报表 - JasperReports教程
- 填充报告模板
- 生成报表
JasperReport查看和打印报告 - JasperReports教程
- 查看报表
  - 查看生成的报告
- 打印报表
  - 打印生成的报告
JasperReport导出报表 - JasperReports教程
- 导出为其他格式
- 生成报表
JasperReport报表参数 - JasperReports教程
- 参数声明
  - name属性
  - class属性
- 内置参数
- 例子
- 报表生成
JasperReports报表数据源 - JasperReports教程
- 数据源的实现
  - JDBC数据源
  - JAVABEAN数据来源
  - 基于MAP的数据来源
  - TableModel的数据来源
  - XML数据源
  - CSV数据来源
  - xls数据来源
  - 空数据来源
- 重绕数据源
- 数据源提供者
JasperReports报表字段 - JasperReports教程
- 字段声明
  - name属性
  - class属性
  - 字段描述
  - 排序字段
- Sorted Report 例子
- 报表生成
JasperReports报表表达式 - JasperReports教程
- 声明表达式
  - 字段引用表达式
  - 变量引用表达式
  - 参数参考表达
  - 资源包参考表达
- 计算器
- 条件表达式
- 在报表条件表达式的示例
- 报表生成
JasperReports报表变量 - JasperReports教程
- 变量声明
  - name属性
  - class属性
  - 计算方法
  - 增量FACTORYCLASS
  - INCREMENTTYPE
  - INCREMENTGROUP
  - RESETTYPE
  - RESETGROUP
- 内置报表变量
- 例子
- 报表生成
JasperReports报表区段 - JasperReports教程
- 主要章节
  - 部分，元素和属性的关系
- section元素
- 段属性
  - 高度
  - 打印当表达式
  - SPLIT ALLOWED
- 例子
  - 报表生成
JasperReports报表组 - JasperReports教程
- 属性组
- 例子
- 报表生成