文章目录
-------------------------------------------------
一.指令元素
1.page指令
import
session
contentType
buffer
isTreadSafe
info
errorPage
isErrorPage
2.include指令
3.taglib指令
二.脚本元素
1.声明元素
2.表达式元素
3.脚本元素
4.注释元素
三.标准动作元素
1.<jsp:param>
2.<jsp:include>
3.<jsp:forward>
4.<jsp:plugin>
5.<jsp:useBean>
6.<jsp:setProperty>
7.<jsp:getProperty>
四.内置对象
1.request
2.response 
3.out
4.session
5.pageContext
6.application
7.config
8.page
9.exception
五.JavaBeans的使用
1.JavaBeans在JSP中的基本使用格式
2.scope范围的具体设定
3.session事件的运用
4.Bean的保存与读取
六.JSP中的文件操作
七.JSP运行原理剖析
-------------------------------------------------

在早期，开发网络数据库应用程序主要采用CGI（Common Gateway Interface）技术。编写CGI程序可以使用不同的程序语言，如Perl、Visual Basic、Delphi或C/C++等。虽然CGI技术已经发展成熟而且功能强大，但由于其编程困难、效率低下、修改复杂等缺陷，所以有被新技术取代的技术。
在这样的背景下，新的技术纷纷面世，如ASP（Active Server Page）、PHP（Personal Home Page）、JSP（Java Server Page）等。其中，JSP被许多人认为是未来最有发展前途的动态网站技术。
JSP页面一般由HTML标签和JSP元素构成，其中的JSP元素则又是由“指令元素”、“脚本元素” 、“标准动作元素” 、“内置对象”四个部分组成。下面，就让我们一起来探究JSP的奥秘吧……

一.    指令元素

可以把JSP理解为用来通知JSP引擎的消息。JSP不直接生成可见的输出，用JSP指令设置JSP引擎处理JSP页面的机制。
一般JSP指令用标签<%@…%>表示，JSP指令包括page、include和taglib。page指令是针对当前页面的指令，而include指令用来指定如何包含另外一个文件，taglib指令用来定义和访问自定义标记库。这三种指令通常都有默认值，这样开发人员就不必显式的使用每一个指令予以确认。
1.    page指令
page指令的设置语法格式是：<%@ page attribute1=”value1” attribute2=”value2”…%>
下面介绍指令中包括的几个常用属性，并作简要说明。
l    import
import指令是所有page指令中，唯一可以多次设置的指令，而且累加每个设置。它用来指定jsp网页中所需要使用到的一些类。例如：
<%@ page import=”java.io.*,java.util.Date”%>
l    session
定义当前页面是否参与http会话。当设置为”true”时，可以获得隐含名为session的对象，为”false”时，则不能。默认设置为”true”。
l    contentType
设置jsp网页输出时数据时，所使用的字符压缩方式，以及所使用的字符集，当编写中文网页时，设置如下：
<%@page contentType=”text/html;charset=Gb2312”%>
此属性的默认值为”text/html;charset=ISO-8859-1”。
l    buffer
设置jsp网页的缓冲区大小，默认为”8k”，如果设置为”none”，则表示不使用缓冲，所有的响应输出都将被PrintWriter直接写到ServletResponse中。
l    isTreadSafe
定义当前页面是否支持线程安全。如果为”true”，则该页面可能同时收到jsp引擎发出的多个请求，反之，jsp引擎会对收到的请求进行排队，当前页面在同一时刻只能处理一个请求。默认为”true”。
l    info
设置页面的文本信息，可以通过Servlet.getServletInfo()的方法获得该字符串。
l    errorPage
定义指向另一个jsp页面的URL。当页面出现一个没有被捕获的异常时，错误信息将以throw语句抛出，而被设置为错误信息网页的jsp页面，将利用exception隐含对象，取得错误信息。
默认没有错误处理页面。    
l    isErrorPage
设置此jsp网页是否为错误处理页面。默认值为”false”。当设置为”true”时，jsp页面将可存取隐含的exception对象，并通过该对象取得从发生错误之网页所传出的错误信息。取得错误信息的语法如下：
<% =exception.getMessage()%>
²    一个页面错误处理的例子
产生错误的页面文件为MakeError.jsp，处理错误的页面文件为ErrorPage.jsp，它们的源程序如下：
MakeError.jsp

