Oracle 版本：Oracle Database 10g Release 2 (10.2.0.1)

下载地址：

http://www.oracle.com/technology/software/products/database/oracle10g/htdocs/10201winsoft.html

安装设置：

1）这里的全局数据库名即为你创建的数据库名，以后在访问数据，创建“本地Net服务名”时用到；

2）数据库口令在登录和创建“本地Net服务名”等地方会用到。

2、创建“本地Net服务名”

1）通过【程序】-》【Oracle - OraDb10g_home1】-》【配置和移植工具】-》【Net Configuration Assistant】，运行“网络配置助手”工具：

2）选择“本地 Net 服务名配置”：

3）这里的“Net 服务名”我们输入安装数据库时的“全局数据库名”：

4）主机名我们输入本机的IP地址：

5）测试数据库连接，用户名/密码为：System/数据库口令（安装时输入的“数据库口令”）：

 
默认的用户名/密码错误：

更改登录，输入正确的用户名/密码：

测试成功：

3、PLSQL Developer 连接测试

输入正确的用户名/口令：

成功登陆：

4、创建表空间

打开sqlplus工具：

Sql代码       sqlplus /nolog  

连接数据库：
 Sql代码     conn /as sysdba

创建表空间：

 Sql代码   create tablespace camds datafile 'D:\oracle\product\10.2.0\oradata\camds\camds.dbf' size 200m autoextend on next 10m maxsize unlimited;  

5、创建新用户

运行“P/L SQL Developer”工具，以DBA（用户名：System）的身份登录：

1）新建“User（用户）：

2）设置用户名、口令、默认表空间（使用上面新建的表空间）和临时表空间：

3）设置角色权限：

4）设置”系统权限“：

5）点击应用后，【应用】按钮变灰，新用户创建成功：

6）新用户登录测试：

输入新用户的“用户名/口令”：

新用户“testcamds”成功登陆：

6、导入导出数据库

先运行cmd命令，进入命令行模式，转到下面的目录：D:\oracle\product\10.2.0\db_1\BIN【该目录下有exp.exe文件】

1）导入

命令语法：

Sql代码   imp userid/pwd@sid file=path/file fromuser=testcamds touser=userid  


命令实例：

Sql代码   imp testcamds/123@camds file=c:\testcamds fromuser=testcamds touser=testcamds  

导入结果：

2）导出：

命令语法：

Sql代码  exp userid/pwd@sid file=path/file owner=userid  
 
命令实例：

exp testcamds/123@camdsora file=c:\testcamds owner=testcamds

导入结果：

　　下面就详细说明TIMESTAMP列类型
　　
　　TIMESTAMP列类型
　　TIMESTAMP值可以从1970的某时的开始一直到2037年，精度为一秒，其值作为数字显示。
　　TIMESTAMP值显示尺寸的格式如下表所示：
　　：
　　+---------------+----------------+
　　| 列类型　　　　| 显示格式　　　 |
　　| TIMESTAMP(14) | YYYYMMDDHHMMSS |　
　　| TIMESTAMP(12) | YYMMDDHHMMSS　 |
　　| TIMESTAMP(10) | YYMMDDHHMM　　  |
　　| TIMESTAMP(8)　| YYYYMMDD　　 　   |
　　| TIMESTAMP(6)　| YYMMDD　　　    　 |
　　| TIMESTAMP(4)　| YYMM　　　　     　 |
　　| TIMESTAMP(2)　| YY　　　　　　          |
　　+---------------+----------------+
　　“完整”TIMESTAMP格式是14位，但TIMESTAMP列也可以用更短的显示尺寸创造
　　最常见的显示尺寸是6、8、12、和14。
　　你可以在创建表时指定一个任意的显示尺寸，但是定义列长为0或比14大均会被强制定义为列长14。
　　列长在从1～13范围的奇数值尺寸均被强制为下一个更大的偶数。
　　
　　列如：
　　定义字段长度　　 强制字段长度
　　TIMESTAMP(0) ->　TIMESTAMP(14)
　　TIMESTAMP(15)->　TIMESTAMP(14)
　　TIMESTAMP(1) ->　TIMESTAMP(2)
　　TIMESTAMP(5) ->　TIMESTAMP(6)
　　
　　所有的TIMESTAMP列都有同样的存储大小，
　　使用被指定的时期时间值的完整精度（14位）存储合法的值不考虑显示尺寸。
　　不合法的日期，将会被强制为0存储
　　
　　这有几个含意：

　　1、虽然你建表时定义了列TIMESTAMP(8)，但在你进行数据插入与更新时TIMESTAMP列实际上保存了14位的数据（包括年月日时分秒），只不过在你进行查询时MySQL返回给你的是8位的年月日数据。如果你使用ALTER TABLE拓宽一个狭窄的TIMESTAMP列，以前被“隐蔽”的信息将被显示。
　　2、同样，缩小一个TIMESTAMP列不会导致信息失去，除了感觉上值在显示时，较少的信息被显示出。
　　3、尽管TIMESTAMP值被存储为完整精度，直接操作存储值的唯一函数是UNIX_TIMESTAMP()；由于MySQL返回TIMESTAMP列的列值是进过格式化后的检索的值，这意味着你可能不能使用某些函数来操作TIMESTAMP列（例如HOUR()或SECOND()），除非 TIMESTAMP值的相关部分被包含在格式化的值中。例如，一个TIMESTAMP列只有被定义为TIMESTAMP(10)以上时， TIMESTAMP列的HH部分才会被显示，因此在更短的TIMESTAMP值上使用HOUR()会产生一个不可预知的结果。
　　4、不合法TIMESTAMP值被变换到适当类型的“零”值(00000000000000)。（DATETIME,DATE亦然）　　　　
　　
　　你可以使用下列语句来验证：
　　

       +----+----------------+
　　| id     | date1　　   　|
　　+----+----------------+
　　|　1  | 20021114　      |
　　+----+----------------+

       +----+----------------+
　　| id | date1　　　　　|
　　+----+----------------+
　　| 1 | 20021114093723 |
　　+----+----------------+
　　
　　你可以使用TIMESTAMP列类型自动地用当前的日期和时间标记INSERT或UPDATE的操作。
　　如果你有多个TIMESTAMP列，只有第一个自动更新。

