JTidy提供了一个语法检查器和标签补偿器，能够对各种乱七八糟的html进行修复，使之符合xhtml标准。

　　r8 snapshot相对于r7改变了一些参数的设置方法，特别是在字符编码处理上，用setInputEncoding和setOutputEncoding方法来确定输入和输出文件的字符编码，可以使用任何有效的Java编码名称，这就比以前的强多了。

　　总体上解析的结果还不错，只是有些地方还需要对生成文件进行手工调整，或者自己再编一段代码处理一下，已经不是大问题了。

　　一些常用的参数设置：

setAltText(java.lang.String altText)
加上默认的alt属性值
setBreakBeforeBR(boolean breakBeforeBR)
在换行<br />之前加一空行
setCharEncoding(int charencoding)
已废弃
setConfigurationFromFile(java.lang.String filename)
从文件中读取配置信息
setConfigurationFromProps(java.util.Properties props)
从properties中读取配置信息
setErrfile(java.lang.String errfile)
错误输出文件
setFixBackslash(boolean fixBackslash)
URL中用/取代\
setForceOutput(boolean forceOutput)
不管生成的xml是否有错，强制输出。
setHideComments(boolean hideComments)
结果中不生成注释
setInputEncoding(java.lang.String encoding)
输入编码
setLogicalEmphasis(boolean logicalEmphasis)
用em替代i，strong替代b
setMessageListener(TidyMessageListener listener)
加入一个TidyMessageListener监听器
setOnlyErrors(boolean onlyErrors)
只输出错误文件
setOutputEncoding(java.lang.String encoding)
输出编码
setPrintBodyOnly(boolean bodyOnly)
只输出body中的部分
setRepeatedAttributes(int repeatedAttributes)
重复属性的处理
setSpaces(int spaces)
每行前的空格数，就是缩进格式
setTidyMark(boolean tidyMark)
是否生成tidy标记
setTrimEmptyElements(boolean trimEmpty)
不输出空元素
setUpperCaseAttrs(boolean upperCaseAttrs)
属性变大写
setUpperCaseTags(boolean upperCaseTags)
标记变大写
setWraplen(int wraplen)
多长换行
setXHTML(boolean xhtml)
输出xhtml
setXmlOut(boolean xmlOut)
输出xml
setXmlPi(boolean xmlPi)
文件头输出xml标记
setXmlSpace(boolean xmlSpace)
加入xml名字空间属性

使用方法极为easy，定义输入输出流，用tidy.parse()转换就行了：

BufferedInputStream in;

FileOutputStream out;

Tidy tidy = new Tidy();

tidy.setConfigurationFromFile(configFileName);//配置文件，写入上面的设置参数

try {

in = new BufferedInputStream(new FileInputStream(srcFileName));

out = new FileOutputStream(outFileName);

tidy.parse(in, out);

} catch (IOException e) {

System.out.println(e);

}

       控制的例子：
用户登入进入一个网络，系统进行认证和权限判定；
用户进入网络后，访问网络中的资源，系统向目录服务查询该用户是否具有使用该资源的权限，并返回所请求资源的物理地址。
个人用户可以使用目录服务存储个人设置信息，并可以对其所有环境进行集中存储和控制。
随着目录服务技术的成熟，人们可以使用该技术通过一些网络设备监视和控制网络传输情况。

    目录服务的基本功能：
资源信息的目录式表示、分布存储、资源定位和查找、用户的统一认证、系统资源的统一授权、系统资源信息的共享、系统资源的单点统一管理、安全传输的保证、资源的统一监控等。
目录服务的主要优点：
网络管理工作大大减轻，包括管理网络上的各个应用；
网络的集中管理点；
访问用户信息的集中控制点；
存储在其它条件下很难处理的管理信息
系统资源信息的利用率高、管理的可扩展性好
简单地说，目录的发展经历了书面目录（电话目录、医士列表）——基于计算机的目录（PIM，不易共享、必须访问到响应的软件和计算机）——网络目录（公共的、共享的、统一的）。
传统的目录是计算机或网络基础结目录的一个构件，它向其它应用程序提供服务，但没有提供集成管理的机制，网络上的计算和服务需要一种公共的、分布式的目录，能够跨平台地对应用程序和用户提供集中、统一的服务。目录服务将使网络上的系统资源管理朝着单一的、全网络的目标发展，并能够让用户、管理员以更容易的方式来管理网络环境。目录服务作为一种工具来减少大型网络的管理负担，提供了集中的单点管理和适应复杂环境所必须的灵活性，减轻了非目录服务系统中存在的冗余管理。
通过网络资源逻辑接口，目录服务（ADS）减少了人们为了利用网络功能而必须对网络掌握的程度。也就是说，普通用户只需要很少的网络知识，就可以通过复杂网络访问和使用资源。用户不需要再了解资源的物理分布，访问本地打印机的方法和访问远程网络资源的方法相同。目录服务（ADS）提供了逻辑表示与资源的网络上的物理位置的连接，从用户的角度看，这可能是转移到基于目录的网络操作系统具有的最大优点。）
目录服务和数据库的区别：
读多于写
一般不支持事务处理
信息访问方式不同（一个是SQL、一个是LDAP的API）
目录中的信息一般不要求严格的一致性
传统的数据库是平面的，无法表示资源之间及资源使用控制的复杂逻辑关系而远远不能满足当前资源信息管理的各种要求。
目录服务与DNS系统的相同之处和不同之处
相同之处：
分布存储
树型层次结构
容错
不同之处：
DNS的功能和目录服务不同，DNS功能单一，本质上是将主机名解析成IP地址。目录服务是可以为多个应用提供网络资源的信息存储和管理，具有广泛的应用特性；
DNS是以一系列文本文件为基础，是一种纯文本式的数据库，无法进行扩展，适应其它功能的要求；
与分布式文件系统的相同在于采用了准树型层次结构，具有一定的授权功能，区别在于：
目录服务表示资源的各种属性信息，可为各种应用提供服务，文件不能表示；
目录服务有很强的逻辑表示和分类，文件的组织逻辑性单一，主要按存储位置；
文件系统的认证功能较差
独立性强
目录服务的应用举例
C4ISR系统：由多个大的子系统构成，管理问题更为复杂和严重
新的应用：电子商务（IBM）、操作系统（WINDOWS2000）
网络的监控管理
会议系统和PIM
搜索功能
太多的应用——基于目录的应用
原有应用的资源管理的重新开发
二、  LDAP协议的特点
X.500协议是为了便于建立全局、分布式的目录信息而设计的一套协议。它是一种C---S（Client—Server）结构的应用协议，支持用户通过网络访问和维护资源信息，另外还具有几个突出的特点：
支持分布式的目录信息维护，所以每一个运行X.500的服务器都只需负责自己所管辖的资源信息，只需在本地就可完成信息的更新；
提供强大查询能力，可以让用户随心所欲的设计查询方式；
全局的信息标示，通过这种标示可以唯一的定位信息位置，获取内容；
结构化的信息模式，支持开发者的本地扩展；
遵循统一的标准，所以可以通过标准的方式访问任何一个X.500服务器，获取信息；
X.500协议中包含了这诸多的强大功能，可以说在很大的程度上满足了用户和开发者的要求，但是在用户和开发制的使用过程中却逐渐暴露出其许多的不足之处，阻碍了它的应用和推广，主要集中在使用方式和性能开销上这两个方面，由于X.500是在OSI协议栈上实现的，虽然X.500提供了强大的信息查询功能，但是协议所要求的访问格式却十分复杂，往往难以掌握；其次在运行X.500服务器时对系统的开销要求较高。为了兼顾保留协议的优点和克服这些不尽人意的地方，推出了由X.500目录服务协议延伸发展而来的轻型目录访问协议（Lightweight Drectory Access Protocol，简称LDAP）。LDAP协议继承了X.500的90%左右的功能，同时兼容所有使用X.500协议建立的服务端数据库，避免了重复开发的浪费；在运行开销上却只是X.500的10%。正是由于LDAP具有巨大的优越性，它从一开始仅仅是作为X.500客户层的另一种实现方式，到现在在许多应用中完全替代了X.500协议，成为一个完整实用的应用开发协议。
LDAP在以下四个方面对X.500进行了简化：
传输 ：   LDAP直接运行在TCP上，避免了OSI多层通信的高层开销；
功能：    LDAP简化了X.500的功能，抛弃了较少用到的功能和冗余的操作；
数据表示：X.500的数据表示结构复杂，LDAP采用简单的字符串对数据进行表示；
编码：    LDAP用于网络传输的编码规则比 X.500的编码规则更加简单。
总到来说，基于LDAP的目录服务有以下特点。
目的是存储网络资源的信息
结构化的信息框架(面向对象的信息存储方法)，采用树型层次式结构表示
在系统中的单点集中（不指物理位置）管理资源，可实现单一登入点
读多于写
基于TCP 协议
Client/Server逻辑结构
标准的访问协议LDAP
强大的搜索功能，允许用户组织复杂的查询要求
维护的分散性(信息可分布存储,具有集中式数据库无可比拟的优越性)
可全球唯一的命名
动态添加和修改信息
容错功能
自动更新和维护存储的信息
方便的备份和恢复功能
安全访问和信息传输的安全
易对资源进行授权管理
三、  LDAP协议的内容
        LDAP定义了四种基本模型：
信息模型说明了LDAP目录中可以存储哪些信息；
命名模型说明了如何组织和引用LDAP目录中的信息；
功能模型说明了LDAP目录中的信息处理，特别是如何访问和更新信息；
安全模型说明如何保护LDAP目录中的信息不受非授权访问和修改。
信息模型
       LDAP的信息模型是以模式（Schema）为基础的，以项目（Entry）为核心的。模式由若干项目组成，项目是描述客观实体的基本单位，项目（如图3）由描述客观实体具体信息的一组属性（Attribute）构成。属性（如图3）只能有一种类型（Type），可以有一个或多个值（Value）。属性的类型具体说明属性值可以存储哪些信息，以及这些信息的行为特性。例如，属性cn的类型是caseIgnoreString，它意味着属性值是按照词典排序的字符串，并且在比较时忽略大小写，如BEIJING和Beijing是相同的；属性tele的类型是telephoneNumber，它具有caseIgnoreString的全部特性，另外在比较时忽略空格和破折号，如0731-4573670和07314573670是相同的。每个项目都有一个属性objectClass，用于说明项目的类型，以及项目中的必选属性和可选属性。属性objectClass的取值可以是一个或多个，其中必须有一个用于说明项目的基本结构的结构对象类（Structural object class），结构对象类不能轻易改变；除此之外，还可以有若干个对项目结构进行辅助说明的辅助对象类（Auxiliary object class），在访问控制允许的范围内可以新增或删除辅助对象类。

命名模型
        在LDAP目录中，项目是按照树形结构组织的，根据项目在树形结构中的位置对项目进行命名，这样的命名通常称为标识（Distinguished name），简称DN。DN由若干元素构成，每个元素称为相对标识（Relative distinguished name），简称RDN。RDN由项目的一个或多个属性构成。

       LDAP的命名模型（如图4）与我们熟悉的文件系统有很多相似之处，RDN与文件系统中的文件名很相似，DN与文件的绝对路径名很相似。另外，与文件系统一样，兄弟项目（即，具有相同父项目的子项目）必然具有不同的RDN。LDAP的命名模型与文件系统之间的区别主要有：
