一、 导出/导入(Export/Import)

　　利用Export可将数据从数据库中提取出来，利用Import则可将提取出来的数据送回到Oracle数据库中去。

　　1、 简单导出数据(Export)和导入数据(Import)

　　Oracle支持三种方式类型的输出:

　　(1)、表方式(T方式)，将指定表的数据导出。

　　(2)、用户方式(U方式)，将指定用户的所有对象及数据导出。

　　(3)、全库方式(Full方式)，瘵数据库中的所有对象导出。

　　数据导入(Import)的过程是数据导出(Export)的逆过程，分别将数据文件导入数据库和将数据库数据导出到数据文件。

　　2、 增量导出/导入

　　增量导出是一种常用的数据备份方法，它只能对整个数据库来实施，并且必须作为SYSTEM来导出。在进行此种导出时，系统不要求回答任何问题。导出文件名缺省为export.dmp，如果不希望自己的输出文件定名为export.dmp，必须在命令行中指出要用的文件名。

　　增量导出包括三种类型:

　　(1)、“完全”增量导出(Complete)

　　即备份三个数据库，比如:

　　(2)、“增量型”增量导出

　　备份上一次备份后改变的数据，比如:

　　(3)、“累积型”增量导出

　　累计型导出方式是导出自上次“完全”导出之后数据库中变化了的信息。比如:

　　数据库管理员可以排定一个备份日程表，用数据导出的三个不同方式合理高效的完成。

　　比如数据库的被封任务可以做如下安排:

　　星期一:完全备份(A)

　　星期二:增量导出(B)

　　星期三:增量导出(C)

　　星期四:增量导出(D)

　　星期五:累计导出(E)

　　星期六:增量导出(F)

　　星期日:增量导出(G)

　　如果在星期日，数据库遭到意外破坏，数据库管理员可按一下步骤来回复数据库:

　　第一步:用命令CREATE DATABASE重新生成数据库结构;

　　第二步:创建一个足够大的附加回滚。

　　第三步:完全增量导入A:

　　第四步:累计增量导入E:

　　第五步:最近增量导入F:

　　冷备份发生在数据库已经正常关闭的情况下，当正常关闭时会提供给我们一个完整的数据库。冷备份时将关键性文件拷贝到另外的位置的一种说法。对于备份Oracle信息而言，冷备份时最快和最安全的方法。冷备份的优点是:

　　1、 是非常快速的备份方法(只需拷文件)

　　2、 容易归档(简单拷贝即可)

　　3、 容易恢复到某个时间点上(只需将文件再拷贝回去)

　　4、 能与归档方法相结合，做数据库“最佳状态”的恢复。

　　5、 低度维护，高度安全。

　　但冷备份也有如下不足:

　　1、 单独使用时，只能提供到“某一时间点上”的恢复。

　　2、 再实施备份的全过程中，数据库必须要作备份而不能作其他工作。也就是说，在冷备份过程中，数据库必须是关闭状态。

　　3、 若磁盘空间有限，只能拷贝到磁带等其他外部存储设备上，速度会很慢。

　　4、 不能按表或按用户恢复。

　　如果可能的话(主要看效率)，应将信息备份到磁盘上，然后启动数据库(使用户可以工作)并将备份的信息拷贝到磁带上(拷贝的同时，数据库也可以工作)。冷备份中必须拷贝的文件包括:

　　1、 所有数据文件

　　2、 所有控制文件

　　3、 所有联机REDO LOG文件

　　4、 Init.ora文件(可选)

　　值得注意的使冷备份必须在数据库关闭的情况下进行，当数据库处于打开状态时，执行数据库文件系统备份是无效的。

　　下面是作冷备份的完整例子。

　　(1) 关闭数据库

　　(2) 用拷贝命令备份全部的时间文件、重做日志文件、控制文件、初始化参数文件

　　(3) 重启Oracle数据库

　　三、 热备份

　　热备份是在数据库运行的情况下，采用archivelog mode方式备份数据库的方法。所以，如果你有昨天夜里的一个冷备份而且又有今天的热备份文件，在发生问题时，就可以利用这些资料恢复更多的信息。热备份要求数据库在Archivelog方式下操作，并需要大量的档案空间。一旦数据库运行在archivelog状态下，就可以做备份了。热备份的命令文件由三部分组成:

　　1. 数据文件一个表空间一个表空间的备份。

　　(1) 设置表空间为备份状态

　　(2) 备份表空间的数据文件

　　(3) 回复表空间为正常状态

　　2. 备份归档log文件

　　(1) 临时停止归档进程

　　(2) log下那些在archive rede log目标目录中的文件

　　(3) 重新启动archive进程

　　(4) 备份归档的redo log文件

　　3. 用alter database bachup controlfile命令来备份控制文件

　　热备份的优点是:

　　1. 可在表空间或数据库文件级备份，备份的时间短。

　　2. 备份时数据库仍可使用。

　　3. 可达到秒级恢复(恢复到某一时间点上)。

　　4. 可对几乎所有数据库实体做恢复

　　5. 恢复是快速的，在大多数情况下爱数据库仍工作时恢复。

　　热备份的不足是:

　　1. 不能出错，否则后果严重

　　2. 若热备份不成功，所得结果不可用于时间点的恢复

　　3. 因难于维护，所以要特别仔细小心，不允许“以失败告终”。

一 使用4GT特性的基本要求：
....尽管可以在不超过2G物理内存的系统上使用4GT特性，但oracle并不推荐这种做法，因为这将会严重降低系统性能。以我的经验来讲，如果系统未安装4G物理内存，最好也不要使用这种方法来让oracle使用更多的内存。此外，在需要你的oracle使用超过2G的内存时，数据库服务器最好不要再运行其他的服务，以减小系统的压力，让oracle工作得更好。
....另外，据MS的文档，4GT只能用于 Advanced Server , Datacenter版本上，Server 版以及 Professional 版不能使用4GT特性(实际上是不是也没有必要？)

二 为什么4GT能让应用程序使用超过2G的内存
....在正常情况下，windows系统对内存的分配是这样的：在内存地址0x00000000 到 0x7FFFFFFF之间的空间，交给应用程序使用，操作系统内核及其支持则使用内存地址 0x80000000 到 0xFFFFFFFF之间的空间。在使用4GT之后，操作系统将内核及其支持程序使用的内存地址空间压缩到 0xC0000000 到 0xFFFFFFFF之间，从而为应用程序“让”出来1G的空间。但是，仅仅“让”出来了这1G的空间还是不够的，还需要指定哪一个应用程序来使用这“多出来的”1G空间，以及如何分配份额等。后面将结合具体的参数设置来讨论。为便于讨论，我们将正常情况下应用程序可以使用的2G内存(即地址在 0x00000000 到 0x7FFFFFFF 之间的内存)称作普通内存，而将windows “让”出来的1G内存(地址在 0x80000000 到 0xBFFFFFFF之间)称作间接内存。

三 oracle使用超过2G内存，不超过3G内存的具体设置步骤：
1 首先应卸载实例，关闭oracle服务。
2 打开操作系统3G开关：
....修改boot.ini文件，在启动windows项中添加 /3G 参数。修改过后的boot.ini文件应该类似以下内容：
[boot loader]
timeout=8
default=multi(0)disk(0)rdisk(0)partition(1)
[operating systems]
multi(0)disk(0)rdisk(0)partition(1)="Microsoft Windows 2000 Advanced Server" /3G /fastdetect
注意在启动win2K AdvServer的一栏里，多了一个 /3G 参数。这个参数的作用，就是让windows启动时，将自己的内核及支持程序装载到内存地址 0xC0000000 到 0xFFFFFFFF 之间，给应用程序留出3G的空间来。
3 修改oralce 的 init.ora 文件
..1) 确定oracle的缓冲区及共享池大小，假设作如下定义：
........ db_block_size = 4096
........ db_block_buffers = 262144 # 缓冲区大小为1G
........ share_pool_size = 314572800 # 使用300M共享池
..2) 添加下列各项内容：
........ use_indirect_data_buffers = true
........ # 告诉oracle可以使用间接内存(即可以使用windows让出来的1G内存作为数据缓冲区)
........ pre_page_sga = true
........ # 把oracle SGA锁定到内存中，不产生页面交换文件(8i的参数可能是lock_sga = true)
........ # 对于一个有4G物理内存的系统来讲，可能这一个参数并不是必须的
4 修改注册表，定义oracle的DBbuffer使用常规内存大小
....在注册表 _Local_Machine中添加一个二进制值，名称为AWE_WINDOW_MEMORY ，值的单位为字节，大小为你需要让oracle使用普通内存作为缓存的大小(不是windows让出来的1G，而是内存地址在0x00000000 到 0x7FFFFFFF 之间的内存大小)。假如设为209715200，即200M大小，那么oracle的数据缓冲区将占用200M的普通内存，其余部分(1G - 200M = 824M)则使用间接内存。
5 重新启动操作系统，启动数据库。OK，你现在的 oracle 可以使用2G + 824M内存了。

四 几个补充讨论
1 windows系统“让”出来的1G间接内存，只能用于数据缓冲区
....在4GT特性测试中发现，间接内存只能用于数据缓冲区，而不能用于共享池，也不能分配给用户作为PGA。或许有其他的参数可以定义，但我查到的文献中没有任何一篇讲间接内存可以用于哪些地方，而在我们的测试中发现按上面的修改后，间接内存只能用于数据缓冲区。此结论只作为一个经验，不是定论，请各位大侠补充修正。
2 注册表中 AWE_WINDOW_MEMORY 参数大小的定义
....这个参数定义缓冲池使用普通内存的大小，不能太小。在数据块大小为4K，缓冲池为1G(即使用262144个块作缓冲池)大小的情况下，此参数定义为100M时，oracle不能启动，定义为200M时正常启动。根据我阅读文献后对这个情况的理解，数据缓冲区的每一个块的块头信息都将存放于普通内存中，不能存放于间接内存中。如果此参数定义过小，导致缓冲区块头信息都不能存放，则可导致数据库启动失败。那么，是不是同样大小的缓冲区，数据库块越大，则这个参数就可以定义得越小，因而可以占用更少的普通内存呢？有待验证。
....在具体的应用中，如何定义此参数，应综合考虑最大并发连接数(专用服务器模式下)、用户重用的堆栈大小、排序区、共享池、大池等内存参数的设置情况，尽可能的将数据缓冲区放到间接内存中，充分利用系统的资源。
3 间接内存的性能
....据oracle的文献讲，间接内存的性能(我想主要是指速度和效率吧？)不如直接内存，绝不推荐在未安装有4G物理内存的系统上使用4GT特性。我不知道如何比较间接内存与直接内存的速度和效率，因而未作测试，姑且信之。
....一点小结，期望能对大家有所启发。还请各位大侠补充指正。
以上内容的测试环境：
IBM X360 +4G内存 + RAID 5阵列
Windows 2000 Advaced Server SP3 + oracle 8.1.6 专用服务器模式

CSS 与 打印控制

随着计算机的普及以及网络的发展，数据库已经不再仅仅是那些程序员所专有的话题。而Oracle数据库更是凭借其性能卓越，操作方便灵活的特点，在数据库的市场中已经占据了一席之地。但是同样随着网络技术的不断进步，数据信息的不断增加，数据安全已经不再是以前的“老生长谈”，也更不是以前书本上那些“可望不可及”的条条框框。
或许很久以前，大家都觉得Oracle数据库的安全并不存在隐患，因为Oracle公司在去年11月份开始促销其数据库软件时提出的口号是“只有Oracle9i能够做到绝对安全”。但是不管它这么说是为了促销，还是为了扩大知名度，总之伴去年12 月份，英国的安全专家 David Litchfield 发现的9iAS 中存在的程序错误导致的缓冲溢出漏洞以及后来，PenTest Limited 和 eEye Digital Security 各自提出了一个小的漏洞，所有使用Oracle公司产品的人都不由地紧张了原本松弛的大脑--这个对于用户来说，毕竟关系到了自己的“身家性命”。
下面笔者将带着大家走进Oracle数据安全的世界。由于笔者水平有限，所以不足之处在所难免，望大家不吝赐教。
（一）Oracle数据库的一些基本常识

这里仅仅是为了以后的安全奠定一些基础，因为我们后面要用到它们。呵呵~！
1.Oracle所包含的组件：
在 Oracle，数据库是指整个 Oracle RDBMS 环境，它包括以下组件：
·Oracle 数据库进程和缓冲（实例）。
·SYSTEM 表空间包含一个集中系统类目，它可以由一个或多个数据文件构成。
·其它由数据库管理员 (DBA)（可选）定义的表空间，每个都由一个或多个数据文件构成。
·两个以上的联机恢复日志。
·归档恢复日志（可选）。
·其它文件（控制文件、Init.ora、Config.ora 等）。
每个 Oracle 数据库都在一个中央系统类目和数据字典上运行，它位于SYSTEM 表空间。
2.关于“日志”
Oracle数据库使用几种结构来保护数据：数据库后备、日志、回滚段和控制文件。下面我们将大体上了解一下作为主要结构之一的“日志”：
每一个Oracle数据库实例都提供日志，记录数据库中所作的全部修改。每一个运行的Oracle数据库实例相应地有一个在线日志，它与Oracle后台进程LGWR一起工作，立即记录该实例所作的全部修改。归档（离线）日志是可选择的，一个Oracle数据库实例一旦在线日志填满后，可形成在线日志归档文件。归档的在线日志文件被唯一标识并合并成归档日志。
·关于在线日志：一个Oracle数据库的每一实例有一个相关联的在线日志。一个在线日志由多个在线日志文件组成。在线日志文件（online redo log file）填入日志项（redo entry），日志项记录的数据用于重构对数据库所作的全部修改。
·关于归档日志：Oracle要将填满的在线日志文件组归档时，则要建立归档日志（archived redo log）。其对数据库备份和恢复有下列用处：
<1>数据库后备以及在线和归档日志文件，在操作系统和磁盘故障中可保证全部提交的事物可被恢复。
<2>在数据库打开和正常系统使用下，如果归档日志是永久保存，在线后备可以进行和使用。
数据库可运行在两种不同方式下：NOARCHIVELOG方式或ARCHIVELOG 方式。数据库在NOARCHIVELOG方式下使用时，不能进行在线日志的归档。如果数据库在ARCHIVELOG方式下运行，可实施在线日志的归档。
3.物理和逻辑存储结构：
Oracle RDBMS是由表空间组成的，而表空间又是由数据文件组成的。表空间数据文件被格式化为内部的块单位。块的大小，是由DBA在Oracle第一次创建的时候设置的，可以在512到8192个字节的范围内变动。当一个对象在Oracle表空间中创建的时候，用户用叫做长度的单位（初始长度（(initial extent)、下一个长度（next extent）、最小长度（min extents）、以及最大长度（max extents））来标明该对象的空间大小。一个Oracle长度的大小可以变化，但是要包含一个由至少五个连续的块构成的链。
4.Oracle与Microsoft SQL Server比较下的联网协议：

（二）Oracle数据安全的维护
记得某位哲学家说过：“事物的变化离不开内因和外因。”那么对于Oracle数据安全这个话题而言，也势必分为“内”和“外”两个部分。那么好，我们就先从“内”开始说起：
§1.从Oracle系统本身说起
我们先抛开令人闻风色变的“hacker”和其他一些外部的原因，先想一下我们的数据库。什么硬盘损坏，什么软件受损，什么操作事物……一系列由于我们的“疏忽”而造成的系统问题就完全可以让我们辛苦建立的数据库中的数据一去不复返。那么，我们就先从自己身上找找原因吧。
【一】解决系统本身问题的方法--数据库的备份及恢复
·数据库的备份：
关于Oracle数据库的备份，标准地有三中办法：导出/导入（Export/Import）、冷备份、热备份。导出备份是一种逻辑备份，冷备份和热备份是物理备份。
<1>导出/导入（Export/Import）
利用Export可将数据从数据库中提取出来，利用Import则可将提取出来的数据送回Oracle数据库中去。
a.简单导出数据（Export）和导入数据（Import）
Oracle支持三种类型的输出：
（1）表方式（T方式），将指定表的数据导出。
（2）用户方式（U方式），将指定用户的所有对象及数据导出。
（3）全库方式（Full方式），将数据库中的所有对象导出。
数据导出（Import）的过程是数据导入（Export）的逆过程，它们的数据流向不同。
b.增量导出/导入
增量导出是一种常用的数据备份方法，它只能对整个数据库来实施，并且必须作为SYSTEM来导出。在进行此种导出时，系统不要求回答任何问题。导出文件名缺省为export.dmp，如果不希望自己的输出文件定名为export.dmp，必须在命令行中指出要用的文件名。
增量导出包括三个类型：
（1）“完全”增量导出（Complete）
即备份整个数据库，比如：
＄exp system/manager inctype=complete file=990702.dmp
（2）“增量型”增量导出
备份上一次备份后改变的数据。比如：
＄exp system/manager inctype=incremental file=990702.dmp
（3）“累计型”增量导出（Cumulative）
累计型导出方式只是导出自上次“完全” 导出之后数据库中变化了的信息。比如：
＄exp system/manager inctype=cumulative file=990702.dmp
数据库管理员可以排定一个备份日程表，用数据导出的三个不同方式合理高效地完成。比如数据库的备份任务可作如下安排：
·星期一：完全导出（A）
·星期二：增量导出（B）
·星期三：增量导出（C）
·星期四：增量导出（D）
·星期五：累计导出（E）
·星期六：增量导出（F）
·星期日：增量导出（G）
如果在星期日，数据库遭到意外破坏，数据库管理员可按以下步骤来恢复数据库：
第一步：用命令CREATE DATABASE重新生成数据库结构；
第二步：创建一个足够大的附加回段。
第三步：完全增量导入A：
＄imp system./manager inctype= RECTORE FULL=Y FILE=A
第四步：累计增量导入E：
＄imp system/manager inctype= RECTORE FULL=Y FILE =E
第五步：最近增量导入F：
＄imp system/manager inctype=RESTORE FULL=Y FILE=F
<2>冷备份
冷备份发生在数据库已经正常关闭的情况下，当正常关闭时会提供给我们一个完整的数据库。冷备份是将关键性文件拷贝到另外位置的一种说法。对于备份Oracle信息而言，冷备份是最快和最安全的方法。冷备份的优点是：
·是非常快速的备份方法（只需拷贝文件）
·容易归档（简单拷贝即可）
·容易恢复到某个时间点上（只需将文件再拷贝回去）
·能与归档方法相结合，作数据库“最新状态”的恢复。
·低度维护，高度安全。
但冷备份也有如下不足：
·单独使用时，只能提供到“某一时间点上”的恢复。
·在实施备份的全过程中，数据库必须要作备份而不能作其它工作。也就是说，在冷备份过程中，数据库必须是关闭状态。
·若磁盘空间有限，只能拷贝到磁带等其它外部存储设备上，速度会很慢。
·不能按表或按用户恢复。
如果可能的话（主要看效率），应将信息备份到磁盘上，然后启动数据库（使用户可以工作）并将所备份的信息拷贝到磁带上（拷贝的同时，数据库也可以工作）。冷备份中必须拷贝的文件包括：
·所有数据文件
·所有控制文件
·所有联机REDO LOG文件
·Init.ora文件（可选）
值得注意的是冷备份必须在数据库关闭的情况下进行，当数据库处于打开状态时，执行数据库文件系统备份是无效的
下面是做冷备份的完整例子：
（1） 关闭数据库＄sqldba lmode=y
SQLDBA >connect internal;
SQLDBA >shutdown normal;
（2） 用拷贝命令备份全部的时间文件、重做日志文件、控制文件、初始化参数文件
SQLDBA >! cp < file > < backup directory >
（3） 重启Oracle数据库
＄sqldba lmode=y
SQLDBA >connect internal;
SQLDBA >startup;
<3>热备份
热备份是在数据库运行的情况下，采用archivelog mode方式备份数据的方法。所以，如果你有昨天夜里的一个冷备份而且又有今天的热备份文件，在发生问题时，就可以利用这些资料恢复更多的信息。热备份要求数据库在Archivelog方式下操作，并需要大量的档案空间。一旦数据库运行在archivelog状态下，就可以做备份了。热备份的命令文件由三部分组成：
1．数据文件一个表空间一个表空间地备份。
（1）设置表空间为备份状态
（2）备份表空间的数据文件
（3）恢复表空间为正常状态
2．备份归档log文件。
（1）临时停止归档进程
（2）log下那些在archive redo log目标目录中的文件
（3）重新启动archive进程
（4）备份归档的redo log 文件
3．用alter database backup controlfile命令来备份拷贝文件
热备份的优点是：
·可在表空间或数据文件级备份，备份时间短。
·备份时数据库仍可使用。
·可达到秒级恢复（恢复到某一时间点上）。
·可对几乎所有数据库实体作恢复。
·恢复是快速的，在大多数情况下在数据库仍工作时恢复。
热备份的不足是：
·不能出错，否则后果严重。
·若热备份不成功，所得结果不可用于时间点的恢复。
·因难于维护，所以要特别仔细小心，不允许“以失败而告终”。