运行程序MakeError.jsp的结果如下：
 
2.    include指令
使用include指令可以把其他的文本文件加入到当前的jsp页面，格式如下：
<%@ include file=”header.inc”%>
如此，则在当前页面中加入header.inc源代码然后再编译整个文件。
可以使用include指令把一个页面分成不同的部分，最后合成一个完整的文件，使用jsp的include指令有助于实现jsp页面的模块化。
3.    taglib指令
（略）

二.    脚本元素

JSP规格提供了四种类型的脚本元素，包括：
l    声明
l    表达式
l    脚本
l    注释
下面分别对它们进行详细叙述。
1.    声明元素
声明用于定义jsp页面中的变量与函数，这些经过定义的变量和函数，将成为Servlet类的属性与方法（关于Servlet请参看后文）。声明并不会产生任何的数据输出，声明时可同时设置初始值，提供给其他的声明、表达式或脚本使用。
声明的语法格式为：

²    jspInit函数与jspDestroy函数
若要在jsp页面开始执行时进行某些数据的初始化，可以利用jspInit函数完成。此函数将在jsp页面被执行时调用，且当jsp页面重新整理时，并不会被再度执行。当关闭服务器时，jspDestroy函数将被执行，可以利用该函数进行数据的善后处理工作。下面举个简单的例子说明，文件InitDes.jsp代码如下：

首次执行此页面时，Resin服务器输出如下：
Resin 1.2.2 -- Tue Jan 16 09:53:18 PST 2001
http listening to *:8080
srun listening to 127.0.0.1:6802
jspInit is called!
刷新此页面数次后，Resin服务器输出仍然如上。
此时，如果关闭服务器，则输出如下：
Resin 1.2.2 -- Tue Jan 16 09:53:18 PST 2001
http listening to *:8080
srun listening to 127.0.0.1:6802
jspInit is called!
closing server
jspDestroy is called!
由此，我们得到启发，在数据库的开发过程中，可以利用jspInit函数来进行数据库的连接工作，用jspDestroy函数来进行数据库的关毕工作。下面以一个分页显示数据库内容的程序为例子，让读者进一步体会jspInit与jspDestroy的功用与好处。
在Pages.jsp这个分页程序中，我们把数据库连接的动作写在jspInit函数中，这样，每一次重新整理页面时，就可以避免重新执行数据库的连接动作。如下：

执行后，结果如下图：
 
2.    表达式元素
表达式是一个简化了的out.println语句。
表达式的语法格式为：
<%=//要输出的数据%>
举例：
<%=square(5)%>
3.    脚本元素
脚本是java程序的一段代码，只要符合java语法的语句都可以写在这里，它是在请求时期执行的，它可以使用jsp页面所定义的变量、方法、表达式或JavaBeans。
脚本的语法格式为：

4.    注释元素
用来对程序进行说明注释。注释大体有下列三种格式：
<!—客户端注释à
<!--<%=客户端动态注释%>-->
<%--服务器端注释--%>

三.    标准动作元素

标准动作元素用于执行一些常用的JSP页面动作，例如：将页面转向、使用JavaBean、设置JavaBean的属性等。在JSP中，标准动作元素共有以下几种：
l    <jsp:param>
l    <jsp:include>
l    <jsp:forward>
l    <jsp:plugin>
l    <jsp:useBean>
l    <jsp:setProperty>
l    <jsp:getProperty>
其中<jsp:useBean>、<jsp:setProperty>、<jsp:getProperty>这三个是专门用来操作JavaBeans的。
下面分别介绍它们。
1.    <jsp:param>
<jsp:param>动作用于传递参数，必须配合<jsp:include>、<jsp:forward>、<jsp:plugin>动作一起使用。
语法格式：
<jsp:param name = “name1” value = “value1”/>
2.    <jsp:include>
<jsp:include>动作用于动态加载HTML页面或者JSP页面。
语法格式：
<jsp:include page = “网页路径”>
<jsp:param name = “name1” value = “value1”/>
<jsp:param name = “name2” value = “value2”/>
<jsp:include/>
在jsp页面中，可以利用下面的语法取得返回的参数：
request.getParameter(“name1”);
若不传递参数时，则语法格式如下：
<jsp:include page = “网页路径”/>
举例：
a.jsp页面代码如下：