在LDAP目录中，位于叶节点和非叶节点的项目都拥有各自的属性；在文件系统中，只有位于叶节点的文件拥有较丰富的内容，而位于非叶节点的目录的内容相对简单。
在LDAP目录中，DN中各元素的排序是从叶到根；在文件系统中，文件绝对路径名中各元素的排序是从根到叶。
在LDAP目录中，DN中各元素之间的分隔符是“，”；在文件系统中，文件绝对路径名中各元素之间的分隔符是“/”或“\”。
在LDAP目录中，允许超越树形结构的别名项目（Alias entry），它指向其它项目。

功能模型
        LDAP的功能模型涉及以下三个方面：
询问（Interrogation）
LDAP在信息询问方面主要定义了查找（Search）和比较（Compare）两个操作。在查找操作中，根据选取标准在指定范围内选择项目，这个选取标准通常称作查找过滤器（Search filter），并且可以规定一组需要返回的属性。另外，还可以规定查找结果的大小和客户端等待结果的时间。比较操作主要是判断指定项目是否包含指定属性（包括类型和值）。
更新（Update）
LDAP在信息更新方面定义了新增（Add）、删除（Delete）、修改（Modify）和修改RDN（Modify RDN）等四个操作。新增操作主要是在LDAP目录中插入一个新的项目。删除操作主要是从LDAP目录中删除已有项目。修改操作主要是修改已有项目的属性，具体地说，可以增加、删除、修改属性或属性值。修改RDN操作主要是修改项目的名字。
身份验证（Authentication）
LDAP在身份验证方面定义了连接（Bind）、断接（Unbind）和作废（Abandon）等三个操作。连接操作主要是客户端向服务器提供身份信息，包括DN和口令，以便于服务器验证客户端的身份，身份验证成功即建立客户端与服务器之间的会话（session）。断接操作主要是结束客户端与服务器的会话。作废操作主要是中止正在执行的操作。
       
        安全模型
如何控制从网络上来的各种访问请求，防止非授权的访问发生？这对于一个系统而言，也是十分重要的，因为许多的用户信息（如密码、费用）以及许多系统的配置数据等都属于敏感信息，它们不希望被随便一个普通的使用者访问，而只允许管理员拥有查询和修改的权限。LDAP的安全模型是以客户端的身份信息为基础的。客户端的身份信息通过连接操作提供给服务器，服务器根据身份信息对客户端提出的访问请求进行控制。在LDAP中存在一个被称为访问控制列表（Access Control List，以下简称ACL）的文件，控制各类访问请求具有的权限。ACL文件中的控制方式具有极大的弹性：即可以在大范围上控制某一类资源可以被某类甚至某个用户访问，还可以具体到资源类中的任何一个属性。其授权的种类有读、搜索、比较、写这几种，可以单独，也可以组合使用。一般的格式是
access to “cn=*,ou=nudt,o=cs,c=cn”
by    “cn=tom,ou=nudt,o=cs,c=cn”   write
上面的控制设置就赋予了Tom对NUDT部门下的所有资源信息写的权利，当然也就有了读等这些权利了。详细的定制和完善ACL文件，可以使目录服务系统提供较好的安全性。此外，开发者还可以根据安全程度的需要，在LDAP中集成其它的安全工具，如KERBOUS, SSL等应用广泛的安全技术，适用不同层次用户的需要。

四、 LDAP如何工作以及如何开发LDAP的应用
LDAP是以服务器—客户端方式工作的，目录服务将数据库软件的逻辑结构分为前端（客户端）和后端（服务端和仓库）（图1）                                            

       客户端是直接面对一般开发者和用户的；服务端是用于接收和解释客户请求，然后以客户的身份完成请求，并将完成结果返回给用户；仓库则是真正存储信息的地方。在LDAP中，服务端和仓库之间的连接采用了ODBC机制，所以可以使用任何支持和具有ODBC驱动程序的数据库软件，简单的可以是Linux系统中自带的GDBM或Alpha中的NDBM等数据库管理系统；也可以选用在功能和性能上更优越的Oracle和Sybase等系统，这样，可以提高系统的可移植性。
       现在已经有了许多基于LDAP协议开发出的资源管理系统和工具，如Openldap、NDS（Novell Directory Service）和ADS（Active Directory Service）等。它们已经逐渐的被使用在了各个需要目录服务的领域，并且应用的趋势在增强。
      Openldap是Michigan大学发布的免费软件，实现了LDAP v2的功能，并部分支持LDAP v3。它提供原代码，可以在大多数的Unix和Linux系统中安装。开发者能够直接利用它所附带的一些SHELL工具开发简单的应用，这些SHELL包括了查询（ldapsearch）、修改（ldapmodify）、删除（ldapdelete）、增加（ldapadd）等，关于他们的使用方法可以参照帮助文件；也可以调用它提供的程序接口（API）来开发应用，接口包括了查询（ldap_search）、修改（ldap_modify）、增加（ldap_add）、删除（ldap_delete）等。从模版的定制到资源信息的组织和输入都可以按照用户的要求进行，开发出满足你要求的应用软件。
我们以openldap1.2.7为例，进一步说明LDAP的工作方式。也就是如何使用openldap1.2.7来建立一个基于LDAP应用开发。Openldap1.2.7的后台数据库选用gdbm 1.8.0，Openldap实现了与gdbm的接口ldbm。SLAPD是Openldap实现的独立的LDAP服务的守护进程，SLURPD是Openldap实现的独立的LDAP更新和复制的守护进程。gdbm 是GNU发布的免费dbm，使用哈希排序的数据库例程集，与标准的UNIX下的dbm例程一样工作。gdbm有比Berkeley dbm更快的快速排序，并且它是可重入的。
进行开发前，先要安装gdbm和openldap。
得到gdbm1.8.0.tar，tar xvf gdbm1.8.0.tar
cd ./gdbm
./configure
make
make install
然后安装openldap：
tar xvf openldap.tar
cd ./ldap
./configure - - with-ldbm-api=gdbm，使ldap服务进程在后端使用gdbm数据库
make depend
make
make install
        接下来，进行基于LDAP协议的应用开发，大致分为四个步骤，这四个步骤同时也分别对应了建立协议中四种基本模型的过程：信息模型、命名模型、功能模型和安全模型。
       首先是建立信息模型，既计划需要管理的资源范围，在LDAP中所建立的信息以“实体”（entry）为单位，数据库的框架被称为“模版”（schema），每个实体的属性范围都会在模版中说明。模版的内容可以根据你的需要随意定制，可以将具有类似属性范围的信息归为一类，对于一类实体的说明采用了基于面向对象的机制，将模版中的每一个信息框架称为一个类“class”，而可以用这个类定义出你需要的事例，也就是一个个信息实体。
例如在模版文件中写入这样内容：
                        objectclass  person
{
requires
account,
userpassword
allows
sex,
……
}
        其中requires所包含的属性是每一个登记的用户都必须填写的属性范围，而allows所包含的则是可有可无的内容，这也给信息的存储控制增添了许多灵活性；其中，象系统管理员这种资源可以与一般用户合并，只是需要在属性中加入“类型”这样的属性用以区分是用户还是，为了安全，也可以将管理员单独设置为一类资源，在他的属性范围中包括帐号名、密码、管辖的范围（机器等设备的标示）、和联系方式等。对于其它的资源则根据实际情况分别设计，最后生成一个完整的模版文件。在openldap中，模版文件包括编辑yourname.oc.conf（定义信息对象类的文件）和yourname.at.conf（定义对象类中属性的文件）。
        对照上面的信息模型所建立的信息库还仅仅是一个个零散的资源记录，为了表现出它们之间的逻辑联系，需要完成LDAP中的命名模型。在平面式数据库中定位信息记录是通过每一条记录前面的标号或通过某些域的关键字匹配来完成的，实现过程大多是通过轮询，这在提高处理性能上就造成了许多障碍。LDAP中采用了更加合理的树形存储方式，将资源信息记录分别放置在树的根到叶的位置上，这种方式总是从不同的方面表现出了信息记录之间的某种从属的逻辑关系。
    对于每一个信息实体的定位使用全球唯一的命名方式既“可区分的名字”（DN：Distinguished Name），信息间的逻辑关系同时从DN中得到体现。可以参照Internet中的域名来理解DN的表示方法，如果你将所管理的信息按照地域进行分类，那么DN中就回包含你的分类标准，如从国家，到地区，在具体到某个部门中的人或者机器等等，格式是“cn=  ，ou=  ，o=  ，c=  ”。（其中的cn、ou、o、c都是一些标示关键字，分别表示用户名字、部门、地区和国家）这样当用户需要寻找某人的一些信息（如电话号码、Email地址等），如果知道他的工作地址，那么可以查找这个单位中所有符合条件的人员信息，如果查找的条件较具体，那么可以直接找到这个人的信息实体，即使是给的查找条件比较模糊，也可以找出单位中所有符合条件的人员信息，然后由用户从中挑选出需要的，信息的逻辑结构见（图2）
  cn            中国
 
  o             长沙              上海     北京
 
  ou           国防科大      市政府
 
 cn           张三               李四
        当然，分类方式完全可以按照你的需要进行选择，将所有的信息组织在数据库中。建立了信息模版之后，就可以开始生成数据库本身了。添加数据库信息可以是先写一个LDIF（Ldap Data Information Format）格式的文档，（每个ldif文件对应一个数据库，在LDAP中可以有多个数据库，）这种格式是与模版是对应的，将一个个信息实体罗列在文件中，然后使用SHELL工具“ldif2ldbm”将其转换为当前使用的数据库软件的格式，并且在启动服务端时告诉这些数据库文件的存储路径；
         如何真正的访问LDAP信息库中的记录则是在其功能模型中定义的内容，在应用开发中即开发一个LDAP的客户端和该客户端如何访问LDAP服务器。Openldap提供的仅仅是一系列的shell命令和API,我们要依靠这些底层调用来建立一个完整的用户访问和显示环境。如果不进行这方面的开发，可以使用普通的浏览器或者直接通过shell命令来操作，不过这种操作方式需要对LDAP的环境，配置情况，存储内容都有相当详细的了解，还要记住LDAP中复杂而又繁琐命令格式。普通用户根本不可能掌握。
         一个完整的访问过程包括四个步骤：初始化、绑定服务器、访问资源信息和断开连接。其中初始化是分配一个操作句柄；绑定服务器是向服务端提供自己的身份标示（含用户名和密码等）；访问资源信息则是提出自己的访问请求（如查询和更新，他们分别有对应的标准API），等待并获取访问结果；断开连接是在所有的访问工作完成之后断开与服务端的连接，释放占用的资源。LDAP是简化了X.500中的许多操作，它在访问资源的方式中主要提供与“读”和“写”相关的操作手段。与“读”相关的有查找（search）和比较（compare），在查找时可以通过设置不同的“过滤器”（filter）达到获得自己需要的结果，过滤器中的内容可以涉及到任何相关属性的名称及取值范围等，并且支持与、或、非等关系表达式；“比较”则是将特定记录中某属性的值取出与自己的设定进行关系比较。与“写”相关的操作有增加、删除、修改和更名。增加是在信息库中增加新的信息记录，当然不能有相同唯一标示的记录存在；删除是将被认定为无用的信息记录从库中删除；修改是对于库中资源信息的某些属性值进行修改；更名则是更替唯一标示中最后一部分的内容，往往使用在仅仅这个资源的名称有了改变的情况下。
        如何防止资源信息的非授权访问和处理数据备份以及恢复是在安全模型中解决的问题。我们在下一章进行详细说明。
