语源科技BlogJava-◎ヤ撧吥菔瀭o┊。

[转]MyEclipse7.1插件安装

優雅Ｄě頽廢 — Tue, 08 Sep 2009 09:23:00 GMT

最近刚使用MyEclise 7.1 ，发现期插件安装与以前有所不同。

MyEclipse 7.1 的安装目录结构如下：

view plaincopy to clipboardprint?
1. Genuitec
2.        ├─Common
3.        │ ├─configuration
4.        │ ├─features
5.        │ └─plugins
6.        └─MyEclipse 7.1
7.            ├─configuration
8.            └─dropins
   1. Genuitec
   2.        ├─Common
   3.        │ ├─configuration
   4.        │ ├─features
   5.        │ └─plugins
   6.        └─MyEclipse 7.1
   7.            ├─configuration
   8.            └─dropins   最新的插件安装方式，要求将插件安装在上图中的dropins节点。并且要求以如下结构安装

dropins-->插件文件夹(可由安装者定制)-->eclipse-->plugins+features

例如，我以fat插件作为安装示例，目录结构图如下：

view plaincopy to clipboardprint?
1. Genuitec
2.     ├─Common
3.     │ ├─configuration
4.     │ ├─features
5.     │ └─plugins
6.     └─MyEclipse 7.1
7.         ├─configuration
8.         └─dropins
9.             └─fat
10.                 └─eclipse
11.                     ├─features
12.                     └─plugins
13.                         └─net.sf.fjep.fatjar_0.0.31(插件)
   1. Genuitec
   2.     ├─Common
   3.     │ ├─configuration
   4.     │ ├─features
   5.     │ └─plugins
   6.     └─MyEclipse 7.1
   7.         ├─configuration
   8.         └─dropins
   9.             └─fat
10.                 └─eclipse
11.                     ├─features
12.                     └─plugins
13.                         └─net.sf.fjep.fatjar_0.0.31(插件)   安装好后重新启动MyEclipse7 .1 ,插件的效果就出来了--当然前提是你的插件支持当前eclipse版本。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/guo_rui22/archive/2009/07/07/4327539.aspx

優雅Ｄě頽廢 2009-09-08 17:23 发表评论

Eclipse插件管理

優雅Ｄě頽廢 — Sun, 13 Jul 2008 11:31:00 GMT

Eclipse插件管理

提示：新下载的插件PlugIn一定不要都放在原始的Eclipse目录下去，一大堆，累死你：（

前提是你已经下载解压并设置好Eclipse工具，比如解压在E:\OpenSource\Eclipse\目录下，以下这个目录以%ECLIPSE_HOME%来进行表示；
此时默认的插件是在%ECLIPSE_HOME%\plugins目录中的；
在%ECLIPSE_HOME%下建立一个PlugInsNew的目录；
　　比如：E:\OpenSource\Eclipse\PlugInsNew
如果你下载了一个新的插件，比如叫做：XYZ
　　那么就在%ECLIPSE_HOME%\PlugInsNew\目录下建立XYZ目录，目录里面是eclipse目录，eclipse目录包含有features与plugins两个子目录；结构如下图所示：
把下载的新插件的文件放在以下相应目录中；
　　%ECLIPSE_HOME%\PlugInsNew\XYZ\eclipse\features

　　%ECLIPSE_HOME%\PlugInsNew\ XYZ\eclipse\plugins
建立相关的.link的文件；
　　然后在%ECLIPSE_HOME%\links目录里建立一个XYZ.link的文件

　　内容如是：

　　path=E:/OpenSource/Eclipse/PlugInsNew/XYZ

　　就一行这样的路径指示而已。

　　这样，如果你下载了多个插件就可以如法炮制建立多个Link文件，想加载哪个插件就把哪个插件的Link文件放到%ECLIPSE_HOME%\links的目录中即可，使用与管理都很方便，建议千万不要放在默认的安装目录中，这样对于升级Eclipse主程序也方便一些；当然如果你喜欢用Find and Install…进行安装的话也可以的；

　　如果上面你的%ECLIPSE_HOME%与此不同，请修改XYZ.link文件里的路径。
删除插件，先关闭Eclipse；
　　删除%ECLIPSE_HOME%\links\XYZ.link文件即可

　　删除%ECLIPSE_HOME%\PlugInsNew\XYZ整个目录及文件
重新启动Eclipse，这样就可以了。如果插件没有生效或者没有删除，请加上-clean进行启动Eclipse，即Eclipse.exe –clean
插件安装验证及记录详见：Eclipse的workspace下面的.metadata\.log文件，比如：%ECLIPSE_HOME%\workspace\.metadata\.log文件，有问题的话，打开这个文件看看并进行解决。
转载别人的，希望大家都能学习！！！

優雅Ｄě頽廢 2008-07-13 19:31 发表评论

DBA必须熟悉的、最有用的DBA视图

優雅Ｄě頽廢 — Fri, 12 Oct 2007 06:48:00 GMT

dba_data_files 关于数据库文件的信息

dba_db_links 数据库中的所有数据库链路

dba_extents 数据库中包括所有分区

dba_free_space 所有表空间中自由分区

dba_indexes 数据库中所有索引的描述

dba_ind_columns 在所有表及聚族上压缩索引的列

dba_objects 数据库中所有的对象

dba_rollback_segs 回滚段的描述

dba_segments 为所有数据库段分配的存储空间

dba_sequences 数据库中所有顺序书的描述

dba_synonyms 数据库中所有同义词

dba_tables 数据库中所有表的描述

dba_tablespaces 数据库中所有表空间的描述

dba_tab_columns 所有表描述、视图以及聚族的列

dba_tab_grants 数据库中对象所授的权限

dba_tab_privs 数据库中对象所授的权限

dba_ts_quotas 所有用户表空间限额

dba_users 关于数据库的所有用户信息

dba_views 数据库中所有视图

優雅Ｄě頽廢 2007-10-12 14:48 发表评论

execute immediate

優雅Ｄě頽廢 — Thu, 11 Oct 2007 07:21:00 GMT

EXECUTE IMMEDIATE代替了以前Oracle8i中DBMS_SQL package包.它解析并马上执行动态的SQL语句或非运行时创建的PL/SQL块.动态创建和执行SQL语句性能超前，EXECUTE IMMEDIATE的目标在于减小企业费用并获得较高的性能，较之以前它相当容易编码.尽管DBMS_SQL仍然可用，但是推荐使用EXECUTE IMMEDIATE,因为它获的收益在包之上。

使用技巧

1. EXECUTE IMMEDIATE将不会提交一个DML事务执行，应该显式提交
如果通过EXECUTE IMMEDIATE处理DML命令，那么在完成以前需要显式提交或者作为EXECUTE IMMEDIATE自己的一部分. 如果通过EXECUTE IMMEDIATE处理DDL命令,它提交所有以前改变的数据

2. 不支持返回多行的查询,这种交互将用临时表来存储记录(参照例子如下)或者用REF cursors.

3. 当执行SQL语句时，不要用分号，当执行PL/SQL块时，在其尾部用分号.

4. 在Oracle手册中，未详细覆盖这些功能。下面的例子展示了所有用到Execute immediate的可能方面.希望能给你带来方便.

5. 对于Forms开发者,当在PL/SQL 8.0.6.3.版本中，Forms 6i不能使用此功能.

EXECUTE IMMEDIATE用法例子

1. 在PL/SQL运行DDL语句

begin
execute immediate 'set role all';
end;

2. 给动态语句传值(USING 子句)

declare
l_depnam varchar2(20) := 'testing';
l_loc varchar2(10) := 'Dubai';
begin
execute immediate 'insert into dept values (:1, :2, :3)'
using 50, l_depnam, l_loc;
commit;
end;

3. 从动态语句检索值(INTO子句)

declare
l_cnt varchar2(20);
begin
execute immediate 'select count(1) from emp'
into l_cnt;
dbms_output.put_line(l_cnt);
end;

4. 动态调用例程.例程中用到的绑定变量参数必须指定参数类型.?]认为IN类型,其它类型必须显式指定

declare
l_routin varchar2(100) := 'gen2161.get_rowcnt';
l_tblnam varchar2(20) := 'emp';
l_cnt number;
l_status varchar2(200);
begin
execute immediate 'begin ' || l_routin || '(:2, :3, :4); end;'
using in l_tblnam, out l_cnt, in out l_status;

if l_status != 'OK' then
dbms_output.put_line('error');
end if;
end;

5. 将返回值传递到PL/SQL记录类型;同样也可用%rowtype变量

declare
type empdtlrec is record (empno number(4),
ename varchar2(20),
deptno number(2));
empdtl empdtlrec;
begin
execute immediate 'select empno, ename, deptno ' ||
'from emp where empno = 7934'
into empdtl;
end;

6. 传递并检索值.INTO子句用在USING子句前

declare
l_dept pls_integer := 20;
l_nam varchar2(20);
l_loc varchar2(20);
begin
execute immediate 'select dname, loc from dept where deptno = :1'
into l_nam, l_loc
using l_dept ;
end;

7. 多行查询选项.对此选项用insert语句填充临时表，用临时表进行进一步的处理,也可以用REF cursors纠正此缺憾.

declare
l_sal pls_integer := 2000;
begin
execute immediate 'insert into temp(empno, ename) ' ||
' select empno, ename from emp ' ||
' where sal > :1'
using l_sal;
commit;
end;