【二】来自内部的另外一个隐患--用户管理以及密码问题
在这里，其实作为一个差不多点的数据库管理员都很清楚，Oracle数据库本身就使用了很多种手段来加强数据库的安全性，经常见到的就有密码，角色，权限等等。那么我们就从最简单的DBSNMP
说起：
Oralce数据库如果采用典型安装后，自动创建了一个叫做DBSNMP的用户，该用户负责运行Oracle系统的智能代理（Intelligent Agent），该用户的缺省密码也是“DBSNMP”。如果忘记修改该用户的口令，任何人都可以通过该用户存取数据库系统。现在我们来看一下该用户具有哪些权限和角色，然后来分析一下该用户对数据库系统可能造成的损失。
启动SQL/PLUS程序，使用该用户登录进入：
SQL> select * from session_privs;
CREATE SESSION
ALTER SESSION
UNLIMITED TABLESPACE
CREATE TABLE
CREATE CLUSTER
CREATE SYNONYM
CREATE PUBLIC SYNONYM
CREATE VIEW
CREATE SEQUENCE
CREATE DATABASE LINK
CREATE PROCEDURE
CREATE TRIGGER
ANALYZE ANY
CREATE TYPE
CREATE OPERATOR
CREATE INDEXTYPE
可以看到该用户不是SYS或SYSTEM管理用户，然而，它却具有两个系统级权限：UNLIMITED TABLESPACE和CREATE PUBLIC SYNONYM。
看到这两个权限你应该马上想到，这些都是安全隐患，尤其是UNLIMITED TABLESPACE，它是破坏数据库系统的攻击点之一。如果这时候你还依然认为，即使有人利用这个没有修改的口令登录进数据库也造成不了什么损失的话，我就不得不提醒你：该用户具有UNLIMITED TABLESPACE的系统权限，它可以写一个小的脚本，然后恶意将系统用垃圾数据填满，这样数据库系统也就无法运行，并将直接导致最终的瘫痪。目前很多数据库系统都要求7X24的工作，如果出现了系统用垃圾数据填满的情况，那么，等数据库系统恢复时，恐怕不可挽回的损失已经造成了。
可是除了 DBSNMP 还有很多其他的用户，怎么办呢？让我们先看一下目前普遍存在于Oracle数据库中的用户管理问题：
（1）权限过大：对ORACLE数据库编程和浏览的一般用户常常具有DBA (数据库管理员权限)，
能对数据库系统做任何修改或删除。
（2）安全性差：很多ORACLE用户缺省存储位置都在系统表空间，这样不仅影响系统的正常工
作，而且不同用户的数据信息互相影响、透明，保密性差。随着数据的不断加入，
有可能使整个数据库系统崩溃。
（3）密码有规律：在ORACLE调试初期形成的用户名和密码一致的不良习惯保留到现在；系统用户SYS和SYSTEM的密码也众所皆知。
知道了这些普遍的“毛病”，我们怎么做呢？下面是我的一些建议：
（1）ORACLE DBA (数据库管理员)的规范
·SUN Solaris操作系统下ORACLE用户密码应严格保密，绝不该把密码设成
ORACLE；并指定专门的数据库管理员定期修改。
·ORACLE初始化建立的SYS和SYSTEM系统管理员用户密码应由原来MANAGER改成别的不易被记忆的字符串。
·ORACLE WEB SERVER的管理端口具备DBA浏览数据库的能力，因此其管理者
ADMIN的密码也应保密，不该把密码设成MANAGER；并指定专门的数据库管理员定
期修改。
·ORACLE DBA最好在SUN SPARC服务器控制台上用窗口式界面实现管理。前提
是ORACLE用户启动服务器，然后在窗口式命令行下输入SVRMGRM，即启动了ORACLE SERVER MANAGER菜单式管理；用SYSDBA身份登录后，就可做数据库系统维护工作了

（2）SQL*PLUS编程用户的规范
·存储结构的规范
考虑到用SQL*PLUS编程可实现各行各业、各公司、各部门多种多样的应用需求，我们的SQL*PLUS编程用户也应该朝这个方向规范：不同种类的应用必须有不同的用户；不同种类的应用必须有不同的存储位置，包括物理文件、缺省表空间、临时表空间的创建和规划：当准备编写某一较大规模(从ORACLE数据量和面向用户量考虑)应用程序时，首先应该创建一个逻辑的存储位置-表空间，同时定义物理文件的存放路径和所占硬盘的大小。
①、物理文件缺省的存放路径在/oracle_home/dbs下，在命令行下用UNIX指令df -k 可查看硬盘资源分区的使用情况。如果oracle_home使用率达90‰以上，而且有一个或多个较为空闲的硬盘资源分区可以利用，我们最好把物理文件缺省的存放路径改到较为空闲的硬盘资源分区路径下。在此路径下我们可以这样规划资源物理文件的存储：
xxx表空间
xxx行业/ xxx公司/ xxx 部门/ xxx 服务.dbf
DEMO表空间
default_datafile_home1/col /elec/sys4/demo1.dbf
default_datafile_home1/col /elec/sys4/demo2.dbf
公司系统四部摹拟演示系统物理文件
HUMAN表空间
default_datafile_home1/col/elec/human/human.dbf
公司人事部人事管理系统物理文件
BOOK表空间
default_datafile_home1/col/elec/book/book.dbf
公司资料室图书管理系统物理文件
QUESTION表空间
default_datafile_home1/col/elec/client/question.dbf
公司客户服务部问题库系统物理文件
PC表空间
default_datafile_home1/col/chaoxun/client/pc.dbf
公司PC机售后服务系统物理文件
……表空间
default_datafile_home2/……………………………
等等
说明：其中default_datafile_home1指oracle_home/dbs；
default_datafile_home2指较为空闲的硬盘资源分区路径。
②、物理文件的大小根据应用系统的数据量、数据对象、程序包的多少来定。一般用于摹拟演示的小系统，表空间初始的物理文件为2M即能满足要求，如果信息量满，还可以增加物理文件，扩充表空间(每次扩充大小也可暂定为2M)；一般实际运行的应用系统可适当增加表空间初始的物理文件大小，但也不要一次分配太大(因为不易回收空间，却易扩充空间)，这也需要根据具体情况具体分析：信息量大、需长时间保存的应用在条件允许情况下，表空间可以大到几百M甚至上G；信息量小、短期经常刷新的应用，表空间可以控制在2M以下。

③、表空间的名称应该采用同系统应用相似的英文字符或字符缩写，表空间所对应的一个或多个物理文件名也应有相关性。不同用户所处的缺省表空间不同，存储的信息就不能互相访问。这比把所有用户信息都储存在系统表空间，安全性大大提高了。如果用ORACLE WEB SERVER管理端口创建的用户，其缺省和临时表空间一定是系统表空间，DBA切记要改变用户的缺省表空间。临时表空间存放临时数据段，处理一些排序、合并等中间操作，根据实际应用的需求可以把它们放在专门创建的表空间里；如果系统表空间大，也可以把它们放在系统表空间。用户创建的数据索引最好和数据文件分开存放在不同表空间，以减少数据争用和提高响应速度。