b.jsp页面代码如下：
名字1、；<%=request.getParameter("name1")%>
<hr color=red>
名字2、；<%=request.getParameter("name2")%>
执行结果如下：
 
“include标准动作”和“include指令”的差别在于：“include标准动作”包含的页面在运行时被加入，而“include指令”在编译时就被加入了。
3.    <jsp:forward>
<jsp:forward>动作用于将浏览器显示的页面导向到另一个HTML页面或者jsp页面。
语法格式：
<jsp:forward page = “网页路径”/>
当然，<jsp:forward>动作中也可以加入<jsp:param>参数，其设置和获得参数的方法与<jsp:include>类似。
4.    <jsp:plugin>
<jsp:plugin>动作用于加载applet，用途与HTML语法中的<Applet>及<Object>标记相同。该动作是在客户端执行的，这里就不作介绍了。
5.    <jsp:useBean>
（见后文的“JavaBeans”的使用）
6.    <jsp:setProperty>
（见后文的“JavaBeans”的使用）
7.    <jsp:getProperty>
（见后文的“JavaBeans”的使用）

四.    内置对象

在jsp页面中有一些已经完成定义的对象，称之为内置对象。这些对象可以不经过定义就直接使用，因为它们是由jsp页面自己定义的。
jsp程序常用的内建对象有如下几个：request、response、out、session、pageContext、application、config、page、exception。你可以在jsp页面中直接使用它们，用以加强jsp程序的功能。
下面分别介绍它们。
1.    request
与request相联系的是HttpServletRequest类。通过getParameter方法可以获得相应的参数值。
2.    response 
与response相联系的是HttpServletResponse类。表示Web页面针对请求的应答。
3.    out
与out相联系的是PrintWrite类。可以使用此对象将内容输出到页面中。
4.    session
与session相联系的是HttpSession类。用来传递客户的会话内容。
5.    pageContext
与pageContext相联系的是pageContext类。用它能方便的访问本页面中设置的共享数据。
6.    application
与application相联系的是ServletContext类。用它能够实现应用程序级别的数据共享。
7.    config
与config相联系的是ServletConfig类。用来在jsp页面范围内处理jsp配置。
8.    page
代表jsp页面编译成的Servlet实例，一般不用。
9.    exception
与exception相联系的是Throwable类。用来捕获jsp执行时抛出的异常。
五.    JavaBeans的使用
JavaBeans是运行于java虚拟机上的100％的纯java组件，它的概念描述很类似于Microsoft的COM组件概念。
JavaBeans传统的应用在于可视化领域，如AWT下的应用。其实，基于AWT的任何java程序已经是一个Bean，完全可以把它当作一个组件来使用。
现在，JavaBeans更多的应用在不可视化领域，它在服务器端应用方面表现出了越来越强的生命力。不可视化的JavaBeans在JSP程序中用来封装事务逻辑，可以很好的实现业务逻辑和前台程序的分离，使得系统具有更好的健壮性和灵活性。
JavaBeans描述了JDK1.1以前的java所没有的东西，因此，运行JavaBeans最小的需求是JDK1.1或者以上的版本。
1.    JavaBeans在JSP中的基本使用格式
l    在JSP中调用JavaBeans的格式
//加载Bean
<jsp:useBean id = “名称” scope = “有效范围” class = “Bean类位置”/>