　　自动更新第一个TIMESTAMP列在下列任何条件下发生：
　　
　　1、列值没有明确地在一个INSERT或LOAD DATA INFILE语句中指定。
　　2、列值没有明确地在一个UPDATE语句中指定且另外一些的列改变值。（注意一个UPDATE设置一个列为它已经有的值，这将不引起TIMESTAMP列被更新，因为如果你设置一个列为它当前的值，MySQL为了效率而忽略更改。）
　　3、你明确地设定TIMESTAMP列为NULL.
　　4、除第一个以外的TIMESTAMP列也可以设置到当前的日期和时间，只要将列设为NULL，或NOW()。
　　
　

        +----+----------------+----------------+
　　| id | date1　　　　　| date2　　　    |
　　+----+----------------+----------------+
　　|　1 | 20021114093723 | 20021114093723 |
　　|　2 | 20021114093724 | 00000000000000 |
　　+----+----------------+----------------+

         ->第一条指令因设date1、date2为NULL,所以date1、date2值均为当前时间
　　　第二条指令因没有设date1、date2列值，第一个TIMESTAMP列date1为更新为当前时间， 而二个TIMESTAMP列date2因日期不合法而变为“00000000000000”
　　
　　

    　+----+----------------+----------------+
　　| id | date1　　　　　| date2　　　　　|
　　+----+----------------+----------------+
　　|　3 | 20021114094009 | 20021114093723 |
　　|　2 | 20021114093724 | 00000000000000 |
　　+----+----------------+----------------+
　　->这条指令没有明确地设定date2的列值，所以第一个TIMESTAMP列date1将被更新为当前时间
　　

        +----+----------------+----------------+
　　| id | date1　　　　　| date2　　　　　|
　　+----+----------------+----------------+
　　|　1 | 20021114094009 | 20021114094320 |
　　|　2 | 20021114093724 | 00000000000000 |
　　+----+----------------+----------------+
　　->这条指令因设定date1=date1，所以在更新数据时date1列值并不会发生改变
　　　而因设定date2=NOW()，所以在更新数据时date2列值会被更新为当前时间
　　　此指令等效为 update test SET id= 1,date1=date1,date2=NULL WHERE id=3;
　　　
　　因MySQL返回的 TIMESTAMP 列为数字显示形式，
　　你可以用DATE_FROMAT()函数来格式化 TIMESTAMP 列
　　

        +----+---------------------+---------------------+
　　| id | date1　　　　　　　 | date2　　　　 |
　　+----+---------------------+---------------------+
　　|　1 | 2002-11-14 09:40:09 | 2002-11-14 09:43:20 |
　　|　2 | 2002-11-14 09:37:24 | 0000-00-00 00:00:00 |
　　+----+---------------------+---------------------+
　　
　

　　+----+-------------+-------------+
　　| id | date1　　　 | date2　　　 |
　　+----+-------------+-------------+
　　|　1 | 2002-11-14　| 2002-11-14　|
　　|　2 | 2002-11-14　| 0000-00-00　|
　　+----+-------------+-------------+
　　
　　在某种程度上，你可以把一种日期类型的值赋给一个不同的日期类型的对象。
　　然而，而尤其注意的是：值有可能发生一些改变或信息的损失：
　　
　　1、如果你将一个DATE值赋给一个DATETIME或TIMESTAMP对象，结果值的时间部分被设置为'00:00:00'，因为DATE值中不包含有时间信息。　　
　　2、如果你将一个DATETIME或TIMESTAMP值赋给一个DATE对象，结果值的时间部分被删除，因为DATE类型不存储时间信息。
　　3、尽管DATETIME, DATE和TIMESTAMP值全都可以用同样的格式集来指定，
　　但所有类型不都有同样的值范围。
　　例如，TIMESTAMP值不能比1970早，也不能比2037晚，
　　这意味着，一个日期例如'1968-01-01'，当作为一个DATETIME或DATE值时它是合法的，
　　但它不是一个正确TIMESTAMP值！并且如果将这样的一个对象赋值给TIMESTAMP列，它将被变换为0。
　　
　　当指定日期值时，当心某些缺陷：
　　
　　1、允许作为字符串指定值的宽松格式能被欺骗。例如，，因为“:”分隔符的使用，值'10:11:12'可能看起来像时间值，但是如果在一个日期中使用，上下文将作为年份被解释成'2010-11-12'。值'10:45:15'将被变换到'0000-00-00'，因为'45'不是一个合法的月份。
　　　　
　　2、以2位数字指定的年值是模糊的，因为世纪是未知的。MySQL使用下列规则解释2位年值： 在00-69范围的年值被变换到2000-2069。 在范围70-99的年值被变换到1970-1999。

　　DATETIME类型用在你需要同时包含日期和时间信息的值时。MySQL检索并且以'YYYY-MM-DD HH:MM:SS'格式显示DATETIME值，支持的范围是'1000-01-01 00:00:00'到'9999-12-31 23:59:59'。（“支持”意味着尽管更早的值可能工作，但不能保证他们可以。）

　　DATE类型用在你仅需要日期值时，没有时间部分。MySQL检索并且以'YYYY-MM-DD'格式显示DATE值，支持的范围是'1000-01-01'到'9999-12-31'。

　　TIMESTAMP列类型提供一种类型，你可以使用它自动地用当前的日期和时间标记INSERT或UPDATE的操作。如果你有多个TIMESTAMP列，只有第一个自动更新。

　　自动更新第一个TIMESTAMP列在下列任何条件下发生：

　　列没有明确地在一个INSERT或LOAD DATA INFILE语句中指定。

　　列没有明确地在一个UPDATE语句中指定且一些另外的列改变值。（注意一个UPDATE设置一个列为它已经有的值，这将不引起TIMESTAMP列被更新，因为如果你设置一个列为它当前的值，MySQL为了效率而忽略更改。）

　　你明确地设定TIMESTAMP列为NULL.

　　除第一个以外的TIMESTAMP列也可以设置到当前的日期和时间，只要将列设为NULL，或NOW()。

　　通过明确地设置希望的值，你可以设置任何TIMESTAMP列为不同于当前日期和时间的值，即使对第一个TIMESTAMP列也是这样。例如，如果，当你创建一个行时，你想要一个TIMESTAMP被设置到当前的日期和时间，但在以后无论何时行被更新时都不改变，你可以使用这个属性：

　　让MySQL在行被创建时设置列，这将初始化它为当前的日期和时间。

　　当你执行随后的对该行中其他列的更改时，明确设定TIMESTAMP列为它的当前值。

　　另一方面，你可能发现，当行被创建并且远离随后的更改时，很容易用一个你用NOW()初始化的DATETIME列。

