路由器

电脑

手机

网络

jsp技术知识

来源：www.45fan.com  2016-09-08 18:10:58

jsp技术知识

一.指令元素
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（CommonGatewayInterface）技术。编写CGI程序可以使用不同的程序语言，如Perl、VisualBasic、Delphi或C/C++等。虽然CGI技术已经发展成熟而且功能强大，但由于其编程困难、效率低下、修改复杂等缺陷，所以有被新技术取代的技术。
在这样的背景下，新的技术纷纷面世，如ASP（ActiveServerPage）、PHP（PersonalHomePage）、JSP（JavaServerPage）等。其中，JSP被许多人认为是未来最有发展前途的动态网站技术。
JSP页面一般由HTML标签和JSP元素构成，其中的JSP元素则又是由“指令元素”、“脚本元素”、“标准动作元素”、“内置对象”四个部分组成。下面，就让我们一起来探究JSP的奥秘吧……

一.指令元素


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

运行程序MakeError.jsp的结果如下：

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

二.脚本元素


JSP规格提供了四种类型的脚本元素，包括：
l声明
l表达式
l脚本
l注释
下面分别对它们进行详细叙述。
1.声明元素
声明用于定义jsp页面中的变量与函数，这些经过定义的变量和函数，将成为Servlet类的属性与方法（关于Servlet请参看后文）。声明并不会产生任何的数据输出，声明时可同时设置初始值，提供给其他的声明、表达式或脚本使用。
声明的语法格式为：
  1. <%!
  2. //声明语句
  3. %>
  4. 举例：
  5. <%!
  6. //此处定义的变量将成为此jsp页面的全局变量
  7. inti=0;
  8. staticintj=100;
  9. Strings=“注意”;
  10. %>
  11. <%!
  12. //此处定义的函数将成为此jsp页面的公共函数
  13. Publicintsquare(inti)
  14. {
  15. return(i*i);
  16. }
  17. %>

²jspInit函数与jspDestroy函数
若要在jsp页面开始执行时进行某些数据的初始化，可以利用jspInit函数完成。此函数将在jsp页面被执行时调用，且当jsp页面重新整理时，并不会被再度执行。当关闭服务器时，jspDestroy函数将被执行，可以利用该函数进行数据的善后处理工作。下面举个简单的例子说明，文件InitDes.jsp代码如下：
  1. <%@pagecontentType="text/html;charset=GB2312"%>
  2. <%!
  3. publicvoidjspInit()
  4. {
  5. System.out.println("jspInitiscalled!");
  6. }
  7.  
  8. publicvoidjspDestroy()
  9. {
  10. System.out.println("jspDestroyiscalled!");
  11. }
  12. %>
  13. <HTML>
  14. <HEAD><TITLE>jspInit函数与jspDestroy函数的使用</TITLE></HEAD>
  15. <BODY>
  16. <CENTER>
  17. <FONTSIZE=5COLOR=blue>jspInit函数与jspDestroy函数的使用</FONT>
  18. </CENTER>
  19. <HR><BR>
  20. </BODY>
  21. </HTML>

