C a c h e - C o n t r o l 指指定任何缓存系统对文档的操作。最常用的值有： n o - c a c h e（表明此文档不需缓存），
n o - s t o r e（表明此文档不必缓存，甚至不要保存在代理服务器中，通常是敏感内容），
m a x - a g e = s e c o n d s（表明文档到过时的时间长度）。这个头从H T T P 1 . 1开始引入
P r a g m a 指H T T P 1 . 0中的等价头是C a c h e - c o n t r o l，并且只有一个可能的值n o - c a c h e
C o n n e c t i o n 指用于表明服务器是否愿意为客户维持持续连接。如果愿意，它的值设为k e e p - a l i v e；
否则设为c l o s e。大多数的服务器代表它们的s e r v l e t处理这个头，当s e r v l e t设置C o n t e n t -
L e n g t h头时，服务器就自动将C o n n e c t i o n的值设为k e e p - a l i v e
R e t r y - A f t e r 指指定服务器可再次处理请求的时间，与S C _ S E RV I C E _ U N AVA I L A B L E状态码一起使
用。它的值要么是代表时间(秒)的整数，要么是代表实际时间的日期子串。
E x p i r e s 指指定何时文档可能改变，或它的信息将变成非法。它也意味着，在这个时间之前文档
不可能变化
L o c a t i o n 指指定文档的新路径，通常与S C _ C R E ATED, SC_MOVED_PREMANENTLY 和
S C _ M O V E D _ T E M P O R A R I LY等状态码一起使用。它的值必须是完整的U R L（包含
"h t t p：/ /"）
W W W- A u t h e n t i c a t e 指指定由访问请求URL 的客户要求的认证体系和认证范围。与S C _ U N AT H O R I Z E D状
态码一起使用
C o n t e n t - E n c o d i n g 指指定用于编码响应体的体系。可能的值有： g z i p（或x - g z i p）、c o m p r e s s（或x -
c o m p r e s s）。多编码体系应按应用于数据的使用顺序用逗号隔开
(1) 设定H T T P头
H t t p S e r v l e t R e s p o n s e类提供了一系列的方法，帮助s e r v l e t设置H T T P响应头信息。可使用
s e t H e a d e r（）方法设置头值：
public void HttpServletResponse.setHeader(String name , String value)
这个方法将指定头的值设置为S t r i n g。这个头名称是不变的，对所有的方法都一样。如果头
的值已经设定，新值将覆盖前一值。头的所有类型都可通过这个方法来设定。
如果需要为头值定义一个日期戳，可使用s e t D a t e H e a d e r（）方法：
public void HttpServletResponse.setDateHeader(String name , long date)
这个方法把指定名称的头值设定为特定的日期和时间，并接收日期的l o n g类型值（表示自
GMT 1970，1，1，0：0：0起的毫秒数）。如果这个头已经设置过，新值将覆盖旧值。
最后，可以用s e t I n t H e a d e r（）为头指定一个整型值：
public void HttpServletResponse.setIntHeader(String name , int value)
这个方法将头的值设定为整型，如果已经设置过，则新值覆盖旧值。
c o n t a i n s H e a d e r（）方法提供了一种检查头是否存在的途径：
public boolean HttpServletResponse.containsHeader(String name)
如果头已被设置，这个方法返回t r u e，否则返回f a l s e。
另外， H T M L 3 . 2规范中，有另一种设置头值的方法：在H T M L页中使用内嵌的< M E TA
H T T P - E Q U I V >标签。
<META HTTP-EQUIV=＂name＂ CONTENT=＂value＂>
这个标签必须作为H T M L页的< H E A D >组成部分发送。这个技术对s e r v l e t没什么用，它主要
第二章预备知识49
用于静态文档，它们不必访问自己的头信息。
(2) 重定向请求
s e r v l e t使用状态码和头信息的另一个用途是重定向请求。这是通过给客户端发送另一个U R L
指示来实现的。重定向通常用在：当文档移动时（给客户端发送新的路径），负载平衡（一个
U R L文档可能分布在几个不同的机器上），简单的随机文档（随机地选择目标路径）。
真正的重定向发生在以下两行:
res.setStatus(res.SC_MOVED_TEMPORARILY);
res.setHeader(＂Location＂, site);
第一行设置状态码，表明需要重定向，第二行给出新的位置。为确保它们正常工作，必须
在发送任何输出之前调用这些方法。记住， H T T P协议在发送内容体之前发送状态码和头信息。
新站点的位置必须以绝对的U R L给出（例如，h t t p：/ / s e r v e r：p o r t / p a t h / f i l e . h t m l），否则，客户就
难以找到。
用s e n d R e d i r e c t（）方法能很方便地将这两行简化为一行：
public void HttpServletResponse.sendRedirect(String location) throws
IOException
这个方法重定向响应信息到新的位置，自动地设置状态码和L o c a t i o n的头信息，这两行就变成：
res.sendRedirect(site);
(3) 客户牵引
客户牵引与重定向类似，主要的区别在于：浏览器一直显示第一页的内容，并且在接收和
显示第二页之前等待一个指定的时间间隔。它之所以叫客户牵引，是因为由客户端拖曳下一页
的内容。
这有什么用呢？首先，可以在第二页之前，由第一页的内容告诉客户请求的内容已经
移动；其次，网页可按顺序接收，为制作慢速页面动画提供了可能。
客户牵引信息是使用Refresh HTTP 头发送给客户端的。这个头值指明在牵引下一页之前显
示当前页的秒数，也可选择地包含一个U R L子串，从中文件。如果没给定U R L，则使用相
同的U R L。下面这个语句告诉客户在显示当前内容3 s后，重新同一个s e r v l e t：
setHeader（＂Refresh＂，＂3＂）；
这里还有一个告诉客户3 s后显示N e t s c a p e主页的语句：
setHeader（＂Refresh＂，＂3；URL=http：//home.netscape.com＂）;
7. 错误处理
s e r v l e t有时会出错，没关系， s e r v l e t必须得处理错误，有预料中的，也有始料未及的。错误
一旦发生，必须关心两件事：
1) 将对服务器的破坏降到最低。
2) 正确的通知客户端。
因为s e r v l e t是用J a v a编写的，所以它对服务器的破坏程度大大降低。服务器可以安全地嵌入
s e r v l e t（甚至嵌入它的进程中），就像We b浏览器能安全地嵌入的a p p l e t s一样。这种安全性
是建立在J a v a的安全体系基础上的，包括保护内存使用，异常处理，安全管理机制等。J a v a的内
50第一部分JSP 入门
存保护保证s e r v l e t不可能偶尔（或故意地）访问服务器的内部系统； J a v a的异常处理使服务器能
捕获由s e r v l e t引起的每一个异常，即使s e r v l e t偶尔被零除，或调用空对象的方法，服务器仍能够
继续工作；J a v a的安全管理机制为服务器提供了一种将信任的s e r v l e t放于一个沙箱中的途径，限
制和防止它们故意破坏的能力。
应该谨慎的是，处于安全管理器沙箱之外运行的s e r v l e t具有造成服务器破坏的能力， s e r v l e t
可能覆盖服务器的文件空间或甚至调用S y s t e m . e x i t ( )，应该相信，被信任的s e r v l e t一般不会导致
服务器破坏，也极少会调用S y s t e m . e x i t ( )。
正确地向客户描述出现的问题，不仅仅是J a v a语言的事，还有许多需要考虑的因素：
1) 怎样告诉客户端？
s e r v l e t是给客户端发送普通的状态码错误页，还是发送错误的字面描述，抑或发送错误堆栈
的详细内容？
2) 怎样记录问题？
是保存到文件，写到服务器日志中，发送到客户端还是忽略？
3) 怎样恢复？
S e r v l e t是否继续处理下一个请求？或s e r v l e t崩溃，这意味着必须重新。
这些问题的答案取决于s e r v l e t和它的用途。怎样处理错误就由开发人员自己决定，但应确保
s e r v l e t在被请求时的可靠性和健壮性。接下来看看s e r v l e t错误处理机制的全貌，可以有选择地用
它们来实现错误处理策略。
(1) 状态码
s e r v l e t最简单的报错方式是用s e n d E r r o r（）方法发送恰当的4 0 0系列或5 0 0系列状态码。例如，
当s e r v l e t被请求一个不存在的文件时，它可以返回S C _ N O T _ F O U N D；如果请求的工作超出了它
的能力范围，它可以返回S C _ N O T _ I M P L E M E N T E D。当发生内部异常时，它可以返回
S C _ I N T E R N A L _ S E RV E R _ E R R O R。
通过使用状态码， s e r v l e t为服务器提供了一个给响应信息特殊处理的机会。例如，有些服务
器如Java Web Server，可以用与服务器相关的错误信息取代s e r v l e t的响应信息；如果错误应由
s e r v l e t向客户提供解释，它可以用s e t S t a t u s（）设置状态码，同时发出相应的响应体，这个响应
体可以是文本格式，图像格式和其他恰当的类型。
在发送响应体之前， s e r v l e t应尽量捕获和处理任何类型的错误。你可能还记得（因为我们反
复提到），H T T P规定状态码和H T T P头必须在响应体之前发送。一旦发出响应信息，哪怕只发出
一个字符，都来不及更改状态码和H T T P头信息。为避免这种“太迟”的尴尬局面，可以使用
B y t e A r r a y O u t p u t S t r e a m缓存或H T M L生成器包。
(2) 日志
s e r v l e t能将它们的行为和错误通过使用l o g（）方法写入日志文件中：
public void ServletContext.log(String msg)
public void ServletContext.log(Exception e, String msg)
单个参数的方法是将给定的消息写入s e r v l e t日志中，这个日志通常是事件日志文件。带两个
参数的版本是将给定的消息和异常堆栈信息写入s e r v l e t日志中。这两种方法的输出格式和日志文
第二章预备知识51
件的路径都是服务器相关的。
G e n e r i c S e r v l e t类也提供了l o g（）方法：
public void GenericServlet.log(String msg)
这是S e r v l e t C o n t e x t方法的另一个版本，移入G e n e r i c S e r v l e t类中是为了使用方便，这个方法
允许s e r v l e t像下面这样简单调用，写入s e r v l e t日志之中：
log（msg）；
然而，G e n e r i c S e r v l e t没提供两个参数的l o g（）版本，这可能是个疏忽，会在将来的版本中
增加。现在，s e r v l e t可以通过调用下列函数执行类似的功能：
getServletContext().log(e , msg);
l o g ( )方法提供了跟踪s e r v l e t行为的途径，可用于帮助程序调试。它也提供了保存s e r v l e t遇到
的任何错的误详尽描述方法，这个描述可以与发送给客户端的一样，也可以更为详尽。
(3) 报告错误
除了能为服务器管理员记录错误和异常外，开发过程中显示问题的详细描述也是很方便的。
遗憾的是，异常不能以S t r i n g形式返回它的堆栈跟踪信息，它只能显示堆栈跟踪信息到P r i n t S t r e a m
或P r i n t Wr i t e r中。要以S t r i n g类型收集堆栈跟踪信息，就必须绕些弯子。必须让异常显示到特殊的
P r i n t Wr i t e r中，这个P r i n t Wr i t e r是建立在B y t e A r r a y O u t p u t S t r e a m基础上的，它能捕获输出并转化为
S t r i n g类型。c o m . o r e i l l y. s e r v l e t . S e r v l e t U t i l s类有个g e t S t a c k Tr a c e S t r i n g ( )方法可完成这种工作：
public static String getStackTraceAsString(Exception e) {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
PrintWriter writer = new PrintWriter(bytes, true);
e.printStackTrace(writer);
return bytes.toString();
}
下面是提供包括I O E x c e p t i o n堆栈跟踪信息的Vi e w F i l e :
file://Return the file
try {
ServletUtils.returnFile(file ,out );
}
catch (FileNotFoundException e) {
log(＂Could not find file: ＂ + e.getMessage());
res.sendError(res.SC_NOT_FOUND);
}
catch (IOException e) {
getServletContext().log(e, ＂Problem sending file＂);
res.sendError(res.SC_INTERNAL_SERVER_ERROR,
ServletUtils.getStackTraceAsString(e));
}
(4) 异常处理
前面曾经提到，抛出的异常如果没被s e r v l e t捕获，就将被服务器捕获。服务器如何处理异常
是因服务器而异的：它也许给客户端发送消息和堆栈跟踪信息；它或许自动地记录异常；它甚
52第一部分JSP 入门
至也许在s e r v l e t上调用d e s t r o y（）方法并重新。
为某特定的服务器设计和开发的s e r v l e t可以优化服务器的行为，而设计为跨多种服务器的
s e r v l e t做不到，如果这种s e r v l e t需要特殊的异常处理，就得考虑相应的服务器因素。
有些异常类型是s e r v l e t必须捕捉的， s e r v l e t仅能将I O E x c e p t i o n、S e r v l e t E x c e p t i o n或
R u n t i m e E x c e p t i o n的子类异常传给它的服务器。原因与方法的特性有关， s e r v l e t的s e r v i c e（）方
法在它的t h r o w s语句中声明抛出I O E x c e p t i o n和S e r v l e t E x c e p t i o n异常，因此它不捕获编译过程中
的异常。R u n t i m e E x c e p t i o n是个特殊类型的异常，它不需要在t h r o w s语句中被声明，一个常见的
例子是N u l l P o i n t E x c e p t i o n。
i n i t（）方法和d e s t r o y（）方法也有自己的特征， i n i t方法声明仅抛出S e r v l e t E x c e p t i o n异常，
而d e s t r o y（）方法声明不抛出异常。
S e r v l e t E x c e p t i o n是j a v a . l a n g . E x c e p t i o n的子类，此类是s e r v l e t相关的，并在j a v a x . s e r v l e t . p a c k a g e
包中被定义。这个异常表明常规s e r v l e t问题，它与j a v a . l a n g . E x c e p t i o n具有相同的构造函数：一个
不带参数，一个仅带一个消息字串参数。捕捉这种异常的服务器可能用任何合适的方法处理它。
j a v a x . s e r v l e t包定义了一个S e r v l e t E x c e p t i o n子类U n a v a i l a b l e E x c e p t i o n，这个异常表明s e r v l e t
不可访问，或是临时的，或是永久的。
U n a v a i l a b l e E x c e p t i o n有两个构造函数：
java.servlet.UnavailableException(Servlet servlet , String msg)
java.servlet.UnavailableException(int Seconds , Servlet servlet , String msg)
双参数的构造函数创建一个新的异常，表明指定的s e r v l e t永久性地不可访问，并且由m s g给
出解释；三参数的构造函数创建一个新的异常，表明指定的s e r v l e t暂时不可访问，并由m s g给出
解释，不可访问的时间长度由s e c o n d s给出，这仅仅是个估计时间。
2.4 SQL语言
J S P的数据库方面所依赖的是J D B C，而J D B C的强大在于：J D B C可以使J a v a成为一种能同不
均匀的数据库环境打交道的强大工具，这种不均匀的数据库环境尽管的确差别很大，但是无论
是哪一种关系数据库，从O r a c l e到D B 2到S y b a s e再到MS SQL Server，有一点是相同的，那就是
S Q L语言-结构化查询语言。
尽管各个不同的数据库厂商对S Q L做了各自的扩展，如： O r a c l e的P L - S Q L、Microsoft SQL
S e r v e r的Tr a n s a c t - S Q L、还有S Q L语言鼻祖I B M的DB2 SQL，每一个R D B M S厂商都宣称自己的
扩展是最优秀的，然而，这些不同的S Q L仍然有共同点，他们都基于ANSI SQL 92。
S Q L不是一门特别复杂的语言，不过如果想要学好S Q L，特别是各个不同厂商特有的S Q L，
仍然需要特别的努力，仅仅讲述S Q L中最基本的语句，本书在第一部分的例子程序中也只会用
到最基本的S Q L语句，在第二部分的例子中由于将会使用存储过程，所以会使用一些扩展的S Q L
语言，这些扩展将在需要时再进行讲解。
2.4.1 SQL子类型
S Q L语言的子类型包括：数据处理语言（ D M L）、数据定义语言（ D D L）和数据控制语言
第二章预备知识53
（D C L）。
数据处理语言D M L完成在数据库中确定、修改、添加、删除某一数据的值的任务，下面是
在J a v a和J D B C中常用到的一些数据处理S Q L语句：
SELECT 在数据库中依据某一种规则查询数据。
I N S E RT 向数据库中添加一行数据。
DELETE 删除数据库中的某一行数据。
U P D ATE 改变数据库中已有记录。
数据定义语言D D L完成定义数据库的结构，包括数据库本身、数据表、目录、视图等数据
库元素：
C R E ATE 在数据库中建立一个元素。
DROP 在数据库中删除一个元素。
数据控制语言D C L完成管理数据库中数据的存储权限的任务，下面是在J a v a和J D B C中常用
到的一些数据控制S Q L语句：
GRANT 设置某一用户或用户组可以某种形式访问数据库中的某一元素。
REVOKE 去掉某一用户或用户组可以某种形式访问数据库中的某一元素的权利。
2.4.2 SQL语言的具体命令和使用
下面的范例使用了Microsoft SQL Server 7.0 自带的样本数据库，需要说明的是，尽管
Microsoft SQL Server在J a v a的支持上比其他的R D B M S如O r a c l e、D B 2要差，但Microsoft SQL
S e r v e r比较容易使用，本书在第一部分的例子基本上都是使用Microsoft SQL Server 7.0建立的；
另一方面，第一部分的例子没有使用到SQL Server特有的S Q L语句的情况，所以读者可把这些例
子移植到O r a c l e、D B 2或是其他任何支持S Q L的数据库系统上。
1. SELECT 语句
SELECT 无疑是S Q L语句中最常用的语句，一个S E L E C T语句可以十分简单，也可以十分复
杂，下面先从最简单的开始：
在Query Analyzer中选择数据库为N o r t h w i n d，然后输入：
SELECT * FROM customers
执行它，则可以看见如图2 - 1所示的结果：
这条S E L E C T语句的含义从字面上就很好理解，即：从c u s t o m e r s数据表中检索出全部数据，
“*”表示全部的列。
如果把“*”换为“C u s t o m e r I D”，则结果将会变为：
customerID
----------
ALFKI
ANATR
ANTON
. . . . . .
注意：为了节省篇幅，下面的例子执行结果将不再使用图形表示，读者应当可以看懂。
54第一部分JSP 入门
图2 - 1
“*”中的内容也可以包含多项，其中用“ ,”隔开即可，如：
"SELECT CustomerID,CompanyName from customers"。
(1) 使用别名
数据表中某一列的名称应该是有意义的，但不幸的是，这仅仅是对某一些人而言，常常有
这种情况：某一位数据库建立者创建的数据库中包含的列名对他自己来说是有明确意义的，但
对另外一些人来说却是不知所云。
解决办法就是在查询的时候为数据表的某一列建立一个别名，下面举例说明：
select phone as "电话", fax as "传真"from customers
结果如下：
电话传真
----------------------- -----------------------
0 3 0 - 0 0 7 4 3 2 1 0 3 0 - 0 0 7 6 5 4 5
(5) 555-4729 (5) 555-3745
(5) 555-3932 N U L L
. . . . . .
这样，原先对于不懂英文的人来说不知所云的“ p h o n e”和“ f a x”现在变成了简单易懂的
第二章预备知识55
“电话”和“传真”。
(2) 在查询输出中加入文本
尽管上面加上别名之后的输出结果让人容易理解，但仍然不是太明确，在查询输出中加入
文本的方法将可以输出完整的句子。
select CompanyName as "公司名称","公司的电话是",phone as"电话"from customers
结果是：
公司名称电话
----------------------------------------------- ------------------------- ------------------------
Alfreds Futterkiste 公司的电话是0 3 0 - 0 0 7 4 3 2 1
Ana Trujillo Emparedados y helados 公司的电话是(5) 555-4729
Antonio Moreno Ta q u e ría 公司的电话是(5) 555-3932
. . . . . . . . . . . .
在J D B C和J S P中，在查询中加入文本有助于直接输出可以用在网页中且包含H T M L代码的查
询结果。
( 3 ) ORDER BY 子句
ORDER BY子句的作用是将输出结果按照某一列按升序或降序排列，其中，升序排列的附
加命令是A S C，而降序排列的附加命令是D E S C，缺省为升序排列。
SELECT CompanyName,phone from customers ORDER BY phone
结果如下：
C o m p a n y N a m e p h o n e
-------------------------- ------------------------
Maison Dewey (02) 201 24 67
S u p rêmes délices (071) 23 67 22 20
Rancho grande (1) 123-5555
而如果是：
SELECT CompanyName,phone from customers ORDER BY phone DESC
则结果是：
C o m p a n y N a m e p h o n e
----------------------------- ------------------------
Wartian Herkku 9 8 1 - 4 4 3 6 5 5
Bon app' 9 1 . 2 4 . 4 5 . 4 0
Wilman Kala 90-224 8858
(4) WHERE短语
W H E R E是一个有条件的选择数据的短语，它指定只返回那些和W H E R E短语重指定的条件
一致的数据。
W H E R E短语的条件可以包含关系运算、布尔运算、L I K E、I N、B E T W E E N等等，甚至可以
包含其他的S E L E C T语句的查询结果。下面分别介绍：
56第一部分JSP 入门
1) 关系运算。S Q L语言的关系运算包括：“=”、“>”、“<”、“> =”、“< =”、“< >”。从这些符
号本身就应该可以理解其意义，下面是一个实例：
SELECT CompanyName,City from customers where City="London"
目的是找出客户中所有所在地为伦敦的公司。结果如下
C o m p a n y N a m e City
------------------------ ---------------
Around the Horn L o n d o n
B's Beverages L o n d o n
Consolidated Holdings L o n d o n
Eastern Connection L o n d o n
N o r t h / S o u t h L o n d o n
Seven Seas Imports L o n d o n
2) 布尔运算。S Q L语言的布尔运算包括“ A N D”、“O R”、“N O T”，即“与”、“或”、“非”
三种运算。
例子如下，目的是找出订单中所有和代号“ V I N E T”的公司相关并且由2号雇员处理的订单。
SELECT OrderID,CustomerID,EmployeeID FROM orders
WHERE CustomerID="VINET"AND EmployeeID=2
结果如下：
O r d e r I D C u s t o m e r I D EmployeeID
----------- -------------------- --------------------
1 0 2 9 5 V I N E T 2
1 0 7 3 7 V I N E T 2
(5) LIKE运算
L I K E运算的用途是在那些文本类型的数据中找出某一特定的字符串，加上通配符的使用，
只需学会使用L I K E运算就可以构造一个简单的搜索引擎了。
在L I K E运算中包含如下两个通配符：
% 代表多个字符
_ 代表一个字符
例子如下：
第一个例子在客户数据表中查找所有名称中含有“ H u n g r y”的公司：
SELECT CompanyName,CustomerID FROM customers
WHERE CompanyName LIKE "%Hungry%"
结果如下：
C o m p a n y N a m e CustomerID
---------------------------------------- --------------------
Hungry Coyote Import Store H U N G C
Hungry Owl All-Night Grocers H U N G O
第二章预备知识57
第二个例子是在订单数据表中查询所有的订单号以“ 1 0 2 4”开头的，且一共为五位的订单。
SELECT OrderID,CustomerID FROM orders WHERE OrderID LIKE "1024_"
结果如下：
O r d e r I D CustomerID
----------- --------------------
1 0 2 4 9 TO M S P
1 0 2 4 8 V I N E T
(6) IN运算
I N运算通过一个预先定义好的值表来限定所用值的范围，当所给参数和表中的值匹配时才
认为是“真”。
例如，在订单数据表中查询所有代号为V I N E T和TO M S P的客户：
SELECT CustomerID,OrderID,ShipName FROM orders
WHERE CustomerID IN("VINET","TOMSP")
结果如下：
C u s t o m e r I D O r d e r I D S h i p N a m e
----------------- ---------------- ----------------------------
TO M S P 1 0 2 4 9 Toms Spezialit?ten
TO M S P 1 0 4 3 8 Toms Spezialit?ten
TO M S P 1 0 4 4 6 Toms Spezialit?ten
TO M S P 1 0 5 4 8 Toms Spezialit?ten
TO M S P 1 0 6 0 8 Toms Spezialit?ten
TO M S P 1 0 9 6 7 Toms Spezialit?ten
V I N E T 1 0 2 4 8 Vins et alcools Chevalier
V I N E T 1 0 2 7 4 Vins et alcools Chevalier
V I N E T 1 0 2 9 5 Vins et alcools Chevalier
V I N E T 1 0 7 3 7 Vins et alcools Chevalier
V I N E T 1 0 7 3 9 Vins et alcools Chevalier
(7) BETWEEN运算
和I N运算一样， B E T W E E N运算也是限定所用值的范围，当所给参数和预设的值匹配时才认
为是“真”。不过B E T W E E N运算所限定的方式不是给出一个值表，而是给出一个最大值和最小
值。当数据表中的值在这个最大和最小值之间（包括最大值和最小值）时认为是“真”。
例如：
要找出订单数据表中所有订单号在1 0 2 4 9和1 0 2 5 4之间的订单：
SELECT CustomerID,OrderID,ShipName FROM orders
WHERE OrderID BETWEEN 10249 AND 10254
结果如下：
58第一部分JSP 入门
C u s t o m e r I D O r d e r I D ShipName
----------------- ---------------- -----------------------------
TO M S P 1 0 2 4 9 Toms Spezialit?ten
H A N A R 1 0 2 5 0 Hanari Carnes
V I C T E 1 0 2 5 1 Victuailles en stock
S U P R D 1 0 2 5 2 S u p rêmes délices
H A N A R 1 0 2 5 3 Hanari Carnes
C H O P S 1 0 2 5 4 Chop-suey Chinese
也许有的读者需要得到在最大值和最小值之间，但并不包括最大值和最小值的数据，那么
可以这样做：
SELECT CustomerID,OrderID,ShipName FROM orders
WHERE OrderID BETWEEN 10249 AND 10254
AND NOT OrderID IN (10249,10254)
这样结果就变成了：
C u s t o m e r I D O r d e r I D S h i p N a m e
------------------ ----------------- ---------------------------
H A N A R 1 0 2 5 0 Hanari Carnes
V I C T E 1 0 2 5 1 Victuailles en stock
S U P R D 1 0 2 5 2 Suprêmes délices
H A N A R 1 0 2 5 3 Hanari Carnes
(8) 使用函数
尽管大部分关系数据库系统（ R D B M S）都扩充了可以在S Q L中使用的函数，许多数据库系
统还允许用户自己扩充函数，但下面的几个函数总是可以使用的：
AVG 返回某一组中的值除以该组中值的个数的和。
COUNT 返回一组行或值中行或值的个数。
MAX 返回一组值中的最大值。
MIN 返回一组值中的最小值。
下面是实际的例子：
求出所有订单的数量总和：
SELECT COUNT(Freight) FROM orders
求出所有订单的运费平均值：
SELECT AVG(Freight) FROM orders
求出所有订单的运费最大值
SELECT MAX(Freight) FROM orders
求出所有订单的运费最小值
SELECT MIN(Freight) FROM orders
(9) 子查询
第二章预备知识59
子查询的概念在于将一个查询的结果作为另一个查询的条件，举例如下：
在订单数据表中的客户公司是使用公司代号来表示的，如果需要查询运费在5 0 0以上的公司
的名称和电话，就需要使用子查询这个概念：
SELECT CompanyName,phone FROM customers
WHERE CustomerID IN (
SELECT CustomerID from orders
WHERE freight>500
)
结果得到了需要的数据：
C o m p a n y N a m e p h o n e
--------------------- --------------------------
Ernst Handel 7 6 7 5 - 3 4 2 5
Great Lakes Food Market (503) 555-7555
Hungry Owl All-Night Grocers 2967 542
Queen Cozinha ( 11) 555-11 8 9
Q U I C K - S t o p 0 3 7 2 - 0 3 5 1 8 8
Rattlesnake Canyon Grocery (505) 555-5939
Save-a-lot Markets (208) 555-8097
White Clover Markets (206) 555-411 2
2. 使用数据修改命令
S Q L语言中数据的修改命令包括：
I N S E RT 建立记录。
D E L E T E 删除记录。
U P D AT E 修改记录。
(1) INSERT语句
I N S E RT语句在使用时有两种不同的格式。需要注意的是， I N S E RT语句假定需要插入数据
的数据表已经用C R E AT E语句或其他工具建立。
第一种用法是不列出数据表的各个列名，而按照数据表建立时的顺序将数据列出：
INSERT INTO Customers VALUES
("AAAAA","AAAAA Co.Ltd.","riso liao","Owner","Peking University","Bei Jing","Bei
Jing","HaiDian","100871","86-10-62754178","86-10-62763126")
第二种用法是在数据表的后面按照后面数据需要插入的列的顺序列出数据表中各个列的名称：
INSERT INTO Customers(
CustomerID,CompanyName,ContactName,ContactTitle,Address,City,Region,PostalCode,
Country,Phone,Fax
) VALUES
("AAAAA","AAAAA Co.Ltd.","riso liao","Owner","Peking University","Bei Jing","Bei
Jing","HaiDian","100871","86-10-62754178","86-10-62763126")
60第一部分JSP 入门
上面两条语句的作用都一样，不过在实际使用中建议使用第二种方法，因为第二种方法可
以让数据和数据要插入的列一一对应，而且还有利于插入空值，例如：现在需要加入到记录中
的这个公司数据相当不完整，只有公司名称和代号，当采用第一种方法时，需要这样书写S Q L
语句：
INSERT INTO Customers VALUES
("AAAAA","AAAAA Co.Ltd.",NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
而第二种方法只需要书写如下语句即可：
INSERT INTO Customers(
CustomerID,CompanyName)
VALUES
("AAAAA","AAAAA Co.Ltd.")
(2) DELETE语句
D E L E T E语句的使用是相当简单的，具体就是：
DELETE FROM 表名条件
其中条件不是必需的，当没有条件时，就意味着删除表中的所有记录。
例如，语句DELETE FROM customers WHERE CustomerID=”A A A A A”将删除刚才建立的
记录；而语句DELETE FROM customers将删除c u s t o m e r s数据表中的所有记录。
(3) UPDAT E语句
U P D AT E语句的作用是将数据库中某一条记录的某一个记录域更新，语句格式如下：
UPDATE 数据表SET 列名=新数据条件
和D E L E T E语句一样，这里的条件也可以是没有的，如果没有条件，那么数据表中的每一条
记录都将被更新。
现在来试验一下U P D AT E语句：
首先看一看数据本来的样子：
SELECT CustomerID,CompanyName FROM customers
可以看到第一行记录为：
C u s t o m e r I D C o m p a n y N a m e
------------------ --------------------------
A L F K I Alfreds Futterkiste
现在执行一个U P D AT E：
UPDATE customers SET CompanyName=’AAAAA’
WHERE CustomerID=’ALFKI’
再执行一下SELECT CustomerID,CompanyName FROM customers
发现结果变成了：
C u s t o m e r I D CompanyName
---------------- ------------------------
A L F K I A A A A A
第二章预备知识61
这样，数据库中的一条语句就被更新了。
2.5 JDBC
本节将在上节讲述的S Q L语言的基础上介绍J D B C，J D B C使得在J a v a程序中可以轻松地操纵
数据库：从企业级的O r a c l e、S y b a s e、D B 2到最简单的A c c e s s、M y S Q L。在J S P中，就是利用
J D B C来访问数据库的。
2.5.1 什么是J D B C
JDBC 是一种用于执行SQL 语句的Java API，它由一组用Java 编程语言编写的类和接口组
成。JDBC 为工具/数据库开发人员提供了一个标准的A P I，使他们能够用纯Java API 来编写数
据库应用程序。
有了J D B C，向各种关系数据库发送SQL 语句就是一件很容易的事。换言之，有了J D B C
A P I，就不必为访问Sybase 数据库专门写一个程序，为访问Oracle 数据库又专门写一个程序，
为访问Informix 数据库又写另一个程序，等等。只需用JDBC API 写一个程序就够了，它可向
相应的数据库发送SQL 语句。而且，使用Java 编程语言编写的应用程序，无须去忧虑要为不同
的平台编写不同的应用程序。将Java 和JDBC 结合起来将使程序员只需写一遍程序就可让它在
任何平台上运行。
Java 具有坚固、安全、易于使用、易于理解和可从网络上自动等特性，是编写数据库
应用程序的杰出语言。所需要的只是Java 应用程序与各种不同数据库之间进行对话的方法。而
JDBC 正是作为此种用途的机制。
JDBC 扩展了Java 的功能。例如，用Java 和JDBC API 可以发布含有applet 的网页，而该
applet 使用的信息可能来自远程数据库。企业也可以用JDBC 通过Intranet 将所有职员连到一个
或多个内部数据库中（即使这些职员所用的计算机有Wi n d o w s、Macintosh 和UNIX 等各种不
同的操作系统）。随着越来越多的程序员开始使用Java 编程语言，对从Java 中便捷地访问数据
库的要求也在日益增加。
MIS 管理员们都喜欢Java 和JDBC 的结合，因为它使信息传播变得容易和经济。企业可继
续使用它们安装好的数据库，并能便捷地存取信息，即使这些信息是存储在不同数据库管理系
统上。新程序的开发期很短。安装和版本控制将大为简化。程序员可只编写一遍应用程序或只
更新一次，然后将它放到服务器上，随后任何人就都可得到最新版本的应用程序。对于商务上
的销售信息服务， Java 和JDBC 可为外部客户提供获取信息的更新更好方法。
1. JDBC 的用途
简单地说，JDBC 可做三件事：
• 与数据库建立连接。
• 发送SQL 语句。
• 处理结果。
下列代码段给出了以上三步的基本示例：
Connection con = DriverManager.getConnection ("jdbc:odbc:wombat", "login",
62第一部分JSP 入门
"password");
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table1");
while (rs.next()) {
int x = rs.getInt("a");
String s = rs.getString("b");
float f = rs.getFloat("c");
}
2. JDBC 是一种低级API ，是高级API 的基础
JDBC 是个”低级”接口，就是说，它用于直接调用SQL 命令。在这方面它的功能极佳，
并比其他的数据库连接A P I更易于使用，但它同时也被设计为一种基础接口，在它之上可以建
立高级接口和工具。高级接口是”对用户友好的”接口，它使用的是一种更易理解和更为方便
的A P I，这种API 在幕后被转换为诸如JDBC 这样的低级接口。在编写本文时，正在开发两种
基于JDBC 的高级A P I：
一种是用于Java 的嵌入式S Q L。至少已经有一个提供者计划编写它。DBMS 实现S Q L：一
种专门设计来与数据库联合使用的语言。JDBC 要求SQL 语句必须作为String 传给Java 方法。
相反，嵌入式SQL 预处理器允许程序员将SQL 语句直接与Java 混在一起使用。例如，可在
SQL 语句中使用Java 变量，用以接受或提供SQL 值。然后，嵌入式SQL 预处理器将通过
JDBC 调用把这种Java/SQL 的混合物转换为J a v a。
另一种关系数据库表到Java 类的直接映射。JavaSoft 和其他提供者都声称要实现该A P I。
在这种”对象/关系”映射中，表中的每行对应于类的一个实例，而每列的值对应于该实例的一
个属性。于是，程序员可直接对Java 对象进行操作；存取数据所需的SQL 调用将在”掩盖下”
自动生成。此外还可提供更复杂的映射，例如将多个表中的行结合进一个Java 类中。
随着人们对JDBC 的兴趣日益浓厚，越来越多的开发人员一直在使用基于JDBC 的工具，
以使程序的编写更加容易。程序员也一直在编写力图使最终用户对数据库的访问变得更为简单
的应用程序。例如，应用程序可提供一个选择数据库任务的菜单。任务被选定后，应用程序将
给出提示及空白供填写执行选定任务所需的信息。所需信息输入后，应用程序将自动调用所需
的SQL 命令。在这样一种程序的协助下，即使用户根本不懂SQL 的语法，也可以执行数据库
任务。
3. JDBC 与ODBC 和其他API 的比较
目前，O D B C（开放式数据库连接） API 可能是使用最广的、用于访问关系数
据库的编程接口。它能在几乎所有平台上连接几乎所有的数据库。为什么Java 不使用
O D B C？
对这个问题的回答是： Java 可以使用O D B C，但最好是在JDBC 的帮助下以J D B C - O D B C
桥的形式使用，这一点稍后再讲解。现在的问题已变成：”为什么需要J D B C”？ 回答如下：
ODBC 不适合直接在Java 中使用，因为它使用C 语言接口。从Java 调用本地C 代码在安
全性、实现性、坚固性和程序的自动移植性方面都有许多缺点。
从ODBC C API 到Java API 的字面翻译是不可取的。例如， Java 没有指针，而ODBC 却对
指针用得很广泛（包括很容易出错的指针“void *”）。你可以将JDBC 想像成被转换为面向对
第二章预备知识63
象接口的O D B C，而面向对象的接口对Java 程序员来说较易于接收。
ODBC 很难学。它把简单和高级功能混在一起，而且即使对于简单的查询，其选项也极为
复杂。相反， JDBC 尽量保证简单功能的简便性，而同时在必要时允许使用高级功能。启用”
纯Java “机制需要像JDBC 这样的Java API。如果使用O D B C，就必须手工地将ODBC 驱动程
序管理器和驱动程序安装在每台客户机上。如果完全用Java 编写JDBC 驱动程序，则JDBC 代
码在所有Java 平台上（从网络计算机到大型机）都可以自动安装、移植并保证安全性。
总之，JDBC API 对于基本的SQL 抽象和概念是一种自然的Java 接口。它建立在ODBC 上，
而不是从零开始。因此，熟悉ODBC 的程序员将发现JDBC 很容易使用。JDBC 保留了O D B C
的基本设计特征；事实上，两种接口都基于X/Open SQL CLI（调用级接口）。它们之间最大的
区别在于：JDBC 以Java 风格与优点为基础并进行优化，因此更加易于使用。
最近，Microsoft 又引进了ODBC 之外的新A P I： R D O、ADO 和OLE DB。这些设计在许
多方面与JDBC 是相同的，即它们都是面向对象的数据库接口且基于可在ODBC 上实现的类。
但在这些接口中，未看见有特别的功能使我们要转而选择它们来替代O D B C，尤其是在O D B C
驱动程序已建立起较为完善的市场的情况下。它们最多也就是在ODBC 上加了一种装饰而已。
这并不是说JDBC 不需要从其最初的版本再发展了；然而，我们觉得大部份的新功能应归入诸
如前一节中所述的对象/关系映射和嵌入式SQL 这样的高级A P I。
4. 两层模型和三层模型
JDBC API 既支持数据库访问的两层模型，同时也支持三层模型。
在两层模型中，Java applet 或应用程序将直接与数据库进行对话。这将需要一个JDBC 驱动
程序来与所访问的特定数据库管理系统进行通信。用户的SQL 语句被送往数据库中，而其结果
将被送回给用户。数据库可以位于另一台计算机上，用户通过网络连接到上面。这就叫做客户
机/服务器配置，其中用户的计算机为客户机，提供数据库的计算机为服务器。网络可以是
I n t r a n e t（它可将公司职员连接起来），也可以是I n t e r n e t。
在三层模型中，命令先是被发送到服务的”中间层“，然后由它将SQL 语句发送给数据库。
数据库对SQL 语句进行处理并将结果送回到中间层，中间层再将结果送回给用户。MIS 管理员
们都发现三层模型很吸引人，因为可用中间层来控制对公司数据的访问和可作的更新的种类。
中间层的另一个好处是，用户可以利用易于使用的高级A P I，而中间层将把它转换为相应的低
级调用。而且，许多情况下三层结构可提供一些性能上的好处。
到目前为止，中间层通常都用C 或C++ 这类语言来编写，这些语言执行速度较快。然而，
随着最优化编译器（它把Java 字节代码转换为高效的特定于机器的代码）的引入，用Java 来实
现中间层将变得越来越实际。这将是一个很大的进步，它使人们可以充分利用Java 的诸多优点
（如坚固、多线程和安全等特征）。JDBC 对于从Java 的中间层来访问数据库非常重要。
5. SQL 的一致性
结构化查询语言(SQL) 是访问关系数据库的标准语言。其困难之处在于：虽然大多数的
D B M S（数据库管理系统）对其基本功能都使用了标准形式的S Q L，但它们却不符合最近为更
高级的功能定义的标准SQL 语法或语义。例如，并非所有的数据库都支持存储程序或外部连接，
那些支持这一功能的数据库又相互不一致。人们希望SQL 中真正标准的那部份能够进行扩展以
包括越来越多的功能。但同时JDBC API 又必须支持现有的S Q L。
JDBC API 解决这个问题的一种方法是允许将任何查询字符串一直传到所涉及的DBMS 驱
动程序上。这意味着应用程序可以使用任意多的SQL 功能，但它必须冒这样的风险：有可能在
某些DBMS 上出错。事实上，应用程序查询甚至不一定是S Q L，或者说它可以是为特定的
DBMS 设计的SQL 的专用派生物（例如，文档或图像查询）。
JDBC 处理SQL 一致性问题的第二种方法是提供ODBC 风格的转义子句。
转义语法为几个常见的SQL 分歧提供了一种标准的JDBC 语法。例如，对日期文字和已存
储过程的调用都有转义语法。
对于复杂的应用程序， JDBC 用第三种方法来处理SQL 的一致性问题。它利用D a t a b a s e
MetaData 接口来提供关于DBMS 的描述性信息，从而使应用程序能适应每个DBMS 的要求和
功能。
由于JDBC API 将用做开发高级数据库访问工具和API 的基础，因此它还必须注意其所有
上层建筑的一致性。“符合JDBC 标准” 代表用户可依赖的JDBC 功能的标准级别。要使用这一
说明，驱动程序至少必须支持ANSI SQL-2 Entry Level（ANSI SQL-2 代表美国国家标准局1 9 9 2
年所采用的标准。Entry Level 代表SQL 功能的特定清单）。驱动程序开发人员可用JDBC API
所带的测试工具包来确定他们的驱动程序是否符合这些标准。
“符合JDBC 标准” 表示提供者的JDBC 实现已经通过了JavaSoft 提供的一致性测试。这些
一致性测试将检查JDBC API 中定义的所有类和方法是否都存在，并尽可能地检查程序是否具
有SQL Entry Level 功能。当然，这些测试并不完全，而且JavaSoft 目前也无意对各提供者的实
现进行标级。但这种一致性定义的确可对JDBC 实现提供一定的可信度。随着越来越多的数据
库提供者、连接提供者、Internet 提供者和应用程序编程员对JDBC API 的接受，JDBC 也正迅
速成为Java 数据库访问的标准。
2.5.2 JDBC 产品
在编写本文时，已经有许多可用的J D B C产品问世。当然，本节中的信息将很快成为过时信
息。因此，有关最新的信息，请查阅JDBC 的网站，可通过从以下URL 开始浏览找到：
h t t p : / / j a v a . s u n . c o m / p r o d u c t s / j d b c
1. JavaSoft 框架
JavaSoft 提供三种JDBC 产品组件，它们是Java 开发工具包(JDK) 的组成部分：
JDBC 驱动程序管理器、JDBC 驱动程序测试工具包和JDBC-ODBC 桥。
JDBC 驱动程序管理器是JDBC 体系结构的支柱。它实际上很小，也很简单；其主要作用是
把Java 应用程序连接到正确的JDBC 驱动程序上，然后退出。
JDBC 驱动程序测试工具包为使JDBC 驱动程序运行你的程序提供一定的可信度。只有通过
JDBC 驱动程序测试包的驱动程序才被认为是符合JDBC 标准TM 的。
JDBC-ODBC 桥使ODBC 驱动程序可被用作JDBC 驱动程序。它的实现为JDBC 的快速发
展提供了一条途径，其长远目标是提供一种访问某些不常见的D B M S（如果对这些不常见的
DBMS 未实现J D B C）的方法。
2. JDBC 驱动程序的类型
目前所知的JDBC 驱动程序可分为以下四个种类：
1) JDBC-ODBC 桥加ODBC 驱动程序： JavaSoft 桥产品利用ODBC 驱动程序提供JDBC 访
问。注意，必须将ODBC 二进制代码（许多情况下还包括数据库客户机代码）加载到使用该驱
动程序的每个客户机上。因此，这种类型的驱动程序最适合于企业网（这种网络上客户机的安
装不是主要问题），或者是用Java 编写的三层结构的应用程序服务器代码。
2) 本地API - 部分用Java 来编写的驱动程序： 这种类型的驱动程序把客户机API 上的
JDBC 调用转换为O r a c l e、S y b a s e、I n f o r m i x、DB2 或其他DBMS 的调用。注意，像桥驱动程
序一样，这种类型的驱动程序要求将某些二进制代码加载到每台客户机上。
3) JDBC 网络纯Java 驱动程序：这种驱动程序将JDBC 转换为与DBMS 无关的网络协议，
之后这种协议又被某个服务器转换为一种DBMS 协议。这种网络服务器中间件能够将它的纯
Java 客户机连接到多种不同的数据库上。所用的具体协议取决于提供者。通常，这是最为灵活
的JDBC 驱动程序。有可能所有这种解决方案的提供者都提供适合于Intranet 用的产品。为了使
这些产品也支持Internet 访问，它们必须处理Web 所提出的安全性、通过防火墙的访问等方面
的额外要求。几家提供者正将JDBC 驱动程序加到他们现有的数据库中间件产品中。
4) 本地协议纯Java 驱动程序：这种类型的驱动程序将JDBC 调用直接转换为DBMS 所使用
的网络协议。这将允许从客户机机器上直接调用DBMS 服务器，是Intranet 访问的一个很实用
的解决方法。由于许多这样的协议都是专用的，因此数据库提供者自己将是主要来源，有几家
提供者已经开发出了这样的驱动程序。
最后，我们预计第3、4 类驱动程序将成为从JDBC 访问数据库的首选方法。第1、2 类驱
动程序在直接的纯Java 驱动程序还没有上市前将会作为过渡方案来使用。对第1、2 类驱动程
序可能会有一些变种（下表中未列出），这些变种要求有连接器，但通常这些是更加不可取的解
决方案。第3、4 类驱动程序提供了Java 的所有优点，包括自动安装（例如，通过使用J D B C
驱动程序的applet applet来该驱动程序）。
表2 - 3显示了这4 种类型的驱动程序及其属性：
表2 - 3
驱动程序种类纯J a v a 网络协议
JDBC-OCBC 桥非直接
基于本地API 的非直接
JDBC 网络的是要求连接器
基于本地协议的是直接
3. JDBC 驱动程序的获取
在编写本文时，已经有许多J D B C驱动程序存在，如果使用的是We b l o g i c或是We b s p h e r e，产
品本身就带有不少数据库系统的驱动程序。许多重要的商业数据库系统也自带了适合自己的
J D B C驱动程序，如： O r a c l e、S y b a s e、IBM DB2。要获取关于驱动程序的最新信息，请查阅
JDBC 的网站，其网址为： http:// java.sun.com/products/jdbc。
2.5.3 连接概述
Connection 对象代表与数据库的连接。连接过程包括所执行的SQL 语句和在该连接上所返
回的结果。一个应用程序可与单个数据库有一个或多个连接，或者可与许多数据库有连接。
1. 打开连接
与数据库建立连接的标准方法是调用D r i v e r M a n a g e r.getConnection ()方法。该方法接受含有
某个URL 的字符串。DriverManager 类（即所谓的JDBC 管理层）将尝试找到可与那个URL 所
代表的数据库进行连接的驱动程序。DriverManager 类存有已注册的Driver 类的清单。当调用方
法getConnection ()时，它将检查清单中的每个驱动程序，直到找到可与URL 中指定的数据库进
行连接的驱动程序为止。Driver 的方法connect 使用这个URL 来建立实际的连接。
用户可绕过JDBC 管理层直接调用Driver 方法。这在以下的特殊情况下将很有用：当两个
驱动器可同时连接到数据库中，而用户需要明确地选用其中特定的驱动器时。但一般情况下，
让DriverManager 类处理打开连接将更为简单。
下述代码显示如何打开一个与位于URL “j d b c : o d b c : w o m b a t” 的数据库的连接。所用的用
户标识符为“o b o y” ，口令为“1 2 J a v a”：
String url = "jdbc:odbc:wombat";
Connection con = DriverManager.getConnection(url, "oboy", "12Java");
2. 一般用法的U R L
由于URL 常引起混淆，所以先对一般URL 作简单说明，然后再讨论JDBC URL。
U R L（统一资源定位符）提供在Internet 上定位资源所需的信息。可将它想像为一个地址。
URL 的第一部份指定了访问信息所用的协议，后面总是跟着冒号。常用的协议有“f t p”
（代表”文件传输协议”）和“h t t p” （代表”超文本传输协议”）。如果协议是“f i l e”，表示资
源是在某个本地文件系统上而非在Internet 上（下例用于表示我们所描述的部分；它并非U R L
的组成部分）。
f t p : / / j a v a s o f t . c o m / d o c s / J D K - 1 _ a p i d o c s . z i p
h t t p : / / j a v a . s u n . c o m / p r o d u c t s / j d k / C u r r e n t R e l e a s e
f i l e : / h o m e / h a r o l d w / d o c s / b o o k s / t u t o r i a l / s u m m a r y. h t m l
URL 的其余部份（冒号后面的）给出了数据资源所处位置的有关信息。如果协议是f i l e，
则URL 的其余部份是文件的路径。对于ftp 和http 协议，URL 的其余部份标识了主机并可选地
给出某个更详尽的地址路径。例如，以下是JavaSoft 主页的U R L。该URL 只标识了主机：
h t t p : / / j a v a . s u n . c o m
从该主页开始浏览，就可以进到许多其他的网页中，其中之一就是JDBC 主页。JDBC 主页
的URL 更为具体，它看起来类似：
h t t p : / / j a v a . s u n . c o m / p r o d u c t s / j d b c
3. JDBC URL
JDBC URL 提供了一种标识数据库的方法，可以使相应的驱动程序能识别该数据库并与之
建立连接。实际上，驱动程序编程员将决定用什么JDBC URL 来标识特定的驱动程序。用户不
必关心如何来形成JDBC URL；他们只需使用与所用的驱动程序一起提供的URL 即可。J D B C
的作用是提供某些约定，驱动程序编程员在构造他们的JDBC URL 时应该遵循这些约定。
由于JDBC URL 要与各种不同的驱动程序一起使用，因此这些约定应非常灵活。
首先，它们应允许不同的驱动程序使用不同的方案来命名数据库。例如， odbc 子协议允许
（但并不是要求）URL 含有属性值。
第二，JDBC URL 应允许驱动程序编程员将一切所需的信息编入其中。这样就可以让要与
给定数据库对话的applet 打开数据库连接，而无需要求用户去做任何系统管理工作。
第三， JDBC URL 应允许某种程度的间接性。也就是说， JDBC URL 可指向逻辑主机或数
据库名，而这种逻辑主机或数据库名将由网络命名系统动态地转换为实际的名称。这可以使系
统管理员不必将特定主机声明为JDBC 名称的一部分。网络命名服务（例如D N S、NIS 和DCE ）
有多种,而对于使用哪种命名服务并无限制。
JDBC URL 的标准语法如下所示。它由三部分组成，各部分间用冒号分隔：
jdbc:< 子协议>:< 子名称>
JDBC URL 的三个部分可分解如下：
jdbc ─ 协议。JDBC URL 中的协议总是j d b c。
〈子协议〉─ 驱动程序名或数据库连接机制（这种机制可由一个或多个驱动程序支持）的
名称。子协议名的典型示例是“o d b c”，该名称是为用于指定ODBC 风格的数据资源名称的
URL 专门保留的。例如，为了通过JDBC-ODBC 桥来访问某个数据库，可以如下所示U R L：
URL： jdbc:odbc:fred
本例中，子协议为“o d b c”，子名称“f r e d” 是本地ODBC 数据资源。
如果要用网络命名服务（这样JDBC URL 中的数据库名称不必是实际名称），则命名服务可
以作为子协议。例如，可用如下所示的URL ：
jdbc:dcenaming:accounts-payable
本例中，该URL 指定了本地DCE 命名服务应该将数据库名称“a c c o u n t s - p a y a b l e” 解析为
更为具体的可用于连接真实数据库的名称。
〈子名称〉─ 一种标识数据库的方法。子名称可以依不同的子协议而变化。它还可以有子
名称的子名称（含有驱动程序编程员所选的任何内部语法）。使用子名称的目的是为定位数据库
提供足够的信息。前例中，因为ODBC 将提供其余部份的信息，因此用"fred" 就已足够。然而，
位于远程服务器上的数据库需要更多的信息。例如，如果数据库是通过Internet 来访问的，则在
JDBC URL 中应将网络地址作为子名称的一部份包括进去，且必须遵循如下所示的标准URL 命
名约定：
file://主机名:端口/子协议
假设dbnet 是个用于将某个主机连接到Internet 上的协议，则JDBC URL 类似：
jdbc:dbnet://"wombat:356/fred"
4. odbc 子协议
子协议odbc 是一种特殊情况。它是为用于指定ODBC 风格的数据资源名称的URL 而保留
的，并具有下列特性：允许在子名称（数据资源名称）后面指定任意多个属性值。odbc 子协议
的完整语法为：
jdbc:odbc:< 数据资源名称>[;< 属性名>=< 属性值>]*
因此，以下都是合法的jdbc:odbc 名称：
jdbc:odbc:qeor7
jdbc:odbc:wombat
jdbc:odbc:wombat;CacheSize=20;ExtensionCase=LOWER
jdbc:odbc:qeora;UID=kgh;PWD=fooey
5. 注册子协议
驱动程序编程员可保留某个名称以将之用作JDBC URL 的子协议名。当DriverManager 类
将此名称加到已注册的驱动程序清单中时，为之保留该名称的驱动程序应能识别该名称并与它
所标识的数据库建立连接。例如， odbc 是为JDBC- ODBC 桥而保留的。假设有个Miracle 公司，
它可能会将“m i r a c l e” 注册为连接到其Miracle DBMS 上的J D B C驱动程序的子协议，从而使
其他人都无法使用这个名称。
JavaSoft 目前作为非正式代理负责注册JDBC 子协议名称。要注册某个子协议名称，请发送
电子邮件到下述地址：
6. 发送SQL 语句
连接一旦建立，就可用来向它所涉及的数据库传送SQL 语句。JDBC 对可被发送的SQL 语
句类型不加任何限制。这就提供了很大的灵活性，即允许使用特定的数据库语句甚至于非S Q L
语句。然而，它要求用户自己负责确保所涉及的数据库可以处理所发送的SQL 语句，否则将自
食其果。例如，如果某个应用程序试图向不支持存储程序的DBMS 发送存储程序调用，就会失
败并将抛出异常。JDBC 要求驱动程序应至少能提供ANSI SQL-2 Entry Level 功能才可算是
“符合JDBC 标准”的。这意味着用户至少可信赖这一标准级别的功能。
JDBC 提供了三个类，用于向数据库发送SQL 语句。Connection 接口中的三个方法可用于
创建这些类的实例。下面列出这些类及其创建方法：
Statement 由方法createStatement 所创建。Statement 对象用于发送简单的SQL 语句。
PreparedStatement 由方法prepareStatement 所创建。PreparedStatement 对象用于发送带有
一个或多个输入参数（ IN 参数）的SQL 语句。PreparedStatement 拥有一组方法，用于设置I N
参数的值。执行语句时，这些IN 参数将被送到数据库中。PreparedStatement 的实例扩展了
Statement ，因此它们都包括了Statement 的方法。PreparedStatement 对象有可能比Statement 对
象的效率更高，因为它已被预编译过并存放在那里以供将来使用。
CallableStatement 由方法prepareCall 所创建。CallableStatement 对象用于执行SQL 存储
程序─ 一组可通过名称来调用（就像函数的调用那样）的SQL 语句。CallableStatement 对象从
PreparedStatement 中继承了用于处理IN 参数的方法，而且还增加了用于处理OUT 参数和
INOUT 参数的方法。
以下所提供的方法可以快速决定应用哪个Connection 方法来创建不同类型的SQL 语句。
createStatement 方法用于。
简单的SQL 语句（不带参数）。
prepareStatement 方法用于：
带一个或多个IN 参数的SQL 语句。
经常被执行的简单SQL 语句。
prepareCall 方法用于：
调用已存储过程。
7. 事务
事务由一个或多个这样的语句组成：这些语句已被执行、完成并被提交或还原。当调用方
法commit 或rollback 时，当前事务即告结束，另一个事务随即开始。
缺省情况下，新连接将处于自动提交模式。也就是说，当执行完语句后，将自动对那个语
句调用commit 方法。这种情况下，由于每个语句都是被单独提交的，因此一个事务只由一个语
句组成。如果禁用自动提交模式，事务将要等到commit 或rollback 方法被显式调用时才结束，
因此它将包括上一次调用commit 或rollback 方法以来所有执行过的语句。对于第二种情况，事
务中的所有语句将作为组来提交或还原。
方法commit 使SQL 语句对数据库所做的任何更改成为永久性的，它还将释放事务持有的
全部锁。而方法rollback 将丢弃那些更改。
有时用户在另一个更改生效前不想让此更改生效。这可通过禁用自动提交并将两个更新组
合在一个事务中来达到。如果两个更新都是成功的，则调用commit 方法，从而使两个更新结果
成为永久性的；如果其中之一或两个更新都失败了，则调用rollback 方法，以将值恢复为进行
更新之前的值。
大多数JDBC 驱动程序都支持事务。事实上，符合JDBC 的驱动程序必须支持事务。
DatabaseMetaData 给出的信息描述DBMS 所提供的事务支持水平。
8. 事务隔离级别
如果DBMS 支持事务处理，它必须有某种途径来管理两个事务同时对一个数据库进行操作
时可能发生的冲突。用户可指定事务隔离级别，以指明DBMS 应该花多大精力来解决潜在冲突。
例如，当事务更改了某个值而第二个事务却在该更改被提交或还原前读取该值时怎么办？ 假设
第一个事务被还原后，第二个事务所读取的更改值将是无效的，那么是否可允许这种冲突？
JDBC 用户可用以下代码来指示DBMS 允许在值被提交前读取该值（” dirty 读取”），其中c o n
是当前连接：
con.setTransactionIsolation(TRANSACTION_READ_UNCOMMITTED);
事务隔离级别越高，为避免冲突所花的精力也就越多。Connection 接口定义了五级，其中
最低级别指定了根本就不支持事务，而最高级别则指定当事务在对某个数据库进行操作时，任
何其他事务不得对那个事务正在读取的数据进行任何更改。通常，隔离级别越高，应用程序执
行的速度也就越慢（用于锁定的资源耗费增加了，而用户间的并发操作减少了）。在决定采用什
么隔离级别时，开发人员必须在性能需求和数据一致性需求之间进行权衡。当然，实际所能支
持的级别取决于所涉及的DBMS 的功能。
当创建Connection 对象时，其事务隔离级别取决于驱动程序，但通常是所涉及的数据库的
缺省值。用户可通过调用setIsolationLevel 方法来更改事务隔离级别。新的级别将在该连接过程
的剩余时间内生效。要想只改变一个事务的事务隔离级别，必须在该事务开始之前进行设置，
并在该事务结束后进行复位。不提倡在事务的中途对事务隔离级别进行更改，因为这将立即触
发commit 方法的调用，使在此之前所作的任何更改成为永久性的。
2.5.4 DriverManager概述
DriverManager 类是JDBC 的管理层，作用于用户和驱动程序之间。它跟踪可用的驱动程序，
并在数据库和相应驱动程序之间建立连接。另外， DriverManager 类也处理诸如驱动程序登录时
间限制及登录和跟踪消息的显示等事务。
对于简单的应用程序，一般程序员需要在此类中直接使用的唯一方法是D r i v e r M a n a g e r. g e t
C o n n e c t i o n。正如名称所示，该方法将建立与数据库的连接。JDBC 允许用户调用DriverManager 的
方法g e t D r i v e r、getDrivers 和registerDriver 及Driver 的方法c o n n e c t。但多数情况下，让
DriverManager 类管理建立连接的细节为上策。
1. 跟踪可用驱动程序
DriverManager 类包含一列Driver 类，它们已通过调用方法D r i v e r M a n a g e r.registerDriver 对
自己进行了注册。所有Driver 类都必须包含有一个静态部分。它创建该类的实例，然后在加载
该实例时对DriverManager 类进行注册。这样， 用户正常情况下将不会直接调用
D r i v e r M a n a g e r. r e g i s t e r D r i v e r；而是在加载驱动程序时由驱动程序自动调用。加载Driver 类，然
后自动在DriverManager 中注册的方式有两种：
1) 通过调用方法C l a s s . f o r N a m e。这将显式地加载驱动程序类。由于这与外部设置无关，因
此推荐使用这种加载驱动程序的方法。以下代码加载类a c m e . d b . D r i v e r：
Class.forName("acme.db.Driver");
如果将acme.db.Driver 编写为加载时创建实例，并调用以该实例为参数的D r i v e r M a n a g e r.
r e g i s t e r D r i v e r（本该如此），则它在DriverManager 的驱动程序列表中，并可用于创建连接。
2) 通过将驱动程序添加到java.lang.System 的属性jdbc.drivers 中。这是一个由
DriverManager 类加载的驱动程序类名的列表，由冒号分隔。初始化DriverManager 类时，它搜
索系统属性j d b c . d r i v e r s，如果用户已输入了一个或多个驱动程序，则DriverManager 类将试图
加载它们。以下代码说明程序员如何在~/.hotjava/properties 中输入三个驱动程序类（启动时，
HotJava 将把它加载到系统属性列表中）：
jdbc.drivers=foo.bah.Driver:wombat.sql.Driver:bad.test.ourDriver;
对DriverManager 方法的第一次调用将自动加载这些驱动程序类。
注意：加载驱动程序的第二种方法需要持久的预设环境。如果对这一点不能保证，则调用
方法Class.forName 显式地加载每个驱动程序就显得更为安全。这也是引入特定驱动程序的方法，
因为一旦DriverManager 类被初始化，它将不再检查jdbc.drivers 属性列表。
在以上两种情况中，新加载的Driver 类都要通过调用D r i v e r M a n a g e r.registerDriver 类进行
自我注册。如上所述，加载类时将自动执行这一过程。
由于安全方面的原因， JDBC 管理层将跟踪哪个类加载器提供哪个驱动程序。这样，当
DriverManager 类打开连接时，它仅使用本地文件系统或与发出连接请求的代码相同的类加载器
提供的驱动程序。
2. 建立连接
加载Driver 类并在DriverManager 类中注册后，它们即可用来与数据库建立连接。当调用
D r i v e r M a n a g e r.getConnection 方法发出连接请求时， DriverManager 将检查每个驱动程序，查看
它是否可以建立连接。
有时可能有多个JDBC 驱动程序可以与给定的URL 连接。例如，与给定远程数据库连接时，
可以使用JDBC-ODBC 桥驱动程序、JDBC 到通用网络协议驱动程序或数据库厂商提供的驱动
程序。在这种情况下，测试驱动程序的顺序至关重要，因为DriverManager 将使用它所找到的第
一个可以成功连接到给定URL 的驱动程序。
首先DriverManager 试图按注册的顺序使用每个驱动程序（ jdbc.drivers 中列出的驱动程序
总是先注册）。它将跳过代码不可信任的驱动程序，除非加载它们的源与试图打开连接的代码的
源相同。
它通过轮流在每个驱动程序上调用方法D r i v e r. c o n n e c t，并向它们传递用户开始传递给方法
D r i v e r M a n a g e r.getConnection 的URL 来对驱动程序进行测试，然后连接第一个认出该URL 的
驱动程序。
这种方法初看起来效率不高，但由于不可能同时加载数十个驱动程序，因此每次连接实际
只需几个过程调用和字符串比较。
以下代码是通常情况下用驱动程序（例如JDBC-ODBC 桥驱动程序）建立连接所需所有步
骤的示例：
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); file://加载驱动程序
String url = "jdbc:odbc:fred";
DriverManager.getConnection(url, "userID", "passwd");
2.5.5 一个简单的例子
下面是一个简单的例子，在这个例子中，将利用J D K自带的J D B C - O D B C桥驱动程序查询一
个Microsoft SQL Server 7.0 自带的例子数据库，并将得到的结果在屏幕上显示出来。
1. 建立O D B C数据源
在Wi n d o w s系统的控制面版中，选择“数据源（ O D B C）”，如果使用Windows 2000，那么将
在“管理工具”中选择。在系统D S N中，选择“添加”，如图2 - 2所示。
然后，建立一个名为N o r t h w i n d的数据源，并且设定数据源为需要使用的SQL Server，这里
假设为本地SQL Server数据源，如果读者的数据源不在本地，请自行修改，如图2 - 3所示。
然后，在接下来几步中设定缺省数据库为N o r t h w i n d，然后点击“完成”，建立O D B C数据源，
如图2 - 4所示。
2. 程序代码
在建立数据源以后，就可以开始程序设计工作了，下面的程序建立在一个Java Application
基础上，使用AW T组件来显示数据库查询的结果，具体的程序代码比较简单，读者应该能看懂。
import java.awt.*;
file://在使用JDBC之前，必须引入JAVA的SQL包
import java.sql.*;
class JDBCTest extends Frame {
TextArea myTextArea;
public JDBCTest () {
file://设定程序的显示界面
super("一个简单的JDBC范例");
setLayout(new FlowLayout());
myTextArea = new TextArea(30,80);
add(myTextArea);
resize(500,500);
show();
myTextArea.appendText("数据库查询中，请等待......\n");
}
void displayResults(ResultSet results) throws SQLException {
file://首先得到查询结果的信息
ResultSetMetaData resultsMetaData = results.getMetaData();
int cols = resultsMetaData.getColumnCount();
file://将等待信息清除
myTextArea.setText("");
file://显示结果
while(results.next()) {
for(int i=1;i<=cols;i++) {
if(i>1)
myTextArea.appendText("\t");
try{
myTextArea.appendText(results.getString(i));
}
file://捕获空值时产生的异常
catch(NullPointerException e){
}
}
myTextArea.appendText("\n");
}
}
public boolean handleEvent(Event evt) {
if (evt.id == Event.WINDOW_DESTROY) {
System.exit(0);
return true;
}
return super.handleEvent(evt);
}
public static void main(String argv[]) throws SQLException,Exception {
file://设定查询字串
String queryString = "select * from Customers";
JDBCTest myJDBCTest = new JDBCTest();
file://加载驱动程序
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
file://建立连接
Connection myConn =
DriverManager.getConnection("jdbc:odbc:Northwind","riso","riso");
Statement myStmt = myonn.createStatement();
file://执行查询
ResultSet myResults = myStmt.executeQuery(queryString);
myJDBCTest.displayResults(myResults);
file://关闭所有打开的资源
myResults.close();
myStmt.close();
myConn.close();
}
}
上面的程序对于了解J a v a语言的读者应该是不难理解的，程序的作用就是：首先建立一个数
据库连接，然后执行一个查询，最后将所得的结果显示在屏幕上。程序的执行结果如图2 - 5所
示。
注意：
1) Class.forName()函数指定了加载的驱动程序。
2) getConnection()函数的三个参数中，第二个参数和第三个参数分别表明登录用的用户名和
密码。