　　TIMESTAMP值可以从1970的某时的开始一直到2037年，精度为一秒，其值作为数字显示。

　　在MySQL检索并且显示TIMESTAMP值取决于显示尺寸的格式如下表。“完整”TIMESTAMP格式是14位，但是TIMESTAMP列可以用更短的显示尺寸创造：

列类型　　　　 显示格式
TIMESTAMP(14) YYYYMMDDHHMMSS
TIMESTAMP(12) YYMMDDHHMMSS
TIMESTAMP(10) YYMMDDHHMM
TIMESTAMP(8) YYYYMMDD
TIMESTAMP(6) YYMMDD
TIMESTAMP(4) YYMM
TIMESTAMP(2) YY

　　所有的TIMESTAMP列都有同样的存储大小，不考虑显示尺寸。最常见的显示尺寸是6、8、12、和14。你可以在表创建时间指定一个任意的显示尺寸，但是值0或比14大被强制到14。在从1～13范围的奇数值尺寸被强制为下一个更大的偶数。

　　使用一个常用的格式集的任何一个，你可以指定DATETIME、DATE和TIMESTAMP值：

　　'YYYY-MM-DD HH:MM:SS'或'YY-MM-DD HH:MM:SS'格式的一个字符串。允许一种“宽松”的语法--任何标点可用作在日期部分和时间部分之间的分隔符。例如，'98-12-31 11:30:45'、'98.12.31 11+30+45'、'98/12/31 11*30*45'和'98@12@31 11^30^45'是等价的。

　　'YYYY-MM-DD'或'YY-MM-DD'格式的一个字符串。允许一种“宽松”的语法。例如，'98-12-31', '98.12.31', '98/12/31'和'98@12@31'是等价的。

　　'YYYYMMDDHHMMSS'或'YYMMDDHHMMSS'格式的没有任何分隔符的一个字符串，例如，'19970523091528'和'970523091528'被解释为'1997-05-23 09:15:28'，但是'971122459015'是不合法的(它有毫无意义的分钟部分)且变成'0000-00-00 00:00:00'。

　　'YYYYMMDD'或'YYMMDD'格式的没有任何分隔符的一个字符串，如果字符串认为是一个日期。例如，'19970523'和'970523'被解释作为'1997-05-23'，但是'971332'是不合法的( 它有无意义的月和天部分)且变成'0000-00-00'。

　　YYYYMMDDHHMMSS或YYMMDDHHMMSS格式的一个数字，如果数字认为是一个日期。例如，19830905132800和830905132800被解释作为'1983-09-05 13:28:00'。

　　YYYYMMDD或YYMMDD格式的一个数字，如果数字认为是一个日期。例如，19830905和830905被解释作为'1983-09-05'。

　　一个返回值可以在一个DATETIME, DATE或TIMESTAMP上下文环境中接受的函数，例如NOW()或CURRENT_DATE。

　　不合法DATETIME, DATE或TIMESTAMP值被变换到适当类型的“零”值('0000-00-00 00:00:00', '0000-00-00'或00000000000000)。

　　对于包括的日期部分分隔符的指定为字符串的值，不必要为小于10的月或天的值指定2位数字，'1979-6-9'与'1979-06-09'是一样的。同样, 对于包括的时间部分分隔符的指定为字符串的值，不必为小于10的小时、月或秒指定2位数字，'1979-10-30 1:2:3'与'1979-10-30 01:02:03'是一样的。

　　指定为数字应该是6、8、12或14位长。如果数字是8或14位长，它被假定以YYYYMMDD或YYYYMMDDHHMMSS格式并且年份由头4位数字给出。如果数字是6或12位长，它被假定是以YYMMDD或YYMMDDHHMMSS格式且年份由头2位数字给出。不是这些长度之一的数字通过填补前头的零到最接近的长度来解释。

　　指定为无分隔符的字符串用它们给定的长度来解释。如果字符串长度是8或14个字符，年份被假定头4个字符给出，否则年份被假定由头2个字符给出。对于字符串中呈现的多个部分，字符串从左到右边被解释，以找出年、月、日、小时、分钟和秒值，这意味着，你不应该使用少于 6 个字符的字符串。例如，如果你指定'9903'，认为将代表1999年3月，你会发现MySQL把一个“零”日期插入到你的表中，这是因为年份和月份值99和03，但是日期部分丢失(零)，因此该值不是一个合法的日期。

　　TIMESTAMP列使用被指定的值的完整精度的存储合法的值，不考虑显示大小。这有几个含意：

　　总是指定年，月，和日，即使你的列类型是TIMESTAMP(4)或TIMESTAMP(2)。否则，值将不是一个合法的日期并且0将被存储。

　　如果你使用ALTER TABLE拓宽一个狭窄的TIMESTAMP列，以前被“隐蔽”的信息将被显示。

　　同样，缩小一个TIMESTAMP列不会导致信息失去，除了感觉上值在显示时，较少的信息被显示出。

　　尽管TIMESTAMP值被存储为完整精度，直接操作存储值的唯一函数是UNIX_TIMESTAMP()，其他函数操作在格式化了的检索的值上，这意味着你不能使用函数例如HOUR()或SECOND()，除非TIMESTAMP值的相关部分被包含在格式化的值中。例如，一个TIMESTAMP列的HH部分部被显示，除非显示大小至少是10，因此在更短的TIMESTAMP值上试试使用HOUR()产生一个无意义的结果。

　　在某种程度上，你可以把一种日期类型的值赋给一个不同的日期类型的对象。然而，这可能值有一些改变或信息的损失：

　　如果你将一个DATE值赋给一个DATETIME或TIMESTAMP对象，结果值的时间部分被设置为'00:00:00'，因为DATE值不包含时间信息。

　　如果你将一个DATETIME或TIMESTAMP值赋给一个DATE对象，结果值的时间部分被删除，因为DATE类型不存储时间信息。

　　记住，尽管DATETIME, DATE和TIMESTAMP值全都可以用同样的格式集来指定，但所有类型不都有同样的值范围。例如，TIMESTAMP值不能比1970早或比2037网晚，这意味着，一个日期例如'1968-01-01'，当作为一个DATETIME或DATE值合法时，它不是一个正确TIMESTAMP值，并且 如果赋值给这样一个对象，它将被变换到0。

　　当指定日期值时，当心某些缺陷：

　　允许作为字符串指定值的宽松格式能被欺骗。例如，值例如'10:11:12'可能看起来像时间值，因为“:”分隔符，但是如果在一个日期中使用，上下文将作为年份被解释成'2010-11-12'。值'10:45:15'将被变换到'0000-00-00'，因为'45'不是一个合法的月份。