对于处理动态语句,EXECUTE IMMEDIATE比以前可能用到的更容易并且更高效.当意图执行动态语句时，适当地处理异常更加重要.应该关注于捕获所有可能的异常.

優雅Ｄě頽廢 2007-10-11 15:21 发表评论

DBA应遵循的oracle调优原则

優雅Ｄě頽廢 — Thu, 11 Oct 2007 07:00:00 GMT

Oracle 调优是一个复杂的主题。关于调优可以写整整一本书，不过，为了改善 Oracle 数据库的性能，有一些基本的概念是每个 Oracle DBA 都应该遵从的。

在这篇简介中，我们将简要地介绍以下的 Oracle 主题：

-- 外部调整：我们应该记住 Oracle 并不是单独运行的。因此我们将查看一下通过调整 Oracle 服务器以得到高的性能。

--Row re-sequencing 以减少磁盘 I/O ：我们应该懂得 Oracle 调优最重要的目标是减少 I/O 。

--Oracle SQL 调整。 Oracle SQL 调整是 Oracle 调整中最重要的领域之一，只要通过一些简单的 SQL 调优规则就可以大幅度地提升 SQL 语句的性能，这是一点都不奇怪的。

-- 调整 Oracle 排序：排序对于 Oracle 性能也是有很大影响的。

-- 调整 Oracle 的竞争：表和索引的参数设置对于 UPDATE 和 INSERT 的性能有很大的影响。

我们首先从调整 Oracle 外部的环境开始。如果内存和 CPU 的资源不足的话，任何的 Oracle 调整都是没有帮助的。

外部的性能问题

Oracle 并不是单独运行的。 Oracle 数据库的性能和外部的环境有很大的关系。这些外部的条件包括有：

． CPU--CPU 资源的不足令查询变慢。当查询超过了 Oracle 服务器的 CPU 性能时，你的数据库性能就受到 CPU 的限制。

．内存 -- 可用于 Oralce 的内存数量也会影响 SQL 的性能，特别是在数据缓冲和内存排序方面。

．网络 -- 大量的 Net8 通信令 SQL 的性能变慢。

许多新手都错误的认为应该首先调整 Oracle 数据库，而不是先确认外部资源是否足够。实际上，如果外部环境出现瓶颈，再多的 Oracle 调整都是没有帮助的。

在检查 Oracle 的外部环境时，有两个方面是需要注意的：

1 、当运行队列的数目超过服务器的 CPU 数量时，服务器的性能就会受到 CPU 的限制。补救的方法是为服务器增加额外的 CPU 或者关闭需要很多处理资源的组件，例如 Oracle Parallel Query 。

2 、内存分页。当内存分页时，内存容量已经不足，而内存页是与磁盘上的交换区进行交互的。补救的方法是增加更多的内存，减少 Oracle SGA 的大小，或者关闭 Oracle 的多线程服务器。

可以使用各种标准的服务器工具来得到服务器的统计数据，例如 vmstat,glance,top 和 sar 。 DBA 的目标是确保数据库服务器拥有足够的 CPU 和内存资源来处理 Oracle 的请求。

以下让我们来看一下 Oracle 的 row-resequencing 是如何能够极大地减少磁盘 I/O 的。

Row-resequencing （行的重新排序）

就象我们上面提到的，有经验的 Oracle DBA 都知道 I/O 是响应时间的最大组成部分。其中磁盘 I/O 特别厉害，因为当 Oracle 由磁盘上的一个数据文件得到一个数据块时，读的进程就必须等待物理 I/O 操作完成。磁盘操作要比数据缓冲慢 10,000 倍。因此，如果可以令 I/O 最小化，或者减少由于磁盘上的文件竞争而带来的瓶颈，就可以大大地改善 Oracle 数据库的性能。

如果系统响应很慢，通过减少磁盘 I/O 就可以有一个很快的改善。如果在一个事务中通过按一定的范围搜索 primary-key 索引来访问表，那么重新以 CTAS 的方法组织表将是你减少 I/O 的首要策略。通过在物理上将行排序为和 primary-key 索引一样的顺序，就可以加快获得数据的速度。

就象磁盘的负载平衡一样，行的重新排序也是很简单的，而且也很快。通过与其它的 DBA 管理技巧一起使用，就可以在高 I/O 的系统中大大地减少响应的时间。

在高容量的在线事务处理环境中（ online transaction processing ， OLTP ），数据是由一个 primary 索引得到的，重新排序表格的行就可以令连续块的顺序和它们的 primary 索引一样，这样就可以在索引驱动的表格查询中，减少物理 I/O 并且改善响应时间。这个技巧仅在应用选择多行的时候有用，或者在使用索引范围搜索和应用发出多个查询来得到连续的 key 时有效。对于随机的唯一 primary-key （主键）的访问将不会由行重新排序中得到好处。

让我们看一下它是如何工作的。考虑以下的一个 SQL 的查询，它使用一个索引来得到 100 行：

select salary from employee where last_name like 'B%';

这个查询将会使用 last_name_index ，搜索其中的每一行来得到目标行。这个查询将会至少使用 100 次物理磁盘的读取，因为 employee 的行存放在不同的数据块中。

不过，如果表中的行已经重新排序为和 last_name_index 的一样，同样的查询又会怎样处理呢？我们可以看到这个查询只需要三次的磁盘 I/O 就读完全部 100 个员工的资料（一次用作索引的读取，两次用作数据块的读取），减少了 97 次的块读取。

重新排序带来的性能改善的程度在于在你开始的时候行的乱序性如何，以及你需要由序列中访问多少行。至于一个表中的行与索引的排序键的匹配程度，可以查看数据字典中的 dba_indexes 和 dba_tables 视图得到。

在 dba_indexes 的视图中，查看 clustering_factor 列。如果 clustering_factor 的值和表中的块数目大致一样，那么你的表和索引的顺序是一样的。不过，如果 clustering_factor 的值接近表中的行数目，那就表明表格中的行和索引的顺序是不一样的。

行重新排序的作用是不可以小看的。在需要进行大范围的索引搜索的大表中，行重新排序可以令查询的性能提高三倍。

一旦你已经决定重新排序表中的行，你可以使用以下的工具之一来重新组织表格。

. 使用 Oracle 的 Create Table As Select (CTAS) 语法来拷贝表格

. Oracle9i 自带的表格重新组织工具

SQL 调优

Oracle 的 SQL 调优是一个复杂的主题，甚至是需要整本书来介绍 Oracle SQL 调优的细微差别。不过有一些基本的规则是每个 Oracle DBA 都需要跟从的，这些规则可以改善他们系统的性能。 SQL 调优的目标是简单的：

. 消除不必要的大表全表搜索：不必要的全表搜索导致大量不必要的 I/O ，从而拖慢整个数据库的性能。调优专家首先会根据查询返回的行数目来评价 SQL 。在一个有序的表中，如果查询返回少于 40% 的行，或者在一个无序的表中，返回少于 7% 的行，那么这个查询都可以调整为使用一个索引来代替全表搜索。对于不必要的全表搜索来说，最常见的调优方法是增加索引。可以在表中加入标准的 B 树索引，也可以加入 bitmap 和基于函数的索引。要决定是否消除一个全表搜索，你可以仔细检查索引搜索的 I/O 开销和全表搜索的开销，它们的开销和数据块的读取和可能的并行执行有关，并将两者作对比。在一些情况下，一些不必要的全表搜索的消除可以通过强制使用一个 index 来达到，只需要在 SQL 语句中加入一个索引的提示就可以了。

. 在全表搜索是一个最快的访问方法时，将小表的全表搜索放到缓存中，调优专家应该确保有一个专门的数据缓冲用作行缓冲。在 Oracle7 中，你可以使用 alter table xxx cache 语句，在 Oracle8 或以上，小表可以被强制为放到 KEEP 池中缓冲。

. 确保最优的索引使用：对于改善查询的速度，这是特别重要的。有时 Oracle 可以选择多个索引来进行查询，调优专家必须检查每个索引并且确保 Oracle 使用正确的索引。它还包括 bitmap 和基于函数的索引的使用。

. 确保最优的 JOIN 操作：有些查询使用 NESTED LOOP join 快一些，有些则是 HASH join 快一些，另外一些则是 sort-merge join 更快。

这些规则看来简单，不过它们占 SQL 调优任务的 90% ，并且它们也无需完全懂得 Oracle SQL 的内部运作。以下我们来简单概览以下 Oracle SQL 的优化。

我们首先简要查看 Oracle 的排序，并且看一看排序操作是如何影响性能的。

调整 Oracle 的排序操作

排序是 SQL 语法中一个小的方面，但很重要，在 Oracle 的调整中，它常常被忽略。当使用 create index 、 ORDER BY 或者 GROUP BY 的语句时， Oracle 数据库将会自动执行排序的操作。通常，在以下的情况下 Oracle 会进行排序的操作：

使用 Order by / Group by 的 SQL 语句

在创建索引的时候:

进行 table join 时，由于现有索引的不足而导致 SQL 优化器调用 MERGE SORT。

当与 Oracle 建立起一个 session 时，在内存中就会为该 session 分配一个私有的排序区域。如果该连接是一个专用的连接 (dedicated connection) ，那么就会根据 init.ora 中 sort_area_size 参数的大小在内存中分配一个 Program Global Area (PGA) 。如果连接是通过多线程服务器建立的，那么排序的空间就在 large_pool 中分配。不幸的是，对于所有的 session ，用做排序的内存量都必须是一样的，我们不能为需要更大排序的操作分配额外的排序区域。因此，设计者必须作出一个平衡，在分配足够的排序区域以避免发生大的排序任务时出现磁盘排序（ disk sorts ）的同时，对于那些并不需要进行很大排序的任务，就会出现一些浪费。当然，当排序的空间需求超出了 sort_area_size 的大小时，这时将会在 TEMP 表空间中分页进行磁盘排序。磁盘排序要比内存排序大概慢 14,000 倍。