//设定Bean属性（两种方法）
//方法一：“标签设定”
<jsp:setProperty name = “名称” property = “属性” value = “值”/>
//方法二：“方法设定(用于java程序中)”
Bean对象名称.set属性(值)

//获取Bean属性（两种方法）
//方法一：“标签获取”
<jsp:getProperty name = “名称” property = “属性”/>
//方法二：“方法获取(用于java程序中)”
Bean对象名称.get属性()
l    JavaBean编写的格式
//定义Bean类所属于的包

²    一个简单的使用JavaBeans的例子
Bean文件LoginData.java的源代码如下：

调用Bean的jsp文件UseBean.jsp源程序如下：

运行结果如下：
 
在前面的使用中，有两点值得注意：
（1）    Bean中各个方法名的“命名规则及大小写”与调用Bean时的“方法名规则及大小写”之间的对应关系需要注意。
（2）    Beans的存放目录将随选用服务器的不同而不同。以resin服务器而言，Beans默认定义存放在application-programme\WEB-INF\classes子目录中。
2.    scope范围的具体设定
JavaBeans可以定义四种生命周期?D?Dpage、request、session与application，将分别运用pageContext、request、session、application四种对象的setAttribute方法，将JavaBeans对象保存在该对象中。下面分别说明：
l    Page的有效范围仅仅涵盖使用JavaBeans的页面，一旦你离开此页面，JavaBeans对象的实体也将随之消失。
l    Request的有效范围仅及于使用JavaBeans的请求而已，一旦你结束该页面的请求，JavaBeans对象的实体也将随之消失。
l    Session的有效范围涵盖了整个用户会话时期。在用户会话期间，JavaBeans对象的实体均不会消失。当用户会话结束时，JavaBeans对象的实体才会消失。
l    Application的有效范围则涵盖了整个应用程序时期。在应用程序期间，JavaBeans对象的实体均不会消失。只有当应用程序结束时，JavaBeans对象的实体才会消失。
下面，举一个简单的例子，对Request与Session两种生命周期做具体的演示。
Bean文件counter.java的源代码如下：

Request实例
两个jsp文件b1.jsp与b2.jsp代码分别如下：
b1.jsp

运行结果如下：
 
Session实例
两个jsp文件c1.jsp与c2.jsp代码分别如下：
c1.jsp
<jsp:useBean id="counter" scope="session" class="j2ee.jsp.counter"/>

<%
out.println(counter.getCount());
%>

<a href="c2.jsp" target="_blank">c2.jsp</a>
c2.jsp
<jsp:useBean id="counter" scope="session" class="j2ee.jsp.counter"/>

<%
out.println(counter.getCount());
%>
运行结果如下：
 
3.    session事件的运用
在jsp页面中，将Bean对象保存至session对象时，可以定义Bean响应HttpSessionBindingEvent事件。当Bean对象加入session、Bean从session中删除以及session对象终止时，将会触发此事件。因此，我们可以利用这两个事件，执行数据起始、善后的工作。
由此，我们可以想到，把jsp页面中最耗费服务器资源的数据库连接工作放入HttpSessionBindingEvent事件中。当一个会话开始时，建立一个“数据库连机”，随后的整个会话过程中，所有与数据库相关的操作均使用这一个“连机”，这样，就避免了每执行一次数据库操作就产生一个数据库连机的巨大消耗。当此会话结束时，再关闭释放这个“数据库连机”。
如果要Bean对象响应HttpSessionBindingEvent事件，则该Bean对象必须实现HttpSessionBindingListener接口，并且定义响应会话开始的valueBound方法以及响应会话结束的valueUnbound方法。
现在，我们来实做一个例子，首先，建立一个“用来建立会话级别数据库联机”的Bean文件DBCon.java，它的源代码如下所示：

编译这个Bean源文件。注意，编译前要设定好classpath的路径，使得它所包含的类库中有javax.servlet.http.*包。
然后，建立两个用来测试此Bean的jsp页面文件DBBean1.jsp与DBBean2.jsp，它们的程序代码差不多，都是用来显示数据库内容的，现在就只列出DBBean1.jsp的源文件，如下：