首次执行此页面时，Resin服务器输出如下：
Resin1.2.2--TueJan1609:53:18PST2001
httplisteningto*:8080
srunlisteningto127.0.0.1:6802
jspInitiscalled!
刷新此页面数次后，Resin服务器输出仍然如上。
此时，如果关闭服务器，则输出如下：
Resin1.2.2--TueJan1609:53:18PST2001
httplisteningto*:8080
srunlisteningto127.0.0.1:6802
jspInitiscalled!
closingserver
jspDestroyiscalled!
由此，我们得到启发，在数据库的开发过程中，可以利用jspInit函数来进行数据库的连接工作，用jspDestroy函数来进行数据库的关毕工作。下面以一个分页显示数据库内容的程序为例子，让读者进一步体会jspInit与jspDestroy的功用与好处。
在Pages.jsp这个分页程序中，我们把数据库连接的动作写在jspInit函数中，这样，每一次重新整理页面时，就可以避免重新执行数据库的连接动作。如下：
  1. <%@pagecontentType="text/html;charset=GB2312"
  2. import="java.sql.*"%>
  3. <%!
  4. intPageSize=2;//设置每张网页显示两笔记录
  5. intShowPage=1;//设置欲显示的页数
  6. intRowCount=0;//ResultSet的记录笔数
  7. intPageCount=0;//ResultSet分页后的总页数
  8. Connectioncon=null;
  9. Statementstmt=null;
  10. ResultSetrs=null;
  11.  
  12. publicvoidjspInit()//执行数据库与相关数据的初始化
  13. {
  14. try
  15. {
  16. Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
  17. //载入驱动程序类别
  18.  
  19. con=DriverManager.getConnection("jdbc:odbc:test");
  20. //建立数据库链接
  21.  
  22. stmt=con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
  23. ResultSet.CONCUR_READ_ONLY);
  24. //建立Statement对象,并设置记录指标类型为可前后移动
  25.  
  26. rs=stmt.executeQuery("SELECT*FROMproducts");
  27. //建立ResultSet(结果集)对象，并执行SQL语句
  28.  
  29. rs.last();//将指标移至最后一笔记录
  30.  
  31. RowCount=rs.getRow();//取得ResultSet中记录的笔数
  32.  
  33. PageCount=((RowCount%PageSize)==0?
  34. (RowCountPageSize):(RowCountPageSize)+1);
  35. //计算显示的页数
  36. }
  37. catch(Exceptionex)
  38. {
  39. System.out.println(ex.toString());
  40. }
  41. }
  42.  
  43. publicvoidjspDestroy()//执行关闭各种对象的操作
  44. {
  45. try
  46. {
  47. rs.close();//关闭ResultSet对象
  48. stmt.close();//关闭Statement对象
  49. con.close();//关闭数据库链接对象
  50. }
  51. catch(Exceptionex)
  52. {
  53. System.out.println(ex.toString());
  54. }
  55. }
  56. %>
  57. <HTML>
  58. <HEAD>
  59. <TITLE>记录的分页显示</TITLE>
  60. </HEAD>
  61. <BODY>
  62. <CENTER>
  63. <FONTSIZE=5COLOR=blue>记录的分页显示</FONT>
  64. </CENTER>
  65. <HR>
  66. <P></P>
  67. <CENTER>
  68. <%
  69. StringToPage=request.getParameter("ToPage");
  70.  
  71. //判断是否可正确取得ToPage参数,
  72. //可取得则表示JSP网页应显示特定分页记录的语句
  73. if(ToPage!=null)
  74. {
  75. ShowPage=Integer.parseInt(ToPage);//取得指定显示的分页页数
  76.  
  77. //下面的if语句将判断用户输入的页数是否正确
  78. if(ShowPage>PageCount)
  79. {//判断指定页数是否大于总页数,是则设置显示最后一页
  80. ShowPage=PageCount;
  81. }
  82. elseif(ShowPage<=0)
  83. {//若指定页数小于0,则设置显示第一页的记录
  84. ShowPage=1;
  85. }
  86. }
  87.  
  88. rs.absolute((ShowPage-1)*PageSize+1);
  89. //计算欲显示页的第一笔记录位置
  90. %>
  91. <H3>目前在第<FONTSIZE=4COLOR=red>
  92. <%=ShowPage%></FONT>页,共有
  93. <FONTSIZE=4COLOR=red>
  94. <%=PageCount%></FONT>页</H3>
  95. <P></P>
  96. <%
  97. //利用For循环配合PageSize属性输出一页中的记录
  98. for(inti=1;i<=PageSize;i++)
  99. {
  100. %>
  101. <TABLEborder=1bordercolor=RoyalBluebgcolor=LightBlue>
  102. <TR><TDbgcolor=LightYellowwidth=100>
  103. <B>商品名</B></TD>
  104. <TDwidth=100><B><%=rs.getString("product_name")%>
  105. </B></TD>
  106. <TDbgcolor=LightYellowwidth=100>
  107. <B>价格</B></TD>
  108. <TDwidth=100><B><%=rs.getInt("price")%>
  109. </B></TD>
  110. <TDbgcolor=LightYellowwidth=100>
  111. <B>描述</B></TD>
  112. <TDwidth=100><B><%=rs.getString("description")%>
  113. </B></TD>
  114. </TR>
  115. </TABLE><BR>
  116. <%
  117. //下面的if判断语句用于防止输出最后一页记录时,
  118. //将记录指标移至最后一笔记录之后
  119. if(!rs.next())//判断是否到达最后一笔记录
  120. break;//跳出for循环
  121. }
  122. %>
  123. <TABLE>
  124. <TRvalign=baselinealign=center>
  125. <%
  126. //判断目前所在分页是否为第一页,
  127. //不是则显示到第一页与上一页的超链接
  128. if(ShowPage!=1)
  129. {
  130. //下面建立的各超链接将链接至自己,
  131. //并将欲显示的分页以ToPage参数传递给自己
  132. %>
  133. <TDWidth=150>
  134. <AHref=Pages.jsp?ToPage=<%=1%>>到第一页</A>
  135. </TD>
  136. <TDWidth=150>
  137. <AHref=Pages.jsp?ToPage=<%=ShowPage-1%>>到上一页</A>
  138. </TD>
  139. <%
  140. }
  141.  
  142. //判断目前所在分页是否为最后一页,
  143. //不是则显示到最后一页与下一页的超链接
  144. if(ShowPage!=PageCount)
  145. {
  146. //下面建立的各超链接将链接至自己,
  147. //并将欲显示的分页以ToPage参数传递自己
  148. %>
  149. <TDWidth=150>
  150. <AHref=Pages.jsp?ToPage=<%=ShowPage+1%>>到下一页</A>
  151. </TD>
  152. <TDWidth=150>
  153. <AHref=Pages.jsp?ToPage=<%=PageCount%>>到最后一页</A>
  154. </TD>
  155. <%
  156. }
  157. %>
  158. <TDWidth=150>
  159. <FORMaction=Pages.jspmethod=POST>
  160. 到
  161. <!--
  162. 供用户输入欲查看页数的文字方块,预设值为目前所在的分页,
  163. 当用户在此文字方块中完成数据输入后按下Enter即可将数据送出,
  164. 相当于按下Submit按钮,因此此表单中将省略Submit按钮
  165. -->
  166. <INPUTtype="text"name=ToPagestyle="HEIGHT:25px;WIDTH:40px"
  167. value=<%=ShowPage%>>页
  168. </FORM></TD></TR>
  169. </TABLE>
  170. </CENTER>
  171. </BODY>
  172. </HTML>