上面我们已经提到，私有排序区域的大小是有 init.ora 中的 sort_area_size 参数决定的。每个排序所占用的大小由 init.ora 中的 sort_area_retained_size 参数决定。当排序不能在分配的空间中完成时，就会使用磁盘排序的方式，即在 Oracle 实例中的临时表空间中进行。

磁盘排序的开销是很大的，有几个方面的原因。首先，和内存排序相比较，它们特别慢；而且磁盘排序会消耗临时表空间中的资源。 Oracle 还必须分配缓冲池块来保持临时表空间中的块。无论什么时候，内存排序都比磁盘排序好，磁盘排序将会令任务变慢，并且会影响 Oracle 实例的当前任务的执行。还有，过多的磁盘排序将会令 free buffer waits 的值变高，从而令其它任务的数据块由缓冲中移走。

接着，让我们看一下 Oracle 的竞争，并且看一下表的存储参数的设置是如何影响 SQL UPDATE 和 INSERT 语句的性能的。

调整 Oracle 的竞争

Oracle 的其中一个优点时它可以管理每个表空间中的自由空间。 Oracle 负责处理表和索引的空间管理，这样就可以让我们无需懂得 Oracle 的表和索引的内部运作。不过，对于有经验的 Oracle 调优专家来说，他需要懂得 Oracle 是如何管理表的 extent 和空闲的数据块。对于调整拥有高的 insert 或者 update 的系统来说，这是非常重要的。

要精通对象的调整，你需要懂得 freelists 和 freelist 组的行为，它们和 pctfree 及 pctused 参数的值有关。这些知识对于企业资源计划（ ERP ）的应用是特别重要的，因为在这些应用中，不正确的表设置通常是 DML 语句执行慢的原因。

对于初学者来说，最常见的错误是认为默认的 Oracle 参数对于所有的对象都是最佳的。除非磁盘的消耗不是一个问题，否则在设置表的 pctfree 和 pctused 参数时，就必须考虑平均的行长和数据库的块大小，这样空的块才会被有效地放到 freelists 中。当这些设置不正确时，那些得到的 freelists 也是 “dead”块，因为它们没有足够的空间来存储一行，这样将会导致明显的处理延迟。

Freelists 对于有效地重新使用 Oracle 表空间中的空间是很重要的，它和 pctfree 及 pctused 这两个存储参数的设置直接相关。通过将 pctused 设置为一个高的值，这时数据库就会尽快地重新使用块。

当有一个请求需要插入一行到表格中时， Oracle 就会到 freelist 中寻找一个有足够的空间来容纳一行的块。你也许知道， freelist 串是放在表格或者索引的第一个块中，这个块也被称为段头（ segment header ）。 pctfree 和 pctused 参数的唯一目的就是为了控制块如何在 freelists 中进出。虽然 freelist link 和 unlink 是简单的 Oracle 功能，不过设置 freelist link (pctused) 和 unlink (pctfree) 对 Oracle 的性能确实有影响。

由 DBA 的基本知识知道， pctfree 参数是控制 freelist un-links 的（即将块由 freelists 中移除）。设置 pctfree=10 意味着每个块都保留 10% 的空间用作行扩展。 pctused 参数是控制 freelist re-links 的。设置 pctused=40 意味着只有在块的使用低于 40% 时才会回到表格的 freelists 中。

许多新手对于一个块重新回到 freelists 后的处理都有些误解。其实，一旦由于一个删除的操作而令块被重新加入到 freelist 中，它将会一直保留在 freelist 中即使空间的使用超过了 60% ，只有在到达 pctfree 时才会将数据块由 freelist 中移走。

表格和索引存储参数设置的要求总结

以下的一些规则是用来设置 freelists, freelist groups, pctfree 和 pctused 存储参数的。你也知道， pctused 和 pctfree 的值是可以很容易地通过 alter table 命令修改的，一个好的 DBA 应该知道如何设置这些参数的最佳值。

有效地使用空间和高性能之间是有矛盾的，而表格的存储参数就是控制这个方面的矛盾：

. 对于需要有效地重新使用空间，可以设置一个高的 pctused 值，不过副作用是需要额外的 I/O 。一个高的 pctused 值意味着相对满的块都会放到 freelist 中。因此，这些块在再次满之前只可以接受几行记录，从而导致更多的 I/O 。

. 追求高性能的话，可以将 pctused 设置为一个低的值，这意味着 Oracle 不会将数据块放到 freelists 中直到它几乎是空的。那么块将可以在满之前接收更多的行，因此可以减少插入操作的 I/O 。要记住 Oracle 扩展新块的性能要比重新使用现有的块高。对于 Oracle 来说，扩展一个表比管理 freelists 消耗更少的资源。

让我们来回顾一下设置对象存储参数的一些常见规则：

．经常将 pctused 设置为可以接收一条新行。对于不能接受一行的 free blocks 对于我们来说是没有用的。如果这样做，将会令 Oracle 的性能变慢，因为 Oracle 将在扩展表来得到一个空的块之前，企图读取 5 个 “dead”的 free block 。

．表格中 chained rows 的出现意味着 pctfree 太低或者是 db_block_size 太少。在很多情况下， RAW 和 LONG RAW 列都很巨大，以至超过了 Oracle 的最大块的大小，这时 chained rows 是不可以避免的。

．如果一个表有同时插入的 SQL 语句，那么它需要有同时删除的语句。运行单一个一个清除的工作将会把全部的空闲块放到一个 freelist 中，而没有其它包含有任何空闲块的 freelists 出现。

． freelist 参数应该设置为表格同时更新的最大值。例如，如果在任何时候，某个表最多有 20 个用户执行插入的操作，那么该表的参数应该设置为 freelists=20 。

应记住的是 freelist groups 参数的值只是对于 Oracle Parallel Server 和 Real Application Clusters 才是有用的。对于这类 Oracle ， freelist groups 应该设置为访问该表格的 Oracle Parallel Server 实例的数目。

優雅Ｄě頽廢 2007-10-11 15:00 发表评论

关于oracle中的空值

優雅Ｄě頽廢 — Thu, 11 Oct 2007 03:14:00 GMT

在数据库中，空值用来表示实际值未知或无意义的情况。在一个表中，如果一行中的某列没有值，那么就称它为空值（NULL）。任何数据类型的列, 只要没有使用非空（NOT NULL）或主键（PRIMARY KEY）完整性限制，都可以出现空值。在实际应用中，如果忽略空值的存在，将会造成造成不必要的麻烦。

---- 例如，在下面的雇员表（EMP）中，雇员名（ENAME）为KING 的行，因为KING 为最高官员（PRESIDENT），他没有主管（MGR），所以其MGR 为空值。因为不是所有的雇员都有手续费（COMM），所以列COMM 允许有空值，除300、500、1400、0 以外的其它各行COMM 均为空值。

EMPNO ENAME    JOB       MGR HIREDATE    SAL   COMM  DEPTNO

---- -------- -------- --------- -------- ------ ---------

7369 SMITH     CLERK     7902 17-DEC-80  800           20

7499 ALLEN     SALESMAN  7698 20-FEB-81  1600    300   30

7521 WARD      SALESMAN  7698 22-FEB-81  1250    500   30

7566 JONES     MANAGER   7839 02-APR-81  2975          20

7654 MARTIN    SALESMAN  7698 28-SEP-81  1250   1400   30

7698 BLAKE     MANAGER   7839 01-MAY-81  2850          30

7782 CLARK     MANAGER   7839 09-JUN-81  2450          10

7788 SCOTT     ANALYST   7566 09-DEC-82  3000          20

7839 KING      PRESIDENT      17-NOV-81  5000          10

7844 TURNER    SALESMAN  7698 08-SEP-81  1500      0   30

7876 ADAMS     CLERK     7788 12-JAN-83  1100          20

7900 JAMES     CLERK     7698 03-DEC-81   950          30

7902 FORD      ANALYST   7566 03-DEC-81  3000          20

7934 MILLER    CLERK     7782 23-JAN-82  1300          10

---- 本文将以上述EMP 表为例，具体讨论一下空值在日常应用中所具有的一些特性。

---- 一、空值的生成及特点

---- 1. 空值的生成

---- 如果一列没有非空（NOT NULL）完整性限制，那么其缺省的值为空值，即如果插入一行时未指定该列的值，则其值为空值。

---- 使用SQL 语句INSERT 插入行，凡未涉及到的列，其值为空值；涉及到的列，如果其值确实为空值，插入时可以用NULL 来表示（对于字符型的列，也可以用'' 来表示）。

---- 例：插入一行，其EMPNO 为1、ENAME 为'JIA'、SAL 为10000、job 和comm 为空值。

SQL >insert into emp(empno,ename,job,sal,comm) 

values(1,'JIA',NULL,1000,NULL);

SQL >select * from emp where empno=1;

EMPNO ENAME  JOB   MGR HIREDATE    SAL    COMM    DEPTNO

--------- ---------- --------- --------- --------- ---------

1 JIA         1000

