jsp技术

一.指令元素
1.page指令
import
session
contentType
buffer
isTreadSafe
info
errorPage
isErrorPage
2.include指令
3.taglib指令
二.脚本元素
1.声明元素
2.表达式元素
3.脚本元素
4.注释元素
三.标准动作元素
1.
2.
3.
4.
5.
6.
7.
四.内置对象
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
  1. <%@ page errorPage="ErrorPage.jsp"%>
  2.  
  3.    产生错误页面
  4. <%
  5. int i=8,j=0;
  6. out.println(ij);
  7. %>
  8. ErrorPage.jsp
  9. <%@ page isErrorPage="true"%>
  10.  
  11.    错误处理页面
  12.  错误原因:<%=exception.getMessage()%>

运行程序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请参看后文)。声明并不会产生任何的数据输出,声明时可同时设置初始值,提供给其他的声明、表达式或脚本使用。
声明的语法格式为:
  1. <%!
  2.     //声明语句
  3. %>
  4. 举例:
  5. <%!
  6. //此处定义的变量将成为此jsp页面的全局变量
  7. int i = 0;
  8. static int j=100;
  9. String s = “注意”; 
  10. %>
  11. <%!
  12. //此处定义的函数将成为此jsp页面的公共函数
  13. Public int square(int i)
  14. {
  15.     return(i*i);
  16. }
  17. %>

²    jspInit函数与jspDestroy函数
若要在jsp页面开始执行时进行某些数据的初始化,可以利用jspInit函数完成。此函数将在jsp页面被执行时调用,且当jsp页面重新整理时,并不会被再度执行。当关闭服务器时,jspDestroy函数将被执行,可以利用该函数进行数据的善后处理工作。下面举个简单的例子说明,文件InitDes.jsp代码如下:
  1. <%@ page contentType="text/html; charset=GB2312"%>
  2. <%!
  3. public void jspInit()
  4. {
  5.     System.out.println("jspInit is called!");
  6. }
  7. public void jspDestroy()
  8. {
  9.     System.out.println("jspDestroy is called!");
  10. }
  11. %>
  12. <HTML>
  13. jspInit函数与jspDestroy函数的使用
  14. jspInit函数与jspDestroy函数的使用


  15. HTML>