　　以2位数字指定的年值是模糊的，因为世纪是未知的。MySQL使用下列规则解释2位年值：

　　在00-69范围的年值被变换到2000-2069。

　　在70-99范围的年值被变换到1970-1999。
本篇文章来源于：开发学院 http://edu.codepub.com   原文链接：http://edu.codepub.com/2009/1121/17945.php

我们要为查询限定条件，可以通过net.sf.hibernate.expression.Expression设置Expression有很多的条件查询方法下面举一些例子：

ge（）表示大于等于，即age大于等于25的user。

between表示weight在60和80之间。

crit.add(Expression.or(
                   Expression.eq("age", new Integer(20)),
                   Expression.isNull("age")
               ));
List users = crit.list();

eq表示age为20的user。

setMaxResult（）设置返回的信息条数，setFirstResult（）设置查询结果的初始位置，上面的程序段可以实现分页。

在hibernate的Session里面使用createCriteria可以创建一个Criteria实例帮助我们进行条件查询，不用自己串hql语句，很方便。
用法很简单，首先传Class实例创建Criteria，Class实例对应你想要查询的那个实体:

然后调用Criteria的add方法加入条件（Restrictions）。常用的条件有：
 
方法说明： Restrictions.eq 等于 
                     Restrictions.allEq 使用Map，使用key/value进行多个等于的对比
                     Restrictions.gt 大于 >
                     Restrictions.ge 大于等于 >=
                     Restrictions.lt 小于 <
                    Restrictions.le 小于等于 <=
                    Restrictions.between 对应SQL的BETWEEN子句
                    Restrictions.like 对应SQL的LIKE子句
                    Restrictions.in 对应SQL的in子句
                    Restrictions.and   and关系
                     Restrictions.or   or关系
                   Restrictions.sqlRestriction    SQL限定查詢 


例如，我想返回Person实体里面年龄(age)大于20的记录，那么就为Criteria加入Restrictions.gt条件：

 
Restrictions.and和Restrictions.or很有用，表示and查询还是or查询，例如我要查询Person实体里面年龄(age)大于20，或者性别 (sex)为man
的记录，那么就为Criteria加入:

如果需要关联查询的话，可以使用Criteria的createCriteria方法创建一个Criteria，例如部门(Department)和人员(Person)是一对多的关系，我要查询Person实体里面年龄(age)大于20，性别 (sex)为man，
备注包含应届生，
且所在部门(department)是开发部的记录:

 
其他条件的用法也很简单，就不列举了。
 
另外，Hibernate3出了一个org.hibernate.criterion.DetachedCriteria，即离线Criteria，它允许你可以先创建DetachedCriteria，然后传到Session里面才真正返回一个Criteria，用法如下：

 
 
最后，需要注意，Criteria还提供了setFirstResult和setMaxResults方法进行分页查询。
 

从一个最基本的对象关系映像自动化程序，了解Hibernate组成的基本元素，并进一步了解Hibernate的基础语义、配置等概念。

1．O/R映像入门第一个Hibernate程序很简单，将一个对象映像至一个数据表

1．1配置Hibernate
Hibernate是ORM的解决方案，其底层对数据库的操作依赖于JDBC，所以您必须先取得JDBC驱动程序，在这边所使用的是MySQL，所以您必须至MySQL®Connector/J取得MySQL的JDBC驱动程序。

接下来至Hibernate官方网站取得hibernate 3.0。

解开zip档案后，当中的hibernate3.jar是必要的，而在lib目录中还包括了许多jar档案，您可以在Hibernate 3.0官方的参考手册上找到这些jar的相关说明，其中必要的是antlr、dom4j、CGLIB、asm、Commons Collections、Commons Logging、 EHCache，Hibernate底层还需要Java Transaction API，所以您还需要jta.jar，到这边为止，总共需要以下的jar档案：

Hibernate可以运行于单机之上，也可以运行于Web应用程序之中，如果是运行于单机，则将所有用到的jar档案（包括JDBC驱动程序）设定至CLASSPATH中，如果是运行于Web应用程序中，则将jar档案置放于WEB-INF/lib中。

如果您还需要额外的Library，再依需求加入，例如JUnit、Proxool等等，接下来可以将etc目录下的log4j.properties复制至Hibernate项目的Classpath下，并修改一下当中的log4j.logger.org.hibernate为error，也就是只在错误发生时显示必要的讯息。

接着设置基本的Hibernate配置文件，可以使用XML或Properties档案，这边先使用XML，档名预设为hibernate.cfg.xml：

hibernate.cfg.xml

            
<?xml version="1.0" encoding="utf-8"?>

            <!DOCTYPE hibernate-configuration PUBLIC

            "-//Hibernate/Hibernate Configuration DTD 3.0//EN"

            "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

            <hibernate-configuration>

            <session-factory>

            <!-- 显示实际操作数据库时的SQL -->

            <property name="show_sql">true</property>

            <!-- SQL 方言，这边设定的是MySQL -->

            <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

            <!-- JDBC 驱动程序 -->

            <property name="connection.driver_class">com.mysql.jdbc.Driver</property>

            <!-- JDBC URL -->

            <property name="connection.url">jdbc:mysql://localhost/demo</property>

            <!-- 数据库使用者 -->

            <property name="connection.username">caterpillar</property>

            <!-- 数据库密码 -->

            <property name="connection.password">123456</property>

            <!-- 以下设置对象与数据库表格映像文件 -->

            </session-factory>

            </hibernate-configuration>
            

配置文件中已经加上批注为每一个项目作了说明，其中对象与数据库表格映像文件还有待加入。

1．2第一个Hibernate
这边以一个简单的单机程序来示范Hibernate的配置与功能，首先作数据库的准备工作，在MySQL中新增一个demo数据库，并建立user表格：

CreateUser2MySQL.sql

            
CREATE TABLE user (

            id INT(11) NOT NULL auto_increment PRIMARY KEY,

            name VARCHAR(100) NOT NULL default '',

            age INT

            );
            

对于这个表格，您有一个User类别与之对应，表格中的每一个字段将对应至User实例上的Field成员。