在处理好以上四个方面后 ，我们就可以启动LDAP服务了，在openldap中，启动服务器端的SLAPD（LDAP服务器进程），就可以响应用户的访问了。
 LDAP中的访问控制
        LDAP通过安全控制列表ACL（Access Control List）可以对信息库中的所有资源进行访问控制，甚至可以具体到一个资源记录中的某个属性。在openldap中，是在slapd.conf中定义的。Slapd.conf是LDAP最主要的配置文件，它说明了LDAP中使用的模板文件、日志文件、数据库位置、系统管理员帐号、系统管理员口令和各种安全机制等，其中主要是定义用户访问权限和建立LDAP的主从和主备关系。
对于用户访问权限，举例说明，我们可以将用户信件信息只授权给收件人，那么当该用户在绑定服务器并提供正确的帐号名和密码之后可以访问所有寄给他的信件，而其他用户试图超越自身的权限，获取其他用户的信件信息时会被立即拒绝。可以这样来描述权限的设置：
access to dn=”.*, User=Tom, o=XY, c=A”   by  dn=”User=Tom, o=XY, c=A”。
通过这条限制就将信件的访问权限完全的赋给了信件的收取者。同样，设备的访问权限是授予了相应的设备管理员，而用户这类资源则只能由系统管理员来控制。
对于用户密码这个属性，可以这样定义。
access to dn=".*,grp=general,ou=nudt,o=cs,c=cn" attr=userpassword
        by self                                       write
        by *                                         none

在slapd.conf中还可以定义referral配置，它的值应是另一个LDAP服务器或多个LDAP服务器的 URL，当用户进行查询时，没在本地找到，就会去referral指定的其它LDAP服务器进行查找。openldap直接在服务器上实现了referral，而是返回给客户referral地址，如图1。①向server发出请求；需要指向其它server时，②返回referral地址；③客户需重新向referral地址发出请求；④返回结果。为了网格用户的方便，需要屏蔽掉信息所在地址即referral，实现Chaining，即在服务器上自动支持referral，如图2。①向server发出请求；需要指向其它server时，②自动指向referral地址；③自动向referral地址发出请求；④返回结果。

图1
图2
有了referral的功能，我们就可以把网络内的LDAP服务器都建立这样一种联系，使得用户不必记住每个LDAP服务器都存储些什么内容以及它们的地址，只要记住离自己最近的LDAP服务器就可以了，如果用户要操作的内容不在该服务器上，会自动地寻找直到找到正确的服务器，得到正确的内容为止。
六、LDAP的主从备份功能
       安全机制中一个重要的内容就是备份和恢复，在LDAP中提供了主从备份服务器的机制，它方便和经济地实现了备份和恢复的功能。下面介绍主从服务器的配置方法和运行过程。
主服务器为了表明当前所运行服务进程的身份，必须在其配置文件（slapd.conf）中注明，并且还标明所有从（备份）服务进程的地址（IP或域名）；从（备份）服务进程中需要标明它所面对的主服务进程的地址（IP或域名）。
主服务进程配置文件：
# Just show the necessary portion for replicate， ‘389’ is the port number
replica          host=172.26.20.98：389
               binddn=“adm=replica99，ou=nudt，o=cs，c=cn”
               bindmethod=simple      credentials=passwd
# The second slave server
replica          host=172.26.20.97：389
               。
               。
               。
（注）：
binddn是主server向该从server发出操作命令时使用的身份。
    Bindmethod是标明使用的身份验证的方法，可以是“用户名+密码”也可以是kerberos方法。
    Credentials分别为密码和认证书

从server配置文件：
# Just show the necessary portion for replicate，98 is the IP of the master server
referral          ldap：//172.26.20.98
updatedn        “adm=replica99，ou=nudt，o=cs，c=cn”
# Give updatedn the right to write the Directory Tree
access  to “.*，o=cs，c=cn”
       by “cn=replica99，ou=nudt，o=cs，c=cn”  write

（注）：
referral：是当在本地无法提供信息数据时，提供下一个服务器的地址，可以通过再一次查询获取数据。
在备份服务进程的配置文件中，不必使用referral，因为它不真正的提供索引服务。
启动顺序
将主服务进程上的数据库文件拷贝给各个从（备份）服务进程，达到最初的一致。
启动主服务进程上的slapd进程
启动从服务进程上的slapd进程
启动主服务进程上的slurpd进程
slurpd是可以定时把主服务器上的修改进行备份，依据是由写操作产生的日志，如果由于网络的原因导致了备份失败，slurpd会自动进行重试，直到备份成功。
日志
设置在主服务进程r服务器上，需要修改配置文件：
# For log of the LDAP server ，you can set the file name you like
replogfile         /home/ldap/nhpce.replog
实际此文件只是给slurpd进程使用，作为一个广播操作命令的中转站，真正的日志文件在/var/tmp下,文件名称为slurpd.replog。
一个主服务器的从服务器个数是没有限制的，通过以上设置，可以产生了一个由主服务器进程和一个或几个从服务进程组成的服务机群，主守护进程作为整个服务机群的核心，其始终维持系统信息的一致性，因为除了查询以外的请求都首先由它操作自己的信息库，然后再将该操作广播给各个从服务器，同步更新各自的信息库。而对于查询请求，由于不会造成信息内容的改变，所以可以由各个从服务器完成，这样的方式特别适用于象目录服务这样查询请求远远多于修改等请求的应用。

下面是一个主服务器和多个从服务器组成的服务机群处理访问的步骤：
客户向服务机群发出请求（客户使用的可能是IP或域名），此请求可以被一个前端的域名服务器转给一个从服务进程。
从服务进程将除了搜索以外的请求发向主服务进程。
主服务进程根据请求成功完成相应操作之后，将操作广播给所有的从服务进程。
从服务进程r此时完成主服务进程要求的操作。
从服务进程将操作结果返回给客户。

图3
这样的服务器机群，每个从服务器都有一个主服务器信息的完全备份，当出现主服务器因为各种原因无法提供服务或无法恢复其信息数据时，则可将备份服务器上的数据信息转移到主服务器上，继续提供服务；或者直接将备份服务器的配置文件进行修改，从新启动服务进程，将其身份变为主服务进程。而且这些处理都十分方便。如果在平时就做好准备，那么可以在极短的时间内恢复服务。
实际上，不但一个主服务器可以对应多个从服务器，而且一个从服务器可以从多个主服务器上备份信息，形成一个主备的服务机群。
        采用主备关系服务机群的系统逻辑视图如下：                                        

图4
        在上图中，设置了两个主服务信息库，它们平时可以是各不相干的角色，管理各自的域内事务，而后面的两个备份信息库则为了提高使用效率，同时作为了两个主服务信息库的备份库。对于上面两种方式的实现，其配置文件的写法大体相同。
不仅如此，多个LDAP服务器之间可以互为主从关系，即每个服务器都把自己管理部分定义为主服务信息库，而其他所有的LDAP服务器把与之相应的信息库定义为该主信息库的从信息库。这样，实际上每个LDAP服务器的地位是平等的，存储的信息则包括了全局的信息。每个单位只有对本单位的LDAP服务器上本单位的信息具有写和修改的权限。而修改的同时各个单位的LDAP服务器上的相应的信息就都修改了，每个单位的用户都可以在本地的LDAP上访问全局的信息，而且基本上能保证是最新的信息，这种方式有响应时间短，资源利用率高，抗毁能力强的优点。充分地发挥了分布式系统特点。缺点是每一次写操作都要广播到每个LDAP服务器，增加了网络的负担。但因为目录服务的特点是读操作远远大于写操作，实际上对网络负载影响不大。具体逻辑关系见下图。
图5
在配置上需要在每个LDAP服务器上建立相应的slapd.conf文件，在配置文件中声明自那部分是主服务器并定义每个从服务器的位置和权限。自己作为从服务器从那些LDAP服务器中以什么身份取得那些信息。下面举例说明。在国家高性能计算环境中基于LDAP的目录服务采用了这种组织形式，它的LDAP的配置文件如下，本地服务器是国防科大。
下面是slapd.conf简化了的写法。

#NHPCE Slapd Configure File
include                /etc/openldap/slapd.oc.conf
include                /etc/openldap/slapd.at.conf
schemacheck        on
pidfile                /var/run/slapd.pid
argsfile        /var/run/slapd.args
access to attr=userpassword
        by self                                                read
        by dn="cn=Manager_nudt,grp=GENERAL,ou=NUDT,o=CS,c=CN"        read
        by *                                                none       

#ldbm definition for the NUDT master database
database        ldbm
suffix                "ou=NUDT,o=CS,c=CN"
directory        /etc/openldap/database/nudt_db
rootdn                "cn=Manager_nudt,grp=GENERAL,ou=NUDT,o=CS,c=CN"
replogfile        /etc/openldap/database/nudt_db/slapd.replog
replica                host=159.226.39.173:389
                binddn="cn=Replicator_nudt,grp=GENERAL,ou=NUDT,o=CS,c=CN"
                bindmethod=simple
                credentials=secret
replica                host=159.226.39.144:389
                binddn="cn=Replicator_nudt,grp=GENERAL,ou=NUDT,o=CS,c=CN"
                bindmethod=simple
                credentials=secret
index                default                none
defaultaccess                                                read
access to dn=".*,grp=general,ou=nudt,o=cs,c=cn"        attr=userpassword
        by self                                                write
        by *                                                none
access to dn=".*,grp=general,ou=nudt,o=cs,c=cn"        attrs=email,telephone,description
        by self                                                write
        by *                                                read       
access to dn="cn=Manager_nudt,grp=GENERAL,ou=NUDT,o=CS,c=CN"
        by *                                                none
access to dn="cn=Replicator_nudt,grp=GENERAL,ou=NUDT,o=CS,c=CN"
        by self                                                write
        by *                                                none
lastmod                                                        on

#ldbm definition for the NUDT slave database
database        ldbm
suffix                "ou=CAS,o=BJ,c=CN"
directory        /etc/openldap/database/cas_db
rootdn                "cn=Replicator_cas,grp=GENERAL,ou=CAS,o=BJ,c=CN"
updatedn        "cn=Replicator_cas,grp=GENERAL,ou=CAS,o=BJ,c=CN"
index                default                none
defaultaccess                                                read       
 
#ldbm definition for the JNICT slave database
database        ldbm
suffix                "ou=JNICT,o=WX,c=CN"
directory        /etc/openldap/database/jnict_db
rootdn                "cn=Replicator_jnict,grp=GENERAL,ou=JNICT,o=WX,c=CN"
updatedn        "cn=Replicator_jnict,grp=GENERAL,ou=JNICT,o=WX,c=CN"
index                default                none
defaultaccess                                                read       
七、 LDAP的应用前景
目录服务系统将在越来越多的网络应用系统中使用，特别是一些大型的网络应用（一些大型网站也会需要）当中，这也是各个大公司为什么要将此作为网络基础软件来看待。
集中单点管理、分布容错和单一登入点（包括合理的认证服务）的功能是具有巨大的诱人优势。
使用LDAP可以开发大的应用软件项目，比如可以应用在C4ISR中，当然会还有其它应用。
小的项目也会需要目录服务的的支持，目录服务是一个在逻辑上集中存储资源信息的特殊数据库，许多数据库开发都可以用LDAP替代，而且LDAP更易于开发，更灵活。
目录服务系统将从现行的V2、V3继续发展，具有目录服务功能的网络DEN（发布、发现和获取）即将出现，不经对网络上的高层资源进行集中管理，而且对网络基础设备的集中管理，例如：具有目录路由器。一句话：就是DEN将网络服务和网络设备的管理更好地继承到普通管理技术中。

