JSP高级编程内容

JSP高级编程内容

第2章预备知识
2.1 Java程序设计基础
J a v a是J S P的基础，要学习J S P技术，J a v a基础是必不可少的。本节将简要介绍J a v a的基本语
法和概念。已经是J a v a编程人员的读者就不用阅读了，这里是为没有多少J a v a经验的读者提供一
个快速入门的方法。这里对J a v a语言的介绍仅仅是一个基本的概况，要想深入学习J S P，必须对
J a v a语言有深刻的理解，笔者推荐机械工业出版社翻译出版的《J a v a编程思想》一书，本书限于
篇幅，就不多讲了。
2.1.1 Java语言规则
J a v a语言的基本结构像C / C + +， 任何用面向过程语言编写过程序的人都可以了解J a v a语言的
大部分结构。
1. 程序结构
J a v a语言的源程序代码由一个或多个编译单元( c o m p i l a t i o n u n i t )组成，每个编译单元只能包
含下列内容(空格和注释除外)：
• 程序包语句(package statement )。
• 入口语句(import statements) 。
• 类的声明(class declarations) 。
• 界面声明(interface declarations)。
每个J a v a的编译单元可包含多个类或界面，但是每个编译单元最多只能有一个类或者界面是
公共的。Java 的源程序代码被编译后，便产生了J a v a字节代码。J a v a的字节代码由一系列不依
赖于机器的指令组成，这些指令能被J a v a的运行系统(runtime system)有效地解释。J a v a的运行系
统工作起来如同一台虚拟机。在当前的J a v a实现中，每个编译单元就是一个以. j a v a为后缀的文件。
每个编译单元有若干个类，编译后，每个类生成一个. c l a s s文件。. c l a s s文件是J a v a虚拟机能够识
别的代码。在引入了J A R这个概念以后，现在可以把许多J a v a的c l a s s文件压缩进入一个J A R文件
中。新版本的J a v a已经可以直接读取J A R文件加以执行。
2. 注释
注释有三种类型:
/ / 注释一行
/ * 一行或多行注释*/
/ * * 文档注释**/
文档注释一般放在一个变量或函数定义之前，表示在任何自动生成文档系统中调入，提取
注释生成文档的工具叫做j a v a d o c，其中还包括一些以@开头的变量，如： @ s e e、@ v e r s i o n、
@ p a r a m等等，具体用法参见J D K自带的工具文档。
3. 标识符
变量、函数、类和对象的名称都是标识符，程序员需要标识和使用的东西都需要标识符。
在J a v a语言里，标识符以字符_或$开头，后面可以包含数字，标识符是大小写有区别的，没有长
度限制。
有效的标识符如： gogogo brood_war Hello _and_you $bill。
声明如：
int a_number;
char _onechar;
float $bill。
以下为J a v a的关键字：
a b s t r a c t c o n t i n u e f o r new switch
b o o l e a n d e f a u l t g o t o n u l l synchronized
b r e a k d o i f p a c k a g e this
b y t e d o u b l e i m p l e m e n t s p r i v a t e threadsafe
b y v a l u e e l s e i m p o r t p r o t e c t e d throw
c a s e e x t e n d s i n s t a n c e o f p u b l i c transient
c a t c h f a l s e i n t r e t u r n true
char f i n a l i n t e r f a c e short try
c l a s s f i n a l l y l o n g s t a t i c void
c o n s t f l o a t n a t i v e s u p e r while
以下单词被保留使用： c a s t、f u t u r e、g e n e r i c、i n n e r、o p e r a t o r、o u t e r、r e s t、v a r。
4. 数据类型
J a v a使用五种基本类型: i n t e g e r (整数)，f l o a t i n g (浮点数)，p o i n t (指针)，B o o l e a n (布尔变量)，
Character or String(字符或字符串)。此外，还有一些复合的数据类型，如数组等。
Integer 包含下面几种类型：
整数长度( B i t s ) 数据类型表示
8 b y t e
1 6 short
3 2 int
6 4 l o n g
floating 下边给出的数据表示都是浮点数的例子：
3 . 1 4 1 5 9，3 . 1 2 3 E 1 5，4 e 5
浮点数长度(Bits) 数据类型表示
3 2 f l o a t
6 4 double
Boolean 下边是布尔变量的两种可能取值：
t r u e false
Character 下边给出的都是字符的例子：
第二章预备知识17

a s d f
String 下边给出的都是字符串的例子：
"gogogo,rock and roll" " J S P高级编程"
数组可以定义任意类型的数组，如char s[]，这是字符型数组； int array []，这是整型数组；
还可以定义数组的数组. intblock[][]=new int [2][3]；数组边界在运行时被检测，以避免堆栈溢出。
在J a v a里，数组实际上是一个对象，数组有一个成员变量： l e n g t h。可以用这个成员函数来
查看任意数组的长度。
在J a v a里创建数组，可使用两种基本方法：
1) 创建一个空数组。
int list[]=new int[50];
2) 用初始数值填充数组.
String names[] = { "Chenji"，"Yuan"，"Chun"，"Yang" };
它相当于下面功能:
String names[];
names = new String[4];
names[0]=new String("Chenji");
names[1]=new String("Yuan");
names[2]=new String("Chun");
names[3]=new String("Yang");
在编译时不能这样创建静态数组：
int name[50]; / /将产生一个编译错误
也不能用n e w操作去填充一个没定义大小的数组。如：
int name[];
for (int i=0;i<9; i++) {
name[i] = i;
}
5. 表达式
J a v a语言的发展中有许多是从C语言借鉴而来的，所以J a v a的表达式和C语言非常类似。
运算符
运算符( o p e r a t o r )优先级从高到低排列如下： .
[ ] () ++ -- ! ～ instanceof * / % + - << >> >>> < > <= >/ == ! = & ^ && || ? : = op = ，
(2) 整数运算符
在整数运算时，如果操作数是l o n g类型，则运算结果是l o n g类型，否则为i n t类型，绝不会是
b y t e，s h o r t或c h a r型。这样，如果变量i被声明为s h o r t或b y t e，i + 1的结果会是i n t。如果结果超过
该类型的取值范围，则按该类型的最大值取模。单目整数运算符是：
运算符操作
- 非
～ 位补码
+ + 加1
- - 减1
18第一部分JSP 入门