User.java

            
package onlyfun.caterpillar;

            public class User {

            private Integer id;

            private String name;

            private Integer age;

            // 必须要有一个预设的建构方法

            // 以使得Hibernate 可以使用Constructor.newInstance()建立对象

            public User() {

            }

            public Integer getId() {

            return id;

            }

            public void setId(Integer id) {

            this.id = id;

            }

            public String getName() {

            return name;

            }

            public void setName(String name) {

            this.name = name;

            }

            public Integer getAge() {

            return age;

            }

            public void setAge(Integer age) {

            this.age = age;

            }

            }
            

其中id是个特殊的属性，Hibernate会使用它来作为主键识别，您可以定义主键产生的方式，这是在XML映像文件中完成，为了告诉Hibernate您所定义的User实例如何映像至数据库表格，您撰写一个XML映射文件档名是User.hbm.xml，如下所示：

User.hbm.xml

            
<?xml version="1.0" encoding="utf-8"?>

            <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

            "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

            <hibernate-mapping>

            <class name="onlyfun.caterpillar.User" table="user">

            <id name="id" column="id" type="java.lang.Integer">

            <generator class="native" />

            </id>

            <property name="name" column="name" type="java.lang.String" />

            <property name="age" column="age" type="java.lang.Integer" />

            </class>

            </hibernate-mapping>
            

<class>卷标的name属性为所映像的对象，而table为所映像的表格；<id>中column属性指定了表格字段，而type属性指定了User实例的中的id之型态，这边type中所设定的是直接指定Java中的对象型态，Hibernate也定义有自己的映像型态，作为Java对象与SQL型态的标准对应型态（因为语言所提供的类型并不一定与数据库的类型对应），这之后会再说明。

#p#

<id>中主键的产生方式在这边设定为"native"，表示主键的生成方式由Hibernate根据数据库Dialect的定义来决定，之后还会介绍其它主键的生成方式。

同样的，<property>标签中的column与type都各自指明了表格中字段与对象中属性的对应。

接着必须在Hibernate配置文件hibernate.cfg.xml中指明映像文件的位置，如下加入映像文件位置：

hibernate.cfg.xml

            
<?xml version="1.0" encoding="utf-8"?>

            <!DOCTYPE hibernate-configuration PUBLIC

            "-//Hibernate/Hibernate Configuration DTD 3.0//EN"

            "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

            <hibernate-configuration>

            <session-factor>

            ....

            <!-- 对象与数据库表格映像文件 -->

            <mapping resource="onlyfun/caterpillar/User.hbm.xml"/>

            </session-factory>

            </hibernate-configuration>
            

接下来撰写一个测试的程序，这个程序直接以Java 程序设计人员熟悉的语法方式来操作对象，而实际上也直接完成对数据库的操作，程序将会将一笔数据存入表格之中：

FirstHibernate.java

            
package onlyfun.caterpillar;

            import org.hibernate.Session;

            import org.hibernate.SessionFactory;

            import org.hibernate.Transaction;

            import org.hibernate.cfg.Configuration;

            public class FirstHibernate {

            public static void main(String[] args) {

            // Configuration 负责管理 Hibernate 配置讯息

            Configuration config = new Configuration().configure();

            // 根据 config 建立 SessionFactory

            // SessionFactory 将用于建立 Session

            SessionFactory sessionFactory = config.buildSessionFactory();

            //将持久化的物件

            User user = new User();

            user.setName("caterpillar");

            user.setAge(new Integer(30));

            //开启Session，相当于开启JDBC 的Connection

            Session session = sessionFactory.openSession();

            //Transaction 表示一组对DB 的交易

            Transaction tx = session.beginTransaction();

            //将对象映像至数据库表格中储存

            session.save(user);

            tx.commit();

            session.close();

            sessionFactory.close();

            System.out.println("新增资料OK!请先用MySQL 观看结果！");

            }

            }
            

如您所看到的，程序中只需要直接操作User 对象，并进行Session 与Transaction 的相关操作，Hibernate 就会自动完成对数据库的操作，您看不到任何一行JDBC 或SQL 的陈述，撰写好以上的各个档案之后，各档案的放置位置如下：

接着可以开始运行程序，结果如下：

FirstHibernate执行结果

            
Hibernate: insert into user (name, age) values (?, ?)
            

新增资料OK!请先用MySQL 观看结果！

执行结果中显示了Hibernate 所实际使用的SQL，由于这个程序还没有查询功能，所以要
进入MySQL 中看看新增的数据，如下：

MySQL 中查询结果

            
mysql> select * from user;

            +----+-------------+------+

            | id | name | age |

            +----+-------------+------+

            | 1 | caterpillar | 30 |

            +----+-------------+------+

            1 row in set (0.03 sec)
            

Comments

第四段代码的标题应该是hibernate.cfg.xml

1．3 第二个 Hibernate
在 第一个 Hibernate 中介绍如何使用Hibernate 在不使用SQL 的情况下，以Java 中操作对象的习惯来插入数据至数据库中，当然储存数据之后，更重要的是如何将资料读出，Hibernate 中也可以让您不写一句SQL，而以Java 中操作对象的习惯来查询数据。

直接来看个范例：

SecondHibernate.java

            
package onlyfun.caterpillar;

            import org.hibernate.Criteria;

            import org.hibernate.Session;

            import org.hibernate.SessionFactory;

            import org.hibernate.cfg.Configuration;

            import org.hibernate.criterion.Expression;

            import java.util.Iterator;

            import java.util.List;

            public class SecondHibernate {

            public static void main(String[] args) {

            Configuration config = new Configuration().configure();

            SessionFactory sessionFactory = config.buildSessionFactory();

            Session session = sessionFactory.openSession();

            Criteria criteria = session.createCriteria(User.class);

            // 查询user 所有字段

            List users = criteria.list();

            Iterator iterator = users.iterator();

            System.out.println("id \t name/age");

            while (iterator.hasNext()) {

            User user = (User) iterator.next();

            System.out.println(user.getId() + " \t " + user.getName() + "/" +

            user.getAge());

            }

            // 查询user 中符合条件的字段

            criteria.add(Expression.eq("name", "caterpillar"));

            users = criteria.list();

            iterator = users.iterator();

            System.out.println("id \t name/age");

            while (iterator.hasNext()) {

            User user = (User) iterator.next();

            System.out.println(user.getId() + " \t " + user.getName() + "/" +

            user.getAge());

            }

            session.close();

            sessionFactory.close();

            }

            }
            

#p#

Criteria 对SQL 进行封装，对于不甚了解SQL 的开发人员来说，使用Criteria 也可以轻易的进行各种数据的检索，您也可以使用 Expression 设定查询条件，并将之加入Criteria中对查询结果作限制，Expression.eq()表示设定符合条件的查询，例如Expression.eq("name", "caterpillar")表示设定查询条件为"name"字段中为"caterpillar"的数据。