<!--[if !supportLists]-->         <!--[endif]-->增加节点

/**

*entry ：包含新增节点的所有信息

/*

public boolean addInformation(Entry entry)

       {

              try

              {

                     Attributes attrs = new BasicAttributes();

                     Enumeration attrEnum = entry.keys();

                     while (attrEnum.hasMoreElements())

                     {

                            String type = (String) attrEnum.nextElement();

                            Attribute oneAttr = new BasicAttribute(type);

                            Vector vals = (Vector) entry.get(type);

                            Enumeration valEnum = vals.elements();

                            while (valEnum.hasMoreElements())

                            {

                                   oneAttr.add((String) valEnum.nextElement());

                            }

                            attrs.put(oneAttr);

                     }

                     dc.createSubcontext(entry.getDN(), attrs);

                     return true;

              } catch (Exception ne) {

                     //System.err.println("Error: " + ne.getMessage());

                     ne.printStackTrace();

                     return false;

              }

       }

       举一个构造entry的例子：

       Entry en    = new Entry();

       String enDN = "cn=dsafa,dc=gsmd,dc=com";

       Vector employeeName = new Vector();

       Vector objectClass = new Vector();

              Vector mailAddress = new Vector();

              Vector mobilePhone = new Vector();

              en.setDN(enDN);

              employeeName.add("liufu");

              en.put("employeeName",employeeName);

              objectClass.add("cssisMail");

              en.put("objectClass",objectClass);

              mailAddress.add("dsfsa");

              en.put("mailAddress",mailAddress);

              mobilePhone.add("1234");

              en.put("mobilePhone",mobilePhone);

<!--[if !supportLists]-->         <!--[endif]-->修改节点的信息

每个节点相当于一个实体，每个实体有很多属性，当然我们要改的就是某些或某个属性的值。

       /**

       *dn ：节点的位置 如：ou = kk, dc = china ,dc=com

       /*

       public boolean modifyInformation(String dn)

       {

              try {

                     ModificationItem[] mods = new ModificationItem[2];

                     Attribute mobilePhone = new BasicAttribute("mobilePhone",

                     "12315");

                     Attribute employeeName = new BasicAttribute("employeeName","Smith");

                     mods[0] = new ModificationItem(DirContext.ADD_ATTRIBUTE,

                                   mobilePhone);

                     mods[1] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE,

                                   employeeName);

                     dc.modifyAttributes(dn,mods);

                     return true;

              } catch (NamingException ne) {

                     System.err.println("Error: " + ne.getMessage());

                     return false;

              }

       }

<!--[if !supportLists]-->         <!--[endif]-->删除指定的节点

这个简单没啥好说的把：）

public boolean deleteInformation(String dn)

       {

              try {

                     dc.destroySubcontext("cn=asdf,ou=mail,dc=gsmd,dc=com");

                     return true;

              } catch (NamingException ne) {

                     System.err.println("Error: " + ne.getMessage());

                     return false;

              }

       }

<!--[if !supportLists]-->         <!--[endif]-->修改节点的名字（dn）

这个好像只能修改叶子节点的，有没有人找到可以修改非叶子节点dn的方法，告诉我porcupine2004@126.com

              public boolean renameEntry(String oldDN,String newDN)

              {

                     try {

                            dc.rename(oldDN,newDN);

                            return true;

                     } catch (NamingException ne) {

                            System.err.println("Error: " + ne.getMessage());

                            return false;

                     }

              }

这两篇文章就LDAP的一些操作进行了简单的讲解，ldap远远不止这些，偶还是一只小小菜鸟，不断在学习中，我会留下偶学习的痕迹的，希望能与各位大大交流，有啥问题也可以一起探讨.

<!--[if !supportLists]-->         <!--[endif]-->连接LDAP服务器

String dn; //包括连接LDAP服务器的用户及要操作的根节点

DirContext dc; //相当于这个树的一个映像

Properties env = new Properties();

env.put(DirContext.INITIAL_CONTEXT_FACTORY,"com.sun.jndi.ldap.LdapCtxFactory");

env.put(DirContext.PROVIDER_URL, "ldap://" + host + ":" + port);

if (dn != null) {

       env.put(DirContext.SECURITY_PRINCIPAL, dn);

       env.put(DirContext.SECURITY_CREDENTIALS, password);

}

dc = new InitialDirContext(env);

dn举例: dn=” cn=Manager,dc=kkk,dc=com”,password就是这个dn对应的密码。Host是LDAP服务器的主机地址，port是端口(openLDAP默认开放的是389)

<!--[if !supportLists]-->         <!--[endif]-->查询这棵树的所有节点

有点类似sql里边的select * from tableName;

                   /**

                    * @param base ：根节点(在这里是”dc=kkk,dc=com”)

                    * @param scope ：搜索范围

            * @param filter ：指定子节点(格式为”(objectclass=*)”,*是指全部，你也可以指定某一特定类型的树节点)

            * @param attributes ：属性集合(格式为{“*”}如果要指定搜索某一指定的属性列，就把*改成响应的属性列名称就行了)

                    * @return result ：result里边存的就是查询的结果集合

                    */

                   public Vector searchInformation(String base, String scope, String filter,

                             String[] attributes)

                   {

                      Vector results = new Vector();

                      SearchControls sc = new SearchControls();

                      if (scope.equals("base")) {

                             sc.setSearchScope(SearchControls.OBJECT_SCOPE);

                      } else if (scope.equals("one")) {

                             sc.setSearchScope(SearchControls.ONELEVEL_SCOPE);

                      } else {

                             sc.setSearchScope(SearchControls.SUBTREE_SCOPE);

                      }

                      // Reduce data provided by the LDAP server by listing

                      // only those attributes we want to return.

                      if (attributes.length > 0) {

                            sc.setReturningAttributes(attributes);

                     }

                      NamingEnumeration ne = null;

                      try {

                             ne = dc.search(base, filter, sc);

                             // Use the NamingEnumeration object to cycle through

                             // the result set.

                             while (ne.hasMore()) {

                                    Entry entry = new Entry();

                                    SearchResult sr = (SearchResult) ne.next();

                                   String name = sr.getName();

                                   if (base != null && !base.equals("")) {

                                           entry.setDN(name + "," + base);

                                    } else {

                                           entry.setDN(name);

                                    }

                                    Attributes at = sr.getAttributes();

                                    NamingEnumeration ane = at.getAll();

                                    while (ane.hasMore()) {

                                           Attribute attr = (Attribute) ane.next();

                                           String attrType = attr.getID();

                                           NamingEnumeration values = attr.getAll();

                                           Vector vals = new Vector();

                                           // Another NamingEnumeration object, this time

                                           // to iterate through attribute values.

                                           while (values.hasMore()) {

                                                  Object oneVal = values.nextElement();

                                                  if (oneVal instanceof String) {

                                                         vals.addElement((String) oneVal);

                                                  } else {

                                                         vals.addElement(new String((byte[]) oneVal));

                                                  }

                                           }

                                           entry.put(attrType, vals);

                                    }

                                    results.addElement(entry);

                             }

                             // The search() method can throw a number of exceptions.

                             // Here we just handle and print the exception.

                             // In real life we might want to pass the exception along

                             // to a piece of the software that might have a better

                             // context for correcting or presenting the problem.

                      } catch (Exception nex) {

                             System.err.println("Error: " + nex.getMessage());

                             nex.printStackTrace();

                             lc.close();

                      }

                      return results;

               }

上面还是有很多有技术价值的东西，不过因为在163所以很少人光顾，帮他打广告^_^
1、操作系统Windows2000（经测试，在Linux不需操作第6点)
2、Tomcat版本：Apache Tomcat/5.0.16
3、JDK版本：j2sdk1.4.1_03
4、DB2版本：使用db2inst1用户输入db2level命令得到：DB2 v8.1.0.96，修订包为"10"
5、在安装DB2的机器上/opt/IBM/db2/V8.1/java目录下拷贝db2java.zip、db2jcc.jar到$CATALINA_HOME/common/lib下，并重命名db2java.zip为db2java.jar
6、把db2java.jar加classpath
   .;C:\j2sdk1.4.1_03\lib\dt.jar;D:\tomcat5\common\lib\db2jcc.jar;D:\tomcat5\common\lib\db2java.jar;
7、手工配置zjdii.xml，不要在$CATALINA_HOME/conf/server.xml修改任何信息；在$CATALINA_HOME/conf/localhost下修改或新建zjdii.xml

<Context displayName="ZJDII" docBase="zjdii" path="/zjdii">
  <Logger className="org.apache.catalina.logger.FileLogger" prefix="localhost_zjdii_log." suffix=".txt" timestamp="true"/>
  <Resource auth="Container" name="jdbc/zjdii" type="javax.sql.DataSource"/>
  <ResourceParams name="jdbc/zjdii">
    <parameter>
      <name>factory</name>
      <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
    </parameter>
    <parameter>
      <name>url</name>
      <value>jdbc:db2://192.168.200.113:6789/zjdii</value>
    </parameter>
    <parameter>
      <name>password</name>
      <value>yourpasswd</value>
    </parameter>
    <parameter>
      <name>maxWait</name>
      <value>1000</value>
    </parameter>
    <parameter>
      <name>maxActive</name>
      <value>10</value>
    </parameter>
    <parameter>
      <name>driverClassName</name>
      <value>COM.ibm.db2.jdbc.net.DB2Driver</value>
    </parameter>
    <parameter>
      <name>username</name>
      <value>yourusername</value>
    </parameter>
    <parameter>
      <name>maxIdle</name>
      <value>30</value>
    </parameter>
  </ResourceParams>
</Context>

常见错误信息及解决方案：

org.apache.commons.dbcp.SQLNestedException: Cannot load JDBC driver class 'COM.i
bm.db2.jdbc.net.DB2Driver', cause:
java.lang.ClassNotFoundException: COM.ibm.db2.jdbc.net.DB2Driver
        at org.apache.catalina.loader.StandardClassLoader.loadClass(StandardClas
sLoader.java:891)
        at org.apache.catalina.loader.StandardClassLoader.loadClass(StandardClas
sLoader.java:756)
        at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:315)
        at java.lang.Class.forName0(Native Method)
        at java.lang.Class.forName(Class.java:140)
        at org.apache.commons.dbcp.BasicDataSource.createDataSource(BasicDataSou
rce.java:730)
        at org.apache.commons.dbcp.BasicDataSource.getConnection(BasicDataSource
.java:518)
        at com.zjdii.db.DataBase.getConnection(Database.java:44)
        at com.zjdii.db.DBFactory.getPreparedStatement(DBFactory.java:86)
        at org.apache.jsp.test.clob.clob_jsp._jspService(clob_jsp.java:50)
        at org.apache.jasper.runtime.HttpJspBase.service(HttpJspBase.java:133)
        at javax.servlet.http.HttpServlet.service(HttpServlet.java:856)
        at org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper
.java:311)
        at org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:3
01)
        at org.apache.jasper.servlet.JspServlet.service(JspServlet.java:248)
        at javax.servlet.http.HttpServlet.service(HttpServlet.java:856)
        at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(Appl
icationFilterChain.java:284)
        at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationF
ilterChain.java:204)
        at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperV
alve.java:256)
        at org.apache.catalina.core.StandardValveContext.invokeNext(StandardValv
eContext.java:151)
        at org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.jav
a:564)
        at org.apache.catalina.core.StandardContextValve.invokeInternal(Standard
ContextValve.java:245)
        at org.apache.catalina.core.StandardContextValve.invoke(StandardContextV
alve.java:199)
        at org.apache.catalina.core.StandardValveContext.invokeNext(StandardValv
eContext.java:151)
        at org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.jav