首次运行DBBean1.jsp文件时，浏览器显示如下：
 
Resin服务器的输出如下：
Resin 1.2.2 -- Tue Jan 16 09:53:18 PST 2001
http listening to *:8080
srun listening to 127.0.0.1:6802
BulidConnection()方法被调用
会话级别的数据库连接已经建立！！！
由此可知，当DBBean1.jsp文件中定义DBCon对象的生命周期为session时，就触发了HttpSessionBindingEvent事件，并调用了valueBound方法，建立了“会话级别的数据库联机”。
然后，我们再在DBBean2.jsp等多个页面中跳转，Resin服务器的输出仍然如上所示，这就表明了，同一会话中的各个页面均使用了同一个数据库联机，所以才没有建立新的联机。
当关闭服务器的时候，输出数据如下：
Resin 1.2.2 -- Tue Jan 16 09:53:18 PST 2001
http listening to *:8080
srun listening to 127.0.0.1:6802
BulidConnection()方法被调用
会话级别的数据库连接已经建立！！！
closing server
会话级别的数据库连接已经关闭！！！
此时，会话结束，触发了HttpSessionBindingEvent事件，并调用了valueUnbound方法，关闭了先前建立的会“话级别的数据库联机”。
4.    Bean的保存与读取
到目前为止，我们所使用的Bean对象均能于建立该对象的页面中使用，而无法将执行的结果保存下来供下次页面执行使用。现在，我们就来讨论一下Bean的保存的问题。
若要某个Bean对象保存进文件，就必须使该Bean可串行化，即该Bean必须实现java.io.Serializable接口。
另外，如果要把Bean对象保存进文件，或是从文件中读取Bean对象，需要用到四个特别的java.io包中的对象，它们是FileOutputStream、ObjectOutputStream、FileInputStream、ObjectInputStream，其中的前两个使用来保存Bean对象的，后两个则是用来读取Bean对象的。具体的使用方法，我们还是通过例子来说明吧！！！
²    Bean对象的保存与读取
我们将要建立如下几个文件，它们的用途及说明如下表：
文件名称    说明    用途
SaveBean.java    定义要保存进文件的Bean对象，此对象将实现Serializable接口。    此Bean中将保存姓名、性别、年龄、生日、爱好这五个个人信息。
BeanSaver.java    定义将Bean对象保存进文件，或是从文件中读取Bean对象的BeanSaver对象。    用来保存或是读取Bean对象。
SaveBean.jsp    建立SaveBean对象，并设定相应的个人信息，然后，把此对象写入文件。    建立SaveBean对象，并利用BeanSaver对象把SaveBean对象写入文件SB.ser。
LoadBean.jsp    利用BeanSaver对象，从文件中取得SaveBean对象。    从文件SB.ser中取得SaveBean对象，然后将其内容，即个人信息显示在页面上。
两个Bean的源文件如下：
SaveBean.java

编译上面的两个源文件，产生j2ee.jsp.SaveBean.class与j2ee.jsp.BeanSaver.class。
两个jsp页面的程序代码如下：
SaveBean.jsp

首先在运行SaveBean.jsp，结果如下：
 
然后运行LoadBean.jsp，显示如下：
 
至此，恭喜你已经学会了JavaBeans所有最核心的应用了，jsp强大的功用也已经展现在了你的眼前，快去构建威力无穷的Web应用吧，祝你一路顺风：） 。

六.    JSP中的文件操作