·密码和用户名的规范
有相当数量的ORACLE用户名和密码一致，这是个很不安全的因素。我们建议ORACLE用户名和密码一定不要一样，密码最好在五，六位字符以上。不同用户间不应该使用相同的密码。用户名的定义可根据实际应用的英文名来设，而依据编程人员的姓名定义的用户名实际上不规范，可在日后的工作中结合上述有关存储结构规范的说明逐步改进。
（3）特殊要求用户的规范
在ORACLE数据库使用过程中，还会遇到一些有特殊要求的用户：非编程人员需要对某个表有查询、增加、删除、修改的权利。DBA应创建一个这样的用户，先确定用户名和密码，再规定相关应用所在缺省表空间(包含某个表)和临时表空间，最后TABLE属主给其授权：赋予CONNECT角色SELECT、INSERT、DELETE、UPDATE ON THE TABLE的对象级权限，这可根据实际需求自由取舍。
举例：●给新用户授于对象级权限(命令行方式)：
假设新用户NEW2需要有查询、删除、修改DCD用户的表EMP。
%svrmgrl
SVRMGR>connect internal; 以系统管理员登录
SVRMGR>create user new2 identified by new2345 default tablespace app;
SVRMGR>connect dcd/dcdpwd; 以dcd用户登录
SVRMGR>grant connect to new2;
SVRMGR>grant select on emp to new2;
SVRMGR>grant delete on emp to new2;
SVRMGR>grant update on emp to new2;
说了这么多关于用户的问题，那么接下来我们就详细得说一下关于密码文件的使用以及维护--在Oracle数据库系统中，用户如果要以特权用户身份（INTERNAL／SYSDBA／SYSOPER）登录Oracle数据库可以有两种身份验证的方法：即使用与操作系统集成的身份验证或使用Oracle数据库的密码文件进行身份验证。因此，管理好密码文件，对于控制授权用户从远端或本机登录Oracle数据库系统，执行数据库管理工作，具有重要的意义。
Oracle数据库的密码文件存放有超级用户INTERNAL／SYS的口令及其他特权用户的用户名／口令，它一般存放在ORACLE_HOME＼DATABASE目录下。
·密码文件的创建：
在使用Oracle Instance Manager创建一数据库实例的时侯，在ORACLE_HOME＼DATABASE目录下还自动创建了一个与之对应的密码文件，文件名为PWDSID.ORA，其中SID代表相应的Oracle数据库系统标识符。此密码文件是进行初始数据库管理工作的基础。在此之后，管理员也可以根据需要，使用工具ORAPWD.EXE手工创建密码文件，命令格式如下：
C:＼ >ORAPWD　FILE=＜ FILENAME ＞　PASSWORD =＜ PASSWORD ＞ ENTRIES=< MAX_USERS >
各命令参数的含义为：
FILENAME：密码文件名；
PASSWORD：设置INTERNAL／SYS帐号的口令；
MAX_USERS：密码文件中可以存放的最大用户数，对应于允许以SYSDBA／SYSOPER权限登录数据库的最大用户数。由于在以后的维护中，若用户数超出了此限制，则需要重建密码文件，所以此参数可以根据需要设置得大一些。
有了密码文件之后，需要设置初始化参数REMOTE_LOGIN_PASSWORDFILE来控制密码文件的使用状态。
·设置初始化参数REMOTE_LOGIN_PASSWORDFILE：
在Oracle数据库实例的初始化参数文件中，此参数控制着密码文件的使用及其状态。它可以有以下几个选项：
NONE：指示Oracle系统不使用密码文件，特权用户的登录通过操作系统进行身份验证；
EXCLUSIVE：指示只有一个数据库实例可以使用此密码文件。只有在此设置下的密码文件可以包含有除INTERNAL／SYS以外的用户信息，即允许将系统权限SYSOPER／SYSDBA授予除INTERNAL／SYS以外的其他用户。
SHARED：指示可有多个数据库实例可以使用此密码文件。在此设置下只有INTERNAL／SYS帐号能被密码文件识别，即使文件中存有其他用户的信息，也不允许他们以SYSOPER／SYSDBA的权限登录。此设置为缺省值。
在REMOTE_LOGIN_PASSWORDFILE参数设置为EXCLUSIVE、SHARED情况下，Oracle系统搜索密码文件的次序为：在系统注册库中查找ORA_SID_PWFILE参数值（它为密码文件的全路径名）；若未找到，则查找ORA_PWFILE参数值；若仍未找到，则使用缺省值ORACLE_HOME＼DATABASE＼PWDSID.ORA；其中的SID代表相应的Oracle数据库系统标识符。
·向密码文件中增加、删除用户：
当初始化参数REMOTE_LOGIN_PASSWORDFILE设置为EXCLUSIVE时，系统允许除INTERNAL／SYS以外的其他用户以管理员身份从远端或本机登录到Oracle数据库系统，执行数据库管理工作；这些用户名必须存在于密码文件中，系统才能识别他们。由于不管是在创建数据库实例时自动创建的密码文件，还是使用工具ORAPWD.EXE手工创建的密码文件，都只包含INTERNAL／SYS用户的信息；为此，在实际操作中，可能需要向密码文件添加或删除其他用户帐号。
由于仅被授予SYSOPER／SYSDBA系统权限的用户才存在于密码文件中，所以当向某一用户授予或收回SYSOPER／SYSDBA系统权限时，他们的帐号也将相应地被加入到密码文件或从密码文件中删除。由此，向密码文件中增加或删除某一用户，实际上也就是对某一用户授予或收回SYSOPER／SYSDBA系统权限。
要进行此项授权操作，需使用SYSDBA权限（或INTERNAL帐号）连入数据库，且初始化参数REMOTE_LOGIN_PASSWORDFILE的设置必须为EXCLUSIVE。具体操作步骤如下：
创建相应的密码文件；
设置初始化参数REMOTE_LOGIN_PASSWORDFILE＝EXCLUSIVE；
使用SYSDBA权限登录： CONNECT　SYS／internal_user_passsword　AS　SYSDBA；
启动数据库实例并打开数据库；
创建相应用户帐号，对其授权（包括SYSOPER和SYSDBA）： 授予权限：GRANT　SYSDBA　TO　user_name；
收回权限：REVOKE　SYSDBA　FROM　user_name；
现在这些用户可以以管理员身份登录数据库系统了；
·使用密码文件登录：
有了密码文件后，用户就可以使用密码文件以SYSOPER／SYSDBA权限登录Oracle数据库实例了，注意初始化参数REMOTE_LOGIN_PASSWORDFILE应设置为EXCLUSIVE或SHARED。任何用户以SYSOPER／SYSDBA的权限登录后，将位于SYS用户的Schema之下，以下为两个登录的例子：
1. 以管理员身份登录：
假设用户scott已被授予SYSDBA权限，则他可以使用以下命令登录：
CONNECT　scott／tiger　AS　SYSDBA
2. 以INTERNAL身份登录：
CONNECT　INTERNAL／INTERNAL_PASSWORD
·密码文件的维护：
1. 查看密码文件中的成员：
可以通过查询视图V$PWFILE_USERS来获取拥有SYSOPER／SYSDBA系统权限的用户的信息，表中SYSOPER／SYSDBA列的取值TRUE／FALSE表示此用户是否拥有相应的权限。这些用户也就是相应地存在于密码文件中的成员。
2. 扩展密码文件的用户数量：
当向密码文件添加的帐号数目超过创建密码文件时所定的限制（即ORAPWD.EXE工具的MAX_USERS参数）时，为扩展密码文件的用户数限制，需重建密码文件，具体步骤如下：
a) 查询视图V$PWFILE_USERS，记录下拥有SYSOPER／SYSDBA系统权限的用户信息；
b) 关闭数据库；
c) 删除密码文件；
d) 用ORAPWD.EXE新建一密码文件；
e) 将步骤a中获取的用户添加到密码文件中。
3. 修改密码文件的状态：
密码文件的状态信息存放于此文件中，当它被创建时，它的缺省状态为SHARED。可以通过改变初始化参数REMOTE_LOGIN_PASSWORDFILE的设置改变密码文件的状态。当启动数据库事例时，Oracle系统从初始化参数文件中读取REMOTE_LOGIN_PASSWORDFILE参数的设置；当加载数据库时，系统将此参数与口令文件的状态进行比较，如果不同，则更新密码文件的状态。若计划允许从多台客户机上启动数据库实例，由于各客户机上必须有初始化参数文件，所以应确保各客户机上的初始化参数文件的一致性，以避免意外地改变了密码文件的状态，造成数据库登陆的失败。
4. 修改密码文件的存储位置：
密码文件的存放位置可以根据需要进行移动，但作此修改后，应相应修改系统注册库有关指向密码文件存放位置的参数或环境变量的设置。
5. 删除密码文件：
在删除密码文件前,应确保当前运行的各数据库实例的初始化参数REMOTE_LOGIN_PASSWORDFILE皆设置为NONE。在删除密码文件后，若想要以管理员身份连入数据库的话，则必须使用操作系统验证的方法进行登录。
但是管理员都觉得乏味，因为在管理员中流行一种很简单的加密办法--就是经常，很频繁地修改自己的密码。可是，每次修改都跟打一次仗似的--因为更新程序并不是每个人都愿意做的事情。
那么有没有什么简单点的办法呢？请往下看：
模型：Oracle7.3；开发工具：Develope2000。收费系统（在数据库中的名称是SFYY），其Client端分散在市区的数个营业点，通过城域网与主机(小型 机)相连。
过程：
·在收费小型机Oracle系统的system用户（DBA）下，创建新用户test;
create user test
identified by carton
default tablespace dataspace1
quota 100K
·对test用户授以权限；
grant create session to test;
grant resource to test;
·在test用户下建立一个存储函数mmtranslate,它其实是一个加密程序。下面是一个简 单的例子。
function mmtranslate(m varchar2)
return varchar2
as
i number(2);
kk varchar2(10);
begin
kk:=′′;
i:=1;
loop
if i<=length(m) then
if instr(′1234567890′,substr(m,i,1),1,1)>0 then
kk:=kk||chr(100+to_number(substr(m,i,1)));
elseif instr(‘wxyz‘,substr(m,i,1),1,1)>0 then
kk:=kk||chr(-8+ascii(substr(m,i,1)));
else
kk:=kk||chr(4+ascii(substr(m,i,1)));
end if;
else
exit;
end if;
i:=i+1;
end loop;
return kk;
exception
when others then
return ′-1′;
end;
·在test用户下建表mmtest并插入记录：
create table mmtest
(usnamevarchar2(6),------用户名称
mimavarchar2(6)------加密前的密码);
insert into mmtest values( ‘sfyy‘,‘eds2‘);
commit;
·执行以下语句
SQL>select mmtranslate(‘eds2‘) from dual;
MMTRANSLATE(‘EDS2‘)
----------------------------------------
ihwf
利用DBA权限更改sfyy的密码为上面语句的执行结果：
alter user sffy
identified by ihwf; ;
·修改应用程序，对于开发环境是Develope2000的程序来说，主要是修改主程序的on-lo gon触发器：
declare
mm varchar2(6);
begin
logon(‘test‘,‘carton‘);
select mima into mm from mmtest where usname=‘sfyy‘;
mm:=mmtranslate(mm);
logout;
logon(‘sfyy‘,mm);
end;
然后再利用触发器WHEN-NEW-FROM-INSTANCE执行Callfrom或Newform等 命令，进入业务处理程序。这个主程序应当仅仅由管理员来掌握,编译之后将执行文件下发 到各收费点的Clien端。
·在System用户下，利用Oracle提供的pupbld.sql,建立表Productuserprofile,执行下面这样的命令，限制在非开发状态Sql命令的使用,例如
insert into productuserprofile
(product,userid,attribute,charvalue) values
(‘SQL*Plus‘,‘TEST‘,‘CONNECT‘,‘DISABLED‘);
insert into productuserprofile
(product,userid,attribute,charvalue) values
(‘SQL*Plus‘,‘SFYY‘,‘DELETE‘,‘DISABLED‘)；这样，在SQL状态下，根本无法连接到TEST用户，而在 sfyy用户下，delete命令将不能执行。当然，DBA可以改变这些设置。
当然了，这个仅仅是属于一种“应用技巧”，但是足可以把那些每天忙于更新系统的管理员舒服好几天了。但是另一方面，还要加强对源程序的管理，在Client端只存放执行程序。加强审计，发现异常现象，及时处理。这样才可以做到更高一层的“安全”。
在下面，我主要是向大家介绍一个REM对GHXXB制立数据库触发子,密码的加密程序。
REM 对GHXXB制立数据库触发子(当INSERT OR UPDATE GHXXB时触发)
drop trigger scjmmm;
create or replace trigger scjmmm
before insert or update of mm On ghxxb For each Row
Begin
:new.mm:=ENCRYPT(:new.mm,:NEW.GH,TO_CHAR(SYSDATE,‘SS‘));
End;
/
---------------------------密码的加密程序ENCRYPT----------------------
Create or Replace
Function ENCRYPT (Inpass In Varchar2,IN_GH In Varchar2,IN_SS In Varchar2)
Return Varchar2 Is
bcs varchar2(20);
bcs1 number;
cs number;
jg number;
m_gh VARCHAR2(4);
m_mm VARCHAR2(20);
Begin
m_gh:=IN_GH;
m_mm:=INPASS;
cs:=TO_NUMBER(IN_SS);
If cs<=1 then cs:=77 ;end if;
bcs:=substr(to_char(ascii(substr(m_gh,1,1))),1,2);
If bcs<‘1‘ then bcs:=‘7‘ ;end if;
m_gh:=substr(m_gh,2);
Loop EXIT WHEN nvl(length(m_gh),0)=0 ;
bcs:=bcs||substr(to_char(ascii(substr(m_gh,1,1))),-1,1);
m_gh:=substr(m_gh,2);
End loop;
Loop EXIT WHEN nvl(length(m_mm),0)=0 ;
bcs:=bcs||substr(to_char(ascii(substr(m_mm,1,1))),-1,1);
m_mm:=substr(m_mm,2);
End loop;
bcs1:=to_number(bcs);
jg:=cs*bcs1;
Loop EXIT WHEN length(to_char(jg))>13;
jg:=jg*cs ;
End loop;
RETURN(IN_SS||substr(to_char(jg),1,14));
End;
/
总结上面的东西，我们仅仅是从自身做起，知道了怎么维护Oracle数据库安全这个话题的“皮毛”。可是，对于这个似乎永远也说不完的话题，我们光知道怎么从内部“防御”就够了吗？不要忘了，在外面，还有一群虎视耽耽的“hacker”在盯着你的数据库--因为这里面有他们想要的东西。
所以，请大家关注好下一个话题：
§2.不被“hacker”入侵的几个建议
我们的目标是：没有蛀牙！（开个玩笑~！呵呵）其实应该是：它应尽可能地堵住潜在的各种漏洞，防止非法用户利用它们侵入数据库系统。对于数据库数据的安全问题，数据库管理员可以参考有关系统双机热备份功能以及数据库的备份和恢复的资料。
以下就数据库系统不被非法用户侵入这个问题作进一步的阐述。
·组和安全性：在操作系统下建立用户组也是保证数据库安全性的一种有效方法。Oracle程序为了安全性目的一般分为两类：一类所有的用户都可执行，另一类只DBA可执行。在Unix环境下组设置的配置文件是/etc/group，关于这个文件如何配置，请参阅Unix的有关手册，以下是保证安全性的几种方法：
(1)在安装Oracle Server前，创建数据库管理员组(DBA)而且分配root和Oracle软件拥有者的用户ID给这个组。DBA能执行的程序只有710权限。在安装过程中SQL*DBA系统权限命令被自动分配给DBA组。
(2)允许一部分Unix用户有限制地访问Oracle服务器系统，增加一个由授权用户组的Oracle组，确保给Oracle服务器实用例程Oracle组ID，公用的可执行程序，比如SQL*Plus，SQL*forms等，应该可被这组执行，然后该这个实用例程的权限为710，它将允许同组的用户执行，而其他用户不能。
(3)改那些不会影响数据库安全性的程序的权限为711。（注：在我们的系统中为了安装和调试的方便，Oracle数据库中的两个具有DBA权限的用户Sys和System的缺省密码是manager。为了您数据库系统的安全，我们强烈建议您该掉这两个用户的密码，具体操作如下：
在SQL*DBA下键入：
alter user sys indentified by password;
alter user system indentified by password;
其中password为您为用户设置的密码。
·Oracle服务器实用例程的安全性：
以下是保护Oracle服务器不被非法用户使用的几条建议：
(1) 确保$ORACLE_HOME/bin目录下的所有程序的拥有权归Oracle软件拥有者所有；
(2) 给所有用户实用便程(sqiplus,sqiforms,exp,imp等)711权限，使服务器上所有的用户都可访问Oracle服务器；
(3) 给所有的DBA实用例程(比如SQL*DBA)700权限。Oracle服务器和Unix组当访问本地的服务时，您可以通过在操作系统下把Oracle服务器的角色映射到Unix的组的方式来使用Unix管理服务器的安全性，这种方法适应于本地访问。
在Unix中指定Oracle服务器角色的格式如下：
ora_sid_role[_dla]
其中 sid 是您Oracle数据库的oracle_sid；
role 是Oracle服务器中角色的名字；
d (可选)表示这个角色是缺省值；a (可选)表示这个角色带有WITH ADMIN选项，您只可以把这个角色授予其他角色，不能是其他用户。
以下是在/etc/group文件中设置的例子：
ora_test_osoper_d:NONE:1:jim,narry,scott
ora_test_osdba_a:NONE:3:pat
ora_test_role1:NONE:4:bob,jane,tom,mary,jim
bin: NONE:5:root,oracle,dba
root:NONE:7:root
词组“ora_test_osoper_d”表示组的名字；词组“NONE”表示这个组的密码；数字1表示这个组的ID；接下来的是这个组的成员。前两行是Oracle服务器角色的例子，使用test作为sid，osoper和osdba作为Oracle服务器角色的名字。osoper是分配给用户的缺省角色，osdba带有WITH ADMIN选项。为了使这些数据库角色起作用，您必须shutdown您的数据库系统，设置Oracle数据库参数文件initORACLE_SID.ora中os_roles参数为True，然后重新启动您的数据库。如果您想让这些角色有connect internal权限，运行orapwd为这些角色设置密码。当您尝试connect internal时，您键入的密码表示了角色所对应的权限。
·SQL*DBA命令的安全性：
如果您没有SQL*PLUS应用程序，您也可以使用SQL*DBA作SQL查权限相关的命令只能分配给Oracle软件拥有者和DBA组的用户，因为这些命令被授予了特殊的系统权限。
(1) startup
(2) shutdown
(3) connect internal
·数据库文件的安全性：
Oracle软件的拥有者应该这些数据库文件($ORACLE_HOME/dbs/*.dbf)设置这些文件的使用权限为0600：文件的拥有者可读可写，同组的和其他组的用户没有写的权限。
Oracle软件的拥有者应该拥有包含数据库文件的目录，为了增加安全性，建议收回同组和其他组用户对这些文件的可读权限。
·网络安全性：
当处理网络安全性时，以下是额外要考虑的几个问题。
(1) 在网络上使用密码在网上的远端用户可以通过加密或不加密方式键入密码，当您用不加密方式键入密码时，您的密码很有可能被非法用户截获，导致破坏了系统的安全性。
(2) 网络上的DBA权限控制您可以通过下列两种方式对网络上的DBA权限进行控制：
A 设置成拒绝远程DBA访问；
B 通过orapwd给DBA设置特殊的密码。
·建立安全性策略：
系统安全性策略
(1)管理数据库用户：数据库用户是访问Oracle数据库信息的途径，因此，应该很好地维护管理数据库用户的安全性。按照数据库系统的大小和管理数据库用户所需的工作量，数据库安全性管理者可能只是拥有create，alter，或drop数据库用户的一个特殊用户，或者是拥有这些权限的一组用户，应注意的是，只有那些值得信任的个人才应该有管理数据库用户的权限。
(2) 用户身份确认：数据库用户可以通过操作系统，网络服务，或数据库进行身份确认，通过主机操作系统进行用户身份认证的优点有：
A 用户能更快，更方便地联入数据库；
B 通过操作系统对用户身份确认进行集中控制：如果操作系统与数据库用户信息一致，Oracle无须存储和管理用户名以及密码；
C 用户进入数据库和操作系统审计信息一致。
(3) 操作系统安全性
A 数据库管理员必须有create和delete文件的操作系统权限；
B 一般数据库用户不应该有create或delete与数据库相关文件的操作系统权限；
C 如果操作系统能为数据库用户分配角色，那么安全性管理者必须有修改操作系统帐户安全性区域的操作系统权限。
·数据的安全性策略：
数据的生考虑应基于数据的重要性。如果数据不是很重要，那么数据的安全性策略可以稍稍放松一些。然而，如果数据很重要，那么应该有一谨慎的安全性策略，用它来维护对数据对象访问的有效控制。
·用户安全性策略：
(1) 一般用户的安全性：
A 密码的安全性：如果用户是通过数据库进行用户身份的确认，那么建议使用密码加密的方式与数据库进行连接。这种方式的设置方法如下：
在客户端的oracle.ini文件中设置ora_encrypt_login数为true；
在服务器端的initORACLE_SID.ora文件中设置dbling_encypt_login参数为true。
B 权限管理：对于那些用户很多，应用程序和数据对象很丰富的数据库，应充分利用“角色”这个机制所带的方便性对权限进行有效管理。对于复杂的系统环境，“角色”能大大地简化权限的理。
(2) 终端用户的安全性：
您必须针对终端用户制定安全性策略。例如，对于一个有很多用户的大规模数据库，安全性管理者可以决定用户组分类为这些用户组创建用户角色，把所需的权限和应用程序角色授予每一个用户角色，以及为用户分配相应的用户角色。当处理特殊的应用要求时，安全性管理者也必须明确地把一些特定的权限要求授予给用户。您可以使用“角色”对终端用户进行权限管理。
·数据库管理者安全性策略：
(1) 保护作为sys和system用户的连接：
当数据库创建好以后，立即更改有管理权限的sys和system用户的密码，防止非法用户访问数据库。当作为sys和system用户连入数据库后，用户有强大的权限用各种方式对数据库进行改动。
(2) 保护管理者与数据库的连接：
应该只有数据库管理者能用管理权限连入数据库，当以sysdba或startup，shutdown，和recover或数据库对象(例如create,drop，和delete等)进行没有任何限制的操作。
(3) 使用角色对管理者权限进行管理
·应用程序开发者的安全性策略：
(1) 应用程序开发者和他们的权限数据库应用程序开发者是唯一一类需要特殊权限组完成自己工作的数据库用户。开发者需要诸如create table,create，procedure等系统权限，然而，为了限制开发者对数据库的操作，只应该把一些特定的系统权限授予开发者。
(2) 应用程序开发者的环境：
A 程序开发者不应与终端用户竞争数据库资源；
B 用程序开发者不能损害数据库其他应用产品。
(3) free和controlled应用程序开发应用程序开发者有一下两种权限：
A free development
应用程序开发者允许创建新的模式对象，包括table,index,procedure,package等，它允许应用程序开发者开发独立于其他对象的应用程序。
B controlled development
应用程序开发者不允许创建新的模式对象。所有需要table,indes procedure等都由数据库管理者创建，它保证了数据库管理者能完全控制数据空间的使用以及访问数据库信息的途径。但有时应用程序开发者也需这两种权限的混和。
(4) 应用程序开发者的角色和权限数据库安全性管理者能创建角色来管理典型的应用程序开发者的权限要求。
A create系统权限常常授予给应用程序开发者，以至于他们能创建他的数据对象。
B 数据对象角色几乎不会授予给应用程序开发者使用的角色。
(5) 加强应用程序开发者的空间限制作为数据库安全性管理者，您应该特别地为每个应用程序开发者设置以下的一些限制：
A 开发者可以创建table或index的表空间；
B 在每一个表空间中，开发者所拥有的空间份额。应用程序管理者的安全在有许多数据库应用程序的数据库系统中，您可能需要一应用程序管理者，应用程序管理者应负责起以下的任务：
a）为每一个应用程序创建角色以及管理每一个应用程序的角色；
b）创建和管理数据库应用程序使用的数据对象；
c）需要的话，维护和更新应用程序代码和Oracle的存储过程和程序包。
我相信有了以上的这些建议，作为一个Oracle的管理者绝对可以做好他本职的工作了。可是，我们再怎么努力，都始终得面对这样一个现实，那就是Oracle毕竟是其他人开发的，而我们却在使用。所以，Oracle到底有多少漏洞--我想这个不是你和我所能解决的。不过既然作为一篇讨论Oracle数据安全的文章，我认为有必要把漏洞这一块也写进去，毕竟这也是“安全”必不可少的一部分。呵呵！
所以……
【Oracle漏洞举例】：
·Oracle9iAS Web Cache远程拒绝服务攻击漏洞（2002-10-28）
·Oracle 8.1.6的oidldapd中的漏洞
·Oracle 9iAS OracleJSP 泄漏JSP文件信息漏洞
·Linux ORACLE 8.1.5漏洞
想必我没有理由再往下举了，因为读者肯定已经从其他有效的途径得到了关于Oracle漏洞的最新情报。我这里就不再赘述了。
总而言之一句话--“Oracle数据安全是一个博大而又精深的话题；如果你没有耐心，就永远不会得到它的精髓之所在。”
常用日期格式是 2005-10-13 怎样能转换成 20051013 呢?

我自己经常用到,怕自己忘记了,所以用BLOG记录下来.

convert(char(12),datatime,112)

　　Commons的包分成两部分：Sandbox，Commons代码库。Sandbox是一个测试平台，用来检验各种设想、计划。本文介绍的组件属于Commons代码库，文章将展示各个组件的功能、适用场合，并通过简单的例子介绍其用法。

　　一、概述

　　可重用性是Jakarta Commons项目的灵魂所在。这些包在设计阶段就已经考虑了可重用性问题。其中一些包，例如Commons里面用来记录日志的Logging包，最初是为其他项目设计的，例如Jakarta Struts项目，当人们发现这些包对于其他项目也非常有用，能够极大地帮助其他项目的开发，他们决定为这些包构造一个"公共"的存放位置，这就是Jakarta Commons项目。

　　为了真正提高可重用性，每一个包都必须不依赖于其他大型的框架或项目。因此，Commons项目的包基本上都是独立的，不仅是相对于其他项目的独立，而且相对于Commons内部的大部分其他包独立。虽然存在一些例外的情况，例如Betwixt包要用到XML API，但绝大部分只使用最基本的API，其主要目的就是要能够通过简单的接口方便地调用。

　　不过由于崇尚简洁，许多包的文档变得过于简陋，缺乏维护和支持，甚至有一部分还有错误的链接，文档也少得可怜。大部分的包需要我们自己去找出其用法，甚至有时还需要我们自己去分析其适用场合。本文将逐一介绍这些包，希望能够帮助你迅速掌握这一积累了许多人心血的免费代码库。

　　说明：Jakarta Commons和Apache Commons是不同的，后者是Apache Software Foundation的一个顶层项目，前者则是Jakarta项目的一个子项目，同是也是本文要讨论的主角。本文后面凡是提到Commons的地方都是指Jakarta的Commons。

　　为了便于说明，本文把Commons项目十八个成品级的组件（排除了EL、Latka和Jexl）分成5类，如下表所示。

　　必须指出的是，这种分类只是为了方便文章说明，Commons项目里面实际上并不存在这种分类，同时这些分类的边界有时也存在一定的重叠。

　　本文首先介绍Web相关类和其他类里面的组件，下一篇文章将涉及XML相关、包装这两类，最后一篇文章专门介绍属于工具类的包。

　　二、其他类

　　CLI、Discovery、Lang和Collections包归入其他类，这是因为它们都各自针对某个明确、实用的小目标，可谓专而精。

　　2.1 CLI

　　■ 概况：CLI即Command Line Interface，也就是"命令行接口"，它为Java程序访问和解析命令行参数提供了一种统一的接口。

　　■ 官方资源：主页，二进制，源代码

　　■ 何时适用：当你需要以一种一致的、统一的方式访问命令行参数之时。

　　■ 示例应用：CLIDemo.java。CLASSPATH中必须包含commons-cli-1.0.jar。

　　■ 说明：

　　有多少次你不得不为一个新的应用程序重新设计新的命令行参数处理方式？如果能够只用某个单一的接口，统一完成诸如定义输入参数（是否为强制参数，数值还是字符串，等等）、根据一系列规则分析参数、确定应用要采用的路径等任务，那该多好！答案就在CLI。

　　在CLI中，每一个想要在命令中指定的参数都是一个Option对象。首先创建一个Options对象，将各个Option对象加入Options对象，然后利用CLI提供的方法来解析用户的输入参数。Option对象可以要求用户必须输入某个参数，例如必须在命令行提供文件名字。如果某个参数是必须的，创建Option对象的时候就要显式地指定。

　　下面是使用CLI的步骤。

// … // ① 创建一个Options： Options options = new Options(); options.addOption("t", false, "current time"); // … // ② 创建一个解析器，分析输入： CommandLineParser parser = new BasicParser(); CommandLine cmd; try { cmd = parser.parse(options, args); } catch (ParseException pe) { usage(options); return; } // … // ③ 最后就可以根据用户的输入，采取相应的操作： if (cmd.hasOption("n")) { System.err.println("Nice to meet you: " + cmd.getOptionValue('n')); }

　　这就是使用CLI的完整过程了。当然，CLI还提供了其他高级选项，例如控制格式和解析过程等，但基本的使用思路仍是一致的。请参见本文最后提供的示例程序。

　　2.2 Discovery

　　■ 概况：Discovery组件是发现模式（Discovery Pattern）的一个实现，它的目标是按照一种统一的方式定位和实例化类以及其他资源。

　　■ 官方资源：主页，二进制，源代码。

　　■ 何时适用：当你想用最佳的算法在Java程序中查找Java接口的各种实现之时。

　　■ 应用实例：DiscoveryDemo.java，MyInterface.java，MyImpl1.java，MyImpl2.java，MyInterface。要求CLASSPATH中必须包含commons-discovery.jar和commons-logging.jar。

　　■ 说明：

　　Discovery的意思就是"发现"，它试图用最佳的算法查找某个接口的所有已知的实现。在使用服务的场合，当我们想要查找某个服务的所有已知的提供者时，Discovery组件尤其有用。

　　考虑一下这种情形：我们为某个特别复杂的任务编写了一个接口，所有该接口的实现都用各不相同的方式来完成这个复杂任务，最终用户可以根据需要来选择完成任务的具体方式。那么，在这种情形下，最终用户应该用什么办法来找出接口的所有可用实现（即可能的完成任务的方式）呢？

　　上面描述的情形就是所谓的服务-服务提供者体系。服务的功能由接口描述，服务提供者则提供具体的实现。现在的问题是最终用户要用某种办法来寻找系统中已经安装了哪些服务提供者。在这种情形下，Discovery组件就很有用了，它不仅可以用来查找那些实现了特定接口的类，而且还可以用来查找资源，例如图片或其他文件等。在执行这些操作时，Discovery遵从Sun的服务提供者体系所定义的规则。

　　由于这个原因，使用Discovery组件确实带来许多方便。请读者参阅本文后面示例程序中的接口MyInterface.java和两个实现类MyImpl1.java、MyImple2.java，了解下面例子的细节。在使用Discovery的时候要提供MyInterface文件，把它放入META-INF/services目录，注意该文件的名字对应接口的完整限定名称（Fully Qualified Name），如果接口属于某个包，该文件的名字也必须相应地改变。

// … // ① 创建一个类装入器的实例。 ClassLoaders loaders = ClassLoaders.getAppLoaders(MyInterface.class, getClass(), false); // … // ② 用DiscoverClass的实例来查找实现类。 DiscoverClass discover = new DiscoverClass(loaders); // … // ③ 查找实现了指定接口的类： Class implClass = discover.find(MyInterface.class); System.err.println("Implementing Provider: " + implClass.getName());

　　运行上面的代码，就可以得到在MyInterface文件中注册的类。再次提醒，如果你的实现是封装在包里面的，在这里注册的名字也应该作相应地修改，如果该文件没有放在正确的位置，或者指定名字的实现类不能找到或实例化，程序将抛出DiscoverException，表示找不到符合条件的实现。下面是MyInterface文件内容的一个例子：MyImpl2 # Implementation 2。

　　当然，实现类的注册办法并非只有这么一种，否则的话Discovery的实用性就要大打折扣了！实际上，按照Discovery内部的类查找机制，按照这种方法注册的类将是Discovery最后找到的类。另一种常用的注册方法是通过系统属性或用户定义的属性来传递实现类的名字，例如，放弃META-INF/services目录下的文件，改为执行java -DMyInterface=MyImpl1 DiscoveryDemo命令来运行示例程序，这里的系统属性是接口的名字，值是该接口的提供者，运行的结果是完全一样的。

　　Discovery还可以用来创建服务提供者的(singleton)实例并调用其方法，语法如下：((MyInterface)discover.newInstance(MyInterface.class)).myMethod();。注意在这个例子中，我们并不知道到底哪一个服务提供者实现了myMethod，甚至我们根本不必关心这一点。具体的情形与运行这段代码的方式以及运行环境中已经注册了什么服务提供者有关，在不同的环境下运行，实际得到的服务提供者可能不同。

　　2.3 Lang

　　■ 概况：Lang是java.lang的一个扩展包，增加了许多操作String的功能，另外还支持C风格的枚举量。

　　■ 官方资源：主页，二进制，源代码。

　　■ 何时适用：当java.lang包提供的方法未能满足需要，想要更多的功能来处理String、数值和System属性时；还有，当你想要使用C风格的枚举量时。

　　■ 示例应用：LangDemo.java，Mortgage.java，OnTV.java。CLASSPATH中必须包含commons-lang.jar。

　　■ 说明：

　　这个包提供了许多出于方便目的而提供的方法，它们中的大多数是静态的，简化了日常编码工作。StringUtils类是其中的一个代表，它使得开发者能够超越标准的java.lang.String包来处理字符串。使用这些方法很简单，通常只要在调用静态方法时提供适当的参数就可以了。例如，如果要将某个单词的首字符改为大写，只需调用：StringUtils.capitalise("name")，调用的输出结果是Name。请浏览StringUtils API文档了解其他静态方法，也许你会找到一些可以直接拿来使用的代码。本文提供的示例程序示范了其中一些方法的使用。

　　另一个值得注意的类是RandomStringUtils，它提供了生成随机字符串的方法，用来创建随机密码实在太方便了。

　　NumberUtils类提供了处理数值数据的方法，许多方法值得一用，例如寻找最大、最小数的方法，将String转换成数值的方法，等等。NumberRange和CharRange类分别提供了创建和操作数值范围、字符范围的方法。

　　Builder包里的类提供了一些特殊的方法，可用来构造类的toString、hashCode、compareTo和equals方法，其基本思路就是构造出类的高质量的toString、hashCode、compareTo和equals方法，从而免去了用户自己定义这些方法之劳，只要调用一下Builder包里面的方法就可以了。例如，我们可以用ToStringBuilder来构造出类的toString描述，如下例所示：

public class Mortgage { private float rate; private int years; .... public String toString() { return new ToStringBuilder(this). append("rate", this.rate). append("years", this.years). toString(); } }

　　Java没有C风格的枚举量，为此，lang包提供了一个类型安全的Enum类型，填补了空白。Enum类是抽象的，如果你要创建枚举量，就要扩展Enum类。下面的例子清楚地说明了Enum的用法。

import org.apache.commons.lang.enum.Enum; import java.util.Map; import java.util.List; import java.util.Iterator; public final class OnTV extends Enum { public static final OnTV IDOL= new OnTV("Idol"); public static final OnTV SURVIVOR = new OnTV("Survivor"); public static final OnTV SEINFELD = new OnTV("Seinfeld"); private OnTV(String show) { super(show); } public static OnTV getEnum(String show){ return (OnTV) getEnum(OnTV.class, show); } public static Map getEnumMap() { return getEnumMap(OnTV.class); } public static List getEnumList() { return getEnumList(OnTV.class); } public static Iterator iterator() { return iterator(OnTV.class); } }

　　以后我们就可以按照下面的方式使用枚举变量：OnTV.getEnum("Idol")。该调用从前面创建的枚举数据类型返回Idol。这个例子比较简单，实际上Enum类还提供了许多有用的方法，请参见本文后面提供的完整实例。

　　2.4 Collections

　　■ 概况：扩展了Java Collection框架，增添了新的数据结构、迭代机制和比较操作符。

　　■ 官方资源：主页，二进制，源代码。

　　■ 何时适用：几乎所有需要操作数据结构的重要Java开发项目都可以使用Collections API。和Java的标准实现相比，Collections API有着诸多优势。

　　■ 示例应用：CollectionsDemo.java。要求CLASSPATH中包含commons-collections.jar。

　　■ 说明：

　　要在有限的文章篇幅之内详尽地介绍 Collections API实在是太困难了，不过这里仍将涵盖大多数最重要的类，希望能够引起你的兴趣，认真了解一下其余的类。Collections本身的文档也提供了许多资料并解释了每一个类的用法。

　　Bag接口扩展标准的Java Collection，允许生成计数器来跟踪Bag里面的所有元素。当你想要跟踪进出某个集合的元素的总数时，Bag是非常有用的。由于Bag本身是一个接口，所以实际使用的应该是实现了该接口的类，例如HashBag或TreeBag--从这些类的名字也可以看出，HashBag实现的是一个HashMap的Bag，而TreeBag实现的是TreeMap的Bag。Bag接口中两个最重要的方法是：getCount(Object o)，用来返回Bag里面特定对象的出现次数；uniqueSet()，返回所有唯一元素。

　　Buffer接口允许按照预定义的次序删除集合中的对象，删除次序可以是LIFO（Last In First Out，后进先出），或FIFO（First In First Out，先进先出），另外还可以是自定义的次序。下面来看看如何实现一个Buffer，按照自然次序删除元素。

　　BinaryHeap类实现了Buffer接口，能够按照自然次序删除元素。如果要颠倒次序，则必须传入一个false，告诉Heap采用自然次序的逆序。

BinaryHeap heap = new BinaryHeap(); // … // 将元素加入该Heap heap.add(new Integer(-1)); heap.add(new Integer(-10)); heap.add(new Integer(0)); heap.add(new Integer(-3)); heap.add(new Integer(5)); //… // 删除一个元素 heap.remove();

　　调用该Heap的remove，按照自然次序，元素集合中的-10将被删除。如果我们要求按照逆序排序，则被删除的将是5。

　　FastArrayList、FastHashMap和FastTreeMap类能够按照两种模式操作，超越了与它们对应的标准Collection。第一种模式是"慢模式"，类的修改操作（添加、删除元素）是同步的。与此相对，另一种模式是"快模式"，对这些类的访问假定为只读操作，因此不需要同步，速度较快。在快模式中，结构性的改动通过下列方式完成：首先克隆现有的类，修改克隆得到的类，最后用克隆得到的类替换原有的类。FastArrayList、FastHashMap和FastTreeMap类特别适合于那种初始化之后大部分操作都是只读操作的多线程环境。

　　iterators包为各种集合和对象提供标准Java Collection包没有提供的迭代器。本文的示例应用示范了ArrayIterator，通过迭代方式访问Array的内容。iterators包里面各种迭代器的用法基本上与标准Java迭代器一样。

　　最后，comparators包提供了一些实用的比较符。所谓比较符其实也是一个类，它定义的是如何比较两个属于同一类的对象，决定它们的排序次序。例如，在前面提到的Buffer类中，我们可以定义自己的比较符，用自定义的比较符来决定元素的排序次序，而不是采用元素的自然排序次序。下面来看看具体的实现经过。

// … // ① 创建一个BinaryHeap类，但这一次参数中 // 指定NullComparator。NullComparator比较 // null与其他对象，根据nullsAreHigh标记来 // 判断null值比其他对象大还是小：如果 // nullsAreHigh的值是false，则认为null要比 // 其他对象小。 BinaryHeap heap2 = new BinaryHeap (new NullComparator(false)); // … // ② 将一些数据（包括几个null值）加入heap： heap2.add(null); heap2.add(new Integer("6")); heap2.add(new Integer("-6")); heap2.add(null); // … // ③ 最后删除一个元素，Bag包含的null将减少 // 一个，因为null要比其他对象小。 heap2.remove();

　　有关其他类Commons组件的介绍就到这里结束。如果你想了解更多细节信息，请参见API文档，最好再看看这些包的源代码。

　　三、Web类

　　Web类的组件用来执行与Web相关的任务。

　　3.1 FileUpload

　　■ 概况：一个可以直接使用的文件上载组件。

　　■ 官方资源：主页。由于这个组件尚未正式发布，今年二月发布的Beta版又有许多BUG，所以建议从nightly builds下载最新的版本。

　　■ 何时适用：当你想要在Java服务器环境中加入一个易用、高性能的文件上载组件之时。

　　■ 示例应用：fileuploaddemo.jsp，fileuploaddemo.htm，和msg.jsp。要求服务器端应用目录的WEB-INF/lib下面有commons-fileupload-1.0-dev.jar。

　　■ 说明：

　　FileUpload组件解决了常见的文件上载问题。它提供了一个易用的接口来管理上载到服务器的文件，可用于JSP和Servlet之中。FileUpload组件遵从RFC1867，它分析输入请求，向应用程序提供一系列上载到服务器的文件。上载的文件可以保留在内存中，也可以放入一个临时位置（允许配置一个表示文件大小的参数，如果上载的文件超过了该参数指定的大小，则把文件写入一个临时位置）。另外还有一些参数可供配置，包括可接受的最大文件、临时文件的位置等。

　　下面介绍一下使用FileUpload组件的步骤。

　　首先创建一个HTML页面。注意，凡是要上载文件的表单都必须设置enctype属性，且属性的值必须是multipart/form-data，同时请求方法必须是POST。下面的表单除了上载两个文件，另外还有一个普通的文本输入框：

<form name="myform" action="fileuploaddemo.jsp" method="post" enctype="multipart/form-data"> 输入你的名字:<br /> <input type="text" name="name" size="15"/><br /> 图形:<br /> <input type="file" name="myimage"><br/> 文件:<br /> <input type="file" name="myfile"><br /><br /> <input type="submit" name="Submit" value="Submit your files"/>

　　接下来创建JSP页面。

// … // ① 检查输入请求是否为multipart的表单数据。 boolean isMultipart = FileUpload. isMultipartContent(request); // … // ② 为该请求创建一个句柄，通过它来解析请求。执行 // 解析后，所有的表单项目都保存在一个List中。 DiskFileUpload upload = new DiskFileUpload(); // 通过句柄解析请求，解析得到的项目保存在一个List中 List items = upload.parseRequest(request); // … // ③ 通过循环依次获得List里面的文件项目。要区分表示 // 文件的项目和普通的表单输入项目，使用isFormField() // 方法。根据处理请求的要求，我们可以保存上载的文 // 件，或者一个字节一个字节地处理文件内容，或者打 // 开文件的输入流。 Iterator itr = items.iterator(); while(itr.hasNext()) { FileItem item = (FileItem) itr.next(); // 检查当前的项目是普通的表单元素，还是一个上载的文件 if(item.isFormField()) { // 获得表单域的名字 String fieldName = item.getFieldName(); // 如果表单域的名字是name… if(fieldName.equals("name")) request.setAttribute("msg", "Thank You: " + item.getString()); } else { // 该项目是一个上载的文件，把它保存到磁盘。 // 注意item.getName() // 会返回上载文件在客户端的完整路径名称，这似乎是一个BUG。 // 为解决这个问题，这里使用了fullFile.getName()。 File fullFile = new File(item.getName()); File savedFile = new File (getServletContext().getRealPath("/"), fullFile.getName()); item.write(savedFile); } }

　　我们可以通过上载句柄的upload.setSizeMax来限制上载文件的大小。当上载文件的大小超过允许的值时，程序将遇到异常。在上面的例子中，文件大小的限制值是-1，表示允许上载任意大小的文件。

　　还有其他一些略有变化的使用形式，正如前面所指出的，我们可以在上载的文件上打开一个输入流，或者让它们驻留在内存中直至空间占用达到一定的限制值，或者在判断文件类型的基础上，以String或Byte数组的形式获取其内容，或者直接删除文件。这一切都只要使用FileItem类提供的方法就可以方便地做到（DefaultFileItem是FileItem的一个实现）。
3.2 HttpClient

　　■ 概况：这个API扩展了java.net包，提供了模拟浏览器的功能。

　　■ 官方资源：主页，二进制，源代码。

　　■ 何时适用：当你要构造Web浏览器的功能；当你的应用需要一种高效的办法进行HTTP/HTTPS通信时。

　　■ 示例应用：HttpClientDemo.java。要求CLASSPATH中有commons-httpclient.jar，common-logging.jar。要求使用JDK 1.4或更高版本。

　　■ 说明：

　　HttpClient扩展和增强了标准java.net包，是一个内容广泛的代码库，功能极其丰富，能够构造出各种使用HTTP协议的分布式应用，或者也可以嵌入到现有应用，为应用增加访问HTTP协议的能力。在Commons稳定版中，HttpClient的文档似乎要比其他包更完善一些，而且还带有几个实例。下面我们通过一个简单的例子来了解如何提取一个Web页面，HttpClient文档中也有一个类似的例子，我们将扩充那个例子使其支持SSL。注意本例需要JDK 1.4支持，因为它要用到Java Secure Socket Connection库，而这个库只有JDK 1.4及更高的版本才提供。

　　① 首先确定一个可以通过HTTPS下载的页面，本例使用的是https://www.paypal.com/。同时确保%JAVA_HOME%/jre/lib/security/java.security文件包含了下面这行代码：security.provider.2=com.sun.net.ssl.internal.ssl.Provider。

　　除了这些设置之外，HTTPS连接的处理方式没有其他特别的地方--至少对于本例来说如此。不过，如果远程网站使用的根证书不被你使用的Java认可，则首先必须导入它的证书。

　　② 创建一个HttpClient的实例。HttpClient类可以看成是应用的主驱动程序，所有针对网络的功能都依赖于它。HttpClient类需要一个Connection Manager来管理连接。HttpConnectionManager允许我们创建自己的连接管理器，或者，我们也可以直接使用内建的SimpleHttpConnectionManager或MultiThreadedHttpConnectionManager类。如果在创建HttpClient时没有指定连接管理器，HttpClient默认使用SimpleHttpConnectionManager。

// 创建一个HttpClient的实例 HttpClient client = new HttpClient();

　　③ 创建一个HttpMethod的实例，即确定与远程服务器的通信要采用哪种传输方式，HTTP允许采用的传输方式包括：GET，POST，PUT，DELETE，HEAD，OPTIONS，以及TRACE。这些传输方式分别作为一个独立的类实现，但所有这些类都实现HttpMethod接口。在本例中，我们使用的是GetMethod，创建GetMethod实例时在参数中指定我们想要GET的URL。

// 创建一个HttpMethod的实例 HttpMethod method = new GetMethod(url);

　　④ 执行HttpMethod定义的提取操作。执行完毕后，executeMethod方法将返回远程服务器报告的状态代码。注意executeMethod属于HttpClient，而不是HttpMethod。

// 执行HttpMethod定义的提取操作 statusCode = client.executeMethod(method);

　　⑤ 读取服务器返回的应答。如果前面的连接操作失败，程序将遇到HttpException或IOException，其中IOException一般意味着网络出错，继续尝试也不太可能获得成功。服务器返回的应答可以按照多种方式读取，例如作为一个字节数组，作为一个输入流，或者作为一个String。获得服务器返回的应答后，我们就可以按照自己的需要任意处置它了。

byte[] responseBody = method.getResponseBody();

　　⑥ 最后要做的就是释放连接。

method.releaseConnection();

　　以上只是非常简单地介绍了一下HttpClient库，HttpClient实际的功能要比本文介绍的丰富得多，不仅健壮而且高效，请参阅API文档了解详情。

　　3.3 Net

　　■ 概况：一个用于操作Internet基础协议的底层API。

　　■ 官方资源：主页，二进制，源代码。

　　■ 何时适用：当你想要访问各种Internet底层协议之时（Finger，Whois，TFTP，Telnet，POP3，FTP，NNTP，以及SMTP）。

　　■ 示例应用：NetDemo.java。要求CLASSPATH中包含commons-net-1.0.0.jar。

　　■ 说明：

　　Net包是一个强大、专业的类库，类库里的类最初属于一个叫做NetComponents的商业产品。

　　Net包不仅支持对各种低层次协议的访问，而且还提供了一个高层的抽象。大多数情况下，Net包提供的抽象已能满足一般需要，它使得开发者不再需要直接面对各种协议的Socket级的低层命令。使用高层抽象并不减少任何功能，Net API在这方面做得很出色，既提供了足够的功能，又不至于在特色方面作过多的妥协。

　　SocketClient是支持所有协议的基础类，它是一个抽象类，聚合了各种协议都需要的公用功能。各种不同协议的使用过程其实很相似，首先利用connect方法建立一个指向远程服务器的连接，执行必要的操作，最后终止与服务器的连接。下面通过实例介绍具体的使用步骤。

// … // ① 创建一个客户端。我们将用NNTPClient //　　从新闻服务器下载新闻组清单。 client = new NNTPClient(); // … // ② 利用前面创建的客户端连接到新闻服务器。 //　　这里选用的是一个新闻组较少的服务器。 client.connect("aurelia.deine.net"); // … // ③ 提取新闻组清单。下面的命令将返回一个 //　　NewsGroupInfo对象的数组。如果指定的服 //　　务器上不包含新闻组，返回的数组将是空的， //　　如果遇到了错误，则返回值是null。 list = client.listNewsgroups(); //... // ④ 最后终止与服务器的连接。 if (client.isConnected()) client.disconnect();

　　必须说明的是，listNewsgroups命令可能需要较长的时间才能返回，一方面是因为网络速度的影响，另外也可能是由于新闻组清单往往是很庞大的。NewsGroupInfo对象包含有关新闻组的详细信息，并提供了一些操作新闻组的命令，比如提取文章总数、最后发布的文章、发布文章的权限，等等。

　　其他客户端，例如FingerClient、POP3Client、TelnetClient等，用法也差不多。

　　结束语：有关Web相关类和其他类的介绍就到此结束。在下一篇文章中，我们将探讨XML类和包装类，最后一篇文章则介绍工具类。

　　希望读者有兴趣试试本文提供的程序实例。很多时候Jakarta Commons给人以混乱的感觉，希望本文使你加深了对Jakarta Commons了解，或者至少引起了你对Commons子项目以及它提供的各种实用API和库的兴趣。

作者：Sun Microsystems, Inc. 的 Norbert Lindenberg 和 Masayoshi Okutsu

2004 年 5 月

English: Supplementary Characters in the Java Platform
日本語: Java プラットフォームにおける補助文字のサポート

摘要

本文介绍 Java 平台支持增补字符的方式。增补字符是 Unicode 标准中代码点超出 U+FFFF 的字符，因此它们无法在 Java 编程语言中描述为单个的 16 位实体（例如 char 数据类型）。这些字符一般极少用，但是，有些会在诸如中文或日文人名中用到，因此，在东亚国家，政府应用程序通常会要求支持这些字符。

Java 平台目前正在改进，以便支持对增补字符的处理，这种改进对现有的应用程序影响微乎其微。新的低层 API 在需要时能够使用单个的字符运行。不过，大多数文本处理 API 均使用字符序列，例如 String 类或字符数组。现在，这些均解释为 UTF-16 序列，而且，这些 API 实现已转变为正确地处理增补字符。这些改进已融入 Java 2 平台 5.0 版，标准版 (J2SE)。

除详细解释这些改进之外，本文同时为应用程序开发人员确定和实现必要的更改提供指导，以支持整个 Unicode 字符集的使用。

背景

Unicode 最初设计是作为一种固定宽度的 16 位字符编码。在 Java 编程语言中，基本数据类型 char 初衷是通过提供一种简单的、能够包含任何字符的数据类型来充分利用这种设计的优点。不过，现在看来，16 位编码的所有 65,536 个字符并不能完全表示全世界所有正在使用或曾经使用的字符。于是，Unicode 标准已扩展到包含多达 1,112,064 个字符。那些超出原来的 16 位限制的字符被称作增补字符。Unicode 标准 2.0 版是第一个包含启用增补字符设计的版本，但是，直到 3.1 版才收入第一批增补字符集。由于 J2SE 的 5.0 版必须支持 Unicode 标准 4.0 版，因此它必须支持增补字符。

对增补字符的支持也可能会成为东亚市场的一个普遍商业要求。政府应用程序会需要这些增补字符，以正确表示一些包含罕见中文字符的姓名。出版应用程序可能会需要这些增补字符，以表示所有的古代字符和变体字符。中国政府要求支持 GB18030（一种对整个 Unicode 字符集进行编码的字符编码标准），因此，如果是 Unicode 3.1 版或更新版本，则将包括增补字符。台湾标准 CNS-11643 包含的许多字符在 Unicode 3.1 中列为增补字符。香港政府定义了一种针对粤语的字符集，其中的一些字符是 Unicode 中的增补字符。最后，日本的一些供应商正计划利用增补字符空间中大量的专用空间收入 50,000 多个日文汉字字符变体，以便从其专有系统迁移至基于 Java 平台的解决方案。

因此，Java 平台不仅需要支持增补字符，而且必须使应用程序能够方便地做到这一点。由于增补字符打破了 Java 编程语言的基础设计构想，而且可能要求对编程模型进行根本性的修改，因此，Java Community Process 召集了一个专家组，以期找到一个适当的解决方案。该小组被称为 JSR-204 专家组，使用 Unicode 增补字符支持的 Java 技术规范请求的编号。从技术上来说，该专家组的决定仅适用于 J2SE 平台，但是由于 Java 2 平台企业版 (J2EE) 处于 J2SE 平台的最上层，因此它可以直接受益，我们期望 Java 2 平台袖珍版 (J2ME) 的配置也采用相同的设计方法。

不过，在了解 JSR-204 专家组确定的解决方案之前，我们需要先理解一些术语。

代码点、字符编码方案、UTF-16：这些是指什么？

不幸的是，引入增补字符使字符模型变得更加复杂了。在过去，我们可以简单地说“字符”，在一个基于 Unicode 的环境（例如 Java 平台）中，假定字符有 16 位，而现在我们需要更多的术语。我们会尽量介绍得相对简单一些 — 如需了解所有详细的讨论信息，您可以阅读 Unicode 标准第 2 章或 Unicode 技术报告 17“字符编码模型”。Unicode 专业人士可略过所有介绍直接参阅本部分中的最后定义。

字符是抽象的最小文本单位。它没有固定的形状（可能是一个字形），而且没有值。“A”是一个字符，“€”（德国、法国和许多其他欧洲国家通用货币的标志）也是一个字符。

字符集是字符的集合。例如，汉字字符是中国人最先发明的字符，在中文、日文、韩文和越南文的书写中使用。

编码字符集是一个字符集，它为每一个字符分配一个唯一数字。Unicode 标准的核心是一个编码字符集，字母“A”的编码为 0041₁₆ 和字符“€”的编码为 20AC₁₆。Unicode 标准始终使用十六进制数字，而且在书写时在前面加上前缀“U+”，所以“A”的编码书写为“U+0041”。

代码点是指可用于编码字符集的数字。编码字符集定义一个有效的代码点范围，但是并不一定将字符分配给所有这些代码点。有效的 Unicode 代码点范围是 U+0000 至 U+10FFFF。Unicode 4.0 将字符分配给一百多万个代码点中的 96,382 代码点。

增补字符是代码点在 U+10000 至 U+10FFFF 范围之间的字符，也就是那些使用原始的 Unicode 的 16 位设计无法表示的字符。从 U+0000 至 U+FFFF 之间的字符集有时候被称为基本多语言面 (BMP)。因此，每一个 Unicode 字符要么属于 BMP，要么属于增补字符。

字符编码方案是从一个或多个编码字符集到一个或多个固定宽度代码单元序列的映射。最常用的代码单元是字节，但是 16 位或 32 位整数也可用于内部处理。UTF-32、UTF-16 和 UTF-8 是 Unicode 标准的编码字符集的字符编码方案。

UTF-32 即将每一个 Unicode 代码点表示为相同值的 32 位整数。很明显，它是内部处理最方便的表达方式，但是，如果作为一般字符串表达方式，则要消耗更多的内存。

UTF-16 使用一个或两个未分配的 16 位代码单元的序列对 Unicode 代码点进行编码。值 U+0000 至 U+FFFF 编码为一个相同值的 16 位单元。增补字符编码为两个代码单元，第一个单元来自于高代理范围（U+D800 至 U+DBFF），第二个单元来自于低代理范围（U+DC00 至 U+DFFF）。这在概念上可能看起来类似于多字节编码，但是其中有一个重要区别：值 U+D800 至 U+DFFF 保留用于 UTF-16；没有这些值分配字符作为代码点。这意味着，对于一个字符串中的每个单独的代码单元，软件可以识别是否该代码单元表示某个单单元字符，或者是否该代码单元是某个双单元字符的第一个或第二单元。这相当于某些传统的多字节字符编码来说是一个显著的改进，在传统的多字节字符编码中，字节值 0x41 既可能表示字母“A”，也可能是一个双字节字符的第二个字节。

UTF-8 使用一至四个字节的序列对编码 Unicode 代码点进行编码。U+0000 至 U+007F 使用一个字节编码，U+0080 至 U+07FF 使用两个字节，U+0800 至 U+FFFF 使用三个字节，而 U+10000 至 U+10FFFF 使用四个字节。UTF-8 设计原理为：字节值 0x00 至 0x7F 始终表示代码点 U+0000 至 U+007F（Basic Latin 字符子集，它对应 ASCII 字符集）。这些字节值永远不会表示其他代码点，这一特性使 UTF-8 可以很方便地在软件中将特殊的含义赋予某些 ASCII 字符。

下表所示为几个字符不同表达方式的比较：

Unicode 代码点	U+0041	U+00DF	U+6771	U+10400
表示字形
UTF-32 代码单元	00000041	000000DF	00006771	00010400
UTF-16 代码单元	0041	00DF	6771	D801 DC00
UTF-8 代码单元	41	C3 9F	E6 9D B1	F0 90 90 80

另外，本文在许多地方使用术语字符序列或 char 序列概括 Java 2 平台识别的所有字符序列的容器：char[], java.lang.CharSequence 的实现（例如 String 类），和 java.text.CharacterIterator 的实现。

这么多术语。它们与在 Java 平台中支持增补字符有什么关系呢？

Java 平台中增补字符的设计方法

JSR-204 专家组必须作出的主要决定是如何在 Java API 中表示增补字符，包括单个字符和所有形式的字符序列。专家组考虑并排除了多种方法：

• 重新定义基本类型 char，使其具有 32 位，这样也会使所有形式的 char 序列成为 UTF-32 序列。
• 在现有的 16 位类型 char 的基础上，为字符引入一种新的 32 位基本类型（例如，char32）。所有形式的 Char 序列均基于 UTF-16。
• 在现有的 16 位类型 char 的基础上，为字符引入一种新的 32 位基本类型（例如，char32）。String 和 StringBuffer 接受并行 API，并将它们解释为 UTF-16 序列或 UTF-32 序列；其他 char 序列继续基于 UTF-16。
• 使用 int 表示增补的代码点。String 和 StringBuffer 接受并行 API，并将它们解释为 UTF-16 序列或 UTF-32 序列；其他 char 序列继续基于 UTF-16。
• 使用代理 char 对，表示增补代码点。所有形式的 char 序列基于 UTF-16。
• 引入一种封装字符的类。String 和 StringBuffer 接受新的 API，并将它们解释为此类字符的序列。
• 使用一个 CharSequence 实例和一个索引的组合表示代码点。

在这些方法中，一些在早期就被排除了。例如，重新定义基本类型 char，使其具有 32 位，这对于全新的平台可能会非常有吸引力，但是，对于 J2SE 来说，它会与现有的 Java 虚拟机¹、序列化和其他接口不兼容，更不用说基于 UTF-32 的字符串要使用两倍于基于 UTF-16 的字符串的内存了。添加一种新类型的 char32 可能会简单一些，但是仍然会出现虚拟机和序列化方面的问题。而且，语言更改通常需要比 API 更改有更长的提前期，因此，前面两种方法会对增补字符支持带来无法接受的延迟。为了在余下的方法中筛选出最优方案，实现小组使用四种不同的方法，在大量进行低层字符处理的代码（java.util.regex 包）中实现了对增补字符支持，并对这四种方法的难易程度和运行表现进行了比较。

最终，专家组确定了一种分层的方法：

• 使用基本类型 int 在低层 API 中表示代码点，例如 Character 类的静态方法。
• 将所有形式的 char 序列均解释为 UTF-16 序列，并促进其在更高层级 API 中的使用。
• 提供 API，以方便在各种 char 和基于代码点的表示法之间的转换。

在需要时，此方法既能够提供一种概念简明且高效的单个字符表示法，又能够充分利用通过改进可支持增补字符的现有 API。同时，还能够促进字符序列在单个字符上的应用，这一点一般对于国际化的软件很有好处。

在这种方法中，一个 char 表示一个 UTF-16 代码单元，这样对于表示代码点有时并不够用。您会注意到，J2SE 技术规范现在使用术语代码点和 UTF-16 代码单元（表示法是相关的）以及通用术语字符（表示法与该讨论没有关系）。API 通常使用名称 codePoint 描述表示代码点的类型 int 的变量，而 UTF-16 代码单元的类型当然为 char。

我们将在下面两部分中了解到 J2SE 平台的实质变化 — 其中一部分介绍单个代码点的低层 API，另一部分介绍采用字符序列的高层接口。

开放的增补字符：基于代码点的 API

新增的低层 API 分为两大类：用于各种 char 和基于代码点的表示法之间转换的方法和用于分析和映射代码点的方法。

最基本的转换方法是 Character.toCodePoint(char high, char low)（用于将两个 UTF-16 代码单元转换为一个代码点）和 Character.toChars(int codePoint)（用于将指定的代码点转换为一个或两个 UTF-16 代码单元，然后封装到一个 char[] 内。不过，由于大多数情况下文本以字符序列的形式出现，因此，另外提供 codePointAt 和 codePointBefore 方法，用于将代码点从各种字符序列表示法中提取出来：Character.codePointAt(char[] a, int index) 和 String.codePointBefore(int index) 是两种典型的例子。在将代码点插入字符序列时，大多数情况下均有一些针对 StringBuffer 和 StringBuilder 类的 appendCodePoint(int codePoint) 方法，以及一个用于提取表示代码点的 int[] 的 String 构建器。

几种用于分析代码单元和代码点的方法有助于转换过程：Character 类中的 isHighSurrogate 和 isLowSurrogate 方法可以识别用于表示增补字符的 char 值；charCount(int codePoint) 方法可以确定是否需要将某个代码点转换为一个或两个 char。

但是，大多数基于代码点的方法均能够对所有 Unicode 字符实现基于 char 的旧方法对 BMP 字符所实现的功能。以下是一些典型例子：

• Character.isLetter(int codePoint) 可根据 Unicode 标准识别字母。
• Character.isJavaIdentifierStart(int codePoint) 可根据 Java 语言规范确定代码点是否可以启动标识符。
• Character.UnicodeBlock.of(int codePoint) 可搜索代码点所属的 Unicode 字符子集。
• Character.toUpperCase(int codePoint) 可将给定的代码点转换为其大写等值字符。尽管此方法能够支持增补字符，但是它仍然不能解决根本的问题，即在某些情况下，逐个字符的转换无法正确完成。例如，德文字符“"ß"”应该转换为“SS”，这需要使用 String.toUpperCase 方法。

注意大多数接受代码点的方法并不检查给定的 int 值是否处于有效的 Unicode 代码点范围之内（如上所述，只有 0x0 至 0x10FFFF 之间的范围是有效的）。在大多数情况下，该值是以确保其有效的方法产生的，在这些低层 API 中反复检查其有效性可能会对系统性能造成负面的影响。在无法确保有效性的情况下，应用程序必须使用 Character.isValidCodePoint 方法确保代码点有效。大多数方法对于无效的代码点采取的行为没有特别加以指定，不同的实现可能会有所不同。

API 包含许多简便的方法，这些方法可使用其他低层的 API 实现，但是专家组觉得，这些方法很常用，将它们添加到 J2SE 平台上很有意义。不过，专家组也排除了一些建议的简便方法，这给我们提供了一次展示自己实现此类方法能力的机会。例如，专家组经过讨论，排除了一种针对 String 类的新构建器（该构建器可以创建一个保持单个代码点的 String）。以下是使应用程序使用现有的 API 提供功能的一种简便方法：

/**
 * 创建仅含有指定代码点的新 String。
 */
String newString(int codePoint) {
    return new String(Character.toChars(codePoint));
}

您会注意到，在这个简单的实现中，toChars 方法始终创建一个中间数列，该数列仅使用一次即立即丢弃。如果该方法在您的性能评估中出现，您可能会希望将其优化为针对最为普通的情况，即该代码点为 BMP 字符：

/**
 * 创建仅含有指定代码点的新 String。
 * 针对 BMP 字符优化的版本。
 */
String newString(int codePoint) {
    if (Character.charCount(codePoint) == 1) {
        return String.valueOf((char) codePoint);
    } else {
        return new String(Character.toChars(codePoint));
    }
}

或者，如果您需要创建许多个这样的 string，则可能希望编写一个重复使用 toChars 方法所使用的数列的通用版本：

/**
 * 创建每一个均含有一个指定
 * 代码点的新 String。
 * 针对 BMP 字符优化的版本。
 */
String[] newStrings(int[] codePoints) {
    String[] result = new String[codePoints.length];
    char[] codeUnits = new char[2];
    for (int i = 0; i < codePoints.length; i++) { 
         int count = Character.toChars(codePoints[i], codeUnits, 0); 
         result[i] = new String(codeUnits, 0, count);
    }
    return result;
}

不过，最终您可能会发现，您需要的是一个完全不同的解决方案。新的构建器 String(int codePoint) 实际上建议作为 String.valueOf(char) 的一个基于代码点的备选方案。在很多情况下，此方法用于消息生成的环境，例如：

System.out.println("Character " + String.valueOf(char) + " is invalid.");

新的格式化 API 支持增补文字，提供一种更加简单的备选方案：

System.out.printf("Character %c is invalid.%n", codePoint);

使用此高层 API 不仅简捷，而它有很多特殊的优点：它可以避免串联（串联会使消息很难本地化），并将需要移进资源包 (resource bundle) 的字符串数量从两个减少到一个。

增补字符透视：功能增强

在支持使用增补字符的 Java 2 平台中的大部分更改没有反映到新的 API 内。一般预期是，处理字符序列的所有接口将以适合其功能的方式处理增补字符。本部分着重讲述为达到此预期所作一些功能增强。

Java 编程语言中的标识符

Java 语言规范指出所有 Unicode 字母和数字均可用于标识符。许多增补字符是字母或数字，因此 Java 语言规范已经参照新的基于代码点的方法进行更新，以在标识符内定义合法字符。为使用这些新方法，需要检测标识符的 javac 编译器和其他工具都进行了修订。

库内的增补字符支持

许多 J2SE 库已经过增强，可以通过现有接口支持增补字符。以下是一些例子：

• 字符串大小写转换功能已更新，可以处理增补字符，也可以实现 Unicode 标准中规定的特殊大小写规则。
• java.util.regex 包已更新，这样模式字符串和目标字符串均可以包含增补字符并将其作为完整单元处理。
• 现在，在 java.text 包内进行整理处理时，会将增补字符看作完整单元。
• java.text.Bidi 类已更新，可以处理增补字符和 Unicode 4.0 中新增的其他字符。请注意，Cypriot Syllabary 字符子集内的增补字符具有从右至左的方向性。
• Java 2D API 内的字体渲染和打印技术已经过增强，可以正确渲染和测量包含增补字符的字符串。
• Swing 文本组件实现已更新，可以处理包含增补字符的文本。

字符转换

只有很少的字符编码可以表示增补字符。如果是基于 Unicode 的编码（如 UTF-8 和 UTF-16LE），则旧版的 J2RE 内的字符转换器已经按照正确处理增补字符的方式实现转换。对于 J2RE 5.0，可以表示增补字符的其他编码的转换器已更新：GB18030、x-EUC-TW（现在实现所有 CNS 11643 层面）和 Big5-HKSCS（现在实现 HKSCS-2001）。

在源文件内表示增补字符

在 Java 编程语言源文件中，如果使用可以直接表示增补字符的字符编码，则使用增补字符最为方便。UTF-8 是最佳的选择。在所使用的字符编码无法直接表示字符的情况下，Java 编程语言提供一种 Unicode 转义符语法。此语法没有经过增强，无法直接表示增补字符。而是使用两个连续的 Unicode 转义符将其表示为 UTF-16 字符表示法中的两个编码单元。例如，字符 U+20000 写作“\uD840\uDC00”。您也许不愿意探究这些转义序列的含义；最好是写入支持所需增补字符的编码，然后使用一种工具（如 native2ascii）将其转换为转义序列。

遗憾的是，由于其编码问题，属性文件仍局限于 ISO 8859-1（除非您的应用程序使用新的 XML 格式）。这意味着您始终必须对增补字符使用转义序列，而且可能要使用不同的编码进行编写，然后使用诸如 native2ascii 的工具进行转换。

经修订的 UTF-8

Java 平台对经修订的 UTF-8 已经很熟悉，但是，问题是应用程序开发人员在可能包含增补字符的文本和 UTF-8 之间进行转换时需要更加留神。需要特别注意的是，某些 J2SE 接口使用的编码与 UTF-8 相似但与其并不兼容。以前，此编码有时被称为“Java modified UTF-8”（经 Java 修订的 UTF-8） 或（错误地）直接称为“UTF-8”。对于 J2SE 5.0，其说明文档正在更新，此编码将统称为“modified UTF-8”（经修订的 UTF-8）。

经修订的 UTF-8 和标准 UTF-8 之间之所以不兼容，其原因有两点。其一，经修订的 UTF-8 将字符 U+0000 表示为双字节序列 0xC0 0x80，而标准 UTF-8 使用单字节值 0x0。其二，经修订的 UTF-8 通过对其 UTF-16 表示法的两个代理代码单元单独进行编码表示增补字符 。每个代理代码单元由三个字节来表示，共有六个字节。而标准 UTF-8 使用单个四字节序列表示整个字符。

Java 虚拟机及其附带的接口（如 Java 本机接口、多种工具接口或 Java 类文件）在 java.io.DataInput 和 DataOutput 接口和类中使用经修订的 UTF-8 实现或使用这些接口和类 ，并进行序列化。Java 本机接口提供与经修订的 UTF-8 之间进行转换的例程。而标准 UTF-8 由 String 类、java.io.InputStreamReader 和 OutputStreamWriter 类、java.nio.charset 设施 (facility) 以及许多其上层的 API 提供支持。

由于经修订的 UTF-8 与标准的 UTF-8 不兼容，因此切勿同时使用这两种版本的编码。经修订的 UTF-8 只能与上述的 Java 接口配合使用。在任何其他情况下，尤其对于可能来自非基于 Java 平台的软件的或可能通过其编译的数据流，必须使用标准的 UTF-8。需要使用标准的 UTF-8 时，则不能使用 Java 本机接口例程与经修订的 UTF-8 进行转换。

在应用程序内支持增补字符

现在，对大多数读者来说最为重要的问题是：必须对应用程序进行哪些更改才能支持增补字符？

答案取决于在应用程序中进行哪种类型的文本处理和使用哪些 Java 平台 API。

对于仅以各种形式 char 序列（[char[]、java.lang.CharSequence 实现、java.text.CharacterIterator 实现）处理文本和仅使用接受和退回序列（如 char 序列）的 Java API 的应用程序，可能根本不需要进行任何更改。Java 平台 API 的实现应该能够处理增补字符。

对于本身解释单个字符、将单个字符传送给 Java 平台 API 或调用能够返回单个字符的方法的应用程序，则需要考虑这些字符的有效值。在很多情况下，往往不要求支持增补字符。例如，如果某应用程序搜索 char 序列中的 HTML 标记，并逐一检查每个 char，它会知道这些标记仅使用 Basic Latin 字符子集中的字符。如果所搜索的文本含有增补字符，则这些字符不会与标记字符混淆，因为 UTF-16 使用代码单元表示增补字符，而代码单元的值不会用于 BMP 字符。

只有在某应用程序本身解释单个字符、将单个字符传送给 Java 平台 API 或调用能够返回单个字符的方法且这些字符可能为增补字符时，才必须更改该应用程序。在提供使用 char 序列的并行 API 时，最好转而使用此类 API。在其他情况下，有必要使用新的 API 在 char 和基于代码点的表示法之间进行转换，并调用基于代码点的 API。当然，如果您发现在 J2SE 5.0 中有更新、更方便的 API，使您能够支持增补字符并同时简化代码（如上 格式化范例 中所述），则没有必要这样做。

您可能会犹豫，是将所有文本转换为代码点表示法（即 int[]）然后在该表示法中处理，还是在大多数情况下仍采用 char 序列，仅在需要时转换为代码点，两者之间孰优孰劣很难确定。当然，总体来说，Java 平台 API 相对于 char 序列肯定具有一定的优势，而且采用 Java 平台 API 可以节省内存空间。

对于需要与 UTF-8 之间进行转换的应用程序，还需要认真考虑是需要标准的 UTF-8 还是经修订的 UTF-8，并针对每种 UTF-8 采用适当的 Java 平台。“经修订的 UTF-8”部分介绍进行正确选择所需的信息。

使用增补字符测试应用程序

经过前面部分的介绍后，无论您是否需要修订应用程序，测试应用程序是否运行正常始终是一种正确的做法。对于不含有图形用户界面的应用程序，有关“在源文件内表示增补字符”　的信息有助于设计测试用例。以下是有关使用图形用户界面进行测试的补充信息。

对于文本输入，Java 2 SDK 提供用于接受“\Uxxxxxx”格式字符串的代码点输入方法，这里大写的“U”表示转义序列包含六个十六进制数字，因此允许使用增补字符。小写的“u”表示转义序列“\uxxxx”的原始格式。您可以在 J2SDK 目录 demo/jfc/CodePointIM 内找到此输入方法及其说明文档。

对于字体渲染，您需要至少能够渲染一些增补字符的字体。其中一种此类字体为 James Kass 的 Code2001 字体，它提供手写体字形（如 Deseret 和 Old Italic）。利用 Java 2D 库中提供新功能，您只需将该字体安装到 J2RE 的 lib/fonts/fallback 目录内即可，然后它可自动添加至在 2D 和 XAWT 渲染时使用的所有逻辑字体 — 无需编辑字体配置文件。

至此，您就可以确认，您的应用程序能够完全支持增补字符了！

结论

对增补字符的支持已经引入 Java 平台，大部分应用程序无需更改代码即可处理这些字符。解释单个字符的应用程序可以在 Character 类和多种 CharSequence 子类中使用基于代码点的新 API。

鸣谢

Java 平台中的增补字符支持由 Java Community Process 的 JSR-204 专家组设计。技术规范设计主持为 Masayoshi Okutsu 和 Brian Beck (Sun Microsystems)，其他专家组成员有 Craig Cummings (Oracle)、Mark Davis (IBM)、Markus Eble (SAP AG)、Jere Käpyaho (Nokia Corp.)、Kazuhiro Kazama (NTT)、Kenji Kazumura (Fujitsu Limited)、Eiichi Kimura (NEC Corp.)、Changshin Lee (Tmax Soft Inc.) 和 Toshiki Murata (Oki Electric Industry Co.)。参考实现由 Sun Microsystems 的 Java Internationalization 团队完成，并承蒙位于圣何塞的 IBM Globalization Center of Competency 的协助。技术规范的技术兼容套件为 Java Compatibility Kit，由 Sun Microsystems 的 JCK 团队实现。

参考书目

Masayoshi Okutsu, Brian Beck (ed.): Unicode Supplementary Character Support. Proposed Final Draft. Sun Microsystems, 2004.

Java 2 Platform Standard Edition 5.0 API Specification. Sun Microsystems, 2004.

The Unicode Consortium: The Unicode Standard, Version 4.0. Addison-Wesley, 2003.

Ken Whistler, Mark Davis: Character Encoding Model. Unicode Technical Report #17. The Unicode Consortium, 2000.

James Kass: Code2001, a Plane 1 Unicode-based Font.

关于作者

Norbert Lindenberg 是 Sun Microsystems 的 Java Web Services 团队内 Java Internationalization 技术主管。在加盟 Sun 之前，曾经供职于 General Magic 和 Apple Computer，参与过多个国际化项目。他毕业于德国的卡尔斯鲁厄大学，拥有计算机科学理科硕士学位。

Masayoshi Okutsu 是 Sun Microsystems 的 Java Web Services 团队的一名国际化工程师，目前担任 Unicode Supplementary Character Support 的 Java Specification Request 204 的技术规范主管。在加盟 Sun Microsystems 之前，供职于 Digital Equipment Corporation，期间曾经参与多个国际化项目。他毕业于日本山形大学，拥有电子工程理学士学位。

1. configure web.xml,insert following tag:
   <init-param>
   <param-name>locale</param-name>
   <param-value>true</param-value>
   </init-param>
   codes above enable localization.
2. configure web.xml,insert following tag:
   <init-param>
   <param-name>application</param-name>
   <paramvalue>ApplicationResources</param-value>
   </init-param>
   codes above indicate where default resource(ApplicationResources.properties) file reside in.If a specific resource locale is required, the actionServlet will look for resource file named ApplicationResources_xx_XX.properties according to locale. for example:ApplicationResources_en_us.properties
   hint:the default path of resource file is WEB-INF/classes/.
3. using the struts framework locale object.
   after above two steps, struts stores a locale object in session context,you can get the object using following codes:
   Locale locale=(Locale)request.getSession().getAttribute(Action.LOCALE_KEY);
4. changing user's locale
   Since locale is immutable ,you must create a new locale object to replace existing one:
   Locale locale=new Locale(myForm.getLanguage(),myForm.getCountry());
   HttpSession session=request.getSession(true);
   session.setAttribute(Action.LOCALE_KEY,locale);
5. placing labels and messages in properties files.
6. creating language-specified properties file for every locale you will support. if properly named,these files will be loaded automatically.if the application can't find a key in the resource for a user's locale,it will use the resource for the default locale.
7. localization-aware components VS other components
   usually,most struts components support I18N automatically.for the components that do not have lacalization built in,you can usually use<bean:message> to provide localized message.
8. localizing other components: validation and tiles
   validation:all the labels and messages used by validator are linked to resource file and will be localized automatically.if additional localization be needed ,say to verify the format of a postal code or telephone number ,you can define a locale-specfic formset element like this:
   <form name="testform" locale="fr" country="CA">...
   tiles:you can define xml file according to locale like resource file :
   tiles_fr_CA.xml

-- ==================================================
-- 名称：得到单据流水号
-- 实现功能：取得对应表的计数器，实现流水号功能．
-- 调用示例：SELECT F_LT_GetOrderNo(FId) as FID, * from Tab1 T1
                    left outer join T_OrderList T2 on T1.FTabID = T2.FID
-- ==================================================
CREATE TABLE T_OrderList(
FID int IDENTITY (1, 1) NOT NULL,
FIncCount int -- 计数器
)

CREATE FUNCTION F_LT_GetOrderNo(@ID int)
AS RETURN VARCHAR(32)
DECLARE @OrderNo int
SELECT @OrderNo = FIncCount FROM T_OrderList WHERE FID = @ID
    -- 取得编号后，计数器加１
UPDATE T_OrderList SET FIncCount = FIncCount +1 -- 函数中不允许执行UPDATE，这种情况要怎么处理．
RETURNS @OrderNo

-- 系统单据表，存放系统所以业务单据列表，存有生成流水号计数器
CREATE  TABLE  T_OrderList( 
           FID  int  IDENTITY  (1,  1)  NOT  NULL, 
           FIncCount  int  --  计数器 
           FOrder varchar(30) not Null
           ) 

-- 系统业务单据，存放企业日常业务数据，具体每单有一个单据流水号
CREATE  TABLE  T_Order( 
           FID  int  IDENTITY  (1,  1)  NOT  NULL, 
           FNumber varchar(40),  -- 单据流水号 
           FOrderInfo varchar(30)
           ) 

-- 现系统要求自动运算，将运算后的数据填充到T_Order业务表中．填充时各记录要生成不同的单据流水号．我原先的实现想法是用存储过程：
CREATE    PROCEDURE P_OnlyC
  @CodeC VARCHAR(48) OUTPUT
AS
DECLARE @OnlyC VARCHAR(48)
,@FIncCount INTEGER

-- 取出当前单据流水号
SELECT @FIncCount=FIncCount FROM T_OrderList WHERE FID=@CodeC
-- 流水号加１
SELECT @FIncCount = @FIncCount +1

UPDATE T_OrderList SET FIncCount = @FIncCount WHERE FID= @CodeC

-- 组织各个编码
SELECT @OnlyC = @CodeC  + '-' + @OnlyC
SELECT @CodeC = @OnlyC; SELECT @OnlyC AS FNumber
-- print @CodeC
GO

但这程方法不能在SELECT语句运算出的结果中调用．如前面写的SELECT P_OnlyC(FId)  as  流水号,  *  from (select sum(..) from tab..) Tab1  所以我想用函数,但函数里又没办法执行递增流水号：

CREATE  FUNCTION  F_LT_GetOrderNo(@ID  int) 
AS  RETURN  VARCHAR(32) 
           DECLARE  @OrderNo  int 
           SELECT  @OrderNo  =  FIncCount  FROM  T_OrderList  WHERE  FID  =  @ID 
       --  取得编号后，计数器加１ 
           UPDATE  T_OrderList  SET  FIncCount  =  FIncCount  +1  --  函数中不允许执行UPDATE 
           RETURNS  @OrderNo
          
          
          
CREATE PROCEDURE n_GetBillNo
@billType  char(2),--单据类型
@BillOutNo  nvarchar(50) Output

 AS

Begin

declare @NowNO int
declare @date char(10)
declare @Symbol nvarchar(10)
declare @ErrorMsg nvarchar(200)

Set NoCount On
Begin Tran
--设定延时
SET LOCK_TIMEOUT 5000

--取当前序号
Select @NowNO=fnumber,@Symbol=fCode,@date=Convert(char(8),fDate,112) from n_BillNo  With(xLock) where fcode=@BillType
if @@Error<>0
   begin
   Set @ErrorMsg='数据被锁定，请求超时！'
   Goto Failed
   end
--是否是新的一月
if Convert(char(8),getdate(),112)<>@date
 Set @NowNo=1
 else
 Set @NowNo=@NowNo+1

--更新当前序列号和设置最后更新日期
update n_BillNo set fNumber=@NowNO,fDate=GetDate() where fcode=@BillType
if @@Error<>0
   begin
   Set @ErrorMsg='更新外部序列号失败！'
   Goto Failed
   end

--取得单号
Set @BillOutNo=lTrim(@SymBol)+Convert(char(8),GetDate(),112)+Right(('0000'+Convert(varchar,@NowNO)),4)

Goto Succeed

Failed:
  RaisError(@ErrorMsg,16,1)
  Rollback Tran 
  Set NoCount Off
  Return 1

Succeed:
  Commit Tran
  Set NoCount Off
  Return 0

End
GO

本文引自：http://www.iplab.cs.tsukuba.ac.jp/~liuxj/jdk1.2/zh/docs/tooldocs/solaris/keytool.html

说明
keytool是个密钥和证书管理工具。它使用户能够管理自己的公钥/私钥对及相关证书，用于（通过数字签名）自我认证（用户向别的用户/服务认证自己）或数据完整性以及认证服务。它还允许用户储存他们的通信对等者的公钥（以证书形式）。

证书是来自一个实体（个人、公司等）的经数字签名的声明，它声明某些其它实体的公钥（及其它信息）具有某一的特定值（参见证书）。当数据被数字化签名后，校验签名即可检查数据的完整性和真实性。完整性的意思是数据没有被修改或损坏过，真实性的意思是数据的确是来自声称创建了该数据和对它进行了签名的实体。

keytool将密钥和证书储存在一个所谓的密钥仓库中。缺省的密钥仓库实现将密钥仓库实现为一个文件。它用口令来保护私钥。

jarsigner 工具利用密钥仓库中的信息来产生或校验 Java 存档 (JAR) 文件的数字签名 （JAR 文件将类文件、图象、声音和/或其它数字化数据打包在一个文件中）。jarsigner 用 JAR 文件所附带的证书（包含于 JAR 文件的签名块文件中）来校验 JAR 文件的数字签名，然后检查该证书的公钥是否“可信任”，即是否包括在指定的密钥仓库中。

请注意：keytool和 jarsigner 工具完全取代了 JDK 1.1 中提供的 javakey 工具。这些新工具所提供的功能比 javakey 提供的多，包括能够用口令来保护密钥仓库和私钥，以及除了能够生成签名外还可以校验它们。新的密钥仓库体系结构取代了 javakey 所创建和管理的身份数据库。可以利用 -identitydbkeytool命令将信息从身份数据库导入 密钥仓库。

密钥仓库项

在密钥仓库中有两种不同类型的项：

 
1. 密钥项 - 每项存放极为敏感的加密密钥信息，这种信息以一种受保护的格式储存以防止未授权的访问。通常，储存在这类项中的密钥是机密密钥，或是伴有用于认证相应公钥用的证书“链”的私钥。keytool 和 jarsigner 工具只处理后一类型的项，即私钥及其关联的证书链。
2. 可信任的证书项 - 每项包含一个属于另一团体的公钥证书。它之所以叫做“可信任的证书”，是因为密钥仓库的拥有者相信证书中的公钥确实属于证书“主体”（拥有者）识别的身份。证书签发人通过对证书签名来保证这点。

密钥仓库使用的别名

对所有的密钥仓库项（密钥项和可信任的证书项）的访问都要通过唯一的别名来进行。别名不区分大小写，即别名 Hugo 和 hugo 指的是同一密钥仓库项。

当用 -genkey 命令来生成密钥对（公钥和私钥）或用 -import 命令来将证书或证书链加到可信任证书的清单中，以增加一个实体到密钥仓库中，必须指定了一个别名。后续 keytool 命令必须使用这一相同的别名来引用该实体。

例如，假设您用别名 duke 生成了新的公钥/私钥密钥对并将公钥用以下命令打包到自签名证书中（参见证书链）：

    keytool -genkey -alias duke -keypass dukekeypasswd

这指定了一个初始口令“dukekeypasswd”，接下来的命令都要使用该口令才能访问与别名 duke 相关联的私钥。以后如果您想更改 duke 的 私钥口令，可用类似下述的命令：

    keytool -keypasswd -alias duke -keypass dukekeypasswd -new newpass

这将把口令从“dukekeypasswd”改为“newpass”。

请注意：实际上，除非是作为测试目的或是在安全的系统上，否则不应在命令行或脚本中指定口令。如果没有在命令行上指定所要求的口令选项，您将会得到要求输入口令的提示。当在口令提示符下键入口令时，口令将被即时显示出来（键入什么就显示什么），因此，要小心，不要当着任何人的面键入口令。

密钥仓库位置

每个 keytool 命令都有一个 -keystore 选项，用于指定 keytool 管理的密钥仓库的永久密钥仓库文件名称及其位置。缺省情况下，密钥仓库储存在用户宿主目录（由系统属性的“user.home”决定）中名为 .keystore 的文件中。在 Solaris 系统中“user.home”缺省为用户的宿主目录。

密钥仓库的创建

当用 -genkey、-import 或 -identitydb 命令向某个尚不存在的密钥仓库添加数据时，就创建了一个密钥仓库。

具体地说，如果在 -keystore 选项中指定了一个并不存在的密钥仓库，则该密钥仓库将被创建。

如果不指定 -keystore 选项，则缺省密钥仓库将是宿主目录中名为 .keystore 的文件。如果该文件并不存在，则它将被创建。

密钥仓库实现

java.security 包中提供的 KeyStore 类为访问和修改密钥仓库中的信息提供了相当固定的接口。可以有多个不同的具体实现，其中每个实现都是对某个特定类型的密钥仓库的具体实现。

目前，有两个命令行工具（keytool 和 jarsigner）以及一个名为 Policy Tool 的基于 GUI 的工具使用密钥仓库实现。由于密钥仓库是公用的，JDK 用户可利用它来编写其它的安全性应用程序。

Sun Microsystems 公司提供了一个内置的缺省实现。它利用名为“JKS” 的专用密钥仓库类型（格式），将密钥仓库实现为一个文件。它用个人口令保护每个私钥，也用口令（可能为另一个口令）保护整个密钥仓库的完整性。

密钥仓库的实现基于提供者 (provider)。更具体地说，由密钥仓库所提供的应用程序接口是借助于“服务提供者接口”(SPI) 来实现的。也就是说，在 java.security 包中还有一个对应的抽象 KeystoreSpi 类，它定义了“提供者”必须实现的服务提供者接口方法。（术语“提供者”指的是一个或一组包，这个或这组包提供了一部份可由 Java 安全 API 访问的服务子集的具体实现。因此，要提供某个密钥仓库实现，客户机必须实现一个“提供者”并实现 KeystoreSpi 子类，如如何为 Java 加密体系结构实现 Provider 中所述。

通过使用 KeyStore 类中提供的“getInstance”工厂方法，应用程序可从不同的提供者中挑选不同类型的密钥仓库实现。密钥仓库类型定义密钥仓库信息的存储和数据格式，以及用于保护密钥仓库中的私钥和密钥仓库自身完整性的算法。不同类型的密钥仓库实现是不兼容的。

keytool 使用基于文件的密钥仓库实现 （它把在命令行中传递给它的密钥仓库位置当成文件名处理并将之转换为文件输入流，从该文件输入流中加载密钥仓库信息）。另一方面，jarsigner 和 policytool 工具可从任何可用 URL 指定的位置读取某个密钥仓库。

对于 keytool 和 jarsigner，可在命令行用 -storetype 选项指定密钥仓库类型。对于 Policy Tool，可通过 “编辑”菜单中的“更改密钥仓库”命令来指定密钥仓库类型。

如果没有明确指定一个密钥仓库类型，这些工具将只是根据安全属性文件中指定的 keystore.type 属性值来选择密钥仓库实现。安全属性文件名为 java.security，它位于 JDK 安全属性目录 java.home/lib/security 中，其中 java.home 为 JDK 的安装目录。

每个工具都先获取 keystore.type 的值，然后检查所有当前已安装的提供者直到找到一个实现所要求类型的密钥仓库的实现为止。然后就使用该提供者的密钥仓库实现。

KeyStore 类定义了一个名为 getDefaultType 的静态方法，它可让应用程序或 applet 检索 keystore.type 属性的值。以下代码将创建缺省密钥仓库类型（此类型由 keystore.type 属性所指定。）的一个实例：

    KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());

缺省的密钥仓库类型是“jks”（这是由“SUN”提供者提供的密钥仓库实现的专用类型）。它在安全性属性文件中由下行进行指定：

    keystore.type=jks

要让工具使用不同于缺省类型的密钥仓库实现，可更改此行，指定不同的密钥仓库类型。

例如，如果您有一个这样的提供者包，它给出一个名为“pkcs12”的密钥仓库类型的密钥仓库实现，则可将上面那行改为：

    keystore.type=pkcs12

注意：密钥仓库类型的命名中大小写无关紧要。例如，“JKS”将被认为是与“jks”相同的。

支持的算法和密钥大小

keytool 允许用户指定任何注册了的加密服务提供者所提供的密钥对生成和签名算法。也就是说，各种命令中的 keyalg 和 sigalg 选项必须得到提供者的实现的支持。缺省的密钥对生成算法是“DSA”。签名算法是从所涉及私钥的算法推导来的：如果所涉及的私钥是“DSA”类型，则缺省的签名算法为“SHA1withDSA”，如果所涉及的私钥是“RSA”类型，则缺省的签名算法为“MD5withRSA”。

在生成 DSA 密钥对时，密钥大小的范围必须在 512 到 1024 位之间，且必须是 64 的倍数。缺省的密钥大小为 1024 位。

证书

证书（也叫公钥证书）是来自某个实体（签发人）的经数字签名的声明，它声明另一实体（主体）的公钥（及其它信息）具有某一特定的值。

下面详细解释本句中使用的主要术语：

 

公钥

是与特定实体相关联的数字。所有需要与该实体进行信任交互的人都应知道该数字。公钥用于校验签名。

经数字签名

如果某些数据经数字签名，说明它们已与某一实体的“身份”存储在一起，而且证明该实体的签名知道这些数据。通过用该实体的私钥进行绘制，这些数据就是不可伪造的了。

身份

用于声明实体的一种手段。某些系统中，身份是公钥，而在另一些系统中则可以是 Unix UID、电子邮件地址或 X.509 特征名等等。

签名

所谓签名，就是用实体的（签名人，在证书中也称为签发人）私钥对某些数据进行计算。

私钥

是一些数字，每个数字都应仅被以该数字作为私钥的特定实体所知（即该数字应保密）。在所有公钥密码系统中，私钥和公钥均成对出现。在 DSA 等具体的公钥密码系统中，一个私钥只对应一个公钥。私钥用于计算签名。

实体

实体是您在某种程度上对其加以信任的个人、组织、程序、计算机、企业、银行等。

通常，公钥密码系统需要访问用户的公钥。在大型联网环境中，并不能确保通信实体之间已经预先建立起关系，也无法确保受信任的储存库与所用的公钥都存在。于是人们发明了证书作为公钥分配问题的解决办法。现在，认证机构 (CA) 可充当可信任的第三方。CA 是可信任的向其它实体签名（发放）证书的实体（例如企业）。由于 CA 受法律协议约束，因此可认为它们只提供可靠有效的证书。公共认证机构数量很多，例如 VeriSign、Thawte、Entrust 等等。您还可以使用诸如 Netscape/Microsoft Certificate Servers 或 Entrust CA 等产品来自己运营认证机构。

使用 keytool 可以显示、导入和导出证书。还可以产生自签名证书。

keytool 目前处理 X.509 证书。

X.509 证书

X.509 标准规定了证书可以包含什么信息，并说明了记录信息的方法（数据格式）。除了签名外，所有 X.509 证书还包含以下数据：

 

版本

识别用于该证书的 X.509 标准的版本，该版本影响证书中所能指定的信息。迄今为止，已定义的版本有三个。keytool 可导入和导出 v1、v2 和 v3 版的证书。它只能生成 v1 版证书。

序列号

发放证书的实体有责任为证书指定序列号，以使其区别于该实体发放的其它证书。此信息用途很多。例如，如果某一证书被撤消，其序列号将放到证书撤消清单 (CRL) 中。

签名算法标识符

用于标识 CA 签名证书时所用的算法。

签发人名称

签名证书的实体的 X.500 特征名。它通常为一个 CA。使用该证书意味着信任签名该证书的实体。注意：有些情况下（例如根或顶层 CA 证书），签发人会签名自己的证书。

有效期

每个证书均只能在一个有限的时间段内有效。该有效期以起始日期和时间及终止日期和时间表示，可以短至几秒或长至一世纪。所选有效期取决于许多因素，例如用于签名证书的私钥的使用频率及愿为证书支付的金钱等。它是在没有危及相关私钥的条件下，实体可以依赖公钥值的预计时间。

主体名

证书可以识别其公钥的实体名。此名称使用 X.500 标准，因此在Internet中应是唯一的。它是实体的 X.500 特征名 (DN)，例如，

    CN=Java Duke, OU=Java Software Division, O=Sun Microsystems Inc, C=US

（这些指主体的通用名、组织单位、组织和国家。）

主体公钥信息

这是被命名实体的公钥，同时包括指定该密钥所属公钥密码系统的算法标识符及所有相关的密钥参数。

X.509 1 版 1988 年发布，已得到广泛使用，是最常用的版本。

X.509 2 版引入了主体和签发人唯一标识符的概念，以解决主体和/或签发人名称在一段时间后可能重复使用的问题。大多数证书监视文档都极力建议不要重复使用主体或签发人名称，而且建议证书不要使用唯一标识符。版本 2 证书尚未得到广泛使用。

X.509 3 版是最新的版本（1996 年）。它支持扩展的概念，因此任何人均可定义扩展并将其纳入证书中。现在常用的扩展包括：KeyUsage（仅限密钥用于特殊目的，例如“只签名”）和 AlternativeNames（允许其它身份也与该公钥关联，例如 DNS 名、电子邮件地址、IP 地址）。扩展可标记为“极重要”，以表示该扩展应被检查并执行或使用。例如，如果某一证书将 KeyUsage 扩展标记为“极重要”，而且设置为“keyCertSign”，则在 SSL 通讯期间该证书出现时将被拒绝，因为该证书扩展表示相关私钥应只用于签名证书，而不应该用于 SSL。

证书中的所有数据均用两个名为 ASN.1/DER 的相关标准进行编码。抽象语法注释 1(Abstract Syntax Notation 1) 描述数据。确定性编码规则 (Definite Encoding Rules) 描述储存和传输该数据的唯一方式。

X.500 特征名

X.500 特征名用于标识实体，例如 X.509 证书的 主体和签发人（签名人）域所命名的实体。keytool 支持以下的子组件：

 
• commonName - 个人常用名，例如“Susan Jones”
• organizationUnit - 小型组织（例如部门或分部）的名称，例如“Purchasing”
• organizationName - 大型组织的名称，例如“ABCSystems, Inc.”
• localityName - 地方（城市）名，例如“Palo Alto”
• stateName - 州或省份名，例如“California”
• country - 两个字母的国家代码，例如“CH”

当给出一个特征名字符串作为 -dname 选项的值时，例如 -genkey 或 -selfcert 命令中的该选项，字符串必须为以下格式：

CN=cName, OU=orgUnit, O=org, L=city, S=state, C=countryCode

其中所有的斜体字代表实际值而上面的关键字是以下缩写：

        CN=commonName
        OU=organizationUnit
        O=organizationName
        L=localityName
        S=stateName
        C=country

以下是特征名字符串样本：

CN=Mark Smith, OU=JavaSoft, O=Sun, L=Cupertino, S=California, C=US

以下是使用这一字符串的样本命令：

keytool -genkey -dname "CN=Mark Smith, OU=JavaSoft, O=Sun, L=Cupertino,
S=California, C=US" -alias mark

大小写对关键字缩写无关紧要。例如，“CN”、“cn”和“Cn”都将被当作是一样的。

但顺序是有关系的；每个子组件必须按设计好的顺序出现。但是，不是所有子组件都必须有。可以只用一部分，例如：

CN=Steve Meier, OU=SunSoft, O=Sun, C=US

如果特征名字符串的值含有逗号，当在命令行指定该字符串时，逗号必须用“\”字符来进行转义，如下所示：

   cn=peter schuster, o=Sun Microsystems\, Inc., o=sun, c=us

在命令行中指定特征名字符串是不必要的。如果某一命令需要指定特征名字符串，而在命令行中又未提供，则用户将得到每个子组件的提示。这种情况下，逗号不需要用“\”来转义。

Internet RFC 1421 证书编码标准

证书常用 Internet RFC 1421 标准中定义的可打印的编码格式来存储，而不是用其二进制编码来存储。这种证书格式，也称“Base 64 编码”，便于通过电子邮件或其它机制将证书导出到别的应用程序中。

用 -import 和 -printcert 命令读入的证书可以是这种格式的编码或是二进制格式的编码。

缺省情况下，-export 命令将以二进制编码格式输出证书，但如果指定了 -rfc 选项，则将以可打印的编码格式输出证书。

缺省情况下，-list 命令打印证书的 MD5 指纹。而如果指定了 -v 选项，将以可读格式打印证书，如果指定了 -rfc 选项，将以可打印的编码格式输出证书。

在其可打印的编码格式中，已编码证书的起始行是：

-----BEGIN CERTIFICATE-----

结束行是：

-----END CERTIFICATE-----

证书链

keytool 可创建和管理密钥仓库的“密钥”项，每个密钥项都含有私钥和相关证书“链”。链中的第一个证书含有与私钥对应的公钥。

当第一次产生密钥时（参见 -genkey 命令），链中只含有一个元素，即自签名证书。自签名证书是一个这样的证书：其签发人（签名人）与主体（证书所认证的公钥所属的实体）相同。当调用 -genkey 命令来生成新的公钥/私钥对时，它同时也把公钥打包进自签名证书中。

之后，当证书签名请求 (CSR) （参见 -certreq 命令）被生成并送至认证机构 (CA) 后，CA 的答复将被导入（参见 -import），证书链将取代自签名证书。在链的底部是认证主体公钥的 CA 所发放的证书（答复）。链中下一个证书是用于认证 CA 公钥的证书。

在许多情况下，这是个自签名证书（即来自认证其自身公钥的 CA 的证书）且是链中的最后一个证书。在其它情况下，CA 也许将返回证书链。这种情况下，链中底部的证书是相同的（由 CA 签名的证书，对密钥项的公钥进行认证），但链中第二个证书是由不同的 CA 所签名的，对您向其发送 CSR 的 CA 的公钥进行认证。然后，链中的下一个证书将是对第二个 CA 的公钥进行认证的证书，以此类推，直至到达自签名的“根”证书为止。因此，链中的每个证书（从第一个以后）都对链中前一个证书的签名人的公钥进行认证。

许多 CA 只返回所发放的证书，而不支持链，特别是当层次结构较简单时（无中介 CA）。这种情况下，必须用储存在密钥仓库中的可信任的证书信息来建立证书链。

另一种答复格式（由 PKCS#7 标准所定义）除了包含所签发的证书外，还支持证书链。两种答复格式都可由 keytool 处理。

顶层（根）CA 证书是自签名的。但是，对根公钥的信任并非来自根证书本身（任何人都可用特征名来产生自签名证书！譬如说用 VeriSign 根 CA 的特征名）, 而是来自报纸之类的其它来源。根 CA 的公钥是广为人知的。它被储存在证书中的唯一原因是因为这是大多数工具所能理解的格式，因此这种情况下的证书只是作为一种传输根 CA 的公钥用的“交通工具”。在将根 CA 证书加到您的密钥仓库中之前，应该先对它进行查看（用 -printcert 选项）并将所显示的指纹与已知的指纹（从报纸、根 CA 的网页等中获取）进行比较。

导入证书

要从一个文件中导入某个证书，可用 -import 命令，如下所示：

    keytool -import -alias joe -file jcertfile.cer

此样本命令导入文件 jcertfile.cer 中的证书并将其存储在由别名 joe 标识的密钥仓库项中。

导入证书的两个理由如下：

 
1. 为将其添加到可信任的证书清单中，或
2. 为导入因向 CA 提交证书签名请求（参见 -certreq 命令）而收到的来自该 CA 的认证答复。

-alias 选项的值指明要进行何种类型的导入。如果数据库中存在别名，且该别名标识具有私钥的项，则将假定您要导入认证答复。keytool 将检查认证答复中的公钥是否与用别名储存的私钥相匹配，如果两者不同，则程序退出。如果别名标识另一种类型的密钥仓库项，则不导入该证书。如果该别名不存在，则它将被创建并与导入的证书关联。

有关导入可信任证书的警告

重要：将证书作为可信任的证书导入之前，请务必先仔细检查该证书！

先查看一下（用 -printcert 命令，或用不带 -noprompt 选项的 -import 命令），确保所显示的证书指纹与所预计的相匹配。例如，假设某人给您送来或用电子邮件发来一个证书，您将它放在名为 /tmp/cert 的文件中。在将它加到可信任证书的清单中之前，可通过执行 -printcert 命令来查看它的指纹，如下所示：

  keytool -printcert -file /tmp/cert
    Owner: CN=ll, OU=ll, O=ll, L=ll, S=ll, C=ll
    Issuer: CN=ll, OU=ll, O=ll, L=ll, S=ll, C=ll
    Serial Number: 59092b34
    Valid from: Thu Sep 25 18:01:13 PDT 1997 until: Wed Dec 24 17:01:13 PST 1997
    Certificate Fingerprints:
         MD5： 11:81:AD:92:C8:E5:0E:A2:01:2E:D4:7A:D7:5F:07:6F
         SHA1: 20:B6:17:FA:EF:E5:55:8A:D0:71:1F:E8:D6:9D:C0:37:13:0E:5E:FE

然后给向您发送证书的人打电话或用其它方式联系，将您将您所看到的指纹与他们所提供的比较。只有两者相等才可保证证书在传送途中没有被其它人（例如，攻击者）的证书所更换。如果发生了这样的攻击，而您未检查证书即将其导入，您就会信任攻击者所签名的任何东西（例如，一个含有恶意类文件的 JAR 文件）。

注意：并不要求在导入证书前执行 -printcert 命令，因为在将证书添加到密钥仓库中可信任证书的清单中之前，-import 命令将会打印出该证书的信息，并提示您进行校验。这时，您可选择中止导入操作。但是注意，只有在调用不带 -noprompt 选项的 -import 命令时才能这样做。如果给出了 -noprompt 选项，则不存在与用户的交互

导出证书

要将证书导出到文件中，请用 -export 命令，如下所示：

    keytool -export -alias jane -file janecertfile.cer

该样本命令将 jane 的证书导出到文件 janecertfile.cer 中。也就是说，如果 jane 是某个密钥项的别名，该命令将导出该密钥仓库项中所含证书链底部的证书。这是认证 jane 的公钥用的证书。

相反，如果 jane 是某个可信任证书项的别名，则导出的是该可信任的证书。

显示证书

要打印某个密钥仓库项的内容，请用 -list 命令，如下所示：

    keytool -list -alias joe

如果未指定别名，如下所示：

    keytool -list

则打印整个密钥仓库的内容。

要显示储存在文件中的证书的内容，请用 -printcert 命令，如下所示：

    keytool -printcert -file certfile.cer

这将打印储存在文件 certfile.cer 中的有关证书的信息。

注意：此操作与密钥仓库无关，也就是说，不需要密钥仓库即可显示储存在文件中的证书。

生成自签名证书

自签名证书是一个这样的证书：其签发人（签名人）与主体（证书所认证的公钥所属的实体）相同。当调用 -genkey 命令来生成新的公钥/私钥对时，它同时也把公钥打包进自签名证书中。

有时您也许希望生成新的自签名证书。例如，您也许想对不同身份（特征名）使用相同的密钥对。例如，假设您换了个部门。此时您可以：

 
1. 复制原始的密钥项。请参见 -keyclone。
2. 用新特征名为该复制项生成新的自签名证书。参见下文。
3. 为该复制项生成证书签名请求，并导入答复证书或证书链。参见 -certreq 和 -import 命令。
4. 删除原始（现在已过时）项。参见 -delete 命令。

要生成自签名证书，请用 -selfcert 命令，如下所示：

    keytool -selfcert -alias dukeNew -keypass b92kqmp
      -dname "cn=Duke Smith, ou=Purchasing, o=BlueSoft, c=US"

所生成的证书作为指定别名（本例中为“dukeNew”）所标识的密钥仓库项中的单元素证书来存储，它将取代现有的证书链。

命令和选项注意事项

下面列出各种命令及其选项，并对它们进行描述。注意：

 
• 所有的命令和选项名之前都有减号 (-) 。
• 每个命令的选项都可按任意顺序提供。
• 所有非斜体项或不在花括号和方括号内的项都不能改动。
• 选项周围的花括号通常表示如果在命令行中没有指定该选项，则使用缺省值。花括号还用在 -v、-rfc 和 -J 选项周围，这些选项只有在命令行中出现时才有意义（也就是说，它们没有任何缺省值，不然就是不存在该选项）。
• 选项周围的方括号表示如果在命令行中没有指定该选项，则用户将得到要求输入其值的提示。（对于 -keypass 选项，如果在命令行中没有指定该选项，keytool 将先是尝试用密钥仓库口令来访问私钥，如果失败，再提示您输入私钥口令。）
• 斜体项（选项）代表必须提供实际值。例如，下面是 -printcert 命令的格式：

    keytool -printcert {-file cert_file} {-v}

  当指定 -printcert 命令时，请用实际文件名来替代 cert_file，如下所示：

    keytool -printcert -file VScert.cer

• 如果选项值含有空白（空格），必须用引号把它们括起来。
• -help 命令是缺省命令。因此，命令行

    keytool

  等价于

    keytool -help

选项缺省值

下面是各选项的缺省值。

-alias "mykey"

-keyalg "DSA"

-keysize 1024

-validity 90

-keystore 用户宿主目录中名为 .keystore 的文件

-file 读时为标准输入，写时为标准输出

签名算法（-sigalg 选项）是由所涉及私钥的算法推导而来的：如果所涉及的私钥是“DSA”类型，则 -sigalg 选项将缺省为“带 DSA 的 SHA1”，如果所涉及的私钥是“RSA”类型，则 -sigalg 选项将缺省为“带 RSA 的 MD5”。

出现在大多数命令中的选项

-v 选项可出现在除 -help 之外的所有命令中。如果出现该选项，表示处在“长格式”模式下；将输出详细的证书信息。

-Jjavaoption 选项也可在任何命令中出现。如果出现该选项，则所指定的 javaoption 字符串将被直接传给 Java 解释器。（keytool 实际上是解释器周围的一个 “wrapper”。） 该选项不应含有任何空格。它有助于调整执行环境或内存使用。要获得可用的解释器选项的清单，可在命令行键入 java -h 或 java -X。

有三个选项可出现在用于操作密钥仓库的所有命令中：

 

-storetype storetype

此限定符指定将被实例化的密钥仓库类型。缺省的密钥仓库类型是安全属性文件中“keystore.type”属性值所指定的那个类型，由 java.security.KeyStore 中的静态方法 getDefaultType 返回。

-keystore keystore

密钥仓库（数据库文件）的位置。缺省情况下，密钥仓库指的是用户宿主目录的 .keystore 文件，它是由“user.home”的系统属性确定的。在 Solaris 系统中，“user.home”缺省为用户宿主目录。

-storepass storepass

口令，用来保护密钥仓库的完整性。

storepass 的长度必须至少为 6 个字符。所有访问密钥仓库内容的命令都必须提供这一选项。对于这些命令，如果没有给出 -storepass 选项，则用户将得到要求输入该选项的提示。

当从密钥仓库中检索信息时，口令属于可选项；如果未给出口令，就不能检查所检索信息的完整性，而且将出现警告。

使用口令时必须小心 - 参见与口令有关的警告。

与口令有关的警告

大多数对密钥仓库操作的命令都要求仓库口令。一些命令要求私钥口令。

口令可以在命令行上（分别在 -storepass 和 -keypass 选项上）指定。但是，除非是作为测试目的或是在一个安全的系统上，否则不应在命令行或脚本中指定口令。

如果没有在命令行上指定所要求的口令选项，您将会得到要求输入口令的提示。当在口令提示符下键入口令时，口令将被即时地显示出来（键入什么就显示什么），因此，要小心，不要当着任何人的面键口令。

命令

另请参阅命令和选项注释。

向密钥仓库添加数据

-genkey {-alias alias} {-keyalg keyalg} {-keysize keysize} {-sigalg sigalg} [-dname dname] [-keypass keypass] {-validity valDays} {-storetype storetype} {-keystore keystore} [-storepass storepass] {-v} {-Jjavaoption}

产生密钥对（公钥和与之关联的私钥）。将公钥打包进 X.509 v1 的自签名证书中，该证书以单元素证书链的形式储存。该证书链和私钥将储存于 alias 所标识的新密钥仓库项中。

keyalg 指定了用于生成密钥对的算法，而 keysize 指定要生成的每个密钥的大小。sigalg 指定签名自签名证书所用的算法；这一算法必须与 keyalg 兼容。参见支持的算法和密钥大小。

dname 指定与 alias 关联的 X.500 特征名，并用作自签名证书中的 issuer 和 subject 域。如果在命令行中没有提供特征名，用户将得到要求输入该信息的提示。

keypass 是口令，用来保护所生成密钥对中的私钥。如果没有提供口令，用户将得到要求输入口令的提示。如果在提示符下按 RETURN 键，则密钥口令将被设置为与密钥仓库所用的口令相同。keypass 的长度必须至少为 6 个字符。使用口令时必须小心 - 参见 与口令有关的警告。

valDays 指定证书的有效期。

-import {-alias alias} {-file cert_file} [-keypass keypass] {-noprompt} {-trustcacerts} {-storetype storetype} {-keystore keystore} [-storepass storepass] {-v} {-Jjavaoption}

从文件 cert_file 中读取证书或证书链（后者在 PKCS#7 格式的答复所给出）并将其储存在 alias 所标识的密钥仓库项中。如果没有给出文件，则从标准输入设备中读取证书或 PKCS#7 答复。keytool 可导入 X.509 v1、v2 和 v3 的证书以及由该类证书所组成的 PKCS#7 格式的证书链。要导入的数据必须是二进制编码格式或 Internet RFC 1421 标准所定义的可打印的编码格式（也称 Base64 编码）。在后一种情况下，编码必须用以“-----BEGIN”开头的字符串开始，用以“-----END”结尾的字符串来结束。

当导入新的可信任证书时，密钥仓库中还没有 alias。在把证书添加到密钥仓库中之前，keytool 将尝试用密钥仓库中已有的可信任证书来构造从该证书到自签名证书（属于根 CA）的信任链，以对证书进行校验。

如果指定了 -trustcacerts 选项，则将为该信任链考虑其它证书，即考虑名为“cacerts”的文件中的证书，该文件位于 JDK 安全属性目录 java.home\lib\security 中，其中 java.home 为 JDK 安装目录。“cacerts”文件代表含有 CA 证书的系统范围的密钥仓库。通过指定密钥仓库类型为“jks”，系统管理员可用 keytool 来配置和管理该文件。“cacerts”密钥仓库文件发送时附有五个 VeriSign 根 CA 证书，其 X.500 特征名如下：

1. OU=Class 1 Public Primary Certification Authority, O="VeriSign, Inc.",
C=US

2. OU=Class 2 Public Primary Certification Authority, O="VeriSign,
Inc.", C=US

3. OU=Class 3 Public Primary Certification Authority,
O="VeriSign, Inc.", C=US

4. OU=Class 4 Public Primary Certification
Authority, O="VeriSign, Inc.", C=US

5. OU=Secure Server Certification
Authority, O="RSA Data Security, Inc.", C=US

“cacerts”密钥仓库文件的初始口令为“changeit” 。系统管理员在安装 JDK 后，就应该立即更改这个口令以及该文件的缺省访问权限。

如果 keytool 无法建立从要导入的证书到自签名证书的信任路径（利用密钥仓库或“cacerts”文件），则打印出该证书的信息，而用户将得到要求校验的提示，例如，系统将通知用户通过比较显示出的指纹和得自其它（可信任的）信息来源的指纹来进行校验，信息来源可能是证书拥有者本人。在将证书作为一个“可信任”证书导入之前，要十分小心，务必保证该证书是有效的！ -- 参见有关导入可信任证书的警告。然后，用户可以选择中止导入操作。但是，如果给了 -noprompt 选项，则不会有与用户的交互。

当导入认证答复时，该认证答复将用密钥仓库中可信任的证书来确认，有时也使用在“cacerts”密钥仓库文件中配置的证书（如果指定了 -trustcacerts 选项）。

如果答复是一个 X.509 证书，keytool 将尝试建立信任链，以该认证答复为头，以属于根 CA 的自签名证书为尾。该认证答复和用于认证该认证答复的证书层次形成了 alias 的新证书链。

如果答复是 PKCS#7 格式的证书链，则该链应首先被排序（用户证书在最前面，自签名的根 CA 证书在最后面），然后 keytool 尝试将答复中的根 CA 证书与密钥仓库或“cacerts”密钥仓库文件（如果指定了 -trustcacerts 选项）中的任何可信任证书进行匹配。如果找不到匹配，则打印出该根 CA 证书的信息，而用户将得到要求校验它的提示，例如，系统将通知用户通过比较显示出的指纹和得自其它（可信任的）信息来源的指纹来进行校验，信息来源可能是证书拥有者本人。因此，用户可以选择中止导入操作。但是，如果给了 -noprompt 选项，则不会有与用户的交互。

alias 的新证书链将取代与该项关联的旧证书链。只有提供了有效的 keypass，即提供了用于保护该项的私钥的口令时，旧链才可被取代。如果没有提供口令，而且私钥口令与密钥仓库口令不同，用户将得到要求输入口令的提示。使用口令时必须小心 --  参见与口令有关的警告。

-selfcert {-alias alias} {-sigalg sigalg} {-dname dname} {-validity valDays} [-keypass keypass] {-storetype storetype} {-keystore keystore} [-storepass storepass] {-v} {-Jjavaoption}

利用密钥仓库信息（包括与 alias 关联的私钥和公钥）产生 X.509 v1 自签名证书。如果在命令行提供了 dname，它将同时用作该证书的签发人和主体的 X.500 特征名。否则，将使用与 alias 关联的 X.500 特征名（位于其现有证书链底部）。

所生成的证书作为 alias 所标识的密钥仓库项中的单元素证书链来存储，它将取代现有的证书链。

sigalg 指定签名证书用的算法。参见支持的算法和密钥大小。

要访问私钥，必须提供正确的口令，因为私钥在密钥仓库中是受口令保护的。如果在命令行中没有提供 keypass，且私钥口令与保护密钥仓库完整性所用的口令不同，则用户将得到要求输入该口令的提示。使用口令时必须小心 -- 参见与口令有关的警告。

valDays 指定证书的有效期。

-identitydb {-file idb_file} {-storetype storetype} {-keystore keystore} [-storepass storepass] {-v} {-Jjavaoption}

从 idb_file 文件中读取 JDK 1.1.x 格式的身份数据库，并将它的项加到密钥仓库中。如果没有给出文件名，则从标准输入设备中读取身份数据库。如果不存在密钥仓库，则创建它。

只有被标记为可信任的身份数据库项（“身份”）才能被导入密钥仓库中。所有其它身份都将被略去。对每个可信任的身份，将创建一个密钥仓库项。身份名用作该密钥仓库项的“别名”。

所有可信任身份的私钥都将在相同的口令 storepass 下得到加密。该口令与保护密钥仓库完整性所用的口令相同。用户随后可用 keytool 命令选项“-keypasswd”来对各私钥赋予单独的口令。

身份数据库中的一个身份可以存放多个证书，各证书所认证的都是同一公钥。但一个私钥的密钥仓库密钥项含有该私钥和单一的“证书链”（该链最初只有一个证书），链中的第一个证书含有与该私钥对应的公钥。当从身份导入信息时，只有该身份中的第一个证书被储存到密钥仓库中。这是因为身份数据库中的身份名被用作其相应密钥仓库项的别名，而别名在密钥仓库中是唯一的。

导出数据

-certreq {-alias alias} {-sigalg sigalg} {-file certreq_file} [-keypass keypass] {-storetype storetype} {-keystore keystore} [-storepass storepass] {-v} {-Jjavaoption}

生成 PKCS#10 格式的证书签名请求 (CSR)。

CSR 用来发送给认证机构 (CA)。CA 对认证请求者进行认证（通常是离线的），并返回证书或证书链，以取代密钥仓库中现有的证书链（该证书链最初只含有自签名证书）。

私钥和与 alias 关联的 X.500 特征名用于创建 PKCS#10 证书请求。要访问私钥，必须提供正确的口令，因为私钥在库中是受口令保护的。如果在命令行没有提供 keypass，且私钥口令与保护密钥仓库完整性所用的口令不同，则用户将得到要求输入口令的提示。

使用口令时必须小心 -- 参见与口令有关的警告。

sigalg 指定签名 CSR 时用的算法。参见支持的算法和密钥大小。

CSR 存储在文件 certreq_file 中。如果没有给出文件名，CSR 将被输出到标准输出设备中。

用 import 命令来导入 CA 所返回的答复。

-export {-alias alias} {-file cert_file} {-storetype storetype} {-keystore keystore} [-storepass storepass] {-rfc} {-v} {-Jjavaoption}

从密钥仓库中读取与 alias 关联的证书，并将其储存在文件 cert_file 中。

如果没有给出文件名，证书将被输出到标准输出设备中。

缺省情况下，证书被输出为二进制编码格式，但如果指定了 -rfc 选项，则将被输出为 Internet RFC 1421 标准中定义的可打印格式。

如果 alias 引用的是可信任证书，则该证书将被输出。否则，alias 引用的是含有相关证书链的密钥项。在这种情况下，链中的第一个证书将被返回。该证书对由 alias 所指定的实体的公钥进行认证。

显示数据

-list {-alias alias} {-storetype storetype} {-keystore keystore} [-storepass storepass] {-v | -rfc} {-Jjavaoption}

打印（到标准输出设备中）alias 所标识的密钥仓库项的内容。如果没有指定别名，则将打印整个密钥仓库的内容。

缺省情况下，该命令打印证书的 MD5 指纹。如果指定了 -v 选项，证书将以可读格式打印，同时包含拥有者、签发人和序列号等附加信息。如果指定了?-rfc 选项，证书将以 Internet RFC 1421 标准所定义的可打印的编码格式打印。

不能同时指定 -v 和 -rfc 两个选项。

-printcert {-file cert_file} {-v} {-Jjavaoption}

从文件 cert_file 中读取证书将以可读格式打印其内容。如果没有给出文件名，则从标准输入设备中读取证书。

证书可以是用二进制编码或 Internet RFC 1421 标准所定义的可打印编码格式。

注意：该选项的使用与密钥仓库无关。

管理密钥仓库

-keyclone {-alias alias} [-dest dest_alias] [-keypass keypass] [-new new_keypass] {-storetype storetype} {-keystore keystore} [-storepass storepass] {-v} {-Jjavaoption}

生成新的密钥仓库项，该项含有的私钥和证书链与原始项的相同。

原始项由 alias （如果没有提供别名，则其值缺省为“mykey”）标识。新（目标）项由 dest_alias 标识。如果没有在命令行中提供目标别名，用户将得到要求输入该信息的提示。

如果私钥口令与密钥仓库口令不同，那么，只有提供了有效的 keypass 时该项才能被复制。keypass 是用于保护与 alias 关联的私钥的口令。如果没有在命令行提供密钥口令，且私钥口令与密钥仓库口令不同，用户将得到要求输入口令的提示。如果愿意，可用不同的口令来保护复制项中的私钥。如果没有在命令行提供 -new 选项，用户将得到提示要求输入新项的口令（可以选择让该口令与被复制项的私钥所用的口令相同）。

使用口令时必须小心 -- 参见与口令有关的警告。

该命令可用于建立多个与给定密钥对相对应的证书链，或用于备份。

-storepasswd [-new new_storepass] {-storetype storetype} {-keystore keystore} [-storepass storepass] {-v} {-Jjavaoption}

更改保护密钥仓库内容的完整性所用的口令。新口令为 new_storepass，其长度必须至少是 6 个字符。

使用口令时必须小心 -- 参见与口令有关的警告。

-keypasswd {-alias alias} [-keypass old_keypass] [-new new_keypass] {-storetype storetype} {-keystore keystore} [-storepass storepass] {-v} {-Jjavaoption}

把保护 alias 所标识的私钥的口令从 old_keypass 更改为 new_keypass。

如果没有在命令行提供 keypass 选项，且私钥口令与密钥仓库口令不同，则用户将得到要求输入该口令的提示。

如果没有在命令行给出 -new 选项，则用户将得到要求输入新口令的提示。

使用口令时必须小心 -- 参见与口令有关的警告。

-delete [-alias alias] {-storetype storetype} {-keystore keystore} [-storepass storepass] {-v} {-Jjavaoption}

从密钥仓库中删除 alias 所标识的项。如果没有在命令行上提供别名，则用户将得到要求输入别名的提示。

获取帮助

-help

列出所有的命令及其选项。

示例

假设您要创建一个密钥仓库以管理您的公钥/私钥对来自您所信任实体的证书。

生成密钥对

您首先要做的是创建一个密钥仓库和生成密钥对。您可以使用以下命令：

    keytool -genkey -dname "cn=Mark Jones, ou=JavaSoft, o=Sun, c=US"
      -alias business -keypass kpi135 -keystore /working/mykeystore
      -storepass ab987c -validity 180

（请注意：键入该命令时必须使其成为一行。此处用多行来显示，主要是为了可读性。）

该命令将在 C 盘的“working”目录（假设它还不存在）中创建名为“mykeystore”的密钥仓库，并赋予它口令“ab987c”。它将为实体生成公钥/私钥对，该实体的“特征名”为：常用名“Mark Jones”、组织单位“JavaSoft”、组织“Sun”和两个字母的国家代码“US”。它使用缺省的“DSA”密钥生成算法来创建密钥，两个密钥（公钥与私钥）的长度都是 1024 位。

它创建自签名证书（使用缺省的“带 DSA 的 SHA1”签名算法），该证书包括公钥和特征名信息。该证书的有效期为 180 天，且与别名“business”所代表的密钥仓库项关联。私钥被赋予口令“kpi135”。

如果采用选项的缺省值，可以大大缩短该命令。实际上，这些选项并不是必需的；对于有缺省值的选项，未指定时将使用缺省值，对于任何被要求的值，您将会得到要求输入它的提示。因此，您可以只使用下面的命令：

    keytool -genkey

这种情况下，将创建一个具有别名“mykey”的密钥仓库项，它含有新生成的密钥对和有效期为 90 天的证书。该项被放在您的宿主目录下一个名为“.keystore”的密钥仓库中（如果该密钥仓库并不存在，则将创建它）。您将得到要求输入特征名信息、密钥仓库口令和私钥口令的提示。

其余示例假设您执行了未指定选项的 -genkey 命令，且用上述第一个 -genkey 命令中给出的值来回答提示要求（私钥口令为“kpi135”等等）。

从认证机构请求已签名的证书

目前为止我们所具有的就是自签名证书。证书如果由认证机构 (CA) 签名，将更有可能得到别人的信任。要得到这样的签名，首先要用以下命令生成证书签名请求 (CSR)：

    keytool -certreq -file MarkJ.csr

这将为缺省别名“mykey”所标识的实体生成 CSR，并将此请求放在名为“MarkJ.csr”的文件中。将此文件提交给某个 CA（例如 VeriSign, Inc.）。该 CA 将对您这个请求者进行认证（通常是离线的），然后返回它们所签名的证书，用于认证您的公钥。（某些情况下，它们实际上将返回证书链，链中每个证书都认证前一个证书的签名人的公钥。）

导入 CA 的证书

自签名证书必须用证书链代替，链中的每个证书都认证前一个证书的签名人的公钥，直到“根”CA 为止。

在导入 CA 的答复之前，在您的密钥仓库中或 cacerts 密钥仓库文件（如导入命令中所述）中需要有一个或多个“可信任”证书：

 
• 如果该认证答复是个证书链，您只需要链中最顶部的证书（即用于认证根 CA 的公钥的“根” CA 证书）。
• 如果该认证答复是单个证书，您需要发放 CA（即签名该证书的认证机构）的证书，如果此证书不是自签名的，则需其签名人的证书，以此类推，直到自签名的“根” CA 证书为止。

“cacerts”密钥仓库文件发送时附有五个 VeriSign 根 CA 证书，因此您可能并不需要导入 VeriSign 证书以作为密钥仓库中的可信任证书。但如果您请求由另一个 CA 签名的证书，而认证该 CA 的公钥的证书未被加到“cacerts”中，则您需要将来自该 CA 的证书作为“可信任证书”导入。

来自 CA 的证书通常是自签名的或是由另一个 CA 签名的（这种情况下您还需要认证该 CA 的公钥的证书）。假设 ABC, Inc. 公司是 CA，而您从该公司获得一个声称是自签名证书的名为“ABCCA.cer”的文件，它用于认证该 CA 的公钥。

在将证书作为一个“可信任”证书导入之前，要十分小心，务必保证该证书是有效的！先查看一下（用 keytool-printcert 命令，或用不带 -noprompt 选项的 keytool-import 命令）以确保所显示的证书指纹与所预计的相匹配。然后可以给发送证书的人打电话，将您所看到的指纹与他们所提供的（或安全公钥储存库所显示的）进行比较。只有两者相等才可保证证书在传送途中没有被其它人（例如，攻击者）的证书所更换。如果发生了这样的攻击，而您未检查证书即将其导入，那么您就会信任攻击者所签名的任何东西。

如果您相信证书是有效的，则您可以用以下命令将其加到密钥仓库中：

    keytool -import -alias abc -file ABCCA.cer

这将在密钥仓库中用文件“ABCCA.cer”中的数据创建“可信任证书”项，并将别名“abc”赋予该项。

导入来自 CA 的认证答复

一旦导入了用于认证 CA（该 CA 是您将证书签名请求送往之处）公钥的证书后，或在“cacerts”文件中已有这种证书时，就可以导入该认证答复，从而用证书链取代您的自签名证书。如果 CA 的答复是证书链，则该链是 CA 响应您的请求而返回的证书链；如果 CA 的答复是一个证书，则该链是用认证答复和可信任证书建立的证书链，这些可信任证书是密钥仓库（您要将认证答复导入之处）或“cacerts”密钥仓库文件中已有的。

例如，假设您将证书签名请求送往 VeriSign。您可用以下命令来导入认证答复，该命令假定所返回的证书名为“VSMarkJ.cer”：

    keytool -import -trustcacerts -file VSMarkJ.cer

导出用于认证您的公钥的证书

假设您用 jarsigner 工具来签名 Java 归档 (JAR) 文件。需要使用这一文件的客户机将认证您的签名。

认证签名的一种方法是先将您的公钥证书作为“可信任”项导入它们的密钥仓库中。您可以将证书导出并将其提供给客户机。例如，假设项的别名为“mykey”，您可以用以下命令将您的证书导出到名为 MJ.cer 的文件中：

    keytool -export -alias mykey -file MJ.cer

有了该证书以及已被签名的 JAR 文件，客户机就可以用 jarsigner 工具来认证您的签名。

更改特征名但保留密钥对

假设，譬如说因为您换了部门或搬到另一个城市去了而改变了您的特征名。如果愿意，您仍然可以使用您先前使用的公钥/私钥对而只对特征名进行更新。例如，假设您的名字叫 Susan Miller，并用别名 sMiller 和以下的特征名创建了初始密钥项：

  "cn=Susan Miller, ou=Finance Department, o=BlueSoft, c=us"

假设您从财务部门换到了会计部门。您仍然可使用先前所生成的公钥/私钥对，而用以下方法对特征名进行更新。首先，复制您的密钥项：

    keytool -keyclone -alias sMiller -dest sMillerNew

（您将得到要求输入密钥仓库口令和初始密钥口令及目标密钥口令的提示，因为在命令行没有提供这些信息。）现在，您需要更改与复制项关联的证书链以使链中的第一个证书使用您的新特征名。先用相应名称生成自签名证书：

    keytool -selfcert -alias sMillerNew
      -dname "cn=Susan Miller, ou=Accounting Department, o=BlueSoft, c=us"

然后根据该新证书中的信息生成证书签名请求：

    keytool -certreq -alias sMillerNew

当您得到 CA 认证答复后，将其导入：

    keytool -import -alias sMillerNew -file VSSMillerNew.cer

导入认证答复后，您也许会要删除使用旧特征名的初始密钥项：

    keytool -delete -alias sMiller

　　首先，通过下表介绍ORACLE与DB2/400数据类型之间的对应关系，是一对多的关系，具体采用哪种对应关系，应具体问题具体分析。

　　注意事项:

　　DATE and TIME

　　Oracle中的DATE含有年、月、日、时、分、秒，它和DB2/400中的DATE不相互对应，DB2/400中的DATE只有年、月、日，TIME类型含有时、分、秒，因此日期和时间类型要进行转换，请参照下表。

Oracle DB2/400 Oracle数据类型 注意事项 DB2 UDB数据类型 注意事项 DATE   DATE TIME TIMESTAMP l 如果只使用MM/DD/YYY,那么使用DATE类型。 l 如果只使用HH:MM:SS, 那么使用TIME类型。 l 如果要使用日期和时间，则使用时间戳类型（TIMESTAMP） l 可以使用Oracle中的TO_CHAR()函数来取DATE的字串来分别与DB2/400的DATE、TIME相匹配。 VARCHAR2(n) n<=4000 CHAR(n) VARCHAR(n) l 若n<=32766,则使用DB2/400中的CHAR类型、VARCHAR LONG n<=2GB VARCHAR(n) CLOB(n) l 若n<=32K,则使用DB2/400中的CHAR类型、VARCHAR。 l 若32K=< n <=2GB，则使用CLOB。 ROW& LONG ROW n<=255 CHAR(n) FOR BIT DATA VARCHAR(n) FOR BIT DATA BLOB(n) l 若n<=32K, 则使用CHAR(n) FOR BIT DATA 或 VARCHAR(n) FOR BIT DATA l 若n<=2GB, 则使用BLOB(n) BLOB n<=4GB BLOB(n) 若n<=2GB, 则使用BLOB(n) CLOB n<=4GB CLOB(n) 若n<=2GB, 则使用CLOB(n) NCLOB n<=4GB DBCLOB(n) 若n<=2GB, 则使用DBCLOB(n/2) NUMBER   SMALLINT/INTEGER/BIGINT DECIMAL(p,s)/NUMBER(p,s) Float(n)/ REAL/DOUBLE l 若Oracle中定义NUMBER(p) 或 NUMBER(p,s), 则使用SAMLLINT/INTEGER/BIGINT l 若Oracle中定义NUMBER(p,s), 则使用DECIMAL(p,s) l 若Oracle中定义NUMBER,则使用FLOAT(n)/REAL/DOUBLE

　　NUMBER

　　Oracle中的NUMBER类型可以对应DB2/400中的很多类型，这种对应关系要依赖于Oracle中number将用于保存何种类型的数据，是整型还是带有小数位的实型数据，另外还要考虑类型所占用的存储空间，例如:SAMLLINT占2 byte, INTEGER占4 byte; BIGINT占8 byte;Oracle中的NUMBER类型所占用的存储空间要根据它的定义而定，例如缺省精度下的NUMBER有38个数字长，占用20 byte的空间。具体的对应关系请参照上表。

　　ROW and LOB类型

　　DB2/400提供VARCHAR和CLOB与ORACLE中的RAW和LONG RAW相对应。ORACLE也支持大对象:BLOB、CLOB、CLOB和NCLOB, ORACLE中的BLOB和CLOB可以提供4GB的空间，而DB2/400中的BLOB和CLOB只能存放2GB的数据;DB2/400中的DBCLOB与ORACLE中的NCLOB 2GB相对应。Oracle 中的BFILE数据类型用于管理数据库以外的二进制数据，数据库中的表将指向数据库外部的存放的BFILE文件，DB2/400也提供一个类似的数据类型DATALINK相对应。

　　ROWID

　　Oracle ROWIND虚拟列用于对表中的某一列进行唯一标示，DB2/400中也有这样的数据类型ROWID，它与ORACLE中的ROWID的功能相似。DB2/400中的ROWID可以存放40 byte的数据用来唯一标示表中的每一行，它没有ccsid属性，这些信息中没有关于datafile、 block 或 row的信息。

　　例如:

　　CREATE TABLE LIBRARYNAME/ORDERS2 (ORDERNO ROWID, SHIPPED_TO VARCHAR (36) , ORDER_DATE DATE) ORDERNO的数据类型为ROWID，用于存放订单号，每当插入一行时，系统自动生成一个值，存放进这个字段。可以用OPERATION NAVIGATOR查看它的内容。

　　Character type

　　DB2/400的CHAR、VARCHAR类型与ORACLE中的VARCHAR2(n)类型相对应，但是ORACLE中的VARCHAR2(n)类型仅用于存放较小的字符串，这里的n小于4000，因此在这种情况下，最好用定长的CHAR(N)类型与ORACLE的VARCHAR2(n)相对应，这样不仅可以提高效率，还可以节省存储空间，若使用VARCHAR(n)类型最好用ALLOCATE参数，这样可以提高数据库的性能,它可以减少内存和硬盘之间的输入/输出操作。

　　要注意DB2/400中的字符串中文输入问题，要想在DB2/400上输入中文应用这样的SQL创建表，这里的CCSID 935,代表简体中文。

　　例如:

　　CREATE TABLE MYLIB/ZHONG (HANZI CHAR (30 ) CCSID 935 NOT NULL WITHDEFAULT)