a:564)
        at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.j
ava:195)
        at org.apache.catalina.core.StandardValveContext.invokeNext(StandardValv
eContext.java:151)
        at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.j
ava:164)
        at org.apache.catalina.core.StandardValveContext.invokeNext(StandardValv
eContext.java:149)
        at org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.jav
a:564)
        at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineVal
ve.java:156)
        at org.apache.catalina.core.StandardValveContext.invokeNext(StandardValv
eContext.java:151)
        at org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.jav
a:564)
        at org.apache.catalina.core.ContainerBase.invoke(ContainerBase.java:972)

        at org.apache.coyote.tomcat5.CoyoteAdapter.service(CoyoteAdapter.java:21
1)
        at org.apache.coyote.http11.Http11Processor.process(Http11Processor.java
:805)
        at org.apache.coyote.http11.Http11Protocol$Http11ConnectionHandler.proce
ssConnection(Http11Protocol.java:696)
        at org.apache.tomcat.util.net.TcpWorkerThread.runIt(PoolTcpEndpoint.java
:605)
        at org.apache.tomcat.util.threads.ThreadPool$ControlRunnable.run(ThreadP
ool.java:677)
        at java.lang.Thread.run(Thread.java:536)
java.lang.NullPointerException

解决方案：
把D:\tomcat5\webapps\common\lib\db2java.jar;加入classpath里

javax.servlet.ServletException: com/ibm/db2/jcc/SQLJPackage
 org.apache.jasper.runtime.PageContextImpl.doHandlePageException(PageContextImpl.java:867)
 org.apache.jasper.runtime.PageContextImpl.handlePageException(PageContextImpl.java:800)
 org.apache.jsp.test.clob.clob_jsp._jspService(clob_jsp.java:82)
 org.apache.jasper.runtime.HttpJspBase.service(HttpJspBase.java:133)
 javax.servlet.http.HttpServlet.service(HttpServlet.java:856)
 org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:311)
 org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:301)
 org.apache.jasper.servlet.JspServlet.service(JspServlet.java:248)
 javax.servlet.http.HttpServlet.service(HttpServlet.java:856)

root cause

java.lang.NoClassDefFoundError: com/ibm/db2/jcc/SQLJPackage
 COM.ibm.db2.jdbc.net.DB2Connection.prepareStatement(DB2Connection.java:627)
 org.apache.commons.dbcp.DelegatingConnection.prepareStatement(DelegatingConnection.java:216)
 org.apache.commons.dbcp.PoolingDataSource$PoolGuardConnectionWrapper.prepareStatement(PoolingDataSource.java:323)
 com.zjdii.db.DBFactory.getPreparedStatement(DBFactory.java:167)
 org.apache.jsp.test.clob.clob_jsp._jspService(clob_jsp.java:50)
 org.apache.jasper.runtime.HttpJspBase.service(HttpJspBase.java:133)
 javax.servlet.http.HttpServlet.service(HttpServlet.java:856)
 org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:311)
 org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:301)
 org.apache.jasper.servlet.JspServlet.service(JspServlet.java:248)
 javax.servlet.http.HttpServlet.service(HttpServlet.java:856)

note The full stack trace of the root cause is available in the Tomcat logs.

解决方案：
把D:\tomcat5\webapps\common\lib\db2jcc.jar;加入classpath里

common-fileupload是jakarta项目组开发的一个功能很强大的上传文件组件

下面先介绍上传文件到服务器（多文件上传）：

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import java.util.regex.*;
import org.apache.commons.fileupload.*;

public class upload extends HttpServlet {
  private static final String CONTENT_TYPE = "text/html; charset=GB2312";
  //Process the HTTP Post request
  public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    response.setContentType(CONTENT_TYPE);
    PrintWriter out=response.getWriter();
    try {
    DiskFileUpload fu = new DiskFileUpload();
 // 设置允许用户上传文件大小,单位:字节，这里设为2m
 fu.setSizeMax(2*1024*1024);
 // 设置最多只允许在内存中存储的数据,单位:字节
 fu.setSizeThreshold(4096);
 // 设置一旦文件大小超过getSizeThreshold()的值时数据存放在硬盘的目录
 fu.setRepositoryPath("c:\\windows\\temp");
 //开始读取上传信息
 List fileItems = fu.parseRequest(request);
 // 依次处理每个上传的文件
   Iterator iter = fileItems.iterator();

//正则匹配，过滤路径取文件名
   String regExp=".+\\\\(.+)$";

//过滤掉的文件类型
String[] errorType={".exe",".com",".cgi",".asp"};
   Pattern p = Pattern.compile(regExp);
      while (iter.hasNext()) {
       FileItem item = (FileItem)iter.next();
       //忽略其他不是文件域的所有表单信息
       if (!item.isFormField()) {
           String name = item.getName();
           long size = item.getSize();
           if((name==null||name.equals("")) && size==0)
               continue;
        Matcher m = p.matcher(name);
       boolean result = m.find();
       if (result){
           for (int temp=0;temp<errorType.length;temp++){
           if (m.group(1).endsWith(errorType[temp])){
                 throw new IOException(name+": wrong type");
           }
           }
           try{

//保存上传的文件到指定的目录

//在下文中上传文件至数据库时，将对这里改写
             item.write(new File("d:\\" + m.group(1)));

           out.print(name+"&nbsp;&nbsp;"+size+"<br>");
           }
           catch(Exception e){
             out.println(e);
           }

        }
       else
       {
         throw new IOException("fail to upload");
       }
       }
   }
}
 catch (IOException e){
   out.println(e);
 }
 catch (FileUploadException e){
      out.println(e);
 }
 
  }
}

下面是个html的上传页面：

<h1>文件上传演示</h1>

<form name="uploadform" method="POST" action="/upload" ENCTYPE="multipart/form-data">

        <table border="1" width="450" cellpadding="4" cellspacing="2" bordercolor="#9BD7FF">

        <tr><td width="100%" colspan="2">

                        文件1：<input name="x" size="40" type="file">

        </td></tr>

        <tr><td width="100%" colspan="2">

                        文件2：<input name="y" size="40" type="file">

        </td></tr>

        <tr><td width="100%" colspan="2">

                        文件3：<input name="z" size="40" type="file">

        </td></tr>

        </table>

        <br/><br/>

        <table>

        <tr><td align="center"><input name="upload" type="submit" value="开始上传"/></td></tr>

       </table>

</form>

现在介绍上传文件到服务器，下面只写出相关代码：

以sql2000为例，表结构如下：

字段名：name    filecode

类型： varchar     image

数据库插入代码为：PreparedStatement pstmt=conn.prepareStatement("insert into test values(?,?)");

代码如下：

。。。。。。

           try{
             //item.write(new File("d:\\" + m.group(1)));//这段代码如果不去掉，将一同写入到服务器中

             int byteread=0;

             InputStream inStream=item.getInputStream();  //读取输入流，也就是上传的文件内容
             pstmt.setString(1,m.group(1));
             pstmt.setBinaryStream(2,inStream,(int)size);
             pstmt.executeUpdate();
             inStream.close();

             out.println(name+"&nbsp;&nbsp;"+size+"<br>");
           }

。。。。。。

这样就实现了上传文件至数据库

在Web应用开发中，常常会遇到文件的上传下载模块，下载文件时无论IE还是常用的flashget等下载软件都提供了友好的下载进度显示，可以让用户很清晰的了解到下载的进度，特别是在进行大文件传输时，为用户提供了非常舒服的感觉...可以想像，一个几百M或者上G的文件传输过程没有进度显示，是一件多么让人无法忍受的事情。

?然而在如今大多数的服务器上传组件中却没能提供文件上传进度的显示功能或相应开发接口，当进行大文件上传操作或低速网络上传时，长时间的无知状态常常使用户不知所措。

?本文（及附上的相应组件）提供了一套基于Java Web的HTTP文件上传进度显示的解决方案，可以应用于jsp,servlet的web应用开发中，它由apache的commons-fileupload-1.0组件扩展而来，没有改动任何原有组件代码，进度显示部分完全以一种扩展组件形式出现，你可以随时使用或不使用此显示组件，而无需对原有上传应用程序进行大规模的变动。

ahxu-commons-fileuploadex-1.0在apache的commons-fileupload-1.0的基础上扩展了以下功能：

1.增加了文件类型检测功能，可以设定上传文件的类型，不被允许上传的文件将不能上传；
2.增加了对非文件域表单上传的过滤功能，可以选择或不选择上传接收非文件域的表单内容；
3.增加了文件上传进度报告功能，动态报告上传文件的文件名、大小、速度、总时间、剩余时间等，并提供了基于此进度报告功能的一种解决方案；

图1 文件上传进度显示对话框

4.文件上传完毕后将显示上传结果，进度对话框自动关闭。
注：以上过程在win2000+sp4+tomcat5.0.27+IE6.0测试通过，其它环境是否能正常运行，希望大家测试后将信息反馈给我，谢谢！

有用的upload-jsp.rar：

upload-jsp.rar中包含的4个文件：upload.jsp、receive.jsp、progressbar.jsp、progressdetail.jsp

1．upload.jsp——文件上传表单页面；
此页面包含了文件上传的form表单，当然也可以是你的应用中任何你喜欢的有文件上传form表单的页面。此页面在submit时调用javascript函数uploadBegin()弹出进度显示对话框（显示progressbar.jsp）；你也可以根据需要自己定制，例如不用对话框，用iframe等。但form的onSubmit时要调用uploadBegin()，如：

简单应用部署的总结：
1．下载安装apache的commons-fileupload-1.0组件及ahxu-commons-fileuploadex-1.0组件；
2．编辑上传表单文件，注意要复制upload.jsp的uploadBegin()，以及form表单的onsubmit="uploadBegin();"
3．复制progressbar.jsp、progressdetail.jsp无需修改；
4．根据需要编辑receive.jsp页的内容。

目的:

     本文描述了Sun公司的HotSpot Java虚拟机的垃圾收集工作原理。以便为更多Java爱好者在设计，开发以及部署时带来更多便利和益处。

摘要：

         JVM规范中要求任何实现JVM的实现必须要提供一个能够回收未被使用内存的机制。这个机制就是垃圾回收（GC－Garbage Collection）。然而垃圾回收机制设计的好坏将直接影响依赖其运行的java应用的性能（包括处理能力，响应时间等）。在接下来的章节中将详细介绍SUN公司的Java虚拟机（其正式名称是Sun HotSopt JVM）中的垃圾回收机制。

分代垃圾回收

       HotSpot JVM使用分代垃圾回收的方式。这种垃圾回收方式并不是HotSpot JVM的首创，而是人们在实践中发现存在下面的两条规律并在很早的时候就提出来了。即:

1）大多数对象在创建后很短的时间内就会没有任何对象再使用它了，即未被其它对象引用。

2）大多数一直被使用的对象（老对象）很少引用新创建的对象。

对于Java应用来说这两条规律始终是存在的，也有人根据这些规律称其为“弱分代”。因为将java对象分为“年轻”对象和“老”对象时并没有一个非常明确的指标而是由JVM规范的实现者控制的（当然JVM也可以提供参数让具体的开发者设定）。在HotSpot JVM中将分配到的内存堆（Heap）分为两个物理区域，一个是“年轻”区，另一个是“老”区。在这里我将“年轻”的一代叫做“新生代”，而对应的将“老”的一代对象叫做“老生代”。