---- 可以看到新插入的一行，除job 和comm 为空值外，mgr、hiredate、deptno 三列由于插入时未涉及，也为空值。

---- 使用SQL 语句UPDATE 来修改数据，空值可用NULL 来表示（对于字符型的列，也可以用'' 来表示）。例:

SQL >update emp set ename=NULL,sal=NULL where empno=1;

---- 2. 空值的特点

---- 空值具有以下特点：

---- * 等价于没有任何值。

---- * 与 0、空字符串或空格不同。

---- * 在where 条件中, Oracle 认为结果为NULL 的条件为FALSE，带有这样条件的select 语句不返回行，并且不返回错误信息。但NULL 和FALSE 是不同的。

---- * 排序时比其他数据都大。

---- * 空值不能被索引。

---- 二、空值的测试

---- 因为空值表示缺少数据，所以空值和其它值没有可比性，即不能用等于、不等于、大于或小于和其它数值比较，当然也包括空值本身（但是在decode 中例外，两个空值被认为是等价）。测试空值只能用比较操作符IS NULL 和IS NOT NULL。如果使用带有其它比较操作符的条件表达式，并且其结果依赖于空值，那么其结果必定是NULL。在where 条件中，Oracle 认为结果为NULL 的条件为FALSE，带有这样条件的select 语句不返回行，也不返回错误信息。

---- 例如查询EMP 表中MGR 为NULL 的行：

SQL >select * from emp where mgr='';  

no rows selected

SQL >select * from emp where mgr=null;  

no rows selected

SQL >select * from emp where mgr is null;

EMPNO ENAME  JOB  MGR HIREDATE   SAL  COMM  DEPTNO

---------- --------- --------- --------- ---------

7839 KING  PRESIDENT  17-NOV-81  5000        10

---- 第1、2 句写法不妥，WHERE 条件结果为NULL，不返回行。第三句正确，返回MGR 为空值的行。

---- 三、空值和操作符

---- 1. 空值和逻辑操作符

---- 逻辑操作符

---- 表达式

---- 结果

AND

NULL AND TRUE

NULL



NULL AND FALSE

FALSE



NULL AND NULL

NULL

OR

NULL OR TRUE

TRUE



NULL OR FALSE

NULL



NULL OR NULL

NULL

NOT

NOT NULL

NULL

---- 可以看到，在真值表中，除NULL AND FALSE 结果为FALSE、NULL OR TRUE 结果为TRUE 以外，其它结果均为NULL。

---- 虽然在where 条件中，Oracle 认为结果为NULL 的WHERE 条件为FALSE，但在条件表达式中NULL 不同于FALSE。例如在NOT （ NULL AND FALSE ）和NOT （ NULL AND NULL ）二者中仅有一处FALSE 和TRUE 的区别，但NOT （ NULL AND FALSE ）的结果为 TRUE，而NOT （ NULL AND NULL ）的结果为NULL。

---- 下面举例说明空值和逻辑操作符的用法：

SQL > select * from emp where not comm=null and comm!=0;

no rows selected

SQL > select * from emp where not ( not comm=null and comm!=0 );

EMPNO ENAME  JOB      MGR  HIREDATE  SAL  COMM  DEPTNO

---------- --------- --------- --------- ---------

7844 TURNER SALESMAN  7698 08-SEP-81 1500   0     30

---- 第一个Select 语句，条件"not comm=null and comm!=0" 等价于NULL AND COMM!=0。对于任意一行，如果COMM 为不等于0 的数值，条件等价于NULL AND TRUE，结果为NULL；如果COMM 等于0，条件等价于NULL AND FALSE，结果为FALSE。所以，最终结果不返回行。

---- 第二个Select 语句的条件为第一个Select 语句条件的" 非"（NOT），对于任意一行，如果COMM 为不等于0 的数值，条件等价于NOT NULL，结果为NULL；如果COMM 等于0，条件等价于NOT FALSE，结果为TRUE。所以，最终结果返回行COMM 等于0 的行。

---- 2. 空值和比较操作符

---- （1）IS [NOT] NULL：是用来测试空值的唯一操作符（见" 空值的测试"）。

（2）=、!=、>=、<=、>、<

SQL >select ename,sal,comm from emp where sal >comm;

ENAME            SAL      COMM

---------- --------- ---------

ALLEN           1600       300

WARD            1250       500

TURNER          1500         0

---- sal 或comm 为空值的行，sal>comm 比较结果为NULL，所以凡是sal 或comm 为空值的行都没有返回。

---- （3）IN 和NOT IN 操作符

SQL >select ename,mgr from emp where mgr in (7902,NULL);

ENAME            MGR

---------- ---------

SMITH           7902

---- 在上述语句中，条件"mgr in (7902,NULL)" 等价于mgr=7902 or mgr=NULL。对于表EMP 中的任意一行，如果mgr 为NULL，则上述条件等价于NULL OR NULL，即为NULL；如果mgr 为不等于7902 的数值，则上述条件等价于FALSE OR NULL，即为NULL；如果mgr 等于7902，则上述条件等价于TRUE OR NULL，即为TRUE。所以，最终结果能返回mgr 等于7902 的行。

SQL >select deptno from emp where deptno not in ('10',NULL);

no rows selected

---- 在上述语句中，条件"deptno not in ('10',NULL)" 等价于deptno!='10' and deptno!=NULL，对于EMP 表中的任意一行，条件的结果只能为NULL 或FALSE，所以不返回行。

---- （4）any,some

SQL >select ename,sal from emp where sal > any(3000,null);

ENAME            SAL

---------- ---------

KING            5000

---- 条件"sal > any(3000,null)" 等价于sal >3000 or sal >null。类似前述（3）第一句，最终结果返回所有sal >3000 的行。

---- （5）All

SQL >select ename,sal from emp where sal > all(3000,null);

no rows selected

---- 条件"sal> all(3000,null)" 等价于sal >3000 and sal >null, 结果只能为NULL 或FALSE，所以不返回行。

---- （6）（not）between

SQL >select ename,sal from emp where sal between null and 3000;

no rows selected

---- 条件"sal between null and 3000" 等价于sal >=null and sal< =3000, 结果只能为NULL 或FALSE，所以不返回行。

SQL >select ename,sal from emp where sal not between null and 3000;

ENAME            SAL

---------- ---------

KING            5000

---- 条件"sal not between null and 3000" 等价于sal3000, 类似前述（3）的第一句，结果返回sal>3000 的行。

---- 下表为比较操作符和空值的小结：

---- 比较操作符

---- 表达式（例：A、B 是NULL、C=10）

---- 结果

IS NULL、IS NOT NULL

A IS NULL

TRUE



A IS NOT NULL

FALSE



C IS NULL

FALSE



C IS NOT NULL

TRUE

=、!=、>=、< =、>、< 

A = NULL

NULL



A > NULL

NULL



C = NULL

NULL



C > NULL

NULL

IN (=ANY)

A IN (10,NULL)

NULL



C IN (10,NULL)

TRUE



C IN (20,NULL)

NULL

NOT IN 

( 等 价 于 ！=ALL)

A NOT IN (20,NULL)

NULL



C NOT IN (20,NULL)

FALSE



C NOT IN (10,NULL)

NULL

ANY，SOME

A > ANY(5,NULL)

NULL



C > ANY(5,NULL)

TRUE



C > ANY(15,NULL)

NULL

ALL

A > ALL(5,NULL)

NULL



C > ALL(5,NULL)

NULL



C > ALL(15,NULL)

FALSE

(NOT)BETWEEN

A BETWEEN 5 AND NULL

NULL



C BETWEEN 5 AND NULL

NULL



C BETWEEN 15 AND NULL

FALSE



A NOT BETWEEN 5 AND NULL

NULL



C NOT BETWEEN 5 AND NULL

NULL



C NOT BETWEEN 15 AND NULL

TRUE

---- 3、空值和算术、字符操作符

---- （1）算术操作符：空值不等价于0，任何含有空值的算术表达式其运算结果都为空值，例如空值加10 为空值。

---- （2）字符操作符||：因为ORACLE 目前处理零个字符值的方法与处理空值的方法相同（日后的版本中不一定仍然如此），所以对于||，空值等价于零个字符值。例：

SQL >select ename,mgr,ename||mgr,sal,comm,sal+comm from emp;

ENAME            MGR ENAME||MGR          SAL      COMM  SAL+COMM

---------- --------- ------------- --------- --------- ---------

SMITH           7902 SMITH7902           800 

ALLEN           7698 ALLEN7698          1600       300      1900

WARD            7698 WARD7698           1250       500      1750

JONES           7839 JONES7839          2975 

MARTIN          7698 MARTIN7698         1250      1400      2650

BLAKE           7839 BLAKE7839          2850 

CLARK           7839 CLARK7839          2450 

SCOTT           7566 SCOTT7566          3000 

KING                 KING               5000 

TURNER          7698 TURNER7698         1500         0      1500

ADAMS           7788 ADAMS7788          1100 

JAMES           7698 JAMES7698           950 

FORD            7566 FORD7566           3000 

MILLER          7782 MILLER7782         1300

---- 我们可以看到，凡mgr 为空值的，ename||mgr 结果等于ename；凡是comm 为空值的行，sal+comm 均为空值。

---- 四、空值和函数

---- 1 ．空值和度量函数

---- 对于度量函数，如果给定的参数为空值，则其（NVL、TRANSLATE 除外）返回值为空值。如下例中的ABS（COMM），如果COMM 为空值，ABS(COMM) 为空值。

