网络程序设计：网络程序设计(讲课)

网络程序设计徐国成
13978029951
2005年 5月目录
第一章 socket网络编程
第二章 C/S模式程序设计
访问关系数据库
程序设计
第三章 B/S模式程序设计
WWW基础
页面程序设计（ javascript）
服务器端程序设计（ jsp,asp）
课程基础
计算机网络基础
计算机网络概念
网络协议与分层模型,TCP/IP协议 (包括 UDP)
Internet/IPV4/IPV6
C/S模式和 B/S模式
WWW和 HTTP,URL
高级语言程序设计 (C,JAVA,VB…)
成绩评分标准
考试,70分
上课内容,20分
教材内容,20分
编程技能和思路,30分
上机,30分 (3-5人一组，至少完成一题 )
Socket程序设计 (实现联通 SGIP协议 )
Ｃ／Ｓ结构程序设计（实现两个数据库之间同名表的同步复制）
Ｂ／Ｓ结构程序设计（实现收发邮件和短信）
可以选择实际的题目（对于有能力联系到实际项目的同学）
第 1章 Socket网络通信编程
1.1 套接字 Socket
Windows,UNIX,Linux等都支持 socket
Microsoft Visual C++,socket被封装成类
（ CAsyncSocket和 Csocket）
Microsoft Visual Basic,socket以 Winsock控件的方式出现
Winsock控件 - 主机之间利用 TCP通信客户程序
RemoteHost属性,RemotePort属性,Connect方法服务器程序
LocalPort属性,Listen方法,ConnectionRequest事件,Accept方法。
发送和接收数据
SendData,DataArrival事件,GetData方法
Winsock控件 - 主机之间利用 UDP通信服务器程序
LocalPort属性,RemoteHost属性,RemotePort属性,SendData方法、
DataArrival事件,GetData方法客户程序
RemoteHost属性,RemotePort属性,SendData方法,DataArrival事件,GetData方法
1.1.1 网络应用程序编程接口操作系统 OS：内核和系统应用程序,应用程序编程接口 API (application program interface)
图 1.1 应用程序与 TCP/IP核心协议的接口
……
应用程序 1 应用程序 2
网络应用程序编程接口（ soc k et ）
TCP/IP 核 心 协 议物 理 介 质应用程序 n
1.1.2 客户 -服务器（ client-server）模式
1,客户 -服务器模式客户和服务器,两个应用程序 （ 进程 ）,可位于互联网的两台主机上 。 客户发出服务请求,服务器作出响应 。
* 非对等性：请求服务 --提供服务,服务器有更大的硬,软件资源和处理能力；
* 随机性：服务器开机后处于等待状态,通信过程由客户进程随机发起,服务器及时响应 。
2,并发服务器和重复服务器
并发服务器 (concurrent server),
主服务器 （ master）,一直运行,监听客户请求 ；当有客户请求时,产生一个子进程即从服务器 (slave)响应请求,而自己回到等待状态 。
重复服务器 (iterative server)：
不产生从服务器,包含一请求队列供客户请求排队,按 FIFO(first in first out) 逐一响应请求 。
优缺点：并发服务器产生多 个子进程并发地响应多个请求,实时性好；但系统开销大 。
3,面向连接和无连接
1.1.3 套接字 Socket
概念：套接字看成是网络环境下 UNIX文件访问机制的一般化,文件描述字 --套接字描述字,是一种网络 API 。
使用：类似文件描述字,
* 打开文件 → 文件描述字 → 使用描述字 write/read
* 创建套接字 → 套接字描述字（ → 地址绑定和
TCP连接 ) → 使用描述字 write/read
套接字对 （ Socket pair）：标识一个 TCP连接，
定义连接两个端点的四元组。
套接字机制基于客户 —服务器模模式。
1.2 Socket 网络通信编程 (C)
1.2.1 套接字的创建与关闭创建调用,
sockid：系统调用 socket（ ） 的返回值,整数,
Socket描述字,或称 Socket号 。
① pf(protocol family),协议族
PF_INET,IPv4 互联网协议
PF_INET6,IPv6 互联网协议
PF_UNIX,UNIX内部地址,文件路径名
② type,类型,应用程序指定通信服务类型
SOCK_STREAM,流 socket；
SOCK_DGRAM,数据报 socket；
sockid = socket (pf,type,protocol)
③ protocol 协议表 1.1
参数组合当一一对应时,protocol可置为 0，默认协议,
S = socket ( PF_INET,SOCK_STREAM,0 ) ---TCP
套接字关闭,
协议族 Socket类型 实际协议
PF_INET
SOCK_DGRAM UDP
SOCK_STREAM TCP
SOCK_RAW IPv4
SOCK_RAW ICMP
PF_INET6
SOCK_DGRAM UDP
SOCK_STREAM TCP
SOCK_RAW IPv6
SOCK_RAW ICMPv6
close (sockid)
1.2.2 绑定本地地址
将本地 socket地址（ IP地址和端口号）与所创建的 socket号联系起来,亦称 socket命名 。
绑定 调用,
① sockid,socket号；
② localaddr 指向 socket地址结构的指针；
③ addrlen 地址长度（字节）。
bind（）成功返回 0，失败返回 -1。
网络字节顺序,高价先存（ big-endian）：
128.10.2.30,低地址 高地址
bind (sockid,localaddr,addrlen)
80 0A 02 1E
1.2.3 建立连接
1,请求连接
客户端的动作，一般用于面向连接的流 socket。
请求连接：
① sockid,本地 socket号；
② destaddr：指向对方 socket地址结构的指针；
③ addrlen：指出对方 socket地址长度 。
成功返回 0，失败返回 -1。
调用 connect( )前可不调用 bind( )，内核负责。
也可用于无连接方式，指明默认目的地址。
connect (sockid,destaddr,
addrlen)
2,接收连接服务器端的动作,bind( )后两步：一是创建侦听队列，以存储多个连接请求；二是接收连接。
（ 1） listen（）,
① sockid 本地 socket号 ;
② quelen 队列长度,限制排队请求的个数 。
成功返回 0,失败返回 -1。
listen（ ） 成功后,该套接字成为准备接收连接的模式,称为 被动套接字 。
Listen(socketid,quelen)
2,接收连接（续）
（ 2） accept（ ）
① sockid,本地 socket号 。
② clientaddr：指向初始值为空的客户 socket地址结构的指针,返回时放入实际地址 。
③ paddrlen：指向初始值为 0的客户 socket地址长度变量的指针,返回时放入实际长度 。
④ newsock：返回的新 socket号,它与客户建立了连接,而原 Socket可继续用来接收新的连接请求 。
newsock = accept ( sockid,clientaddr,paddrlen)
图 1.2 accept( )调用返回前后的状态图 1.3
使用并发服务器 ---产生一个从服务器
1.2.4 数据的发送与接收
1,发送数据
（ 1） 面向连接的数据发送缓冲发送：
可控缓冲发送：
收集发送：
① sockid：本地 socket号；
② buff：指向发送缓冲区的指针；
③ length,发送数据长度 (字节 )；
write(sockid,buff,length)
writev(sockid,iovector,vectorlen)
send(sockid,buff,length,flags)
1,发送数据 (续 1)
④ iovector,指向 I/O向量表的指针；
⑤ vectorlen,I/O向量表的长度 (字节 )；
⑥ flags：传输控制标志 。
缓冲发送,从 sockid指定的套接字发送数据,
数据取自 buff所指向的缓冲区中的前 length个字节,返回值是实际发出的字节数,应等于
length,出错时返回 -1。
收集发送 (gather write),一次发送若干个 I/O
向量表指示的分散的数据块 。
可控缓冲发送,紧急数据和寻址控制 。
1,发送数据 ( 续 2)
（ 2） 无连接的数据发送可控缓冲无连接发送：
可控收集无连接发送：
① dstadd,指向目的 socket地址的指针；
② addrlen,目的 socket地址长度；
③ message,指向待发数据的指针 。
sendto (sockid,buff,length,flags,dstadd,addrlen)
sendmsg (sockid,message,flags)
2,接收数据
write(),
send(),
writev(),
sendto(),
sendmsg(),
发送与接收系统调用,
* 在默认情况下是阻塞的 ;
*正常返回值是实际发送或接收的字节数,
read(sockid,buff,length)
readv(sockid,iovector,vectorlen)
recvfrom(sockid,buff,length,flags,fromadd,addrlen)
recv(sockid,buff,length,flags)
recvmsg(sockid,message,flags)
1.2.5 客户 —服务器模式的 socket实现框架图 1.6
面向连接的实现框架图 1.7 无连接的客户 —服务器模式实现框架
1.3 Socket 网络通信编程 (JAVA)
1.3.1 Java 网络基础知识
Java获得迅速推广的一个重要原因就在于强大的网络能力，利用网络类,Java程序能够方便地访问 Internet和 Wrold Wide Web上的资源。接入
Internet的计算机相互之间的通信要么采用 TCP协议要么采用 UDP协议，这些是较低层次的协议。
当你编写 Java网络程序时，是基于应用层的，不需要考虑那些复杂的底层协议。 java.net类库包含了你所需要的各种网络类，使用它们就可以编写出基于 TCP或 UDP协议的网络程序。
传输控制协议 TCP（ transmission control
protocol）是一个基于连接的协议，可在两台相连计算机之间提供可靠的数据流。当两台计算机要传输信息时，需要建立一个可靠的连接以便发送和接收。
用端口区分。 Internet传输的数据都带有地址，包含了计算机和端口信息。计算机以 32-bit IP地址表示，端口用一个 16-bit数表示,TCP和 UDP就是使用了这个端口数才能把数据发给正确的程序。
基于连接的 TCP协议，服务器会把一个套接字
（ Socket）和一个指定端口绑在一起，客户机连接到这个端口就可接收所有指向这个端口的数据。
而基于数据报的 UDP协议，每个数据包都包含端口数,UDP可以指引它们到达正确的应用程序。
很多应用程序需要可靠的、按顺序的数据传输，
也有的应用程序不需要，因此在设计网络程序时应正确选择网络类。 URL,URLConnection、
Socket和 ServerSocket类是基于 TCP协议的，而
DatagramPacket,DatagramSocket和
MulticastSocket类是基于 UDP协议的。
1.3.2 URL编程
URL（统一资源定位符）代表着 Internet上的指定资源。为浏览器指定了 URL你就可以访问这个资源。 Java程序同样可以使用 URL访问网络资源，
java.net提供了 URL类，可用它创建一个代表
URL地址的对象，通过对象就可以访问指定资源。
例 1-8利用 URL访问网站，如下图所示。
import java.awt.*;
import java.awt.event.*;
import java.net.*;
import java.applet.Applet;
class HomeButton extends Button {
String name;
URL home;
HomeButton(String name,String site) {
setLabel(name);
try {
home=new URL(site);
}
catch (MalformedURLException e) {}
}
}
public class GoHome extends Applet implements
ActionListener {
HomeButton javaHome=new HomeButton(″Java″,
″http://java.sun.com″);
HomeButton yahooHome=new
HomeButton(″Yahoo″,
″http://www.yahoo.com″);
public void init( ) {
add(javaHome);
add(yahooHome);
javaHome.addActionListener(this);
yahooHome.addActionListener(this);
}
public void actionPerformed(ActionEvent e) {
HomeButton btn=(HomeButton)e.getSource( );
getAppletContext( ).showDocument(btn.home);
}
}
HomeButton是按钮的子类，添加了两个属性，
name用来设定按钮名称,home是一个 URL对象。
创建 URL对象时会抛出
MalformedURLException异常，因此使用了
try...catch结构，根据传递的参数来创建这个
URL对象。
主类创建了两个按钮，参数是网站的名称和对应的网址。这里的网址是一个字符串，包含了两部分内容,http代表应用层协议，双斜杠后面是主机名，例如 java.sun.com代表 Sun公司的网络服务器主机。程序没有给出文件名，浏览器将使用默认文件名即 index.html。
在 init方法中，将这两个按钮添加到 Applet，注册了它们的事件监听者。在事件处理方法中,btn代表所点击的按钮。点击按钮，浏览器将启动拨号程序访问按钮代表的网站。
注意 Applet方法的使用,getAppletContext方法的返回值是一个对象引用，这个对象引用就是运行 Applet的浏览器。 showDocument方法需要一个 URL对象，这里用 btn.home作为参数，它就是在 HomeButton类中创建的 URL对象。
1.3.3 创建 URL对象
从上面的例子来看,URL编程的关键是 URL对象的创建。下面是 URL对象的构造方法，根据参数的不同，
可以创建多种形式的 URL对象：
(1) URL(String url)url代表一个绝对地址,URL对象直接指向这个资源。
(2) URL(URL baseURL,String
relativeURL)baseURL代表绝对地址,relativeURL
代表相对地址。
(3) URL(String protocol,String host,String
file)protocol代表通信协议,host代表主机名,file代表文件名。
(4) URL(String protocol,String host,int port,
String file)protocol代表通信协议,host代表主机名，
port代表端口,file代表文件名。
例 1-9查看 URL的属性。
import java.io.*;
import java.net.*;
public class GetURL {
public static void main(String［］ args) throws
Exception {
URL url=new URL(″http″,″java.sun.com″,80,
″docs/books/tutorial/index.html#DOWNLOADING
″);
System.out.println(″协议,″+url.getProtocol( ));
System.out.println(″主机,″+url.getHost( ));
System.out.println(″文件,″+url.getFile( ));
import java.io.*;
import java.net.*;
public class URLReader {
public static void main(String［］ args) throws
Exception {
URL url=new URL(″http://www.zz.ha.cn/″);
InputStreamReader urlStream=new
InputStreamReader(url.openStream( ));
BufferedReader in=new
BufferedReader(urlStream);
String str;
while ((str=in.readLine( ))!=null)
System.out.println(str);
in.close( );
urlStream.close( );
}
}
1.3.5 利用 URLConnection和服务器交互
例，向服务器发送信息并接收信息处理结果，如下图所示。
import java.io.*;
import java.net.*;
public class Reverse {
public static void main(String［］ args) {
if (args.length!=1) {
System.err.println(″用法,java Reverse ＼ ″这里是一个字符串＼ ″″);
System.exit(1);
}
String sendMessage=URLEncoder.encode(args
［ 0］ );
try {
URL url=new URL(″http://java.sun.com/cgi-
bin/backwards″);
URLConnection channel=url.openConnection( );
channel.setDoOutput(true);
PrintWriter out=new
PrintWriter(channel.getOutputStream( ));
out.println(″string=″+sendMessage);
out.close( );
InputStreamReader urlStream=new
InputStreamReader(channel.getInputStream( )
);
BufferedReader in=new BufferedReader(urlStream);
String getMessage;
while ((getMessage=in.readLine( ))!=null)
System.out.println(getMessage);
in.close( );
urlStream.close( );
} catch (MalformedURLException e) {
System.err.println(″无法建立 URL″);
System.exit(1);
} catch (IOException e) {
System.err.println(″无法和服务器通信 ″);
System.exit(1);
}
}
}
从这个例子中我们归纳出向服务器发送信息的步骤：
（ 1） 创建 URL对象；
（ 2） 建立连接到 URL对象的通道；
（ 3） 指定这个通道可输出；
（ 4） 指定通道所用的输出流，输出流将和服务器的标准输入流连接；
（ 5） 向输出流写入数据；
（ 6） 关闭输出流。
1.3.6 利用 Socket和服务器交互
URL可建立高层即应用层连接，而 Socket可用来建立低层连接，它们都是基于 TCP协议的。连接双向数据通道的端点称为 Socket，常用于编写客户机 /服务器应用程序。 Socket要和一个端口号捆绑在一起，所以又称为套接字，因为端口号是用一个数字来表示的。
这种双向通信要在服务器端和客户机端分别编程并分别运行。服务器端首先要建立一个
ServerSocket，以指定端口号并监听客户机的请求，还要建立一个 Socket用来和客户机通信。客户机端则要建立套接到同一个端口的 Socket以便和服务器通信。
例 1-10两台计算机进行聊天，下面是服务器端程序。下图是服务器收发信息的情况，下页图是客户机收发信息的情况。
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
public class Server extends Frame implements
ActionListener {
Label label=new Label(″交谈 ″);
Panel panel=new Panel( );
TextField tf=new TextField(10);
TextArea ta=new TextArea( );
ServerSocket server;
Socket client;
InputStream in;
OutputStream out;
public Server( ) {
super(″服务器 ″);
setSize(250,250);
panel.add(label);
panel.add(tf);
tf.addActionListener(this);
add(″North″,panel);
add(″Center″,ta);
addWindowListener(new WindowAdapter( ) {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
} );
show( );
try {
server=new ServerSocket(4000);
client=server.accept( );
ta.append(″已连接的客户机：
″+client.getInetAddress( ).getHostName( )+″＼ n＼ n″);
in=client.getInputStream( );
out=client.getOutputStream( );
} catch (IOException ioe) {}
while(true) {
try {
byte［］ buf=new byte［ 256］ ;
in.read(buf);
String str=new String(buf);
ta.append(″客户机说,″+str);
ta.append(″＼ n″);
} catch (IOException e) {}
}
}
public void actionPerformed(ActionEvent e) {
try {
String str=tf.getText( );
byte［］ buf=str.getBytes( );
tf.setText(null);
out.write(buf);
ta.append(″我说,″+str);
ta.append(″＼ n″);
} catch (IOException ioe) {}
}
public static void main(String［］ args) {
new Server( );
}
}
在构造方法的开始部分设定了窗口的基本属性，
添加各种对象，并将自身注册为文本框的事件监听者。当用户在文本框里按下回车键时将激发键盘动作事件，程序定义了该事件处理方法。使用匿名类为窗口添加关闭功能。
构造方法的第二部分是一个 try...catch块，包含了服务器端编程的关键内容。创建了一个
ServerSocket对象 server并指定端口 4000，然后建立 Socket对象 client，这个对象不能用构造方法创建，是由 server的 accept方法创建的。创建过程是这样的：服务器程序运行后，将处于阻塞状态，一直等到一个客户机连接到这个端口，服务器端的 client就和这个客户机联系起来了，也就是说双向通道此时才建成。
client的 getInputStream和 getOutputStream方法可以创建输入流和输出流，我们将输入流 in和输出流 out分别与它们对接。
构造方法的最后部分是一个条件恒为真的 while循环，其中包含一个 try...catch块，其作用是重复接收客户机发来的信息，将接收的字节流转换成字符串显示出来。
在键盘动作事件处理方法中，主要是把用户在文本框输入的内容发送给客户机。文本框的内容先转换成字节数组，然后将这个字节数组写入输出流，发送给客户机。最后将已发送的内容显示在文本区中。
例 1-11客户机端程序，和服务器聊天，参见下图。
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
public class Client extends Frame implements
ActionListener {
Label label=new Label(″交谈 ″);
panel panel=new Panel( );
TextField tf=new TextField(10);
TextArea ta=new TextArea( );
Socket client;
InputStream in;
OutputStream out;
public Client( ) {
super(″客户机 ″);
setSize(250,250);
panel.add(label);
panel.add(tf);
tf.addActionListener(this);
add(″North″,panel);
add(″Center″,ta);
addWindowListener(new WindowAdapter( ) {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
} );
show( );
try {
client=new Socket(InetAddress.getLocalHost( ),4000);
ta.append(″已连接到服务器：
″+client.getInetAddress( ).getHostName( )+″＼ n＼ n″);
in=client.getInputStream( );
out=client.getOutputStream( );
} catch (IOException ioe) {}
while(true) {
try {
byte［］ buf=new byte［ 256］ ;
in.read(buf);
String str=new String(buf);
ta.append(″服务器说,″+str);
ta.append(″＼ n″);
} catch (IOException e) {}
}
}
public void actionPerformed(ActionEvent e) {
try {
String str=tf.getText( );
byte［］ buf=str.getBytes( );
tf.setText(null);
out.write(buf);
ta.append(″我说,″+str);
ta.append(″＼ n″);
}
catch (IOException ioe) {}
}
public static void main(String［］ args) {
new Client( );
}
}
客户机程序和服务器程序在窗口方面的设计完全一样，信息的接收和发送处理也基本相同，差别主要在于通信连接方面。
注意：首先运行服务器程序，然后运行客户机程序，这要打开两个 MS DOS窗口才能实现同步运行。如果先运行客户机程序或服务器没有准备好，
Java虚拟机将会抛出找不到服务器异常。
如何指定端口号呢？这里服务器起主要作用，客户机只要和服务器保持一致即可。指定端口号时要遵循一个原则，不要使用 1024以内的端口，它们是被系统保留的，如下：
07号端口为默认的服务端口，提供常用服务；
80号是 WWW服务端口；
25号是电子邮件服务端口；
21号是 ftp端口；
513号是远程登录端口。
1.3.7 利用 Datagram和服务器交互
有很多应用并不需要维持一个固定连接，如收发电子邮件就不需要在两台计算机上建立固定信息通道，发信人一旦发出邮件就可断开网络连接，收信人则可在任意时间接收邮件。这种情况下，使用基于无连接的数据报 Datagram
就比较合适，而且更加简单。数据报是独立的、内含地址信息的数据包，它的到达、到达时间和内容都没有保证，
但资源占用较少。
Java有两个数据报类,DatagramSocket和
DatagramPacket，程序可通过
DatagramSocket收发 DatagramPacket，
DatagramPacket也可以利用广播的方式向多台计算机发送。
例 1-12服务器端程序，接收客户机信息也向客户机发送信息。图 1.12是服务器收发信息的情况，
图 1.13是客户机收发信息的情况。
图 1.12
图 1.13
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
public class DataServer extends Frame {
TextArea ta=new TextArea( );
DatagramSocket in,out;
DatagramPacket dataIn,dataOut;
public DataServer( ) {
super(″服务器 ″);
setSize(250,200);
add(″Center″,ta);
addWindowListener(new WindowAdapter( ) {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
} );
show( );
try {
out=new DatagramSocket( );
in=new DatagramSocket(4000);
byte data［］ =new byte［ 256］ ;
dataIn=new DatagramPacket(data,data.length);
in.receive(dataIn);
String str=new String(dataIn.getData( ));
ta.append(″已收到数据包：＼ n″);
ta.append(″主机,″+dataIn.getAddress( )+″＼ n″);
ta.append(″端口,″+dataIn.getPort( )+″＼ n″);
ta.append(″长度,″+dataIn.getLength( )+″＼ n″);
ta.append(″内容,″+str);
str=″信息已收到 ″;
byte b［］ =str.getBytes( );
dataOut=new
DatagramPacket(b,b.length,dataIn.getAddress( ),5000
);
out.send(dataOut);
ta.append(″＼ n＼ n向客户机发送确认信息 ″);
ta.append(″＼ n数据包已发送 ″);
} catch (IOException ioe) {}
}
public static void main(String［］ args) {
new DataServer( );
}
}
定义一个字节数组，长度为 256个字节。创建接收数据包对象 dataIn时，使用字节数组为数据包的缓冲区。然后调用输入口 in的 receive方法监听客户机的连接，输入口 in只监听 4000号端口，一旦有数据传递过来，就把它们存入 dataIn的缓冲区里。
数据包有很多方法,getData可取出数据、
getAddress返回客户机的地址,getPort返回客户机发送数据使用的端口号,getLength返回数据长度。程序取出了这些参数并显示在文本区中。
最后，向客户机发送确认信息，表明数据已经收到。创建发送数据包 dataOut时，使用了已经准备好的字节数组，包含的信息是转换以后的字符串“信息已收到”。构造方法中有 4个参数：字节数组、字节数组的长度、客户机地址（这里用
dataIn包含的地址）、客户机上指定的接收端口号 5000。 dataOut创建以后，调用输出口 out的
send方法发送出去。
例 1-13 客户机端程序，接收服务器信息也向服务器发送信息。参见图 1.13。
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
public class DataClient extends Frame implements
ActionListener {
Label label=new Label(″信息 ″);
Panel panel=new Panel( );
TextField tf=new TextField(10);
TextArea ta=new TextArea( );
DatagramSocket in,out;
DatagramPacket dataIn,dataOut;
public DataClient( ) {
super(″客户机 ″);
setSize(250,200);
panel.add(label);
panel.add(tf);
tf.addActionListener(this);
add(″North″,panel);
add(″Center″,ta);
addWindowListener(new WindowAdapter( ) {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
} );
show( );
try {
out=new DatagramSocket( );
in=new DatagramSocket(5000);
byte data［］ =new byte［ 256］ ;
dataIn=new DatagramPacket(data,data.length);
in.receive(dataIn);
String str=new String(dataIn.getData( ));
ta.append(″已收到数据包：＼ n″);
ta.append(″主机,″+dataIn.getAddress( )+″＼ n″);
ta.append(″端口,″+dataIn.getPort( )+″＼ n″);
ta.append(″长度,″+dataIn.getLength( )+″＼ n″);
ta.append(″内容,″+str);
} catch (IOException ioe) {}
}
public void actionPerformed(ActionEvent e) {
try {
String str=tf.getText( );
byte b［］ =str.getBytes( );
dataOut=new
DatagramPacket(b,b.length,InetAddress.getLocalHos
t( ),4000);
out.send(dataOut);
ta.append(″数据包内容,″+str+″＼ n″);
ta.append(″数据包已发送＼ n＼ n″);
} catch (IOException ioe) {}
}
public static void main(String［］ args) {
new DataClient( );
}
}
客户机程序和服务器程序基本相同，差别有以下几个方面：客户机添加了文本框以输入要发送的信息；在键盘动作事件处理方法中发送信息，使用本地主机地址，并发送到服务器指定端口 4000；
客户机指定的接收口为 5000。
注意：这两个程序的运行次序无限制，但也要在两个 MS-DOS窗口分别运行。运行以后各自处于监听状态，客户机可以主动发出信息，服务器收到信息后会自动发送一个确认信息。从图中可以看到，客户机发送信息时使用的是 4714端口，而服务器发送信息时使用的是 4713端口。
１,４ ＶＢ下 Winsock编程利用 Winsock控件编写简单的客户 —服务器程序
(1)服务器程序在 UDP的 2000端口守候客户的请求信息收到客户的,Date”请求：响应日期收到客户的,Time”请求：响应时间
(2)客户程序发送,Date”和,Time”请求显示收到的响应服务器程序的编写（ 1）
服务器程序的编写（ 2）
服务器程序的编写（ 3）
服务器程序的编写（ 4）
服务器程序的编写（ 5）
服务器程序的编写（ 6）
服务器程序的编写（ 7）
服务器程序的编写（ 8）
服务器程序的编写（ 9）
服务器程序的编写（ 10）
服务器程序的编写（ 11）
客户程序的编写（ 1）
客户程序的编写（ 2）
客户程序的编写（ 3）
客户程序的编写（ 4）
客户程序的编写（ 5）
客户程序的编写（ 6）
客户程序的编写（ 7）
客户程序的编写（ 8）
客户程序的编写（ 9）
客户程序的编写（ 10）
客户程序的编写（ 11）
客户程序的编写（ 12）
测试编写的客户 —服务器程序（ 1）
测试编写的客户 —服务器程序（ 2）
作业用 c语言编写实现联通短信协议 SGIP
要求：
1、客户端程序和服务器端程序都要实现
2、每组 3-5人，自由组合
3、本课程结束前交（ 6月 15日前）
4、组之间程序不能抄袭，对于 90%以上代码相同者没有成绩第二章 客户 /服务器模式程序设计客户机 服务器呼叫：请求服务应答：响应请求几乎所有应用层服务都采用客户 /服务器模式，
服务通过两个进程分工合作完成：一个主动请求、一个被动响应；一个启动通信，一个等待通信。
在这里，“客户” 和“服务器”指的是运行程序，它们一般运行在不同的主机中，但也可以位于同一台主机中。
客户程序和服务器程序特性对比客户程序和服务器程序特性对比举例
２,1 数据库连接
ODBC (Open Database Connectivity)
OLE DB 和 ADO
JDBC
OLE DB
OLE DB 是新的低层接口，它介绍了一种“通用的”数据访问范例。也就是说,OLE DB 并不局限于 ISAM,Jet 甚至关系数据源，但是它能够处理任何类型的数据，而不考虑它们的格式和存储方法。在实际应用中，这种多样性意味着可以访问驻留在 Excel 电子数据表、文本文件甚至邮件服务器，诸如
Microsoft Exchange 中的数据。
在 Visual Basic 6.0 中，可以通过 ADO,OLE DB 的程序员接口，调整 OLE DB 的灵活性。甚至可以在 Visual Basic 中创建自己的 OLE DB 提供程序。
OLE DB 和 ADO
由于接口比较复杂，不能在 Visual Basic 中直接访问
OLE DB。 ActiveX 数据对象 (ADO) 封装并且实际上实现了 OLE DB 的所有功能。
ADO 概述
ADO（ ActiveX Data Objects）是基于组件的数据库编程接口，
它是一个和编程语言无关的 COM组件系统。
Microsoft ActiveX Data Objects (ADO) 使得客户端应用程序能够通过任何 OLE.DB 提供者来访问和操作数据库服务器中的数据。
ADO 使您能够编写应用程序以通过 OLE.DB 提供者访问和操作数据库服务器中的数据。 ADO 最主要的优点是易于使用、
速度快、内存支出少和磁盘遗迹小。 ADO 支持建立客户端 /服务器和基于 Web 的应用程序的关键功能。
ADO 的另一个功能是“远程数据访问” (RDS)，能够通过一个来回的传输将数据从服务器移动到客户端应用程序或 Web
页中，然后在客户端对数据进行操作，最后将更新数据返回服务器。 RDS 先前发布的版本是 Microsoft Remote Data
Service 1.5。 RDS 已与 ADO 编程模块合并以简化客户端数据的远程调用。
ADO 对象编程模型连接数据源 (Connection)，可选择开始事务。
可选择创建表示 SQL 命令的对象 (Command)。
可选择指定列、表以及 SQL 命令中的值作为变量参数
(Parameter)。
执行命令（ Command,Connection 或 Recordset）。
如果命令以行返回，将行存储在存储对象中 (Recordset)。
可选择创建存储对象的视图以便进行排序、筛选和定位数据 (Recordset)。
编辑数据。可以添加、删除或更改行、列 (Recordset)。
在适当情况下，可以使用存储对象中的变更对数据源进行更新 (Recordset)。
在使用事务之后，可以接受或拒绝在事务中所做的更改。
结束事务 (Connection)。
ADO 对象编程步骤
1,连接数据源。
2,可选择创建表示 SQL 查询命令的对象。
3,可选择在 SQL 命令中将值作为变量参数。
4,执行命令。如果命令以行返回，将行存储在存储对象中。
5,可选择对数据进行定位、检查、操作和编辑。
6,适当情况下，可以使用存储对象中的变更对数据源进行更新。可选择在事务处理中嵌入更新数据。
7,在使用事务之后，可以接受或拒绝在事务中所做的更改。
结束事务。
ADO 和 RDO,DAO 的比较
ADO 并不是自动和您现存的数据访问应用程序代码兼容的。当 ADO
封装 DAO 和 RDO 的功能的时候，您必须将许多语言要素转换为
ADO 语法。在某些情况下，这将意味着您现存代码的某些功能的一个简单转换。在其他情况下，最佳的做法可能是用 ADO 的新功能重写该应用程序。
DAO (Data Access Objects) 数据访问对象是第一个面向对象的接口，
它显露了 Microsoft Jet 数据库引擎（由 Microsoft Access 所使用），并允许 Visual Basic 开发者通过 ODBC 象直接连接到其他数据库一样，直接连接到 Access 表。 DAO 最适用于单系统应用程序或小范围本地分布使用。
RDO (Remote Data Objects) 远程数据对象是一个到 ODBC 的、面向对象的数据访问接口，它同易于使用的 DAO style组合在一起，提供了一个接口，形式上展示出所有 ODBC 的底层功能和灵活性。尽管 RDO 在很好地访问 Jet 或 ISAM 数据库方面受到限制，而且它只能通过现存的 ODBC 驱动程序来访问关系数据库。但是,RDO 已被证明是许多 SQL Server,Oracle 以及其他大型关系数据库开发者经常选用的最佳接口。 RDO 提供了用来访问存储过程和复杂结果集的更多和更复杂的对象、属性，以及方法。
ADO 和 RDO,DAO 的比较
ADO 是 DAO/RDO 的后继产物。 ADO 2.0在功能上与 RDO 更相似，而且一般来说，在这两种模型之间有一种相似的映射关系。 ADO,扩展”了 DAO
和 RDO 所使用的对象模型，这意味着它包含较少的对象、更多的属性、方法（和参数），以及事件。例如,ADO 没有与 rdoEngine 和
rdoEnvironment 对象相等同的对象，可以显露 ODBC 驱动程序管理器和
hEnv 接口。尽管事实上您的接口可能是通过 ODBC OLE DB 服务提供程序实现的，但您当前也不能从 ADO 中创建 ODBC 数据源。
包含在 DAO 和 RDO 模型中的许多功能被合并为单个对象，这样就生成了一个简单得多的对象模型。然而，由于这个原因，起初您可能会觉得找到合适的 ADO 对象、集合、属性、方法，或事件非常困难。与 DAO 和 RDO不同的是，尽管 ADO 对象是分层结构的，但在分层结构范围之外也是可以创建的。
不过，也应当注意,ADO 当前并不支持 DAO 的所有功能。 ADO 主要包括
RDO 风格的功能性，以便和 OLE DB 数据源交互，另外还包括远程和
DHTML 技术。
一般说来，在 ADO 的演化过程中，马上把大多数 DAO 应用程序（ except
possibly是那些使用 ODBCDirect 的应用程序）移植到 ADO 上可能为时太早，因为当前的 ADO 并不支持数据定义 (DDL)、用户、组，等等。不过，
如果您只将 DAO 用于客户 —服务器应用程序，而并不依赖于 Jet 数据库引擎或不使用 DDL，那么您现在就可能移植到 ADO。最终,Microsoft 将提供一个 ADO DDL 部件来帮助进行 DAO 到 ADO 的移植，并为 OLE DB 供应
２,２ 程序设计第三章 浏览器／服务器模式程序设计
3.1 WWW基础
Web服务器
Web浏览器
Cookies
统一资源定位器 URL
超文本传输协议 HTTP
超文本标记语言 HTML
样式表 CSS
动态 Web文档及相关技术
Web服务器
Web服务器发布的文档称为 Web页,即网页。 Web
页一般是超文本文档，除文本外它包含指向其它
Web页的 超链接 (指针 )。
一个 Web服务器上超文本文档的全体一般包括多个
Web页，这组 Web页以意义相关的方式链接在一起，
这组 Web页的顶页称为 主页 (home page),它是浏览这组 Web页的起点，它的位置用统一资源定位器
URL描述。
主页一般通过超链接提供对服务器上其它 Web页的访问。
Web服务器 (续 )
主页超链接 超链接
Web页的层次式链接
Web服务器 (续 )
Web没有整体结构，它是世界范围所有 Web服务器上的 Web页集合 。 唯一把 Web页捆绑在一起的是超链接 。
Web页用 HTML 语言书写 。
在 Web服务器准备好 Web页后，需要下载一个
HTTP服务器程序，这可以从环球信息网协会的主页 (http://www.w3.org/)查到。 Apache软件基金会提供源代码开放的 HTTP服务器程序。 Apache 的主页在 http://www.apache.org/。
Web服务器 (续 )
Web服务器在 TCP端口 80 侦听来自 Web浏览器的连接请求。
当浏览器要求某 Web服务器上特定的文档时，它向该服务器 80端口发起 TCP连接请求，连接建立起来后，浏览器发送该文档请求，服务器抓取该文档发给浏览器。
一种特殊的 Web服务器称为 代理 (proxy)。安全代理如防火墙，缓存代理 (cache proxy)常用来改进
WWW的性能。
Web浏览器
Web浏览器的基本功能是 导航 和 浏览 。导航是根据给定超链接在 Web中穿梭航行，并从 Web服务器获取 Web页；浏览是解释和显示 Web页。
导航是执行 HTTP协议；浏览是解释 HTML语言。
超链接所包含的指针是用统一资源定位器 URL来描述的。
Web页上超链接的显示常被加亮，且常带下划线。
当用户鼠标停留其上时，光标会变成手指形，单击它，将去抓取并显示其指向的 Web页。
Web浏览器 (续 )
启动 Web浏览器时，它抓取和显示的第一个 Web页称为,(浏览器的 )主页 (home page)”。
浏览器的“前进 (forward)”、“后退 (back)”、“主页
(home)”、“收藏 (bookmak)”、“历史 (history)”等按钮。
大多数浏览器可处理 GIF(Graphic Interchange
Format)和 JPEG(Joint Photographic Experts
Group)压缩图象格式,GIF89a和渐进式 JPEG
(Progressive JPEG)允许浏览器以交织方式下载和显示图象，先看到粗轮廓，再填入细节。
Web浏览器 (续 )----浏览器的结构
Cookies(特殊字符串 )
用于解决 HTTP的一次连接的特性，
让独立的连接建立起联系。用途客户机 服务器
N次连接
S 把结果发回，无须对 C 再进行身份认证第一次 C S 口令、密码判断正确后 S C 正常结果和额外信息第二次 C S 同时把接收的 Cookies发回统一资源定位器 URL
在 Web中 Internet的资源或对象都用 URL描述。
URL （ Uniform Resource Locator） 的格式,
“访问方法,说明采用什么协议,
http 超文本传送协议 HTTP
ftp 文件传送协议 FTP
telnet 用于交互式会话
mailto 电子邮件地址
Gopher Gopher协议
News USENET新闻
file 特定主机的文件名访问方式,// 服务器域名 [:端口号 ]/ 路径 /文件名
Web的工作方式
Disk
Disk
客户服务器
www.edu.cn
超链接 服务器sina.com超链接
Internet
超文本传输协议 HTTP
目前浏览器和服务器大多使用 HTTP/1.0或 1.1。
Web浏览器和服务器之间需要可靠的双向字节流传输,HTTP是建立在 TCP之上的应用层协议。
HTTP基于客户和服务器进程通信的基本模式，即请求 /回答模式 。
Web浏览器和 Web服务器之间的交互步骤：
1.浏览器确定 Web页的 URL,如 http://www.edu.cn/。
2.浏览器请求域名服务器解析 www.edu.cn的 IP地址，
例如为 202.112.0.36。
超文本传输协议 HTTP(续 )
3.浏览器向 202.112.0.36的 80端口发起 TCP连接 。
4.TCP连接建立后，浏览器发送请求报文，例如
,GET /index.html”。
5.Web服务器 202.112.0.36发回 Web页 index.html。
6*,服务器 关闭 TCP连接 。
7.浏览器显示 Web页 index.html中的文本。
8*,浏览器为该页上每个图象与 202.112.0.36建立一个新的 TCP连接 。
9.浏览器发送请求报文，从服务器获得并显示图。
超文本传输协议 HTTP(续 )
加 *的步骤在 HTTP/1.1中不需要。 HTTP/1.0中浏览器为每个 HTTP请求与服务器进程建立一个新 TCP
连接，一般是打开连接、传输文档、关闭连接。每个 HTTP请求独立处理，简单但效率低。 HTTP/1.1
作了改进,6和 8不再需要。
HTTP请求报文包括一个请求行，若干报文头，可能带报文体，报文体与报文头以空行分隔。
HTTP回答报文包括一个状态行，若干报文头，并可能在空行后带报文体。
超文本传输协议 HTTP(续 )
HTTP请求报文 结构请求报文 响应报文请求行通用首部请求首部实体首部实体主体状态行通用首部响应首部实体首部实体主体超文本传送协议 HTTP（续）
(1) 请求行 (Request-Line)
* 包含：方法,URL以及 HTTP版本；
* 方法,对所请求对象的操作,共 14种,如 GET、
PUT,DELETE等。
(2) 通用首部 (General-Header)
对 请 求 和 响 应 报 文 都 适 用,8 种,如
Connection、
Keep-Alive等。
超文本传输协议 HTTP(续 )
(3) 请求首部 (Request-Header)
说明浏览器的信息,13种,如 Accept,From
(4)状态行 (Status-Line)
版本,状态码及解释状态码的短语,状态码,
5类 33种,如 200(OK),400(Bad Request)等
(5) 响应首部 (Response-Header)
6个可选字段，如 Location。
超文本传输协议 HTTP(续 )
(6) 实体首部 (Entity-Header)
请求和响应报文都适用,16种,如 Allow、
Content-encoding,Content-length、
Content-type,Transfer-encoding等 。
(7) 实体主体 （ Entity-Body）
请求和响应报文的实体主体均可包含任意长度的字节序列 。
HTTP请求报文例
GET /pub/www/TheProject.html HTTP/1.0
Referer,http://www.w3.org/
From,abc@tsinghua.edu.cn
If-Modified-Since,Thu,1 Dec 1998 15:00:00 GMT
User-Agent,CERN-LineMode/2.15
这是检索请求。请求报文的第一行是请求行，请求行中指明方法 GET、文档路径名,HTTP版本。报文头 Referer中指明从哪个 URL取文档。 If-Modified-
Since说明是条件 GET请求 … 。
HTTP回答报文例
HTTP/1.0 200 OK 状态行,状态码 2xx是成功。
Server,CERN3.0 指明 HTTP服务器软件
MIME-Version,1.0 MIME报文头
Content-Type,text/html
Content-Length,6078
<HTML> 报文体 (服务器下载的文这里是文档 档 )
</HTML>
HTTP的改进
HTTP/1.0 以前的版本最大的问题是效率低：浏览器先检索文档，然后对每个图象再建立 TCP连接，
再发检索请求。每个 HTTP的请求 -回答,TCP连接三次握手,TCP连接关闭，有一些重迭是可能的，
最少的检索是 4个网络往返时间。
浏览器曾对含有大量图象的页面同时打开几个 TCP
连接并行检索。但每个连接持续时间短，由于 TCP
的慢启动，很多连接都以低速使用。
在 HTTP/1.1中 持续连接 是默认的设置,即一个
TCP连接可以传输多个 HTTP请求 -回答 。,..
超文本标记语言 HTML
HTML(HyperText Markup Language)源于 1986年
ISO8879中制订的标准通用化标记语言
SGML(Standard Generalized Markup Language)。
SGML的基本原理是文档的描述应基于内容而不是外观。 HTML多少偏离了此点。
HTML从 1990年开始被 Web使用,HTML第 1个正式标准是 IETF完成的 HTML2.0。后来 HTML的标准化工作由 W3C负责，第 2个正式建议是 HTML3.2，后面的正式建议是 HTML4.0。
XML(eXtensible Markup Language)
超文本标记语言 HTML(续 )
HTML是简单的标记语言，它主要用于描述 Web文档的结构，是结构化的标注语言,HTML代码可以影响文档的版面。
HTML文档由 HTML标记 (tag)和普通文本组成。
HTML标记封装在,<”和,>”中，不区分大小写字母，大部分标记成对出现，如 <table> 和 </table>
是一对标记，分别称开始和结束标记，把它影响的文本括在中间。也有一些是单元素标记，如 <img>
是图象元素的开始标记。
超文本标记语言 HTML(续 )
许多标记附有必需的或可选的 属性 (attribute)，它给浏览器关于标记如何解释提供进一步信息。属性在开始标记中，形式为“属性名 =属性值”，属性用空格分开。例如
<table border=“2” cellspacing=“20”>…</table> 。
HTML—常用标记
1,HTML的格式与标签标签 描述
< HTM L>? < / HTM L> 声明是用 HTM L 编写的万维网文档
< HEA D >? < / HEA D > 页面首部
< TI TLE>? < / TI TLE> 定义标题，不在浏览器的显示窗口显示
< BOOY >? < / BOD Y > 页面主体
< Hn >? < / Hn > n 级标题,n= 1 ~ 6,1 级最高
< B>? < / B> 设置为粗体字
< I >? < / I > 设置为斜体字
< U L>? < / U L> 设置为无序的列表，每一表项前出现一个园点
< OL>? < / OL> 设置为有序的列表，每一表项前有一个编号
< M EN U >? < / M E NU> 设置为菜单
< LI > 表项的开始，可不用 < / LI > )
< BR > 换行
< P > 一段的开始
< HR > 水平线
< P R E>? < / P R E> 预格式化文本，浏览器显示时不需要重新排版
< I M G SR C =,?” 装载图象文件
< A HR EF =,?” >? < /A > 定义超链接
2,HTML的超链
标签,<A>,A(Anchor),锚,扎到超链的终点 。
<A HREF =,terminal-URL” > start < /A >
<A HREF=,http://www.gxut.edu.cn” >
广西工学院 < /A >
远程链接,本地链接
命名锚 (named anchor),链接到同一文件中某处定义命名锚 （ 链接的终点 ）,
<A NAME =,namedanchor” >
terminal-characters </A>
链接到一个命名锚：
<A HREF =,# named anchor” > start < /A >
HTML—文体标记
HTML标记可分成两大类：文体标记和结构标记。
文体标记 给出元素的显示指令，如,<B>：
黑体文本 <I>：斜体文本
<FONT face=字体 >：
规定字体,face是属性名 <FONT size=n>：规定字体大小,size是属性名 <FONT color=颜色 >：规定字体颜色 <SUB>：下标
<SUP>：上标
<STYLE>：文体信息
HTML—文体标记 (续 )
例如，在 HTML文档中：
<I> 第一项定义 </I>
浏览器将显示：
第一项定义
HTML—结构标记
结构标记 描述文档的各个部分：头、章节、段落、
表格、图象、超链接等。结构标记分成：
1.基本结构标记,<html>,<head>,<title>,<body>
2.列表标记,<OL>：编号顺序列表
<UL>：无序列表，如,?”打头的表
<LI>：列表项
<DL>：定义列表
<DT>：定义项
<DD>：定义描述
HTML—结构标记 (续 )
3.段落标记,<p>：标注段落开始
4.超链接标记,<a 属性 >
5.图象标记,<img src=“图象文件名或 URL”>
6.表格排列标记,<table>,<tr>,<th>,<td>等
HTML—基本结构标记
—HTML文档的一般形式
<html>
<head>
<title> 文档名称 </title>
<h1> 1 级标题 </h1>
<h2> 2 级标题 < /h2>..,</head>
<body>
<p> 文档段落 …
</body>
</html>
HTML—基本结构标记 (续 )
Web文档有两个主要部分,文档头 和 文档体 。
文档头给出文档的总体信息。 <head>和 </head>标注文档头的开始和结束。括在文档头中的信息有
<title>和 </title>标注的文档名称。文档名称在页面中不显示，一般做浏览器窗口标题；当在浏览器中加入 bookmark时，用它标识此页。
文档体是显示在浏览器窗口的信息。 <body>和
</body>标注文档体的开始和结束。
HTML—列表标记
<UL>标注无序列表，每个表项都用 <LI>标记，
</LI>可省略。如：
<UL>
<LI>表项 1
<LI>表项 2
</UL>
在浏览器上显示为,? 表项 1
表项 2
HTML—列表标记 (续 )
<OL>标注编号顺序列表，每个表项都用 <LI>标记，
</LI>可省略。如：
<OL type=“a” start=“9”>
<LI>表项 1
<LI>表项 2
</OL>
在浏览器上显示为,i,表项 1
j,表项 2
HTML—列表标记 (续 )
定义列表用 <DL>标记,<DT>标记定义项，
定义项左对齐,<DD>标记表项的定义。如：
<DL> <DT> <B> 第一项 </B>
<DD> <I> 第一项的定义 </I>
<DT> <B> 第二项 </B>
<DD> <I> 第二项的定义 </I>
</DL>
在浏览器上显示为,第一项第一项的定义第二项第二项的定义
HTML—超链接标记
超文本功能的关键是超链接标记 <a>，也称锚
(anchor)标记，它是 HTML的核心。
超链接标记的语法是：
<a HREF=“URL 或文件名” > 锚文本 </a>
其中 HREF指超文本引用 (Hypertext
REFerence)，它指定此超链接指向的 URL或本机的文件名。锚文本 (anchor-text)是该超链接在 Web页上显示的文本。例如：
<a HREF=“http://www.edu.cn/”>教育网 </a>
HTML—图象标记
Web页上的图象用 HTML的图象标记表示，例如,
<img src=“../images/abc.gif,alt=“text”> 这里属性 src是必需的，它的值说明图象的位置。例中图象位置是用相对 URL来表示的。浏览器显示的图象是在该 Web页所在目录的父目录下的子目录 images
中的文件 abc.gif。属性 alt是可选的，若浏览器只支持文本则显示 text。
大部分浏览器可以处理 GIF和 JPEG压缩图象格式。
GIF和 JPEG都是位图，使用不同色调、明度的象素矩阵来创建图。
HTML—图象标记 (续 )
图象交换格式 GIF(Graphics Interchange Format)是由 CompuServe创建的，它是 8位彩色 (256色 )的压缩位图 (bit map)格式。老版本是 GIF87a，新版本是
GIF89a。 GIF采用无损压缩，所以文件大，但图象质量不会下降。
JPEG是由 ISO的 Joint Photographic Experts Group
开发的，一般用于照片图象，可支持 24位彩色 (16.7
百万色 )。 JPEG对非本质的图象信息进行压缩，这类称为有损压缩，压缩程度高，但图象质量会下降。
新版本是渐进式 JPEG。
HTML—表格排列标记
表格 (table)是在 HTML3.2中引入的扩展，也许设计者本来只是为了提供传统的表格功能，但使用者很快就用它来为 Web页面作结构布局。
可以用 table标记说明表块的宽度，也可对页面作水平分隔或垂直分隔，分隔的表格单元 (table cell)中可包含文本或图。
与表格有关的标记有：
<table> </table> 给表格所有标记规定公共属性
border=“n” 表边的宽
cellspacing=“n” 表格单元之间的空间
HTML—表格排列标记 (续 )
<TR> </TR> 创建一个新表格行，属性如
align=“left”,“right”,“center” 水平位置调整
valign=“top”,“middle”,“bottom”垂直位置调整
<TH> </TH> 标注每个表格单元的头部
<TD> </TD> 标注每个表格单元的数据
align=“left”,“right”,“center” 数据位置调整
hight=“n” 表格单元高度
width=“n” 表格单元宽度
colspan=n 表格单元所跨列数
HTML—表格排列标记 —例
<table border=“10” cellspacing=“20”>
<tr valign=“top”>
<td align=“left” width=“270” hight=“400”>
…</td>
<td align=“left” width=“270”>
…</td>
</tr>
<tr align=“center”>
<td colspan=2>
…</td> </tr>
</table>
HTML—表格排列标记 —例
270
10 20
400
<td> <td>
<td>
<table>
样式表 CSS
样式表由样式规则组成,以告诉浏览器怎样去表现一个文档,有很多将样式规则加入到 HTML文档中的方法,但最简单的启动方法是使用 HTML的 STYLE
组件,这个元素放置于文档的 HEAD部分,包含网页的样式规则,
每个规则的组成包括一个 选择符 --通常是一个 HTML
的元素,例如 BODY,P,或 EM--和该选择符所接受的样式,
有很多的 属性 可以用于定义一个元素,每个属性带一个 值,共同地描述选择符应该如何呈现,
样式表 CSS----样式规则
样式规则组成如下,
选择符 { 属性,值 }
单一选择符的复合样式声明应该用分号隔开,
选择符 { 属性 1,值 1; 属性 2,值 2 }
例如,
H2 { font-size,large; color,blue }
样式表 CSS----基本语法
样式表由样式规则组成,以告诉浏览器怎样去表现一个文档,
有很多将样式规则加入到 HTML文档中的方法,但最简单的启动方法是使用 HTML的 STYLE组件,这个元素放置于文档的 HEAD部分,包含网页的样式规则,
每个规则的组成包括一个 选择符 --通常是一个 HTML的元素,
例如 BODY,P,或 EM--和该选择符所接受的样式,
有很多的 属性 可以用于定义一个元素,每个属性带一个 值,共同地描述选择符应该如何呈现,
样式规则组成如下,
选择符 { 属性,值 } 单一选择符的复合样式声明应该用分号隔开,
选择符 { 属性 1,值 1; 属性 2,值 2 }
样式表 CSS----基本语法动态 Web文档及相关技术
存储在 Web站点的 Web页基本上是静态文档，只需原封不动地下载。
但有些信息内容是动态变化的，如天气预报、股市行情。许多变化的信息以数据库形式存放，数据库信息不是 Web页的格式。当浏览器申请动态变化的数据库信息时，服务器并没有现成的 Web页，而需要运行程序访问所查询的数据库信息，生成 Web页再下载给浏览器，这称为动态 Web文档。有时还需提供一种交互的 Web页从用户获得信息，如填写表单返回。
动态 Web文档及相关技术 (续 )
创建动态、交互 Web页的方法是通过 Web编程。
Web程序分两类：服务器执行或由浏览器执行。
服务方应用和 CGI
客户方脚本
Java
服务方应用和 CGI
服务方应用有搜索引擎；
数据库访问；
布告牌系统 BBS；
表单处理。
公共网关接口 CGI(Common Gateway Interface)是
Web服务器和服务方应用之间的通信标准。遵循
CGI 标准的服务方应用常称为 CGI 应用。
服务方应用和 CGI(续 )
Web服务器 Web浏览器
CGI应用环境变量
(1)
(2) (3)
(4)
(6)
(5)
服务方应用和 CGI(续 )
(1) Web浏览器发送请求；
(2) Web服务器设置环境变量；
(3) Web服务器调用 CGI 应用；
(4) CGI应用得到环境变量，运行；
(5) CGI应用输出结果；
(6) Web服务器得到结果，发送到 Web浏览器。
服务方应用和 CGI(续 )
CGI 应用在 Web服务器运行，它由来自 Web
浏览器的请求或输入激活。例如 Web页中某标记 <A HREF=“http://www.onesite.edu/cgi-
bin/xx”>的属性 HREF的 URL指向一个 CGI
应用，当浏览器向服务器 www.onesite.edu
发送该请求时，服务器注意到它指向在目录
cgi-bin下某个 CGI 应用 xx (根据文件位置，路径或扩展名 )，就把请求报文头的信息放在环境变量中，启动该 CGI 应用。
服务方应用和 CGI(续 )
CGI应用可从环境变量取值,CGI应用执行后的输出结果送给 Web服务器，服务器形成
HTTP回答报文送给浏览器。
环境变量有：
SERVER_NAME Web服务器主机域名
SCRIPT_NAME URL中域名后的路径名 REMOTE_ADDR 浏览器所在主机的 IP
地址 REMOTE_HOST 浏览器所在主机的域名 QUERY_STRING URL中,?”后面的部分服务方应用和 CGI(续 )
CGI不是写 CGI应用的语言，可以使用任何程序语言或脚本语言来写 CGI应用。
最通用的写 CGI应用的语言是 Perl,C,C++,TCL，
UNIX,Shell,Java,Visual Basic等。
脚本和程序的区别在脚本是通过命令解释器来一行一行执行，而程序是编译后执行。
客户方脚本
由浏览器执行的是脚本 (script)，它嵌在 HTML文档中，下载到客户方的主机，由 Web浏览器执行。客户方脚本可创建活动图象，如飘动的旗帜，蹦蹦跳跳的动画。
JavaScript是第一个客户方脚本语言，是由
Netscape公司在 1996年开发的，它比 Java简单，
容易学。微软公司的 Jscript 和 VBScript。
客户方脚本可以放在 HTML文档的任何地方，用标记 <SCRIPT>和 </SCRIPT>括起来。子程序定义放在文档头，子程序调用放在文档体。
Java
Java 是 Sun Microsystem公司在 1990年开发的，创始人是 James Gosling。
Java 是一种新的程序设计语言，它面向对象，解释执行，有 TCP/IP网络功能。在 Web中 Java用于写活动文档。
Java 源程序经编译后，可以生成一种中间代码，称为字节代码 (bytecode)。这种字节代码应用程序称为 applet，它可以放在 HTML文档中。有 Java解释器的 Web浏览器可从服务器下载并执行 applet。
Applet独立于计算机硬件，可移植。
Java(续 )
Java 源程序一般使用扩展名,.java”，编译后的字节代码一般使用扩展名,.class”。
在 Web页中用 <applet>和 </applet>指明某个字节代码应用。例如：
<APPLET code=“HelloWorld.class” width=“200”
hight=“20”> </APPLET>
指出一个浏览器应下载的 Java applet 在文件
HelloWorld.class，属性 width 和 hight 规定此应用的窗口宽和高。
3.2 JavaScript脚本语言
JavaScript语言简介
JavaScript语法基础
JavaScript内置对象与函数
JavaScript语言简介
JavaScript有关概念
JavaScript是一种 基于对象（ Object） 和 事件驱动（ Event Driven） 并具有安全性能的 脚本语言 。
JavaScript的特点是一种脚本编写语言：采用小程序段的方式实现编程。是一种 解释性语言。
简单性,首先它是一种基于 Java基本语句和控制流之上的简单而紧凑的设计，从而对于学习 Java是一种非常好的过渡。其次它的变量类型是采用弱类型，并未使用严格的数据类型。
安全性,它不允许访问本地的硬盘，只能通过浏览器实现信息浏览或动态交互。可以有效地防止数据的丢失。
动态性,JavaScript是动态的，它可以直接对用户或客户输入做出响应，无须经过 Web服务程序。它对用户的反映响应，是采用以事件驱动的方式进行的。
跨平台性,JavaScript是依赖于浏览器本向，与操作环境无关，
只要能运行浏览器的计算机，并支持 JavaScript的浏览器就可正确执行。
JavaScript与 Java的区别两者是两个公司开发的不同的两个产品。用途不同，前身不同；
基于对象和面向对象,Java是一种真正面向对象的语言；
JavaScript是一种脚本语言，是一种基于对象和事件驱动。
解释和编译,Java的源代码在传递到客户端执行之前，须经过编译，因而客户端上必须具有相应平台上的住址器或解释器，它可以通过编译器或解释器实现独立于某个特定的平台编译代码的束缚。而 JavaScript是一种解释性编程语言，其源代码在发往客户端执行之前不需经过编译，而是将文本格式的字符代码发送给客户端由浏览器解释执行。
JavaScript语言简介
强变量和弱变量,Java采取强变量类型，即所有变量在使用前必须进行声明；而在 JavaScript中，变量在使用前不需作声明，而是解释器在运行时检查其数据类型；如定义一个整型变量和一个字符型变量：
Java中：
int x; x=1234;
string y; y=1234;
JavaScript中：
x=1234;
y=“1234”;
代码格式不一样,Java是一种与 HTML无关的格式，必须通过像 HTML
中引用外媒体那样进行装载，其代码以字节代码的形式保存在独立的文档中。 JavaScript的代码是一种文本字符格式。可以直接嵌入 HTML
文档中。
var x=“123.3”;
var y=“5”;
x=x+y;
Alert(typeof(x));
JavaScript语言简介
嵌入方式不一样,
Java使用 <applet>… </applet>,JavaScript使用
<script>… </script>。
静态联编和动态联编：
Java的对象引用必须在编译时进行，以便强类型检查。
JavaScriptr的对象引用在运行时进行检查，如不经编译则就无法实现对象引用的检查。
JavaScript语言简介第一个 JavaScript程序
<html>
<head>
<Script Language ="JavaScript">
// JavaScript Appears here.
alert("这是第一个 JavaScript例子 !");
alert("欢迎你进入 JavaScript世界 !");
alert("今后我们将共同学习 JavaScript知识！ ");
</Script>
</Head>
</Html>
JavaScript代码的加入
<Script Language ="JavaScript">
JavaScript语言代码；
JavaScript语言代码 ;
....
</Script>
说明：
通过标识 <Script>...</Script>指明 JavaScript脚本源代码将放入其间。
通过属性 Language=“JavaScript”说明标识中是使用的何种语言，这里是 JavaScript语言，还可以其它脚本语言。
JavaScript语言简介
JavaScript语法基础
JavaScript基本数据结构
JavaScript程序构成
JavaScript程序实例
JavaScript脚本语言同其它语言一样，有它自身的基本数据类型、表达式和算术运算符以及程序的基本框架结构。
一,基本数据类型,
数值型 (Number)：可为整数或浮点数
字符串型 (String)：保存各种文本数据
布尔型 (Boolean)：只能是 true或 false
对象 (Object):例如 document,window,date等等，是一群属性的集合，每一个属性都有一个名称和值。而属性的数据类型可以是前面介绍的任一种
函数 (Function):为内置函数或用户自定义
空值 (Null)：
注：在 JavaScript中，一个数据的变量或常量不必首先作声明，而是在使用或赋值时确定其数据的类型的。
JavaScript基本数据结构
JavaScript基本数据结构二,常量整型常量：
实型常量：
布尔型：只有两种状态,True,False.主要用来说明或代表一种状态或标志，
以说明操作流程。
字符型常量：使用 ‘ 或,” 括起来的一个或几个字符。
空值,null，表示什么也没有特殊字符：同 C语言一样,JavaScript中同样以有些以 /开头的不可显示的特殊字符。通常称为控制字符。
三,变量用来存放数据、提供存放信息的容器。或可以看作：
代表某内存空间的名称对于变量必须明确变量的命名、变量的类型、变量的声明及变量的作用域。
变量的命名：字母、数字、下划线,不能以数字开头；不能使用关键字（保留字）。
变量的类型：即上述几种数据类型。
变量作用域：全局变量、局部变量。
定义新的变量名称：在 JavaScript中，可以使用 var命令来定义新的变量，若没有事先定义，则根据数据特性自动定义；
var text;
var high_score;
var count3 = 1;
var ErrorMessage = "Connect to host failed."
var daysLeft = 5.7;
var 82much = true; // 这行代码是有语法错误的。
Typeof可以用来查询某一变量的数据类型。
JavaScript的基本数据结构
JavaScript的基本数据结构数据类型转换
1.自动类型转换：
使用不同的运算符，产生的类型变化各不相同，其中，使用加法运算时，数据类型的变化情况如下：
操作数
1
操作符 操作数
2
结果
number + string String
boolea
n
+ string String
number + boolea
n
numbe
r
2.强制类型转换：
用来转换字符串类型的函数及其功能如下表所示：
函数 功能
parseInt 将字符串转换为整数
parseFlo
at
将字符串转换为浮点数函数 功能
eval 执行字符串的表达式
JavaScript的基本数据结构例 1,var n1=365;
Var n2=“12”;
n1=n1+n2;
alert(typeof(n1));
例 4.x=“10个人” ;
y=parseInt(x);
结果,y=10
例 7.x=“12.3+3.2”;
y=eval(x);
结果,y=15.5;
例 2.var n1=“3”;
Var n2=“4”;
n3=n1*n2;
alert(typeof(n3));
例 5.x=“73”;
y=parseInt(x,8);
结果,y=59
以八进制格式转换；
例 8.x1=3;x2=4;
x3=“x1>x2”;
y=eval(x3);
结果,y=false
例 3.x=“12.3”;
y=parseInt(x);
结果,y=12
例 6.x=“HOME”;
y=parseFloat(x);
结果,y=NaN;
Not a Number.
例 9.
x=“score=100”;
eval(x);
结果,score=100
JavaScript的基本数据结构内部变量与全局变量内部变量,指只有该段程序可以使用的变量名称，同时在该段程序代码结束后，
内部变量即推动作用。
全局变量,指其值一直被保留下来，且所有的程序可以共享并获得或改变其值的变量。
变量的生命期变量生命期,是指定义变量后，变量数据内容的保留期。全局变量和内部变量的生命期如下：
全局变量：直到离开网页文件；
内部变量：程序或函数执行结束；
例,<script language=“javascript”>
var a,b,c;//a,b,c为全局变量；
……
Function my_area(){
var x,y,z;//x,y,z为 my_area()的内部变量；
……
}</script>
JavaScript的基本数据结构四,表达式和运算符表达式：运算符和运算数组成的完成一定功能的式子。
运算符：分为赋值运算符、算术运算符、逻辑运算符、关系运算符、字符串运算符等。
算术运算符,+,-,*,/,%,-,++,--、（）
关系运算符,>,<,<=,>=,= =,!=
逻辑运算符：！,&&,||,&,^,|,~（后四种：位与、位异或、位或、位非）
赋值运算符,=,+=,-=,*=,/=,%=,&=,^=,|=,<<=,>>=,>>>=
字符串运算符,+（连接运算）,“
注释符号,//（单行）,/*和 */（可多行）
运算符的优先级,算术运算符 >字符串运算符 >关系运算符 >逻辑运算符。
JavaScript程序构成一、程序控制流
1.if条件语句格式 1：
If(表达式 )
{语句段 1}
Else{语句段 2}
…
功能：若表达式为
true,执行语句段 1；
否则执行语句段 2；
说明,if-else语句可以改变语句的执行顺序。
表达式中必须使用关系语句，来实现判断，
它是作为一个布尔值来估算的。它将零和非零的数分别转化成 false和 true。
若 if后的语句有多行，则必须使用花括号将其括起来。
举例,if(x==1){
y=100;z=50;}
else{
y=50;z=100;}
格式 2：
If(表达式 1)语句 1；
Else if(表达式 2)语句
2； …
说明,每一级的布尔表述式都会被计算，若为真，则执行其相应的语句，否则执行 else后的语句。
举例：
if(x==1)y=100;
JavaScript程序构成
2.for循环语句：
基本格式 功能 说明
For(初始化；条件；增量； )
语句集；
实现条件循环，
当条件成立时，
执行语句集，
否则跳出循环体。
初始化参数告诉循环的开始位置,必须赋予变量的初值 ；
条件：是用于判别循环停止时的条件。若条件满足，则执行循环体，否则跳出。
增量：主要定义循环控制变量在每次循环时按什么方式变化。
三个主要语句之间，必须使用分号分隔。
3.while循环语句：
基本格式 功能 说明
While(表达式 )语句集；
当条件为真时，重复循环，否则退出循环。
使用 For语句在处理有关数字时更易看懂，也较紧凑；而 while循环对复杂的语句效果更特别。
如果要中断 for循环的执行，可以使用 break命令，而执行循环的下一个值则使用 continue命令。
４,break和 continue语句与 C++语言相同，使用 break语句使得循环从 For或
while中跳出,continue使得跳过循环内剩余的语句而进入下一次循环。
二、函数：
JavaScript函数可以封装那些在程序中可能要多次用到的模块。并可作为事件驱动的结果而调用的程序。从而实现一个函数把它与事件驱动相关联。这是与其它语言不样的地方。
1.函数定义格式：
JavaScript程序构成
Function 函数名 （参数,变元） {
函数体 ;.
Return表达式 ;
}
JavaScript程序构成
当调用函数时,所用变量或字面量均可作为变元传递。
函数由关键字 Function定义。
函数名：定义自己函数的名字。
参数表，是传递给函数使用或操作的值，其值可以是常量，变量或其它表达式。
通过指定函数名（实参）来调用一个函数。
必须使用 Return将值返回。
函数名对大小写是敏感的。
JavaScript程序构成事件
基本概念
鼠标或键盘的动作，我们称之为 事件（ Event）,
由事件引发的一连串的动作，称之为 事件驱动（ Event Driver）。
对事件进行处理的程序或函数，我们称之为 事件处理程序（ Event Handler）。
当某 事件 发生时，由特定事件驱动程序引发某一特定 动作 。
捕捉事件的方法 ---定义事件句柄
定义一个事件句柄：即将 事件名称 和 事件触发时要执行的 JavaScript 代码 一同加到
HTML 的标记中去。例如：
<a href=“page2.html” onClick=“count++”>下一页 </a>
事件句柄列表现将各事件句柄归纳如下：
（１）单击事件 onClick
当用户单击鼠标按钮时，产生 onClick事件。同时 onClick指定的事件处理程序或代码将被调用执行。通常在下列基本对象中产生：
JavaScript程序构成
button（按钮对象）?checkbox（复选框）或（检查列表框）
radio（单选钮）?submitbuttons（提交按钮）
例：可通过下列按钮激活 change()文件：
<Form>
<input type=“button” Value=,” onClick=“change()”>
</Form>
（２）改变事件 onChange
例,<Form>
<Input
type="text,name="Test,value="Test,onChange="check('this.test)">
</Form>
JavaScript程序构成
（３）选中事件 onSelect
当 Text或 Textarea对象中的文字被加亮后，引发该事件。
（４）获得焦点事件 onFocus
当用户单击 Text或 textarea以及 select对象时，产生该事件。此时该对象成为前台对象。
（５）失去焦点 onBlur
当 text对象或 textarea对象以及 select对象不再拥有焦点、而退到后台时，引发该文件，他与 onFocas事件是一个对应的关系。
（６）载入文件 onLoad
当文档载入时，产生该事件。 onLoad一个作用就是在首次载入一个文档时检测 cookie的值，并用一个变量为其赋值，使它可以被源代码使用。
（７）卸载文件 onUnload
当 Web页面退出时引发 onUnload事件，并可更新 Cookie的状态。
基于对象的 JavaScript语言对象的属性和方法对象的基础知识建立与自定义对象对象的基础知识一、对象的基本结构：
１、对象的基本结构
JavaScript中的对象是由属性 (properties)和方法 (methods)两个基本的元素构成的。方法是属于对象成员的一种功能，而属性则是属于对象成员的一个或一组值。
我们可以通过下面两个实例认识对象、方法和属性：
实例 1,认识对象和方法实例 2,认识属性对象类型主要分为客户端对象、服务器对象和核心对象三类。
主要对象名称及功能前面介绍过对象是方法和属性的集合，而不同的对象所拥有的方法和属性也不相同。
２、引用对象的途径一个对象要真正地被使用，可采用以下几种方式获得：
引用 JavaScript内部对象；
由浏览器环境中提供；
创建新对象。
从上面我们可以看出 JavaScript引用对象可通过三种方式获取。要么创建新的对象，要么利用现存的对象。
已将现存主要对象列举出来了，那么怎么样创建一个新的对象？
人 ------------类；
每个人 ------------属于,人,这个类的实例；
由类创建一个实例对象 ---new
对象的基础知识对象的基础知识
３,有关对象操作语句
JavaScript不是一种面向对象的语言，它没有提供面向对象语言的许多功能，因此 JavaScript设计者之所以把它称为,基于对象,而不是
,面向对象,的语言，在 JavaScript中提供了几个用于操作对象的语句和关键字及运算符。
1） For...in语句格式如下：
For（对象属性名 in已知对象名）
说明：
该语句的功能是用于对已知对象的所有属性进行操作的控制循环。它是将一个已知对象的所有属性反复置给一个变量；而不是使用计数器来实现的。该语句的优点就是无需知道对象中属性的个数即可进行操作。
对象的基础知识例：下列函数是显示数组中的内容：
Function showData(object)
for(var X=0;X<30;X++)
document.write(object[i])；
该函数是通过数组下标顺序值，来访问每个对象的属性，使用这种方式首先必须知道数组的下标值，否则若超出范围，则就会发生错误。而使用 For...in语句，则根本不需要知道对象属性的个数，见下：
Function showData(object)
for(var prop in object)
document.write(object[prop])；
使用该函数时，在循环体中,For自动将它的属性取出来，直到最后为至。
with语句
使用该语句的意思是：在该语句体内，任何对变量的引用被认为是这个对象的属性，以节省一些代码。
withobject{,..}
所有在 with语句后的花括号中的语句，都是在后面 object对象的作用域的。
this关键字
this是对当前的引用，在 JavaScript由于对象的引用是多层次，多方位的，往往一个对象的引用又需要对另一个对象的引用，而另一个对象有可能又要引用另一个对象，这样有可能造成混乱，最后自己已不知道现在引用的是哪一个对象，为此 JavaScript提供了一个用于将对象指定当前对象的语句 this。
New运算符对象的基础知识对象的基础知识
New运算符在 JavaScript中设计人员可以按照需求来创建自己的对象，以满足某一特定的要求。使用 New运算符可以创建一个新的对象。其创建对象使用如下格式：
Newobject=new Object(Parameterstable);
其中
Newobject是创建的新对象：
object是已经存在的对象；
Parameterstable是参数表；
new是 JavaScript中的命令语句。
４、对象属性的引用对象属性的引用可由下列三种方式之一实现：
（１）使用点,,”运算符
university.Name=“云南省,
university.city=“昆明市,
university.Date=“1999”
其中 university是一个已经存在的对象,Name,City,Date是它的三个属性，并通过,=”操作对其赋值。
（２）通过对象的下标实现引用
university[0]=“云南,
university[1]=“昆明市,
university[2]="1999"
通过数组形式访问属性，可以使用循环操作获取其值。
Function showunievsity(object)
for(varj=0;j<2;j++)
document.write(object[j])
对象的基础知识若采用 For...in则可以不知其属性的个数后就可以实现：
Functionshowmy(object)
for(varpropinthis)
docament.write(this[prop]);
（３）通过字符串的形式实现
university["Name"]=“云南,
university["City"]=“昆明市,
university["Date"]="1999“
５、对象的方法的引用在 JavaScript中对象方法的引用是非常简单的。
ObjectName.methods()
实际上 methods()=FunctionName方法实质上是一个函数。如引用
university对象中的 showmy（）方法，则可使用：
document.write(university.showmy())
对象的基础知识对象的基础知识
或,document.write(university)
如引用 math内部对象中 cos()的方法：
with(math)
document.write(cos(35));
document.write(cos(80));
若不使用 with则引用时相对要复杂些：
document.write(math.cos(35))
document.write(math.sin(80))
JavaScript为我们提供了一些非常有用的常用内部对象和方法。用户不需要用脚本来实现这些功能。这正是基于对象编程的真正目的。
在 JavaScript提供了 string（字符串）,math（数值计算）和 Date
（日期）三种对象和其它一些相关的方法。从而为编程人员快速开发强大的脚本程序提供了非常有利的条件。
1、常用内部对象在 JavaScript中对于对象属性与方法的引用，有两种情况：其一是说该对象是静态对象，即在引用该对象的属性或方法时不需要为它创建实例；而另一种对象则在引用它的对象或方法时必须为它创建一个实例，即该对象是动态对象。
对 JavaScript内部对象的引用，以是紧紧围绕着它的属性与方法进行的。因而明确对象的静动性对于掌握和理解 JavaScript内部对象是具有非常重要的意义。
１ )、串对象常用对象的属性和方法
string对象：内部静态性。
访问 properties和 methods时，可使用（,）运算符实现。
基本使用格式,objectName.prop/methods
（１）串对象的属性该对象只有一个属性，即 length。它表明了字符串中的字符个数，
包括所有符号。例：
mytest="ThisisaJavaScript"
mystringlength=mytest.length
最后 mystringlength返回 mytest字串的长度为 20。
（２）串对象的方法
string对象的方法共有１９个。主要用于有关字符串在 Web页面中的显示、字体大小、字体颜色、字符的搜索以及字符的大小写转换。
其主要方法如下：
常用对象的属性和方法常用对象的属性和方法
锚点 anchor()：该方法创建如用 Html文档中一样的 anchor标记。通过下列格式访问,string.anchor(anchorName)。
有关字符显示的控制方法
Italics()斜体字显示,bold()粗体字显示,blink()字符闪烁显示，
small（）字符用小体字显示,fixed()固定高亮字显示、
fontsize(size)控制字体大小等。
字体颜色方法； fontcolor(color)
字符串大小写转换
toLowerCase()－小写转换,toUpperCase()大写转换。下列把一个给定的串分别转换成大写和小写格式,
string=stringValue.toUpperCase和
string=stringValue.toLowerCase。
字符搜索,indexOf[charactor,fromIndex]
从指定 formIndtx位置开始搜索 charactor第一次出现的位置。
从 start开始到 end的字符全部返回。
返回字串的一部分字串,substring(start,end)
２ )、算术函数的 math对象
功能：提供除加、减、乘、除以外的一引些自述运算。如对数，平方根等。
静动性：静态对象
（１）主要属性
math中提供了６个属性，它们是数学中经常用到的常数Ｅ、以１０
为底的自然对数ＬＮ１０、以２为底的自然对数 LN2,3.14159的 PI、
1/2的平方根 SQRT1-2,2的平方根为 SQRT2。
（２）主要方法绝对值,abs()
正弦余弦值,sin(),cos()
常用对象的属性和方法
反正弦反余弦,asin(),acos()
正切反正切,tan(),atan()
四舍五入,round()
平方根,sqrt()
基于几方次的值,Pow(base,exponent)
３ )、日期及时间对象
功能：提供一个有关日期和时间的对象。
静动性：动态性，即必须使用 New运算符创建一个实例。例,
MyDate=NewDate()
Date对象没有提供直接访问的属性。只具有获取和设置日期和时间的方法。
日期起始值,１７７０年１月１日００,００,００。
常用对象的属性和方法常用对象的属性和方法
1,获取日期的时间方法
getYear(),返回年数
getMonth():返回当月号数
getDate(),返回当日号数
getDay():返回星期几
getHours():返回小时数
getMintes(:返回分钟数
getSeconds():返回秒数
getTime(),返回毫秒数
（２）设置日期和时间：
setYear();设置年
setDate():设置当月号数
setMonth():设置当月份数
setHours():设置小时数
setMintes():设置分钟数
setSeconds():设置秒数
setTime ():设置毫秒数
2,JavaScript中的系统函数
JavaScript中的系统函数又称内部方法。它提供了与任何对象无关的系统函数，使用这些函数不需创建任何实例,可直接用。
常用对象的属性和方法
1．返回字符串表达式中的值：
方法名,eval（字串表达式），例：
test=eval("8+9+5/2");
返回字符串 ASCI码：
方法名,unEscape (string)
3．返回字符的编码：
方法名,escape(character)
4．返回实数：
parseFloat(floustring);
５、返回不同进制的数：
parseInt(numbestring,rad.X)
其中 radix是数的进制,numbs字符串数常用对象的属性和方法
使用 JavaScript可以创建自己的对象。在 JavaScript中创建一个新的对象是十分简单的。首先它必须定义一个对象，而后再为该对象创建一个实例。这个实例就是一个新对象，它具有对象定义中的基本特征。
一、对象的定义
JavaScript对象的定义，其基本格式如下：
FunctionObject（属性表）
This.prop1=prop1 This.prop2=prop2
...
This.meth=FunctionName1;
This.meth=FunctionName2;
...
在一个对象的定义中，可以为该对象指明其属性和方法。通过属性和方法构成了一个对象的实例。如以下是一个关于 University对象的定义：
Functionuniversity(name,city,creatDateURL)
创建新的对象
This.name=name This.city=city
This.creatDate=NewDate(creatDate)
This.URL=URL
其基本含义如下：
Name－指定一个,单位,名称。
City－,单位,所在城市。
CreatDate－记载 university对象的更新日期。
URL－该对象指向一个网址。
创建新的对象二、创建对象实例一旦对象定义完成后，就可以为该对象创建一个实例了：
NewObject=Newobject();
其中 Newobjet是新的对象,Object已经定义好的对象。例：
U1=Newuniversity(“云南省,,,昆明市,,
"January05,199712:00:00","http://www.YN.KM")
U2=Newuniversity(“云南电子科技大学,,,昆明,,"January07,1997
12:00:00","htlp://www.YNKJ.CN")
三、对象方法的使用在对象中除了使用属性外，有时还需要使用方法。在对象的定义中，我们看到 This.meth=FunctionName语句，那就是为定义对象的方法。实质对象的方法就是一个函数 FunctionName，通过它实现自己的意图。
例在 university对象中增加一个方法，该方法是显示它自己本身，并返回相应的字串。
functionuniversity(name,city,createDate,URL)
创建新的对象
This.Name=Name; This.city=city;
This.createDate=NewDate(creatDate)；
This.URL=URL；
This.showuniversity=showuniversity;
其中 This.showuniversity就是定义了一个方法－－－
showuniversity()。
而 showuniversity()方法是实现 university对象本身的显示。
functionshowuniversity()
For(varpropinthis) alert(prop+="+this[prop]+"");
其中 alert是 JavaScript中的内部函数，显示其字符串。
四,JavaScript中的数组创建新的对象
使用 New创建数组
JavaScript中没有提供像其它语言具有明显的数组类型，但可以通过 function定义一个数组，并使用 New对象操作符创建一个具有下标的数组。从而可以实现任何数据类型的存储。 a、定义对象的数组
FunctionarrayName(size){
This.length=Size;
for(varX=;X<=size;X++)
this[X]=0;
Returethis;
}其中 arrayName是定义数组的一个名子,Size是有关数组大小的值（ 1-size），即数组元素的个数。通过 for循环对一个当前对象的数组进行定义，最后返回这个数组。
从中可以看出,JavaScript中的数组是从 1到 size，这与其它０到 size的数组表示方法有所不同，当然你可根据需要将数组的下标由１到 size调整到０到 size－１,可由下列实现,
FunctionarrayName(size)
For(varX=0;X<=size;X++)
this[X]=0;
this.lenght=size;
Returnthis;
创建新的对象创建新的对象
从上面可以看出该方法是只是调整了 this.lenght的位置，该位置是用于存储数组的大小的。从而调整后的数组的下标将与其它语言一致。但请读者注意正是由于数组下标顺序由１到 size，使得 JavaScript中的对象功能更加强大。
b、创建数组实例一个数组定义完成以后，还不能马上使用，必须为该数组创建一个数组实例：
Myarray=NewarrayName(n);
并赋于初值：
Myarray[1]=“字串１,；
Myarray[2]=“字串２,；
Myarray[3]=“字串３,；
...
Myarray[n]=“字串 n”；
一旦给数组赋于了初值后，数组中就具有真正意义的数据了，以后就可以在程序设计过程中直接引用。
创建多维数组
FunctioncreatMArray(row,col){ varindx=0;
this.length=(row*10)+col
for(varx=1;x<=row;x++)
for(vary=1;y<=col;y++)
indx=(x*10)+y;
this[indx]=””;
}
myMArray=newcreatMArray();
之后可通过 myMArray[11],myMArray[12],myMArray[13],myMArray[21]、
myMArray[22],myMArray[23]、
… 来引用。
内部数组
在 Java中为了方便内部对象的操作,可以使用窗体 (Forms)、框架 (Frames)、
元素 (element)、链接 (links)和锚 (Anchors)数组实现对象的访问。
创建新的对象
anchors[]:使用,A name=“anchorName“,标识来建立锚的链接。
links[],使用 <Ahref=”URL”>来定义一个越文本链接项。
Forms[],在程序中使用多窗体时,建立该数组。
Elements[]:在一个窗口中使用从个元素时,建立该数组。
Frames[]:建立框架时,使用该数组
anchors[]用于窗体的访问 (它是通过,form name=“form1”,所指定的 ),link[]用于被链接到的锚点的访问 (它是通过,ahref=URL,所指定的 )。 Forms[]反映窗体的属性,而 anchors[]反映 Web页面中的链接属性。
创建新的对象使用浏览器的内部对象系统,可实现与 HTML文档进行交互。它的作用是将相关元素组织包装起来，提供给程序设计人员使用，从而减轻编程人的劳动，
提高设计 Web页面的能力。
一、浏览器对象层次及其主要作用除了前面提到过的文档 document对象外,Navigator浏览器中还提供了窗口
（ Window）对象以及历史（ History）和位置（ Location）对象。
浏览器对象 (Navigator)
提供有关浏览器的信息
窗口对象 (Windows)
Window对象处于对象层次的最顶端，它提供了处理 Navigator窗口的方法和属性
位置对象 (Location)
Location对象提供了与当前打开的 URL一起工作的方法和属性，它是一个静态的对象。
历史对象 (History)
History对象提供了与历史清单有关的信息。
使 用内部对象系统
文档对象 (Document)
document对象包含了与文档元素 (elements)一起工作的对象，它将这些元素封装起来供编程人员使用。
编程人员利用这些对象，可以对 WWW浏览器环境中的事件进行控制并作出处理。
在 JavaScript中提供了非常丰富的内部方法和属性,从而减轻了编程人员的工作,
提高编程效率。这正是基于对象与面向对象的根本区别所在。在这些对象系统中,文档对象属于非常重要的,它位于最低层,但对于我们实现 Web页面信息交互起作关键作用。因而它是对象系统的核心部分。
二,文档对象功能及其作用在 Navigator浏览器中,document文档对象是核心是，同时也是最重要的。
如下图所示：
使用内部对象系统
links anchor form method prop
链接对象 锚对象 窗口对象 方法 对象使用内部对象系统
从上图可以看出,document对象的主要作用就是把这些基本的元素（如
links,anchor等）包装起来，提供给编程人员使用。从另一个角度看，
document对象中又是由属性和方法组成。
１,document中三个主要的对象在 document中主要有,links,anchor,form等三个最重要的对象：
（１） anchor锚对象：
anchor对象指的是 <A Name=..,</A标识在 HTML源码中存在时产生的对象。它包含着文档中所有的 anchors信息。
（２）链接 links对象
link对象指的是用 <A Href=..,</A标记的连接一个超文本或超媒体的元素作为一个特定的 URL。
（３）窗体（ Form）对象窗体对象是文档对象的一个元素，它含有多种格式的对象储存信息，使用它可以在 JavaScript脚本中编写程序进行文字输入，并可以用来动态改变文档的行为。通过 document,Forms[]数组来使得在同一个页面上可以有多个相同的窗体,使用 forms[]数组要比使用窗体名字要方便得多。
例,下面就是一个使用窗体数组和窗体名字的例子。该程序使得两个窗体中的字段内容保持一致。
例,下面就是一个使用窗体数组和窗体名字的例子。该程序使得两个窗体中的字段内容保持一致。
<Html
<head
</head
<body
<form
<input type=text
onChange="document.my.elements[0].value=this.value;"
</form
<form NAME="my"
<input type=text
onChange="document.forms[0].elements[0].value=this.value;"
</form
</body
</html
使用内部对象系统其中用了 OnChnge事件 (当窗体内容改变时激发 )。第一个使用窗体名字标识 my,第二个使用窗体数组 Forms[]。其效果是一致的。
２、文档对象中的 attribute属性
document对象中的 attribute属性，主要用于在引用 Href标识时，
控制着有关颜色的格式和有关文档标题、文档原文件的 URL以及文档最后更新的日期。这部分元素的主要含义如下：
（１）链接颜色,alinkcolor
这个元素主要用于，当选取一个链接时，链接对象本身的颜色就按
alinkcolo r指定改变。
（２）链接颜色,linkcolor
当用户使用 <A Href=..,Text string </A链接后,Textstring的颜色就会按 Linkcolor所指定的颜色更新。
（３）浏览过后的颜色,VlinkColor
该属性表示的是已被浏览存储为已浏览过的链接颜色。
（４）背景颜色,bgcolor
该元素包含文档背景的颜色。
使用内部对象系统使用内部对象系统
（５）前景颜色,Fgcolor
该元素包含 HTML文档中文本的前景颜色
３、文档对象的基本元素
（１）窗体属性：
窗体属性是与 HTML文档中 <Form...</Form相对应的一组对象在 HTML
文档所创建的窗体数，由 length指定。通过 document.forms.length反映该文档中所创建的窗体数目。
（２）锚属性,anchors
该属性中，包含了 HTML文档的所有 <A </A标记为 Name=...的语句标识。所有,锚,的数目保存在 document.anchors.length中。
（３）链接属性,links
链接属性是指在文档中 <A...</A的由 Href=...指定的数目，其链接数目保存在 document.links.length中。
3.3 Applet
3.3.1 HTML和 Applet的参数传递
从 HTML文件向 Applet传递参数为用户提供了一个强有力的手段，通过参数传递大大加强了
Applet的灵活性，使你的 Applet不用修改和重新编译就能适用于多种情形。
HTML语言有一个 <APPLET>标签，可加入各种属性来指定与 Applet有关的内容，其中 CODE、
WIDTH,HEIGHT是必选属性。如果需要向
Applet传递参数，可通过 PARAM标签来指定。
这样做的好处是,Applet一次编译成功就可保持不变，如果需要 Applet显示不同的内容，仅修改
HTML文件中指定的参数即可。
图 7.3
例 3.2 Applet的参数传递，如图 3.3所示。
import java.applet.Applet;
import java.awt.Graphics;
public class ParamDemo extends Applet {
String string=null;
int x,y;
public void init( ) {
string=getParameter(″message″);
x=Integer.parseInt(getParameter(″xPos″));
y=Integer.parseInt(getParameter(″yPos″));
}
public void paint(Graphics g) {
if (string!=null)
g.drawString(string,x,y);
}
}
相应的 HTML文件内容如下：
<APPLET
codebase=d:/mydoc/ch7
code=ParamDemo.class
width=300
height=120>
<PARAM name=message value=″参数传递示例 ″>
<PARAM name=xPos value=30>
<PARAM name=yPos value=30>
</APPLET>
3.3.2 APPLET标签属性
熟悉 HTML语言的 APPLET标签属性能够帮助你更好地设计出 Applet，该标签可用大写或小写符号指定与 Applet有关的内容，语法格式如下：
<APPLET
CODE=字节码文件名
WIDTH=宽度
HEIGHT=高度
［ CODEBASE=字节码文件路径］
［ ALT=可替换的文本内容］
［ NAME=对象名］
［ ALIGN=对齐方式］
［ VSPACE=垂直间隔］
［ HSPACE=水平间隔］ >
［ <PARAMNAME=参数名 VALUE=参数值 >］
...
［ alternateHTML］
</APPLET>
注意,CODE,WIDTH,HEIGHT是必选属性，
属性可用大写或小写符号表示，属性值定义为字符串，但可省略引号，所有属性必须包含在
<APPLET>和 </APPLET>之间。下面我们讨论这些属性的用法。
(1) CODE用来指定 Applet字节码文件名，可省略扩展名。
(2) WIDTH和 HEIGHT用来指定 Applet显示区域的大小，以像素点为计量单位。
(3) CODEBASE用来指定 Applet字节码文件路径。当字节码文件和 HTML文件不在同一个目录下时，
应指定字节码文件的位置，可采用 URL格式即网络地址。对于本地计算机可采用绝对路径，但必须注意格式，请参考例 7.2。
(4) ALT用来指定替换显示的文本内容。如果浏览器不能运行 Applet，就显示替换文本内容，例如：
ALT=″指定的字节码文件找不到 ″。
(5) NAME用来指定 Applet的实例化对象名，使同一个 Web页上的多个 Applet可以互相识别出来。
(6) ALIGN用来指定 Applet在浏览器窗口中的对齐方式。常用值有 left(左对齐 ),right(右对齐 )，
top(靠上 ),middle(对中 ),bottom(靠下 )等。
(7) VSPACE和 HSPACE用来指定 Applet四周的间隔，
以像素点为计量单位。 VSPACE指定上下间隔，
HSPACE指定左右间隔。
(8) PARAM标签包含两个参数,NAME指定参数名，
VALUE指定参数值。 Applet可通过
getParameter方法读取这两个参数。
(9) alternateHTML用来指定可替换的 HTML代码。如果你的浏览器不支持 APPLET标签，将忽略
<APPLET>和 <PARAM>内容，显示指定的
HTML代码。
3.4 动态网页 ASP
3.4.1 ASP基础
1,实现交互式动态网页的几种技术；
2,ASP的特性和功能；
3,普通 HTML和 ASP的执行过程；
4,Web服务器的安装和配置；
5,ASP文件的编写和使用方法；
交互式动态网页技术
1,CGI（ Common Gateway Interface）：通用网关接口，是外部程序和 Web服务器之间的标准接口。
2,PHP(Hypertext Preprocessor)：是一种 HTML内嵌式的语言,
3,JSP(Java Server Pages)：是 SUN公司推出的网站开发技术，是将纯 JAVA代码嵌入 HTML中实现动态功能的一项技术。
4,ASP(Active Server Pages)：一种类似 HTML,Script与
CGI的结合体，它与 CGI的不同主要体现在对象和组件的使用。 ASP除了内置的基本对象外，还允许用户以外挂的方式使用 ActiveX控件。
ASP是 Active Server Pages的简称，是服务器端脚本编写环境，使用它可以创建和运行动态、交互的 Web
服务器应用程序。使用 ASP 可以组合 HTML 页、脚本命令和 ActiveX 组件以创建交互的 Web页和基于
Web 的功能强大的应用程序。 ASP 可用来创建动态
Web 页或生成功能强大的 Web 应用程序。
可以包含服务器端脚本。
ASP提供了几种内置对象
使用附加组件可以扩展 ASP；
ASP可以和数据库建立连接；
浏览器兼容性好；
隐密安全性高；
ASP的特性和功能什么是 ASP
ASP重要特性
ASP的特性和功能
ASP功能
Microsoft脚本调试程序；
事务性脚本；
管理工具；
隔离 ASP应用程序；
文件上载；
新的 ASP组件；
应用程序根目录的改变；
支持 HTTP1.1协议；
使用脚本语言；
ASP的工作平台一般来说,ASP程序可以在 Windows
9x/NT/2000等操作系统下运行,本节将 以
windows98为例解释一下安装 TCP/IP网络通讯协议,Web服务器及 ASP软件。
服务器端
（ web
服务器）
客户端
（ Browser）
执行的是服务器端脚本 *.asp 由浏览器解释执行 的 *.html文件
HTML文件
1,运行环境不同； 例 1.1
2,编写方式不同；
用 <%和 %>将脚本括起来
<script>和 </script>中间，用 runat=server注明。
服务端脚本和客户端脚本
HTML和 ASP的执行过程
ASP的工作原理：
普通 HTML的执行过程和 ASP的执行过程
ASP的运行环境：
客户端 (Browser) 服务器
(Server)
请求响应
a) 操作系统,Windows95以上版本；
b) 正确设置 TCP/IP网络通讯协议；
c) 安装 Web服务器（ PWS或 IIS)；
WEB服务器的安装浏览器只能用来,浏览” ASP网页,并不具有,打开” ASP网页 的能力。所以 ASP并不适用于单机之上，
在单机上要打开 ASP网页必须通过 PWS（或 IIS）来模拟网络服务器才能执行；
一,PWS
1.硬件要求：
2.安装 PWS （ 自学 ）
二,IIS
1.硬件要求：
2.安装 IIS（演示）
IIS安装完成之后 ……
创建 WEB站点启动、停止 WEB站点；
设置 WEB站点创建和设置虚拟目录；
WEB服务器的配置
<html>
<head><title>简单的 ASP文件 </title></head>
<body>
<% Response.Write(“嗨！你好” )%>//引用了 ASP内置对象 //Response的 write方法；
<% Response.Write(DATE)%>//同上
<%=“sdfsfdsdf”%>//ASP的两种命令之一
</body>
</html>
创建简单的 ASP网页
ASP的两种命令在 ASP程序中除了使用脚本语言外，还可以使用 ASP本身的两个重要的命令：输出命令和处理命令。
（ 1）输出命令：指 〈 % =expression % 〉 显示表达式值。
（ 2）处理命令：指 <% kerword %〉 表达式。为 ASP提供处理,asp
文件所需要的信息。例如，以下命令将 JScript设为主脚本语言：
〈 % LANGUAGE=Jscript %〉
处理命令必须出现在,asp文件的第一行，而且和关键字之间必须加入一个空格。
创建简单的 ASP网页创建简单的 ASP网页
ASP文件的编写格式
a) ASP应用程序是后缀名为,asp的文本文件
b) ASP文件的组成
文本；
HTML标记；
脚本命令；
c) 使用的脚本语言：
JavaScript或 VBScript (PWS或 IIS默认 )改变黙认脚本
d) 使用的编写工具：
常用的文本编辑工具即可（如 notebook,推荐使用 UltraEdit）
e) ASP脚本和 HTML网页代码结合方式：
以 <%,%>为定界符以 <Script RunAt=“Server”></Script>来定界上机作业
1.安装 IIS；
2,配置 IIS环境；
3.在 D盘下建立一个文件夹 (文件夹名为 aspfile)
作为站点配置其虚拟目录，起名为 aspsite；
4.在 aspfile下创建一个简单的 asp文件，验证路径配置是否正确；
5.编写一个,asp文件，实现下图所示的功能；
“提交,按钮实现下面的功能：
1.当,姓名,或,年龄,为空时，弹出新窗口提示不能为空。并以红色显示。如图 1
2.当年龄不为数字时，弹出窗口提示
,必须为数字！,（红色，如图 2）
3.若输入正确，则打开新窗口显示输入信息。（如图 3）
图 1
图 3
图 2
3.4.2 Request和 Response对象
HTTP协议的传输过程
Response对象的使用
Request对象的使用网页程序所用语言什么是 HTTP？
HTTP(Hypertext Transfer Protocol),超文本传输协议，是一种非常重要的 WWW传输协议,它限制了在网络中传输信息的内容以及客户端浏览器与服务器端交互的方式。
ASP的内置对象
Response（响应）对象它控制在 HTTP响应消息中，将消息发送给浏览器
Request （请求）对象它在一个 HTTP请求过程中，获取由浏览器传送给服务器的消息
Server （服务器）对象它提供对驻留在服务器上的资源的访问
Session （会话期）对象它用于存储和管理与一个特定的用户会话有关的信息
Application （应用程序）对象它用于存储和管理与该 Web应用程序有关的信息
Cookie对象
HTTP协议的传输过程客户端 服务端
HTTP是一种 WWW传输协议，限制了在网络中传输信息的内容以及客户端浏览器与客户端交互的方式。
建立连接并发送请求注意事项
1.ASP网页程序所使用的语言可以是 JavaScript，也可以是 VBScript；
2.ASP网页程序的命名不是,*.html”而是,*.asp”;
3.ASP程序是嵌入在 HTML里的，撰写 ASP程序网页，程序语句区段一定要放在 <%和 %>之间；
4.ASP程序与 HTML标签一样，是不区分大小写的 ;
5.若要在单机上执行 ASP文件，则必须安装 IIS或 PWS；
6.即使安装了 IIS或 PWS而且已经启动它们了，仍然不能以浏览器,打开,的方式来观看程序网页。而必须使用,浏览,的方式。
Response和 Request对象一,Response对象
Response对象：网页数据输出对象。是响应数据给浏览器，
包括网页服务器所要响应给用户的各项信息。但凡与数据输出相关的都得靠 Response对象的方法。
1.Response.write方法：负责将字符串信息输出至客户端。
例 4-2：
<body>
轻松学习 ASP
<hr>
今天是,<% response.write date %>
</body>
本例中利用 Response对象的
,write”方法输出了一个日期数据，这个日期是调用了,date”这个函数产生的。
Response和 Request对象一,Response对象
Response对象：网页数据输出对象。是响应数据给浏览器，
包括网页服务器所要响应给用户的各项信息。但凡与数据输出相关的都得靠 Response对象的方法。
1.Response.write方法：负责将字符串信息输出至客户端。
例 4-2：
<body>
轻松学习 ASP
<hr>
今天是,<% response.write date %>
</body>
本例中利用 Response对象的
,write”方法输出了一个日期数据，这个日期是调用了,date”这个函数产生的。
3.4.3 ASP内置对象
3.4.3.1 Request对象
3.4.3.2 Response对象
3.4.3.3 Sever对象
3.4.3.4 Session对象
3.4.3.5 Application对象
3.4.3.6 ObjectContext对象本章将介绍 ASP本身所提供的对象，
称为 ASP内置对象，包括 Request对象、
Response对象,Server对象,Session对象、
Application对象及 ObjectContext对象。
这些对象都有其特别的任务与工作，
在详细说明之前，下面先简单地说明每个内置对象的功能，然后再将这些对象分六个小节进行介绍 。
对 象 名 称 对 象 功 能
Request对象 负责从用户端接收信息 。
Response对象 负责传送信息给用户 。
Sever对象 负责控制 ASP的运行环境 。
Session对象 负责存储个别用户的信息,以便重复使用 。
Application对象 负责存储数据以供多个用户使用 。
ObjectContext
对象可供 ASP程序直接配合 MTS进行分散式的事务处理 。
3.4.3.1 Request对象
Request对象通常包括了用户端的相关信息，如浏览器的种类、表头信息、表单参数及 cookies等等。
而 Response对象则是包含 Web服务器所要响应给用户的各项信息。
Request对象的语法描述如下,
Request[.collection|property|method](variable)
其中 collection表示 Request对象的集合,property表示 Request对象的属性，
method表示 Request对象的方法，变量参数（ variable）是一些字符串，这些字符串指定要从集合中检索的项目，或作为方法或属性的输入。
Request对象的集合如下：
集 合 功 能 说 明
ClientCertificate 存储发送到 HTTP请求中客户端证书中的字段值 。
Cookies HTTP请求中被发送的 cookies的值 。
Form HTTP请求正文中表格元素的值 。
QueryString HTTP中查询字符串中变量的值 。
ServerVariables 预定的环境变量的值 。
Request对象提供 BinaryRead方法,
该 方法是以二进制方式来读取客户端使用
POST传送方法所传递的数据。
Request对象总共提供了 Form 集合,
Cookies集合,ClientCertificate集合,
ServerVariables集合 及 QueryString集合等。
3.4.3.2 Response对象在 ASP中负责将信息传递给用户的对象就是 Response对象。
Response对象用于动态响应客户端请求
（ Request），并将动态生成的响应结果返回到客户端浏览器中，使用该对象可以动态创建 web页面。
Response对象 的使用语法为：
其中 collection表示 Response对象的集合,property表示 Response对象的属性,
method表示 Response对象的方法 。
Response.collection|property|method
Response对象的方法：
方 法 功 能 说 明
AddHeader 从名称到值设置 HTML标题 。
AppendToLog 在该请求的 Web服务器日志条目后添加字符串 。
BinaryWrite 将给出信息写入到当前 HTTP输出中,并且不进行任何字符集转换 。
Clear 清除任何缓冲的 HTML输出 。
End 停止处理,asp文件并返回当前的结果 。
Flush 立即发送缓冲的输出 。
Redirect 将重指示信息发送到浏览器,尝试连接另一个 URL。
Write 将变量作为字符串写入当前的 HTTP输出 。
Response对象的属性：
属 性 功 能 说 明
Buffer 表明页输出是否被缓冲 。
CacheControl 决定代理服务器是否能缓存 ASP生成的输出 。
Charset 将字符集的名称添加到内容类型标题中 。
ContentType 指定响应的 HTTP内容类型 。
Expires 在浏览器中缓存的页面超时前,指定缓存的时间 。
ExpiresAbsolute 指定浏览器上缓存页面超时的日期和时间 。
IsClientConnect
ed
表明客户端是否与服务器断开 。
Pics 将 PICS标记值添加到响应标题的 PICS标记字段中 。
Status 服务器返回的状态行的值 。
Response对象只有 Cookies一个数据集合。
Cookies数据集合允许将数据设置在客户端的浏览器中。假如所指定名称的
Cookies不存在，系统会自动在客户端的浏览器中建立新的 Cookies，
3.4.3.3 Sever对象
Server 对象提供对服务器上的方法和属性的访问，其中大多数方法和属性是作为实用程序的功能服务的。
Sever对象 的使用语法为：
其中 property表示 Server对象的属性,
method表示 Server对象的方法 。
Server.property|method
Server的属性只有一个 ScriptTimeout,表示超时值，即在脚本运行超过这一时间之后作超时处理。
Server对象的方法,
方 法 描 述
CreateObject 创建服务器组件的实例 。
HTMLEncode 将 HTML编码应用到指定的字符串 。
MapPath 将指定的虚拟路径,无论是当前服务器上的绝对路径,还是当前页的相对路径,映射为物理路径 。
URLEncode 将 URL编码规则,包括转义字符,应用到字符串 。
3.4.3.4 Session对象由于网页是一种无状态的程序，因此无法得知用户的浏览状态。
在 ASP中，是通过 Session对象记录用户的相关信息，用来作为用户再次对服务器提供要求时作确认。
要 注意的是，会话状态仅在支持 Cookie
的浏览器中保留。
Session对象 的使用语法为：
其中 collection表示 Session对象的集合,
property表示 Session对象的属性,method
表示 Session对象的方法 。
Session.collection|property|method
Session对象在 global.asa文件中声明两个事件 Session_OnEnd,Session_OnStart的脚本。
Session 对 象 对 应 两 个 事 件,
Session_OnEnd,Session_OnStart。
其中 Session_OnStart事件对应 Session对象的起始事件：每当产生一个 Session对象,
该 事 件 所 定 义 的 代 码 都 将 被 激 活 ；
Session_OnEnd事件对应 Session对象的结束事件：当 Session对象被终止或失效时,该事件所对应的代码被激活 。
<SCRIPT LANGUAGE = ScriptLanguage RUNAT = Server>
Sub Session_OnStart
事件的处理程序代码
End Sub
Sub Session_OnEnd
事件的处理程序代码
End Sub
</SCRIPT>
这两个事件的代码必须放在 global.asa文件中，如下：
Session对象的属性：
属 性 名 描 述
CodePage 将用于符号映射的代码页 。
LCID 现场标识 。
SessionID 返回用户的会话验证 。
Timeout 应用程序会话状态的超时时限,以分钟为单位 。
Session对象的 集合,
集 合 名 描 述
Contents 包含已用脚本命令添加到会话中的项目 。
StaticObjects 包含通过 <OBJECT>标记创建的并给定了会话作用域的对象 。
Session对象 只提供了 Abandon方法，该方法删除所有存储在 Session对象中的对象并释放这些对象的源。
3.4.3.5 Application对象
Application对象和 Session对象有很多相似之处，它们的功能都是用于在不同的 ASP
之间共享信息。
最大的不同在于其应用的范围：
Application对象是对所有用户，
Session对象是对单一用户。
Application对象 的使用语法为：
其中 property表示 Application对象的属性,method表示 Application对象的方法 。
Application.property|method
Application对象在 global.asa文件中声明两个事件 Application_OnEnd、
Application_OnStart的脚本：
Application 对 象 对 应 两 个 事 件,
Application_OnEnd,Application_OnStart。
其中 Application_OnStart 事 件 对 应
Application对象的起始事件：每当产生一个
Application对象,该事件所定义的代码都将被 激 活 ； Application_OnEnd 事 件 对 应
Session对象的结束事件：当 Application对象被终止或失效时,该事件所对应的代码被激活 。
<SCRIPT LANGUAGE = ScriptLanguage RUNAT = Server>
Sub Application_OnStart
事件的处理程序代码
End Sub
Sub Application_OnEnd
事件的处理程序代码
End Sub
</SCRIPT>
这两个事件的代码必须放在 global.asa文件中，如下：
Application对象的集合如下：
Application对象的属性如下：
属 性 名 描 述
Lock Lock方法禁止其他客户修改 Application对象的属性 。
Unlock Unlock方法允许其他客户修改 Application对象的属性 。
集 合 名 描 述
Contents 包含所有通过脚本命令添加到应用程序中的项 。
StaticObjects 包含所有用 <OBJECT>标记添加到会话中的对象 。
3.4.3.6 ObjectContext对象
ObjectContext对象是一个以组件为主的事务处理系统,可以保证事务的成功完成 。
使用 ObjectContext对象,就允许程序在网页中直接配合 Microsoft Transaction Server
（ MTS） 使用,从而可以管理或开发高效率的 Web服务器应用程序 。
在 ASP中使用 @TRANSACTIO关键字来完成的,语法如下：
<%@TRANSACTION = value %>
要注意的是 @TRANSACTION 指令必须位于,asp文件中的第一行，否则将出错，
必须将该指令加到要在某个事务下运行的每一页中。当脚本处理完成之后，当前事务也就结束了。
ObjectContext的 方法,
方 法 意 义
SetComplete SetComplete方法声明脚本不了解事务未完成的原因 。 如果 事 务 中的 所 有 组件 都 调 用
SetComplete,事务将完成 。
SetAbort SetAbort方法声明被脚本初始化的事务未完成,
无法更新源 。
ObjectContext对象提供 OnTransactionCommit、
OnTransactionAbort两个事件处理程序，前者是在事务完成时被激活，后者是在事务失败时激活。
SubOnTransactionCommit()
处理程序
End Sub
SubOnTransactionAbort()
处理程序
End Sub
3.4.4 ASP组件
3.4.4.1 Ad Rotator组件
3.4.4.2 Browser Capabilities组件
3.4.4.3 Database Access 组件
3.4.4.4 File Access组件
3.4.4.5 Content Linking组件
3.4.4.6 其它 ASP组件使用组件可以完成诸如 Web广告条轮换、
浏览器兼容、数据库存取、服务器端文件存取等多种功能，值得一提的是,ASP提供的组件是在服务器端运行，
组 件 名 描 述
Ad Rotator 创建一个 Ad Rotator对象,该对象可按用户指定的播放顺序,在同一页上自动轮换显示各种广告 。
Browser
Capabilities
创建一个 Browser Type对象,该对象决定访问
Web站点的每个浏览器的性能,类型及版本 。
Database
Access
提供 ActiveX Data Objects(ADO) 对数据库的访问 。
Content
Linking
创建一个 Next Link对象,该对象可动态生成 Web
页内容列表,并象书一样将各页顺续连接 。
File Access 提供对 Web服务器端文件的输入输出访问 。
3.4.4.1 Ad Rotator组件
Ad Rotator组件中，能很容易实现在
Web页面上插入一个循环播放广告横幅的播放器，可以通过定义一个播放顺序文件，使播放器能根据文件中定义的播放顺序轮流播放一系列广告图片。
Ad Rotator组件所使用的播放顺序文件是一个文本文件，只要修改这个文件，就可以实现广告横幅播放顺序的更新。
一般来说,Ad Rotator组件相关文件除了必要的 Adrot.dll文件外，还要有循环定时文件，另外也可以有重定向文件。
循 环 定 时 文 件 也 叫 作 Rotator
Schedule文件,包含 Ad Rotator组件用于管理和显示各种广告图象的信息 。
重定向文件是 Ad Rotator组件中可选择项，如果在循环定时文件中指定使用重定向文件，每当用户点击广告时，其发出的请求对会重定向到该文件。
Ad Rotator组件的属性属 性 名 语 法 描 述
Border Border = size 允许用户指定显示广告时四周是否带边框 。
Clickable Clickable =
value
允许用户指定是否将广告作为超链接显示 。 默认值是 TRUE。
TargetFr
ames
TargetFrame =
frame
用于指定链接将被装入的目标框架 。
该属性完成的功能等价于 HTML语句中的 TARGET参数 。 frame指定用来显示广告框架的名称 。
Ad Rotator组件只要 GetAdvertisement
一个方法,主要功能在于重新取得一个将要显示的图片和超文本链接 。 语法如下：
其中 rotationSchedulePath 指定
Rotator Schedule文件相对于虚拟目录的位置 。
GetAdvertisement(rotationSchedulePath)
3.4.4.2 Browser Capabilities组件
ASP提供的 Brower Capabilities组件的使用，可以轻松地获取客户端浏览器的类型，
进而判断浏览器所支持的特性，然后再根据此信息，启用浏览器支持的特性，屏蔽不支持的特性。
Browser Capabilities组件除包含一系列属性,方法外,也有一个外部驱动文件
Browscap.ini文件 。 语法如下：
Set Browser = Server.CreateObject("MSWC.BrowserType")
Browscap.ini文件中主要定义了各种浏览器所具有的属性,可以在该文件中声明属性定义任意数量的浏览器数目,也可以设置用户浏览器不在所定义的列表中时使用的默认值 。
对每一个浏览器定义,都可以提供一个用户代理的 HTTP（ HTTP User Agent） 标题和属性以及希望与标题相关联的值 。
3.4.4.3 Database Access 组件
Database Access 组件是 ASP的精华，通过使用 该 组件,Web开发人员可以很容易地实现在 Web应用程序中访问数据库。
Database Access 组件可以通过 ADO访问存储在数据库或其他表格化数据结构中的信息，同时支持 ODBC3.0的数据库连接池特征。
3.4.4.4 File Access组件
File Access组件可用来访问计算机文件系统的方法和属性。 该 组件是由
FileSystemObject对象,TextStream对象组成。其中,FileSystemObject对象负责文件或目录的管理，但如果你要访问文件的内容，就必须与 TextStream对象一起使用。
File Access组件建立的语法如下：
Set fs=CreateObjext(“Scripting.FileSystemObject”)
FileSystemObject对象提供对计算机文件系统的访问,共有 24种方法 （ 教材表 4.4）
和一种属性 。 语法如下：
Scripting.FileSystemObject
TextStream对象的使用可以有助于顺序访问文件,可以协助利用 File Access组件启动或建立的文件 。 语法如下：
TextStream.{property | method}
其中 property和 method参数可以是任何与 TextStream对象相关联的属性和方法。
3.4.4.5 Content Linking组件
Content Linking组件的主要目的在于管理网页或网址间的超文本链接，可以通过一个网页或网址的线性排列顺序列表来管理多个网页或网址间的超文本链接顺序。
该组件读取一个被称为线性排列顺序文本链接的文本文件，根据 该文件的内容,组件可以自动创建每个相关页面的导航链接和目录链接 。
Content Linking组件创建语法如下：
Set NextLink = Server.CreateObject("MSWC.NextLink")
线性排列顺序文件是一个包含 Web页列表的文本文件,语法如下：
Web-page-URL [ text-description [ comment]]
其中参数 Web-page-URL表示的 Web页的虚拟或相对 URL。 参数 text-description包含
Web-page-URL 描述文字的值 。 参数
comment为组件不处理的说明性文字 。
3.4.4.6 其他 ASP组件
ASP还包括其他组件，每个组件都相当于一个小工具，利用这些组件，就可以快速、方便的构造网页。比如 Content
Rotator组件,Permission Checker组件、
Logging Utility组件,Tools组件等。
3.4.5 VBScript和 Jscript
3.4.5.1 服务器端脚本和客户端脚
3.4.5.2 VBScript脚本语言
3.4.5.3 JScript脚本语言
ASP程序是由文本,HTML标记和脚本组合而成的。可以用任何脚本语言来编写 ASP程序中的脚本部分，只要 Web服务器上安装了该语言的脚本引擎。
目前比较流行的脚本语言有 VBScript
和 Jscript。
3.4.5.1 服务器端脚本和客户端脚本使用 VBScript和 JScript，既可编写服务器端脚本，也可编写客户端脚本。服务器端脚本在 Web服务器上执行，生成发送到浏览器的 HTML页面由 Web服务器负责。
在 ASP中，服务器端脚本要用分隔符 <％
％ >括起，或者在 <SCRIPT></SCRIPT>标记中用 RUNAT=Server表示脚本在服务器端执行。
脚本代码能够嵌入到 HTML文档的任何地方，通常都是将所有脚本代码集中放在
HEAD部分，这样可以确保在 BODY部分调用代码之前所有脚本代码都被读取并解码 。
3.4.5.2 VBScript脚本语言
VBScript是 Visual Basic的一个子集，编程方法和 Visual Basic基本相同，但有相当多的 Visual Basic特性在 VBScript中都被删去了。
1 将单行语旬分成多行有时一条语句可能会很长，这给打印和阅读带来不便，此时可用续行符,-”（一个空格紧跟一个下划线）将长语句分成多行。
2 在代码中加注释在 VBScript中，注释符采用西文单引号,′”，即以撇号作为注释的开始。注释可以和语句在同一行并写在语句的后面，也可单独占一行。
3 使用不同进制的数字在 VBScript中，除了可以用默认的十进制来表示数字外，还允许用十六进制或八进制来表示数字。对于不同进制的数，
VBScript在表达方式上有明确规定，即十六进制数要加前缀＆ H（如＆ H9），八进制数要加前缀＆ 0（数字零）（如＆ 011）
4 数据类型
VBScript只有一种数据类型，即 Variant
类型。由于 Variant类型是 VBScript中唯一的数据类型，因此它也是 VBScript中所有函数的返回值的数据类型。 Variant类型可以在不同场合代表不同类型的数据。
5 变量声明变量有两种方式，即显式声明和隐式声明。
显式声明要用到 Dim语句。
隐式声明是指脚本中第一次使用变量时，就自动创建该变量。
在 VBScript中，变量命名必须遵循这样的规则：
①名字必须以字母开头；
②名字中不能含有句号；
③名字不能超过 255个字符；
④名字不能和关键字同名；
⑤名字在被声明的作用域内必须唯一。
VBScript不区分大小写。
变量被声明后不是在任何地方都可以被使用，每个变量都有它的作用域，作用域是指程序中哪些代码能引用变量。过程内部声明变量称为 过程级变量或局部变量,这样的变量只有在声明它们的过程中才能使用，即无法在过程外部访问；过程外部声明的变量称为 脚本级变量或全局变量,即在同一个程序文件中的任何脚本命令均可访问和修改该变量的值。过程级和脚本级变量可以同名，
修改其中一个变量的值，不会影响另一个。
6 常量常量是具有一定含义的名称，用于代替数值或字符串。
在 VBScript中，还可以用 Const语句来定义自己的常量。
7 数组在 VBScript中，把具有相同名字不同下标值的一组变量称为数组变量，简称数组。
数组有上界和下界，数组中的元素在上下界内是连续的。
在 VBScript中，数组有两种类型，即固定数组和动态数组。
8 运算在 VBScript中，可以进行 4种类型的运算，即算术运算、连接运算、关系运算和逻辑运算。
在表达式中，当运算符不止一种时，要首先进行算术运算，接着进行关系运算，
然后进行逻辑运算。
9 控制结构在 VBScript中，控制结构有两种，即判定结构和循环结构。
VBScript支持的判定结构分条件结构和选择结构两种。
可以用选择结构来替代块结构的条件语句，
以便在多个语句块中有选择地执行其中的一个。
循环结构允许重复执行一行或数行代码。
在 VBScript中，提供了三种不同风格的循环结构，即 Do循环,For循环和 For
Each循环。
10 with语句
with语句用于对某个对象执行一系列操作，而不用重复指出对象的名字。
With语句可以嵌套，即 With语句能够置入另一个 With语句中，但不能用一个 With
来 设置多个不同的对象。
11 过程过程是用来执行特定任务的独立的程序代码。
使用过程，可以将程序划分成一个个较小的逻辑单元，过程中的代码能够被反复调用，这样可以减少不必要的重复。
12 VBscript函数摘要
VBScript提供的函数见教材表 5.5
3.4.5.3 JScript脚本语言
Jscript完全实现了 ECMAScript-262语言规范并提供了一些增强特性。与 C++和
Java这样成熟的面向对象语言相比，功能要弱些，不能用 Jscript来编写独立运行的应用程序,Jscript脚本只能在某个解释器上运行，该解释器既可是 Web服务器，也可是
Web浏览器。 Jscript是一种宽松类型的语言，
即不必显式定义变量的数据类型,JScript
会根据需要自动进行转换。
1 语句和语句块在 JScript中，语句由一行中的一个或多个项和符号组成。每行开始一条新的语句。可以用分号 (； )来显式地终止一条语句。分号是 JScript的语句终止符。
用大括号括起来的一组 Jscript语句称为一个语句块。
2 变量
JScript通常不要求变量声明，但在使用之前先进行声明是一种良好的编程习惯。
在 JScript中，变量声明要用到 var语句。
3 数据类型
JScript有六种数据类型（见教材表
5.6）。
在 JScript中，变量在技术上没有固定的类型，但具有与其包含的值的类型等价的类型。
4 运算符
Jscript的运算符如教材表 2.7所示。
5 数组在 JScript中，可以用 new运算符和
Array()构造函数来创建数组。
当创建数组时,Jscript将在该数组中包括一个只写的 length属性，用来记录数组中的项数。
创建数组后，可以用方括号 []来访问数组中的单个元素。
6 控制结构
Jscript支持 if和 if… else条件语句。
JScript支持条件运算。条件运算在待测条件后用一个问号并指定两个可选项，
一个可选项在条件满足时使用，另一个在条件不满足时使用，选项间用冒号隔开。
JScript支持 for循环,for… in循环、
while循环和 do… while循环。
7 函数在 JScript中，可以用 function语句来创建自己的函数。
8 复制、传递和比较数据
9 特殊字符
JScript提供了一些特殊字符（见教材表 5.9），允许在字符串中包括一些无法直接键人的字符。每个特殊字符都以反斜杠开始。反斜杠是一个转义字符，表示紧随其后的字符是特殊字符。
10 固有对象
JScript提供了九个固有对象（教材表
5.10），每个固有对象都有与之关联的方法和属性。
3.4.6 Web数据库的使用
3.4.6.1 Web数据库的概述
3.4.6.2 ODBC的安装设置
3.4.6.3 ADO概述
3.4.6.4 Connection对象
3.4.6.5 Command对象
3.4.6.6 Recordset对象
3.4.6.7 Field对象和 Fields数据集合
3.4.6.8 Properies数据集合和 Property对象
3.4.6.9 Parameters数据集合与 Parameter对象
3.4.6.10 Errors数据集合和 Error对象
3.4.6.1 Web数据库的概述数据库是管理信息的常规方法，它可以处理各种各样的信息、试验数据、销售总结、
业务记录、人事档案和顾客要求等等 。
随着网络技术的飞速发展，基于
Internet/Intranet的浏览器 /服务器结构的管理信息系统应运而生 。
要开发基于 Internet/Intranet的浏览器 /
服务器结构的管理信息系统,首先要解决的就是如何实现网页与数据库的连接和集成,实现这个目的,一般有下面三种方法：
(1) CGI的方法；
(2) Web通过处理器与数据库进行连接；
(3)采用集成了 ODBC接口功能的 Web服务器 。
现在采用的方式绝大多数都是用第三种方式 。
对于一个 ASP程序而言,它通常是通过 ADO层或 ODBC接口来访问数据库的 。
ASP对数据库的整个访问过程是这样：
客户端的浏览器向 Web服务器提出 ASP页面文件请求（包括数据库的操作），服务器将把该页面由 ASP.DLL文件进行解释，并在服务器端运行，完成数据库的操作，再把数据库操作的结果生成动态的网页返回给浏览器，浏览器再将该网页内容显示在客户端。
3.4.6.2 ODBC的安装设置本节主要介绍如何建立一个与已有数据库连接的 DSN（ Data Source Name），其中
DSN表示应用程序和指定数据库的连接信息。
（请参考书 6.2 ）
3.4.6.3 ADO概述
ASP对数据库的访问是可以通过 ADO模式来实现。 ADO对象给开发人员提供了一种快捷、简单、高效的数据库访问方法,ADO
可以包含在脚本中来产生对数据库的连接，
并从数据库表中读取记录，形成实际要使用的对象集合。而且，对数据资源，如数据库，
ADO提供了应用程序一级的界面。
ADO对象主要是由 Connection对象,
Command 对象,Parameter 对象,
Recordset对象,Field对象,Property对象,
Error对象等七个对象,以及 Fields数据集合,Properties数据集合,Parameters数据集合,Error数据集合等四个数据集合所组成 。
在介绍 ADO的七个对象和四个数据集合后，下面将用图表的关系来介绍一下。
C o n n e c t i o n 对象 R e c o r d s e t 对象
E r r o r 对象
P a r a m e t e r
对象
C o m m a n d 对象
F i e l d 对象
E x e c u t e 操作方法
A c ti v e C o n n e c t
属性
E x e c u t e 操作方法
F i e l d s 数据对象
S o u r c e 属性
P a r a m e t e r s
数据集合
E r r o r s 数据集合
A c ti v e C o n n e c t
属性
3.4.6.4 Connection对象在 ASP中,Connection对象是网页通过
ADO存取数据库的关键,Connection对象负责与数据库实际的连接动作，其它的对象都是必须依赖与 Connection对象的连接才能发挥其特有的功能。
Connection对象代表与数据源进行的唯一会话。
在成功安装 ASP与 Web服务器后,就可以使用 ASP Server对象的 CreateObject方法来创建 Connection对象,语法如下：
Set Conn = Server.CreateObject(“ADODB.Connect”)
Connection对象的方法包括,Open、
Execute,Close,Cancel,Save,BeginTrans、
CommitTrans,RollbackTrans等方法。（请参考书 6.4）
Connection对象的属性包括 Attributes、
CommandTimeout,ConnectionString、
ConnectionTimeout,CursorLocation、
DefaultDatabase,IsolationLevel,Mode、
Provider,State,Version等属性。
Connection对象提供 Properties,
Errors两种数据集合。前者表示 Connection
对象运行是最近一次的错误或警告信息，
后者表示 Connection对象所定义的相关属性。
3.4.6.5 Command对象
Command对象负责对数据库提供请求，
也就是传递指定的 SQL命令。使用 Command对象可以查询数据库并返回 Recordset对象中的记录，以便执行大量操作或处理数据库结构。
使用该对象不仅能够对一般的数据库信息进行操作，还因为对象可以带输入、输出参数，从而可以完成对数据库存贮过程的调用。
Command对象可以使用 Execute方法来执行 SQL语句或对数据库存储过程的调用，
或创建一个 RecordSet对象。
Command对象还包括一个 Parameter集合，使用该集合，可以将数据库存储过程的参数与集合中各项元素相对应，而且存储过程的输出值也作为一个参数被包含在
Parameter集合中，从而简化对存储过程的调用。
Command对象所提供的属性包括 Name、
ActiveConnection,CommandText,State、
CommandType,CommandTimeout,Prepared
等属性。
Command 对 象 提 供 了 Execute,
CreateParameter等方法 。 (请参考书 6.5。 )
3.4.6.6 Recordset对象
Recordset对象表示的是来自基本表或命令执行结果的记录全集。任何时候该对象所指的当前记录均为集合内的单个记录。
也就是说，该对象负责浏览和操作从数据库中取出的数据，该对象就像一个二维数组，数组的每一列表示数据库中的一个数据列，而同时每个数据列包含多个字段，每个数据字段就表示一个 Field对象。
Recordset对象中一共有,Open,Close、
Movefirst,MoveLast,MoveNext,Move、
MovePrevious,Update,AddNew,Delete、
NextRecordset,CancelBatch,CancelUpdate、
GetRows,Requery,Resync,Cupports、
UpdateBatch,Close等方法。
Recordset对象属性同样很多，包括了
ActiveConnection,Source,CursorLocation、
CurSorType,LockType,RecordCount、
BOF,EOF,PageCount,PageSize,State、
AbsolutePage,AbsolutePosition,Bookmark、
EditMode,Filter,MaxRecords,CacheSize、
Status等。 (请参考书 6.6)
3.4.6.7 Field对象和 Fields数据集合
Field对象代表使用普通数据类型的数据的列。前面介绍的 Recordset对象，就包含有由 Field对象组成的 Fields集合，每个 Field
对象对应于 Recordset中的一列。使用 Field
对象的 Value属性可设置或返回当前记录的数据。
Fields数据集合与其它数据集合一样，
都有属于自己的方法与属性，有时候也称为 Field数据集合对象。 Fields数据集合提供的方法和属性包括 Count属性,Refresh方法、
Item方法。
Field对象属性包括 Name,Value,Type、
Attribute,NumericScale,Precision、
ActualSize,DefinedSize,OriginalValue、
UnderlyingValue等属性。方法包括 GetChunk,
AppendChunk等。
3.4.6.8 Properies数据集合和
Property对象
Property 对象代表由提供者定义的
ADO对象的动态特征，动态属性由基本的数据提供者定义，并出现在相应的 ADO对象
(如 Connect对象,Command对象,Field对象,Recordset对象 )的 Properties集合中。
语法如下：
Set properties = ADO对象,Properties
Properties集合是包含特定对象实例的所有 Property 对象，有时候也称为 Properties
数据集合对象。包括 Count属性,Refresh方法,Item方法等。
Property对象主要是用来记录相应 ADO
对象的每一项属性值，包括了 Name属性、
Value属性,Type属性,Attributes属性等。
3.4.6.9 Parameters数据集合与
Parameter对象在前面介绍 Command对象时，知道
Command对象是通过 Parameter对象来传递一个参数，而 Parameters数据集合则是
Command对象所有 Parameter对象的集合。
也可以说,Parameter对象是代表与基于参数化查询或存储过程的 Command对象相关联的参数或自变量。
Parameters集合是由 Parameter对象组成的。该集合包括 Count属性,Append方法、
Delete方法,Refresh方法,Item方法。
Parameter对象负责记录程序中要传递参数的相关属性,Parameter对象提供了
Name属性,Value属性,Type属性、
Attribute属性等。
3.4.6.10 Errors数据集合和
Error对象在 ADO关系图中，知道通过 Errors数据集合，取得系统运行时发生的错误或警告信息，从而使程序更加完善。任何涉及 ADO对象的操作都会生成一个或多个提供者错误。
每个错误出现时，一个或多个 Error对象将被放到 Connection对象的 Errors集合中。
如果是通过直接建立 Connection对象来使用,可以直接通过 Connection对象的
Errors数据集合取得 Error对象 。 如果是通过建立 Recordset对象或 Command对象,在通过 ActiveConnection 属 性 来 使 用
Connection对象时,则必须通过 Recordset
对象或 Command对象的 ActiveConnection
属性来取得 Error对象 。 语法如下：
Set Err = Connection.Errors
Set Err = Recordset.ActiveConnection.Errors
Set Err = Command.ActiveConnection.Errors
Errors数据集合，也称 Errors数据集合对象，包含在响应涉及提供者的单个失败时产生的所有 Error对象。包括 Count属性,Clear
方法,Item方法。
Error对象是负责记录存储一个系统运行时发生的错误或警告。 Error对象提供了
Desription,Number,Source,NativeError、
SQLState,HelpContext,HelpFile等属性。
3.4.7 数据库的访问
3.4.7,1 常用的 SQL命令
3.4.7,2 数据库的连接
3.4.7,3 数据的查询控制
3.4.7,4 数据的添加和删除
3.4.7,5 数据的修改
3.4.7,6 调用数据库的存储过程本章将进一步介绍如何进行
Web数据库的访问操作,下面将
ADO存取数据源的数据的一般流程表示为如图：
连接数据源执行S Q L 命令设定参数设定S Q L 命令建立事务处理数据完成
3.4.7.1 常用的 SQL命令
SQL是 Strucured Query Language的缩写，
也就是常说的结构化查询语言。使用 SQL可以实现下面的功能：
(1)修改表结构；
(2)查询表中的数据信息；
(3)添加、删除数据库中的数据内容；
(4)修改数据库中的数据记录。
1 修改表结构在 ASP中，可以通过使用 SQL语句来修改现有的表结构。
修改表结构的 SQL命令是 ALTER
TABLE，该命令可以实现两种形式的修改：
在原有的表中添加一个或多个列；修改原表中已有列的属性。
语法如下：
ALTER TABLE 表名
ADD 列名 数据类型 | MODIFY 列名 数据类型 ;
其中 ADD表示添加新列,MODIFY表示修改已有的列 。
2 查询表中的数据信息
,查询,是数据库应用开发中最常用的操作，在 SQL中，查询操作是通过
Select语句来完成的，最简单的 Select语句如下：
Select <列名 > From 表名
Select语句还具有筛选的功能，即可以有选择地输出表中的记录，方法是在 Select
语句后面加上 Where子句，加上筛选的条件。
同时,Select语句还提供了 Order By子句,通过使用该字句,可以改变输出结果的排序方式,语法如下：
Select <列名 > From 表名 Where 条件 Order By <列 1>,<列 1>…
3 添加、删除数据库中数据在实际操作中，程序往往要将新记录数据添加到数据库中，这时就要使用 SQL
语句中 Insert语句进行数据的插入操作。程序除了要添加记录，往往还要把某些记录从数据库中删除，这时就要使用 SQL语句中的 Delete语句。
Insert语句有两种方法,语法如下：
Insert Into 表名 <列 1,列 2… > VALUES <值 1,值 2… >
或
Insert Into 表 1名 <列 1,列 2… > Select <列 1,列 2… > From 表 2名 Where 条件其中前一种是 Insert命令的基本形式,它将值 1,值 2等值分别赋值给列 1,列 2,并为表添加一条新的数据记录,只适用于少数记录的添加,对于大批量的数据输入,则是很不适合的 。 这时,就要使用第二种方法,这种命令格式可以将一个或多个表的记录输入到另一个表中 。
Delete语句的语法如下：
Delete From 表名 Where 条件要注意的是,如果没有在 Delete语句中加上 Where条件,则该语句将删除所有的记录,这一点需要特别注意 。
4 修改数据库中的数据记录在使用过程中，有些数据记录需要进行修改，这时就可以使用 SQL中的 Update
命令，进行修改数据库的记录，语法如下：
Update表名 Set 列 1＝值 1,列 2＝值 2…… Where条件
3.4.7.2 数据库的连接数据库访问操作的第一步是数据库的连接。主要分下面几种方法：
(1)设置 ODBC的方法来连接数据库
(2)直接指定 ODBC驱动程序来连接数据库
(3)设置 Connection对象的 Provider属性来设置连接信息
(4)设置 ActiveConnection参数，完成对数据源连接的设置
3.4.7.3 数据的查询控制数据库在网络中的应用，主要集中在数据的查询操作上。数据的查询主要是利用
ADO对象中的 Connection对象和 Recordset对象 。
数据的查询主要通过使用 SQL语句中的
Select语句，采用了 Select语句对表进行了筛选，然后得到了所要的数据结果。
当查询结果得到的数据记录很大的时候,就有些不适用了,如随着数据记录数量的增加,从服务器传递到客户机的时间就会增加,可能发生数据传递超时而中断的现象,同时对服务器也会产生一些不好的后果,如增加服务器的负载等 。
本节主要介绍两种方法：
一种是通过 Session对象的特性,让查询程序以一页或一条为单位进行查询操作,
主要利用 Recordset对象的 AbsolutePosition属性来记录数据指针的位置；
另一种则主要是利用 Recordset对象的
PageSize属性来控制每一页所要显示的数据记录条数,当然其间也用到了 Session对象和 Recordset对象的 AbsolutePosition属性 。
3.4.7.4 数据的添加和删除添加数据记录方法很多，这里主要介绍两种：一种是利用 SQL语句中的 Insert命令来添加数据记录；另一种是利用 ADO对象之一的 Recordset对象的 AddNew方法来添加数据记录。
数据的删除也存在两种方式：一种就是运行 SQL语句中的 Delete命令来删除表中的数据记录；另一种就是利用 Recordset对象中的 Delete方法来删除数据 。
3.4.7.5 数据的修改数据的修改也可以有相似的两种方法：
一种就是利用 SQL语句中的 Update命令来修改表中的数据记录；另一种也是利用
Recordset对象的 Update或 UpdateBatch方法来完成数据的修改。
3.4.7.6 调用数据库的存储过程存储过程是大型数据库的一个重要概念。
存储过程（ Stored Procedure）有时也称为存储查询（ Stored Query），是存储在数据库中的一组预先定义的 SQL语句集合，在存储过程中不仅可以包括标准的 SQL语句，还可以包含输入和输出参数。
因此在更一般意义上讲，存储过程相当于对一个数据库进行操作的子程序，如果灵活运用，则可以完成很多复杂的功能 。
存储过程具有以下优点：
(1) 存储过程在执行速度上要快得多；
(2) 存储过程减少了对磁盘的访问；
(3) 存储过程允许被嵌套调用；
(4) 提高数据的安全性；
(5) 使用存储过程可以减轻网络的通信流量；
(6) 存储过程可以带有输入输出参数，可以利用它返回一个数据集合或其它类型的结果
1 创建存储过程创建存储过程使用的是一种被称为数据定义语言（ DDL）的命令，该命令对 SQL
的扩展。存储过程可以包含多条 Transact-
SQL语句，而 Transact-SQL对使用
Microsoft SQL Server非常重要，与 SQL
Server通讯的所有应用程序都通过向服务器发送 Transact-SQL语句来进行通讯。
可使用 Transact-SQL 语句 CREATE
PROCEDURE 创建存储过程。创建存储过程前，请考虑下列事项：
(1) 不能将该语句与其它 SQL 语句组合到单个批处理中；
(2) 创建存储过程的权限默认属于数据库所有者；
(3) 存储过程是数据库对象；
(4) 只能在当前数据库中创建存储过程。
而且，在创建存储过程时，还应指定：
(l) 所有输入参数和向调用过程或批处理返回的输出参数；
(2) 执行数据库操作（包括调用其它过程）的编程语句；
(3) 返回至调用过程或批处理以表明成功或失败（以及失败原因）的状态值。
创建存储过程的语法如下：
CREATE PROC [ EDURE ] procedure_name [ ; number ]
[ { @parameter data_type }
[ VARYING ] [ = default ] [ OUTPUT ]
] [,...n ]
[ WITH
{ RECOMPILE | ENCRYPTION | RECOMPILE,ENCRYPTION
} ]
[ FOR REPLICATION ]
AS sql_statement [,..n ]
各个参数的意义的意义请参考书 7.6.1。
2．在 SQL Server中创建存储过程由于在 ASP应用开发中最常用的大型数据库是 SQL Sever，这里将介绍 SQL Server
2000如何创建存储过程。需注意的是 SQL
Server一般是安装在 NT环境 。
3 在 ASP中调用存储过程在 ASP中，调用存储过程的方法主要有两种：一种是通过 Connection对象来执行存储过程，另一种是通过 Command对象来执行存储过程。
3.4.8 用 Visual InterDev编写调试脚本
3.4.8.1 Visual InterDev使用基础
3.4.8.2 建立 Web工程
3.4.8.3 建立 Web页
3.4.8.4 客户端脚本
3.4.8.5 服务器端脚本
Visual InterDev是 Microsoft公司推出的一个功能强大的用于在
Internet/Intranet领域建立和维护动态
Web站点的软件，是快速设计、建立和调试 Web应用程序的可视化编程环境。
使用 Visual InterDev，既可编写客户端脚本，也可编写服务器端脚本。
3.4.8.1 Visual InterDev使用基础
1 Visual InterDev主要特点网页设计器站点设计器
CSS编辑器功能强大的调试器数据库集成动态 HTML
协作开发
2 开发环境和工作模式开发环境：
每台工作站都要安装一份 Visual
InterDev或 Microsoft FrontPage。开发者可以在各自工作站上建立本地 Web（ Local Web）
进行开发，从宿主 Web（ Master Web）中获取文件，拷贝到本地 Web中。另外，每台工作站上应安装一份 IIS或 PWS，以便开发者在本机上测试和调试应用程序。
工作模式宿主模式（ Master Mode）
本地模式（ Local Mode）
脱机模式（ Offline Mode）
3 Visual InterDev用户界面如上图所示，其中包括标题栏、菜单栏、
网页编辑器、工具箱、工程浏览器和属性窗口等部分。
网页编辑器工具箱属性窗口工程浏览器
3.4.8.2 建立 Web工程建立一个工程需要五步：①命名工程；
②指定服务器和工作模式；③指定 Web；④
选择一种布局；⑤选择一种主题。
建立工程后，如果要更改工作模式，请从,Project”菜单指向,Web Project”子菜单，再选择,Working Mode”子菜单的
,Local”,,Master”或,Work Offline”命令。
3.4.8.3 建立 Web页
1 添加新页面
2 设置页面属性
Web页面都有一些通用属性，如页面标题、
背景图像及颜色等。要设置这些属性，在网页编辑器中打开待设置属性的页面，然后在属性窗口的对象框中选择,DOCUMENT”，
再单击属性窗口的,Property Pages”按钮，
打开,Properties”对话框。
3 文本与列表文本输入及格式化,在页面编辑器中，可以直接输入文本并用 HTML工具栏来设置文本的格式，如标题、字体、字体号、粗体、
斜体、下划线、上下标、颜色及对齐方式列表,在 Visual InterDev中，可以建立五种列表，即无序列表、有序列表、目录列表、菜单列表和定义列表。
4 滚动文本滚动文本是指可在网页的指定区域循环往复滚动的字符串。插入滚动文本的方法是：
⑴ 将光标移到待插入滚动文本的位置。
⑵ 选择,HTML”菜单的,Marquee”命令，
网页编辑器中出现一个矩形区域。
⑶ 输入要滚动的文本，并通过 HTML工具栏对文本进行格式化处理。
5 超级链接超级链接是从文本或图像指向另一页面或其它类型文件的链接。每个超级链接包含两个端点（也称锚）和一个方向。超级链接由开始端点（称源锚）指向目标端点
（称目标锚）。目标锚可以是任意的网络资源，而源锚通常是页面中的文本或图像。
6 书签书签是页面中一个预定义的位置，它可以作为同一页面或其它页面中超级链接的目标锚。当在浏览器单击指向书签的超级链接时，浏览器不仅会加载相应的页面，
而且会自动 滚动到书签的位置。
7 插入图像网页上常用的图像格式有 GIF,JPEG和
PNG。 GIF是交错图形格式，使用非常高效的无损压缩。交错图片的特点是只要一半的显示时间便可大致看出全貌。 JPEG是有损压缩的静态图像文件格式，特点是压缩比非常高并支持真彩色图像。 PNG采用无损压缩来保存图片，产生的文件比 GIF小，
支持真彩色图像。
8 表格表格由多个方框组成，这些方框排成若干行和列。每个方框称为单元格，在单元格中可以填入文字、图像和超级链接等。
9 表单表单是用来输入信息的区域。方法是：
⑴ 将光标移到合适的位置。
⑵ 选择,HTML”菜单的,Form”命令，在页面中插入一个表单。
⑶ 根据需要从工具箱的,HTML”选项卡中把表单元素拖放到页面中。
⑷ 设置表单及表单元素的属性。
10 文档大纲文档大纲以层次结构形式显示了当前页面中的所有 HTML元素和对象。在文档大纲中选择一个 HTML元素或对象，就可以在网页编辑器中将光标迅速移到相应的位置。
3.4.8.4 客户端脚本客户端脚本是嵌在网页中的一段程序，
是由浏览器进行解释执行的。客户端脚本能够为用户提供更多的交互性。例如，在将表单内容发送给服务器之前，可以用客户端脚本来验证内容的合法性，这样不需要连接服务器就能使用户得到及时的反馈。
1 设置脚本语言客户端脚本可以用 VBScript来编写，
也可用 JavaScript来编写。 Visual InterDev
默认将脚本语言设为 JavaScript。如果要将脚本语言设为 VBScript,请在,Client”框中选择 VBScript。
2 事件处理网页上的每个元素都是一个对象。对象具有自己的属性、方法和事件。事件是能被对象识别的操作。客户端脚本可以处理由网页上的元素产生的事件。当事件由系统或用户触发时，对象就会对事件做出响应。响应某个事件后执行的操作是通过一段代码来实现的，这段代码称为事件处理函数。
3 脚本大纲
Visual 1nterDeV提供了一个脚本大纲来帮助开发人员编写事件处理函数，脚本大纲按层次结构显示了网页中的所有的对象、
事件和脚本。
4 样式属性要在脚本中访问元素的样式属性，需借助 style这个辅助对象才能实现。
3.4.8.5 服务器端脚本与客户端脚本一样，服务器端脚本也是嵌入在网页中的一小段程序，区别是：服务器端脚本是在 Web服务器上执行，而客户端脚本是由浏览器执行。
在 ASP页中，服务器端脚本要使用分隔符 <%和 %>括起，或者在 <SCRIPT>和
</SCRIPT>标记中用 RUNAT=Server表示脚本在服务器端执行。
3.4.9 如何建立自己的 ASP组件
3.4.9.1 什么是 ActiveX Server Components
3.4.9.2 Visual Basic 6.0与 ActiveX Server
Components
3.4.9,3 使用 ActiveX组件封装复杂计算和向 ASP
导出高级语言的函数
3.4.9.1 什么是 ActiveX Server
Components
除了内置对象,ASP还提供了一些基本组件（ Base Component），称为
ActiveX Server Components。
它们包括对用户浏览器能力及用户环境侦测组件的 Browser Capabilities
Component、提供建立动态广告板的 Ad
Rotator Component、协助管理、更新及建立网页连接功能的 Content Linking
Component、具有建立或存取服务器端文字文件能力的 File Access Component及具有建立网页计数器能力的 Page Counter
Component等。
3.4.9.2 Visual Basic6.0与
ActiveX Server Components
1 使用 Visual Basic 6.0编写
ASP组件开发 ActiveX Server Components可以使用很多工具，如 C/C++,Visual Basic或
Delphi等。这里通过示例介绍如何使用
Microsoft Visual Basic 6.0来编写属于自己的组件。
Visual Basic 6.0属性视窗及对象类别的属性
Name（名称）
DataBindingBehavior
DataSourceBehavior
Instancing
MTSTransactionMode
Persistable
2 通过 ASP调用自建组件编写前端用户界面编写后端处理程序
3.4.9.3 使用 ActiveX组件封装复杂计算和向 ASP导出高级语言的函数在 ASP脚本的编制过程中，可采用
VBScript和 JavaScript两种脚本语言。这两种脚本提供了丰富的功能和函数，但有时候它们提供的功能是不够的，碰到这种情况，一种行之有效的方法是使用 ActiveX组件来封装用高级语言编制的复杂计算，或者将高级语言的函数导出到 ASP应用程序中。
3.4.10 ASP应用程序开发入门
3.4.10.1 ASP应用程序概述
3.4.10.2 网上投票系统
3.4.10.3 创建在线商店
3.4.10.1 ASP应用程序概述
ASP应用程序是通过 Internet服务管理器来创建与管理其所在的虚拟目录和所有子目录的。
基于 ASP的应用程序通常有两种状态：
应用程序状态,该状态对应 ASP中的
Application对象，在这种状态下，应用中的所有信息可以为登录到网上的所有用户使用。
会话状态,该状态对应 ASP中的 Session对象，在这种状态下，应用中的所有信息，
只能被一个对话中的用户使用。
在编写 ASP应用程序代码时，可以通过
Global.asa文件处理有关 ASP应用的所有事件。 Global.asa文件是一个普通文本文件，
其后缀名 asa代表 Active Server Application
（活动服务器应用），使用任何一个普通的文本编辑器都可以编辑它。
Global.asa文件在以下两种情况下被调用：
⒈ Web服务器第一次接收到客户端对 ASP 文件的请求；
⒉ 尚未处于会话状态用户请求一个 ASP文件。
3.4.10.2 网上投票系统设计网上投票系统的关键之处在于，如何保存和读取选票结果。在 ASP应用程序中，主要通过两种形式保存数据，一是文本文件；二是数据库。这两种方法各有优劣，适用于不同的场合。
在 ASP里，用 FileSystemObject（ FSO）
对象模式来处理驱动器、文件夹和文件。
FileSystemObject（ FSO）对象模式下包含着不同的子对象和集合，通过它们，可以在 WEB服务器上添加、移动、改变、创建或删除文件夹（目录）和文件。
3.4.10.3 创建在线商店在线商店应用程序将会成为与访问客户交换信息的双向通道,所以创建一个三个表的相关数据库 。
1.Mproduce（ 产品 ） 表：在 Mproduce表中存储待售商品的信息；
2.Member（ 会员 ） 表：在 Member表中存储会员的信息；
3.Hbuy（ 定货 ） 表：在 Hbuy表中包含了每个定单每项内容的每一条记录 。
1,Mproduce表,Mproduce表中存储了名称、产品描述等信息，它包含下列字段：
字段名 含义
Mpno 包含一个作为记录识别标志的自动增加的数字域
Mpname 包含商品名称的文字域
Mpprice 包含商品单价的数字域
Mpunit 包含商品单位的文字域
Mpnum 包含商品库存量的数字域
Mpphoto 包含商品图片名称 (商品图片存储在
Image文件夹 )的文字域
2,Member表,Member表存储了会员的基本信息，它包含下列字段：
字段名 含义
Meno 包含一个作为记录识别标志的自动增加的数字域
Mename 包含会员名称的文字域
Mepwd 包含会员密码的文字域
Metruename 包含会员真实姓名的文字域
Memoney 包含会员金额的数字域
Meemail 包含会员 EMAIL地址的文字域
Megrand 包含会员等级的文字域,1表示此会员为系统管理员
3,Hbuy表,Hbuy表存储了会员购买商品的信息，
它包含下列字段：
字段名 含义
Hbno 包含一个作为记录识别标志的自动增加的数字域
Meno 包含会员编号的数字域
Mpno 包含商品编号的数字域
Hbdate 包含购买日期的日期域
Hbnum 包含购买某一商品数目的数字域
Hbqf 包含最近一次购买标志的文字域,1表示为最近一次购买内容
3.4.11 ASP程序的调试
3.4.11,1 错误处理
3.4.11,2 Err对象
3.4.11,3 脚本调试器
3.4.11.1 错误处理错误处理是指发生错误时,在代码中进行某些处理或仅捕获该错误而不进行处理 。 错误发生的原因有许多种：当程序正在使用的一些服务程序没有正常安装,这时就会发生错误；当程序代码中使用了不正确的语法也会有错误发生；当程序代码中出现了系统不知道如何处理的情况时也会发生错误 。
通过设置可以改变 IIS采用的默认处理错误代码程序,但这也仅仅提供某一个错误更友好的更容易理解的提示 。 所以,在实际操作的时候,通常自己编写代码来检查错误,然后根据该错误采取适当的处理方法 。
如果想在 ASP程序中处理错误代码，
那么就要使用 On Error语句，并将该语句放在 Option Explicit语句后，其它所有的代码之前。
On Error语句语法如下：
On Error Resume Next
这条语句是说明如果一行代码产生一个错误，就跳过该行代码而继续执行下面的语句，后面的语句代码就可以用来处理该错误。
3.4.11.2 Err对象
Err对象是用来判断发生什么错误 。 该对象提供了一系列的属性和方法,提供这些属性和方法就可以得到各种错误信息 。
Err对象包含五个属性（ Number、
Description,Source,HelpFile、
HelpContext），这五个属性包含了一个错误的所有细节 。
通过合理使用 Err对象的这个五个属性，
就可以很清楚的了解错误的类型。在这个五个属性中，最常用的是前面三个。
Err对象包括两个方法（ Clear,Raise），
可以用来操作 Err对象 。
现在可以使用 Err对象来识别发生的错误,但如果需要处理更加困难的问题,比如有访问者告诉网页存在问题,但又不知道位置,也不知道出了什么问题,这时就很难处理,很难找到错误发生的时间和页面 。
如果能将错误发生的时间和发生的页面记录在一个文本中以便以后补救,这是一个很有帮助的方法 。 利用这种方法可以帮助定位所发生的错误,也可以判断什么错误根本没有发生过 。
3.4.11.3 脚本调试器要检查错误发生的地方,就要一行一行的跟踪代码的执行过程,以便得到变量的变化结果 。 如果采用脚本调试器就能很容易地完成在 Windows2000中自带的 IIS5.0
就有脚本调试器,通过设置就可以很方便的调用脚本调试器调试出错的网页 。
3.5 JavaServer Pages（ JSP）
程序设计
3.5.1 JSP语法及内置对象
3.5.1.1 Java基础知识
3,5.1.2 JSP语法
3,5.1.3 JSP内置对象
3,5.1.4 HTML表单
3,5.1.5 JSP与客户机的交互
3.5.1.6 实践：练习 JSP编程
3,5.1.2 JSP语法
概述
基本语法
JSP的概念
Java Server Page
Servlet简化设计，逻辑与界面设计分开，开发更方便；
HTML语法的 java 扩展，加入新的标签 (<%,
%>,…) ；
强大的组件（ Java Bean）支持功能；
JSP文件结构及主要标签
<%@ page contentType="text/html;charset=gb2312" %>
<%@ page import="java.util.*,%>
...
<HTML>
<BODY>
其他 HTML 语言
<%
符合 JAVA 语法的 JAVA 语句
%>
其他 HTML 语言
</BODY>
</HTML>
JSP示例 (Hello.jsp)
<%@ page contentType="text/html;charset=gb2312" %>
<%@ page import="java.util.*"%>
<HTML>
<BODY>
<%
for ( int i=0; i<2; i++ )
{
%>
你好 <br>
<%
}
%>
</BODY>
</HTML>
<HTML>
<BODY>
你好 <br>
你好 <br>
</BODY>
</HTML>
JSP执行过程
*.jsp *.java *.classrequest
response
执行
jsp parser JSDK
servlet
servlet 分析器
JS
P
执行过程查找对应的JSP文件是否存在
Y
N
是否是修改或创建后第一次调用
Y
调用Jsp Parser将其编译成Servlet程序调用JSDK将对应的Servlet
程序编译成Servlet字节码执行(若未载入则先载入)
已有的对应的Java字节码
N
JSP示例 (Hello_Date.jsp)
<%@ page import="java.util.*" %>
<%@ page contentType="text/html;
charset=gb2312" %>
<HTML>
<BODY>
你好,今天是
<%
Date today=new Date();
%>
<%=today.getDate()%>号，
星期 <%=today.getDay()%>
</BODY>
</HTML>
import java.util.*;
response.setContentType("text/html;
charset=gb2312");
out = pageContext.getOut();
out.write(“\r\n\r\n<HTML>\r\n
<BODY>\r\n你好,今天是 \r\n");
Date today=new Date();
out.print(today.getDate());
out.write("号，星期 ");
out.print(today.getDay());
out.write(" \r\n </BODY>\r\n</HTML>\r\n ");
JSP文件
servlet文件
JSP示例 (浏览结果 )
JSP语法概述
JSP原始代码中包含了 JSP元素和
Template(模板 ) data两类
Template data指的是 JSP引擎不处理的部分,
即 标记 <%……%> 以外的部分，例如代码中的 HTML的内容等,这些数据会直接传送到客户端的浏览器
JSP元素则是指将由 JSP引擎直接处理的部分，
这一部分必须符合 JSP语法，否则会导致编译错误。
jsp例子 (hi.jsp)
<html>
<head>
<title>Hi-JSP实验 </title>
</head>
<body>
<%
String Msg = "This is JSP test.";
out.print("Hello World!");
%>
<h2><%=Msg%></h2>
</body>
</html>
Template data
JSP元素
JSP语法
JSP语法分为三种不同的类型编译器指令 (DIRECTIVE) 例如,<%@ page
import=“java.io.*” %>
脚本语法 (SCRIPTING)
动作语法 (ACTION) 例如,<jsp:forward>，
<jsp:getProperty>,<jsp:include>
脚本语法
脚本语法包括
,HTML注释,,<!— comments -->
,隐藏注释,,<%-- comments --%>
,声明,
,表达式,
,脚本段,
编译器指令
编译器指令包括“包含指令”,“页指令”
和,taglib指令”
它们包含在,<%@ %>”卷标里。
两个主要的指令是 page与 include。
动作语法
动作语法包括 <jsp:forward>,<jsp:include>，
<jsp:plugin>,<jsp:getProperty>，
<jsp:setProperty>和 <jsp:useBean>。
HTML注释
JSP 语法格式如下：
<!-- comment [ <%= expression %> ] --> 或
<!-- 注释 [<%= 表达式 %> ] -->
这种注释发送到客户端,但不直接显示,在源代码中可以查看到 。
HTML注释 (peixun2.1.jsp)
<html>
<head>
<title> HTML注释 </title>
</head>
<body>
<!-- This file displays the user login screen -->
未显示上一行的注释 。
</body>
</html>
HTML注释
HTML注释 (peixun2.2.jsp)
<html>
<head>
<title>要多加练习 </title>
</head>
<body>
<!--This page was loaded on <%= (new java.util.Date()).toLocaleString() %> --
>
在源文件中包括当前时间 。
</body>
</html>
HTML注释
IE中的源程序有注释隐藏注释
JSP 语法格式如下：
<%-- 注释 --%>
不发送到客户端 。
隐藏注释 (peixun2.3.jsp)
<html>
<head>
<title>A Comment Test</title>
</head>
<body>
<h2>A Test of Comments</h2>
<%-- This comment will not be visible in the page
source --%>
</body>
</html>
隐藏注释在 IE中查看源代码声明
JSP 语法格式如下：
<%! declaration; [ declaration; ],.,%> 或
<%! 声明 ; [声明 ; ],.,%>
声明 (test2.4.jsp)
<%@ page language=”java” import=”java.util.*” %>
<html>
<head>
<title> test2.4.jsp </title>
</head>
<body>
<%! int i = 0; %>
<%! int a,b,c; %>
<%! Date date; %>
</body>
</html>
表达式
用于在页面上输出信息,语法格式如下：
<%= expression %> 或
<%= 表达式 %>
表达式 (peixun2.4.jsp)
<%@ page language="java"
import="java.util.*" %>
<html>
<head>
<title> test </title>
</head>
<body>
<center>
<%! Date date=new Date(); %>
<%! int a,b,c; %>
表达式
<% a=12;b=a; c=a+b;%>
<font color="blue">
<%=date.toString()%>
</font> <br>
<b>a=<%= a %></b><br>
<b>b=<%= b %></b><br>
<b>c=<%= c %></b><br>
</center>
</body>
</html>
peixun2.4.jsp执行结果脚本段
JSP 语法格式如下：
<% code fragment %> 或
<% 代码 %>
脚本段 (peixun2.5.jsp)
<%@ page language="java" import="java.util.*" %>
<%! int condition;%>
<html>
<head>
<title> test </title>
</head>
<body>
<%
condition=1;
switch(condition){
case 0:
out.println("You must select condition 0!"+"<br>");
break;
case 1:
out.println("You must select condition 1!"+"<br>");
break;
case 2:
out.println("You must select condition 2!"+"<br>");
break;
default:
out.println("Your select not in \"0,1,2\",select again!!"+"<br>");
}
%>
</body>
</html>
转义符,双引号 \“,单引号 \’,反斜杠 \\,回车 \r,换行 \n,制表符 \t,退格
\b
脚本段执行结果包含指令
include指令：向当前页中插入一个静态文件的内容 。
JSP 语法格式如下：
<%@ include file="relativeURL" %> 或
<%@ include file="相对位置 " %>
包含指令 (peixun2.6.jsp)
<html>
<head>
<title>test</title>
</head>
<body bgcolor="white">
<font color="blue">
The current date and time are
<%@ include file=“peixun2.6.1.jsp" %>
</font>
</body>
</html>
“peixun2.6.1.jsp”
<%@ page import="java.util.*" %>
<%=(new java.util.Date() ).toLocaleString() %>
包含指令
Page指令
,Page”指令用于定义 JSP文件中的全局属性 。
JSP 语法格式如下：
<%@ page
[ language="java" ]
[ extends="package.class" ]
[import="{package.class | package.*},..." ]
[ session="true | false" ]
[ buffer="none | 8kb | sizekb" ]
Page指令
[ autoFlush="true | false" ]
[ isThreadSafe="true | false" ]
[ info="text" ]
[ errorPage="relativeURL" ]
[ contentType="mimeType
[;charset=characterSet]" | "text/html; charset=ISO-8859-1" ]
[ isErrorPage="true | false" ]
%>
Page指令
属性：
1,language="java"
声明脚本语言的种类,目前只能用 "java" 。
2.import="{package.class | package.* },..."
需要导入的 Java包的列表,这些包作用于程序段,表达式,以及声明 。 下面的包在 JSP编译时已经导入了,所以就不需要再指明了：
java.lang.* javax.servlet.*
javax.servlet.jsp.*
javax.servlet.http.*
3,errorPage="relativeURL"
设置处理异常事件的 JSP文件 。
4,isErrorPage="true | false"
设置此页是否为出错页,如果被设置为 true,
你就能使用 exception对象
page指令详说
,<%@ page %>”指令作用于整个 JSP页面,同样包括静态的包含文件 。 但是,<%@ page %>”指令不能作用于动态的包含文件,比如,<jsp:include>”。
可以在一个页面中用上多个,<%@ page %>”指令,但是其中的属性只能用一次,不过也有例外,那就是 import
属性 。 因为 import属性和 Java中的 import语句类似 (参照
Java Language,import语句引入得是 Java语言中的类 )，
所以此属性就能多用几次 。
无论把,<%@ page %>”指令放在 JSP的文件的哪个地方,
它的作用范围都是整个 JSP页面 。 不过,为了 JSP程序的可读性,以及好的编程习惯,最好还是把它放在 JSP文件的顶部 。
page指令（ peixun2.7.jsp）
<%@ page import="java.util.*,java.lang.*" %>
<%@ page buffer="24kb" autoFlush="false" %>
<%@ page errorPage="error.jsp" %>
<html>
<head>
<title>test3</title>
</head>
<body>
Test for using 'Page'.
</body>
</html>
page指令例子运行结果
taglib指令
JSP语法
<%@ taglib uri="URIToTagLibrary"
prefix="tagPrefix" %>
用于引入定制标签库
taglib指令
属性
1,uri="URIToTagLibrary"
Uniform Resource Identifier (URI)根据标签的前缀对自定义的标签进行唯一的命名,URI可以是以下的内容：
Uniform Resource Locator (URL),由 RFC 2396 定义,
可以从以下位置查看 (http://www.hut.fi/u
/jkorpela/rfc/2396/full.html)。
Uniform Resource Name (URN),由 RFC 2396定义
一个相对或绝对的路径
可以是标签库描述文件
2,prefix="tagPrefix"
表示标签在 JSP中的名称 。
在 自 定 义 标 签 之 前 的 前 缀,比如,在
<public:loop> 中的 public,如果这里不写
public,那么这就是不合法的 。 请不要用 jsp,
jspx,java,javax,servlet,sun,和 sunw做为你的前缀,这些已被 Sun公司声明保留 。
Tablib指令（ peixun2.8.jsp）
<%@ taglib uri="http://www.jspcentral.com/tags"
prefix="public" %>
<html>
<head>
<title>test</title>
</head>
<body>
<public:loop>
<%-- 执行代码 --%>
</public:loop>
</body>
</html>
<jsp:forward>
JSP 语法格式如下：
1,<jsp:forward page={"relativeURL" | "<%=
expression %>"} />
2,<jsp:forward page={"relativeURL" | "<%=
expression %>"} >
<jsp:param name="parameterName"
value="{parameterValue | <%= expression %>}" />
[<jsp:param … />]
</jsp:forward>
（,[<jsp:param … />]”指可以有多个,<jsp:param/>”
标记。）
属性：
1,page="{relativeURL | <%= expression %>}"
这里是一个表达式或是一个字符串用于说明你将要定向的文件或 URL。 这个文件可以是
JSP,程序段,或者其它能够处理 request对象的文件 (如 asp,cgi,php)。
2,<jsp:param name="parameterName"
value="{parameterValue | <%= expression
%>}" />
向一个动态文件发送一个或多个参数,这个文件必须是动态文件 。 如果想传递多个参数,
可以在一个 JSP 文 件 中 使 用 多 个
,<jsp:param>” ；,name”指 定 参 数 名,
,value”指定参数值 。
注意
,<jsp:forward>”标签从一个 JSP文件向另一个文件传递一个包含用户请求的 request对象 。
,<jsp:forward>”标签以后的代码,将不能执行 。
<jsp:forward>例子
（ peixun2.9.jsp）
<%@ page contentType="text/html;charset=gb2312" %>
<html>
<head>
<title>test</title>
</head>
<body>
<jsp:forward page="forwardTo.jsp">
<jsp:param name="userName" value="riso"/>
</jsp:forward>
</body>
</html>
forwardTo.jsp
<%@ page contentType="text/html;charset=gb2312"
%>
<!--forwardTo.jsp-->
<%
String
useName=request.getParameter("userName");
String outStr= "谢谢光临！ ";
outStr+=useName;
out.println(outStr);
%>
运行结果（ TOMCAT）
<jsp:include>
包含一个静态或动态文件,
JSP 语法格式如下：
1,<jsp:include page="{relativeURL |
<%=expression%>}" flush="true" />
2,<jsp:include page="{relativeURL | <%=expression
%>}" flush="true" >
<jsp:param name="parameterName" value="{parameterValue |
<%= expression %>}" />
[<jsp:param … />]
</jsp:include>
（,[<jsp:param … />]”指可以有多个,<jsp:param/>”标记 。 ）
<jsp:include>的 属性
1,page="{relativeURL | <%=expression %>}"
参数为一相对路径，或者是代表相对路径的表达式。
2,flush="true"
这里必须使用 flush="true"，不能使用 false值。而缺省值为 false 。
3,<jsp:param name="parameterName"
value="{parameterValue | <%= expression
%> }" />
“<jsp:param>”用来传递一个或多个参数到指定的动态文件,能在一个页面中使用多个
,<jsp:param>”来传递多个参数,
<jsp:include> 例子 (peixun2.10.jsp)
<html>
<head>
<title>peixun.2.10.jsp</title>
</head>
<body>
<jsp:include page="peixun2.10.1.jsp" flush="true" >
<jsp:param name="User" value="HiFi King" />
</jsp:include>
</body>
</html>
peixun2.10.1.jsp
<%
String username;
username=request.getParameter("User");
out.println("Username is "+username+"<br>");
%>
<jsp:include>运行结果
（ TOMCAT）
<jsp:plugin>
使用,<jsp:plugin>”插入一个 applet或 Bean,必要的话还要下载一个 Java插件用于执行它 。
JSP 语法格式如下：
<jsp:plugin
type="bean | applet"
code="classFileName"
codebase="classFileDirectoryName"
[ name="instanceName" ]
[ archive="URIToArchive,..." ]
[ align="bottom | top | middle | left | right" ]
[ height="displayPixels" ]
[ width="displayPixels" ]
[ hspace="leftRightPixels" ]
[ vspace="topBottomPixels" ]
[ jreversion="JREVersionNumber | 1.1" ]
[ nspluginurl="URLToPlugin" ]
[ iepluginurl="URLToPlugin" ] >
[ <jsp:params>
[ <jsp:param name="parameterName"
value="{parameterValue | <%= expression %>}" /> ]+
</jsp:params> ]
[ <jsp:fallback> text message for user
</jsp:fallback> ]
</jsp:plugin>
<jsp:plugin>属性
1,type="bean | applet"
将被执行的插件对象的类型,你必须得指定这个是
Bean还是 applet,因为这个属性没有缺省值 。
2,code="classFileName"
将会被 Java插件执行的 Java Class的名字,必须以,class结尾 。 这个文件必须存在于 codebase属性指定的目录中 。
3,codebase="classFileDirectoryName"
将会被执行的 Java Class文件的目录 （ 或者是路径 ）,如 果 你 没 有 提 供 此 属 性,那 么 使 用
<jsp:plugin>的 jsp文件的目录将会被使用 。
4,name="instanceName"
这个 Bean或 applet实例的名字,它将会在 Jsp其它的地方调用 。
<jsp:plugin>例子
<jsp:plugin type=applet code="MediaPlay.class"
codebase="../classes">
<jsp:params>
<jsp:param name="way" value="Hall" />
</jsp:params>
<jsp:fallback>
<p>Unable to load applet</p>
</jsp:fallback>
</jsp:plugin>
<jsp:useBean>
创建一个 Bean实例并指定它的名字和作用范围 。
JSP 语法格式如下：
<jsp:useBean
id="beanInstanceName"
scope="page | request | session | application"
{
class="package.class" |
type="package.class" |
class="package.class" type="package.class" |
beanName="{package.class | <%= expression
%>}"
type="package.class"
}
{
/> |
> other elements </jsp:useBean>
}
属性以及用法
1,id="beanInstanceName"
在所定义的范围中确认 Bean的变量,使之能在后面的程序中使用此变量名来分辨不同的 Bean,这个变量名对大小写敏感,必须符合所使用的脚本语言的规定,这个规定在 Java Language 规范已经写明 。
如果 Bean已经在别的,<jsp:useBean>”标记中创建,
则当使用这个已经创建过 Bean时,id的值必须与原来的那个 id值一致；否则则意味着创建了同一个类的两个不同的对象 。
2,scope="page | request | session |
application"
Bean存在的范围以及 id变量名的有效范围 。
缺省值是 page,以下是详细说明：
page - 能在包含,<jsp:useBean>”元素的 JSP文件以及此文件中的所有静态包含文件中使用这个
Bean,直到页面执行完毕向客户端发回响应或转到另一个文件为止 。
request - 在任何执行相同请求的 Jsp文件中使用这个 Bean,直到页面执行完毕向客户端发回响应或转到另一个文件为止 。 能够使用 Request对象访问这个
Bean,比如
request.getAttribute(beanInstanceName)。
session - 从创建 Bean开始,就能在任何使用相同
session的 jsp文件中使用这个 Bean。 这个 Bean存在于整个 Session生存周期内,任何在分享此 Session
的 Jsp文件都能使用同一 Bean。 注意在创建这个 Bean
的 Jsp文件中,<% @ page %>”指令中必须指定
,session="true"”。
application - 从创建 Bean开始,就能在任何使用相同 application的 Jsp文件中使用
Bean。 这个 Bean存在于整个 application生存周期内,任何在分享此 application的 Jsp文件都能使用同一 Bean.
3,class="package.class"
使用 new关键字以及 class构造器从一个 class中实例化一个 bean。 这个 class不能是抽象的,必须有一个公用的,
没有参数的构造器 。 这个 package的名字区别大小写 。
4,type="package.class"
如果这个 Bean已经在指定的范围中存在,那么赋予这个
Bean一个的数据开库类型 。 如果使用 type属性的同时没有使用 class或 beanName,Bean将不会被实例化 。 注意
package和 class的名称区分大小写 。
5,beanName="{package.class | <%= expression
%>}" type="package.class"
使用 java.beans.Beans.instantiate方法来从一个 class
或串行化的模板中实例化一个 Bean,同时指定 Bean的类型 。 Beans.instantiate方法将检查此名称是否表示一个类或一个串行化模板 。 如果这个 Bean是被串行化的,
那么 Beans.instantiate方法将通过使用一个类装载器读取串行化格式 （ 类似 package.class.ser） 。
beanName可以是 package和 class,也可以是表达式,它的值会传给 Beans.instantiate方法 。 type的值可以和 Bean相同,也可以是它的基类,或者是它所实现的接口 。 package
和 class 名字区分大小写 。
<jsp:getProperty>
JSP 语法格式如下：
<jsp:getProperty name="beanInstanceName"
property="propertyName" />
属性：
1,name="beanInstanceName"
bean的名字,由 <jsp:useBean>指定 。
2,property="propertyName"
所指定的 Bean的属性名 。
<jsp:getProperty>例子
<html>
//声明引用的 bean
<jsp:useBean id="calendar" scope="page"
class="employee.Calendar" />
<head>
<title>test</title>
</head>
<body>
Calendar of <jsp:getProperty name="calendar"
property="username" />
</body>
</html>
<jsp:setProperty>
设置 Bean的属性值,
JSP 语法格式如下：
<jsp:setProperty
name="beanInstanceName"
{
property= "*" |
property="propertyName"
[ param="parameterName" ] |
property="propertyName" value="{string | <%=
expression %>}"
}
/>
属性
1,name="beanInstanceName"
表示已经在,<jsp:useBean>”中创建的 Bean实例的名字 。
2,property="*"
储存用户在 jsp输入的所有值,用于匹配 Bean中的属性 。
3,property="propertyName"
[ param="parameterName" ]
用一个参数值来指定 Bean中的一个属性值,
一般情况下是从 request对象中获得的 。 其中 property指定 Bean的属性名,param指定
request中的参数名 。
4,property="propertyName" value="{string |
<%= expression %>}"
使用指定的值来设定 Bean属性 。 这个值可以是字符串,
也可以是表达式 。 如果这个字符串,那么它就会被转换成 Bean属性的类型 （ 转换方法见表 4.1） 。 如果是一个表达式,那么它的类型就必须和将要设定的属性值的类型一致 。
如果参数值为空值,那么对应的属性值也不会被设定 。
此外,不能在同一个,<jsp:setProperty>”中同时使用
param和 value参数 。
package rmg;
public class student {
private long classNo;
private String name;
private int age;
private boolean sexy;
public student() { //构造函数
classNo=970431;
name="ZZZl";
age=34;
sexy=true;
}
例,//建立类 rmg.student
public long getClassNo() {
return classNo;
}
public void setClassNo(long no) {
this.classNo=no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name=name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age=age;
}
public boolean getSexy() {
return sexy;
}
public void setSexy(boolean sexy) {
this.sexy=sexy;
}
}
<%--JavaBean.jsp文件，理解 useBean动作的 scope作用范围 --%>
<html>
<body>
<%-- 引用自己编写的 javaBean生成的 bean组件 --%>
<jsp:useBean id="student" scope="application" class="rmg.student" />
<%=student.getname()%><br>
<% student.setname("cong"); %>
<%-- 用 getProperty动作来返回 bean组件的属性值 --%>
<jsp:getProperty name="student" property="classNo" /> <br>
<jsp:getProperty name="student" property="name" /> <br>
<jsp:getProperty name="student" property="age" /> <br>
<jsp:getProperty name="student" property="sexy" /> <br>
<%-- 取属性值 --%>
<%=student.getClassNo() %> <br>
<%=student.getName() %> <br>
<%=student.getAge() %> <br>
<%=student.getSexy() %> <br>
<%--引用 Java类库中生成的 bean组件 --%>
<jsp:useBean id="date" scope="session"
class="java.util.Date" />
<%=date%><br>
</body>
</html>
第一次运行结果以后运行结果第一行发生变化测试 session作用域
<%--JavaBean1.jsp文件，理解 useBean动作的 scope作用范围 -->
<%@ page contentType="text/html;charset=gb2312" %>
<html>
<body>
<%-- 引用自己编写的 javaBean生成的 bean组件 --%>
<jsp:useBean id="student" scope="session" class="rmg.student" />
<!--用 setProperty动作设定 bean组件的属性值 -->
<jsp:setProperty name="student" property="classNo" value="000001"/>
<jsp:setProperty name="student" property="name" value="wanglan"/>
<jsp:setProperty name="student" property="age" value="22"/>
<jsp:setProperty name="student" property="sexy" value="true"/>
<%-- 取属性值 --%>
<%=student.getClassNo() %> <br>
<%=student.getName() %> <br>
<%=student.getAge() %> <br>
<%=student.getSexy() %> <br>
<!--用 JSP类属性设定 bean组件的属性值 -->
<%student.setClassNo(000002); %>
<%student.setName("John"); %>
<%student.setAge(26); %>
<%student.setSexy(false); %>
<br>
<%=student.getClassNo() %> <br>
<%=student.getName() %> <br>
<%=student.getAge() %> <br>
<%=student.getSexy() %> <br>
</body>
</html>
运行结果实践：练习 JSP编程
1,HelloWorld.jsp 最简单的 jsp程序
2,Scripting.jsp 程序片段
3,Declaration.jsp 变量的声明
4,Directive.jsp 和 Top.htm 和 Bottom.jsp
Directives语法
5,Include.jsp 和 Date.jsp include指令
6,News.jsp 和 Item1.htm 和 Item2.htm 和
Item3.htm 和 Item4.htm <jsp:include >的使用
7,ForwardTest.jsp 和 morning.htm 和 afternoon.jsp
<jsp:forward >的使用
3,5.1.3 JSP内置对象
JSP 有以下九种内置对象,包括：
·request,请求对象
·response,响应对象
·pageContext,页面上下文对象
·session,会话对象
·application,应用程序对象
·out,输出对象
·config,配置对象
·page,页面对象
·exception,例外对象重点介绍
request,请求对象
session,会话对象
application,应用程序对象综述
有几种对象看起来和 ASP的内置对象差不多,功能也类似,这是因为这些内置对象的构建基础是标准化的 HTTP协议 。
如果使用过 ASP,又对 Java有一定的了解的话,那么对这几种 JSP内置对象的使用应该能迅速掌握 。 需要注意的问题是对象名的写法,包括这些对象方法的调用时也要书写正确,因为 Java语言本身是大小写敏感的 。
从本质上讲,JSP的这些内置对象其实都是由特定的 Java类所产生的,在服务器运行时根据情况自动生成,所以如果你有较好的
Java基础,可以参考相应的类说明,表 3.1给出了他们的对应关系 。 更进一步的讲解将会在讲解 Servlet的一章中展开,如果你的 Java
基础不太好,可以先熟悉在这一章里所介绍的各种方法的使用 。
request和 response
,request” 对象代表的是来自客户端的请求,例如我们在 FORM表单中填写的信息等,是最常用的对象 。
关 于 它 的 方 法 使 用 较 多 的 是 getParameter,
getParameterNames和 getParameterValues,通过调用这几个方法来获取请求对象中所包含的参数的值
,response” 对象代表的是对客户端的响应,也就是说可以通过,response”对象来组织发送到客户端的数据 。 但是由于组织方式比较底层,所以不建议普通读者使用,需要向客户端发送文字时直接使用,out” 对象即可 。
request对象示例
<html><body>
<form action="./Hello_req.jsp">
姓名 <input type="text" name="UserName">
<input type="submit" value="提交 ">
</form>
</body></html>
request对象示例（ Hello_req.jsp
<%@ page contentType="text/html;gb2312" %>
<%@ page import="java.util.*" %>
<HTML>
<BODY>
你好,
<%! String Name;%>
<%
Name=request.getParameter("UserName");
%>
<%=Name%>,
今天是
<%
Date today=new Date();
%>
<%=today.getDate()%>号，星期 <%=today.getDay()%>
</BODY>
</HTML>
request对象示例（输出结果）
<HTML>
<BODY>
你好,
独孤求败,
今天是
9号，星期 1
</BODY>
</HTML>
pageContext
,pageContext” 对象直译时可以称作,页面上下文,对象,代表的是当前页面运行的一些属性,常用的方法包括 findAttribute,
getAttribute,getAttributesScope 和
getAttributeNamesInScope,一 般 情 况 下
,pageContext” 对象用到得也不是很多,只有在项目所面临的情况比较复杂的情况下,才会利用到页面属性来辅助处理 。
session对象
,session” 对象代表服务器与客户端所建立的会话,当需要在不同的 JSP页面中保留客户信息的情况下使用,比如在线购物,客户轨迹跟踪等 。,session” 对象建立在 cookie的基础上,所以使用时应 注意判断 一下客 户端是否 打开 了
cookie 。 常 用 的 方 法 包 括 getId,
getValue,getValueNames和 putValue
等 。
session对象
概要
HTTP是无状态（ stateless）协议；
Web Server 对每一个客户端请求都没有历史记忆；
Session用来保存客户端状态信息；
由 Web Server 写入；
存于客户端；
客户端的每次访问都把上次的 session记录传递给 Web
Server；
Web Server读取客户端提交的 session来获取客户端的状态信息；
session对象示例 (Form表单 —
Logon_session.html)
<html><body>
<form action="./Logon_session.jsp">
姓名 <input type="text" name="UserName">
<input type="submit" value="提交 ">
</form>
</body></html>
session对象示例
Logon_session.jsp
<%@page contentType="text/html;gb2312" %>
<%@page import="java.util.*" %>
<HTML>
<BODY>
<%
String Name=request.getParameter("UserName");
session.putValue("LogName",Name);
%>
你的名字 "<%=Name%>"已经写入 session
<br>
<a href='./check_session.jsp'>check</a>
</BODY>
</HTML>
session对象示例
(Check_session.jsp)
<%@page contentType="text/html;gb2312" %>
<HTML><BODY>
<%
String yourName=(String)session.getValue("LogName");
if (yourName= =null)
{
%>您还未登录
<%
}else
{
%>
"<%=yourName%>"已经登录
<%
}
%>
</BODY></HTML>
application对象
,application” 对象负责提供应用程序在服务器中运行时的一些全局信息,常用的方法有 getMimeType和 getRealPath等 。
out
,out” 对象代表了向客户端发送数据的对象,与
,response” 对象不同,通过,out” 对象发送的内容将是浏览器需要显示的内容,是文本一级的,
可以通过,out” 对象直接向客户端写一个由程序动态生成 HTML文件 。 常用的方法除了 pirnt和
println之外,还包括 clear,clearBuffer,flush、
getBufferSize和 getRemaining,这是因为,out”
对象内部包含了一个缓冲区,所以需要一些对缓冲区进行操作的方法 。
config,page,exception
,config” 对象提供一些配置信息,常用的方法有
getInitParameter和 getInitParameterNames,以获得 Servlet初始化时的参数 。
,page” 对象代表了正在运行的由 JSP文件产生的类对象,不建议一般读者使用 。
,exception” 对象则代表了 JSP文件运行时所产生的例外对象,此对象不能在一般 JSP文件中直接使用,而只能在使用了,<%@ page
isErrorPage="true "%>”的 JSP文件中使用
request请求对象
1,getAttribute
原型,public java.lang.Object
getAttribute(java.lang.String name)
说明：以对象的形式返回特定名称的属性值。
这个方法允许 Servlet引擎给出一个客户请求的特定信息。 （ Servlet为服务器端小程序，
所有 JSP页面都事先翻译成 Servlet后才执行）
request请求对象
如果所给名称的属性不存在将返回空值 。
属性名应该遵循和包命名方式同样的约定,
不要采用如,java.*”,,javax.*”及,sun.*”.
这样的命名 。
参数,name 一个标示属性名的字符串
返回值：一个包含属性值的对象，当属性不存在是为空。
request对象使用示例
（ peixun2.11.jsp ）
<%@ page contentType="text/html;charset=gb2312" %>
<html>
<head>
<title>request</title>
</head>
<body>
<form method="POST" action="post.jsp">
<p align="center">用户登录
<p align="center">
用户名,<input type="text" name="User"
size="20">&nbsp;&nbsp;&nbsp;&nbsp;
密码,<input type="password" name="pwd" size="20"><br> <br>
浏览器类型,<input type="radio" name="radio" value="ie" checked >IE
&nbsp;&nbsp;
<input type="radio" name="radio" value="ns">Netscape <br>
资料选项：
<input type="checkbox" name="check1" value="ON" checked>标题
<input type="checkbox" name="check2" value="ON">详细
<input type="hidden" name="hidden" value="transPara">
</p><p align="center">
<input type="submit" value=" 提交 ">
<input type="reset" value="全部重写 "></p>
</form>
</body>
</html>
Post.jsp代码
<%@ page contentType="text/html;charset=gb2312"%>
<html>
<head><title>test</title></head>
<body>
<%
out.println("用户名,"+request.getParameter("User")+"<br>");
out.println("密码,"+request.getParameter("pwd")+"<br>");
out.println("浏览器,"+request.getParameter("radio")+"<br>");
out.println("标题,"+request.getParameter("check1")+"<br>");
out.println("详细,"+request.getParameter("check2")+"<br>");
out.println("隐含,"+request.getParameter("hidden")+"<br>");
out.println("getContentLength()="+request.getContentLength()+"<br>");
out.println("getContentType()="+request.getContentType()+"<br>");
out.println("getRequestURI()="+request.getRequestURI()+"<br>");
out.println("getServerPort()="+request.getServerPort()+"<br>");
out.println("getServerName()="+request.getServerName()+"<br>");
out.println("getProtocol()="+request.getProtocol()+"<br>");
out.println("getRemoteAddr()="+request.getRemoteAddr()+"<br>");
out.println("getHeaderNames()="+request.getHeaderNames()+"<br>");
out.println("getMethod()="+request.getMethod()+"<br>");
out.println("getServletPath()="+request.getServletPath()+"<br>");
out.println("isRequestedSessionIdValid()="+request.isRequestedSessionIdVa
lid()+
"<br>");
%>
</body>
</html>
运行结果
session对象示例
<%--session对象示例,peixun2.12.jsp文件代码 --%>
<%@ page contentType="text/html;charset=gb2312"%>
<html>
<head><title>session</title></head>
<body>
<form method="post" action="post1.jsp">
请输入您的姓名：
<input type="text" name="username">
<input type="submit" value="submit">
</form >
</body>
</html>
post1.jsp
<%@ page contentType="text/html;charset=gb2312"%>
<html>
<head><title>post.jsp</title></head>
<body>
<%@ page language="java" %>
<%! String name=""; %>
<p>
<%
name = request.getParameter("username");
//将 username存入 session
session.putValue("username",name);
%>
您的姓名是,<%=name%>
<p><form method="post" action="post11.jsp">
您最喜欢的娱乐是：
<input type="text" name="amuse">
<input type="submit" value="submit"> </p>
</form>
</body>
</html>
post11.jsp
<%@ page contentType="text/html;charset=gb2312"%>
<html>
<head><title>post1.jsp</title></head>
<body>
<%@ page language="java"%>
<%! String amuse=""; %>
<%
amuse=request.getParameter("amuse");
String user=(String)session.getValue("username");
%>
您的姓名是,<%=user%>
您喜欢的娱乐是,<%=amuse%>
</body>
</html>
运行结果提交后输入值再次提交（保存名字）
application对象运行示例
<%--application对象示例,peixun2.13.jsp文件代码 --%>
<%@ page contentType="text/html;charset=gb2312"%>
<html>
<head><title>application</title><head>
<body>
<% out.println("Java Servlet API Version "+application.getMajorVersion()
+"."+application.getMinorVersion()+"<br>");
out.println("peixun2.13.jsp's MIME type
is:"+application.getMimeType("peixun2.13.jsp")
+"<br>");
out.println("URL of 'peixun2.13.jsp' is,
"+application.getResource(“/peixun2.13.jsp")+"<br>");
out.println("getServerInfo()="+application.getServerInfo()+"<br>");
out.println(application.getRealPath(" "));
application.log("Add a Record to log_file"); %>
</body>
</html>
运行结果
application对象实现网页计数器
<%--用 application对象实现网页计数器 peixun2.14.jsp文件代码 --%>
<%@ page contentType="text/html;charset=gb2312"%>
<html>
<head><title>网页计数器 </title><head>
<body>
<% if (application.getAttribute("counter")==null)
application.setAttribute("counter","1");
else{
String strnum=null;
strnum=application.getAttribute("counter").toString();
int icount=0;
icount=Integer.valueOf(strnum).intValue();
icount++;
application.setAttribute("counter",Integer.toString(icount));
} %>
您是第 <%=application.getAttribute("counter")%>位访问者！
</body>
</html>
运行结果 (第一次访问 )
刷新一次
exception对象示例
<%--exception对象示例,ErrorPage.jsp文件代码 --%>
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page isErrorPage="true" %>
<html>
<body bgcolor="#ffffc0">
<h1>Error page login</h1>
<br>An error occured in the bean,Error Message is,<br>
<%= exception.getMessage() %><br>
<%= exception.toString()%><br>
</body>
</html>
内置对象小结
全面介绍了 JSP的几种内置对象 。 熟练使用这些内置对象是开发 JSP应用程序的基本要求,尤 其 是 对 于 request,session 和
application对象更是必须要掌握的 。
会使用对象所具有的方法,能熟练使用每一种对象的几种常用方法 。
3,5.1.4 HTML表单
复习 Web运行原理
HTML表单的概念
表单元素介绍
HTML表单的客户端确认
客户端表单确认实例
Web运行原理－ 1
客户端同 Web服务器之间的协议为 http
HTTP为超文本传输协议
HTPP协议为“请求和响应”协议
客户端请求包括：请求行、头、信息体
客户端请求的方法
GET,POST,HEAD
DELETE,TRACE,PUT
提交表单的方法,GET,POST
Web运行原理－ 2
服务器接收到请求后，返回 HTTP响应
每个响应：状态行、头、信息体
常见状态
404 所请求的文件不存在
500 服务器程序出错
200 OK 成功
信息体用于浏览器显示页面访问失败
HTML表单
表单是具有输入域、文本域的页面
用于客户端同服务器端交互
用户在客户端填写表单，然后“提交”
表单中的信息发送到服务器
服务器返回处理情况
HTML表单标记
表单主标记
<form> </form>
表单中的标记
<input>
<select> </select>
<option>
<textarea> </textarea>
<form>是表单开始标记,</form>结束表单的例子（ peixun2.15.jsp）
<%--表单例子,peixun2.15.jsp文件代码 --%>
<%@ page contentType="text/html;charset=gb2312"%>
<html>
<head><title>表单 </title><head>
<body>
<form method="POST" action="">
<p align="center">用户登录
<p align="center">
用户名,<input type="text" name="User" size="20">&nbsp;&nbsp;&nbsp;&nbsp;
密码,<input type="password" name="pwd" size="20"><br> <br>
</form>
</body>
</html>
运行结果
form标记
描述表单的特性，语法
<form method="POST" action=",enctype=“”>
method表单传输方法
GET方法将表单信息在 URL后传输
POST方法将表单信息作为信息体传输
action为表单处理方式，通常为一个 URL
enctype为编码方式
<input>标记
表单中输入信息的区域
属性
type 类型
name 名称
id 标识
maxlength 最大字符数
size 输入域宽度
value 域的初始值
button 按钮 用 javascript响应
<input>的类型
text 文本
passwowrd 口令方式
checkbox 多选框 name相同
radio 单选按钮 name相同
image 图片
hidden 隐藏表单 发送数据
submit 提交按钮 向服务器提交表单
reset 复位按钮 将表单充置为初始状态文本框,TEXTAREA
多行文本域,<textarea> </textarea>
参数
COLS：宽度
ROWS：高度
NAME：名称
<textarea NAME=“Computer” ROWS=6 COLS=64>
CPU PIV 1500
Memory 512M
</textarea>
下拉框,SELECT
定义列表框,<select> </select>
参数
MULTIPLE 可同时选取多行
NAME 名称
SIZE 可见项目数
每个项目用 option标记
属性 SELECTED出现在 option表示选中
select的例子
<select name="area" style="width"50" size="1">
<option value="北京 " selected > 北京 </option>
<option value="天津 " > 天津 </option>
<option value="上海 " > 上海 </option>
<option value="重庆 " > 重庆 </option>
</select>
表单提交
提交方式：
submit类型按钮提交表单
通过普通按钮的 javascript函数
传输方法依据 <form>中的 method
推荐使用 POST
传输编码依据 <form>中的 enctype
处理方式依据 <form>中的 action
<input type="submit" value=" 提交 ">
表单清除
reset按钮重置表单为初始值
<input type="reset" value="全部重写 "></p>
综合例子
<%--表单综合例子,peixun2.16.jsp文件代码 --%>
<%@ page contentType="text/html;charset=gb2312"%>
<html>
<head><title>表单 </title><head>
<body>
<form method="POST" action="">
<p align="center">用户注册
<p align="center">
用户名,<input type="text" name="User" size="20">&nbsp;&nbsp;&nbsp;&nbsp;
密码,<input type="password" name="pwd" size="20"><br> <br>
<p>你喜欢：
<input type="checkbox" name="sports" value=football> 足球
<input type="checkbox" name="sports" value=bastketball> 篮球
&nbsp;&nbsp;&nbsp;&nbsp;
性别：
<input type="radio" name="sexy" value=male> 男
<input type="radio" name="sexy" value=female> 女 <br><br>
<p>你的计算机 </p>
<textarea NAME=“Computer” ROWS=6 COLS=64>
CPU PIV 1500
Memory 512M
</textarea><br><br>
<p>你计算机的操作系统
<input type="image" name="os" src="images\TURBOLINUX6.GIF">
&nbsp;&nbsp;&nbsp;&nbsp;
你所在地：
<select name="area" style="width"50" size="1">
<option value="北京 " selected > 北京 </option>
<option value="天津 " > 天津 </option>
<option value="上海 " > 上海 </option>
<option value="重庆 " > 重庆 </option>
</select>
<br> <br>
<input type="submit" value=" 提交 ">
<input type="reset" value="全部重写 "></p>
</form>
</body>
运行结果表单的确认
客户端确认
减少服务器负载
缩短用户等待时间
兼容性难
服务器端确认
统一确认
兼容性强
服务器负载重客户端确认
采用 javascript进行确认
常用函数
isBetween
isDate
isTime
isDigit
isEmail
isEmpty
isInt
isReal
客户端确认例子
<%--客户端确认例子,peixun2.17.jsp文件代码 --%>
<%@ page contentType="text/html;charset=gb2312"%>
<html>
<head><title>客户端确认 </title><head>
<body>
<form method="POST" name="frm1" onsubmit="return checkform(this)">
<p align="center">用户登录
<p align="center">
用户名,<input type="text" name="name" size="20">&nbsp;&nbsp;&nbsp;&nbsp;
密码,<input type="password" name="pwd" size="20"><br> <br>
<input type="submit" value=" 提交 ">
<input type="reset" value="全部重写 "></p>
</form>
<SCRIPT language=JavaScript>
function checkform(frm){
var flag=true;
if(frm.name.value=="")
{
alert("姓名不能为空，请输入值！ ");
frm.name.focus();
flag=false;
}
return flag;
}
</SCRIPT>
</body>
</html>
运行结果
3,5.1.4 JSP与客户机的交互
从表单中获得参数
返回参数
表单的服务器端确认从表单中获得参数
JSP通过 request内置对象获取表单信息
用不同的方法获取不同种类的信息
获取参数的主要方法：
getParameter() 获取参数的值
getParameterNames() 获取参数的名称
getParameterValues() 获取多个值
getParameter()
可以获得文本框、文本区域、单选、多选的值
表单中各元素的 NAME属性是它的唯一标识，
用它获取参数。
参考 peixun2.11.jsp及 post.jso
<input type="text" name="User" >
request.getParameter("User");
向客户端输出
使用内置对象 out
out.println(content)
使用,=”
<%= content% >
参看 peixun2.11.jsp和 post.jsp
out.println("用户名," +User+"<br>");
参看 peixun2.14.jsp
您是第 <%=application.getAttribute("counter")%>位访问者！
表单的服务器端确认
在客户端不能用 JSP进行确认
分工：数据处理在服务器端
实效性：客户端得到服务器确认后表明数据已经到达服务器
客户端兼容性好
缺点：加大服务器负载和用户等待时间服务器端确认方法
采用 Java类对表单数据进行复杂的检查
采用 JSP进行确认服务器端确认的例子
<%--服务器端确认例子,peixun2.18.jsp文件代码 --%>
<%@ page contentType="text/html;charset=gb2312"%>
<html>
<head><title>服务器端确认 </title><head>
<body>
<form method="POST" name="frm1" action="loginAction.jsp">
<p align="center">用户登录
<p align="center">
用户名,<input type="text" name="name" size="20">&nbsp;&nbsp;&nbsp;&nbsp;
密码,<input type="password" name="pwd" size="20"><br> <br>
<input type="submit" value=" 提交 ">
<input type="reset" value="全部重写 "></p>
</form>
</body>
</html>
loginAction.jsp
<%--服务器端确认例子,loginAction.jsp确认表单文件代码 --%>
<%@ page contentType="text/html;charset=gb2312"%>
<html>
<head><title>确认 JSP</title></head>
<body>
<%
String name=request.getParameter("name");
String pwd=request.getParameter("pwd");
if((name!=null)&&(!name.equals("")))
{
name=new String(name.getBytes("ISO8859_1"),"gb2312");
out.println("用户名," +name+"<br>");
out.println("密码,"+pwd+"<br>");
}
else{
%>
<p align="center">用户名不能为空 </p><br><br>
<form method="POST" name="frm1" action="loginAction.jsp">
<p align="center">用户登录
<p align="center">
用户名,<input type="text" name="name" size="20" value="<%=name%>">
&nbsp;&nbsp;&nbsp;&nbsp;
密码,<input type="password" name="pwd" size="20" value="<%=pwd%>"><br> <br>
<input type="submit" value=" 提交 ">
<input type="reset" value="全部重写 "></p>
</form>
<%}%>
</body>
</html>
运行结果（ TOMCAT）
(未输入姓名 )直接提交输入用户名输入用户名后提交
JSP的汉字问题的原理
客户端和服务器用 gb2312
HTTP传输编码用 ISO8859_1
服务器需要指示客户端文档的编码方式
ISO8859_1 ISO8859_1
gb2312 gb2312
JSP的汉字问题出现环节
客户端显示文档时的编码方式（由服务器中的 JSP,Servlet指明）
客户端发送汉字时自动转换为 iso8859_1
服务器中采用 gb2312对汉字编码，接收到客户端汉字需要转换为 gb2312
服务器端将 JSP转换为 Servlet时自动将汉字转换为 iso8859_1
服务器端应该告诉客户端汉字的编码方式
JSP汉字问题的范围
JSP文件的汉字问题
表单处理的汉字问题
Servlet的汉字问题（以后讲解）
JDBC的汉字问题（以后讲解）
JSP文件的汉字问题
JSP中的汉字字符串在服务器端用 gb2312
在编译为 Servlet时自动转换为 iso8859_1
汉字在传输中是正确的
在没有特别指示下，浏览器中无法正确显示
在 HTML中指示浏览器文档的编码（ myJSP\index.html）
<meta http-equiv="Content-Type" content="text/html;
charset=gb2312">
在 JSP中指示 JSP引擎文档的编码
<%@ page contentType="text/html;charset=gb2312"%>
每个要显示汉字的 JSP文档都应该包含该语句
JSP文件的汉字问题 (JSPhanzi.jsp)
<%--JSP的汉字问题 JSPhanzi.jsp--%>
<html>
<head>
<title>JSP中的汉字问题 </title>
</head>
<body>
<%
String HelloMsg="你好 ";
out.println(HelloMsg);
%>
</body>
</html>
<html>
<head>
<title>JSP中的汉字问题 </title>
</head>
<body>
你好
</body>
</html>
JSP中增加编码指示后
<%--JSP的汉字问题 JSPhanzi.jsp--%>
<%@ page contentType="text/html;
charset=gb2312"%>
<html>
<head>
<title>JSP中的汉字问题 </title>
</head>
<body>
<%
String HelloMsg="你好 ";
out.println(HelloMsg);
%>
</body>
</html>
<html>
<head>
<title>JSP中的汉字问题 </title>
</head>
<body>
你好
</body>
</html>
表单处理中的汉字问题
表单处理涉及到客户端和服务器的完整交互过程
在客户端和服务器是 gb2312，传输用
ISO8859_1
在服务器端接收到客户端数据时需要转换为
gb2312后进行处理，方法
name=new String(name.getBytes("ISO8859_1"),"gb2312");
服务器端指示客户端汉字的显示编码
<%@ page contentType="text/html;charset=gb2312"%>
表单处理的汉字问题 (hanzi.jsp)
<%--表单处理的汉字问题,hanzi.jsp文件代码 --%>
<%@ page contentType="text/html;charset=gb2312"%>
<html>
<head><title>表单处理的汉字问题 </title><head>
<body>
<form method="POST" name="frm1"
action="hanziAction.jsp">
<p align="center">用户登录
<p align="center">
用户名,<input type="text" name="name" size="20">
<input type="submit" value=" 提交 ">
</form>
</body>
</html>
<html>
<head><title>表单处理的汉字问题 </title><head>
<body>
<form method="POST" name="frm1“
action="hanziAction.jsp">
<p align="center">用户登录
<p align="center">
用户名：
<input type="text" name="name" size="20">
<input type="submit" value=" 提交 ">
</form></body></html>
处理过程
<%--hanziAction.jsp--%>
<%@page contentType="text/html;
charset=gb2312"%>
<html>
<head>
<title>表单中汉字的处理 </title>
</head>
<body>
<%
String name=request.getParameter("name");
//name=new String(name.getBytes("ISO8859_1"),
"gb2312");
out.println("用户名," +name+"<br>");
%>
</body>
</html>
<html>
<head>
<title>表单中汉字的处理 </title>
</head>
<body>
用户名,<br>
</body>
</html>
处理过程（修改后）
<%--hanziAction.jsp--%>
<%@page contentType="text/html;
charset=gb2312"%>
<html>
<head>
<title>表单中汉字的处理 </title>
</head>
<body>
<%
String name=request.getParameter("name");
name=new String(name.getBytes("ISO8859_1"),
"gb2312");
out.println("用户名," +name+"<br>");
%>
</body>
</html>
<html>
<head>
<title>表单中汉字的处理 </title>
</head>
<body>
用户名：测试 <br>
</body>
</html>
3,5.1.6 实践：练习 JSP编程
分析 softshop的首页及用户认证
编写综合练习的首页、认证和注册页面
注意汉字问题综合练习综合练习：我的网上商店 myshop,具有以下功能
用户登录,注册
口令空转向 loginError.jsp（ 采用 <jsp:forward >）
建立 web应用 myshop,参考 softshop目录结构
体会表单的两种发送方法页面设计：
完成首页,用户登录,注册 （ index.jsp,login.jsp,registor.jsp）
首页 index.jsp包括简介,商品分类,新注册用户,登录用户计数,
按钮：用户登录,注册
用户计数采用 application对象
login.jsp包括输入用户名,口令的表单,用户名是否为空由服务器端确认,口令是否为空由客户端确认,处理表单的 jsp为
check.jsp,当口令为空时转向显示错误页面,登录成功时显示用户名和口令 （ 表单采用 GET方法发送 ）
3,5.1.6 实践：练习 JSP编程
－ 综合练习
registor.jsp中录入用户信息,综合使用表单的功能：
form标记 （ 表单采用 POST方法发送 ）
text：用户名,口令
radio按钮：性别
select：出生年月,所在地,行业 其中会使用到 option标记
checkbox：选择兴趣
textarea：自我介绍按钮：提交和重新输入
处理 registor.jsp的 jsp为 record.jsp,record.jsp接收 text,textarea,radio、
select的数据,并显示出来 （ 注意汉字问题 ） 。
record.jsp中用 session存储新注册的用户名 。
record.jsp包含返回首页 index.jsp的超链接
index.jsp中用 session提取新注册用户并显示习 题
1,用 Java或Ｃ＋＋实现ＣＭＰＰＶ３协议
2,用多线程编写一个 Applet，让一个红色小球从左边移动到右边，碰到边框再反弹回去。
3,如何通过 URL从服务器读取文件？