l        新生代：绝大多数新创建的对象存放于此，这个区域一般来说比较小而且垃圾收集的频率也比较高。因为许多对象在创建后很快就会“死”去，在每次的“新生代”垃圾收集后能够“幸存”的对象非常的少。使用在“新生代”的这种垃圾收集叫做次要垃圾收集（Minor Collection）。正是因为“新生代”的大小（较小，寻址时间很短）和其存放的对象的特点（寿命短，所以有很多垃圾，每次收集都能释放较大的内存空间）使得次要垃圾收集的效率非常高。见图1。

图1：分代垃圾回收

l        老生代：在“新生代”中生存了较长时间的对象将被提升为“老”对象并转移到“老生代”区。这个区域一般要大一些而且增长的速度相对于“新生代”要慢一些，所以负责“老生代”垃圾收集的主垃圾收集（Major Collection）的执行频率与次要垃圾收集比要低很多。主垃圾收集发生在“老生代”中的对象占用的存储空间达到一定的量值的时候。见图1。

*为方便起见，在下面的章节中将用次收集来替代“次要垃圾收集”，用主收集替代“主要垃圾收集”。

为了使次收集的收集时间尽可能的短，HotSpot JVM使用了一种叫做卡表（Card Table）的机制见图2，来避免在每次进行次收集的时候遍历整个“老生代”。

图2：HotSpot中的卡表

         卡表的机制是将“老生代”以512字节为单位进行划分，划分得到的每个区域叫做一个卡。每个卡在卡表中有占用一个一个字节的标识。java代码在执行的过程中JVM一旦发现“老生代”的对象引用了或者释放了“新生代”中的对象，那么JVM就要将与之对应的卡表中的状态置为相应的值。这样在次收集的时候只遍历被标记为“脏”的卡，以便知道哪些“新生代”的对象被引用中，是不可以进行回收的。

         分代进行垃圾收集的好处是可以根据每个代的具体特点为其设定不同的垃圾收集算法。在新生代中往往使用速度较快的垃圾收集算法，因为次要收集的频率比较高。这种算法在内存的使用效率上没有优势，好在“新生代”的空间占整个JVM内存堆比例较小，尚不能对性能构成大的问题。而内存使用效率高的算法往往用在“老生代”的垃圾收集上。因为“老生代”占据着JVM堆的很大部分。虽然“老生代”中进行的主收集每次的收集时间相对于次收集要长好多，但是主收集在频率上要比次收集少很多，故对性能的影响也不大。正是这种新、“老生代”的相互补很好的平衡JVM垃圾收集中的瓶颈。

新生代的组成

         “新生代”又3个部分组成，见图3。一个Eden和两个生存区（Survivor Space），

图3：新生代组成

其中：

l        Eden：绝大部分新创建的对象存放在此区域。为什么说绝大多数而不是所有的呢？原因是应用在创建一个非常大的对象的时候JVM会直接将其分配在老生代而非新生代。在每次完成次收集的时候Eden区域总是空的。

l        存活区：顾名思义在垃圾收集过程中没有被当作垃圾收集的对象将放在次区域中。也就是说这个区域中的对象至少经历了一次次收集。存放存活区的对象在被“提升”到老生代前还有机会被收集。存活区有一对，他们中的一个始终保持为空，另一个用于存放存活下来的对象。

  图4描述了次收集的收集过程，其中绿色部分是未被使用的对象

图4：一次次收集

（即垃圾）。从图中可以看到在Eden区的绿色部分将被收集而幸存下来的对象（白色部分）将被移到没有被使用的存活区2。在存活区1中的绿色部分是也是不被使用的对象，这些对象也将被收集。而位于存活区1中的蓝色部分是尚被引用但是还不够“老”的这些对象也将移到到存活区2。存活区1中剩余的部分就是被引用且已经够“老”的对象，他们将被移到老生代区。

         在完成了一次次收集后（见图5），两个存活区就会交互角色。即存活区2中将存放存活对象，存活区1将不被使用。Eden区将会变的空空如也。同时由于有新对象移到了老生代，老生代的空间将被更多的对象占据。

图5：完成一次次收集后

垃圾收集器

         Sun 的HotSpot JVM提供了3中不同的垃圾收集器。他们可以根据应用的实际情况有选择性的使用。下面将分别介绍。

串行收集器：又叫做“标记-压缩”收集器。这种收集器在收集的时候要求JVM停止执行应用。所以人们戏称这种收集模式为Stop-the-World(停止一切)模式。在完成收集后JVM才继续执行应用（见图6）。

图6：串行收集

串行收集器首先将“老生代”中的仍然存活的对象进行标记并将这些对象压缩到“老生代”空间的前端。这样“老生代”的后端将变成一个连续的空间，以便从“新生代”中足够老的对象顺利的“提升”到“老生代”中（见图7，红色部分为垃圾对象）。对于大多数不要求有非常迅速响应（例如几秒钟）的场合，例如客户端程序，这种收集器还是能够胜任的。

图7：“老生代”的一次压缩

并行收集器：在目前实际的应用中多数的java程序都运行在具有很大物理内存和多个CPU的服务器上。在比较理想的情况下垃圾收集应该能够有效利用所有的CPU，而不是只用其中的一个且其他的CPU都处于空闲状态。为避免过多的垃圾收集以便提高系统的吞吐量（即处理能力），在服务器模式的环境下Sun的HotSopt JVM使用并行收集器进行垃圾回收。因为这种垃圾回收器的一个主要目标是提高吞吐量，所以也叫做吞吐量型的收集器。并行收集器的工作方式是在次收集（对应于“新生代”）中使用所有的CPU进行并行收集，在主收集（对应于“老生代”）中采用串行收集器（见图8）。虽然与串行收集器相比较主收集没有显著的改善（因为两者在“老生代”中都使用了相同的串行收集器），但是在次收集部分的效率得以大幅度的提高。进而提高的系统的吞吐量。

图8：并行收集

同步收集器（Mostly-Concurrent Collector）：对于某些的应用程序来说响应速度要远比吞吐量重要。同时收集器就是为低延时而设计的一种收集器。在已经介绍的Stop-the-World（停止一切）的收集模式中，当垃圾收集没有结束前对于外部的请求是不会进行响应的，直到收集完毕应用才会继续响应请求。这对于次搜集来说一般来说停顿时间不是很长（因为次收集往往需要很短的时间），但对于主收集来说，即使不是很频繁也会导致应用较长时间的停顿，尤其是在JVM堆分配的比较大的时候就更明显了。为了解决这种情况Sun JVM引入了同步收集器的方式。这种方式也叫做同步标记－清楚（CMS）或者还可以叫做“低延迟”收集器。图9展示了其工作原理。

图9：同步收集器

同步收集器以一个短暂的停顿开始，在这个短暂的停顿中将对那些能够迅速确定不是垃圾的对象进行标记。紧接着将进入同步标记阶段，在这个阶段中同步收集器对被使用的对象进一步进行标记，而应用也同时运行。应用在运行的过程中可能改变了对某些对象的引用，这使得同步标记阶段中并不能保证所有的被引用对象进行了标记，也导致了必须需要进行的第三个阶段－“再标记”。在再标记阶段中将会使应用进入第二个暂停，利用这个暂停时间同步收集器将完成对所有对象的标记。可以看出在再标记的过程中使用了并行的方式，所以这部分标记的对象的数量要比在初始阶段中标记完成的多。在最后一个阶段同步收集器将会把前几个阶段中标记出来的“老生代”中的垃圾对象进行清除。但是不会将被引用的对象放在一个连续的空间中（见图10，橙色为垃圾对象，绿色为收集后的空闲空间）。可以看出“老生代”中的可用空间并不是连续的，这个会导致将为提升到“老生代”的对象分配空间时需要工多的时间和资源。

图10：“老生代”中的同步清除

与串行收集器和并行收集器相比较同步收集器会有下面几个特点。

1)要求分配到的堆大；

2）对不连续空间的使用效率低；

3）在某些情况下能够显著缩短主收集使应用停顿的时间。

附录A：参考文献

JVM Specification第二版

http://java.sun.com/docs/books/vmspec/2nd-edition/html/VMSpecTOC.doc.html

Written by Halatu Hubisi

引言
有JAVA开发经验的朋友们一定碰到过下面的这种情况,那就是自己所开发的应用运行了一段时间后其性能或者响应速度会有明显的降低.这是由多方面的原因造成的即有程序本身的优化问题,也有运行环境问题.此运行环境即包括硬件环境也包括软件环境.大多数人第一个能想到的解决方法是提升硬件的配置而忽略了程序本身的运行环境JVM也提供了比较多的调优选项.本文将重点描述利用JVM的一些选项对GC进行调优.

约定:
1.读者应具备一定JAVA的知识.

2.本文中的JVM选项均以SUN公司发布的HotSpot JVM 5为准（不过大多数的选项在JVM1.3,JVM1.4中也是可用的）.

3.以JAVA_HOME下demo/jfc/SwingSet2/SwingSet2.jar为例进行说明.

4.阅读本文需要一些关于GC的知识，可以到附录A中了解这些知识。

关键字:
JVM(java虚拟机),调优,GC(垃圾回收)

JVM GC调优
为了能够将JVM GC的调优能够使用在具体的实践当中,下面将利用若干个例子来说明GC的调优.
例1：Heap size 设置
JVM堆的设置是指java程序运行过程中JVM可以调配使用的内存空间的设置.JVM在启动的时候会自动设置Heap size的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)是物理内存的1/4。可以利用JVM提供的-Xmn -Xms -Xmx等选项可进行设置。Heap size 的大小是Young Generation 和Tenured Generaion 之和。
当在JAVA_HOME下demo/jfc/SwingSet2/目录下执行下面的命令。
java -jar -Xmn4m -Xms16m -Xmx16m SwingSet2.jar
系统输出为：
Exception in thread "Image Fetcher 0" java.lang.OutOfMemoryError: Java heap space
Exception in thread "Image Fetcher 3" java.lang.OutOfMemoryError: Java heap space
Exception in thread "Image Fetcher 1" java.lang.OutOfMemoryError: Java heap space
Exception in thread "Image Fetcher 2" java.lang.OutOfMemoryError: Java heap space
除了这些异常信息外，还会发现程序的响应速度变慢了。这说明Heap size 设置偏小，GC占用了更多的时间，而应用分配到的执行时间较少。
提示：在JVM中如果98％的时间是用于GC且可用的Heap size 不足2％的时候将抛出此异常信息。
将上面的命令换成以下命令执行则应用能够正常使用，且未抛出任何异常。
java -jar -Xmn4m -Xms16m -Xmx32m SwingSet2.jar
提示：Heap Size 最大不要超过可用物理内存的80％，一般的要将-Xms和-Xmx选项设置为相同，而-Xmn为1/4的-Xmx值。