自从有了数据库系统以后，文件的操作似乎变得不再那么重要了，很多大型的应用系统也往往愿意把数据的存取工作交给数据库而不是文件。就笔者自身的体会是，数据库的确在很多时候可以替代文件，但在某些特定的应用上使用文件可以得到更佳的应用效果和方便的操作特性，而且在操作少量数据的存取时，文件不但方便保存携带，更不像数据库那样运行时需要消耗大量的服务器资源。因此，笔者认为，文件的操作仍然是一个重点。
要在JSP中操作文件，大体上需要用到java.io.*包中的数个类及其相应的方法，很多时候实现同一功能都有数种不同的方法。在此，笔者不想在各个类的基本定义格式及其相应方法的说明上多费笔墨，而是直接把一个集合了众多文件操作功能的Bean呈现在各位读者面前。使用此Bean，可以进行绝大多数的文件操作，至于其中具体到某个类、某个方法的操作原理及其细节，请各位参看相关资料。
下表列出了CtrlFile类的所有公开方法及其说明：
方法名    用途说明
createNewFile    建立一个新的文件
deleteFile    删除文件
createNewDir    建立一个新的目录
deleteDir    删除目录
fileLength    测量文件的长度
isFile    判断是不是文件
isDir    判断是不是目录
readLine    读取文件的第一行
readAll    读取整个文件的内容
writeLine    把数据写入文件
writeAppend    把数据追加入文件

七.    JSP运行原理剖析

谈到JSP的运行原理，就不得不谈到Servlet了。虽然按照Sun的观点，将来是要用JSP替代Servlet的，但JSP是在Servlet的基础上发展起来的，要深刻理解JSP的运行原理，就一定需要Servlet的相关知识。在阅读本节前，笔者假设你已经至少对Servlet有了基本的概念理解。OK，不再多说废话了，Let’s go！！
Servlet技术的出现时间很早，是当时为了Java的服务器端应用而开发的。大家都知道Applet是应用小程序，Servlet就是服务器端小程序了。但在Microsoft公司的ASP技术出现后，使用Servlet进行响应输出时一行行的输出语句就显得非常笨拙，对于复杂布局或者显示页面更是如此。JSP就是为了满足这种需求在Servlet技术之上开发的。可见，JSP和Servlet之间有着内在的血缘关系，在学习JSP时，如果能够抓住这种联系，就能更深刻地理解JSP的运行机理，达到事半功倍的效果。 
JSP页面的请求响应过程如下图：
 
下面笔者举例说明：
HelloWorld.jsp代码清单如下：

这个文件存放在D:\java\resin1.2.2\webapps中，通过浏览器请求执行HelloWorld.jsp：
http://127.0.0.1:8080/helloworld.jsp。
服务器resin接到这个请求后，调出jsp引擎，首先将HelloWorld.jsp解析成Servlet存入D:\java\resin1.2.2\work\_jsp目录，文件名是_helloworld__jsp.java，此Servlet的源代码如下：

从上面可以看出，HelloWorld.jsp在运行时首先解析成一个Java类_helloworld__jsp.java，该类继承于com.caucho.jsp.JavaPage基类，此基类实现了HttpServlet接口。可见，JSP在运行前首先将编译为一个Servlet，这就是理解JSP技术的关键。 
我们还知道JSP页面中内置了几个对象，如pageContext、application、config、page、session、out等，你可能会奇怪，为什么在JSP中的代码片断中可以直接使用这些内置对象。观察_jspService()方法，实际上这几个内置对象就是在这里定义的。在对JSP文件中的代码片断进行解析之前，先对这几个内置对象进行初始化。 
原来jsp文件中的“<%="Hello World!!!!!!"%>”被翻译成了“out.print(("Hello World!!!!!!"));”。
jsp引擎将HelloWorld.jsp解析成_helloworld__jsp.java后，再将_helloworld__jsp.java编译成_helloworld__jsp.class，接着执行_helloworld__jsp.class，这时才通过out内置对象将HelloWorld.jsp页面内容送至客户端的浏览器。
最后，_helloworld__jsp.class就存入了服务器电脑的内存里，往后再执行请求页面HelloWorld.jsp时，就直接执行存于服务器电脑内存里面的_helloworld__jsp.class了。
本篇“JSP技术”到此结束，一路走来，笔者详述了jsp的整个框架结构以及开发中最核心的技术应用，最后还从全新的角度对jsp的运行原理进行了阐述。现在，你是否感觉自己已经是个jsp的高手了呢？

--------------------====全文完===-----------------