执行后，结果如下图：

2.表达式元素
表达式是一个简化了的out.println语句。
表达式的语法格式为：
<%=//要输出的数据%>
举例：
<%=square(5)%>
3.脚本元素
脚本是java程序的一段代码，只要符合java语法的语句都可以写在这里，它是在请求时期执行的，它可以使用jsp页面所定义的变量、方法、表达式或JavaBeans。
脚本的语法格式为：
  1. <%
  2. //java代码
  3. %>
  4. 举例：
  5. <%
  6. if(age<18)
  7. {
  8. out.println(“你是未成年人！！！！”);
  9. }
  10. else
  11. {
  12. out.println(“你已经成年了！！！！”);
  13. }
  14. %>

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:paramname=“name1”value=“value1”/>
2.<jsp:include>
<jsp:include>动作用于动态加载HTML页面或者JSP页面。
语法格式：
<jsp:includepage=“网页路径”>
<jsp:paramname=“name1”value=“value1”/>
<jsp:paramname=“name2”value=“value2”/>
<jsp:include/>
在jsp页面中，可以利用下面的语法取得返回的参数：
request.getParameter(“name1”);
若不传递参数时，则语法格式如下：
<jsp:includepage=“网页路径”/>
举例：
a.jsp页面代码如下：
  1. <jsp:includepage="b.jsp">
  2. <jsp:paramname="name1"value="value1"/>
  3. <jsp:paramname="name2"value="value2"/>
  4. </jsp:include>

b.jsp页面代码如下：
名字1、；<%=request.getParameter("name1")%>
<hrcolor=red>
名字2、；<%=request.getParameter("name2")%>
执行结果如下：

“include标准动作”和“include指令”的差别在于：“include标准动作”包含的页面在运行时被加入，而“include指令”在编译时就被加入了。
3.<jsp:forward>
<jsp:forward>动作用于将浏览器显示的页面导向到另一个HTML页面或者jsp页面。
语法格式：
<jsp:forwardpage=“网页路径”/>
当然，<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:useBeanid=“名称”scope=“有效范围”class=“Bean类位置”/>

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

//获取Bean属性（两种方法）
//方法一：“标签获取”
<jsp:getPropertyname=“名称”property=“属性”/>
//方法二：“方法获取(用于java程序中)”
Bean对象名称.get属性()
lJavaBean编写的格式
//定义Bean类所属于的包
  1. package包名
  2.  
  3. //定义为公开等级的类，并且类名称与源代码文件名相同
  4. publicclass类名
  5. {
  6. //Bean类的属性，其等级定义为private
  7. private数据类型属性名
  8.  
  9. //用来初始化的构造函数
  10. //Bean的构造函数无输入参数
  11. public类名
  12. {}
  13.  
  14.  
  15. //以setXXX函数，作为设定Bean类属性的接口
  16. publicvoidset属性名称(数据类型参数)
  17. {
  18. this.属性=参数
  19. }
  20.  
  21. //以getXXX函数，作为取得Bean类属性的接口
  22. publicvoidget属性名称()
  23. {
  24. returnthis.属性
  25. }
  26. }

²一个简单的使用JavaBeans的例子
Bean文件LoginData.java的源代码如下：
  1. packagej2ee.jsp;
  2. //定义Bean所属的包
  3.  
  4. publicclassLoginData
  5. {
  6. //Bean属性
  7. privateStringName="";
  8. privateStringPwd="";
  9.  
  10. publicLoginData()//构造函数
  11. {
  12. }
  13.  
  14. //以下为设定Bean属性的方法
  15. publicvoidsetLoginName(Stringname)
  16. {this.Name=name;}
  17. publicvoidsetPassword(Stringpwd)
  18. {this.Pwd=pwd;}
  19.  
  20. //以下为取得Bean属性的方法
  21. publicStringgetLoginName()
  22. {returnthis.Name;}
  23. publicStringgetPassword()
  24. {returnthis.Pwd;}
  25. }