例2：Young Generation（-Xmn）的设置
在本例中看一下Young Generation的设置不同将有什么现象发生。
假设将Young generation 的大小设置为4M ，即执行java -jar -verbose:gc -Xmn4m -Xms32m -Xmx32m -XX:+PrintGCDetails SwingSet2.jar，屏幕输出如下（节选）
[GC [DefNew: 3968K->64K(4032K), 0.0923407 secs] 3968K->2025K(32704K), 0.0931870 secs]
[GC [DefNew: 4021K->64K(4032K), 0.0356847 secs] 5983K->2347K(32704K), 0.0365441 secs]
[GC [DefNew: 3995K->39K(4032K), 0.0090603 secs] 6279K->2372K(32704K), 0.0093377 secs]
[GC [DefNew: 3992K->23K(4032K), 0.0057540 secs] 6325K->2356K(32704K), 0.0060290 secs]
[GC [DefNew: 3984K->27K(4032K), 0.0013058 secs] 6317K->2360K(32704K), 0.0015888 secs]
[GC [DefNew: 3981K->59K(4032K), 0.0023307 secs] 6315K->2422K(32704K), 0.0026091 secs]
将程序体制并将Young Generation的大小设置为8M，即执行java -jar -verbose:gc -Xmn8m -Xms32m -Xmx32m -XX:+PrintGCDetails SwingSet2.jar，屏幕输出如下（节选）
[GC [DefNew: 7808K->192K(8000K), 0.1016784 secs] 7808K->2357K(32576K), 0.1022834 secs]
[GC [DefNew: 8000K->70K(8000K), 0.0149659 secs] 10165K->2413K(32576K), 0.0152557 secs]
[GC [DefNew: 7853K->59K(8000K), 0.0069122 secs] 10196K->2403K(32576K), 0.0071843 secs]
[GC [DefNew: 7867K->171K(8000K), 0.0075745 secs] 10211K->2681K(32576K), 0.0078376 secs]
[GC [DefNew: 7970K->192K(8000K), 0.0201353 secs] 10480K->2923K(32576K), 0.0206867 secs]
[GC [DefNew: 7979K->30K(8000K), 0.1787079 secs] 10735K->4824K(32576K), 0.1790065 secs]
那么根据GC输出的信息（这里取第一行）做一下Minor收集的比较。可以看出两次的Minor收集分别在Young generation中找回3904K（3968K->64K）和7616K(7808K->192K)而对于整个jvm则找回1943K（3968K->2025）和5451K（7808K->2357K）。第一种情况下Minor收集了大约50％（1943/3904）的对象，而另外的50％的对象则被移到了tenured generation。在第二中情况下Minor收集了大约72％的对象，只有不到30％的对象被移到了Tenured Generation.这个例子说明此应用在的Young generation 设置为4m时显的偏小。
提示：一般的Young Generation的大小是整个Heap size的1/4。Young generation的minor收集率应一般在70％以上。当然在实际的应用中需要根据具体情况进行调整。

例3：Young Generation对应用响应的影响
还是使用-Xmn4m 和-Xmn8m进行比较，先执行下面的命令

java -jar -verbose:gc -Xmn4m -Xms32m -Xmx32m -XX:+PrintGCDetails -XX:+PrintGCApplicationConcurrentTime -XX:+PrintGCApplicationStoppedTime SwingSet2.jar
屏幕输出如下（节选）
Application time: 0.5114944 seconds
[GC [DefNew: 3968K->64K(4032K), 0.0823952 secs] 3968K->2023K(32704K), 0.0827626 secs]
Total time for which application threads were stopped: 0.0839428 seconds
Application time: 0.9871271 seconds
[GC [DefNew: 4020K->64K(4032K), 0.0412448 secs] 5979K->2374K(32704K), 0.0415248 secs]
Total time for which application threads were stopped: 0.0464380 seconds
Young Generation 的Minor收集占用的时间可以计算如下：应用线程被中断的总时常/（应用执行总时?L+应用线程被中断的总时常），那么在本例中垃圾收集占用的时?L约为系统的5％~14％。那么当垃圾收集占用的时间的比例越大的时候，系统的响应将越慢。
提示：对于互联网应用系统的响应稍微慢一些，用户是可以接受的，但是对于GUI类型的应用响应速度慢将会给用户带来非常不好的体验。

例4：如何决定Tenured Generation 的大小
分别以-Xmn8m -Xmx32m和-Xmn8m -Xmx64m进行对比，先执行
java -verbose:gc -Xmn8m -Xmx32m-XX:+PririntGCDetails -XX:+PrintGCTimeStamps java类，命令行将提示（只提取了Major收集）

111.042: [GC 111.042: [DefNew: 8128K->8128K(8128K), 0.0000505 secs]111.042: [Tenured: 18154K->2311K(24576K), 0.1290354 secs] 26282K->2311K(32704K), 0.1293306 secs]
122.463: [GC 122.463: [DefNew: 8128K->8128K(8128K), 0.0000560 secs]122.463: [Tenured: 18630K->2366K(24576K), 0.1322560 secs] 26758K->2366K(32704K), 0.1325284 secs]
133.896: [GC 133.897: [DefNew: 8128K->8128K(8128K), 0.0000443 secs]133.897: [Tenured: 18240K->2573K(24576K), 0.1340199 secs] 26368K->2573K(32704K), 0.1343218 secs]
144.112: [GC 144.112: [DefNew: 8128K->8128K(8128K), 0.0000544 secs]144.112: [Tenured: 16564K->2304K(24576K), 0.1246831 secs] 24692K->2304K(32704K), 0.1249602 secs]
再执行java -verbose:gc -Xmn8m -Xmx64m-XX:+PririntGCDetails -XX:+PrintGCTimeStamps java类，命令行将提示（只提取了Major收集）
90.597: [GC 90.597: [DefNew: 8128K->8128K(8128K), 0.0000542 secs]90.597: [Tenured: 49841K->5141K(57344K), 0.2129882 secs] 57969K->5141K(65472K), 0.2133274 secs]
120.899: [GC 120.899: [DefNew: 8128K->8128K(8128K), 0.0000550 secs]120.899: [Tenured: 50384K->2430K(57344K), 0.2216590 secs] 58512K->2430K(65472K), 0.2219384 secs]
153.968: [GC 153.968: [DefNew: 8128K->8128K(8128K), 0.0000511 secs]153.968: [Tenured: 51164K->2309K(57344K), 0.2193906 secs] 59292K->2309K(65472K), 0.2196372 secs]
可以看出在Heap size 为32m的时候系统等候时间约为0.13秒左右，而设置为64m的时候等候时间则增大到0.22秒左右了。但是在32m的时候系统的Major收集间隔为10秒左右，而Heap size 增加到64m的时候为30秒。那么应用在运行的时候是选择32m还是64m呢？如果应用是web类型（即要求有大的吞吐量）的应用则使用64m（即heapsize大一些）的比较好。对于要求实时响应要求较高的场合（例如GUI型的应用）则使用32m比较好一些。
注意：
1。因为在JVM5运行时已经对Heap-size进行了优化，所以在能确定java应用运行时不会超过默认的Heap size的情况下建议不要对这些值进行修改。
2。Heap size的 -Xms -Xmn 设置不要超出物理内存的大小。否则会提示“Error occurred during initialization of VM Could not reserve enough space for object heap”。

例5:如何缩短minor收集的时间
下面比较一下采用-XX:+UseParNewGC选项和不采用它的时候的minor收集将有什么不同。先执行
java -jar -server -verbose:gc -Xmn8m -Xms32m -Xmx32m SwingSet2.jar
系统将输出如下信息（片段〕
[GC 7807K->2641K(32576K), 0.0676654 secs]
[GC 10436K->3108K(32576K), 0.0245328 secs]
[GC 10913K->3176K(32576K), 0.0072865 secs]
[GC 10905K->4097K(32576K), 0.0223928 secs]
之后再执行 java -jar -server -verbose:gc -XX:+UseParNewGC -Xmn8m -Xms32m -Xmx32m SwingSet2.jar
系统将输出如下信息（片段〕
[ParNew 7808K->2656K(32576K), 0.0447687 secs]
[ParNew 10441K->3143K(32576K), 0.0179422 secs]
[ParNew 10951K->3177K(32576K), 0.0031914 secs]
[ParNew 10985K->3867K(32576K), 0.0154991 secs]
很显然使用了-XX:+UseParNewGC选项的minor收集的时间要比不使用的时候优。

例6:如何缩短major收集的时间
下面比较一下采用-XX:+UseConcMarkSweepGC选项和不采用它的时候的major收集将有什么不同。先执行
java -jar -verbose:gc -XX:+UseConcMarkSweepGC -XX:+UseParNewGC -Xmn64m -Xms256m -Xmx256m SwingSet2.jar
系统将输出如下信息（片段〕
[Full GC 22972K->18690K(262080K), 0.2326676 secs]
[Full GC 18690K->18690K(262080K), 0.1701866 secs
之后再执行 java -jar -verbose:gc -XX:+UseParNewGC -Xmn64m -Xms256m -Xmx256m SwingSet2.jar
系统将输出如下信息（片段〕
[Full GC 56048K->18869K(260224K), 0.3104852 secs]
提示：此选项在Heap Size 比较大而且Major收集时间较长的情况下使用更合适。

例7:关于-server选项 在JVM中将运行中的类认定为server-class的时候使用此选项。SUN 的Hot Spot JVM5 如果判断到系统的配置满足如下条件则自动将运行的类认定为server-class，并且会自动设置jvm的选项（当没有手工设置这选项的时候〕而且HOTSPOT JVM5提供了自动调优的功能，他会根据JVM的运行情况进行调整。如果没有特别的需要是不需要太多的人工干预的。SUN形象的称这个机制为“人体工学”（Ergonomics〕。具体可以参考http://java.sun.com/docs/hotspot/gc5.0/ergo5.html
*.具有2个或更多个物理的处理器
*.具有2G或者更多的物理内存
提示：此选项要放在所有选项的前面。例如：java -server 其他选项 java类

附录A:预备知识
．JVM中对象的划分及管理

JVM根据运行于其中的对象的生存时间大致的分为3种。并且将这3种不同的对象分别存放在JVM从系统分配到的不同的内存空间。这种对象存放空间的管理方式叫做Generation管理方式。
1。Young Generation：用于存放“早逝”对象（即瞬时对象）。例如：在创建对象时或者调用方法时使用的临时对象或局部变量。
2。Tenured Generation：用于存放“驻留”对象（即较长时间被引用的对象）。往往体现为一个大型程序中的全局对象或长时间被使用的对象。
3。Perm Generation：用于存放“永久”对象。这些对象管理着运行于JVM中的类和方法。

．JVM选项的分类

JVM有这么几种选项供使用.
1.供-X选项使用的项目,又称为非标准选项，不同厂商的此类型选项是有所不同的。例如：IBM的JVM用的一些选项在Sun的JVM中就不一定能生效。这种选项的使用方式如下:
java -Xmn16m -Xms64m -Xmx64m java类名
2.供-XX选项使用的项目，这种类型的选项可能要求有对系统信息访问的权限。所以要慎用。这种选项的使用方式如下:
java -XX:MaxHeapFreeRatio=70 -XX:+PrintGCDetails java类名
3.java选项(即在命令行执行java后提示的选项).
java -server -verbose:gc -d64 java类名

．垃圾收集分类

在JVM中有两种垃圾方式，一种叫做Minor（次收集），另一种叫做Major（主收集）。其中Minor在Young Generation的空间被对象全部占用后执行，主要是对Young Generation中的对象进行垃圾收集。而Major是针对于整个Heap size的垃圾收集。其中Minor方式的收集经常发生，并且Minor收集所占用的系统时间小。Major方式的垃圾收集则是一种“昂贵”的垃圾收集方式，因为在Major要对整个Heap size进行垃圾收集,这会使得应用停顿的时间变得较长。

．GC信息的格式

[GC [<collector>: <starting occupancy1> -> <ending occupancy1>, <pause time1> secs] <starting occupancy3> -> <ending occupancy3>, <pause time3> secs]
<collector> GC为minor收集过程中使用的垃圾收集器起的内部名称.
<starting occupancy1> young generation 在进行垃圾收集前被对象使用的存储空间.
<ending occupancy1> young generation 在进行垃圾收集后被对象使用的存储空间
<pause time1> minor收集使应用暂停的时间长短(秒)
<starting occupancy3> 整个堆(Heap Size)在进行垃圾收集前被对象使用的存储空间
<ending occupancy3> 整个堆(Heap Size)在进行垃圾收集后被对象使用的存储空间
<pause time3> 整个垃圾收集使应用暂停的时间长短(秒),包括major收集使应用暂停的时间(如果发生了major收集).
．GC信息的选项
-XX:+PrintGCDetails 显示GC的详细信息
-XX:+PrintGCApplicationConcurrentTime 打印应用执行的时间
-XX:+PrintGCApplicationStoppedTime 打印应用被暂停的时间
提示:1.":"后的"+"号表示开启此选项,如果是"-"号那么表示关闭此选项。
     2.在不同的选项和不同的收集方式和类型下输出的格式会有所不同。

附录B：HotSpot JVM 选项
请参考JavaTM HotSpot VM Options

附录C：其他资源
http://java.sun.com/docs/hotspot/gc5.0/gc_tuning_5.html
http://java.sun.com/docs/hotspot/gc5.0/ergo5.html

Properties props = new Properties();
// fill props with any information
Session session = Session.getDefaultInstance(props, null);

Properties props = new Properties();
// fill props with any information
Session session = Session.getInstance(props, null);

MimeMessage message = new MimeMessage(session);

message.setContent("Hello", "text/plain");

message.setText("Hello");

message.setSubject("First");

Address address = new InternetAddress("president@whitehouse.gov"); 

Address address = new InternetAddress("president@whitehouse.gov", "George Bush"); 

message.setFrom(address);
message.setReplyTo(address);

Address address[] = ...;
message.addFrom(address);

message.addRecipient(type, address)

Address toAddress = new InternetAddress("vice.president@whitehouse.gov");
Address ccAddress = new InternetAddress("first.lady@whitehouse.gov");
message.addRecipient(Message.RecipientType.TO, toAddress);
message.addRecipient(Message.RecipientType.CC, ccAddress);

Properties props = new Properties();
// fill props with any information
Authenticator auth = new MyAuthenticator();
Session session = Session.getDefaultInstance(props, auth);

Transport.send(message);

message.saveChanges(); // implicit with send()
Transport transport = session.getTransport("smtp");
transport.connect(host, username, password);
transport.sendMessage(message, message.getAllRecipients());
transport.close();

session.setDebug(true)。

// Store store = session.getStore("imap");
Store store = session.getStore("pop3");
store.connect(host, username, password);

Folder folder = store.getFolder("INBOX");
folder.open(Folder.READ_ONLY);
Message message[] = folder.getMessages();

System.out.println(((MimeMessage)message).getContent());

folder.close(aBoolean);
store.close();

String host = ...;
String from = ...;
String to = ...;

// Get system properties
Properties props = System.getProperties();

// Setup mail server
props.put("mail.smtp.host", host);

// Get session
Session session = Session.getDefaultInstance(props, null);

// Define message
MimeMessage message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, 
  new InternetAddress(to));