先来看一下执行结果：
SecondHibernate 执行结果

            
Hibernate: select this_.id as id0_, this_.name as name0_0_, 
            
this_.age as age0_0_ from user 
            
this_id

            id name/age

            1 caterpillar/30

            3 bush/5

            2 momor/26

            Hibernate: select this_.id as id0_, this_.name as name0_0_, 
            
this_.age as age0_0_ from user 
            
this_

            where this_.name=?

            id name/age

            1 caterpillar/30
            

Criteria 是对象导向式的查询方式，让不了解SQL 的开发人员也可以轻易进行各项查询，但Criteria 的API 目前还不是很完善，而Hibernate 鼓励的查询方式，是透过HQL（Hibernate Query Language）来进行，直接来看个实例：

SecondHibernateUsingHQ.java

            
package onlyfun.caterpillar;

            import org.hibernate.Query;

            import org.hibernate.Session;

            import org.hibernate.SessionFactory;

            import org.hibernate.cfg.Configuration;

            import java.util.Iterator;

            import java.util.List;

            public class SecondHibernateUsingHQ {

            public static void main(String[] args) {

            Configuration config = new Configuration().configure();

            SessionFactory sessionFactory = config.buildSessionFactory();

            Session session = sessionFactory.openSession();

            // 使用HQL 建立查询

            Query query = session.createQuery("from User");

            List users = query.list();

            Iterator iterator = users.iterator();

            System.out.println("id \t name/age");

            while (iterator.hasNext()) {

            User user = (User) iterator.next();

            System.out.println(user.getId() + " \t " + user.getName() + "/" +

            user.getAge());

            }

            System.out.println();

            // 使用HQL 建立查询

            query = session.createQuery("from User user where user.name like ?");

            // 设定查询参数

            query.setParameter(0, "caterpillar");

            users = query.list();

            iterator = users.iterator();

            System.out.println("id \t name/age");

            while (iterator.hasNext()) {

            User user = (User) iterator.next();

            System.out.println(user.getId() + " \t " + user.getName() + "/" +

            user.getAge());

            }

            session.close();

            sessionFactory.close();

            }

            }
            

执行结果：

SecondHibernateUsingHQ 执行结果

            
Hibernate: select this_.id as id0_, this_.name as name0_0_, 
            
  this_.age as age0_0_ from user 
            
this_id

            id name/age

            1 caterpillar/30

            3 bush/5

            2 momor/26

            Hibernate: select this_.id as id0_, this_.name as name0_0_,  
            
  this_.age as age0_0_ from user 
            
this_

            where this_.name=?

            id name/age

            1 caterpillar/30
            

透过Query 接口，您可以先设定查询参数，之后透过setXXX()等方法，将指定的参数值填入，而不用每次都撰写完整的HQL，Query 的setParameter()方法第一个参数是指定?出现的位置，从 0 开始，第二个参数则是设定查询条件。

#p#

二、简单的Hibernate 程序

这边以一个简单的单机程序来示范Hibernate的配置与功能，在这个例子中的一些操作，实际上会使用一些自动化工具来完成，而不一定亲自手动操作设定，这边完全手动的原因，在于让您可以知道Hibernate实际上会作那些动作，在进行范例之前，请先确定前一个主题中的相关jar档案都已经设定在CLASSPATH中。
　
我们先作数据库的准备工作，在MySQL中新增一个HibernateTest数据库，并建立USER表格：

            
CREATE TABLE USER (

                user_id CHAR(32) NOT NULL PRIMARY KEY,

                name VARCHAR(16) NOT NULL,

                sex CHAR(1),

                age INT

            );
            

我们先撰写一个纯Java对象，它纯綷表示一个数据集合，待会我们会将之映像至数据库的表格上，程序如下：

User.java

            
package onlyfun.caterpillar;

             public class User {

                private String id;

                private String name;

                private char sex;

                private int age;

                public int getAge() {

                    return age;

                }

                public String getId() {

                    return id;

                }

                public String getName() {

                    return name;

                }

                public char getSex() {

                    return sex;

                }

                public void setAge(int i) {

                    age = i;

                }

                public void setId(String string) {

                    id = string;

                }

                public void setName(String string) {

                    name = string;

                }

                public void setSex(char c) {

                    sex = c;

                }

            }
            

其中id是个特殊的属性，Hibernate会使用它来作为主键识别，我们可以定义主键产生的方式，这是在XML映像文件中完成，为了告诉Hibernate对象如何映像至数据库表格，我们撰写一个XML映射文件档名是User.hbm.xml，如下所示：

User.hbm.xml

            
<?xml version="1.0"?>

            <!DOCTYPE hibernate-mapping

                PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"

                "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

            <hibernate-mapping>

                <class name="onlyfun.caterpillar.User" table="USER">

                    <id name="id" type="string" unsaved-value="null">

                        <column name="user_id" sql-type="char(32)" />

                        <generator class="uuid.hex"/>

                    </id>

                    <property name="name" type="string" not-null="true">

                        <column name="name" length="16" not-null="true"/>

                    </property>

                    <property name="sex" type="char"/>

                    <property name="age" type="int"/>

                </class>

            </hibernate-mapping>
            

这个XML文件定义了对象属性映像至数据库表格的关系，您可以很简单的了解对映的方法，像是User对象对应至USER表格，其中我们使用 uuid.hex来定义主键的产生算法，UUID算法使用IP地址、JVM的启动时间、系统时间和一个计数值来产生主键。除了使用uuid.hex之外，我们还可以使用其它的方式来产生主键，像是increment等，这可以在Hibernate参考手册中找到相关资料。

<property>卷标用于定义Java对象的属性，而当中的<column/>卷标用于定义与数据库的对应，如果您是手工建立Java对象与数据库表格，则在最简单的情况下，可以只定义<property name="sex"/>这样的方式，而由Hibernate自动判断Java对象属性与数据库表格名称对应关系，在< property/>与<column/>标签上的额外设定（像是not null、sql-type等），则可以用于自动产生Java对象与数据库表格的工具上。

接下来我们定义Hibernate配置文件，主要是进行SessionFactory配置，Hibernate可以使用XML或属性文件来进行配置，我 们这边先介绍如何使用XML配置，这也是Hibernate所建议的配置方式，我们的文件名是hibernate.cfg.xml，如下：