+ +运算符用于表示直接加1操作。增量操作也可以用加运算符和赋值操作间接完成。+ +
lvalue （左值表示l v a l u e + = 1， ++lvalue 也表示lvalue =lvalue +1 (只要l v a l u e没有副作用)。- -运
算符用于表示减1操作。+ +和- -运算符既可以作为前缀运算符，也可以作为后缀运算符。双目
整数运算符是：
运算符操作
+ 加
- 减
* 乘
/ 除
% 取模
& 位与
｜ 位或
^ 位异或
< < 左移
> > 右移(带符号)
> > > 添零右移
整数除法按零舍入。除法和取模遵守以下等式： ( a/b ) * b + ( a%b ) == a。整数算术运算的
异常是由于除零或按零取模造成的。它将引发一个算术异常，下溢产生零，上溢导致越界。例
如：加1超过整数最大值，取模后，变成最小值。一个o p =赋值运算符，和上表中的各双目整数
运算符联用，构成一个表达式。整数关系运算符<，>，< =，> =，= =和! =产生b o o l e a n类型的数
据。
( 3 ) 布尔运算符
布尔( b o o l e a n )变量或表达式的组合运算可以产生新的b o o l e a n值。单目运算符!是布尔非。
双目运算符＆、｜和^是逻辑A N D、O R和X O R运算符，它们强制两个操作数求布尔值。为避免
右侧操作数冗余求值，用户可以使用短路求值运算符＆＆ 和｜｜。用户可以使用= =和! =，赋值
运算符也可以用& =、| =、^ =。三元条件操作符? : 和C语言中的一样。
(4) 浮点运算符
浮点运算符可以使用常规运算符的组合，如单目运算符+ +、- -，双目运算符+、-、* 和/，
以及赋值运算符+ =，- =，* =，和/ =。此外，还有取模运算：%和% =也可以用于浮点数，例如：
a % b和a-((int) (a/b)*b)的语义相同。这表示a % b的结果是除完后剩下的浮点数部分。只有单精度
操作数的浮点表达式按照单精度运算求值，产生单精度结果。如果浮点表达式中含有一个或一
个以上的双精度操作数，则按双精度运算，结果是双精度浮点数。
(5) 数组运算符
数组运算符形式如下：
<expression> [ <expression>]
可给出数组中某个元素的值。合法的取值范围是从0到数组的长度减1。取值范围的检查只
在运行时刻实施。
( 6 ) 对象运算符
双目运算符instanceof 测试某个对象是否是指定类或其子类的实例。例如：
if (myObject instanceof MyClass) {
第二章预备知识19

MyClass anothermyObject=( MyClass) myObject;
...
}
是判定m y O b j e c t是否是M y C l a s s的实例或是其子类的实例。
(7) 强制和转换
J a v a语言和解释器限制使用强制和转换，以防止出错导致系统崩溃。整数和浮点数间可以来
回强制转换，但整数不能强制转换成数组或对象。对象不能被强制为基本类型。
6. Java流控制
下面几个控制结构是从C语言借鉴的。
( 1 ) 分支结构
i f / e l s e分支结构：
if (Boolean) {
statemanets;
}
else {
statements;
}
s w i t c h分支结构：
switch(expr1) {
case expr2:
statements;
break;
case expr3:
statements;
break;
default:
statements;
break;
}
(2) 循环结构
f o r循环结构：
for (init expr1;test expr2;increment expr3) {
statements;
}
W h i l e循环结构：
While(Boolean) {
statements;
}
D o循环结构：
do
statements;
} while (Boolean);
20第一部分JSP 入门

2.1.2 Java变量和函数
J a v a的类包含变量和函数。数据变量可以是原始的类型，如i n t、c h a r等。成员函数是可执行
的过程。例如，下面的程序：
public class TestClass
public TestClass () {
i=10;
}
public void addI(int j) {
i=i+j;
}
}
Te s t C l a s s包含一个变量i和两个成员函数，TestClass(int first)和addI(int j)。
成员函数是一个可被其他类或自己类调用的处理子程序。一个特殊的成员函数叫构造函数，
这个函数名称一般与本类名称相同。它没有返回值。
在J a v a里定义一个类时，可定义一个或多个可选的构造函数，当创建本类的一个对象时，用
某一个构造函数来初始化本对象。用前面程序例子来说明，当Te s t C l a s s类创建一个新实例时，
所有成员函数和变量被创建(创建实例)。构造函数被调用。
TestClass testObject;
testObject = new TestClass();
关键词n e w用来创建一个类的实例，一个类用n e w初始化前并不占用内存，它只是一个类型
定义，当t e s t O b j e c t对象初始化后，t e s t O b j e c t对象里的i变量等于1 0。可以通过对象名来引用变量
i。(有时称为实例变量) testObject.i++;// testObject实例变量加1，因为t e s t O b j e c t有Te s t C l a s s类的
所有变量和成员函数，可以使用同样的语法来调用成员函数a d d I：addI(10); 现在t e s t O b j e c t . i变
量等于2 1。
J a v a并不支持析构函数( C + +里的定义)，因为j a v a对象无用时，有自动清除的功能，同时它
也提供了一个自动垃圾箱的成员函数，在清除对象时被调用：
Protected void finalize() { close(); }
2.1.3 子类
子类是利用存在的对象创建一个新对象的机制，比如，如果有一个H o r s e类，你可以创建一
个Z e b r a子类，Z e b r a是H o r s e的一种。
class Zebra extends Horse { int number_OF_stripes: }
关键词e x t e n d s来定义对象有的子类. Z e b r a是H o r s e的子类。H o r s e类里的所有特征都将拷贝到
Z e b r a类里，而Z e b r a类里可以定义自己的成员函数和实例变量。Z e b r a称为H o r s e的派生类或继承。
另外，你也许还想覆盖基类的成员函数，可用Te s t C l a s s说明，下面是一派生类覆盖A d d I功能的
例子。
import TestClass;
public class NewClass extends TestClass {
第二章预备知识21

public void AddI(int j) {
i=i+(j/2);
}
}
当N e w C l a s s类的实例创建时，变量i初始化值为1 0，但调用A d d I产生不同的结果。
NewClass newObject;
newObject=new NewClass();
newObject.AddI(10);
当创建一个新类时，可以标明变量和成员函数的访问层次。
public public void AnyOneCanAccess(){} public实例变量和成员函数可以由任意其他类调
用。
protected protected void OnlySubClasses(){} protected实例变量和成员函数只能被其子类调
用。
private private String CreditCardNumber; private实例变量和成员函数只能在本类里调用。
friendly void MyPackageMethod(){}是缺省的，如果没有定义任何访问控制，实例变量或函
数缺省定义成f r i e n d l y，这意味着可以被本包里的任意对象访问，但其他包里的对象不可访问。
对于静态成员函数和变量，有时候，你创建一个类，希望这个类的所有实例都公用一个变
量。就是说，所有这个类的对象都只有实例变量的同一个拷贝。这种方法的关键词为s t a t i c， 例
如：
class Block {
static int number=50;
}
所有从B l o c k类创建的对象的n u m b e r变量值都是相同的。无任在哪个对象里改变了n u m b e r的
值， 所有对象的n u m b e r都跟着改变。同样，可以定义s t a t i c成员函数，但这个成员函数不能访问
非s t a t i c函数和变量。
class Block {
static int number = 50;
int localvalue;
static void add_local(){
localvalue++; file://没有运行
}
static void add_static() {
number++;//运行
}
}
2.1.4 this和s u p e r
访问一个类的实例变量时， t h i s关键词是指向这个类本身的指针，在前面的Te s t C l a s s例子中，
可以增加构造函数如下：
public class TestClass {
22第一部分JSP 入门

int i;
public TestClass() {
i = 10;
}
public TestClass (int value) {
this.i = value;
}
public void AddI(int j) {
i = i + j;
}
}
这里，t h i s指向Te s t C l a s s类的指针。如果在一个子类里覆盖了父类的某个成员函数，但又想
调用父类的成员函数，可以用super 关键词指向父类的成员函数。
import TestClass;
public class NewClass extends TestClass {
public void addI (int j) {
i = i+(j/2);
super.addI (j);
}
}
下面程序里，i变量被构造函数设为1 0，然后为1 5，最后被父类( Te s t C l a s s )设为2 5。
NewClass newObject;
newObject = new NewClass();
newObject.addI(10);
2.1.5 类的类型
迄今为止，在类前面只用了一个p u b l i c关键词，其实它有下面4种选择：
a b s t r a c t。一个a b s t r a c t类必须至少有一个虚拟函数，一个a b s t r a c t类不能直接创建对象，必须
继承子类后才能创建对象。
f i n a l一个f i n a l类声明了子类链的结尾，用f i n a l声明的类不能再派生子类。
P u b l i c。p u b l i c类能被其他的类访问。在其他包里，如果想使用这个类，必须先i m p o r t，否
则它只能在它定义的p a c k a g e里使用。
s y n c h r o n i c a b l e。这个类标识表示所有类的成员函数都是同步的。
2.1.6 抽象类
面向对象的一个最大优点就是能够定义怎样使用这个类而不必真正定义好成员函数。当程
序由不同的用户实现时，这是很有用的，这不需用户使用相同的成员函数名。
在j a v a里，G r a p h i c s类中一个a b s t r a c t类的例子如下：
public abstract class Graphics {
public abstract void drawLine(int x1，int y1，int x2， int y2);
public abstract void drawOval(int x，int y，int width， int height);
第二章预备知识23

public abstract void drawRect(int x，int y，int width， int height);
}
在G r a p h i c s类里声明了几个成员函数，但成员函数的实际代码是在另外一个地方实现的。
public class MyClass extends Graphics { public void drawLine (int x1，int y1，int x2，
int y2) { <画线程序代码> } }
当一个类包含一个a b s t r a c t成员函数时，这个类必须定义为a b s t r a c t类。然而并不是a b s t r a c t类
的所有成员函数都是a b s t r a c t的。A b s t r a c t类不能有私有成员函数(它们不能被实现)，也不能有静
态成员函数。
2.1.7 接口
当确定多个类的操作方式都很相像时， a b s t r a c t成员函数是很有用的。但如果需要使用这个
a b s t r a c t成员函数，必须创建一个新类，这样有时很繁琐。接口提供了一种抽象成员函数的有利
方法。一个接口包含了在另一个地方实现的成员函数的收集。成员函数在接口里定义为p u b l i c和
a b s t r a c t。接口里的实例变量是p u b l i c、s t a t i c和f i n a l。接口和抽象的主要区别是，一个接口提供
了封装成员函数协议的方法而不必强迫用户继承类。
例如：
public interface AudiClip {
file://Start playing the clip.
void play();
file://Play the clip in a loop.
void loop();
file://Stop playing the clip
void stop();
}
想使用Audio Clip接口的类使用i m p l e n e n t s关键词来提供成员函数的程序代码。
class MyClass implements AudioClip {
void play(){ <实现代码> }
void loop <实现代码> }
void stop <实现代码> }
}
接口的优点是：一个接口类可以被任意多的类实现，每个类可以共享程序接口而不必关心
其他类是怎样实现的。
2.1.8 包
包( P a c k a g e )由一组类( c l a s s )和界面( i n t e r f a c e )组成。它是管理大型名字空间，避免名字冲突
的工具。每一个类和界面的名字都包含在某个包中。按照一般的习惯，它的名字由“ .” 号分隔
的单词构成，第一个单词通常是开发这个包的组织的名称。
定义一个编译单元的包由p a c k a g e语句定义。如果使用p a c k a g e语句，编译单元的第一行必
须无空格，也无注释。其格式如下：
24第一部分JSP 入门