SQL > select ename,sal,comm,abs(comm) from emp where sal< 1500;

ENAME            SAL      COMM ABS(COMM)

---------- --------- --------- ---------

SMITH            800

WARD            1250       500       500

MARTIN          1250      1400      1400

ADAMS           1100

JAMES            950

MILLER          1300

---- 2. 空值和组函数

---- 组函数忽略空值。在实际应用中，根据需要可利用nvl 函数用零代替空值。例：

SQL >select count(comm),sum(comm),avg(comm) from emp;

COUNT(COMM) SUM(COMM) AVG(COMM)

----------- --------- ---------

4      2200       550

SQL >select count(nvl(comm,0)),sum(nvl(comm,0)),avg(nvl(comm,0))

from emp;

COUNT(NVL(COMM,0)) SUM(NVL(COMM,0)) AVG(NVL(COMM,0))

------------------ ---------------- ----------------

14             2200        157.14286

---- 第一个SELECT 语句忽略COMM 为空值的行，第二个SELECT 语句使用NVL 函数统计了所有的COMM，所以它们统计的个数、平均值都不相同。另外需要注意的是，在利用组函数进行数据处理时，不同的写法具有不同的不同含义，在实际应用中应灵活掌握。例如：

SQL >select deptno,sum(sal),sum(comm), 

sum(sal+comm),sum(sal)+sum(comm),sum(nvl(sal,0)+nvl(comm,0)) 

from emp

group by deptno;

DEPTNO  SUM(SAL) SUM(COMM) SUM(SAL+COMM) SUM(SAL)

+SUM(COMM) SUM(NVL(SAL,0)+NVL(COMM,0))

--------- --------- --------- ------------- ------- 

10   8750                             8750

20   10875                            10875

30   9400      2200       7800        11600 11600

---- 可以看到SUM(SAL+COMM)、SUM(SAL)+SUM(COMM)、 SUM(NVL(SAL,0)+NVL(COMM,0)) 的区别：SUM(SAL+COMM) 为先加然后计算各行的和，如果SAL、COMM 中有一个为NULL，则该行忽略不计；SUM(SAL)+SUM(COMM) 为先计算各行的合计然后再加，SAL、COMM 中的NULL 都忽略不计，但如果 SUM(SAL)、SUM(COMM) 二者的结果之中有一个为NULL，则二者之和为NULL；在SUM(NVL(SAL,0)+NVL(COMM,0)) 里，SAL、COMM 中的NULL 按0 处理。

---- 五、空值的其它特性

---- 1. 空值在排序时大于任何值。例如：

SQL > select ename,comm from emp where deptno='30' order by comm；

ENAME           COMM

---------- ---------

TURNER             0

ALLEN            300

WARD             500

MARTIN          1400

BLAKE 

JAMES

---- 2. 空值不能被索引。虽然在某列上建立了索引，但是对该列的空值查询来说，因为空值没有被索引，所以不能改善查询的效率。例如下面的查询不能利用在MGR 列上创建的索引。

SQL >select ename from emp where mgr is null;

ENAME

----------

KING

---- 另外正是因为空值不被索引，所以可在含有空值的列上建立唯一性索引（UNIQUE INDEX）。例如，可以在EMP 表的COMM 列上建立唯一性索引：

SQL >  create unique index emp_comm on emp(comm);

Index created.

優雅Ｄě頽廢 2007-10-11 11:14 发表评论

MD5算法的java版本（转）

優雅Ｄě頽廢 — Wed, 19 Sep 2007 10:56:00 GMT

package DPS.AuthCom.Radius;

/*************************************************
md5 类实现了RSA Data Security, Inc.在提交给IETF
的RFC1321中的MD5 message-digest 算法。
*************************************************/