hibernate.cfg.xml

            
<?xml version='1.0' encoding='big5'?>

            <!DOCTYPE hibernate-configuration

                PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"

                "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">

            <hibernate-configuration>

                <session-factory>

                    <!-- 显示实际操作数据库时的SQL -->

                    <property name="show_sql">true</property>

                    <!-- SQL方言，这边设定的是MySQL -->

                    <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>

                    <!-- JDBC驱动程序 -->

                    <property name="connection.driver_class">com.mysql.jdbc.Driver</property>

                    <!-- JDBC URL -->

                    <property name="connection.url">jdbc:mysql://localhost/HibernateTest</property>

                    <!-- 数据库使用者 -->

                    <property name="connection.username">caterpillar</property>

                    <!-- 数据库密码 -->

                    <property name="connection.password">123456</property>

                    <!-- 对象与数据库表格映像文件 -->

                    <mapping resource="User.hbm.xml"/>

                </session-factory>

            </hibernate-configuration>
            

接下来我们撰写一个测试的程序，这个程序将直接以Java程序设计人员熟悉的语法方式来操作对象，而实际上也直接完成对数据库的操作，程序将会将一笔数据存入表格之中：

HibernateTest.java

            
import onlyfun.caterpillar.*;

            import net.sf.hibernate.*;

            import net.sf.hibernate.cfg.*;

            public class HibernateTest {

                public static void main(String[] args) throws HibernateException {

                    SessionFactory sessionFactory = 

                      new Configuration().configure().buildSessionFactory();

                    User user = new User();

                    user.setName("caterpillar");

                    user.setSex('M');

                    user.setAge(28);

                    Session session = sessionFactory.openSession();

                    Transaction tx= session.beginTransaction();

                    session.save(user);

                    tx.commit();

                    session.close();

                    sessionFactory.close();          

                    System.out.println("新增资料OK!请先用MySQL观看结果！");

                }

            }
            

#p#

Configuration代表了Java对象至数据库的映像设定，这个设定是从我们上面的XML而来，接下来我们从Configuration取得SessionFactory对象，并由它来开启一个Session，它代表对象与表格的一次会话操作，而 Transaction则表示一组会话操作，我们只需要直接操作User对象，并进行Session与Transaction的相关操作， Hibernate就会自动完成对数据库的操作。这边对程序先只作简单的介绍，之后再详加说明。

将所有的.java档案编译，并将两个XML档案放置在与HibernateTest相同的目录中，也就是档案位置如下：

            
/

            |--HibernateTest.class

            |--User.hbm.xml

            |--hibernate.cfg.xml

                /onlyfun

                    /caterpillar

                    |--User.class
            

OK!现在您可以执行HibernateTest，程序将会出现以下的讯息：

            
log4j:WARN No appenders could be found for logger (net.sf.hibernate.cfg.Environment).

            log4j:WARN Please initialize the log4j system properly.

            Hibernate: insert into USER (name, sex, age, user_id) values (?, ?, ?, ?)
            

新增资料OK!请先用MySQL观看结果！

这边只先进行数据的存入，要观看数据存入的结果的话，请进入MySQL观看，以下是数据库存入的结果：

            
mysql> SELECT * FROM USER;

            +----------------------------------+-------------+------+------+

            | user_id                          | name        | sex  | age  |

            +----------------------------------+-------------+------+------+

            | 297e3dbdfea6023d00fea60241000001 | caterpillar | M    |   28 |

            +----------------------------------+-------------+------+------+

            1 rows in set (0.00 sec) 
            

CODE:

long now = System.currentTimeMillis();

String s = String.format("%tR", now);   // "15:12"

CODE:

// Current month/day/year

Date d = new Date(now);

s = String.format("%tD", d);                // "07/13/04"

CODE:

s = String.format("%,d", Integer.MAX_VALUE); // "2,147,483,647"

CODE:

s = String.format("%05d", 123);              // "00123"是不是很方便，让人动心啊？哈哈，还有更多的效果!

其实format函数有些类似c语言中printf函数，一些格式字符串与 C 类似，但已进行了某些定制，以适应 Java 语言，并且利用了其中一些特性。此方法提供了对布局对齐和排列的支持，以及对数值、字符串和日期/时间数据的常规格式和特定于语言环境的输出的支持。支持诸如 byte、BigDecimal 和 Calendar 等常见 Java 类型。

产生格式化输出的每个方法都需要格式字符串 和参数列表。格式字符串是一个 String，它可以包含固定文本以及一个或多个嵌入的格式说明符。请考虑以下示例：

Calendar c = ...;
String s = String.format("Duke's Birthday: %1$tm %1$te,%1$tY", c);

格式字符串是 format 方法的第一个参数。它包含三个格式说明符 "%1$tm"、"%1$te" 和 "%1$tY"，它们指出应该如何处理参数以及在文本的什么地方插入它们。格式字符串的其余部分是包括 "Dukes Birthday: " 和其他任何空格或标点符号的固定文本。 参数列表由传递给位于格式字符串之后的方法的所有参数组成。在上述示例中，参数列表的大小为 1，由新对象 Calendar 组成。

1.常规类型、字符类型和数值类型的格式说明符的语法如下：%[argument_index$][flags][width][.precision]conversion

可选的 argument_index 是一个十进制整数，用于表明参数在参数列表中的位置。第一个参数由 "1$" 引用，第二个参数由 "2$" 引用，依此类推。
可选的 flags 是修改输出格式的字符集。有效标志的集合取决于转换类型。
可选 width 是一个非负十进制整数，表明要向输出中写入的最少字符数。
可选 precision 是一个非负十进制整数，通常用来限制字符数。特定行为取决于转换类型。
所需的 conversion 是一个表明应该如何格式化参数的字符。给定参数的有效转换集合取决于参数的数据类型。

2.用来表示日期和时间类型的格式说明符的语法如下:
%[argument_index$][flags][width]conversion

可选的 argument_index、flags 和 width 的定义同上。
所需的 conversion 是一个由两字符组成的序列。第一个字符是 't' 或 'T'。第二个字符表明所使用的格式。这些字符类似于但不完全等同于那些由 GNU date 和 POSIX strftime(3c) 定义的字符。


3.与参数不对应的格式说明符的语法如下：
%[flags][width]conversion

可选 flags 和 width 的定义同上。
所需的 conversion 是一个表明要在输出中所插内容的字符。