首次执行此页面时,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函数中,这样,每一次重新整理页面时,就可以避免重新执行数据库的连接动作。如下:
  1. <%@ page contentType="text/html; charset=GB2312" 
  2.     import="java.sql.*"%>
  3. <%!
  4. int PageSize = 2; //设置每张网页显示两笔记录
  5. int ShowPage = 1; //设置欲显示的页数
  6. int RowCount = 0; //ResultSet的记录笔数
  7. int PageCount = 0; //ResultSet分页后的总页数
  8. Connection con = null;
  9. Statement stmt = null;
  10. ResultSet rs = null;
  11. public void jspInit() //执行数据库与相关数据的初始化
  12. {    
  13.     try
  14.         {
  15.         Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
  16.         //载入驱动程序类别
  17.         con = DriverManager.getConnection("jdbc:odbc:test");
  18.         //建立数据库链接
  19.         stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
  20.                        ResultSet.CONCUR_READ_ONLY);
  21.         //建立Statement对象, 并设置记录指标类型为可前后移动
  22.         rs = stmt.executeQuery("SELECT * FROM products");
  23.         //建立ResultSet(结果集)对象,并执行SQL语句
  24.         rs.last(); //将指标移至最后一笔记录
  25.         RowCount = rs.getRow(); //取得ResultSet中记录的笔数
  26.     
  27.         PageCount = ((RowCount % PageSize) == 0 ? 
  28.                 (RowCountPageSize) : (RowCountPageSize)+1);
  29.         //计算显示的页数
  30.     }
  31.     catch(Exception ex)
  32.     {    
  33.         System.out.println(ex.toString());
  34.     }
  35. }
  36. public void jspDestroy() //执行关闭各种对象的操作
  37. {
  38.     try
  39.         {
  40.         rs.close(); //关闭ResultSet对象
  41.         stmt.close(); //关闭Statement对象
  42.         con.close(); //关闭数据库链接对象
  43.     }
  44.     catch(Exception ex)
  45.     {
  46.         System.out.println(ex.toString());
  47.     }
  48. }
  49. %>
  50. <HTML>
  51. 记录的分页显示
  52. 记录的分页显示

  53. <%
  54. String ToPage = request.getParameter("ToPage");
  55. //判断是否可正确取得ToPage参数, 
  56. //可取得则表示JSP网页应显示特定分页记录的语句
  57. if(ToPage != null)
  58. {
  59.     ShowPage = Integer.parseInt(ToPage); //取得指定显示的分页页数
  60.     
  61.     //下面的if语句将判断用户输入的页数是否正确
  62.     if(ShowPage > PageCount)
  63.     { //判断指定页数是否大于总页数, 是则设置显示最后一页
  64.         ShowPage = PageCount;
  65.     }
  66.     else if(ShowPage <= 0)
  67.     { //若指定页数小于0, 则设置显示第一页的记录
  68.         ShowPage = 1;
  69.     }
  70. }
  71. rs.absolute((ShowPage - 1) * PageSize + 1); 
  72. //计算欲显示页的第一笔记录位置
  73. %>
  74. 目前在第

  75. <%= ShowPage %>页, 共有
  76. <%= PageCount %>
  77. <%
  78. //利用For循环配合PageSize属性输出一页中的记录
  79. for(int i = 1; i <= PageSize; i++)
  80. {
  81.     %>
  82.     
  83.         
  84.         商品名
  85.         <%= rs.getString("product_name") %>
  86.         
  87.         
  88.         价格
  89.         <%= rs.getInt("price") %>
  90.         
  91.         
  92.         描述
  93.         <%= rs.getString("description") %>
  94.         
  95.         
  96.     
  97.     <%
  98.     //下面的if判断语句用于防止输出最后一页记录时, 
  99.     //将记录指标移至最后一笔记录之后
  100.     if(!rs.next())     //判断是否到达最后一笔记录
  101.         break;  //跳出for循环
  102. }
  103. %>
  104. <%
  105. //判断目前所在分页是否为第一页,
  106. //不是则显示到第一页与上一页的超链接
  107. if(ShowPage != 1)
  108. {
  109. //下面建立的各超链接将链接至自己, 
  110. //并将欲显示的分页以ToPage参数传递给自己
  111.     %>
  112.     
  113.     >到第一页
  114.     
  115.     
  116.     >到上一页
  117.     
  118.     <%
  119. }
  120. //判断目前所在分页是否为最后一页,
  121. //不是则显示到最后一页与下一页的超链接
  122. if(ShowPage != PageCount)
  123. {
  124. //下面建立的各超链接将链接至自己, 
  125. //并将欲显示的分页以ToPage参数传递自己
  126.     %>    
  127.     
  128.     >到下一页
  129.       
  130.     
  131.     >到最后一页
  132.     
  133.     <%
  134. }
  135. %>
  136. 到 
  137. "text" name=ToPage style="HEIGHT: 25px; WIDTH: 40px"
  138.  value=<%= ShowPage%> > 页
  139. 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    
l    
l    
l    
l    
l    
l    
其中这三个是专门用来操作JavaBeans的。
下面分别介绍它们。
1.    
动作用于传递参数,必须配合动作一起使用。
语法格式:

2.    
动作用于动态加载HTML页面或者JSP页面。
语法格式:




在jsp页面中,可以利用下面的语法取得返回的参数:
request.getParameter(“name1”);
若不传递参数时,则语法格式如下:

举例:
a.jsp页面代码如下:
  1. "b.jsp">
  2.     "name1" value = "value1"/>
  3.     "name2" value = "value2"/>

b.jsp页面代码如下:
名字1、;<%=request.getParameter("name1")%>

名字2、;<%=request.getParameter("name2")%>
执行结果如下:
 
“include标准动作”和“include指令”的差别在于:“include标准动作”包含的页面在运行时被加入,而“include指令”在编译时就被加入了。
3.    
动作用于将浏览器显示的页面导向到另一个HTML页面或者jsp页面。
语法格式:

当然,动作中也可以加入参数,其设置和获得参数的方法与类似。
4.    
动作用于加载applet,用途与HTML语法中的标记相同。该动作是在客户端执行的,这里就不作介绍了。
5.    
(见后文的“JavaBeans”的使用)
6.    
(见后文的“JavaBeans”的使用)
7.    
(见后文的“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


//设定Bean属性(两种方法)
//方法一:“标签设定”

//方法二:“方法设定(用于java程序中)”
Bean对象名称.set属性(值)

//获取Bean属性(两种方法)
//方法一:“标签获取”

//方法二:“方法获取(用于java程序中)”
Bean对象名称.get属性()
l    JavaBean编写的格式
//定义Bean类所属于的包
  1. package 包名
  2. //定义为公开等级的类,并且类名称与源代码文件名相同
  3. public class类名
  4. {
  5.    //Bean类的属性,其等级定义为private
  6.    private 数据类型 属性名
  7.    //用来初始化的构造函数
  8.    //Bean的构造函数无输入参数
  9.    public 类名
  10.    {  }
  11.    //以setXXX函数,作为设定Bean类属性的接口
  12.    public void set属性名称(数据类型 参数)
  13.    {
  14.       this.属性 = 参数
  15.    }
  16.    //以getXXX函数,作为取得Bean类属性的接口
  17.    public void get属性名称()
  18.    {
  19.       return this.属性
  20.    }
  21. }

²    一个简单的使用JavaBeans的例子
Bean文件LoginData.java的源代码如下:
  1. package j2ee.jsp;
  2. //定义Bean所属的包
  3. public class LoginData
  4. {
  5.     //Bean属性
  6.     private String Name = "";
  7.     private String Pwd = "";
  8.     public LoginData()  //构造函数
  9.     {        
  10.     }
  11.     //以下为设定Bean属性的方法
  12.     public void setLoginName(String name)
  13.     { this.Name = name; }
  14.     public void setPassword(String pwd)
  15.     { this.Pwd = pwd; }
  16.     //以下为取得Bean属性的方法
  17.     public String getLoginName()
  18.     { return this.Name; }
  19.     public String getPassword()
  20.     { return this.Pwd; }
  21. }

调用Bean的jsp文件UseBean.jsp源程序如下:
  1. <%@ page contentType="text/html; charset=GB2312" %>
  2. <HTML>
  3. 使用Beans
  4. 使用Beans

  5. "login" scope="application"  
  6.     class="j2ee.jsp.LoginData"/>
  7. "login" 
  8.     property="loginName" value="最后的决定"/>
  9. <%
  10. login.setPassword("123456"); //调用Bean对象的方法, 设定属性
  11. %>
  12. <Font color = red>LoginNameFont>属性值为
  13. <Font color = blue>
  14. "login" property="loginName"/>
  15. Font>
  16. <Font color = red>PasswordFont>属性值为
  17. <Font color = blue>
  18. <%--以调用Bean对象方法的方式取得属性--%>
  19. <%= login.getPassword() %>Font>
  20. 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对象保存在该对象中。下面分别说明:
l    Page的有效范围仅仅涵盖使用JavaBeans的页面,一旦你离开此页面,JavaBeans对象的实体也将随之消失。
l    Request的有效范围仅及于使用JavaBeans的请求而已,一旦你结束该页面的请求,JavaBeans对象的实体也将随之消失。
l    Session的有效范围涵盖了整个用户会话时期。在用户会话期间,JavaBeans对象的实体均不会消失。当用户会话结束时,JavaBeans对象的实体才会消失。
l    Application的有效范围则涵盖了整个应用程序时期。在应用程序期间,JavaBeans对象的实体均不会消失。只有当应用程序结束时,JavaBeans对象的实体才会消失。
下面,举一个简单的例子,对Request与Session两种生命周期做具体的演示。
Bean文件counter.java的源代码如下:
  1. package j2ee.jsp;
  2. public class counter
  3. {
  4.     private int count = 0;
  5.     
  6.     public void setCount(int c)
  7.     {
  8.         this.count = c;
  9.     }
  10.     
  11.     public int getCount()
  12.     {
  13.         this.count++;
  14.         return this.count;
  15.     }
  16. }    

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

运行结果如下:
 
Session实例
两个jsp文件c1.jsp与c2.jsp代码分别如下:
c1.jsp


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

c2.jsp
c2.jsp


<%
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. package j2ee.jsp;
  20. import javax.servlet.http.*; 
  21. import java.sql.*;
  22. //定义DBCon类别实做HttpSessionBindingListener介面
  23. public class DBCon implements HttpSessionBindingListener
  24. {
  25.     //与数据库连结有关的Bean属性
  26.     private Connection con = null;
  27.     
  28.       /**
  29.        * 方法名:BulidConnection
  30.        * 级别:private
  31.        * @param     (无)
  32.        * @return    (无)
  33.        * @throws    (无)
  34.        * 作用:建立一个数据库联机
  35.        */
  36.     private void BulidConnection()
  37.     {
  38.         try
  39.         {
  40.             System.out.println("BulidConnection()方法被调用");     
  41.             Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
  42.             //载入驱动程式类别
  43.     
  44.             con = DriverManager.getConnection("jdbc:odbc:test");
  45.             //建立数据库连线            
  46.         }
  47.         catch(Exception ex)
  48.         {    
  49.             System.out.println(ex.toString());
  50.         }        
  51.     }
  52.       /**
  53.        * 方法名:close
  54.        * 级别:private
  55.        * @param     (无)
  56.        * @return    (无)
  57.        * @throws    (无)
  58.        * 作用:关闭数据库联机
  59.        */
  60.     private void close()
  61.     {
  62.         try
  63.         {
  64.             con.close(); //关闭Connection对象        
  65.             con =  null;
  66.         }
  67.         catch(SQLException sex)
  68.         {    
  69.             System.out.println(sex.toString());
  70.         }    
  71.     }
  72.       /**
  73.        * 方法名:getConnection
  74.        * 级别:public
  75.        * @param     (无)
  76.        * @return    Connection     数据库联机
  77.        * @throws    (无)
  78.        * 作用:返回一个数据库联机
  79.        */
  80.     public Connection getConnection()
  81.     { 
  82.         //若con为null时, 重新建立数据库连结
  83.         if(con == null)
  84.             BulidConnection();
  85.         return this.con;
  86.     }    
  87.       /**
  88.        * 方法名:valueBound
  89.        * 级别:public
  90.        * @param     HttpSessionBindingEvent     事件
  91.        * @return    (无)
  92.        * @throws    (无)
  93.        * 作用:建立一个数据库联机,并输出相关信息
  94.        */
  95.     public void valueBound(HttpSessionBindingEvent event)
  96.        {
  97.          BulidConnection();
  98.             System.out.println("会话级别的数据库连接已经建立!!!");
  99.        }
  100.       /**
  101.        * 方法名:valueUnbound
  102.        * 级别:public
  103.        * @param     HttpSessionBindingEvent     事件
  104.        * @return    (无)
  105.        * @throws    (无)
  106.        * 作用:关闭一个数据库联机,并输出相关信息
  107.        */
  108.     public void valueUnbound(HttpSessionBindingEvent event)
  109.     {
  110.         if(con != null)
  111.             close(); //呼叫close方法
  112.             System.out.println("会话级别的数据库连接已经关闭!!!");
  113.     }
  114. }

编译这个Bean源文件。注意,编译前要设定好classpath的路径,使得它所包含的类库中有javax.servlet.http.*包。
然后,建立两个用来测试此Bean的jsp页面文件DBBean1.jsp与DBBean2.jsp,它们的程序代码差不多,都是用来显示数据库内容的,现在就只列出DBBean1.jsp的源文件,如下:
  1. <%@ page contentType="text/html; charset=GB2312" 
  2.     import="java.sql.*"%>
  3. <HTML>
  4. 利用Bean对象建立数据库链接
  5. 利用Bean对象建立数据库链接

  6. <%--起始建立数据库链接的Bean对象--%>
  7. "ConBean" scope="session"  
  8.     class="j2ee.jsp.DBCon"/>
  9. <%
  10. Connection con = ConBean.getConnection();
  11. //从Bean对象取得已完成建立的数据库链接
  12. Statement stmt = con.createStatement();
  13. //建立Statement对象
  14. ResultSet rs = stmt.executeQuery("SELECT product_name, price FROM products");
  15. //建立ResultSet(结果集)对象,并执行SQL叙述
  16. %>
  17.         
  18.     书  名价   格    
  19.         
  20.     <%
  21.     //利用while循环将数据表中的记录列出
  22.     while (rs.next())
  23.     {
  24.         %>
  25.                 
  26.         <%= rs.getString("product_name") %>
  27.         <%= rs.getString("price") %>            
  28.         
  29.         <%
  30.     }
  31.     rs.close(); //关闭记录集
  32.     stmt.close(); //关闭Statement对象
  33. %>    
  34. "DBBean2.jsp">DBBean2.jsp
  35. HTML>

首次运行DBBean1.jsp文件时,浏览器显示如下:
 

你可能感兴趣的:(jsp技术)