message.setSubject("Hello JavaMail");
message.setText("Welcome to JavaMail");
// Send message
Transport.send(message);

String host = ...;
String username = ...;
String password = ...;

// Create empty properties
Properties props = new Properties();

// Get session
Session session = Session.getDefaultInstance(props, null);

// Get the store
Store store = session.getStore("pop3");
store.connect(host, username, password);

// Get folder
Folder folder = store.getFolder("INBOX");
folder.open(Folder.READ_ONLY);

// Get directory
Message message[] = folder.getMessages();

for (int i=0, n=message.length; i<n; i++) {
   System.out.println(i + ": " + message[i].getFrom()[0] 
     + "\t" + message[i].getSubject());
}

// Close connection 
folder.close(false);
store.close();

BufferedReader reader = new BufferedReader (
  new InputStreamReader(System.in));

// Get directory
Message message[] = folder.getMessages();
for (int i=0, n=message.length; i<n; i++) {
  System.out.println(i + ": " + message[i].getFrom()[0] 
    + "\t" + message[i].getSubject());

  System.out.println("Do you want to read message? " +
    "[YES to read/QUIT to end]");
  String line = reader.readLine();
  if ("YES".equals(line)) {
    message[i].writeTo(System.out);
  } else if ("QUIT".equals(line)) {
    break;
  }
}

message.setFlag(Flags.Flag.DELETED, true);

folder.open(Folder.READ_WRITE);

folder.close(true);

// Setup properties
Properties props = System.getProperties();
props.put("mail.pop3.host", host);

// Setup authentication, get session
Authenticator auth = new PopupAuthenticator();
Session session = Session.getDefaultInstance(props, auth);

// Get the store
Store store = session.getStore("pop3");
store.connect();

import javax.mail.*;
import java.util.*;

public class PopupAuthenticator extends Authenticator {

  public PasswordAuthentication getPasswordAuthentication(String param) {
    String username, password;

    StringTokenizer st = new StringTokenizer(param, ",");
    username = st.nextToken();
    password = st.nextToken();

    return new PasswordAuthentication(username, password);
  }

}

MimeMessage reply = (MimeMessage)message.reply(false);
reply.setFrom(new InternetAddress("president@whitehouse.gov"));
reply.setText("Thanks");
Transport.send(reply);

// Create the message to forward
Message forward = new MimeMessage(session);

// Fill in header
forward.setSubject("Fwd: " + message.getSubject());
forward.setFrom(new InternetAddress(from));
forward.addRecipient(Message.RecipientType.TO, 
  new InternetAddress(to));

// Create your new message part
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText(
  "Here you go with the original message:\n\n");

// Create a multi-part to combine the parts
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);

// Create and fill part for the forwarded content
messageBodyPart = new MimeBodyPart();
messageBodyPart.setDataHandler(message.getDataHandler());

// Add part to multi part
multipart.addBodyPart(messageBodyPart);

// Associate multi-part with message
forward.setContent(multipart);

// Send message
Transport.send(forward);

// Define message
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, 
  new InternetAddress(to));
message.setSubject("Hello JavaMail Attachment");

// Create the message part 
BodyPart messageBodyPart = new MimeBodyPart();

// Fill the message
messageBodyPart.setText("Pardon Ideas");

Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);

// Part two is attachment
messageBodyPart = new MimeBodyPart();
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
multipart.addBodyPart(messageBodyPart);

// Put parts in message
message.setContent(multipart);

// Send the message
Transport.send(message);

<FORM ENCTYPE="multipart/form-data" 
    method=post action="/myservlet"> 
  <INPUT TYPE="file" NAME="thefile">
  <INPUT TYPE="submit" VALUE="Upload">
</FORM>

Multipart mp = (Multipart)message.getContent();

for (int i=0, n=multipart.getCount(); i<n; i++) {
  Part part = multipart.getBodyPart(i));

  String disposition = part.getDisposition();

  if ((disposition != null) && 
      ((disposition.equals(Part.ATTACHMENT) || 
       (disposition.equals(Part.INLINE))) {
    saveFile(part.getFileName(), part.getInputStream());
  }
}

// from saveFile()
File file = new File(filename);
for (int i=0; file.exists(); i++) {
  file = new File(filename+i);
}

if (disposition == null) {
  // Check if plain
  MimeBodyPart mbp = (MimeBodyPart)part;
  if (mbp.isMimeType("text/plain")) {
    // Handle plain
  } else {
    // Special non-attachment cases here of 
    // image/gif, text/html, ...
  }
...
}

String htmlText = "<H1>Hello</H1>" + 
  "<img src=\"http://www.jguru.com/images/logo.gif\">";
message.setContent(htmlText, "text/html"));

if (message.getContentType().equals("text/html")) {
  String content = (String)message.getContent();
  JFrame frame = new JFrame();
  JEditorPane text = new JEditorPane("text/html", content);
  text.setEditable(false);
  JScrollPane pane = new JScrollPane(text);
  frame.getContentPane().add(pane);
  frame.setSize(300, 300);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.show();
}

String file = ...;

// Create the message
Message message = new MimeMessage(session);

// Fill its headers
message.setSubject("Embedded Image");
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, 
  new InternetAddress(to));

// Create your new message part
BodyPart messageBodyPart = new MimeBodyPart();
String htmlText = "<H1>Hello</H1>" + 
  "<img src=\"cid:memememe\">";
messageBodyPart.setContent(htmlText, "text/html");

// Create a related multi-part to combine the parts
MimeMultipart multipart = new MimeMultipart("related");
multipart.addBodyPart(messageBodyPart);

// Create part for the image
messageBodyPart = new MimeBodyPart();

// Fetch the image and associate to part
DataSource fds = new FileDataSource(file);
messageBodyPart.setDataHandler(new DataHandler(fds));
messageBodyPart.setHeader("Content-ID","<memememe>");

// Add part to multi-part
multipart.addBodyPart(messageBodyPart);

// Associate multi-part with message
message.setContent(multipart);

SearchTerm st = ...;
Message[] msgs = folder.search(st);

SearchTerm st = 
  new OrTerm(
    new SubjectTerm("ADV:"), 
    new FromStringTerm("friend@public.com"));
Message[] msgs = folder.search(st);

import lotus.domino.AgentBase;
import lotus.domino.NotesException;
import lotus.domino.NotesFactory;
import lotus.domino.Session;

public abstract class EclipseAgentBase extends AgentBase {

public abstract void sendMail(String text);

public Session getSession() {
try {
return NotesFactory.createSession();
} catch (NotesException e) {
throw new RuntimeException("Unable to create session", e);
}
}
}

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import lotus.domino.NotesThread;
import lotus.domino.Session;
import lotus.domino.*; 

public class MyAgent extends EclipseAgentBase {

private String sendname;
private String servername;
private String filepatch;
public MyAgent(){
    try {
        InputStream in = this.getClass().getResourceAsStream("/MailSystem.properties");
        Properties props = new Properties();
         props.load(in);
         this.sendname=props.getProperty("sendname");
         this.servername=props.getProperty("servername");
         this.filepatch=props.getProperty("filepatch");
         //System.out.println(sendname);
         //System.out.println(servername);
         //System.out.println(filepatch);
    } catch (IOException e) {
        
        e.printStackTrace();
    }
    
}
public void sendMail(String text) {
try {
    Session session = this.getSession();
    System.out.println("Username: " + session.getUserName());
    Database   db=session.getDatabase(servername,filepatch,true);
    Document   domMail=db.createDocument();   
    domMail.appendItemValue("Form","Memo");   
    RichTextItem   body=domMail.createRichTextItem("body"); 

    body.appendText(text);   

    domMail.send(sendname);   
    System.out.println("done");   
    } catch (Exception e) {
        e.printStackTrace();
        }
    }


}

MailSystem.properties

sendname=jiangmin.java@gmail.com
servername=Dominosrv/MVS
filepatch=mail/jiangmin.nsf

这两个类就是完整的代码,调用sendMail()就可以发送邮件了,光有代码是不能发送的,现在我们来说说环境的搭建,首先要安装Lotus Notes客护端(我这个程序不是运行在本地的,也就是说它不和Lotus Notes服务器在一起的,我们需要远程访问),然后我们需要两个JAR包Notes.jar和NCSO.jar,把D:\lotus\notes加到patch路径下(也就是Notes的根目录),最后就是配置Notes客户端了,配置好了,一切OK```如果你关掉Notes客户端,那么该程序需要你输入密码,要想不用输入密码那么你就得一直看着客户端了(没办法).