转换
转换可分为以下几类：
1. 常规 - 可应用于任何参数类型
2. 字符 - 可应用于表示 Unicode 字符的基本类型：char、Character、byte、Byte、short 和 Short。当 Character.isValidCodePoint(int) 返回 true 时，可将此转换应用于 int 和 Integer 类型
3. 数值
      1. 整数 - 可应用于 Java 的整数类型：byte、Byte、short、Short、int、Integer、long、Long 和 BigInteger
      2. 浮点 - 可用于 Java 的浮点类型：float、Float、double、Double 和 BigDecimal
4. 日期/时间 - 可应用于 Java 的、能够对日期或时间进行编码的类型：long、Long、Calendar 和 Date。
5. 百分比 - 产生字面值 '%' ('\u0025')
6. 行分隔符 - 产生特定于平台的行分隔符

下表总结了受支持的转换。由大写字符（如 'B'、'H'、'S'、'C'、'X'、'E'、'G'、'A' 和 'T'）表示的转换与由相应的小写字符的转换等同，根据流行的 Locale 规则将结果转换为大写形式除外。后者等同于 String.toUpperCase() 的以下调用.

Calendar c = ...;
String s1 = String.format("Duke's Birthday: %1$tm %1$te,%1$tY", c);

String s2 = String.format("Duke's Birthday: %1$tm %<$te,%<$tY", c);

主要功能如下：
1、$() 获得页面参数值
2、addOptions and removeAllOptions 初始化下拉框
3、addRows and removeAllRows 填充表格
4、getText  取得text属性值
5、getValue 取得form表单值
6、getValues 取得form多个值
7、onReturn
8、selectRange
9、setValue
10、setValues
11、toDescriptiveString
12、useLoadingMessage
13、Submission box

1。$();
功能 : 相当于 document.getElementById(id);
参数 : id 或 name 属性值 ;
例 :
<script>
         Var ele=$(txt_test);
         Var str=DWRUtil.toDescriptiveString(ele,1)
         DWRUtil.debug(str);
</script>

2。DWRUtil.getValue();
功能 : 获得指定元素 value 值
参数 : id 或 name 属性值 ;
注意 : 该函数只能用于有 value 属性的元素
例 :
<script>
         var val=DWRUtil.getValue(“txt_test”);
         DWRUtil.debug(val);
</script>

3。 DWRUtil.getValues();
功能 : 获得一组指定元素的 value 值 ;
参数 :id 或 name 构成的数组对象
例 :
<script>
         Var arr_=DWRUtil.getValues({“txt_name”:null,”txt_pswd”:null});
         Var str=DWRUtil.toDescriptiveString(arr,1)
         DWRUtil.debug(str);
</script>

4。DWRUtil.setValue();
功能 : 设置指定元素的 value 值
参数 : id 或 name 属性值
例 :
<script>
         DWRUtil.setValue(“txt_test”,”wiley”);
</script>

5。 DWRUtil.setValues();
功能 : 设置一组指定元素的值
参数 : id 或 name 构成的数组对象
例 :
<script>
         DWRUtil.setValues({“txt_name”:”wiley”,”txt_pswd”:”wiley”});
</script>

6。 DWRUtil.getText();
功能 : 获得 select 元素的文本值
参数 : id 或 name 属性值
例 :
<script>
         Var txt=DWRUtil.getText (“sel_test”);
         Var val=DWRUtil.getValue(“sel_test”);
         DWRUtil.debug(“Text:”+txt+”\tValue:”+val);
</script>

7。DWRUtil.addRows();
功能 : 指定表格添加行
格式 :DWRUtil.addRows(id,items, functions);
参数 :
第一个参数 :table 或 tbody 的 id 属性值
第二个参数 : 数组或链表 ( 可能用词不是很适合 )
第三个参数 : 函数链表
例:
<script>
         Var arr_={“wiley’s blog”,”wiley 中国 ”};
         DWRUtil.addRows(“tby_test”,arr_,[function(arr_){return arr_}]);
</script>

<script>
         Var items=[{“name”:”wiley 中国 ”,”add”:”wiley-cn.com”}];
         DWRUtil.addRows(“tby_test”,items,[function(item){return item.name}, function(item){return item.add}]);
</script>

8。DWRUtil.romoveAllRows();
功能 : 删除指定表格行
参数 :table 或 tbody 的 id 属性值
<script>
         DWRUtil.romoveAllRows(“tby_test”);// 每次添加前将原有数据行删除 , 防止数据重叠
         Var items=[{“name”:”wiley 中国 ”,”add”:”wiley-cn.com”}];
         DWRUtil.addRows(“tby_test”,items,[function(item){return item.name}, function(item){return item.add}]);
</script>

9。DWRUtil.addOptions();
功能 : 添加 select 元素的 option 子元素
格式 :DWRUtil.addOption(id,items) 或 DWRUtil.addOption(id,items,valueProp,textProp);
参数 :
第一个参数 :select 的 id 或 name 属性值
第二个参数 : 数组或链表 ( 填充数据 )
第三、四个参数 : 链表节点的属性 , 第三个填充 value 值，第四个填充 text 值
    <script>
         Var arr_={“wiley”,”wiley 中国 ”};
         DWRUtil.addRows(“sel_test”,arr_);// 此时 value 与 text 值相同
         DWRUtil.romoveAllOptions(“sel_test”);
         Var items=[{“name”:”wiley 中国 ”,”add”:”wiley-cn.com”}];
         DWRUtil.addRows(“sel_test”,”add”,”name”);// 此时 value 与 text 不相同
</script>

10。DWRUtil.romoveAllOptions();
功能 : 删除指定 select 元素的 option 子元素
参数 :select 元素的 id 或 name 属性值
例 : 前面例子有用到

11。DWRUtil.debug();
功能 : 等价于 alert()
例 : 前面例子有用到

12。DWRUtil.toDescriptiveString();
功能：将对象序列化成字符串 , 主要用于调试
带debug信息的toString，第一个为将要debug的对象，第二个参数为处理等级。等级如下：

     0: Single line of debug 单行调试 
     1: Multi-line debug that does not dig into child objects 不分析子元素的多行调试 
     2: Multi-line debug that digs into the 2nd layer of child objects 最多分析到第二层子元素的多行调试

     <input type="text" id="text">
     DWRUtil.toDescrīptiveString("text",0);

13。DWRUtil.useLoadingMessage();
    功能：当发出ajax请求后,页面显示的提示等待信息;
    例：
    function searchUser(){
        var loadinfo = "loading....."
        regUser.queryAllUser(userList);
        DWRUtil.useLoadingMessage(loadinfo); 
     }