public class MD55
{
/* 下面这些S11-S44实际上是一个4*4的矩阵，在原始的C实现中是用#define 实现的，
这里把它们实现成为static final是表示了只读，切能在同一个进程空间内的多个
Instance间共享*/
static final int S11 = 7;
static final int S12 = 12;
static final int S13 = 17;
static final int S14 = 22;

static final int S21 = 5;
static final int S22 = 9;
static final int S23 = 14;
static final int S24 = 20;

static final int S31 = 4;
static final int S32 = 11;
static final int S33 = 16;
static final int S34 = 23;

static final int S41 = 6;
static final int S42 = 10;
static final int S43 = 15;
static final int S44 = 21;

static final byte[] PADDING =
      {
       -128, 0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
/* 下面的三个成员是MD5计算过程中用到的3个核心数据，在原始的C实现中
     被定义到MD5_CTX结构中

*/
private long[] state = new long[4]; // state (ABCD)
private long[] count = new long[2]; // number of bits, modulo 2^64 (lsb first)
private byte[] buffer = new byte[64]; // input buffer

/* digestHexStr是MD5的唯一一个公共成员，是最新一次计算结果的
　 16进制ASCII表示.
*/
public String digestHexStr;

/* digest,是最新一次计算结果的2进制内部表示，表示128bit的MD5值.
*/
private byte[] digest = new byte[16];

/*
    getMD5ofStr是类MD5最主要的公共方法，入口参数是你想要进行MD5变换的字符串
    返回的是变换完的结果，这个结果是从公共成员digestHexStr取得的．
   */
public String getMD5ofStr(String inbuf)
{
    md5Init();
    md5Update(inbuf.getBytes(), inbuf.length());
    md5Final();
    digestHexStr = "";
    for (int i = 0; i < 16; i++)
    {
      digestHexStr += byteHEX(digest[i]);
    }
    return digestHexStr;
}

// 这是MD5这个类的标准构造函数，JavaBean要求有一个public的并且没有参数的构造函数
public MD55()
{
md5Init();

return;
}

/* md5Init是一个初始化函数，初始化核心变量，装入标准的幻数 */
private void md5Init()
{
    count[0] = 0L;
    count[1] = 0L;
    ///* Load magic initialization constants.

     state[0] = 0x67452301L;
    state[1] = 0xefcdab89L;
    state[2] = 0x98badcfeL;
    state[3] = 0x10325476L;

return;
}

/* F, G, H ,I 是4个基本的MD5函数，在原始的MD5的C实现中，由于它们是
简单的位运算，可能出于效率的考虑把它们实现成了宏，在java中，我们把它们
　　实现成了private方法，名字保持了原来C中的。 */

private long F(long x, long y, long z)
{
return (x & y) | ( (~x) & z);

}

private long G(long x, long y, long z)
{
return (x & z) | (y & (~z));

}

private long H(long x, long y, long z)
{
return x ^ y ^ z;
}

private long I(long x, long y, long z)
{
return y ^ (x | (~z));
}

/*
     FF,GG,HH和II将调用F,G,H,I进行近一步变换
     FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
     Rotation is separate from addition to prevent recomputation.
   */

private long FF(long a, long b, long c, long d, long x, long s,
                  long ac)
{
    a += F(b, c, d) + x + ac;
    a = ( (int) a << s) | ( (int) a >>> (32 - s));
    a += b;
    return a;
}

private long GG(long a, long b, long c, long d, long x, long s,
                  long ac)
{
    a += G(b, c, d) + x + ac;
    a = ( (int) a << s) | ( (int) a >>> (32 - s));
    a += b;
    return a;
}

private long HH(long a, long b, long c, long d, long x, long s,
                  long ac)
{
    a += H(b, c, d) + x + ac;
    a = ( (int) a << s) | ( (int) a >>> (32 - s));
    a += b;
    return a;
}

private long II(long a, long b, long c, long d, long x, long s,
                  long ac)
{
    a += I(b, c, d) + x + ac;
    a = ( (int) a << s) | ( (int) a >>> (32 - s));
    a += b;
    return a;
}

/*
   md5Update是MD5的主计算过程，inbuf是要变换的字节串，inputlen是长度，这个
   函数由getMD5ofStr调用，调用之前需要调用md5init，因此把它设计成private的
   */
private void md5Update(byte[] inbuf, int inputLen)
{

    int i, index, partLen;
    byte[] block = new byte[64];
    index = (int) (count[0] >>> 3) & 0x3F;
    // /* Update number of bits */
    if ( (count[0] += (inputLen << 3)) < (inputLen << 3))
      count[1]++;
    count[1] += (inputLen >>> 29);

partLen = 64 - index;

    // Transform as many times as possible.
    if (inputLen >= partLen)
    {
      md5Memcpy(buffer, inbuf, index, 0, partLen);
      md5Transform(buffer);

for (i = partLen; i + 63 < inputLen; i += 64)
{

        md5Memcpy(block, inbuf, 0, i, 64);
        md5Transform(block);
      }
      index = 0;

}
else

i = 0;

///* Buffer remaining input */
md5Memcpy(buffer, inbuf, index, i, inputLen - i);

}

/*
    md5Final整理和填写输出结果
   */
private void md5Final()
{
    byte[] bits = new byte[8];
    int index, padLen;

///* Save number of bits */
Encode(bits, count, 8);

    ///* Pad out to 56 mod 64.
     index = (int) (count[0] >>> 3) & 0x3f;
    padLen = (index <
    md5Update(PADDING, padLen);

///* Append length (before padding) */
md5Update(bits, 8);

///* Store state in digest */
Encode(digest, state, 16);

}

/* md5Memcpy是一个内部使用的byte数组的块拷贝函数，从input的inpos开始把len长度的
　　　　　字节拷贝到output的outpos位置开始
*/

private void md5Memcpy(byte[] output, byte[] input,
int outpos, int inpos, int len)
{
int i;

for (i = 0; i < len; i++)
output[outpos + i] = input[inpos + i];
}

/*
     md5Transform是MD5核心变换程序，有md5Update调用，block是分块的原始字节
   */
private void md5Transform(byte block[])
{
    long a = state[0], b = state[1], c = state[2], d = state[3];
    long[] x = new long[16];

Decode(x, block, 64);

    /* Round 1 */
    a = FF(a, b, c, d, x[0], S11, 0xd76aa478L); /* 1 */
    d = FF(d, a, b, c, x[1], S12, 0xe8c7b756L); /* 2 */
    c = FF(c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */
    b = FF(b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */
    a = FF(a, b, c, d, x[4], S11, 0xf57c0fafL); /* 5 */
    d = FF(d, a, b, c, x[5], S12, 0x4787c62aL); /* 6 */
    c = FF(c, d, a, b, x[6], S13, 0xa8304613L); /* 7 */
    b = FF(b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */
    a = FF(a, b, c, d, x[8], S11, 0x698098d8L); /* 9 */
    d = FF(d, a, b, c, x[9], S12, 0x8b44f7afL); /* 10 */
    c = FF(c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */
    b = FF(b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */
    a = FF(a, b, c, d, x[12], S11, 0x6b901122L); /* 13 */
    d = FF(d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */
    c = FF(c, d, a, b, x[14], S13, 0xa679438eL); /* 15 */
    b = FF(b, c, d, a, x[15], S14, 0x49b40821L); /* 16 */

    /* Round 2 */
    a = GG(a, b, c, d, x[1], S21, 0xf61e2562L); /* 17 */
    d = GG(d, a, b, c, x[6], S22, 0xc040b340L); /* 18 */
    c = GG(c, d, a, b, x[11], S23, 0x265e5a51L); /* 19 */
    b = GG(b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */
    a = GG(a, b, c, d, x[5], S21, 0xd62f105dL); /* 21 */
    d = GG(d, a, b, c, x[10], S22, 0x2441453L); /* 22 */
    c = GG(c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */
    b = GG(b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */
    a = GG(a, b, c, d, x[9], S21, 0x21e1cde6L); /* 25 */
    d = GG(d, a, b, c, x[14], S22, 0xc33707d6L); /* 26 */
    c = GG(c, d, a, b, x[3], S23, 0xf4d50d87L); /* 27 */
    b = GG(b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */
    a = GG(a, b, c, d, x[13], S21, 0xa9e3e905L); /* 29 */
    d = GG(d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */
    c = GG(c, d, a, b, x[7], S23, 0x676f02d9L); /* 31 */
    b = GG(b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 */

    /* Round 3 */
    a = HH(a, b, c, d, x[5], S31, 0xfffa3942L); /* 33 */
    d = HH(d, a, b, c, x[8], S32, 0x8771f681L); /* 34 */
    c = HH(c, d, a, b, x[11], S33, 0x6d9d6122L); /* 35 */
    b = HH(b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */
    a = HH(a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */
    d = HH(d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */
    c = HH(c, d, a, b, x[7], S33, 0xf6bb4b60L); /* 39 */
    b = HH(b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */
    a = HH(a, b, c, d, x[13], S31, 0x289b7ec6L); /* 41 */
    d = HH(d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */
    c = HH(c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */
    b = HH(b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */
    a = HH(a, b, c, d, x[9], S31, 0xd9d4d039L); /* 45 */
    d = HH(d, a, b, c, x[12], S32, 0xe6db99e5L); /* 46 */
    c = HH(c, d, a, b, x[15], S33, 0x1fa27cf8L); /* 47 */
    b = HH(b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 */

    /* Round 4 */
    a = II(a, b, c, d, x[0], S41, 0xf4292244L); /* 49 */
    d = II(d, a, b, c, x[7], S42, 0x432aff97L); /* 50 */
    c = II(c, d, a, b, x[14], S43, 0xab9423a7L); /* 51 */
    b = II(b, c, d, a, x[5], S44, 0xfc93a039L); /* 52 */
    a = II(a, b, c, d, x[12], S41, 0x655b59c3L); /* 53 */
    d = II(d, a, b, c, x[3], S42, 0x8f0ccc92L); /* 54 */
    c = II(c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */
    b = II(b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */
    a = II(a, b, c, d, x[8], S41, 0x6fa87e4fL); /* 57 */
    d = II(d, a, b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */
    c = II(c, d, a, b, x[6], S43, 0xa3014314L); /* 59 */
    b = II(b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */
    a = II(a, b, c, d, x[4], S41, 0xf7537e82L); /* 61 */
    d = II(d, a, b, c, x[11], S42, 0xbd3af235L); /* 62 */
    c = II(c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */
    b = II(b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */

    state[0] += a;
    state[1] += b;
    state[2] += c;
    state[3] += d;

}

/*Encode把long数组按顺序拆成byte数组，因为java的long类型是64bit的，
    只拆低32bit，以适应原始C实现的用途
   */
private void Encode(byte[] output, long[] input, int len)
{
    int i, j;

    for (i = 0, j = 0; j < len; i++, j += 4)
    {
      output[j] = (byte) (input[i] & 0xffL);
      output[j + 1] = (byte) ( (input[i] >>> 8) & 0xffL);
      output[j + 2] = (byte) ( (input[i] >>> 16) & 0xffL);
      output[j + 3] = (byte) ( (input[i] >>> 24) & 0xffL);
    }
}

/*Decode把byte数组按顺序合成成long数组，因为java的long类型是64bit的，
    只合成低32bit，高32bit清零，以适应原始C实现的用途
   */
private void Decode(long[] output, byte[] input, int len)
{
    int i, j;

    for (i = 0, j = 0; j < len; i++, j += 4)
      output[i] = b2iu(input[j]) |
          (b2iu(input[j + 1]) << 8) |
          (b2iu(input[j + 2]) << 16) |
          (b2iu(input[j + 3]) << 24);

return;
}

/*
    b2iu是我写的一个把byte按照不考虑正负号的原则的＂升位＂程序，因为java没有unsigned运算
   */
public static long b2iu(byte b)
{
    return b < 0 ? b &
}

/*byteHEX()，用来把一个byte类型的数转换成十六进制的ASCII表示，
    　因为java中的byte的toString无法实现这一点，我们又没有C语言中的
    sprintf(outbuf,"%02X",ib)
   */
public static String byteHEX(byte ib)
{
    char[] Digit =
        {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        'A', 'B', 'C', 'D', 'E', 'F'};
    char[] ob = new char[2];
    ob[0] = Digit[ (ib >>> 4) & 0X0F];
    ob[1] = Digit[ib & 0X0F];
    String s = new String(ob);
    return s;
}

/**
   * getMD5ofBye
   *
   * @param inbuf byte[]
   * @return byte[]
   */
public byte[] getMD5ofBye(byte[] inbuf)
{
    md5Init();
    md5Update(inbuf, inbuf.length);
    md5Final();
    digestHexStr = "";

   for (int i = 0; i < 16; i++)
    {
      digestHexStr += byteHEX(digest[i]);

}
return digestHexStr.getBytes();

}
}

注：如果有人使用过这个版本的MD5算法，会发现和c的返回值不一样，是因为c返回的是一个char*的指针，而java并没有指针，和c程序在内存中的值明显对不上，即使把最后一个方法getMD5ofBye的返回值改成char[]还是达不到目的，而且你会看到c内存中返回值的一个字节是java内存中返回值的两个字节合在一起的值，举个例子：比如说c中的返回值是char a[0] ='0x12',而java中返回值则是char b[0] = '0x01',b[1] = '0x02'。要怎么改变这种在内存中返回值不同的情况？你可以把byteHEX方法完全注释掉，换成下面这个方法：

public static byte byteHEX(byte ib)
{
return ib;
}

并且把getMD5ofBye方法稍作修改，即改成：
public byte[] getMD5ofBye(byte[] inbuf)
{
    md5Init();
    md5Update(inbuf, inbuf.length);
    md5Final();
    byte digestHexStr;

    byte b[] = new byte[16];//大小根据需要自己定；
    for (int i = 0; i < 16; i++)
    {
      digestHexStr += byteHEX(digest[i]);

      b[i] = digestHexStr
    }
    return b;

}

经过这样的处理后，java版本的MD5算法就和c版本的MD5算法在返回值上完全一致了。

優雅Ｄě頽廢 2007-09-19 18:56 发表评论

LookupDispatchAction使用示例

優雅Ｄě頽廢 — Wed, 19 Sep 2007 05:31:00 GMT

LookupDispatchAction是DispatchAction的子类。他的作用是将多个响应用户请求的Action方法放置在同一个Action中。

LookupDispatchAction主要适合用于页面中同一个表单具有多个提交按钮，每个提交按钮要递交给不同的Action处理方法的情况。

LookupDispatchAction所执行的方法也是依据页面传递的参数来确定的。而具体执行哪个Action方法则是由用户提交参数的值、资源文件、定义的映射方法所共同决定的。

具体请参考下面的例题：

1、先在JSP页面中使用如下的提交按钮：

#test.jsp

2、在Struts的配置文件中设置paramerter属性：

#struts-config.xml

3、创建一个继承LookupDispatchAction的类，名叫TestLookUpDispatchAction放在action包下：

#TestLookUpDispatchAction.java

package action;

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.LookupDispatchAction;

public class TestLookUpDispatchAction extends LookupDispatchAction {

@Override
protected Map getKeyMethodMap() {// 定义资源文件关键字与Action方法之间的映射关系
     Map map = new HashMap();
     map.put("button.add", "add");
    map.put("button.delete", "delete");
    return map;
}

// 自定义的方法
public ActionForward add(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response)
   throws Exception {
  System.out.println("执行add方法成功");
  return null;
}

// 自定义的方法
public ActionForward delete(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response)
   throws Exception {
  System.out.println("执行delete方法成功");
  return null;
}
}
4、在资源文件中为每个标记定义显示信息：

message.properties

button.add=add
button.delete=delete

这样就OK了，你可以试一下是否能调用到自己想要的方法。有什么问题可以联系我。

優雅Ｄě頽廢 2007-09-19 13:31 发表评论

Hibernate 参数设置一览表

優雅Ｄě頽廢 — Wed, 19 Sep 2007 05:28:00 GMT

Hibernate配置属性

属性名	用途
`hibernate.dialect`	一个Hibernate `Dialect`类名允许Hibernate针对特定的关系数据库生成优化的SQL. 取值 `full.classname.of.Dialect`
`hibernate.show_sql`	输出所有SQL语句到控制台. 有一个另外的选择是把`org.hibernate.SQL`这个log category设为`debug`。 eg. `true` \| `false`
`hibernate.format_sql`	在log和console中打印出更漂亮的SQL。取值 `true` \| `false`
`hibernate.default_schema`	在生成的SQL中, 将给定的schema/tablespace附加于非全限定名的表名上. 取值 `SCHEMA_NAME`
`hibernate.default_catalog`	在生成的SQL中, 将给定的catalog附加于非全限定名的表名上. 取值 `CATALOG_NAME`
`hibernate.session_factory_name`	`SessionFactory`创建后，将自动使用这个名字绑定到JNDI中. 取值 `jndi/composite/name`
`hibernate.max_fetch_depth`	为单向关联(一对一, 多对一)的外连接抓取（outer join fetch）树设置最大深度. 值为`0`意味着将关闭默认的外连接抓取. 取值建议在`0`到`3`之间取值
`hibernate.default_batch_fetch_size`	为Hibernate关联的批量抓取设置默认数量. 取值建议的取值为`4`, `8`, 和`16`
`hibernate.default_entity_mode`	为由这个`SessionFactory`打开的所有Session指定默认的实体表现模式. 取值 `dynamic-map`, `dom4j`, `pojo`
`hibernate.order_updates`	强制Hibernate按照被更新数据的主键，为SQL更新排序。这么做将减少在高并发系统中事务的死锁。取值 `true` \| `false`
`hibernate.generate_statistics`	如果开启, Hibernate将收集有助于性能调节的统计数据. 取值 `true` \| `false`
`hibernate.use_identifer_rollback`	如果开启, 在对象被删除时生成的标识属性将被重设为默认值. 取值 `true` \| `false`
`hibernate.use_sql_comments`	如果开启, Hibernate将在SQL中生成有助于调试的注释信息, 默认值为`false`. 取值 `true` \| `false`

表 3.4. Hibernate JDBC和连接(connection)属性

属性名	用途
`hibernate.jdbc.fetch_size`	非零值，指定JDBC抓取数量的大小 (调用`Statement.setFetchSize()`).
`hibernate.jdbc.batch_size`	非零值，允许Hibernate使用JDBC2的批量更新. 取值建议取`5`到`30`之间的值
`hibernate.jdbc.batch_versioned_data`	如果你想让你的JDBC驱动从`executeBatch()`返回正确的行计数 , 那么将此属性设为`true`(开启这个选项通常是安全的). 同时，Hibernate将为自动版本化的数据使用批量DML. 默认值为`false`. eg. `true` \| `false`
`hibernate.jdbc.factory_class`	选择一个自定义的`Batcher`. 多数应用程序不需要这个配置属性. eg. `classname.of.Batcher`
`hibernate.jdbc.use_scrollable_resultset`	允许Hibernate使用JDBC2的可滚动结果集. 只有在使用用户提供的JDBC连接时，这个选项才是必要的, 否则Hibernate会使用连接的元数据. 取值 `true` \| `false`
`hibernate.jdbc.use_streams_for_binary`	在JDBC读写`binary (二进制)`或`serializable (可序列化)` 的类型时使用流(stream)(系统级属性). 取值 `true` \| `false`
`hibernate.jdbc.use_get_generated_keys`	在数据插入数据库之后，允许使用JDBC3 `PreparedStatement.getGeneratedKeys()` 来获取数据库生成的key(键)。需要JDBC3+驱动和JRE1.4+, 如果你的数据库驱动在使用Hibernate的标识生成器时遇到问题，请将此值设为false. 默认情况下将使用连接的元数据来判定驱动的能力. 取值 `true\|false`
`hibernate.connection.provider_class`	自定义`ConnectionProvider`的类名, 此类用来向Hibernate提供JDBC连接. 取值 `classname.of.ConnectionProvider`
`hibernate.connection.isolation`	设置JDBC事务隔离级别. 查看`java.sql.Connection`来了解各个值的具体意义, 但请注意多数数据库都不支持所有的隔离级别. 取值 `1, 2, 4, 8`
`hibernate.connection.autocommit`	允许被缓存的JDBC连接开启自动提交(autocommit) (不建议). 取值 `true` \| `false`
`hibernate.connection.release_mode`	指定Hibernate在何时释放JDBC连接. 默认情况下,直到Session被显式关闭或被断开连接时,才会释放JDBC连接. 对于应用程序服务器的JTA数据源, 你应当使用`after_statement`, 这样在每次JDBC调用后，都会主动的释放连接. 对于非JTA的连接, 使用`after_transaction`在每个事务结束时释放连接是合理的. `auto`将为JTA和CMT事务策略选择`after_statement`, 为JDBC事务策略选择`after_transaction`. 取值 `on_close` \| `after_transaction` \| `after_statement` \| `auto`
`hibernate.connection.`	将JDBC属性`propertyName`传递到`DriverManager.getConnection()`中去.
`hibernate.jndi.`	将属性`propertyName`传递到JNDI `InitialContextFactory`中去.

表 3.5. Hibernate缓存属性

属性名	用途
`hibernate.cache.provider_class`	自定义的`CacheProvider`的类名. 取值 `classname.of.CacheProvider`
`hibernate.cache.use_minimal_puts`	以频繁的读操作为代价, 优化二级缓存来最小化写操作. 在Hibernate3中，这个设置对的集群缓存非常有用, 对集群缓存的实现而言，默认是开启的. 取值 `true\|false`
`hibernate.cache.use_query_cache`	允许查询缓存, 个别查询仍然需要被设置为可缓存的. 取值 `true\|false`
`hibernate.cache.use_second_level_cache`	能用来完全禁止使用二级缓存. 对那些在类的映射定义中指定的类，会默认开启二级缓存. 取值 `true\|false`
`hibernate.cache.query_cache_factory`	自定义实现`QueryCache`接口的类名, 默认为内建的`StandardQueryCache`. 取值 `classname.of.QueryCache`
`hibernate.cache.region_prefix`	二级缓存区域名的前缀. 取值 `prefix`
`hibernate.cache.use_structured_entries`	强制Hibernate以更人性化的格式将数据存入二级缓存. 取值 `true\|false`

表 3.6. Hibernate事务属性

属性名	用途
`hibernate.transaction.factory_class`	一个`TransactionFactory`的类名, 用于Hibernate `Transaction` API (默认为`JDBCTransactionFactory`). 取值 `classname.of.TransactionFactory`
`jta.UserTransaction`	一个JNDI名字，被`JTATransactionFactory`用来从应用服务器获取JTA `UserTransaction`. 取值 `jndi/composite/name`
`hibernate.transaction.manager_lookup_class`	一个`TransactionManagerLookup`的类名 - 当使用JVM级缓存，或在JTA环境中使用hilo生成器的时候需要该类. 取值 `classname.of.TransactionManagerLookup`
`hibernate.transaction.flush_before_completion`	如果开启, session在事务完成后将被自动清洗(flush)。现在更好的方法是使用自动session上下文管理。取值 `true` \| `false`
`hibernate.transaction.auto_close_session`	如果开启, session在事务完成后将被自动关闭。现在更好的方法是使用自动session上下文管理。取值 `true` \| `false`

表 3.7. 其他属性

属性名	用途
`hibernate.current_session_context_class`	为"当前" `Session`指定一个(自定义的)策略。eg. `jta` \| `thread` \| `custom.Class`
`hibernate.query.factory_class`	选择HQL解析器的实现. 取值 `org.hibernate.hql.ast.ASTQueryTranslatorFactory` or `org.hibernate.hql.classic.ClassicQueryTranslatorFactory`
`hibernate.query.substitutions`	将Hibernate查询中的符号映射到SQL查询中的符号 (符号可能是函数名或常量名字). 取值 `hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC`
`hibernate.hbm2ddl.auto`	在`SessionFactory`创建时，自动检查数据库结构，或者将数据库schema的DDL导出到数据库. 使用 `create-drop`时,在显式关闭`SessionFactory`时，将drop掉数据库schema. 取值 `validate` \| `update` \| `create` \| `create-drop`
`hibernate.cglib.use_reflection_optimizer`	开启CGLIB来替代运行时反射机制(系统级属性). 反射机制有时在除错时比较有用. 注意即使关闭这个优化, Hibernate还是需要CGLIB. 你不能在`hibernate.cfg.xml`中设置此属性. 取值 `true` \| `false`

3.4.1. SQL方言

你应当总是为你的数据库将hibernate.dialect属性设置成正确的 org.hibernate.dialect.Dialect子类. 如果你指定一种方言, Hibernate将为上面列出的一些属性使用合理的默认值, 为你省去了手工指定它们的功夫.

表 3.8. Hibernate SQL方言 (hibernate.dialect)

RDBMS	方言
DB2	`org.hibernate.dialect.DB2Dialect`
DB2 AS/400	`org.hibernate.dialect.DB2400Dialect`
DB2 OS390	`org.hibernate.dialect.DB2390Dialect`
PostgreSQL	`org.hibernate.dialect.PostgreSQLDialect`
MySQL	`org.hibernate.dialect.MySQLDialect`
MySQL with InnoDB	`org.hibernate.dialect.MySQLInnoDBDialect`
MySQL with MyISAM	`org.hibernate.dialect.MySQLMyISAMDialect`
Oracle (any version)	`org.hibernate.dialect.OracleDialect`
Oracle 9i/10g	`org.hibernate.dialect.Oracle9Dialect`
Sybase	`org.hibernate.dialect.SybaseDialect`
Sybase Anywhere	`org.hibernate.dialect.SybaseAnywhereDialect`
Microsoft SQL Server	`org.hibernate.dialect.SQLServerDialect`
SAP DB	`org.hibernate.dialect.SAPDBDialect`
Informix	`org.hibernate.dialect.InformixDialect`
HypersonicSQL	`org.hibernate.dialect.HSQLDialect`
Ingres	`org.hibernate.dialect.IngresDialect`
Progress	`org.hibernate.dialect.ProgressDialect`
Mckoi SQL	`org.hibernate.dialect.MckoiDialect`
Interbase	`org.hibernate.dialect.InterbaseDialect`
Pointbase	`org.hibernate.dialect.PointbaseDialect`
FrontBase	`org.hibernate.dialect.FrontbaseDialect`
Firebird	`org.hibernate.dialect.FirebirdDialect`

表 3.9. Hibernate日志类别

类别	功能
`org.hibernate.SQL`	在所有SQL DML语句被执行时为它们记录日志
`org.hibernate.type`	为所有JDBC参数记录日志
`org.hibernate.tool.hbm2ddl`	在所有SQL DDL语句执行时为它们记录日志
`org.hibernate.pretty`	在session清洗(flush)时，为所有与其关联的实体(最多20个)的状态记录日志
`org.hibernate.cache`	为所有二级缓存的活动记录日志
`org.hibernate.transaction`	为事务相关的活动记录日志
`org.hibernate.jdbc`	为所有JDBC资源的获取记录日志
`org.hibernate.hql.AST`	在解析查询的时候,记录HQL和SQL的AST分析日志
`org.hibernate.secure`	为JAAS认证请求做日志
`org.hibernate`	为任何Hibernate相关信息做日志 (信息量较大, 但对查错非常有帮助)

表 3.10. JTA TransactionManagers

Transaction工厂类	应用程序服务器
`org.hibernate.transaction.JBossTransactionManagerLookup`	JBoss
`org.hibernate.transaction.WeblogicTransactionManagerLookup`	Weblogic
`org.hibernate.transaction.WebSphereTransactionManagerLookup`	WebSphere
`org.hibernate.transaction.WebSphereExtendedJTATransactionLookup`	WebSphere 6
`org.hibernate.transaction.OrionTransactionManagerLookup`	Orion
`org.hibernate.transaction.ResinTransactionManagerLookup`	Resin
`org.hibernate.transaction.JOTMTransactionManagerLookup`	JOTM
`org.hibernate.transaction.JOnASTransactionManagerLookup`	JOnAS
`org.hibernate.transaction.JRun4TransactionManagerLookup`	JRun4
`org.hibernate.transaction.BESTransactionManagerLookup`	Borland ES

優雅Ｄě頽廢 2007-09-19 13:28 发表评论

Hibernate包祥解

優雅Ｄě頽廢 — Wed, 19 Sep 2007 05:26:00 GMT

Hibernate一共包括了23个jar包，令人眼花缭乱。本文将详细讲解Hibernate每个jar包的作用，便于你在应用中根据自己的需要进行取舍。

　　下载Hibernate，例如2.0.3稳定版本，解压缩，可以看到一个hibernate2.jar和lib目录下有22个jar包：

　　hibernate2.jar:

　　Hibernate的库，没有什么可说的，必须使用的jar包

　　cglib-asm.jar:

　　CGLIB库，Hibernate用它来实现PO字节码的动态生成，非常核心的库，必须使用的jar包

　　dom4j.jar:

　　dom4j是一个Java的XML API，类似于jdom，用来读写XML文件的。dom4j是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件，可以在SourceForge上找到它。在IBM developerWorks上面可以找到一篇文章，对主流的Java XML API进行的性能、功能和易用性的评测，dom4j无论在那个方面都是非常出色的。我早在将近两年之前就开始使用dom4j，直到现在。如今你可以看到越来越多的Java软件都在使用dom4j来读写XML，特别值得一提的是连Sun的JAXM也在用dom4j。这是必须使用的jar包，Hibernate用它来读写配置文件。

　　odmg.jar:

　　ODMG是一个ORM的规范，Hibernate实现了ODMG规范，这是一个核心的库，必须使用的jar包。

　　commons-collections.jar：

　　Apache Commons包中的一个，包含了一些Apache开发的集合类，功能比java.util.*强大。必须使用的jar包。

　　commons-beanutils.jar：

　　Apache Commons包中的一个，包含了一些Bean工具类类。必须使用的jar包。

　　commons-lang.jar:

　　Apache Commons包中的一个，包含了一些数据类型工具类，是java.lang.*的扩展。必须使用的jar包。

　　commons-logging.jar:

　　Apache Commons包中的一个，包含了日志功能，必须使用的jar包。这个包本身包含了一个Simple Logger，但是功能很弱。在运行的时候它会先在CLASSPATH找log4j，如果有，就使用log4j，如果没有，就找JDK1.4带的java.util.logging，如果也找不到就用Simple Logger。commons-logging.jar的出现是一个历史的的遗留的遗憾，当初Apache极力游说Sun把log4j加入JDK1.4，然而JDK1.4项目小组已经接近发布JDK1.4产品的时间了，因此拒绝了Apache的要求，使用自己的java.util.logging，这个包的功能比log4j差的很远，性能也一般。

　　后来Apache就开发出来了commons-logging.jar用来兼容两个logger。因此用commons-logging.jar写的log程序，底层的Logger是可以切换的，你可以选择log4j，java.util.logging或者它自带的Simple Logger。不过我仍然强烈建议使用log4j，因为log4j性能很高，log输出信息时间几乎等于System.out，而处理一条log平均只需要5us。你可以在Hibernate的src目录下找到Hibernate已经为你准备好了的log4j的配置文件，你只需要到Apache 网站去下载log4j就可以了。commons-logging.jar也是必须的jar包。

　　使用Hibernate必须的jar包就是以上的这几个，剩下的都是可选的。

　　ant.jar:

　　Ant编译工具的jar包，用来编译Hibernate源代码的。如果你不准备修改和编译Hibernate源代码，那么就没有什么用，可选的jar包

　　optional.jar：

　　Ant的一个辅助包。

　　c3p0.jar：

　　C3PO是一个数据库连接池，Hibernate可以配置为使用C3PO连接池。如果你准备用这个连接池，就需要这个jar包。

　　proxool.jar：

　　也是一个连接池，同上。

　　commons-pool.jar, commons-dbcp.jar:

　　DBCP数据库连接池，Apache的Jakarta组织开发的，Tomcat4的连接池也是DBCP。

　　实际上Hibernate自己也实现了一个非常非常简单的数据库连接池，加上上面3个，你实际上可以在Hibernate上选择4种不同的数据库连接池，选择哪一个看个人的偏好，不过DBCP可能更通用一些。另外强调一点，如果在EJB中使用Hibernate，一定要用App Server的连接池，不要用以上4种连接池，否则容器管理事务不起作用。

　　connector.jar:

　　JCA 规范，如果你在App Server上把Hibernate配置为Connector的话，就需要这个jar。不过实际上一般App Server肯定会带上这个包，所以实际上是多余的包。

　　jaas.jar:

　　JAAS是用来进行权限验证的，已经包含在JDK1.4里面了。所以实际上是多余的包。

　　jcs.jar：

　　如果你准备在Hibernate中使用JCS的话，那么必须包括它，否则就不用。

　　jdbc2_0-stdext.jar:

　　JDBC2.0的扩展包，一般来说数据库连接池会用上它。不过App Server都会带上，所以也是多余的。

　　jta.jar：

　　JTA规范，当Hibernate使用JTA的时候需要，不过App Server都会带上，所以也是多余的。

　　junit.jar:

　　Junit包，当你运行Hibernate自带的测试代码的时候需要，否则就不用。

　　xalan.jar, xerces.jar, xml-apis.jar:

　　Xerces是XML解析器，Xalan是格式化器，xml-apis实际上是JAXP。一般App Server都会带上，JDK1.4也包含了解析器，不过不是Xerces，是Crimson，效率比较差，不过Hibernate用XML只不过是读取配置文件，性能没什么紧要的，所以也是多余的。

優雅Ｄě頽廢 2007-09-19 13:26 发表评论