功能说明：
　　Java归档工具

语法：
　　jar [ 命令选项 ] [manifest] destination input-file [input-files]

补充说明：
　　jar工具是个java应用程序，可将多个文件合并为单个JAR归档文件。jar是个多用途的存档及压缩工具，它基于ZIP和ZLIB压缩格式。然而，设计jar的主要目的是便于将java applet或应用程序打包成单个归档文件。将applet或应用程序的组件(.class 文件、图像和声音)合并成单个归档文件时，可以用java代理(如浏览器)在一次HTTP事务处理过程中对它们进行下载，而不是对每个组件都要求一个新连接。这大大缩短了下载时间。jar还能压缩文件，从而进一步提高了下载速度。此外，它允许applet的作者对文件中的各个项进行签名，因而可认证其来源。jar工具的语法基本上与tar命令的语法相同。

命令选项
　　-c 在标准输出上创建新归档或空归档。

　　-t 在标准输出上列出内容表。

　　-x[file] 从标准输入提取所有文件，或只提取指定的文件。如果省略了file，则提取所有文件；否则只提取指定文件。

　　-f 第二个参数指定要处理的jar文件。在-c(创建)情形中，第二个参数指的是要创建的jar文件的名称(不是在标准输出上)。在-t(表(或-x(抽取)这两种情形中，第二个参数指定要列出或抽取的jar文件。

　　-v 在标准错误输出设备上生成长格式的输出结果。

　　-m 包括指定的现有清单文件中的清单信息。用法举例：“jar cmf myManifestFile myJarFile *.class”

　　-0 只储存，不进行 ZIP 压缩。

　　-M 不创建项目的清单文件。

　　-u 通过添加文件或更改清单来更新现有的 JAR 文件。例如：“jar -uf foo.jar foo.class”将文件 foo.class 添加到现有的JAR文件foo.jar中，而“jar umf manifest foo.jar”则用manifest中的信息更新foo.jar的清单。

　　-C 在执行 jar 命令期间更改目录。例如：“jar -uf foo.jar -C classes *”将classes目录内的所有文件加到foo.jar中，但不添加类目录本身。

程序示例
　　1:将当前目录下所有CLASS文件打包成新的JAR文件：
　　jar cf file.jar *.class

　　2:显示一个JAR文件中的文件列表
　　jar tf file.jar

　　3:将当前目录下的所有文件增加到一个已经存在的JAR文件中
　　jar cvf file.jar *
　

javadoc使用说明

功能说明
　　Java API文档生成器从Java源文件生成API文档HTML页。

语法：
　　javadoc [ 命令选项 ] [ 包名 ] [ 源文件名 ] [ @files ]
　　其中[ 包名 ]为用空格分隔的一系列包的名字，包名不允许使用通配符，如（*）。[ 源文件名 ]为用空格分隔的一系列的源文件名，源文件名可包括路径和通配符，如（*）。[ @files ]是以任何次序包含包名和源文件的一个或多个文件。

补充说明
　　Javadoc解析Java源文件中的声明和文档注释，并产生相应的HTML页缺省），描述公有类、保护类、内部类、接口、构造函数、方法和域。

　　在实现时，Javadoc要求且依赖于java编译器完成其工作。Javadoc调用部分javac编译声明部分，忽略成员实现。它建立类的内容丰富的内部表示，包括类层次和“使用”关系，然后从中生成HTML。Javadoc还从源代码的文档注释中获得用户提供的文档。

　　当Javadoc建立其内部文档结构时，它将加载所有引用的类。由于这一点，Javadoc必须能查找到所有引用的类，包括引导类、扩展类和用户类。

命令选项
　　-overview i>path/filename 指定javadoc应该从path/filename所指定的“源”文件中获取概述文档，并将它放到概述页中（overview-summary.html）。其中path/filename 是相对于-sourcepath的相对路径名。

　　-public 只显示公有类及成员。

　　-protected 只显示受保护的和公有的类及成员。这是缺省状态。

　　-package 只显示包、受保护的和公有的类及成员。

　　-private 显示所有类和成员。

　　-help 显示联机帮助，它将列出这些javadoc和doclet命令行选项。

　　-doclet class 指定启动用于生成文档的docle 的类文件。该doclet定义了输出的内容和格式。如果未使用-doclet选项，则javadoc使用标准doclet生成缺省HTML格式。该类必须包含start(Root)法。该启动类的路径由 -docletpath选项定义。

　　-docletpath classpathlist 指定doclet类文件的路径，该类文件用-doclet选项指定。如果doclet已位于搜索路径中，则没有必要使用该选项。

　　-1.1 生成具有用Javadoc 1.1生成的文档的外观和功能的文档。也就是说，页的背景为灰色，用图像做页眉，使用bullet列表而不是表格，具有单层目的目录结构，不包含继承 API，不使?*** TML框架，并且不支持内部类。该选项还自动将索引分割成每个字母一个文件。如果想要这种外观，则该选项比javadoc 1.1优越之处等于修正了一些错误。

　　-sourcepath sourcepathlist
　　当将包名传递到javadoc命令中时，指定定位源文件（.java）的搜索路径。注意只有当用 javadoc命令指定包名时才能使用sourcepath选项 -- 它将不会查找传递到javadoc命令中的.java文件。如果省略-sourcepath，则javadoc使用类路径查找源文件。

　　-classpath classpathlist 指定javadoc将在其中查找引用类的路径 -- 引用类是指带文档的类加上它们引用的任何类。Javadoc将搜索指定路径的所有子目录。classpathlist可以包括多个路径，彼此用逗号分隔。

　　-bootclasspath classpathlist 指定自举类所在路径。它们名义上是Java平台类。这个bootclasspath是Javadoc将用来查找源文件和类文件的搜索路径的一部分。在 classpathlist中用冒号（:）分隔目录。

　　-extdirs dirlist 指定扩展类所在的目录。它们是任何使用Java扩展机制的类。这个 extdirs是Javadoc将用来查找源文件和在文件的搜索路径的一部分。在dirlist中用冒号（:）分隔目录。

　　-verbose 在javadoc运行时提供更详细的信息。不使用verbose选项时，将显示加载源文件、生成文档（每个源文件一条信息）和排序的信息。verbose选项导致打印额外的信息，指定解析每个java源文件的毫秒数。

　　-locale language_country_variant 指定javadoc在生成文档时使用的环境。

　　-encoding name 指定源文件编码名，例如EUCJIS/SJIS。如果未指定该选项，则使用平台缺省转换器。

　　-J[flag] 将flag直接传递给运行javadoc的运行时系统java。注意在J和flag之间不能有空格。
标准 Doclet 提供的选项

　　-d directory 指定javadoc保存生成的HTML件的目的目录。省略该选项将导致把文件保存到当前目录中。其中directory可以是绝对路径或相对当前工作目录的相对路径。

　　-use 对每个带文档类和包包括一个“用法”页。该页描述使用给定类或包的任何 API 的包、类、方法、构造函数和域。对于给定类 C，使用类 C 的任何东西将包括 C 的子类、声明为 C 的域、返回 C 的方法以及具有 C 类型参数的方法和构造函数。

　　-version 在生成文档中包括 @version 文本。缺省地将省略该文本。

　　-author 在生成文档中包括 @author 文本。

　　-splitindex 将索引文件按字母分割成多个文件，每个字母一个文件，再加上一个包含所有以非字母字符开头的索引项的文件。

　　-windowtitle[title] 指定放入 HTML
　
 
相关文章：
>>Cookie的传递流程及安全问题
>>JAVA生成JPG缩略图
>>上传图片的缩放处理
>>学习JSP的一些心得.jsp
>>怎样打包成可执行的jar文件.jsp
>>开发晋级篇：Java性能优化技巧集锦
>>为何我写的邮件发送程序不能正确发送邮件？
>>一个邮件发送的API（可以带附件和群发）
 

JavaDoc命令使用说明

作者：未知    转贴自：网络收藏    点击数：25

javadoc的命令行语法如下：
javadoc [ options ] [ packagenames ] [ sourcefiles ] [ @files ]
参数可以按照任意顺序排列。下面分别就这些参数和相关的一些内容进行说明：
• Packagenames 包列表。这个选项可以是一系列的包名（用空格隔开），例如java.lang java.lang.reflect java.awt。不过，因为javadoc不递归作用于子包，不允许对包名使用通配符；所以你必须显示地列出希望建立文档的每一个包。
• Sourcefiles 源文件列表。这个选项可以是一系列的源文件名（用空格隔开），可以使用通配符。javadoc允许四种源文件：类源代码文件、包描述文件、总体概述文件、其他杂文件。
◇ 类源代码文件：类或者接口的源代码文件。
◇ 包描述文件：每一个包都可以有自己的包描述文件。包描述文件的名称必须是package.html，与包的.java文件放置在一起。包描述文件的内容通常是使用HTML标记写的文档。javadoc执行时将自动寻找包描述文件。如果找到，javadoc将首先对描述文件中之间的内容进行处理，然后把处理结果放到该包的Package Summary页面中，最后把包描述文件的第一句（紧靠）放到输出的Overview summary页面中，并在语句前面加上该包的包名。
◇ 总体概述文件：javadoc可以创建一个总体概述文件描述整个应用或者所有包。总体概述文件可以被任意命名，也可以放置到任意位置。-overview选项可以指示总体概述文件的路径和名称。总体概述文件的内容是使用HTML标记写的文档。javadoc在执行的时候，如果发现-overview选项，那么它将首先对文件中之间的内容进行处理；然后把处理后的结果放到输出的Overview summary 页面的底部；最后把总体概述文件中的第一句放到输出的Overview summary页面的顶部。
◇ 其他杂文件：这些文件通常是指与javadoc输出的HTML文件相关的一些图片文件、Java源代码文件（.java）、Java程序（.class）、Java小程序（Applets）、HTML文件。这些文件必须放在doc-files目录中。每一个包都可以有自己的doc-files目录。举个例子，你希望在java.awt.Button的HTML文档中使用一幅按钮的图片（Button.gif）。首先，你必须把图片文件放到C:usersrcjavaawtdoc-files中；然后在Button.java文件中加入下面注释
/**
* This button looks like this:
*
*/
• @files 包含文件。为了简化javadoc命令，你可以把需要建立文档的文件名和包名放在一个或多个文本文件中。例如，为了简化下面命令：
javadoc -d apidoc com.mypackage1 com.mypackage2 com.mypackage3
你可以建立一个名称为mypackage.txt的文件，其内容如下：
com.mypackage1
com.mypackage2
com.mypackage3
然后执行下面命令即可：
javadoc -d apidoc @mypackage.txt
• options 命令行选项。javadoc使用doclets（doclets是指用doclet API编写的程序。）来确定输出的内容和格式。命令行选项中一部分是可用于所有doclet的通用选项，一部分是由默认的标准doclet提供的专用的选项。下面对各自一些常用的选项分别进行介绍：
通用选项：
◇ -1.1 生成具有javadoc 1.1版本生成的文档的外观和功能的文档。不是所有的选项都可以用于-1.1选项，具体可以使用javadoc -1.1 -help察看。
◇ -help 显示联机帮助。
◇ -bootclasspath classpathlist 指定根类（通常是Java平台自带的一些类。例如java.awt.*等）的路径。
◇ -sourcepath sourcepathlist 指定包的源文件搜索路径。但是必须注意，只有在javadoc命令中指定了包名的时候才可以使用-sourcepath选项。如果指定了包名，而省略了-sourcepath，那么javadoc使用类路径查找源文件。举例说明：假定你打算为com.mypackage建立文档，其源文件的位置是C:usersrc。那么你可以使用下面的命令：
javadoc -sourcepath c:usersrc com.mypackage
◇ -classpath classpathlist 指定javadoc查找引用类的路径。引用类是指带文档的类加上它们引用的任何类。javadoc将搜索指定路径的所有子目录。Classpathlist可以包含多个路径（使用;隔开）。如果省略-classpath，则javadoc使用-sourcepath查找源文件和类文件。举例说明：假定你打算为com.mypackage建立文档，其源文件的位置是C:usersrc，包依赖C:userlib中的库。那么你可以使用下面的命令：
javadoc -classpath c:userlib -sourcepath c:usersrc com.mypackage
◇ -overview pathfilename 告诉javadoc从pathfilename所指定的文件中获取概述文档，并且把它放到输出的概述页面（overview-summary.html）中。其中pathfilename是相对于-sourcepath的相对路径。
◇ -public 只显示公共类以及成员。
◇ -protected 只显示受保护的和公共的类以及成员。缺省选项。
◇ -package只显示包、受保护的和公共的类以及成员。
◇ -private 显示所有类和成员。
◇ -doclet class 指定javadoc产生输出内容的自定义doclet类。如果忽略这个选项，javadoc将使用默认的doclet产生一系列HTML文档。
◇ -docletpath classpathlist 与- doclet选项相关，制定自定义的doclet类文件的路径。Classpathlist可以包含多条路径（用;隔开）。
◇ -verbose 在javadoc运行时提供更详细的信息。
标准doclet专用选项：
◇ -author 在生成的文档中包含作者项。
◇ - d directory 指定javadoc保存生成的HTML文件的目录。省略该选项将把文件保存在当前目录。Directory可以是绝对目录，也可以是相对当前目录的相对目录。
◇ -version 在生成的文档中包含版本项。
◇ -use 为类和包生成use（用法）页面。这些页面描述了该类和包在javadoc命令涉及的文件中被使用的情况。例如：对于给定的类C，在C的用法页面中将包含C的子类，类型为C的域，返回变量类型为C的方法以及在参数中有变量类型为C的方法和构造器。
◇ -splitindex 把索引文件按照字母顺序分为多个文件。每一个文件对应一个字母。
◇ -windowtitle title 指定输出的HTML文档的标题。
◇ -header header 指定输出的HTML文档的页眉文本。
◇ -footer footer 指定输出的HTML文档的脚注文本。
◇ -bottom text 指定输出的HTML文档底部的文本。
◇ - group groupheading packagepatten;packagepatten;… 在总体概述页面中按照命令的指定方式分隔各个包。例如执行下面命令：
javadoc -group Core Packages java.lang*:java.util
-group Extension Packages javax.*
java.lang java.lang.reflect java.util javax.servlet java.new
在页面中将有如下结果：
Core Packages
java.lang
java.lang.reflect
java.util
Extension Packages
javax.servlet
Other Packages
java.new
◇ - noindex 不输出索引文件。
◇ - help 在文件的导航条中忽略help链接。
◇ - helpfile pathfilename 指定导航条中的help链接所指向的帮助文件。忽略该选项，javadoc将生成缺省的帮助文件。
◇ -stylesheetfile pathfilename 指定javadoc的HTML样式表文件的路径。忽略该选项，javadoc将自动产生一个样式表文件stylesheet.css。
JavaDoc文档标记
javadoc注释以/**开始，以*/结束，里面可以包含普通文本、HTML标记和javadoc标记。javadoc只处理源文件中在类/接口定义、方法、域、构造器之前的注释，忽略位于其他地方的注释。举例如下：
/**
*Demo--Helloworld
*@author sunjl
*@version 1.0 2001/10/15
*/
public class myHelloworld
{
/**
*在main( )方法中使用的显示用字符串
*@see #main(java.lang.String[])
*/
static String SDisplay;
/**
*显示HelloWorld
*@param args 从命令行中带入的字符串
*@return 无
*/
public static void main(String args[])
{
SDisplay = Hello World ;
System.out.println( SDisplay );
}
}

使用下面命令：
javadoc -private -d doc -author -version myHelloworld.java
即可以生成漂亮的关于myHelloworld.java的API文档了。
上面例子中以@开头的标记就是javadoc标记。在Java程序中正确使用javadoc标记是一个良好的注释习惯，将非常有助于javadoc自动从源代码文件生成完整的格式化API文档。下面就对各种标记进行详细说明。
◇ @author name-text 指定生成文档中的作者项，从JDK/SDK 1.0开始引入。name-text可以指定多个名字（使用,隔开）。文档注释可以包含多个类。
◇ {@docroot} 代表产生文档的根路径，从JDK/SDK 1.3开始引入。用法举例如下
/**
*see the copyright
*/
假定生成文档的根目录是doc，上面注释所在的文件最后生成的文件是docutilityutl.html，那么copyright的链接会指向..copyright.html。
◇ @deprecated deprecated-text 添加注释，表明不推荐使用该API。
◇ @exception class-name description @throw的同义标记，从JDK/SDK 1.0开始引入。
◇ {@link package.class#member label} 插入指向package.class#member的内嵌链接，从JDK/SDK 1.2开始引入。举例说明，假定注释中有如下文档：
/** Use the {@link #getComponentAt(int, int) getComponentAt} method. */
那么javadoc最终生成的HTML页面中将有如下内容
Use the getComponentAt method.
◇ @param parameter-name description 描述参数，从JDK/SDK 1.0开始引入。
◇ @return description 描述返回值，从JDK/SDK 1.0开始引入。
◇ @see reference 添加参见标题，其中有指向reference的链接或者文本项，从JDK/SDK 1.0开始引入。@see标记有三种形式，下面分别说明：
（1）、@see string 为string添加文本项，不产生链接。
（2）、@see Label 使用HTML标记产生链接
（3）、@see package.class#member Label 使用Java语言的名字package.class #member产生链接。
◇ @serial field-description 用于缺省可序列化域的注释，从JDK/SDK 1.2开始引入。
◇ @serialField field-name field-type field-description 建立Serializable类的serialPersistentFields成员的ObjectStreamField组件的文档，从JDK/SDK 1.2开始引入。
◇ @serialData data-description data-description建立数据序列和类型的文档，从JDK/SDK 1.2开始引入。
◇ @since since-text 利用since-text内容为文档增加since标题，从JDK/SDK 1.1开始引入。
◇ @throws class-name description 与@exception同义。用class-name和description为输出文档添加抛出标题，从JDK/SDK 1.2开始引入。
◇ @version version-text 添加版权标题，从JDK/SDK 1.0开始引入。
上面介绍了标准doclet提供的所有标记。不过，需要注意这些标记的使用是有位置限制的。其中可以出现在类或者接口文档注释中的标记有：@see、{@link}、@since、@deprecated、@author、@version。可以出现在方法或者构造器文档注释中的标记有：@see、{@link}、@since、@deprecated、@param、@return、@throws、@exception、@serialData。可以出现在域文档注释中的有：@see、{@link}、@since、@desprecated、@serial、@serialField。
除了javadoc自身提供的标准标记以外，我们可以定制自己的标记吗？当然可以。只需要对javadoc标准的doclet程序进行扩充即可。实际上，利用javadoc提供的doclet API，不仅可以扩充doclet标记，甚至还可以改变javadoc的整个输出。为了满足需要，你可以使javadoc输出普通文本、XML文件等。由于扩充doclet涉及到Java编程，本文不再做深入介绍。
总之，javadoc提供了完整规范的API文档功能。在软件项目管理中，合理地使用javadoc不仅可以减少开发时的文档工作量，提高效率；而且还非常有利于将来软件的修改和维护。
JavaDoc 书写规范：
1、 File Header Comments : 每个文件都应该加上文件头标记，包括文件名、修改历史、版权信息和附加信息。例如：

/**
* @(#)demo.java 1.00 2002/05/27
*
* Copyright (c) 2000-2002 中国平安保险股份有限公司 版权所有
* Ping An Insurance Company of China. All rights reserved.

* This software is the confidential and proprietary
* information of Ping An Insurance Company of China.
* (Confidential Information). You shall not disclose
* such Confidential Information and shall use it only
* in accordance with the terms of the contract agreement
* you entered into with Ping An.
*/

2、class description:类信息，概括的描述类的功能和实现。
/** class description
*/
3、Variable Description:描述变量的意义和取值含义。
/** var variable description
*/
4、Method Description:标明每个方法的输入、输出参数和返回值类型，说明特殊变量取值的含义。相关类文档链接。
/** method description
* @param var signification
* @exception exception class name
* @return return_value return signification
*/

5、Association Description:关联类文档描述，在注释当中需要参引其它文档描述的地方，可在相应的注释当中如下插入：
/** method description
* @param var signification
* @exception exception class name
* @return return_value return signification
* @see package.class#member label
*/
6、包描述文件：概括描述包的功能和设计概要。为每个包创建一个描述文件，命名为package.html，与包的java文件放在一起。
注：javadoc生成文档时，会将该html文件的第一句放在package summary中，而把整个内容放在Overview summary中.

转载自:Jar使用说明和JavaDoc的使用说明

第一部分：使用iReport制作报表的详细过程（Windows环境下）

第二部分：使用Jasperreport作为报表控件开发胖客户端报表应用

第三部分：使用Jasperreport作为报表控件开发Web报表应用

第一部分：使用iReport制作报表的详细过程（Windows环境下）

1、前言

在网络上可以搜索到很多使用iReport和Jasperreport配合实现各种报表任务的文章，但是我觉得很少有一篇（几乎没有）做一个比较详细的介绍如何使用iReport制作报表的全过程，我所看过的文章的基本思想是覆盖面广，很多内容都是提及即过，并不是开发人员都有时间为每个实践花费时间自己实现，如果能有更详细的资料，那岂不是一件乐事。出于这个念头促使我写这篇文章，希望能对那些使用iReport和Jasperreport朋友有所帮助，特别是需要亲身去实现报表的朋友，希望能给你们带来一点帮助。本文不是对iReport的每个细节进行介绍，关于iReport的每个细节可以参考iReport网站的资料，但是可能得花费一些费用。一般用户没有必要付出这些费用，因为我们关心的是如何制作我们需要的报表，而不是去扩展iReport，比如制作iReport的插件。

2、准备

2.1、下载JDK

地址：http://www.sun.com，选择1.3以上版本（建议1.4.2以上版本），安装JDK，默认安装即可；如果你的系统已经有安装过JDK或是有JRE即可省略这一步骤，验证JDK或是JRE是否可以默认运行，在命令行（CMD）打入X:>java 如果出现：Usage：java………………………..开头的一堆信息既是通过验证。否则必须进行配置，配置信息如下，在windows的环境变量设置：

path：在最后面加入“;java的安装目录”

JAVA_HOME ：“java的安装目录”

CLASSPATH：“java的安装目录\bin”

重新验证JDK或是JRE是否可以在CMD任何位置运行

2.2、下载iReport

地址：http://ireport.sourceforge.net/，选择0.3.2版本（发稿之前为止建议使用的版本）解压iReport在任意目录，解压后的文件里面有一个iReport.bat，通过双击，过大约30秒钟如果可以弹出iReport的主窗体即表明你的系统已经可以运行iReport了，如果不能弹出主窗体，一般是第一步骤错误，或是没有完成。

2.3、准备数据库

iReport支持绝大部分数据库，只要该数据库能提供JDBC驱动器。本文提供MySql数据库作为例子，但是文章最后会提到如何配置Oracle的支持。关于数据库的安装和建立表不属于本文的范围，请参考其他资料。本文假设已经安装了MySql和在MySql已经有一些表，并且确定表中已经有数据了。

*【特别提示】MySql的版本要求与iReport文件夹下的Lib目录的使用MySql驱动程序兼容，笔者建议到 http://dev.mysql.com/downloads/ 下载最新版本mysql的驱动器，这样就不会应为JDBC驱动器的问题而当心数据库的支持问题。

2.4、启动MySql服务

确定Mysql使用的的字符集是重要的问题，特别是对需要中文报表的朋友，应该特别注意这个问题。

2.5、确定商务逻辑

       也就是希望完成什么样的报表任务。需要实现的报表的详细描述，这是实现报表的业务条件，否则所有的任务绝大部分没有意义。本文使用一个Bug记录表为例，本文的例子是制作一个根据项目和项目中的模块分组的Bug量统计。

3、开始配置基本信息

3.1、配置界面使用的语言和报表输出路径

       第一次进入系统是英文环境，可以通过【Tools】－【Options】开启配置iReport系统的基本信息对话框。在“Language”选项里面选择你需要的界面语言，比如“中文－中国”。点击【Apply】按钮，系统既把整个界面中文化。

       在配置iReport系统的基本信息对话框中选择【编译】Label，之后决定你的报表输出路径，可以把“编译在报表数据文件夹”选择打勾，这样报表的jrxml文件和jasper文件就放置同一文件夹。（在新建报表时会要求你把jrxml文件保存到指定的文件夹）

【Options】选项中的一部分参数修改不能通过【Apply】按钮直接起作用，比如“Look&Feel”，必须重新启动iReport才能起作用。不知道是不是iReport的Bug？！最后【存档】。

3.2、配置MySql的数据库连接

       这就是报表与数据库的接口。可以通过【资料来源】－【连接/资料来源】开启配置列表对话框，iReport会记录以前使用的所有连接，除非你手工删除这些连接，否则所有的连接都会存在连接/资料来源配置列表对话框中，不管是否确实可用。

       点击【New】进入配置新连接界面，如图：

填写JDBC连接需要的信息，iReport支持多种数据源连接，如图：

本文只是介绍DataBase JDBC Connection连接方式，这也是最常用的方式，特别是在嵌入式报表应用。所有的信息填写并测试通过之后，最后就是保存信息。回到配置列表对话框，关闭对话框，完成MySql数据库JDBC连接配置。

提示：如果你需要报表提供中文内容显示可以在JDBC URL下工夫，比如输入：

jdbc:mysql://localhost/SUBRDB?user=****&password=****&useUnicode=true&characterEncoding=GB2312

其中的****号替换成数据库的用户合密码。

3.3、新建一个空报表的基本配置

单击工具栏的第一个工具“New Report”，新建一个报表，输入报表名称和定义报表的一些参数，比如名称输入BugsRpt（例子是做一个项目的Bug量统计报表）,单击【More….】选择标签，填写或是选择XML编码，这是关系到你的XML支持的字符集的选择，请根据需要选择，比如需要你的XML文件支持中文，那么可以输入GB2312或是GBK，之后点击【OK】按钮，进入报表的设计界面。

*【特别提示】请在开始任何工作之前保存报表，这时iReport提示保存报表的位置，选择合适的位置之后输入BugsRpt作为名称。

3.4、定义报表可能需要的字体类型及其属性

       一个报表的内容五花八门，有表头、栏位名、数据、其他变量信息等等，如果这些信息都是一致的字体和属性（比如颜色），那么整个报表就死气沉沉，显得很粗糙了。我们可以在为报表添加每个元素时定义元素的属性，但是那是一个多么费时的工作，如果能预先定义一些属性的组合，之后在创建每个元素时只需选择这些组合的其中一个即可，省事又快速。

       单击【预览】－【报表字体】开启自定义组合对话框。单击【New】进入定义详细对话框，如图：按照图中的顺序填写信息和步骤，依次定义“表头”、“组”、“列”、“列内容”、“统计计算”、“其他”等6中字体组合。注意PDF内嵌字体的选择，如果你需要报表时以PDF文件格式提供，那么对此需要作出选择。

4、理解几个重要的概念

4.1、iReport的输出格式

iReport的预览输出格式可以支持以下几种：

PDF、HTML、CSV、JAVA2D、Excel、纯文字、JRViewer，其中最常用的是PDF、JRViewer。本文以JRViewer为例子。JRViewer是直接以C/S方式作为报表的输出格式，在JFrame框架下输出。Jasperreport提供默认的JRViewer输出类。

4.2、报表的动态对象变量、参数、字段

在使用iReport的过程中会碰到很多与变量（Variables）、参数（Parameters）、字段（Fields）这些有关的内容，我们要介绍这些对象的使用和意义：

·字段（Fields）：是数据库抽取出来的，希望在报表中出现的数据库内容。比如一个ID的所有值。$F{ filedsName }

·参数（Parameters）：这是你的应用需要提供给报表的入口，比如你希望在报表被解释的时候提供Where语句的条件值，那么就可以使用参数（Parameters）。$P{ parameterName }

·变量（Variables）：这是报表中一些逻辑运算的表现，比如统计值。$V{ variablesName }

每种对象的定义格式如每个对象的后面说明，比如定义一个变量（Variables），那么表达式就写成$V{ variablesName }，报表中出现的就是这个变量的名称。后文会详细的介绍使用方法。

4.3、编译、静态运行、动态运行

Jasperreport运行时需要的就是一个jasper后缀的文件，编译过程其实就是把jrxml后缀的文件生成jasper后缀的文件。（可以参考Jasperreport的运行原理）

静态运行和动态运行是相对的，后者带数据源运行，比如带数据库运行。前者就是静态文本运行，和数据源无关，如果报表中出现和数据源有关的对象，则以null显示。

4.4、报表结构

       一个报表的结构大致是几个部分：title、pageHeader、columnHeader、detial、columnFooter、pageFooter、summary、groupHeader、groupfooter。

·Title：每个报表一般会有一个名字，比如×××销售报表，title就是搁置这个名称的最好地方了，当然你也可以根据需要搁置在合适的地方。

·pageHeader：报表的一些公共要素，比如页码、创建时间、创建人等信息放置在这里是比较好的选择。

·columnHeader：无可非议的这里是放置列的名称，记住不是列数据。

·Detial：放置需要循环的数据，比如销售记录数据。

·columnFooter：放置列级别的统计计算值或是列的说明。

·pageFooter：放置页级别的统计值或是页的说明。

·Summary：可能需要对几页（你的报表可能有几个页组成）的统计值。比如50个销售记录共占用了3页，那么放置这些统计记录的统计值最好的地方就是summary。

·groupHeader：每个表的内容可能需要根据某个属性进行划分显示内容和计算内容，比如希望以月份为单位每组分开显示销售记录，那么就可以定义一个组（组的定义参考后文），groupHeader就是放置组说明或是组标志最好的地方。

·Groupfooter：放置组的统计或是说明

5、向表添加对象

5.1、添加静态对象

可以通过工具栏的工具添加静态对象，比如文本，点击【T】，之后在报表的空白处单击，如此即可把静态对象添加到报表，然后拖动对象的边框，使它的大小合适，双击对象弹出对象的属性配置对话框，切换到【Font】Label，在“Report font”的ComBox选择“表头”字体，（表头字体是前文提供的自定义属性组合），再切换到【Static Text】Label，修改表头的名字，比如“Bug统计报表”或是“销售记录统计表”等等与业务有关的内容。添加图片，请点击【Image Tool】，之后的操作与Text类似。其他静态对象操作步骤类似。

5.2、使用连接

       还记得前文提供的（3.2节）配置MySql数据库连接吗？这里我们将要使用前文配置的连接了。选择菜单【建立】－【使用动态连接】开启可选的动态连接，选择任何一个你需要的连接最后【OK】，保存报表，这样你的报表就使用了这个连接了。

*【特别提示】此连接必须与以后应用程序使用的连接一致。

5.3、创建SQL查询语句

       SQL语句是对任何RDBMS起作用的语言，外部用户需要使用这些语言管理维护数据库中的数据，同样的，iReport也是需要这么做，我们需要提供查询数据库的语言－SQL语句，这样，iReport即可通过此SQL语句获取数据，之后组织到报表中并显示出来，以满足用户的需要为目的。

       通过菜单【资料来源】－【报表查询】开启SQL输入对话框，并在【Report SQL Query】 Label中输入SQL语句如图：图中的“Automatically Retrieve Fields”checkbox和“ReadFields”Button是确认自动获取还是手动获取数据库表的可用Fields。单击【OK】，保存报表。

5.4、创建字段动态对象

报表的动态对象有变量、参数、字段，前文提及了他们的概念，这里将要一一讲解如何使用。

字段也就是数据库中的字段，通过菜单【预览】－【报表字段】开启字段的列表（工具条上可以找到相应的工具），可以拖放任意字段到报表的任何位置，比如拖动一部分Bug的内容字段到detial段（内容无关紧要，只要知道原理）。

5.5、创建组

组是一个很重要的概念，一个报表可以多个组，每个组以一个关键字为标记，比如希望Bug统计是根据项目（或是产品）进行统计的。那么可以设立一个项目标记的组。如图：

组的参数设定可以看界面即可理解部分，其中最主要的是“Group expression”，这是必须输入格式正确的并且存在的字段名称，本文的“proname”是【字段】中的一个元素。依此类推，建立其他的组对象。每建立一个组，在报表的界面上都会出现该组对应的段，如图：至于他们的意义和容纳的内容参考“4.4报表结构”，他们是首尾对应出现的。（Header和Footer）

5.6、添加参数和使用参数

我们重申参数作用，一般是需要外界提供参数给报表的入口，比如SQL语句的where条件的表达式。通过【预览】－【报表参数】开启报表参数列表对话框（工具条上可以找到相应的工具）。如图：输入名称及其他参数。【ok】,保存报表。

那么如何使用呢？打开SQL语句对话框，参考“5.3创建SQL查询语句”，这时候的SQL语句应该是：

SELECT *

FROM bugs  where proname=$P{ProjectName} order by proname,modulename

注意其中的红体字部分，就是把刚才定义的变量运用到SQL语句了。这样当应用提供参数时，只要指定提供给这个参数，那么报表解释引擎即可替换这些变量然后再执行SQL语句，在第二部分提到编程时，会提供参数设定代码。

5.7、添加变量和使用变量

变量的定义类似参数，通过【预览】－【报表变量】开启报表变量列表对话框（工具条上可以找到相应的工具），如图，图中定义的变量的作用是：定义一个Bug的计数器，数据类型是java.lang.Integer,使用Count函数进行统计字段tester，作用范围是模块组，也就是统计模块的Bug量。其中的tester可以改成其他非组对象，比如proname是组对象，就不要用作这里的统计参数。以上提供的是自定义变量，其实iReport系统还有提供一些内嵌（Buildin）的变量，比如页码，行记录数等，视需要而使用。

6、最后的报表

6.1、完成后的报表

6.2、预览报表

点击动态运行报表，出现如图内容：

7、总结

第一部分只是介绍了如何制作一个动态数据报表，其实iReport还有提供很多的特性供开发人员使用，比如柱状图、饼图、及各种形状的图形等，满足企业绝大部分应用的需求。希望你能继续研究并充分利用。    

    关于使用Oracle数据库作为数据源的内容：提供与使用的Oracle版本对应的JDBC驱动，把驱动放置在iReport的lib目录，配置数据库的JDBC连接时如图：其它操作基本没有区别。

8、补充内容

8.1、实现表格

可以在Detial中加入必要线条实现表格，配合columnFooter、columnHeader、Detial这3个位置实现，您可以试试画线的位置！

第二部分：使用Jasperreport作为报表控件开发胖客户端报表应用

1、概述

我们对第一部分的内容做个简要的回忆，第一部分主要是介绍使用iReport如何制作一个数据报表，我认为文章比较详细的介绍“如何从零到满足大部分需求报表出现”。但是文中没有涉及Jasperreport的任何内容，目的是让你纯粹的理解如何做报表，因为做报表和把报表内嵌到应用程序编程是可以分工的，便于整合也便于分解。

我们知道iReport是一个Jasperreport的前端开发工具，iReport用来制作和预览报表，为应用使用报表提供足够的前端支持。现在简要的介绍Jasperreport是如何工作的，这样你可以更好的理解iReport是如何帮助Jasperreport实现前端的工作，其实这些工作在我们看来就是“脏活”，为什么呢？看看下面的资料就知道了。

        通过上图你大概已经明白Jasperreport的工作原理了。首先是要有一个XML文件（一般是以jrxml后缀），那么这个XML文件从那里来呢？做什么用呢？ 这个XML文件就是报表的定义文件，整个报表的每一个细节都在这个XML文件之中定义，一个简单报表的xml文件就有几百行，你可以手工编辑这个XML文件（一行一行，一段一段的编辑吧――这就是所谓的“脏活”）。如果是手工制作这个XML文件，单从效率上考虑就不允许，特别是现在很多应用系统的开发时间变得越来越紧张，总是会在时间上出问题。节省时间最好的办法就是充分的利用自动化工具，詹姆斯.马丁的软件工程思想也是反复的强调过程的自动化，如何做到自动化呢？就是充分的利用自动化工具集成到开发流程，说了一大堆不就是为了说要用iReport来做报表吗！这是我们第一部分已经完成的工作，但是这里重要的是理解Jasperreport的工作原理。

2、结合Jbuilder开发胖客户端报表应用

2.1、建立Application

参考Jbuilder有关资料。只要是普通Window窗口应用即可。

2.2、引入JasperReports需要的库文件

通过jbuilder9【Tool】－【configure Libraries】－按最左边的【New】－输入一个名称，比如Report－【add】按钮，导航到iReport的lib目录，把lib目录里面的所有文件引入。如图：

按两次OK回到Jbuilder的开发界面。

2.3、向工程添加Report系列库文件

通过右击工程，选择【properties】－【paths】Label－【Required Libraries】Label－【Add】按钮－选择“Report”－按两次OK回到Jbuilder的开发界面。这样就添加完成了需要的库文件了。这么做是比较理想的，但是报表运行时可能不需要iReport的lib下所有的jar文件。

2.4、在主界面上添加需要的组件

在主Frame添加一个Button和一个Label以及一个TextBox，当然你也可以通过创建菜单连接，如图：

这个窗体时用来做测试用的，实际的界面可能很复杂，其中的TextBox就是为报表的变量做准备的。这里填写的值就是要传递给报表的变量，也就是第一部分定义的带$P{}符号的变量，程序会把他们对应起来。Button的单击事件代码如下：

/**

   * RptDialog对话框是用来承载报表的显示。

   * @param e

   */

  void jButton1_actionPerformed(ActionEvent e) {

        //请创建一个对话框类RptDialog

     RptDialog dlg = new RptDialog(this.jGroupID.getText());

     Dimension dlgSize = dlg.getPreferredSize();

     Dimension frmSize = getSize();

     Point loc = getLocation();

     dlg.setLocation( (frmSize.width - dlgSize.width) / 2 + loc.x,

                     (frmSize.height - dlgSize.height) / 2 + loc.y);

     dlg.setModal(true);

     dlg.pack();

     dlg.show();

  }

RptDialog是接下来制作的一个Dialog对象，通过Jbuilder新建一个Dialog对象并命名RptDialog。RptDialog的代码如下：

import java.awt.*;

import javax.swing.*;

import dori.jasper.engine.*;

import dori.jasper.view.*;

import dori.jasper.engine.util.JRLoader;

import java.sql.Connection;

import java.io.File;

import java.util.Map;

import java.util.HashMap;

import mytest.trac.CommectionDB;

/**

 * <p>Title: RptDialog </p>

 * <p>Description: 报表承载对话框</p>

 * <p>Copyright: Copyright (c) 2004</p>

 * <p>Company: *****</p>

 * @author 李克喜

 * @version 1.0

 */

public class RptDialog extends JDialog {

  JPanel ReportPan = new JPanel();

  BorderLayout borderLayout1 = new BorderLayout();

  //Bug项目名称

  String proname = "";

  //显示报表需要的控件

  JRViewer jrview;

  public RptDialog(String GroupID) {

    proname = GroupID;

    try {

      jbInit();

      pack();

    }

    catch (Exception ex) {

      ex.printStackTrace();

    }

  }

  private void jbInit() throws Exception {

    ReportPan.setLayout(borderLayout1);

    getContentPane().add(ReportPan);

    //装载报表,在Jbuilder工程的目录创建一个Reports文件夹，并把报表的jasper文件搁置在该文件夹。

    String reportPath = System.getProperty("user.dir") + "\\Reports\\ BugsRpt.jasper";

    JasperReport jasperReport =

(JasperReport) JRLoader.loadObjectFromLocation(reportPath);

    //创建数据库的连接，参考java的JDBC编程资料创建连接方式

    CommectionDB conndb = new CommectionDB();

    //注意：这个连接要求与制作报表时使用的连接一致

    Connection conn = conndb.getDbConnection();

    //报表配置参数，前文提过的SQL语句的Where条件参数就是与这里对应。

  //条件的值可能是通过多种方式得到的，比如上一个页面传递过来的

    Map parameters = new HashMap();   

    //ProjectName就是iReport的变量$P{ProjectName}的名称，参考第一部分的5.6添加参数和使用参

proname就是从界面上获取的值。

 parameters.put("ProjectName ", proname);  

 JasperPrint jasperPrint =

           JasperFillManager.fillReport(

           jasperReport,

           parameters,

           conn

    );

   //装载过程，注意其中的红体字部分

   jrview = new dori.jasper.view.JRViewer(jasperPrint);

   ReportPan.setLayout(borderLayout1);

   ReportPan.setPreferredSize(new Dimension(800, 600));

   getContentPane().add(ReportPan, BorderLayout.CENTER);

   ReportPan.add(jrview,null);

  }

}

到这里，所有需要设置和编程的工作基本完成了。

3、运行

确定数据库已经启动了，在JBuilder运行应用程序。在TextBox输入有意义的组值，比如“BugWin系统”，这是我的测试值，实际情况是根据你的需要来确定的。单击Button，系统会弹出对话框，运行结果和第一部分6.2、预览报表结果一致。

4、总结

随着技术的进步，应用环境的不断变化，胖客户端的应用可能会逐渐退出主流，但是它的存在是必要的。所以我要写胖客户端的应用方面的报表使用技术。文中简要明了的介绍了如何使用Jasperreport编程报表程序。希望对你有一点帮助。

第三部分：使用Jasperreport作为报表控件开发Web报表应用

1、概述

如何实现发Web报表有很多的选择，自定义CSS＋HTML或是XSLT＋XML或是其他控件，特别是支持图表的控件，比如：jfreechart。本文作为Web报表的一种实现方式，建议你使用Jasperreport作为报表控件，第一、二部分已经对制作报表和开发胖客户端报表应用做了介绍，其实有很多的文章可以参考实现第三部分的内容，不止是我写的这篇文章。

2、数据连接建立

参考http://blog.csdn.net/jemlee2002/archive/2004/09/28/JJEM.aspx，这里有详细的介绍数据库的连接过程。

3、拷贝必要的jar文件到Web应用的WEB-INF\lib目录

每个Web应用都会有WEB-INF目录，但是lib是不一定有的，如果没有就创建它，本文需要的jar库文件有3个：

jasperreports-0.5.3.jar ：jasperreports执行时需要的API

iTextAsian.jar ：亚洲字符集支持

itext-1.02b.jar ：其他字符集支持

如果你的报表全英文或是不需要支持亚洲字符集，那么iTextAsian.jar、可以不要。

4、创建repotrs目录并导入.jasper文件

在Web应用中根目录下创建repotrs目录，其实这是一种建议，没有必要完全按照这样做，你可以根据你的业务需要创建N个目录或是层次目录。

把.jasper文件拷贝到repotrs目录下，比如例子中的BusinessRpt.jasper文件。

5、例子程序

Test.jsp文件的内容：

<%@ page session="false" %>

<%@ page import="dori.jasper.engine.*" %>

<%@ page import="javax.naming.*"%>

<%@ page import="java.sql.*"%>

<%@ page import="javax.sql.*"%>

<%@ page import="java.util.*" %>

<%@ page import="java.io.*" %>

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=gb2312">

<title></title>

<%   

   DataSource ds = null;

   try{

        InitialContext ctx=new InitialContext();

        ds=(DataSource)ctx.lookup("java:comp/env/jdbc/mysql");

        Connection conn = ds.getConnection();

        //装载jasper文件

        File business_rpt = new File(application.getRealPath("/reports/BusinessRpt.jasper"));

        //配置参数，可以参考《第二部分：使用Jasperreport作为报表控件开发胖客户端报表应用》

        // http://blog.csdn.net/jemlee2002/archive/2004/10/08/JJem3.aspx

        //ProjectName就是iReport的变量$P{ProjectName}的名称，

        //参考第一部分的5.6添加参数和使用参数

        //proname就是从界面上获取的值。

Map parameters = new HashMap();

        parameters.put("ProjectName ", proname); 

        // JasperRunManager是一个输出控制管理类，下文会提及部分内容

        JasperRunManager.runReportToHtmlFile(business_rpt.getPath(),parameters,conn);

       //如果创建报表成功，则转向该报表，其实可以把报表套在框架内，这样实现比较有意义的报表格式。

        response.sendRedirect("/reports/BusinessRpt.html");

   }catch(Exception ex){

       out.print("出现例外，信息是:"+ex.getMessage());

       ex.printStackTrace();

   }

%>

</head>

<body>

</body>

</html>

6、关于JasperRunManager

JasperRunManager有很多的静态方法，控制输出的格式，比如输出格式是pdf或是html等，建议浏览JasperRunManager的一些方法，这样对开发报表输出有帮助。

7、输出内容

例子中输出格式是以HTML文件格式，所以web服务器可以直接解释并显示，效果不错。

8、总结

终于把3个部分的内容全部写完，到这里我可以休息一小会儿了，就像一休大师说得:“休息,休息……”.

1）它可以PDF，HTML，XML等多种形式产生报表或动态报表，在新版本还支持CSV，XLS，RTF等格式的报表；

2）它按预定义的XML文档来组织数据，来源多（如：关系数据库，Java容器对象（collection，arrays）等）；

报表的填充过程：

先产生报表设计对象->序列化该对象->存储在磁盘或网络->产生XML文件（表格数据）。

表单的设计过程就是用定义于XML文件中的Java表达式来实现报表的设计。

3）它带数据一致性验证；

4）报表引擎必须先接受数据（通过参数等多种形式）来产生报表，更多的是来自数据源，引擎直接接收用于填充表格的数据源对象，或者通过自身提供的JDBC连接对象来处理数据库的数据；

5）报表最终要产生一个新的对象来进行填充操作，从而产生打印文档对象，这也是存储在磁盘或网络传输介质的序列化对象；

6）内置浏览器能直接查看结果，以PDF，HTML，XML导出；

7）重要的类：

net.sf.jasperreports.engine.design.JasperDesign

其实例是用于报表产生的原始类；

net.sf.jasperreports.engine.design.JasperReport

表现了报表设计对象，是作为报表的编译过程的结果而被实例化，是向报表中填充数据的准备。

二、结构

JasperReports用XML文件来定义，约定用jrxml作为文件的后缀名。

1）主要元素：

<jasperReport> 根元素

<title> 报表的标题

<pageHeader> 页眉

<detail> 正文

<pageFooter> 页脚

<band> 定义报表部件，以上所有元素都包含一个band元素作为其唯一子元素。

除了根元素，其余元素是可选的。

2）其编辑工具iReport在Eclipse3.2下的安装过程

菜单“帮助”->“软件更新”->“查找并安装”->“搜索要安装的新功能部件”--(下一步)-->“新建远程站点”，输入以下内容：

名称：JasperForge

URL：http://www.jasperforge.org/update

--(确定)-->“下一步”-->直至完成。

3）以JasperReports1.3.0版本为例，一个JasperReports项目需要如下jar包：

包名                                    说明

jasperreports-1.3.0.jar                 JasperReports API

commons-beanutils-1.7.jar               JavaBeans Utility classes

commons-collections-2.1.jar             Collections framework extension classes

commons-digester-1.7.jar                classes for processing XML documents

commons-logging-1.0.2.jar               Logging classes

poi-2.0-final-20040126.jar              Jarkarta POI API to generate an Excel Document

itext-1.3.1.jar                         PDF library

xml-apis.jar                            XML parser API

三、iReport介绍

1）iReport是为JasperReports设计的强大的，直观的，易于使用的可视化报表设计器，为win32平台编写。允许用户可视化地编辑XML JasperDesign文件，可以和其它数据库进行JDBC通信。

再设计模板时可以以HTML，PDF，XML方式预览，用它生成的文件有.jrxml和.jasper两种文件。

.jrxml：是可视化编辑的xml文件；

.jasper：经编译后生成的类文件，即报表模板文件。

2）iReport的输出格式

其预览输出格式有：PDF，HTML，CSV。JAVA2D，EXCEL，纯文本，JRView。

注意：JRViewer是直接以C/S方式作为报表的输出格式，在JFrame框架下输出。

3）报表的动态对象变量、参数、字段

字段Fields：是从数据库抽取出来的，在报表中出现的数据库内容。$F

参数Parameters：你写的应用需要提供给报表的入口。 $P

变量Variables：报表中一些逻辑运算的表现。 $V

每个对象的定义格式如下： $V{variablesName}

4）运行时需要.jasper文件；编译：把.jrxml->.jasper文件。

静态运行：静态文本来运行，和数据源无关；

动态运行：带数据源运行。

5）报表的结构

title、pageHeader、columnHeader、detail、columnFooter、pageFooter、summary、groupHeader、groupfooter。

6）在iReport中创建数据库连接

（1）菜单DourceSource -> Connections/DataSources -> ...new ->

（2）菜单Build -> Set active connection -> 选择 -> ... -> OK

7）在iReport中创建文件

iReport工具是一个可视编辑器帮助创建JasperReports文件。JasperReports是一个基于Java报表的引擎。

当你在iReport中创建一个报表，你实际上是对配置文件进行操作，告诉JasperReports应该怎样建立Report。

三种文件：

.jasper文件：编译的二进制文件；

.jrxml文件：报表的配置文件；

.pdf文件：生成的pdf文件。

8）报表格式化

在iReport上选择报表的一个区域，将呈现蓝色高亮显示；

可用鼠标拖曳来改变区域的尺寸，当误操作时，用undo来恢复；

如选择框变红，则有错误，report将不能编译；

改变字体或调整尺寸，菜单“View”->“Element properties”->分三个选择：

（1）Common选择：尺寸，前景色/背景色，透明度，打印条件，位置属性等；

（2）Font选择：字体、大小、类型，PDF字体，加粗，斜体，下划线，水平位置，垂直位置，PDF编码。

注意：两种字体：

     Font Name：将显示在iReport设计器和JasperReports运行中；

     PDF font Name：将显示在编译后的PDF文件中。

（3）Static Text：静态文本。

想浏览元素时，看“View”->“Elements browser”；

一次选择多个域，按“shift”键再用鼠标点击；

菜单“View”->“Report Properties”报表属性：

报表尺寸，单位，页边距，报表名，纵向Portrait/横向Landscape，列宽，Spacing，标题作为新页，Summary作为新页，XML编码（UTF-8）。

9）使用Groups

菜单“View”->“Report query” 可以查询和修改SQL语句。

10）为report增加参数

（1）菜单“View”->“Report Query”，修改SQL语句，如：加上 WHERE LAST_NAME=$P{LAST_NAME}

注意：参数用$P{}来封装。

（2）定义参数

菜单“View”->“Reports Parameters”

新建参数，如参数名为“LAST_NAME”，再指定参数的类型（如：String）

还可设定“缺省值”和参数的“描述”

运行报表（缺省），还可以传递参数方式：http://server/showReport?LAST_NAME=smith

菜单“Build”->“Execute report（using active conn.）”

11）创建子报表

例子：一个报表包含另一个报表

（1）建立两个报表；

（2）扩展master报表，增加一个subreport元素；

（3）双击subreport元素，设置其属性。在Subreport（other）栏中，

Subreport Expression填入“c:\test2.jasper”(第二个表即子表的文件名），点击“Add”，增加/修改：“Subreport parameter name”和Default value expression值；（COUNTRY     $F{COUNTRY}）

（4）对子表“Report query”->添加'where COUNTRY=${COUNTRY}'

（5）增加“Report parameters”，（COUNTRY，java.lang.String)

（6）编译detail report；

（7）运行master report。

iReport支持Groovy脚本语言，可无需懂Java。

1、配置XML文件

jasperreports的XML配置文件局域jasperreport.dtd文件而来。

1）根元素jasperReport

其子元素有：报告的字体reportFont，参数parameter，查询字符串queryString，字段field，变量variable，组group，标题title，页眉pageHeader，列眉columnHeader，表明细detail，列脚columnFooter，页脚pageFooter。

属性有：列宽columnWidth，列间距columnSpacing，左边距leftMargin，顶边距topMargin，底边距bottomMargin。

2）报表层字体含义reportFonts

无子元素；

属性有：名字name，是否缺省isFault，字体名fontName，字体大小size，是否粗体isBold，是否斜体isItalic，是否带下划线isUnderline，isStrikeThrough，PDF字体名pdfFontName，PDF编码pdfEncoding，是否嵌入PDF（isPdfEmbedded）。

3）用于产生报表的对象参数parameter。引用P${name}

其子元素有：ParameterDescription，defaultValueExpression

属性有：name，class

4）从数据库检索数据的查询SQL语句 queryString

5）包含于report中的数据库表列字段 field。 引用F${name}

其子元素有：variableExpression，initialValueExpression

属性有：name，class

6）用在XML文件中的变量 Variable   引用V${name}

其子元素有：variableExpression，initialValueExpression

属性有：name，class

7）报表标题 title

其子元素有：band

无属性

8）页眉 pageHeader

其子元素有：band

无属性

9）报表的列名 columnHeader

其子元素有：band

无属性

10）指定的列值detail

其子元素有：band

无属性

11）列尾columnFooter

其子元素有：band

无属性

12）页脚pageFooter

其子元素有：band

无属性

注：在report中，一个band表示一个report节点。一个band元素包括：staticText（静态文本）和textElement（文本元素）两个元素。

常见报表模型：列表、分组、主从、嵌套、交叉、图形、套打、分栏、填报。

2、创建报表

1）建立输入源

InputStream input = new FileInputStream(new File("c:\\JasperReports\\catalog.xml"));

JasperDesign design=JRXmlLoader.load(Input);

2）创建对象

JasperReport report = JasperCompileManager.compileReport(design);

3）获得JDBC连接从数据库检索数据

InitialContext initialContext = new InitialContext();

DataSource ds = (DataSource)initialContext.lookup("java:comp/env/jdbc/OracleDBConnectionDS");

Connection conn = ds.getConnection();

4）产生可预览、打印、输出为其它格式的JasperPrint文件

JasperPrint print = JasperFillManager.fillReport(report, parameters, conn);

5）参数处理

Map parameters = new HashMap();

parameters.put("ReportTitle", "PDF JasperReport");

6）输出成XML，PDF，HTML，CSV，XLS（Excel）的任一种文件。

OutputStream output = new FileOutputStream(new File("c:/JasperReports/catalog.pdf"))

JasperExportManager.exportReportToPdfStream(print,output);

3、JasperReports的安装配置

1）JDK的安装，注意JAVA_HOME环境变量；

2）要支持中文，需itext-1.3.1.jar和iTextAsian.jar包，加入CLASSPATH环境变量中；

3）安装iReport，用iReport-1.3.0-windows-installer.exe安装；

4）JasperReport不需任何配置，将其jar包（jasperreports-1.3.0.jar）放入CLASSPATH；

5）数据库的JDBC驱动包，例如Sybase的驱动包为jconn6.jar，加入到CLASSPATH。

4、iReport的安装配置

iReport如果不用其安装文件iReport-1.3.0-windows-installer.exe安装，则需要配置。

iReport需Sun公司的JDK下的tools.jar，需拷贝到iReport的lib目录下。

iReport初始化配置的组成：

（1）建立报表；

（2）选择语言；

（3）加入到CLASSPATH。

四、Report Structure 报告的结构

本章描述报告的结构，可用的report对象和它们的属性。这基本上是JasperReports的快速参考。

1、Expressions 表达式

表达式是JasperReports的核心特征。它是一个重要的机制，允许操纵和显示报告数据，执行各种计算，自定义报告的外观和报告对象的可视性。

1）一个典型的表达式

$F{LastName} + " " + $F{LastName}

一个JasperReports的表达式是以Java表达式为基础的，再加上一些附加的语法，它允许引用参数、变量和字段等。

比如说要引用一个名叫DATA的参数时，语法应为$P{PARAM_NAME}。

对变量和字段来说，其引用语法分别为$V{VAR_NAME}和$F{FIELD_NAME}。

注意：在JasperReports的groovy脚本语言中，也同样可以用$F，$P，$V引用参数、变量和字段。

2）表达式的语法

（1）$F{FIELD}   引用名为FIELD的字段；

（2）$V{VAR}     引用名为VAR的变量；

（3）$P{PARAM}   引用名为PARAM的参数；

（4）$P!{PARAM} 引用名为PARAM的参数；这个特殊的语法仅能用于report的查询中。它允许插入参数的内容到查询字符串中。例如，它能被用于创建一个带通过参数来指定WHERE条件的动态查询。

$R{keyName}      在resource bundle中检索带keyName关键字的字符串。

注意：表达式是用Java或Groovy写成的，这意外着可以用Java强大的功能，如调用方法，允许构建无限复杂的表达式。还要注意，表达式的结果总是一个对象。

3）更多的表达式

（1）new Integer(Math.max($V{Price1},$V{Price2}))

（2）(new SimpleDateFormat("dd/MM/yyyy")).format($F{OrderDate})

（3）$F{SpecialOffer}.booleanValue()? $F{SpecialPrice} : $F{Price}

2、内建的函数

JasperReports提供了一套内建的函数用于report表达式中。这些函数尽管是内建的工具，还是可以在普通操作中执行它。

注意：目前这套函数很有限，在未来会得到扩展。

1)例：使用内建函数

msg("Total cost is {0}", $F{TOTAL})

msg("Matched {0} products out of {1}", $F{MATCHED}, $P{TOTAL})

2)内建的函数

（1）String str(String key);

从和report相联系的resource bundle中得到给出的key的一个字符串。这个函数的功能和使用$R{key}语法等价。

（2）String msg(String pattern, Object arg0);

建立一个带给定的pattern和给定参数来指定其格式的java.util.MessageFormat对象。

（3）String msg(String pattern, Object arg0, Object arg1);

同上；

（4）String msg(String pattern, Object arg0, Object arg1, Object arg2);

同上。

3、Report 报告

Report是表现为报告模板的根对象。在报告执行期间，report模板和数据组合成最终的文档。

报告的属性有：

（1）Report Name 报告名；

（2）Units 报告的单位；有：像素Pixels，毫米Millimeters，厘米Centimeters和英寸Inches。

（3）Language 报告表达式使用的语言；目前有Java和Groovy两种。

（4）Orientation 页的方向；其可能值为水平Protrait和纵向Landscape。

（5）Page Width 以报告单位指定的页宽；

（6）Page Height 以报告单位指定的页高；

（7）Page Size 报告的尺寸，即为page width和page height。

（8）Left Margin 以报告单位指定的左边页边距；

（9）Right Margin 以报告单位指定的右边页边距；

（10）Top Margin 以报告单位指定的顶部页边距；

（11）Bottom Margin 以报告单位指定的底部页边距；

（12）Column Count 报告中的列数；

（13）Column Spacing 以报告单位指定的列边距；

（14）Column Width 以报告单位指定的列宽；

（15）Print Order 填充列的顺序；有垂直Vertical和水平Horizontal两种。

（16）Float Column Footer 浮动列脚，指出是否在列底部或明细表最后或组脚进行打印；

（17）Default Font 缺省字体；

（18）Default Style 缺省风格；

（19）Scriptlet Class 脚本类，它必须是JRAbstractScriptlet类的子类。如果省略，将创建一个JRDefaultScriptlet的实例。

（20）Summary New Page 新页的概要；

（21）Title New Page 新页的标题；

（22）When No Data Print 无数据时的打印，有三个选择：No Pages 表示0页；Blank Page 空白页；All Sections No Detail 除了detail section，其它的都打印。

（23）Query 查询，用来检索数据到报告中。

（24）Query Language 查询语言，有五个值：SQL 用于JDBC数据源的查询语言；HBM Hibernate用于Hibernate数据源的查询语言；XPath 用于XML数据源的查询语言；EJBQL用于支持Java持久层（Persistence）API的数据源的查询语言；MDX 用于Mondrian数据源的查询语言。

（25）Imports java输入的列表，例如：java.util.*和java.text.SimpleDateFormat格式。用于简化report的表达式。

（26）Resource Bundle 为report提供了本地的系列字符串。在报告中，本地字符串能用$R{key}引用。

（27）When Resource Missing Print 允许自定义引擎在resource bundle中处理丢失的resource。有4种选择：Null 丢失的resource不打印；Empty 丢失的resource为空；Key 用$R{key}指定的key来打印； Error 用错误来中断报告的执行。

4、Styles 风格

一个report可以定义大量的风格。一旦定义了，它们能和report对象联系起来，为了给各种可视视图提供基本的配置。report允许用模块化的方式来定义模块的风格。

风格有相关联的条件风格。条件风格允许当其表达式为真时改变风格。

1）风格的属性有：

（1）Name 风格名；

（2）Parent Style 父风格；

（3）Foreground 前景色；

（4）Background 背景色；

（5）Mode 方式，决定是否带透明度；

（6）Pen 画笔 有6种选择：None 无线；1 Point 正常宽度的线；2 Point 中等宽度的线；4 Point 粗线；Dotted 虚线；Thin 细线。

（7）Fill 填充；决定对对象进行填充的模式；

（8）Box 指定盒子的属性，如边框类型，边框颜色，是否填充。

（9）Horizontal Alignment 水平排列；有3种选择：Left 左；Center 中；Right 右。

（10）Vertical Alignment 垂直排列；有3种选择：Top 顶；Middle 中；Bottom 底。

（11）Scale 比例；指定图像的比例，有3种选择：Clip 尺寸不适合时，多余部分省略；Fill Frame 图像按比例填充进Image对象中；Retain Shape 保留原形状进行填充。

（12）Radius 指定矩形边框倒角的弧度；

（13）Pattern 用Text Field表达式的值来指定样式；其日期类型的值用java.text.SimpleDataFormat类来定义；其数值型的值用java.text.DecimalFormat来定义。

（14）Blank When Null 当Text Field表达式的值为null时显示空白；

（15）Line Spacing 线距；有3种选择：Single：单倍线距；1 and 1/2：1.5倍线距；Double：双倍线距。

（16）Rotation 旋转；有3种选择：None 不旋转；Left 左旋180度；Right 右旋180度。

（17）Styled Text 是一个标志位，用来指定是否text对象包含了已定义风格或规则的text。

（18）Font Name 字体名；

（19）Font Size 字体的尺寸；

（20）Bold 粗体；

（21）Italic 斜体；

（22）Underline 下划线；

（23）Strike Through 通过标准位来取消；

（24）PDF Font Name：PDF字体名；

（25）PDF Encoding：PDF编码；

（26）PDF Embedded是一个标志位，指定是否PDF字体应该嵌入到文档中。

2）条件风格的属性：

和上面仅有一点点的不同。其不同的属性为：

Condition Expression 条件表达式；是一个布尔型的表达式，用于判断是否应用条件表达式。

5、Section Properties 节属性

Section的种类前面已经讲了，这里只是补充讲述它的属性：

（1）Height 以报告的单位指定的section的高度；

（2）Print When Expression 是一个布尔表达式，决定是否打印本Section；

（3）Split Allowed 一个标志位，指示当Section超过当前页面的尺寸时，是否允许分割它。如果为真，当前Section将迁移到下一页。注意：如果Section在下一页也不适合时，则不管标志位值如何，都会分割它。

6、Groups 组

一个report可以定义大量的组。组表示决定带相关数据的可视组的表达式名。一旦声明后，组能在报告任意地方使用。

一个数据组用一个表达式组来识别。

注意：组机制不能完成来自于数据源数据的任何排序。如果想要有序的数据，必须把数据源的数据进行先排序处理。

组属性：

（1）Name 组名；用于引用组。

（2）Expression 表达式；决定report数据的组；

（3）Min Height To Start New Page 开始新页的最小高度；

（4）Reprint Header On Each Page 一个标志位，指示在每一页的开始处是否重新打印组头；

（5）Reset Page Number 重设页数，一个标志位；在组头在新页开始处打印时，是否重新设置页数；

（6）Start New Column 一个标志位，是否在新列中总是打印组头；

（7）Start New Page 一个标志位，是否在新页中总是打印组头；

报表工具之JasperReports+iReport（5）

五、JasperReports作为一种开源的报表库为应用提供了强大的支持。其易用性和灵活性为系统的开发提供了极大的便利。

在报表生成过程中，使用JDBC等传统数据源操作方法获取数据的过程会消耗大量的系统时间，这样就需要利用其它手段来简化数据源操作。

在这种情况下，适当的使用ORM（Object/Relational Mapping）技术，能够很好的解决这个问题，对于系统性能的提升有很大的帮助。

1、JasperReports填充报表

要完成报表的填充，必须先完成用于报表的xml模板，其过程是先产生报表布局对象，再序列号该对象，存储在磁盘或者网络，用于产生特定应用的表格数据。

实际上，表单的设计过程就是用定义于xml文件中的java表达式来表现报表的布局。

编辑过程中会有各种保证数据一致性的验证，最终会产生相关数据的文档。

报表引擎必须先接受数据来产生报表，这些数据一般来源于各种数据源，报表引擎能直接接收用于填充表格的数据源对象，或者通过自身提供的JDBC连接对象来处理数据库的数据。

报表最终要产生一个新的对象来进行填充操作从而产生用于输出的文档对象，这也是一个存储在磁盘或者网络传输介质的序列化对象。

JasperReports的内置浏览器能直接查看结果或者以PDF,HTML,XML形式将其导出。

2、持久化技术和ORM

持久化（Persistence），即把数据保存到可永久保存的存储设备中（如磁盘）。

持久化的主要应用是将内存中的数据存储在关系型的数据库中，当然也可以存储在磁盘文件中、XML数据文件中等。

ORM即“对象－关系型数据映射组件。对于O/R，即Object（对象）和Relational（关系型数据），表示必须同时使用面向对象和关系型数据进行开发。

MVC（Model View Control）中的Model包含了复杂的业务逻辑和数据逻辑，以及数据存取机制（如JDBC的连接、SQL生成和Statement创建、还要ResultSet结果集的读取等）。将这些复杂的业务逻辑和数据逻辑分离，以将系统的紧耦合关系转化为松耦合关系（即解耦合），是降低系统耦合度迫切要做的，也是持久化要做的工作。

MVC模式实现了架构上将表现层和数据处理层分离的解耦合，而持久化设计则实现了数据处理层内部的业务逻辑和数据逻辑分离的解耦合。

关系型数据库中的数据基本都是以一行行的数据进行存取的，而程序运行却是一个个对象进行处理，而目前大部分数据库驱动技术（如ADO.NET、JDBC、ODBC等）均是以行集的结果集一条条进行处理的。所以为解决这一困难，就出现ORM这一个对象和数据之间映射技术。

3、在JasperReports中使用Hibernate

Hibernate是一个开发源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP,完成数据持久化的重任。

package src;

import java.util.HashMap;

import java.util.List;

import net.sf.jasperreports.engine.JRException;

import net.sf.jasperreports.engine.JasperCompileManager;

import net.sf.jasperreports.engine.JasperFillManager;

import net.sf.jasperreports.engine.JasperPrint;

import net.sf.jasperreports.engine.JasperReport;

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

import net.sf.jasperreports.engine.design.JasperDesign;

import net.sf.jasperreports.engine.xml.JRXmlLoader;

import net.sf.jasperreports.engine.JasperExportManager;

import org.hibernate.HibernateException;

import org.hibernate.MappingException;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

public class Simple1 {

public static void main(String args[]){

   String sampleReportFile=new String("reports/sampleReport.jrxml");

   //Hibernate Result Set Holder.

   List bowlerInfo=null;

   try{

    //Configure the Hibernate session

    Configuration cfg=new Configuration();

    cfg.addResource("hibernate-mapping.xml");

    SessionFactory sessions=cfg.buildSessionFactory();

    //Open the Hibernate Session

    Session session=sessions.openSession();

    //Returns all SampleData records.

    //Simple POJO object.

    bowlerInfo=session.createQuery("from SampleData").list();

    //Fill the parameters

    HashMap parameters=new HashMap();

    parameters.put("ReportTitle","Bowling Scores");

    parameters.put("NoOfGames", new Integer(3));

    //Load the sample report file from the XML file

    //into the JasperDesign object.

    JasperDesign design=JRXmlLoader.load(sampleReportFile);

    //Compile the Report in Memory storing it in a JasperReport object

    //no .jasper report file is created.

    JasperReport report=new JasperCompileManager().compileReport(design);

    //Fill the report using the JRBeanCollectionDataSource passed

    //a Hibernate query result set.

    JasperPrint print=JasperFillManager.fillReport(report,parameters,new JRBeanCollectionDataSource(bowlerInfo));

    //Export to PDF file.

    JasperExportManager.exportReportToPdfFile(print,"simpleHibernatExample.pdf");

    //Close the Hibernate Session.

    session.close();   

   }catch(JRException jre){

    jre.printStackTrace();

   }catch(MappingException me){

    me.printStackTrace();

   }catch(HibernateException he){

    he.printStackTrace();

   }

}

}

当Hibernate检索返回集合类型的对象时，使用JRBeanCollection接口可将数据通过Hibernate的POJO（Plain Old Java Object）实例映射到报表域中，使用JRXmlLoader.load(templateName)方法加载报表模板，最后通过JasperFillManager方法将数据填入模板中。

本例使用JasperExportManager.exportReportToPdfFile()方法将报表输出为PDF格式。JasperReports提供的net.sf.jasperreports.engine.JRExporter接口可以方便的将报表输出为PDF、XLS、CSV、RTF、HTML或者XML格式，目前以PDF和EXCEL格式较为通用。

4、总结

在JasperReports中使用了Hibernate以后，如果随业务更换数据源的话，只需要更好Hibernate的映射文件，极大提高了代码的可重用性，同时由于Hibernate本身对于查询的优化，也能很好的提高整个应用的效率，尽可能的节省开发时间。

            Id = Random String

            Cookie autoLogin = new Cookie(“autoLogin” , id);

            autoLogin set有效期限

2.      自动登录

            Request.getCookies[]

            获取auto login key.

            检索自动登录管理表……

本文主要描述Log4j的API的唯一特性和它的设计原理。Log4j是一个基于许多作者的开放源码的项目。它允许开发员以任意的间隔来控制日志的输出。它通过设在外部的配置文件而达到运行时灵活的设置。最重要的是，Log4j有一个平稳的学习曲线。注意：根据来自用户的反馈判断，它很容易使人上瘾。

 2.       导言

几乎所有的大型应用程序都包括它的自己的日志和跟踪API。顺应这个规则，E.U. SEMPER 项目决定写它自己的跟踪PAI。这是1996年初。在无数次加强，几次变形和许多工作后，那个API变成了如今的Log4j，一个流行的java日志包。这个包以Apache Software License协议发布，一个成熟的开放源吗协议。最新的Log4j版本，包括全部的源码，class文件和文档，你可以在http://jakarta.apache.org/Log4j/上找到。顺便，Log4j已经给C, C++, C#, Python, Ruby, and Eiffel 语言都提供了接口。

 为了调试而插入日志输出到代码里是一个低技术成分的方法，但它可能也是唯一的方法，因为调试器并不是一直可用或者可以适应的，尤其对于多线程的分布使式的大型程序而言。

 经验指出调试是软件开发周期中一个重要的组成部分。

Log4j拥有几个优点：

首先，它提供关于运行程序的准确的环境。一旦代码被插入，不需要人工干预就可以产生调试信息。

其次，日志输出可以被有计划的保存在永久媒体中以便日后研究。

另外，除了在开发周期中，一个充分详尽的日志包可以被用来作为以后的统计工具。

 Log4j当然还有它的缺点，它可能减慢程序。如果太详细，它可能导致屏幕盲目滚动。排除这些情况，Log4j是可靠的，快速的，可以扩展的。因为日志很少是一个应用程序的主要目的, 设计者们正努力使得Log4j API学习和使用简单化。

 3.                  日志类别、输出源和布局

Log4j有三个主要的组件：日志类别（Loggers）、输出源（ Appenders）和布局（Layouts）。这三种类型的组件一起工作使得开发员可以根据信息的类型和级别记录它们，并且在运行时控制这些信息的输出格式和位置。

 3.1               日志类别的层次结构(Loggers)

Log4j首要的相对于简单的使用System.out.println()方法的优点是基于它的在禁止一些特定的信息输出的同时不妨碍其它信息的输出的能力。这个能力源自于日志命名空间，也就是说，所有日志声明的空间，它根据一些开发员选择的公式而分类。以前的观察引导我们选择类别作为包的中心概念。然而，自从Log4j的1.2版本，Logger类被Catalog类所取代，对于那些熟悉Log4j以前版本的人来说，Logger类可以被想象成仅仅是Category 类的别名。

 Loggers 被指定为实体，Logger的名字是大小写敏感的，它们遵循以下的命名

规则：

²        命名继承

如果类别的名称（后面加一个点）是其子类别名称的前缀，则它就是另一个类别的祖辈。

如果一个类别(Logger)和它的子类别之间没有其它的继承关系，我们就称之为parent与child的关系。

 例如，类别"com.foo"是类别"com.foo.Bar"的parent。相似的，"java"是"java.util"的parent，是"java.util.Vector"的父辈。.这个命名规则应该被大多数的开发员所熟悉。

 根(root) 类别位于logger继承结构的最上层。它有两种例外：

1.它一直存在

2.它不能根据名称而获得。 

调用类的静态方法Logger.getRootLogger可以得到它。其它所有的Logger可以通过静态方法Logger.getLogger而得到它们自己的实例。这个方法取希望的Logger名作为参数。Logger的一些基本的方法示例如下：

  package org.apache.Log4j;

   public Logger class {

      // Creation & retrieval methods:

    public static Logger getRootLogger();

    public static Logger getLogger(String name);

    // printing methods:

    public void debug(Object message);

    public void info(Object message);

    public void warn(Object message);

    public void error(Object message);

  // generic printing method:

    public void log(Level l, Object message);

}

 Loggers可以被分配的级别。所有级别的集合包括：

DEBUG

INFO

WARN

ERROR

FATAL

 它们被定义于org.apache.Log4j.Level 类。虽然我们不鼓励，但是你们可以通过继承Level类来定义你们自己的级别。我们随后将介绍一个比较好的方法。

 如果一个Logger没有被分配一个级别，那么它将从一个被分配了级别的最接近它的ancestor哪里继承。

正规的说：

 ²        级别继承

对于一个给定的Logger C，它的继承的级别等于从C开始上溯到的第一个拥有非空级别的Logger的级别。

 为了保证所有的Logger最终能够继承到一个级别，根Logger通常有一个已经定义了的级别。

 以下四个表中的数据演示了根据以上规则得到的结果。

 

类别名	分配的级别	继承的级别
root	Proot	Proot
X	none	Proot
X.Y	none	Proot
X.Y.Z	none	Proot
Example 1

 在例子1中，只有根Logger定义了一个级别，它的级别的值--"Proot"被所有其它的Loggers X, X.Y, 和X.Y.Z所继承。

 

类别名	分配的级别	继承的级别
root	Proot	Proot
X	Px	Px
X.Y	Pxy	Pxy
X.Y.Z	Pxyz	Pxyz
Example 2

 在例子2中，所有的Logger都有一个被分配的级别值，所以它们不需要级别继承。

 

类别名	分配的级别	继承的级别
root	Proot	Proot
X	Px	Px
X.Y	none	Px
X.Y.Z	Pxyz	Pxyz
Example 3

 在例子3中，根Logger，以及X和X.Y.Z被分别分配了级别Proot，Px和Pxyz。Logger X.Y从它的parent X继承了级别值Px。

 

类别名	分配的级别	继承的级别
root	Proot	Proot
X	Px	Px
X.Y	none	Px
X.Y.Z	none	Px
Example 4

 在例子4中，根Logger和X被分别分配了级别"Proot"和"Px"，Logger X.Y 和 X.Y.Z从被分配了级别的最接近它们的ancestor X那里得到继承。

 我们需要通过调用Logger的输出的实例方法之一来实现日志请求。这些输出的方法是debug, info, warn, error, fatal 和 log.

 通过定义输出方法来区分日志的请求的级别。例如，如果c是一个Logger的实例，那么声明 c.info 就是一个INFO级别的日志请求。

 如果一个日志的请求的级别高于或等于日志的级别那么它就能被启用。反之，将被禁用。一个没有被安排级别的Logger将从它的父辈中得到继承。这个规则总结如下。

 ²        基本的选择规则

假如在一个级别为q的Logger中发生一个级别为p的日志请求，如果p>=q,那么请求将被启用。

 这是Log4j的核心原则。它假设级别是有序的。对于标准级别，我们定义DEBUG < INFO < WARN < ERROR < FATAL.

 以下是关于这条规则的一个例子。

    // get a logger instance named "com.foo"

   Logger logger = Logger.getLogger("com.foo");

    // Now set its level. Normally you do not need to set the

   // level of a logger progamitcally. This is usually done

   // in configuration files.

   cat.setLevel(Level.INFO);

  Logger barlogger = Logger.getLogger("com.foo.Bar");

    // This request is enabled, because WARN >= INFO.

   logger.warn("Low fuel level.");

     // This request is disabled, because DEBUG < INFO.

   logger.debug("Starting search for nearest gas station.");

    // The logger instance barlogger, named "com.foo.Bar",

   // will inherit its level from the logger named

   // "com.foo" Thus, the following request is enabled

   // because INFO >= INFO. 

   barlogger.info("Located nearest gas station.");

    // This request is disabled, because DEBUG < INFO.

   barlogger.debug("Exiting gas station search");

 调用getLogger方法将返回一个同名的Logger对象的实例。

 例如，

   Categoty x = Logger.getLogger("wombat");

   Categoty y = Logger.getLogger("wombat");

 x和y参照的是同一个Logger对象。

 这样我们就可以先定义一个Logger，然后在代码的其它地方不需传参就可以重新得到我们已经定义了的Logger的实例.

同基本的生物学理论--父先于子相反，Log4j 的loggers可以以任何顺序创造和配置。特别是，一个后实例化的"parent"logger能够找到并且连接它的子logger。

 配置Log4j的环境通常在一个应用程序被初始化的时候进行，最好的方法是通过读一个配置文件。这个方法我们将简短介绍。

 Log4j使得通过软件组件命名logger很容易。我们可以通过Logger的静态的初始化方法在每一个类里定义一个logger，令logger的名字等于类名的全局名，而实现logger的命名。这是一个实效的简单的定义一个logger的方法。因为日志输出带有产生日志的类的名字，这个命名策略使得我们更容易定位到一个日志信息的来源。虽然普通，但却是命名logger的常用策略之一。Log4j没有限制定义logger的可能。开发员可以自由的按照它们的意愿定义logger的名称。

 然而，以类的所在位置来命名Logger好象是目前已知的最好方法。

 3.2               输出源（Appenders）和布局（Layouts）

 有选择的能用或者禁用日志请求仅仅是Log4j的一部分功能。Log4j允许日志请求被输出到多个输出源。用Log4j的话说，一个输出源被称做一个Appender. 。Appender包括console（控制台）, files（文件）, GUI components（图形的组件）, remote socket servers（socket 服务）, JMS（java信息服务）, NT Event Loggers（NT的事件日志）, and remote UNIX Syslog daemons（远程UNIX的后台日志服务）。它也可以做到异步记录。

 一个logger可以设置超过一个的appender。

 用addAppender 方法添加一个appender到一个给定的logger。对于一个给定的logger它每个生效的日志请求都被转发到该logger所有的appender上和该logger的父辈logger的appender上。换句话说，appender自动从它的父辈获得继承。举例来说，如果一个根logger拥有一个console appender，那么所有生效的日志请求至少会被输出到console上。如果一个名为C的logger有一个file类型的appender，那么它就会对它自己以及所有它的子logger生效。我们也可以通过设置appender的additivity flag 为false，来重载appender的默认行为，以便继承的属性不在生效。

  调节输出源（appender）添加性的规则如下。

 输出源的可添加性（Appender Additivity ）

一个名为C的logger的日志定义的输出将延续到它自身以及它的ancestor logger的appenders。这就是术语"appender additivity"的含义。            

然而，logger C的一个ancestor logger P，它的附加标志被设为false，那么C的输出将被定位到所有C的appender，以及从它开始上溯到P的所有ancestor logger的appender。

Loggers的附加标记（additivity flag）默认为true。

 下表是一个例子。

 经常，用户希望自定义不但输出源，而且定义输出格式。这个是通过在一个appender上附加一个layout来完成的。layout是负责根据用户的希望来格式化日志请求。而appender是负责发送格式化的输出到它的目的地。PatternLayout，作为Log4j标准版中的一部分，让用户指以类似C语言的printf方法的格式来指定日志的输出格式。

例如，转化模式为"%r [%t] %-5p %c - %m%n" 的PatternLayout 将输出类似如下的信息：

176 [main] INFO org.foo.Bar - Located nearest gas station.

第一个栏位是自从程序开始后消逝的毫秒数。

第二个栏位是做出日志的线程。

第三个栏位是log的级别。

第四个栏位是日志请求相关的logger的名字。而"-"后的文字是信息的表述。

Log4j将根据用户定义的公式来修饰日志信息的内容。例如，如果你经常需要记录Oranges，一个在你当前的项目被用到的对象类型，那么你可以注册一个OrangeRenderer ，它将在一个orange需要被记录时被调用。

对象渲染类似的类的结构继承。例如，假设oranges是fruits，如果你注册了一个FruitRenderer，所有的水果包括oranges将被FruitRenderer所渲染。除非你注册了一个orange。

 对象渲染必须实现ObjectRenderer接口。

if  ( ! artistList.contains(artistEntity))  {
   artistList.add(artistEntity);
}

   但运行的结果并不是如开始设计的那样，页面显示表明artistList包含了两个相同的ArtistEntity对象，这是什么原因呢？
   我看了一下jdk关于这段的源代码：

     /** */ /**
     * Returns <tt>true</tt> if this list contains the specified element.
     *
     *  @param  elem element whose presence in this List is to be tested.
     *  @return   <code>true</code> if the specified element is present;
     *        <code>false</code> otherwise.
      */
     public   boolean  contains(Object elem)  {
     return  indexOf(elem)  >=   0 ;
    }

     /** */ /**
     * Searches for the first occurence of the given argument, testing 
     * for equality using the <tt>equals</tt> method. 
     *
     *  @param    elem   an object.
     *  @return   the index of the first occurrence of the argument in this
     *          list; returns <tt>-1</tt> if the object is not found.
     *  @see      Object#equals(Object)
      */
     public   int  indexOf(Object elem)  {
     if  (elem  ==   null )  {
         for  ( int  i  =   0 ; i  <  size; i ++ )
         if  (elementData[i] == null )
             return  i;
    }   else   {
         for  ( int  i  =   0 ; i  <  size; i ++ )
         if  (elem.equals(elementData[i]))
             return  i;
    }
     return   - 1 ;
    }

    /** *//**
     * @return
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode() {
        final int PRIME = 31;
        int result = 1;
        result = PRIME * result + ((artstCd == null) ? 0 : artstCd.hashCode());
        return result;
    }

    /** *//**
     * @param obj
     * @return
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        final ArtistEntity other = (ArtistEntity) obj;
        if (artstCd == null) {
            if (other.artstCd != null)
                return false;
        } else if (!artstCd.equals(other.artstCd))
            return false;
        return true;
    }

// 当アーティスト情報列表中不包含时才加入
                    if (!artistCodeList.contains(artistEntity.getArtstCd())) {
                        artistCodeList.add(artistEntity.getArtstCd());
                        artistList.add(artistEntity);
                    }

//定义Message数据结构
function msgObj(msgname, msgkey, msgvalue) {
 this.msgname = msgname;
 this.msgkey = msgkey;
 this.msgvalue = msgvalue;
 
 msgObj.prototype.getname = function() {
  return this.msgname;
 }
 
 msgObj.prototype.getkey = function() {
  return this.msgkey;
 }
 
 msgObj.prototype.getvalue = function() {
  return this.msgvalue;
 }
}

//去空
function zNull(str) {
 if (str.length < 1) {
  str = "&nbsp";
 }
 return str;
}

function errorMsgWindow(){
 var obj = window.top.errorMsg;
 if (obj.length > 0) {
  showMsgWindow(obj);
  clearErrorMessage();
  return false;
 }
 return true;
}

//根据参数对Message进行初始化
function pushErrorMessage(){
 var strobj = new msgObj();

 if (arguments.length >= 3) {  
  strobj = new msgObj(zNull(arguments[0]), zNull(arguments[1]), zNull(arguments[2]));
 } else if (arguments.length == 2) {
  strobj = new msgObj(zNull(arguments[0]), zNull(arguments[1]), "&nbsp");
 } else {
  return false;
 }
 window.top.errorMsg.push(strobj);
}

function clearErrorMessage(){
 window.top.errorMsg = new Array();
}
   事实证明这里有几个地方是有点问题的，一般调用好像不会出现，但用的范围广一些就会有感觉了。

解决的办法自然是想办法用相对路径代替绝对路径，其实log4j的FileAppender本身就有这样的机制，如：

log4j.appender.logfile.File=${WORKDIR}/logs/app.log

其中“${WORKDIR}/”是个变量，会被System Property中的“WORKDIR”的值代替。这样，我们就可以在log4j加载配置文件之前，先用System.setProperty设置好根路径。

在 没有发现这个技巧之前，为了解决这个问题，我曾自己扩展了log4j的RollingFileAppender类，其他的FileAppender同样道 理。扩展的方法，就是用一个子类去覆盖setFile方法，这个方法在log4j读取配置文件生成appender的时候调用，传入的就是配置文件中的路 径，这样我就可以按照自己的想法在路径前面加上根路径了。

2.

可以使用环境变量
log4j.appender.R=org.apache.log4j.RollingFileAppender 
log4j.appender.R.File=${catalina.base}/logs/logs_tomcat.log 
log4j.appender.R.MaxFileSize=10KB






3.具体实现:


一般在我们开发项目过程中,log4j日志输出路径固定到某个文件夹,这样如果我换一个环境,日志路径又需要重新修改,比较不方便,目前我采用了动态改变日志路径方法来实现相对路径保存日志文件

 (1).在项目启动时,装入初始化类: 

public class Log4jInit extends HttpServlet {
    static Logger logger = Logger.getLogger(Log4jInit.class);


    public Log4jInit() {
    }


    public void init(ServletConfig config) throws ServletException {
        String prefix = config.getServletContext().getRealPath("/");
        String file = config.getInitParameter("log4j");
        String filePath = prefix + file;
        Properties props = new Properties();
        try {
            FileInputStream istream = new FileInputStream(filePath);
            props.load(istream);
            istream.close();
            //toPrint(props.getProperty("log4j.appender.file.File"));
            String logFile = prefix + props.getProperty("log4j.appender.file.File");//设置路径
            props.setProperty("log4j.appender.file.File",logFile);
            PropertyConfigurator.configure(props);//装入log4j配置信息
        } catch (IOException e) {
            toPrint("Could not read configuration file [" + filePath + "].");
            toPrint("Ignoring configuration file [" + filePath + "].");
            return;
        }


    }


    public static void toPrint(String content) {
        System.out.println(content);
    }


}


(2).Web.xml中的配置


<servlet>
    <servlet-name>log4j-init</servlet-name>
    <servlet-class>Log4jInit</servlet-class>
    <init-param>
      <param-name>log4j</param-name>
      <param-value>WEB-INF/classes/log4j.properties</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>

最后决定 在项目中选择第二种比较方便

<?xml version="1.0" encoding="ISO-8859-1"?>

<bookstore>

<book>
  <title lang="en">Harry Potter</title>
  <author>J K. Rowling</author> 
  <year>2005</year>
  <price>29.99</price>
</book>

</bookstore>

<bookstore>  (document node)

<author>J K. Rowling</author>  (element node)

lang="en"  (attribute node)

J K. Rowling

"en"

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>

<bookstore>

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>

</bookstore>

<bookstore>

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>

</bookstore>

XPath语法
翻译：Linyupark / 2006-03-24

XPath uses path expressions to select nodes or node-sets in an XML document. The node is selected by following a path or steps.
XPath使用路径表达式来选择XML文档的节或是节集。顺着路径或步骤来选择节。

The XML Example Document
XML实例文档

We will use the following XML document in the examples below.
举例中我们将使用下面的XML文档

<?xml version="1.0" encoding="ISO-8859-1"?>

<bookstore>

<book>
  <title lang="eng">Harry Potter</title>
  <price>29.99</price>
</book>

<book>
  <title lang="eng">Learning XML</title>
  <price>39.95</price>
</book>

</bookstore>

Selecting Nodes
选择节

XPath uses path expressions to select nodes in an XML document. The node is selected by following a path or steps. The most useful path expressions are listed below:
一些非常有用的路径表达式：

Examples
实例

In the table below we have listed some path expressions and the result of the expressions:
下面我们所列举的表格有路径表达式以及其结果：

Predicates
谓语

Predicates are used to find a specific node or a node that contains a specific value.
谓语用来指定明确的节所含有的特殊的值

Predicates are always embedded in square brackets.
谓语被嵌入在中括号

Examples
举例

In the table below we have listed some path expressions with predicates and the result of the expressions:
下面的表格列举了一些使用了谓语的路径表达式以及其产生的结果：

Selecting Unknown Nodes
选择未知的节

XPath wildcards can be used to select unknown XML elements.
XPath的通配符可以用来选择未知的XML元素

Examples实例

In the table below we have listed some path expressions and the result of the expressions:
下面的表格我们将列举一些路径表达式以及它们的结果

Selecting Several Paths
选择数个路径

By using the | operator in an XPath expression you can select several paths.
通过在XPath中使用 | 你可以选择数个路径

Examples
实例

In the table below we have listed some path expressions and the result of the expressions:
下面的表格我们会列举一些路径表达式以及其结果：

XPath 轴
翻译：Linyupark / 2006-03-24

The XML Example Document
XML举例文档

We will use the following XML document in the examples below.
我么将使用该XML文档进行下面的举例说明

<?xml version="1.0" encoding="ISO-8859-1"?>

<bookstore>

<book>
  <title lang="eng">Harry Potter</title>
  <price>29.99</price>
</book>

<book>
  <title lang="eng">Learning XML</title>
  <price>39.95</price>
</book>

</bookstore>

XPath Axes
XPath轴

An axis defines a node-set relative to the current node.
轴定义了相对于当前节的节集

Location Path Expression
路径表达试定位

A location path can be absolute or relative.
定位路径可以是绝对的也可以是相对的

An absolute location path starts with a slash ( / ) and a relative location path does not. In both cases the location path consists of one or more steps, each separated by a slash:
绝对定位的路径由(/)开始，而相对定位就不这样。定位的路径由一个或多个步骤所组成，每部分由(/)相分隔：

An absolute location path:

/step/step/...

A relative location path:

step/step/...

Each step is evaluated against the nodes in the current node-set.
在当前的节集中每步的赋值是逆向的

A step consists of:

• an axis (defines the tree-relationship between the selected nodes and the current node)
• a node-test (identifies a node within an axis)[在轴中鉴定节]
• zero or more predicates (to further refine the selected node-set)[0个或多个谓语可以来更好的选择节]

The syntax for a location step is:
定位的语法

axisname::nodetest[predicate]

Examples
实例

XPath运算符
翻译：无 / 2006-03-24

An XPath expression returns either a node-set, a string, a Boolean, or a number.

XPath Operators

Below is a list of the operators that can be used in XPath expressions:

<?xml version="1.0" encoding="ISO-8859-1"?>

<bookstore>

<book category="COOKING">
  <title lang="en">Everyday Italian</title>
  <author>Giada De Laurentiis</author>
  <year>2005</year>
  <price>30.00</price>
</book>

<book category="CHILDREN">
  <title lang="en">Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>

<book category="WEB">
  <title lang="en">XQuery Kick Start</title>
  <author>James McGovern</author>
  <author>Per Bothner</author>
  <author>Kurt Cagle</author>
  <author>James Linn</author>
  <author>Vaidyanathan Nagarajan</author>
  <year>2003</year>
  <price>49.99</price>
</book>

<book category="WEB">
  <title lang="en">Learning XML</title>
  <author>Erik T. Ray</author>
  <year>2003</year>
  <price>39.95</price>
</book>

</bookstore>

set xmlDoc=CreateObject("Microsoft.XMLDOM")
xmlDoc.async="false"
xmlDoc.load("books.xml")

xmlDoc.selectNodes(path expression)

xmlDoc.selectNodes("/bookstore/book")

xmlDoc.selectNodes("/bookstore/book[0]")

xmlDoc.selectNodes("/bookstore/book/price/text()") 

xmlDoc.selectNodes("/bookstore/book[price>35]/price") 

xmlDoc.selectNodes("/bookstore/book[price>35]/title") 

1 ． java.lang.Class.getMethod(String name, Class... parameterTypes) throws NoSuchMethodException, SecurityException ；

       String name ——待反射的目标方法

       Class... parameterTypes ——待反射的目标方法的参数类型的列表

2 ． java.lang.reflect.Method.invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException ；

       Object obj ——待调用反射方法的宿主对象

       Object... args ——传入待调用反射方法参数的列表

使用说明：

待反射类 PersonService.java （其中有两个同名方法）

/** */ /**

 *  @author  kxx129

 *  @version  1.0.0 2006-7-24

 *  @since  

 * 

  */

public   class  PersonService  {

       

        public  String PersonTest(Person person)  {

              person.setName(person.getName()  +   " has been detected! " );

               return  person.getName()  +  person.getRole();

       }

       

        public  String PersonTest(Person person, Person person2)  {

              person.setName(person.getName()  +   " has been detected! " );

               return  person.getName()  +  person2.getName();

       }

 

}

调用实例

》》调用目标为了调用 obj 对象的 methodName 方法，这两个值一般作为参数传入

Object obj  =   new  PersonService();

String methodName = " PersonTest " ; /**/ /* 一般反射时这个obj和methodName是不知道的，这里这样直接声名纯粹为了简化，方便实现 */

java.lang.reflect.Method m;

Class[] cls  =   {Person. class , Person. class } ;

Object[] arg  =   {person2, person } ;

try   {

                     m  =  obj.getClass().getMethod(methodName, cls);

/**/ /*                   System.out.println(m.getName());

                     System.out.println(m.getReturnType().getName().toUpperCase());

                     for (int i = 0; i<m.getGenericParameterTypes().length; i++){

                            System.out.println(m.getGenericParameterTypes()[i].toString());

                     } */

                     System.out.println(String.valueOf(m.invoke(obj, arg)));

              }   catch  (SecurityException e)  {

                      //  TODO Auto-generated catch block

                     e.printStackTrace();

              }   catch  (NoSuchMethodException e)  {

                      //  TODO Auto-generated catch block

                     e.printStackTrace();

              }   catch  (IllegalArgumentException e)  {

                      //  TODO Auto-generated catch block

                     e.printStackTrace();

              }   catch  (IllegalAccessException e)  {

                      //  TODO Auto-generated catch block

                     e.printStackTrace();

              }   catch  (InvocationTargetException e)  {

                      //  TODO Auto-generated catch block

                     e.printStackTrace();

              }

代码说明：

在实例中待调用方法的参数类型列表，参数列表如下

Class[] cls = {Person.class, Person.class};

Object[] arg = {person2, person };

所以是调用的 PersonService 类的 public String PersonTest(Person person, Person person2) 方法，如果这里换成

Class[] cls = {Person.class };

Object[] arg = { person };

则会调用 public String PersonTest(Person person) 方法。

当然如果参数类型列表换成 Class[] cls = {String.class };

则必然在 getMethod(methodName, cls) 处抛出 NoSuchMethodException

如果参数类型与参数不对应：

Class[] cls = {Person.class };

Object[] arg = { “ String ” };

则也必然在 invoke(obj, arg) 处抛出 IllegalArgumentException

<script language="javascript">
function handle()
{
    if(event.keyCode==13)
    {
        window.close();
    }
}

document.onkeydown=handle;
</script>

……
<body style="back-groundcolor:white;margin-left:20px;margin-right:20px;margin-top:10px;margin-bottom:0px" onkeydown="if (window.event.keyCode==13)self.close();">
……

……
<form name="form1" onkeydown = "if (window.event.keyCode == 13)confirmClick('save');">
……

ENTER键可以让光标移到下一个输入框
<input onkeydown="if(event.keyCode==13)event.keyCode=9" > <br>

只能是中文<input onkeyup="value=value.replace(/[ -~]/g,'')" onkeydown="if(event.keyCode==13)event.keyCode=9"> <br>

屏蔽输入法<input style="ime-mode:disabled" onkeydown="if(event.keyCode==13)event.keyCode=9"> <br>

只能输入英文和数字<input onkeyup="value=value.replace(/[\W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))" onkeydown="if(event.keyCode==13)event.keyCode=9"> <br>

只能是数字<input onkeyup="value=value.replace(/[^\d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"><br>

只能显示，不能修改<input readonly value="只能显示，不能修改">

• 初始化参数    
• 存储在背景中的对象  
• 与本背景关联的各种资源    
• 日志

可以调用ServletContext.getInitParameterNames()返回一个初始化参数的枚举对象（java.util.Enumeration），或直接指定一个参数名来得到特定的参数值：ServletContext.getInitParameter(String name)。
另外，在Servlet的背景中还可以存放与特定名字绑定的任意类型的对象，比如：

 context.setAttribute(String name, Object object);

        将把object对象绑定到名字name，存放在Servlet背景中，可供同一背景中的其他Servlet共享。其他Servlet可以通过context.getAttribute(String name)，得到一个背景中的对象，或通过context.removeAttribute(String name)在背景中移除一个对象。
        一个特定资源的URL可以通过调用ServletContext.getResource(String path)得到，这儿的path参数必须以/开始，将被解析为相对于当前Servlet背景的根的相对路径。这个方法有别于基于类加载器的java.lang.Class.getResource方法。如果你通过ServletContext.getResource方法请求了一个.jsp页面，你得到的将是JSP的源码，要得到执行结果，可以使用RequestDispatcher对象的include方法。你也可以直接以输入流的形式得到资源，

 public InputStream getResourceAsStream(String path); 
        ServletContext提供了日志的支持，你可以简单的通过调用ServletContext.log(String msg)，或ServletContext.log(String msg,Throwable throwable)方法，向底层的Servlet日志记录写入日志信息，后者还可写入异常信息和throwable的跟踪栈。
学习笔记：ServletContext接口   (http://www.51dibs.com/article_view.asp?id=10471)