package packageName;
若编译单元无p a c k a g e语句，则该单元被置于一个缺省的无名的包中。
在J a v a语言里，提供了一个包可以使用另一个包中类和界面的定义和实现的机制。用i m p o r t
关键词来标明来自其他包中的类。一个编译单元可以自动把指定的类和界面输入到它自己的包
中。在一个包中的代码可以有两种方式定义自其他包中的类和界面：在每个引用的类和界面前
面给出它们所在的包的名字：
file://前缀包名法acme. project.FooBar
obj=new acme. project. FooBar( );
使用i m p o r t语句引入一个类或一个界面，或包含它们的包。引入的类和界面的名字在当前的
名字空间可用。引入一个包时，则该包所有的公有类和界面均可用。其形式如下：
// 从acme.project 引入所有类
import acme.project.*;
这个语句表示a c m e . p r o j e c t中所有的公有类被引入当前包。以下语句从acme. project包中进
入一个类E m p l o y e c _ L i s t。
file://从acme. project而引入Employee_List
import acme.project.Employee_list;
Employee_List obj = new Employee_List( );
在使用一个外部类或界面时，必须要声明该类或界面所在的包，否则会产生编译错误。
i m p o r t (引入)类包(class package)用i m p o r t关键词调入指定p a c k a g e名字如路径和类名，用*匹
配符可以调入多于一个类名。
import java.Date; import java.awt.*;
如果j a v a源文件不包含p a c k a g e，它放在缺省的无名p a c k a g e。这与源文件同目，类可以这样
引入:
import MyClass;
J a v a系统包： J a v a语言提供了一个包含窗口工具箱、实用程序、一般I / O、工具和网络功能
的包。
各个包的用法和类详解在J D K自带的文档中都有详细的说明，希望读者能够好好的看一看，
对大部分的常用包的类都熟悉了，才能更好地掌握J a v a这门技术。
在了解J a v a语言的概况以后，接下来看一看与J S P技术密切相关的三种J a v a技术：J a v a E e a n s，
J D B C，Java Servlet。
2.2 JavaBeans
J a v a B e a n s是什么？J a v a B e a s n s是一个特殊的类，这个类必须符合J a v a B e a n s规范。J a v a B e a n s
原来是为了能够在一个可视化的集成开发环境中可视化、模块化地利用组件技术开发应用程序
而设计的。不过，在J S P中，不需要使用任何可视化的方面，但仍然需要利用J a v a B e a n s的属性、
事件、持久化和用户化来实现模块化的功能。下面分别介绍J a v a B e a n s的属性、事件、持久化和
用户化。
第二章预备知识25