调用Bean的jsp文件UseBean.jsp源程序如下：
  1. <%@pagecontentType="text/html;charset=GB2312"%>
  2. <HTML>
  3. <HEAD>
  4. <TITLE>使用Beans</TITLE>
  5. </HEAD>
  6. <BODY>
  7. <CENTER>
  8. <FONTSIZE=5COLOR=blue>使用Beans</FONT>
  9. </CENTER>
  10. <HR>
  11. <P></P>
  12. <H2>
  13. <jsp:useBeanid="login"scope="application"
  14. class="j2ee.jsp.LoginData"/>
  15. <jsp:setPropertyname="login"
  16. property="loginName"value="最后的决定"/>
  17. <%
  18. login.setPassword("123456");//调用Bean对象的方法,设定属性
  19. %>
  20.  
  21. <Fontcolor=red>LoginName</Font>属性值为
  22. <Fontcolor=blue>
  23. <jsp:getPropertyname="login"property="loginName"/>
  24. </Font><BR>
  25. <Fontcolor=red>Password</Font>属性值为
  26. <Fontcolor=blue>
  27. <%--以调用Bean对象方法的方式取得属性--%>
  28. <%=login.getPassword()%></Font>
  29. </BODY>
  30. </HTML>

运行结果如下：

在前面的使用中，有两点值得注意：
（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对象保存在该对象中。下面分别说明：
lPage的有效范围仅仅涵盖使用JavaBeans的页面，一旦你离开此页面，JavaBeans对象的实体也将随之消失。
lRequest的有效范围仅及于使用JavaBeans的请求而已，一旦你结束该页面的请求，JavaBeans对象的实体也将随之消失。
lSession的有效范围涵盖了整个用户会话时期。在用户会话期间，JavaBeans对象的实体均不会消失。当用户会话结束时，JavaBeans对象的实体才会消失。
lApplication的有效范围则涵盖了整个应用程序时期。在应用程序期间，JavaBeans对象的实体均不会消失。只有当应用程序结束时，JavaBeans对象的实体才会消失。
下面，举一个简单的例子，对Request与Session两种生命周期做具体的演示。
Bean文件counter.java的源代码如下：
  1. packagej2ee.jsp;
  2. publicclasscounter
  3. {
  4. privateintcount=0;
  5.  
  6. publicvoidsetCount(intc)
  7. {
  8. this.count=c;
  9. }
  10.  
  11. publicintgetCount()
  12. {
  13. this.count++;
  14. returnthis.count;
  15. }
  16. }

Request实例
两个jsp文件b1.jsp与b2.jsp代码分别如下：
b1.jsp
  1. <jsp:useBeanid="counter"scope="request"class="j2ee.jsp.counter"/>
  2.  
  3. <%
  4. counter.setCount(100);
  5. %>
  6.  
  7. <jsp:forwardpage="b2.jsp"/>
  8. b2.jsp
  9. <jsp:useBeanid="counter"scope="request"class="j2ee.jsp.counter"/>
  10.  
  11. <%
  12. out.println(counter.getCount());
  13. %>

运行结果如下：

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

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

<ahref="c2.jsp"target="_blank">c2.jsp</a>
c2.jsp
<jsp:useBeanid="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，它的源代码如下所示：
  1. /*
  2. *文件名：DBCon.java
  3. *
  4. *类名：DBCon
  5. *
  6. *所属包：j2ee.jsp
  7. *
  8. *导入包：java.sql.*;javax.servlet.http.*;
  9. *
  10. *作者：杨??
  11. *
  12. *创建时间：2003.12.9
  13. *
  14. *用途描述：在此JavaBean中建立会话级别的数据库联机，供会话过程中的各个jsp页面使用
  15. *
  16. *版本号：1.0
  17. *
  18. */
  19.  
  20. packagej2ee.jsp;
  21.  
  22. importjavax.servlet.http.*;
  23. importjava.sql.*;
  24.  
  25. //定义DBCon类别实做HttpSessionBindingListener介面
  26. publicclassDBConimplementsHttpSessionBindingListener
  27. {
  28. //与数据库连结有关的Bean属性
  29. privateConnectioncon=null;
  30.  
  31. /**
  32. *方法名：BulidConnection
  33. *级别：private
  34. *@param(无)
  35. *@return(无)
  36. *@throws(无)
  37. *作用：建立一个数据库联机
  38. */
  39. privatevoidBulidConnection()
  40. {
  41. try
  42. {
  43. System.out.println("BulidConnection()方法被调用");
  44.  
推荐阅读