2.2.1 JavaBeans的属性
J a v a B e a n s的属性与一般J a v a程序中所指的属性，或者说与所有面向对象的程序设计语言中
对象的属性是一个概念，在程序中的具体体现就是类中的变量。在J a v a B e a n s设计中，按照属性
的不同作用又细分为四类： Simple, Index, Bound与C o n s t r a i n e d属性。
1. Simple属性
Simple 属性表示伴随有一对g e t / s e t方法（C语言的过程或函数在J a v a程序中称为”方法”）的
变量。属性名与和该属性相关的g e t / s e t方法名对应。例如：如果有s e t X和g e t X方法，则暗指有一
个名为”X”的属性。如果有一个方法名为i s X，则通常暗指”X”是一个布尔属性（即X的值为
t r u e或f a l s e）。例如，在下面这个程序中：
public class alden1 extends Canvas {
string ourString= "Hello";
file://属性名为ourString，类型为字符串
public alden1(){
file://alden1()是alden1的构造函数，与C++中构造函数的意义相同
setBackground(Color.red);
setForeground(Color.blue);
}
/* "set"属性*/
public void setString(String newString) {
ourString=newString;
}
/* "get"属性*/
public String getString() {
return ourString;
}
}
2. Indexed属性
I n d e x e d属性表示一个数组值。使用与该属性对应的s e t / g e t方法可取得数组中的数值。该属
性也可一次设置或取得整个数组的值。例如：
public class alden2 extends Canvas {
int[] dataSet={1,2,3,4,5,6};
// dataSet是一个indexed属性
public alden2() {
setBackground(Color.red);
setForeground(Color.blue);
}
/* 设置整个数组*/
public void setDataSet(int[] x){
dataSet=x;
}
/* 设置数组中的单个元素值*/
public void setDataSet(int index, int x){
dataSet[index]=x;
26第一部分JSP 入门

}
/* 取得整个数组值*/
public int[] getDataSet(){
return dataSet;
}
/* 取得数组中的指定元素值*/
public int getDataSet(int x){
return dataSet[x];
}
}
3. Bound属性
B o u n d属性是指当该种属性的值发生变化时，要通知其他的对象。每次属性值改变时，这种
属性就触发一个P r o p e r t y C h a n g e事件(在J a v a程序中，事件也是一个对象)。事件中封装了属性名、
属性的原值、属性变化后的新值。这种事件传递到其他的B e a n s，至于接收事件的B e a n s应做什
么动作，由其自己定义。
当P u s h B u t t o n的b a c k g r o u n d属性与D i a l o g的b a c k g r o u n d属性绑定时，若P u s h B u t t o n的
b a c k g r o u n d属性发生变化，D i a l o g的b a c k g r o u n d属性也发生同样的变化。例如：
public class alden3 extends Canvas{
String ourString= "Hello";
file://ourString是一个bound属性
private PropertyChangeSupport changes = new PropertyChangeSupport(this);
/*Java是纯面向对象的语言，如果要使用某种方法则必须指明是要使用哪个对象的方法，在下面的程序中要进行点
火事件的操作，这种操作所使用的方法是在PropertyChangeSupport类中的。所以上面声明并实例化了一个
changes对象，在下面将使用changes的firePropertyChange方法来点火ourString的属性改变事件。*/
public void setString(string newString){
String oldString = ourString;
ourString = newString;
/* ourString的属性值已发生变化，于是接着点火属性改变事件*/
changes.firePropertyChange("ourString",oldString,newString);
}
public String getString(){
return ourString;
}
/** 以下代码是为开发工具所使用的。我们不能预知alden3将与哪些其他的Beans组合成为一个应用，无法预知若
alden3的ourString属性发生变化时有哪些其他的组件与此变化有关，因而alden3这个Beans要预留出一些接口
给开发工具，开发工具使用这些接口，把其他的JavaBeans对象与alden3挂接。*/
public void addPropertyChangeListener(PropertyChangeLisener l){
changes.addPropertyChangeListener(l);
}
public void removePropertyChangeListener(PropertyChangeListener l){
changes.removePropertyChangeListener(l);
}
第二章预备知识27

通过上面的代码，开发工具调用c h a n g e s的a d d P r o p e r t y C h a n g e L i s t e n e r方法把其他J a v a B e a n注
册入o u r S t r i n g属性的监听者队列l中，l是一个Ve c t o r数组，可存储任何J a v a对象。开发工具也可
使用c h a n g e s的r e m o v e P r o p e r t y C h a n g e L i s t e n e r方法，从l中注销指定的对象，使a l d e n 3的o u r S t r i n g
属性的改变不再与这个对象有关。当然，当程序员手写代码编制程序时，也可直接调用这两个
方法，把其他J a v a对象与a l d e n 3挂接。
4. Constrained属性
J a v a B e a n s的Co n s t r a i n e d属性是指当这个属性的值要发生变化时，与这个属性已建立了某种连
接的其他J a v a对象可否决属性值的改变。Co n s t r a i n e d属性的监听者通过抛出P r o p e r t y Ve t o E x c e p t i o n
来阻止该属性值的改变。
例如：下面程序中的Co n s t r a i n e d属性是P r i c e I n C e n t s。
public class JellyBean extends Canvas{
private PropertyChangeSupport changes=new PropertyChangeSupport(this);
private VetoableChangeSupport Vetos=new VetoableChangeSupport(this);
/*与前述changes相同，可使用VetoableChangeSupport对象的实例Vetos中的方法，在特定条件下来阻
止PriceInCents值的改变。*/
......
public void setPriceInCents(int newPriceInCents) throws PropertyVetoException {
/* 方法名中throws PropertyVetoException的作用是当有其他Java对象否决PriceInCent
s的改变时，要抛出例外。*/
/* 先保存原来的属性值*/
int oldPriceInCents=ourPriceInCents;
/**点火属性改变否决事件*/
vetos.fireVetoableChange
("priceInCents",new Integer(OldPriceInCents), new Integer(newPriceInCents));
/**若有其他对象否决priceInCents的改变，则程序抛出例外，不再继续执行下面的两条语句，方法结束。若无其
他对象否决priceInCents的改变，则在下面的代码中把ourPriceIncents赋予新值，并点火属性改变事件*/
ourPriceInCents=newPriceInCents;
changes.firePropertyChange
("priceInCents", new Integer(oldPriceInCents),new Integer(newPriceInCents));
}
/**与前述changes相同，也要为PriceInCents属性预留接口，使其他对象可注册入PriceInCents否决改变监
听者队列中，或把该对象从中注销
public void addVetoableChangeListener(VetoableChangeListener l){
vetos.addVetoableChangeListener(l);
}
public void removeVetoableChangeListener(VetoableChangeListener l){
vetos.removeVetoableChangeListener(l);
}
......
}
从上面的例子中可看到，一个Co n s t r a i n e d属性有两种监听者：属性变化监听者和否决属性
改变的监听者。否决属性改变的监听者在自己的对象代码中有相应的控制语句，在监听到有
Co n s t r a i n e d属性要发生变化时，在控制语句中判断是否应否决这个属性值的改变。
28第一部分JSP 入门

总之，某个B e a n s的Co n s t r a i n e d属性值可否改变取决于其他的B e a n s或者是J a v a对象是否允许
这种改变。允许与否的条件由其他的B e a n s或J a v a对象在自己的类中进行定义。
2.2.2 JavaBeans的事件
事件处理是J a v a B e a n s体系结构的核心之一。通过事件处理机制，可让一些组件作为事件源，
发出可被描述环境或其他组件接收的事件。这样，不同的组件就可在构造工具内组合在一起，
组件之间通过事件的传递进行通信，构成一个应用。从概念上讲，事件是一种在“源对象”和
“监听者对象”之间某种状态发生变化的传递机制。事件有许多不同的用途，例如在Wi n d o w s系
统中常要处理的鼠标事件、窗口边界改变事件、键盘事件等。在J a v a和J a v a B e a n s中则定义了一
个一般的、可扩充的事件机制，这种机制能够：
• 对事件类型和传递模型的定义和扩充提供一个公共框架，并适合于广泛的应用。
• 与J a v a语言和环境有较高的集成度。
• 事件能被描述环境捕获和触发。
• 能使其他构造工具采取某种技术在设计时直接控制事件、事件源和事件监听者之间的联
系。
• 事件机制本身不依赖于复杂的开发工具。
特别地，还应当：
• 能够发现指定的对象类可以生成的事件。
• 能够发现指定的对象类可以观察（监听）到的事件。
• 提供一个常规的注册机制，允许动态操纵事件源与事件监听者之间的关系。
• 不需要其他的虚拟机和语言即可实现。
• 事件源与监听者之间可进行高效的事件传递。
• 能完成J a v a B e a n事件模型与相关的其他组件体系结构事件模型的中立映射。
1. 概述
J a v a B e a n s事件模型总体结构的主要构成： 事件从事件源到监听者的传递是通过对目标监听
者对象的J a v a方法调用进行的。对每个明确的事件发生，都相应地定义一个明确的J a v a方法。这
些方法都集中定义在事件监听者（E v e n t L i s t e n e r）接口中，这个接口要继承j a v a . u t i l . E v e n t L i s t e n e r。
实现了事件监听者接口中一些或全部方法的类就是事件监听者。伴随着事件的发生，相应的状态
通常都封装在事件状态对象中，该对象必须继承自j a v a . u t i l . E v e n t O b j e c t。事件状态对象作为单参
传递给应响应该事件的监听者方法中。发出某种特定事件的事件源的标识是：遵从规定的设计格
式为事件监听者定义注册方法，并接受对指定事件监听者接口实例的引用。有时，事件监听者不
能直接实现事件监听者接口，或者还有其他的额外动作时，就要在一个源与其他一个或多个监听
者之间插入一个事件适配器类的实例，以建立它们之间的联系。
2. 事件状态对象
与事件发生有关的状态信息一般都封装在一个事件状态对象中，这种对象是j a v a . u t i l . E v e n t O b j e c t
的子类。按设计习惯，这种事件状态对象类名应以E v e n t结尾。例如：
public class MouseMovedExampleEvent extends java.util.EventObject{
第二章预备知识29

protected int x, y；
/* 创建一个鼠标移动事件MouseMovedExampleEvent */
MouseMovedExampleEvent(java.awt.Component source, Point location) {
super(source);
x = location.x;
y = location.y;
}
/* 获取鼠标位置*/
public Point getLocation() {
return new Point(x, y);
}
}
3. 事件监听者接口与事件监听者
由于J a v a事件模型是基于方法调用的，因而需要一个定义并组织事件操纵方法的方式。
J a v a B e a n s中，事件操纵方法都被定义在继承了j a v a . u t i l . E v e n t L i s t e n e r类的事件监听者（E v e n t L i s t e n e r）
接口中，按规定，E v e n t L i s t e n e r接口的命名要以L i s t e n e r结尾。任何一个类如果想操纵在E v e n t L i s t e n e r
接口中，定义的方法都必须以实现这个接口方式进行。这个类就是事件监听者。
例如：
/*先定义了一个鼠标移动事件对象*/
public class MouseMovedExampleEvent extends java.util.EventObject {
// 在此类中包含了与鼠标移动事件有关的状态信息
...
}
/*定义了鼠标移动事件的监听者接口*/
interface MouseMovedExampleListener extends java.util.EventListener {
/*在这个接口中定义了鼠标移动事件监听者所应支持的方法*/
void mouseMoved(MouseMovedExampleEvent mme);
}
在接口中只定义方法名，方法的参数和返回值类型。如上面接口中的m o u s e M o v e d方法的具
体实现是在下面的A r b i t r a r y O b j e c t类中定义的：
class ArbitraryObject implements MouseMovedExampleListener {
public void mouseMoved(MouseMovedExampleEvent mme) {
...
}
}
A r b i t r a r y O b j e c t就是M o u s e M o v e d E x a m p l e E v e n t事件的监听者。
4. 事件监听者的注册与注销
为了让各种可能的事件监听者把自己注册入合适的事件源中，就建立源与事件监听者间的
事件流，事件源必须为事件监听者提供注册和注销的方法。在前面的b o u n d属性介绍中，已看到
了这种使用过程，在实际中，事件监听者的注册和注销要使用标准的设计格式：
public void add< ListenerType>(< ListenerType> listener)；
public void remove< ListenerType>(< ListenerType> listener)；
例如：
30第一部分JSP 入门

首先定义了一个事件监听者接口：
public interface ModelChangedListener extends java.util.EventListener {
void modelChanged(EventObject e);
}
接着定义事件源类：
public abstract class Model {
private Vector listeners = new Vector();
// 定义了一个存储事件监听者的数组
/*上面设计格式中的< ListenerType>在此处即是下面的ModelChangedListener*/
public synchronized void addModelChangedListener(ModelChangedListener mcl){
listeners.addElement(mcl);
}
file://把监听者注册入listeners数组中
public synchronized void removeModelChangedListener(ModelChangedListener mcl){
listeners.removeElement(mcl);
file://把监听者从listeners中注销
}
/*以上两个方法的前面均冠以synchronized，是因为运行在多线程环境时，可能同时有几个对象同时要进行注册
和注销操作，使用synchronized来确保它们之间的同步。开发工具或程序员使用这两个方法建立源与监听者之间的事件
流*/
protected void notifyModelChanged() {
/**事件源使用本方法通知监听者发生了modelChanged事件*/
Vector l;
EventObject e = new EventObject(this);
/* 首先要把监听者拷贝到l数组中，冻结EventListeners的状态以传递事件。这样来确保在事件传递到所有监
听者之前，已接收了事件的目标监听者的对应方法暂不生效。*/
synchronized(this) {
l = (Vector)listeners.clone();
}
for (int i = 0; i < l.size(); i++) {
/* 依次通知注册在监听者队列中的每个监听者发生了modelChanged事件，并把事件状态对象e作为参数传递
给监听者队列中的每个监听者*/
((ModelChangedListener)l.elementAt(i)).modelChanged(e);
}
}
}
在程序中可见，事件源M o d e l类显式地调用了接口中的m o d e l C h a n g e d方法，实际是把事件状
态对象e作为参数，传递给了监听者类中的m o d e l C h a n g e d方法。
5. 适配类
适配类是J a v a事件模型中极其重要的一部分。在一些应用场合，事件从源到监听者之间的传
递要通过适配类来“转发”。例如：当事件源发出一个事件，而有几个事件监听者对象都可接收
该事件，但只有指定对象做出反应时，就要在事件源与事件监听者之间插入一个事件适配器类，
由适配器类来指定事件应该是由哪些监听者来响应。
适配类成为了事件监听者，事件源实际是把适配类作为监听者注册入监听者队列中，而真
第二章预备知识31

正的事件响应者并未在监听者队列中，事件响应者应做的动作由适配类决定。目前绝大多数的
开发工具在生成代码时，事件处理都是通过适配类来进行的。
2.2.3 持久化
当J a v a B e a n s在构造工具内被用户化，并与其他B e a n s建立连接之后，它的所有状态都应当可
被保存，下一次被装载进构造工具内或在运行时，就应当是上一次修改完的信息。为了能做到
这一点，要把B e a n s的某些字段的信息保存下来，在定义B e a n s时要使它实现j a v a . i o . S e r i a l i z a b l e
接口。例如：
public class Button implements java.io.Serializable {
}
实现了序列化接口的B e a n s中字段的信息将被自动保存。若不想保存某些字段的信息则可在
这些字段前冠以t r a n s i e n t或s t a t i c关键字，t r a n s i e n t和s t a t i c变量的信息是不可被保存的。通常，一
个B e a n s所有公开出来的属性都应当是被保存的，也可有选择地保存内部状态。B e a n s开发者在
修改软件时，可以添加字段，移走对其他类的引用，改变一个字段的p r i v a t e / p r o t e c t e d / p u b l i c状
态，这些都不影响类的存储结构关系。然而，当从类中删除一个字段，改变一个变量在类体系
中的位置，把某个字段改成t r a n s i e n t / s t a t i c，或原来是t r a n s i e n t / s t a t i c，现改为别的特性时，都将
引起存储关系的变化。
J a v a B e a n s的存储格式
J a v a B e a n s组件被设计出来后，一般是以扩展名为j a r的Z i p格式文件存储，在j a r中包含与
J a v a B e a n s有关的信息，并以M A N I F E S T文件指定其中的哪些类是J a v a B e a n s。以j a r文件存储的
J a v a B e a n s在网络中传送时极大地减少了数据的传输数量，并把J a v a B e a n s运行时所需要的一些资
源捆绑在一起。
这里主要论述了J a v a B e a n s s的一些内部特性及其常规设计方法，参考的是J a v a B e a n s s规范书。
随着世界各大I S V对J a v a B e a n s s越来越多的支持，规范在一些细节上还在不断演化，但基本框架
不会再有大的变动。
2.2.4 用户化
J a v a B e a n s开发者可以给一个B e a n s添加定制器（C u s t o m i z e r）、属性编辑器（P r o p e r t y E d i t o r）
和B e a n I n f o接口来描述一个B e a n s的内容， B e a n s的使用者可在构造环境中通过与B e a n s附带在一
起的这些信息来用户化B e a n s的外观和应做的动作。一个B e a n s不必都有B e a n C u s t o m i z e r、
P r p e r t y E d i t o r和B e a n I n f o，根据实际情况，这些是可选的，当有些B e a n s较复杂时，就要提供这
些信息，以Wi z a r d的方式使B e a n的使用者能够定制一个B e a n s。有些简单的B e a n s可能没有这些
信息，则构造工具可使用自带的透视装置，透视出B e a n s的内容，并把信息显示到标准的属性表
或事件表中供使用者定制B e a n s，前几节提到的B e a n s的属性、方法和事件名要以一定的格式命
名，主要的作用就是供开发工具对B e a n s进行透视。当然也是给程序员在手写程序中使用B e a n s
提供方便，使其能观其名，知其意。
1. 定制器接口
32第一部分JSP 入门

当一个B e a n有了自己的定制器时，在构造工具内就可展现出自己的属性表。在定义定制器
时必须要实现j a v a . b e a n s . C u s t o m i z e r接口。例如，下面是一个“按钮” B e a n s的定制器：
public class OurButtonCustomizer extends Panel implements Customizer {
... ...
/*当实现像OurButtonCustomizer这样的常规属性表时，一定要在其中实现addProperChangeListener和
removePropertyChangeListener,这样，构造工具可用这些功能代码为属性事件添加监听者。*/
... ...
private PropertyChangeSupport changes=new PropertyChangeSupport(this);
public void addPropertyChangeListener(PropertyChangeListener l) {
changes.addPropertyChangeListener(l);
}
public void removePropertyChangeListener(PropertyChangeListener l) {
changes.removePropertyChangeListener(l);
}
... ...
}
2. 属性编辑器接口
一个J a v a B e a n s可提供P r o p e r t y E d i t o r类，为指定的属性创建一个编辑器。这个类必须继承自
j a v a . b e a n s . P r o p e r t y E d i t o r S u p p o r t类。构造工具与手写代码的程序员不直接使用这个类，而是在
下一小节的B e a n I n f o中实例化并调用这个类。例如：
public class MoleculeNameEditor extends java.beans.PropertyEditorSupport {
public String[] getTags() {
String resule[]={
"HyaluronicAcid","Benzene","buckmisterfullerine",
"cyclohexane","ethane","water"};
return resule;
}
}
上例中是为Ta g s属性创建了属性编辑器，在构造工具内，从下拉表格中选择M o l e c u l e N a m e
的属性应是”H y a l u r o n i c A i d”或“w a t e r”。
3. BeanInfo接口
每个B e a n类也可能有与之相关的B e a n I n f o类，在其中描述了这个B e a n在构造工具内出现时
的外观。B e a n I n f o中可定义属性、方法、事件，显示它们的名称，提供简单的帮助说明。
例如：
public class MoleculeBeanInfo extends SimpleBeanInfo {
public PropertyDescriptor[] getPropertyDescriptors() {
try {
PropertyDescriptor pd=new PropertyDescriptor("moleculeName",Molecule.class);
/*通过pd引用了上一节的MoleculeNameEditor类,取得并返回
moleculeName属性*/
pd.setPropertyEditorClass(MoleculeNameEditor.class);
PropertyDescriptor result[]={pd};
return result;
第二章预备知识33

} catch(Exception ex) {
System.err.println("MoleculeBeanInfo: unexpected exeption: "+ex);
return null;
}
}
}
2.3 Java Servlet
鉴于J S P和Java Servlet的紧密联系，笔者认为学习J S P一定要有Java Servlet的基础，当然，
不需要成为Java Servlet的专家，但一定要有概念上的认识。
下面将介绍Java Servlet的基础知识，对于具体的程序开发，现在不需要读者立即掌握，本
节的目的在于让读者能够对S e r v l e t有所了解。
2.3.1 HTTP Servlet API
Java Servlet 开发工具（ J S D K）提供了多个软件包，在编写Servlet 时需要用到这些软件包。
其中包括两个用于所有Servlet 的基本软件包：javax.servlet 和j a v a x . s e r v l e t . h t t p。可从s u n公司的
We b站点Java Servlet 开发工具，现在一般使用J S D K 2 . 0。这里主要介绍j a v a x . s e r v l e t . h t t p提
供的HTTP Servlet应用编程接口。
1. 简述
创建一个HTTP Servlet，需要扩展HttpServlet 类，该类是用专门的方法来处理H T M L表格
数据的GenericServlet 的一个子类。HttpServlet 类包含i n i t ( )、d e s t r o y ( )、service() 等方法。其中
init() 和destroy() 方法是继承的。
（1） init() 方法
在Servlet 的生命期中，仅执行一次init() 方法。它是在服务器装入Servlet 时执行的。可以
配置服务器，以在启动服务器或客户机首次访问Servlet 时装入S e r v l e t。无论有多少客户机访问
S e r v l e t，都不会重复执行init() 。
（2）service() 方法
service() 方法是Servlet 的核心。每当一个客户请求一个HttpServlet 对象时，该对象的
service() 方法就要被调用，而且传递给这个方法一个“请求”（S e r v l e t R e q u e s t）对象和一个“响
应”（S e r v l e t R e s p o n s e）对象作为参数。在HttpServlet 中已存在service() 方法。缺省的服务功
能是调用与HTTP 请求的方法相应的do 功能。例如， 如果HTTP 请求方法为G E T，则缺省情
况下就调用doGet() 。Servlet 应该为Servlet 支持的HTTP 方法覆盖do 功能。因为
HttpServlet.service() 方法会检查请求方法是否调用了适当的处理方法，不必覆盖service() 方法。
只需覆盖相应的do 方法就可以了。
（3）destroy() 方法
destroy() 方法仅执行一次，即在服务器停止且卸装Servlet 时执行该方法。典型的，将
Servlet 作为服务器进程的一部分来关闭。缺省的destroy() 方法通常是符合要求的，但也可以覆
盖它，典型的是管理服务器端资源。例如，如果Servlet 在运行时会累计统计数据，则可以编写
34第一部分JSP 入门

一个destroy() 方法，该方法用于在未装入Servlet 时将统计数字保存在文件中。另一个示例是关
闭数据库连接。
（4）G e t S e r v l e t C o n f i g（）方法
G e t S e r v l e t C o n f i g（）方法返回一个ServletConfig 对象，该对象用来返回初始化参数和
S e r v l e t C o n t e x t。ServletContext 接口提供有关servlet 的环境信息。
（5）G e t S e r v l e t I n f o（）方法
G e t S e r v l e t I n f o（）方法是一个可选的方法，它提供有关servlet 的信息，如作者、版本、版
权。
当服务器调用sevlet 的S e r v i c e（）、d o G e t（）和d o P o s t（）这三个方法时，均需要“请求”和
“响应”对象作为参数。“请求”对象提供有关请求的信息，而”响应”对象提供了一个将响应信
息返回给浏览器的通信途径。javax.servlet 软件包中的相关类为S e r v l e t R e s p o n s e和S e r v l e t R e q u e s t，
而javax.servlet.http 软件包中的相关类为HttpServletRequest 和H t t p S e r v l e t R e s p o n s e。
Servlet 通过这些对象与服务器通信并最终与客户机通信。Servlet 能通过调用“请求
（R e q u e s t）”对象的方法获知客户机环境、服务器环境的信息和所有由客户机提供的信息。S e r v l e t
可以调用“响应”对象的方法发送响应，该响应是准备发回客户机的。
2. 常用HTTP Servlet API概览
支持H T T P协议的s e r v l e t可以使用j a v a x . s e r v l e t . h t t p包进行开发，而j a v a x . s e r v l e t包中的核心功
能提供了We b开发的许多类和函数，为进行J S P 的开发带来了极大的方便。比如，抽象
H t t p S e r v l e t 类包含对不同H T T P 请求方法和头信息的支持， H t t p S e r v l e t R e q u e s t 和
H t t p S e r v l e t R e s p o n s e接口允许直接与We b服务器通信，而H t t p S e s s i o n提供内置会话跟踪功能；
C o o k i e类可以很快地设置和处理HTTP Cookie，H t t p U t i l s类用于处理请求字串。
(1) Cookie
C o o k i e类提供了读娶创建和操纵HTTP Cookie的便捷途径，允许s e r v l e t在客户端存储少量
的数据。C o o k i e主要用于会话跟踪和存储少量用户配置信息数据。
S e r v l e t用H t t p S e r v l e t R e q u e s t的g e t C o o k i e（）方法获取C o o k i e信息； H t t p S e r v l e t R e s p o n s e的
a d d C o o k i e（）方法向客户端发送新的C o o k i e，因为是使用HTTP 头设置的，所以a d d C o o k i e（）
必须在任何输出发送到客户端之前调用。
虽然Java Web Server有一个s u n . s e r v l e t . u t i l . C o o k i e类能完成大致相同的工作，但最初的
Servlet API 1.0 却没有C o o k i e类。s u n . s e r v l e t . u t i l . C o o k i e类和当前C o o k i e类唯一不同的是获取和
创建方法是C o o k i e类的静态组成部分，而不是H t t p S e r v l e t R e q u e s t和H t t p S e r v l e t R e s p o n s e的接口。
(2) HttpServlet
H t t p S e r v l e t是开发HTTP servlet框架的抽象类,，其中的s e r v i c e ( )方法将请求分配给H T T P的
protected service()方法。
(3) HttpServletRequest
H t t p S e r v l e t R e q u e s t通过扩展S e r v l e t R e q u e s t基类，为HTTP servlets提供附加的功能。它支持
C o o k i e s和s e s s i o n跟踪及获取H T T P头信息的功能； H t t p S e r v l e t R e q u e s t还能解析H T T P的表单数
据，并将其存为s e r v l e t参数。
第二章预备知识35

服务器将H t t p S e r v l e t R e q u e s t对象传给H t t p S e r v l e t的s e r v i c e ( )方法。
(4) HttpServletResponse
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 R e s p o n s e类，允许操纵H T T P协议相关数据，包括响应头和
状态码。它定义了一系列常量，用于描述各种H T T P状态码，还包含用于s e s s i o n跟踪操作的帮助
函数。
(5) HttpSession
H t t p S e s s i o n接口提供了对We b访问者的认证机制。H t t p S e s s i o n接口允许s e r v l e t查看和操纵会
话相关信息，比如创建访问时间和会话身份识别。它还包含一些方法，用于绑定会话到特定的
对象，允许“购物车”和其他的应用程序保存数据用于各连接间共享，而不必存到数据库或其
他的e x t r a - s e r v l e t资源中。
S e r v l e t调用H t t p S e r v l e t R e q u e s t的g e t S e s s i o n ( )方法来获得H t t p S e s s i o n对象，定制S E S S I O N的
行为，比如在销毁S E S S I O N之前等待的时间，依服务器而定。
虽然任何对象都可以绑定到S E S S I O N，然而对一些事务繁忙的Se r v l e t，绑定大的对象到
S E S S I O N中将会加重服务器的负担。减轻服务器负担最常用的解决办法是，仅仅绑定用于实现
j a v a . i o . S e r i a l i z a b l e接口的对象（它包含Java API核心中的所有数据类型对象）。有些服务器能将
S e r i a l i z a b l e对象写入磁盘中，U n s e r i a l i z a b l e对象比如j a v a . s q l . C o n n e c t i o n ,必须保留在内存中。
(6) HttpSessionBindingEvent
H t t p S e s s i o n B i n d i n g L i s t e n e r监听对象绑定或断开绑定于会话时， H t t p S e s s i o n B i n d i n g E v e n t被
传递到H t t p S e s s i o n B i n d i n g L i s t e n e r。
(7) HttpSessionBindingListener
当对象绑定于H t t p S e s s i o n或从H t t p S e s s i o n松开绑定时，通过调用valueBound () 和
valueUnbound ()来通知用于实现H t t p S e s s i o n B i n d i n g L i s t e n e r的接口。其他情况下，这个接口可以
顺序清除与s e s s i o n相关的资源，例如数据库连接等。
(8) HttpSessionContext
H t t p S e s s i o n C o n t e x t提供了访问服务器上所有活动s e s s i o n的方法，这对s e r v l e t清除不活动的
s e s s i o n，显示统计信息和其他共享信息是很有用的。S e r v l e t 通过调用H t t p S e s s i o n 的
getSessionContext () 方法获得H t t p S e s s i o n C o n t e x t对象。
(9) HttpUtils
这是一个容纳许多有用的基于H T T P方法的容器对象，使用这些方法，可以使S e r v l e t开发更
方便。
2.3.2 系统信息
要成功建立We b应用，必须了解它所需的运行环境，还要了解执行s e r v l e t的服务器和发送请
求的客户端的具体情况。不管应用程序运行于哪种环境，都应该确切知道应用程序所应处理的
请求信息。
S e r v l e t有许多方法可以获取这些信息。大多数情况下，每个方法都会返回不同的结果。比
较C G I用于传递信息的环境变量，读者会发现s e r v l e t方法具有以下几个优点：
36第一部分JSP 入门

• 强有力的类型检查。
• 延迟计算。
• 与服务器的更多交互。
1. 初始化参数
每个注册的s e r v l e t名称都有与之相关的特定参数， s e r v l e t程序在任何时候都可获得这些参
数；它们经常使用i n i t（）方法来为s e r v l e t设定初始或缺省值以在一定程度上定制s e r v l e t的行为。
(1) 获得初始参数
s e r v l e t用g e t I n i t P a r a m e t e r（）方法来获取初始参数：
public String ServletConfig.getInitParameter(String name)
这个方法返回初始参数的名称或空值(如果不存在)。返回值总是S t r i n g类型，由s e r v l e t对它
进行解释。
G e n e r i c S e v l e t类实现S e r v l e t C o n f i g接口，直接访问g e t I n i t P a r a m e t e r（）方法。
(2) 获取初始参数名
s e r v l e t调用g e t I n i t P a r a m e t e r N a m e s（）方法可检验它的所有参数：
public Enumeration ServletConfig.getInitParameterNames()
这个方法返回值是字符串对象的枚举类型或空值(如果没参数)，经常用于程序的调试。
G e n e r i c S e r v l e t类也可以使得s e r v l e t s直接访问这个方法。
2. 服务器
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 r v l e t的S e r v l e t R e q u e s t对象调用，两
个从S e r v l e t C o n t e x t对象调用，S e r v l e t C o n t e x t包含s e r v l e t的运行环境。通过使用方法g e t S e r v e r N a m e（）
和g e t S e r v e r P o r t（），S e r v l e t能为具体请求分别获取服务器的名称和端口号：
public String ServletRequest.getServerName()
public int ServletRequest.getServerPort()
S e r v l e t C o n t e x t的G e t S e r v e r I n f o（）和g e t A t t r i b u t e（）方法提供服务器软件和属性的信息：
public String ServletContext.getServerInfo()
public Object ServletContext.getAttribute(String name)
(2) 锁定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能及时地访问到服务器的相关信息。
3 客户端
对每个请求，s e r v l e t能获取客户机、要求认证的页面及实际用户的有关信息。这些信息可用
第二章预备知识37

于登录访问，收集用户个人资料或限制某些客户端的访问。
(1) 获取客户机信息
s e r v l e t可用g e t R e m o t e A d d r ( )和g e t R e m o t e H o s t ( )分别获取客户机的I P地址和主机名称：
public String ServletRequest.getRemoteAddr()
public String ServletRequest.getRemoteHost()
以上两种方法都返回字符串对象类型。这些信息来自于连接服务器和客户端的s o c k e t端口，所以
远程地址和远程主机名有可能是代理服务器的地址和主机名称。远程地址可能是“1 9 2 . 2 6 . 8 0 . 11 8”,
而远程主机名可能是“d i s t . e n g r. s g i . c o m”。
I n e t A d d r e s s . g e t B y N a m e ( )方法可以将I P地址和远程主机名称转化为j a v a . n e t . I n e t A d d r e s s对象:
InetAddress remoteInetAddress = InetAddress.getByName(req.getRemoteAddr());
(2) 限制为只允许某些地区的机器访问
由于美国政府对好的加密技术出口的限制政策，在某些We b站点上，允许的软件就得特
别谨慎。利用s e r v l e t的获取客户机信息的功能，可以很好地加强这种限制。这些s e r v l e t能检查客
户机，并对那些来自美国和加拿大的机器提供链接。
对于商业应用，可以确定让一个S e r v l e t只对来自企业内部网的客户机服务，从而保证安全。
(3) 获取用户相关信息
如果要对Web pages作更进一步的限制，而不是根据地域限制访问，该怎么做呢？比如，发
布的在线杂志，只想让已定购的用户可以访问。读者也许会说，这好办，我早都能做，不一定
非得用s e r v l e t。
是的，几乎每种H T T P服务器都内嵌了这种功能，可以限制特定用户访问所有或部分网页。
怎样设定限制依你所使用的服务器不同而有差异，这里我们给出它们的共同工作机理。浏览器
第一次试图访问某个页面时，服务器会给浏览器一个要求身份验证的响应，浏览器收到这个响
应后，会弹出一个要求输入用户名和密码的对话框。
用户输入信息后，浏览器会试图再一次访问该页，但这次请求信息中附加了用户名称和密
码信息。服务器接受用户名/密码对后，就会处理此请求；如果相反，服务器不接受此用户名/密
码对，浏览器的访问再一次被拒绝，用户必须重新输入。
那么，s e r v l e t是怎样处理的呢？当访问受限制的s e r v l e t时，s e r v l e t可以调用g e t R e m o t e U s e r ( )
方法，获取服务器认可的用户名称：
public String HttpServletRequest.getRemoteUser()
S e r v l e t也可以用g e t A u t h Ty p e（）方法获取认证类型：
public String HttpServletRequest.getAuthType()
这个方法返回所用的认证类型或可空值(如果未加限制)，最常使用的认证类型是“ B A S I C”
和“D I G E S T”。
(4) 个性化的欢迎信息
一个简单的调用g e t R e m o t e U s e r ( )方法的s e r v l e t，可以通过称呼用户名称向他问好，并记住他
上次登录的时间。但是需要注意的是，这种方法仅仅适用于授权用户。对于未授权用户，可以
使用S e s s i o n。
38第一部分JSP 入门

4. 请求
前面讲述了s e r v l e t如何获取服务器和客户机的相关信息，现在要学习真正重要的内容：
s e r v l e t如何知道客户请求什么。
(1) 请求参数
每个对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要获取许多参数，获取每个参数的方法也都一样，即g e t P a r a m e t e r ( )和
g e t P a r a m e t e r Va l u e s ( )方法：
public String ServletRequest.getParameter(String name)
public String[] ServletRequest.getParameterValues(String name)
g e t P a r a m e t e r ( )以字符串形式返回命名的参数，如果没指定参数则返回空值，返回值必须保
证是正常的编码形式。如果此参数有多个值，那么这个值是与服务器相关的，这种情况下应该
用g e t P a r a m e t e r Va l u e s ( )方法，这个方法以字符对象数组的形式返回相应参数的所有值，如果没
指定，当然为空值。返回的每个值在数组中占一个单位长度。
除了能获取参数值之外， s e r v l e t还能用g e t P a r a m e t e r N a m e s ( )获取参数名称:
public Enumeration ServletRequest.getParameterNames()
这个方法以字符串枚举类型返回参数名称，或者在没有参数时返回空值。这个方法经常用
于程序的调试。
最后，s e r v l e t还能用g e t Q u e r y S t r i n g ( )方法获取请求的二进制字串：
public String ServletRequest.getQueryString()
这个方法返回请求的二进制字串(已编码的G E T参数信息)，如果没有请求字串，则返回空值。
这些底层数据很少用来处理表单数据。
(2) 发布许可证密钥
如果现在准备编写一个给特定主机和端口号发布K e y e d S e r v e r L o c k许可证密钥的s e r v l e t，从
s e r v l e t获取的密钥可用于解锁K e y e d S e r v e r L o c k的s e r v l e t。那么，怎么知道s e r v l e t所要解锁的主机
名和端口号呢？当然是请求参数。
(3) 路径信息
除参数信息外， H T T P请求还能包括“附加路径信息”或“虚拟路径”等。通常，附加路径
信息是用于指明s e r v l e t要用到的文件在服务器上的路径，一般用H T T P请求的U R L形式表示，可
能像这样：
h t t p：/ / s e r v e r：p o r t / s e r v l e t / Vi e w F i l e / i n d e x . h t m l
这将激活ViewFile servlet，同时传递“ i n d e x . h t m l”作为附加路径信息。S e r v l e t可以访问这
个路径信息，还能将字串“i n d e x . h t m l”转化为文件i n d e x . h t m l的真实路径。什么是“/ i n d e x . h t m l”
的真实路径呢？它是指当客户直接请求“ / i n d e x . h t m l”文件时，服务器返回的完整文件系统路径。
可能是d o c u m e n t _ r o o t / i n d e x . h t m l，当然服务器也可能用别名将它改变了。
除了用明确的U R L形式指定外，附加信息也可写成H T M L表单中A C T I O N参数的形式：
第二章预备知识39

<FORM METHOD=GET
ACTION=＂/servlet/Dictionary/dict/definitions.txt＂>
word to look up: <INPUT TYPE=TEXT NAME=＂word＂><P>
<INPUT TYPE=SUBMIT><P>
</FORM>
表单激活Dictionary servlet处理请求任务，同时传递附加路径信息“ d i c t / d e f i n i t i o n s . t x t”。
s e r v l e t会用单词d e f i n i t i o n s查找d e f i n i t i o n s . t x t文件，如果客户请求“ / d i c t / d e f i n i t i o n s . t x t”文件，
同时在s e r v e r _ r o o t / p u b l l i c _ h t m l / d i c t / d e f i n i t i o n s . t x t也存在，客户将会看到相同的文件。
1 ) 获取路径信息。
s e r v l e t可用g e t P a t h I n f o ( )方法获取附加路径信息：
public String HttpServletRequest.getPathInfo()
这个方法返回与请求相关的附加路径信息，或者在没给定时，返回空值。S e r v l e t通常需要
知道给定文件的真实文件系统路径，这样就有了g e t P a