UML软件工程组织
JBuilder 2005实战JSP开发
作者：陈雄华
JBuilder2005实战JSP之程序功能介绍. 用户登录模块程序的结构图如下图所示：

图 1 实例页面流转图

　　用户在登录页面中录入密码、验证正确后转向欢迎主页面，如果输入的密码错误，导向登录失败页面。这个模块包含6个JSP文件、3个Java类及两张后台表。

　　6个JSP文件分别为用户登录、页面流转控制、错误处理、登录成功和失败、以及退出系统的处理页面，简单介绍如下：

　　表 1 JSP文件

JSP页面 说明
login.jsp 登录JSP页面
switch.jsp 进行密码验证和页面流转控制的JSP页面。
error.jsp 错误处理JSP页面，以一种友好的方式向客户报告程序的错误。为其他所有JSP页面的错误处理页面。
welcome.jsp 登录成功后转向的欢迎页面。我们在该页面中引用了一套第三方的标签库。
fail.jsp 登录失败后转向这个错误处理页面。
quit.jsp 退出系统后调用的页面，它负责清除session，结束会话。

　　JSP文件主要负责页面的展现，而业务逻辑或资源处理等功能可以放到Java类中，表单数据则可以通过Bean来封装，模块中提供了3个类，介绍如下：

　　表 2 3个Java类

类 说明
DBConnection 获取数据库的连接。
User 描述用户对象并负责写登录、退出日志。
UserList 获取系统的所有用户并转换为一个网页下拉框。

　　用户信息及用户登录信息用数据库表来存放，选择Oracle 9i作为我们的数据库，当然，你也可以使用其他类型的数据库，只要相应地调整DBConnection类和表SQL定义语句就可以了，这种移植的代价是很小的，下面介绍这两张表的用途和结构：

　　表 3 2张数据库表

表名 说明
T_USER 用户信息表，包含用户ID、用户名及密码3个字段。
T_LOGIN_LOG 记录用户登录的时间和退出的时间，日志主键利用一个序列SEQ_LOGIN_LOG_ID产生。

　　这两张数据库表和序列的结构如下：


图 2 数据表及序列

　　数据库用户名/密码是：jbuser/abc。在着手开发我们的登录模块前，必须先在数据库中创建用户，创建生成表和序列。

. JBuilder2005实战JSP之创建数据库表.1．在Oracle的SQL Plus工具中，以具有DBA权限的用户登录数据库。

　　system/manger@to_128

　　@后的to_128为数据库的连接串名，需要根据具体情况更改，如果数据库是在本地，则可以省略@和连接串。

　　2．创建jbuser用户，指定密码为abc。

　　SQL> create user jbuser identified by abc;

　　3．为jbuser用户分配connect和resource角色权限。

　　SQL> grant connect ,resource to jbuser;

　　4．用jbuser登录数据库

　　SQL> connect jbuser/abc@to_128;

　　5．创建用户表和序列，在SQL> 命令中运行下面的sql代码。

　　代码清单 1 创建表和序列的代码　

1. --创建用户表
2. create table T_USER (
3. USER_ID CHAR(6) not null,
4. USER_NAME VARCHAR2(60),
5. PASSWORD VARCHAR2(20),
6. constraint PK_T_USER primary key (USER_ID)
7. );
8. --创建登录日志表
9. create table T_LOGIN_LOG (
10. ID CHAR(12) not null,
11. USER_ID CHAR(6) not null,
12. DT_LOGIN CHAR(14) not null,
13. DT_LONOUT CHAR(14),
14. constraint PK_T_LOGIN_LOG primary key (ID)
15. );
16.
17. --创建索引，用于生成T_LOGIN_LOG表的主键
18. create sequence SEQ_LOGIN_LOG_ID
19. increment by 1
20. maxvalue 999999999999
21. minvalue 100000000000;
.
　　6．在T_USER用户表中插入3历史人物作为初始用户，在SQL>命令中运行下面的sql代码。

　　代码清单 2 往T_USER表中插入3条记录

.
1. insert into T_USER(USER_ID,USER_NAME,PASSWORD) values( 100000 , 姜子牙 , 123456 );
2. insert into T_USER(USER_ID,USER_NAME,PASSWORD) values( 100001 , 鲍叔牙 , 123456 );
3. insert into T_USER(USER_ID,USER_NAME,PASSWORD) values( 100002 , 竖牙 , 123456 );
4. commit;
.
　　创建工程及Web模块

　　在创建数据库后，打开JBuilder，创建工程和Web模块。

　　1．File->New Project...创建一个名为bookstore的工程。

　　2．File->New...->Web->双击Web Module（WAR）图标创建一个Web模块，名称取为webModule。选用Tomcat 5.0作为Web应用服务器。

　　编写获取数据库连接类

　　必须通过数据连接才可以访问数据库，在模块的多个地方都需要获取数据库连接，所以我们编写一个获取数据连接的类，以增强代码的复用率。

　　在编写获取数据连接的类时，必须先将Oracle的JDBC驱动器类包classes12.jar加入工程扩展类库中（classes12.jar位于<oracle安装目录>/ jdbc/lib的目录下），我们将classes12.jar放在<工程目录>/oraJdbcLib下。通过以下的步骤在工程扩展类库中引入classes12.jar：
Project->Properties...->Paths设置页->切换到Required Libraries->点击Add...->在弹出的Add to Project Classpath对话框中切换到Archives标签页，选择工程目录下的<工程目录>/oraJdbcLib /classes12.jar。

　　将Oracle的JDBC驱动器类包classes12.jar引入工程扩展类库后，在工程中创建DBConnection类，其代码如下所示：

　　代码清单 3 DBConnection.java

. 　
1. package bookstore;
2.
3. import java.sql.*;
4. import java.util.Properties;
5.
6. public class DBConnection {
7. 　//获取数据库连接类
8. 　public static Connection getConnection() throws SQLException {
9. 　try {
10. 　　Class.forName("oracle.jdbc.driver.OracleDriver");
11. 　} catch (ClassNotFoundException ex) {
12. 　　ex.printStackTrace();
13. 　　return null;
14. 　}
15. 　Properties sysProps = new Properties();
16. 　sysProps.put("user", "jbuser");
17. 　sysProps.put("password", "abc");
18. 　return DriverManager.getConnection(
19. 　　"jdbc:oracle:thin:@192.168.0.128:1521:ora9i", sysProps);
20. 　}
21. }
.
　　该类仅提供了一个静态方法getConnection()，用jbuser/abc获取位于192.168.0.128，SID为ora9i的数据连接。

　　获取数据库连接有两个关键点：

　　1、指定数据库驱动器类

　　如第10行代码所示，Oracle的JDBC驱动器类名是：oracle.jdbc.driver.OracleDriver，不同数据库有自己的JDBC数据库驱动器，如果你使用其它数据库，请自行查阅相关的资料。

　　2、指定数据库的URL连接串

　　在第19行中，我们指定了一个数据库URL连接串，不同数据库的URL连接串格式也不一样，对于Oracle数据库来说，数据库URL连接串包含4个部分：

　　·jdbc:oracle:thin ：指定JDBC驱动器的类型，这里指定用瘦客户端驱动器，无需在连接客户端安装其他的组件，最为常用。

　　·@192.168.0.128 ：数据库所在机器的IP，也可以用机器名。

　　·1521 ：数据库监听器所在的端口，一般情况下Oracle默认在1521端口。

　　·ora9i ：数据库SID名称。.

JBuilder2005实战JSP之登录页面.

 通过File-＞New...-＞Web-＞双击JSP图标，弹出创建JSP向导的对话框，如下图所示：

图 3 通过向导创建login.jsp

　　·Web module：如果一个工程下有多个Web模块，你可以通过这儿指定JSP所要加入到的Web模块，因为我们的工程中只有一个webModule，所以是向导将默认设置为webModule。

　　·Name ：键入JSP文件名，你可以键入.jsp后缀，也可以不写后缀，直接键入login就可以了。

　　Generate sample bean选项勾选后JBuilder将生成一个示例的Bean并在JSP中引入这个Bean。对于初学者来说，可以通过该选项查看JSP如何引用一个Bean，而Generate error page选项将自动为JSP创建一个配套的错误处理JSP文件，这里，我们不勾选它们。

　　直接点击Finish创建login.jsp，login.jsp文件出现在内容窗格的编译器中，如下图所示：

图 4 向导创建的JSP文件

　　JSP编译窗口的左右两边都有一个可以通过 和 按钮控制的竖栏，左边栏为放置JSP标签和HTML标签的面板，可以像可视化UI设计器中一样用拖拽方式往JSP文件中放置各种标签，如上图中，我们从面板中选择表单的HTML标签放置到login.jsp文件中。

　　而右边竖栏中是JSP文件中当前光标所在标签的属性编译器，如下图所示：

图 5 设置JSP标签属性编辑器

　　属性编辑器是动态的，光标移到不同的标签上，属性编辑器就显示这个标签所有可设置的属性。如上图中对应的是HTML 表单标签的属性编辑器，我们将其action属性设置为switch.jsp，指定用POST方式发送请求数据。

　　我们在login.jsp中提供一个用户名下拉框、一个密码输入框以及一个登录提交按钮，其代码如下：

　　代码清单 4 login.jsp
1. ＜%@page contentType="text/html; charset=GBK" %＞
2. ＜html＞
3. ＜head＞
4. ＜title＞login＜/title＞
5. ＜/head＞
6. ＜body bgcolor="#ffffff"＞
7. ＜表单 name="表单1" method="post" action="switch.jsp"＞
8. 用户名： ＜select name="userId"＞
9. ＜option value="" selected＞--登录用户--＜/option＞
10. ＜option value="100000"＞姜子牙＜/option＞
11. ＜option value="100001"＞鲍叔牙＜/option＞
12. ＜option value="100002"＞竖牙＜/option＞
13. ＜/select＞
14. 密 码：＜input name="password" type="password"＞
15. ＜input type="submit" name="Submit" value="登录"＞
16. ＜/表单＞
17. ＜/body＞
18. ＜/html＞

　　表单标签代表网页中的一个表单，表单可以包含多个组件，这些组件的数据在网页表单提交后，以HTTP协议发送给action属性所指定的JSP文件处理。表单的数据一般以POST发送，POST发送方式对数据量的大小没有限制，且保密性更强。

　　login.jsp的效果页面如下图所示：

图 6 login.jsp录入页面

　　实战经验：

　　JSP文件代码包含静态和动态两部分，即一部分是HTML代码，而另一部分为JSP标签和Scriptlet代码。JSP一般是动态逻辑的网页，JBuilder对JSP标签及Scriptlet这些动态代码部分支持得非常好，你可以使用CodeInsight和TagInsight等工具快速而正确地完成编码，同时还可以对JSP进行编译调试。在JSP静态HTML代码编写及可视化设计方面，JBuilder却显得力不从心，Dreamweaver在静态代码和可视化设计方面明显优于JBuilder。

　　事情的复杂促进了分工，分工的精细促进了专业的发展，在编写JSP时，并不是一旦拥有JBuilder就别无所求了。韩信善兵、萧何善谋，如果能够将Dreamweaver和JBuilder结合起来，用Dreamweaver开发JSP的可视化部分，用JBuilder开发JSP的动态代码部分，两者互补有无，相得益彰，JSP开发工作将变得更加行云流水。

将用户列表改为动态

　　目前创建的login.jsp有一个缺陷，假设在数据库后台T_USER表中添加其他的用户时，因为用户名下拉框是静态的代码，新创建的用户并不会出现在页面中，因此有必要将用户名列表改为动态的代码，用数据库表T_USER的记录动态产生下拉框的数据。

　　我们通过UserList.ava类来完成这个工作，在工程中创建UserList.java，其代码如下：

　　代码清单 5 UserList.java
1. package bookstore;
2. import java.sql.*;
3.
4. public class UserList
5. {
6. 　//获取HTML下拉框的用户列表代码
7. 　public static String getUserListHTML() {
8. 　　Connection conn = null;
9. 　　StringBuffer sBuf = new StringBuffer();
10.　　try {
11.　　　conn = DBConnection.getConnection();
12.　　　PreparedStatement pStat = conn.prepareStatement(
13.　　　　 "select USER_ID,USER_NAME from T_USER");
14.　　　ResultSet rs = pStat.executeQuery();
15.　　　while (rs.next()) {
16.　　　　sBuf.append("＜option value= " + rs.getString("USER_ID") + " ＞" +
17.　　　　rs.getString("USER_NAME") + "＜/option＞\n");
18.　　　}
19.　　　return sBuf.toString();
20.　　} catch (SQLException ex) {
21.　　　ex.printStackTrace();
22.　　　return "";
23.　　} finally {
24.　　　try {
25.　　　　if (conn != null) {
26.　　　　　conn.close();
27.　　　　　conn = null;
28.　　　　}
29.　　　} catch (SQLException ex1) {
30.　　}
31.　}
32. }
33. }

　　UserList.java只提供了一个静态的getUserListHTML()方法，这个方法从后台数据库的T_USER表中获取用户记录，并生成HTML的select组件的选项代码，如第16~17行所示。

　　在创建这个类后，我们引用该类调整login.jsp的代码，首先在page指令标签中通过import属性引用UserList类，然后将select选项中的内容调整为getUserListHTML()方法返回的值，如下图所示：

图 7 通过CodeInsight编写代码

　　通过表达式标签替换原静态的HTML代码，值得提起的是，在JSP中也可以象在编写一般的Java类中一样使用CodeInsight输入代码。调整后的login.jsp的代码如下所示，用粗体表示：

　　代码清单 6 调整后的login.jsp代码
1. ＜%@page contentType="text/html; charset=GBK" import="bookstore.UserList"%＞
2. ＜html＞
3. ＜head＞
4. ＜title＞login＜/title＞
5. ＜/head＞
6. ＜body bgcolor="#ffffff"＞
7. 　＜表单 name="表单1" method="post" action="switch.jsp"＞用户名：
8. 　　＜select name="userId"＞
9. 　　　＜option value="" selected＞--登录用户--＜/option＞
10. 　　　＜%=UserList.getUserListHTML()%＞
11. 　　＜/select＞
12. 　　密 码：＜input name="password" type="password"＞
13. 　　＜input type="submit" name="Submit" value="登录"＞
14. ＜/表单＞
15. ＜/body＞
16. ＜/html＞

　　保存login.jsp后，在内容窗格login.jsp文件标签中点击右键，选择Web Run using Defaults，JBuilder 将启动Tomcat 5.0应用服务器，运行于8080端口上，编译并运行login.jsp文件，如下图所示：

图 8 在JBuilder中运行login.jsp

　　JBuilder自动切换到Web View视图页中，显示页面的运行效果。但JBuilder的浏览器对网页的支持效果很弱，也不支持JavaScript脚本。所以在运行login.jsp后，最好通过IE来查看网页的效果，你只需要打开IE，并将JBuilder中的访问login.jsp的地址拷贝到IE的地址栏中就可以了，如下图所示：

图 9 用IE访问JBuilder中运行的login.jsp

　　此时用户名的下拉框中的用户已经是动态的用户列表中，当T_USER表中添加、删除用户时下拉框的用户也会相应地改变。

　　在运行JSP前最好先单独编译一个这个JSP文件：在内容窗格的JSP文件标签上点击右键，在弹出的菜单中选择make "xxx.jsp"，即可完成对JSP文件的编译，及时发现错误。JSP文件和Java文件在编辑时，最大的区别是Java程序文件一有错误就会在编辑器和结构窗格中列出，但JSP文件的有些错误需要通过编译才能发现。
　　提示：

　　由于编译JSP文件需要先将其转换为Servlet文件，然后再编译这个中间Servlet文件，发生错误后转定向到JSP文件中，所以编译一个JSP文件是比较耗时的，往往比编译一个Java文件要花好几倍的时间。在默认的情况下，编译一个工程时，会编译整个工程中所有的JSP，需要消耗大量的时间。所以最好取消在编译工程连带编译JSP文件的设置：通过Project-＞Project Properties...-＞Build-＞ 在Build设置页中取消Check JSPs for errors at build-time选项。在确实需要的时候再勾选这个选项，并在编译后及时取消这个选项。通过这样的设置将可以为你的开发赢得不少宝贵的时间。

JBuilder2005实战JSP之切换控制.

由于在login.jsp的表单中通过action属性指定switch.jsp为响应的JSP文件，当用户在login.jsp中选定登录用户，输入密码提交表单后，客户端将向服务器发送一个HTTP请求，服务器即调用switch.jsp来响应这个请求。

　　表单中用户名和密码两组件的数据将通过HTTP请求传给服务器的switch.jsp，服务器将这些信息封装在request对象中传给switch.jsp，所以switch.jsp可通过request.getParameter(String paraName)来获取这两个值。
String userId = request.getParameter("userId");
String password = request.getParameter("password");

　　试想如果login.jsp的表单有10个以上的数据组件，则在switch.jsp中必须通过相应数目的request.getParameter()方法获取其值。此外，如果这些数据不是字段串类型，而是整数或浮点数，由于request.getParameter()方法返回的值都是String，还必须进行类型的转换，这种工作不但单调乏味，还容易出错。

　　JSP允许你通过Bean以映射的方式接收网页表单的数据，Bean以这个规则映射表单的数据：Bean属性名=表单数据组件名，也即所有和Bean属性名相同的表单数据域被自动填充到Bean中，并且完成数据类型的转换。如login.jsp的表单中有两个数据组件，一个名为userId，另一个是password，定义一个拥有相同名的userId和password属性的User.java Bean，这个Bean将可以自动接收表单中的两个数据组件值。

　　编写User.java

　　我们先来编写这个User.java的Bean，在工程中创建User.java，其代码如下所示：

　　代码清单 7 User.java
1. package bookstore;
2.
3. public class User
4. {
5. private String userId;//用户Id
6. private String password;//密码
7. private String userName;//用户名
8. public String getPassword() {
9. return password;
10. }
11. public String getUserId() {
12. return userId;
13. }
14. public String getUserName() {
15. return userName;
16. }
17. public void setPassword(String password) {
18. this.password = password;
19. }
20. public void setUserId(String userId) {
21. this.userId = userId;
22. }
23. public void setUserName(String userName) {
24. this.userName = userName;
25. }
26. }

　　除userId和password两属性名，还有一个用户名属性userName，这个属性的值不是从login.jsp的表单接收的，当用户名密码验证正确后，从数据表T_USER表中获取用户名保存在这个属性中，以便其他地方引用，保存并编译这个类。
　　提示：

　　你可以通过JBuilder的Bean Express工具快速创建User.java的代码，在一般情况下，你应该通过Bean Express来创建Bean的属性，这样不但自动产生get/set的属性访问方法，还保证了Bean命名规范。

.编写页面程序

　　在创建User.java 的Bean后，我们着手创建switch.jsp，在switch.jsp中引用这个Bean。

　　通过File-＞New..-＞Web-＞双击JSP图标启动创建JSP向导。

　　1．指定swith.jsp名字

图 10 指定switch.jsp的名字

　　一直按Next到向导的第3步。

　　2．引用User.java Bean

图 11 指定JSP中引用Bean

　　点击Add Bean...按钮，弹出Select a Class对话框，在对话框中选择bookstore.User类，如下图所示：

图 12 选择类作为Bean

　　按OK后，返回到向导第3步的对话框，此时对话框的Bean列表中多了一行记录，可以在ID栏中为Bean指定一个名字，在Scope中指定Bean的作用域，如下图所示：

图 13 引用一个Bean

　　我们为User的Bean取名为userBean，将其作用域设置为page域。page域即为页面作用域，在当前页面范围作用域内可用，当JSP返回响应，或请求转到其他的JSP页面中时，都不可用了，其他3个作用域说明如下：

　　·request作用域：当一个请求产生直到返回响应的范围内都是有效的，如a.jsp中声明为request作用域的Bean，当a.jsp通过＜jsp:forward＞转移请求到b .jsp页面中时还是可用的。

　　·session作用域：在用户会话的周期内都是可用的，会话周期为用户登录系统直到其退出系统为此。

　　·application作用域：这个作用域最长，表示Web容器启动直到关闭都是有效的。

　　按Next到下一步。

3．设置运行配置项

　　在向导的最后一步，你可以为创建的JSP产生一个运行配置项，虽然向导将创建一个运行配置项设置为默认选项，但笔者认为这并不是一个合理的默认值，建议取消create a runtime configuration设置项，不要创建JSP的运行配置项，如下图所示：

　　按Finish按钮创建switch.jsp文件，其代码如下所示：

　　代码清单 8 向导创建的switch.jsp
1. ＜%@ page contentType="text/html; charset=GBK" %＞
2. ＜html＞
3. ＜head＞
4. 　＜title＞
5. 　　switch
6. 　＜/title＞
7. ＜/head＞
8. ＜jsp:useBean id="userBean" scope="page" class="bookstore.User" /＞
9. ＜jsp:setProperty name="userBean" property="*" /＞
10. ＜body bgcolor="#ffffff"＞
11.　＜h1＞
12.　　JBuilder Generated JSP
13.　＜/h1＞
14. ＜/body＞
15. ＜/html＞

　　第8行是引用Bean的JSP标签，第9行用表单的数据填充Bean的属性值，即以名字匹配的方式将request的参数填充到Bean的属性中，同时完成类型转换（只有基本数据类型或构造函数支持的才可以完成转换）。在执行完第9行后，userBean中的userId和password属性将被设置为login.jsp页面中所发送过来的用户名和密码的值。

　　因为switch.jsp只是用于控制，并不需要显示内容到客户端，所以我们去除switch.jsp中的HTML代码，将switch.jsp调整为：

　　代码清单 9 去除静态HTML代码后的switch.jsp
1. ＜%@ page contentType="text/html; charset=GBK" %＞
2. ＜jsp:useBean id="userBean" scope="page" class="bookstore.User" /＞
3. ＜jsp:setProperty name="userBean" property="*" /＞

　　在switch.jsp中提供一段Scriptlet，将userId和password发送到数据库和T_USER表中的用户比较看是否是合法的用户，根据验证的结果转向不同的页面。switch.jsp的最终代码如下所示：

　　代码清单 10 最终的switch.jsp
1. ＜%@page contentType="text/html; charset=GBK"%＞
2. ＜%@page import="bookstore.*"%＞
3. ＜%@page import="java.sql.*"%＞
4. ＜jsp:useBean id="userBean" scope="session" class="bookstore.User"/＞
5. ＜jsp:setProperty name="userBean" property="*"/＞
6. ＜%
7. Connection conn = null;
8. try {
9. 　conn = DBConnection.getConnection();
10.　PreparedStatement pStat = conn.prepareStatement(
11.　　"select USER_NAME from T_USER where USER_ID=? and password = ?");
12.　pStat.setString(1, userBean.getUserId());
13.　pStat.setString(2, userBean.getPassword());
14.　ResultSet rs = pStat.executeQuery();
15.　if (rs.next()) { //密码正确
16.　　userBean.setUserName(rs.getString(1));//设置用户名
17.　　session.setAttribute("ses_userBean", userBean);//将userBean放入Session对象中
18. %＞＜jsp:forward page=" welcome.jsp "＞＜/jsp:forward＞
19. ＜%} else { //密码错误%＞
20. ＜jsp:forward page="fail.jsp"＞＜/jsp:forward＞
21. ＜%
22.　 }} finally {
23.　　 if(conn != null) conn.close();
24.　 }
25. %＞

　　·在第2~3行中引入Scriptlet代码中需要的类。

　　·第7~14行代码向数据库发送查询SQL语句并返回结果。

　　·第15行通过检查结果集的记录数间接判断用户密码是否正确。

　　·第16~18行是用户密码正确的响应代码，首先用结果集的USER_NAME属性填充userBean的userName属性值，然后将userBean对象放入Session中，最后转向welcome.jsp页面。

　　·当用户输入密码不正确时，结果集中将没有记录，此时rs.next()返回false，程序转向第20行，第20行的代码将页面转向到密码输入错误的处理页面fail.jsp。

　　·第22~24行的代码用于关闭数据库的连接。

　　也许大家已经发现虽然第9~21行会抛出SQLException异常，但我们并没有相应的异常捕获块，在标准的Java程序中将导致一个编译期的错误，但在JSP中却可以顺序通过编译，这是因为JSP页面本身会捕获页面中抛出的所有异常。

　　假设第11行的SQL查询语句发生有错误，如将用户表名误写为User（正确为T_USER），当switch.jsp被调用后，第14行将抛出SQLException异常，此时switch.jsp将显示出异常堆栈迹的跟踪信息页面，如下图如示：

图 14 可怕的错误处理页面

　　上图所示的错误处理页面可谓青面獠牙，面目狰狞，非常不友好，对于开发人员来说这种报错页面也许是适合的，因为它提供了许多错误跟踪信息，但最终用户是不可能接受这种粗野的出错页面的。JSP允许你通过＜%@ page errorPage%＞为页面指定一个专门处理错误的JSP页面，以便用一种友好、直观的形式展现错误。在下一节里，我们将创建一个用于处理错误的JSP页面，在创建之后，我们再来为switch.jsp指定错误处理JSP页面。

. JBuilder2005实战JSP之错误处理.

错误处理页面error.jsp

　　Web应用程序一般都有一个或多个统一的错误处理JSP页面，以便在功能性的JSP页面发生错误时，能以一种友好的形式向用户反馈。友好而统一的错误页面是Web展现层一个无可忽略的方面。

　　下面，我们创建错误处理error.jsp文件，其代码如下所示：

　　代码清单 11 error.jsp错误处理JSP页面
1. ＜%@page contentType="text/html; charset=GBK" isErrorPage="true" %＞
2. ＜html＞
3. ＜head＞
4. ＜title＞error＜/title＞
5. ＜/head＞
6. ＜body bgcolor="#ffffff"＞
7. 抱歉，系统发生异常，点击＜a href="login.jsp"＞这儿＜/a＞返回首页
8. ＜/body＞
9. ＜/html＞

　　错误处理JSP页面的page指令标签中的isErrorPage属性应该设置为true，如第1行所示，这样JSP页面中就可以访问exception隐含对象了。在第7行，我们用一种"优雅"的方式向用户报告程序错误并提供一个返回到登录页面的链接。

　　现在，我们回过头去，通过＜%@ page errorPage="错误处理JSP"%＞将error.jsp指定为switch.jsp和login.jsp的错误处理页面。

　　为switch.jsp页面添加错误处理页面后，其代码如下：

　　代码清单 12 switch.jsp添加错误处理Jsp页面
1. ＜%@page contentType="text/html; charset=GBK" errorPage="error.jsp"%＞
2. ＜%@page import="bookstore.*"%＞
3. ＜%@page import="java.sql.*"%＞
4. …

　　为login.jsp页面添加错误处理JSP页面后，其代码如下：

　　代码清单 13 login.jsp添加错误处理页面
1. ＜%@page contentType="text/html; charset=GBK" errorPage="error.jsp"%＞
2. ＜%@page errorPage="error_error.jsp"%＞
3. …

　　这样，当switch.jsp的SQL查询语句不正确引发SQLException异常时，那个晦涩难懂的异常迹信息错误页面不见了，取而代之的是下面这个友好的报错页面：

图 15 友好的错误处理页面
.

登录失败fail.jsp

　　当用户提供不正确的密码时，switch.jsp将转向fail.jsp页面，同样你可以通过JSP向导创建fail.jsp页面，fail.jsp的代码如下：

　　代码清单 14 fail.jsp 登录失败页面　

1. ＜%@ page contentType="text/html; charset=GBK" errorPage="error.jsp" %＞
2. ＜html＞
3. ＜head＞
4. ＜title＞
5. fail
6. ＜/title＞
7. ＜/head＞
8. ＜body bgcolor="#ffffff"＞
9. 你输入的密码不正确，点击＜a href="login.jsp"＞这儿＜/a＞返回登录页面。
10. ＜/body＞
11. ＜/html＞
.
　　当用户密码输入错误后，所看到的fail.jsp页面效果，如下图所示：

. 　

图 16 fail.jsp页面效果
.
JBuilder2005实战JSP之特殊页面.

欢迎页面welcome.jsp

　　当用户录入正确的密码后，switch.jsp控制JSP页面导向welcome.jsp欢迎页面，在这节里，我们来开发这个welcome.jsp页面。因为welcome.jsp需要使用到一个第三方的标签库，所以在开发welcome.jsp之前需要在JBuilder中作一些配置引入这个标签库。

　　将第三方标签库配置到JBuilder中

　　Apache开源组织提供了许多有用标签库，欢迎页面welcome.jsp需要使用一个来源于Apache的datetime标签库，可以用这个标签库在JSP中提供各种时间的显示，下载的地址是：http://apache.justdn.org/jakarta/taglibs/datetime/binaries/jakarta-taglibs-datetime-1.0.1.zip。

　　标签库一般包括两个文件，其一是类包JAR文件，其二是以.tld为扩展名的标签符描述文件。从下载的压缩文档中解压后，我们将taglibs-datetime.jar和taglibs-datetime.tld文件放到＜工程目录＞/datetimeTag目录下。

　　要在工程中使用第三方的标签库，必须事先在JBuilder中配置这个标签库，并在工程中引用它。配置标签库和配置类库相似，也是通过Configure Libraries对话框来完成。JBuilder类库及标签库都列在Configure Libraries对话框中左边的树中，类库显示为 图标，而标签库显示为 图标。下面我们来将datetime标签库配置到JBuilder中。

　　1．Tools-＞Configure-＞Libraries-＞Configure Libraries对话框。

　　点击Configure Libraries对话框的左下角的Add...按钮，弹出New Library Wizard对话框，如下图所示：

图 17新库向导对话框

　　在Name中给这个库取一个名字：datetimeTag，按OK返回Configure Libraries对话框。

　　2．指定标签库文件。

　　在返回Configure Libraries对话框后，datetimeTag节点出现在左边的树中，因为还没有为其指定类库文件，有别于其他节点显示为显目的红色，点选datetimeTag并将Library Settings设置页切换到Framework标签页中，如下图所示：

图 18 切换到Framework中

　　在Framework下拉框中选择User-Defined JSP Tag Library选项，点击标签页右下方的Add...按钮，弹出Define New Tag Library对话框，如下图所示：

图 19 指定标签库的描述文件

　　在Define New Tag Library对话框中，点击TLD file后的…按钮，导航到＜工程目录＞/datetimeTag/taglibs-datetime.tld文件中，确认后JBuilder自动填充其余的设置项，一般不需要更改JBuilder这些自动补充的设置。其中Prefix为这个标签库指定了一个引用前缀。点击OK按钮返回Configure Libraries对话框，datetimeTag节点显示为正常的颜色如下图所示：

图 20 正确配置标签库后的效果

　　点击Configure Libraries对话框的OK按钮完成datetime标签库的配置。

　　3．在当前工程中引用这个新配置的标签库。

　　Project-＞Project Properties...-＞Paths-＞切换到Required Libraries标签页中-＞点击Add...按钮从JBuilder类库中选择datetimeTag。配置成功后，Project Properties对话框如下所示：

图 21 工程引用库

　　创建欢迎JSP页面

　　1．File-＞New…-＞Web-＞双击JSP图标，启动创建JSP向导，指定JSP文件名为welcome，点击Next到下一步。

　　2．在welcome.jsp页面中引用datetimeTag标签库。

　　在向导的第2步中允许你选择JBuilder中的各种标签库，我们在上一节中配置的datetimeTag标签库也出现在Tag Libraries列表中，如下图所示：

图 22 引用标签库

　　展开datetime Tag并勾选taglibs-datetime，按Next到一下步。

　　3．引用在switch.jsp中放入session域的userBean对象。

图 23 引用switch.jsp中放入session的userBean

　　点击Add Bean...选择bookstore.User类，在ID栏中指定Bean的名字为ses_userBean，Scope栏中选择session作用域。ses_userBean即是在switch.jsp为userBean所指定的名字，Web容器将根据这个名字到session中查找对象，如果找不到才创建bookstore.User对象，因为welcome.jsp在switch.jsp之后才被调用，所以除非session对期，否则都可以找到userBean对象。

　　直接点击Finish创建welcome.jsp文件，其代码如下所示：

　　代码清单 15 welcome.jsp欢迎页面
1. ＜%@ page contentType="text/html; charset=GBK" %＞
2. ＜%@ taglib uri="http://jakarta.apache.org/taglibs/datetime-1.0" prefix="dt" %＞
3. ＜html＞
4. ＜head＞
5. ＜title＞
6. welcome
7. ＜/title＞
8. ＜/head＞
9. ＜jsp:useBean id="ses_userBean" scope="session" class="bookstore.User" /＞
10. ＜jsp:setProperty name="ses_userBean" property="*" /＞
11. ＜body bgcolor="#ffffff"＞
12. ＜h1＞
13. JBuilder Generated JSP
14. ＜/h1＞
15. ＜/body＞
16. ＜/html＞

　　在向导第2步所引用的标签库设置对应第2行的引用标签库声明代码。而在第3步中设定的Bean对应第9~10行代码，因为在welcome.jsp中无需填充Bean的值，所以应该手工去除第10行的代码。

　　下面我们在welcome.jsp文件中引用datetime标签库，用它生成一个当前时间格式化串。打开welcone.jsp文件并切换到Source视图页中。首先清除＜body＞＜/body＞中JBuilder所产生的代码，在＜body＞＜/body＞中输入"＜dt:"，JBuilder将使用TagInsight功能显示出这个标签库中所有可用的标签项，如下图所示：

　　　　
　　　　　　　　　　　　图 24 利用TagInsight录入标签库

　　使用TagInsight可以非常方便地录入标签库中的可用标签，大大加速标签库的代码录入并保证正确性。在welcome.jsp中我们使用标签库获得一个当前的格式化时间串，此外我们还通过ses_userBean获取用户的名字。welcome.jsp的最终代码如下所示：

　　代码清单 16 welcome.jsp 引用标签库和Session对象
1. ＜%@page contentType="text/html; charset=GBK" errorPage="error.jsp"%＞
2. ＜%@taglib uri="http://jakarta.apache.org/taglibs/datetime-1.0" prefix="dt"%＞
3. ＜html＞
4. ＜head＞
5. ＜title＞welcome＜/title＞
6. ＜/head＞
7. ＜jsp:useBean id="ses_userBean" scope="session" class="bookstore.User"/＞
8. ＜body bgcolor="#ffffff"＞你是
9. ＜%=ses_userBean.getUserName()%＞,欢迎登录。＜br＞
10. 现在的时间是＜dt:表单at pattern="MM/dd/yyyy hh:mm"＞＜dt:currentTime/＞＜/dt:表单at＞
11. ＜br＞点击＜a href="quit.jsp"＞这儿＜/a＞退出系统
12. ＜/body＞
13. ＜/html＞

　　此外，JBuilder将datetime标签库描述文件taglibs-datetime.tld拷贝到WEB-INF下，并对web.xml文件动了手脚，声明taglibs-datetime.tld所在的地址：

　　代码清单 17 web.xml中声明标签描述文件
1. ＜?xml version="1.0" encoding="UTF-8"?＞
2. …
3. ＜web-app＞
4. ＜taglib＞
5. ＜taglib-uri＞http://jakarta.apache.org/taglibs/datetime-1.0＜/taglib-uri＞
6. ＜taglib-location＞/WEB-INF/taglibs-datetime.tld＜/taglib-location＞
7. ＜/taglib＞
8. ＜/web-app＞

　　如上所示，web.xml的第4~7行，JBuilder自动加入了datetime标签库的描述文件，以便Web容器正确找到所需的信息。

　　在编译工程生成Web目录时，JBuilder会将datetime标签库的JAR文件taglibs-datetime.jar拷贝到WEB-INF/lib目录下。

　　当用户登录成功后，将转向welcome.jsp页面，其页面效果如下图所示：

图 25 welcome.jsp效果页面

　　当用户点击"这儿"的链接时，将链接到quit.jsp，quit.jsp页面负责清除session，清除session后，将引用session中的对象解绑并释放资源。
　
　　quit.jsp退出处理页面

　　由于HTTP协议以请求/响应的方式工作，所以客户端退出系统时需要主动往Web服务器发送一个请求，通知Web服务器及时销毁会话，否则Web服务器只会等到会话过期时才会销毁它。

　　我们用一个quit.jsp来处理用户退出系统的操作，quit.jsp负责注销session，及时释放资源。

　　·注销session。

　　·关闭浏览器窗口。

　　其代码如下所示：
1. ＜%@ page contentType="text/html; charset=GBK" %＞
2. ＜%
3. 　session.invalidate();
4. %＞
5. ＜script language="javaScript" ＞
6. 　window.opener = null;
7. 　window.close();
8. ＜/script＞

　　其中第3行负责注销session，原先放入session的对象将解绑定，等待垃圾回收以释放资源。对于本例而言，session中有一个名为ses_userBean的userBean对象（它是在switch.jsp中放入session的），调用session.invalidate()后，userBean从session中解绑定，它的valueUnbound()方法会被触发调用，然后再等待垃圾回收。

　　第5~8行是一段JavaScript脚本程序，负责关闭窗口，如果网页不是通过脚本程序打开的（window.open()），调用window.close()脚本关闭窗口前，必须先将window.opener对象置为null，如第6行所示，否则浏览器会弹出一个确定关闭的对话框，笔者发现这个问题困扰了不少的Web程序员，故特别指出。
　　实战经验：

　　在用户退出系统时，需要注销session，否则只有等到session在服务器中过期后，session对象才会被清除。假设一个session的不活动最大时间为30分钟（默认的时间），如果不手工清除session对象，则当一个用户退出系统后再过30分钟，这些对象所占用的系统资源才会被释放。

. JBuilder2005实战JSP之日志和部署.用户登录和退出日志

　　当用户登录系统时，在日志表中插入一条记录，记录用户登录的时间，在用户退出系统时记录用户退出系统的时间。

　　我们利用HttpSessionBindingListener接口来完成记录登录和退出日志的功能，该接口中定义了两个方法：

　　·valueBound(HttpSessionBindingEvent event)

　　·valueUnbound(HttpSessionBindingEvent event)

　　如果一个类实现了HttpSessionBindingListener接口，当对象通过session.setAttribute()被绑定到Session中时，则对象的接口方法valueBound()被自动调用，当对象从session中移出时(通过调用session.invalidate()、session.removeAttribute()或session自动过期时)，valueUnbound()方法将被自动调用。

　　下面我们使User.java类实现HttpSessionBindingListener接口，调整后的代码如下所示：

　　代码清单 18 实现了HttpSessionBindingListener的User.java
1. package bookstore;
2. import javax.servlet.http.HttpSessionBindingListener;
3. import javax.servlet.http.HttpSessionBindingEvent;
4. import java.sql.*;
5. import java.text.SimpleDate表单at;
6. import java.util.Date;
7.
8. public class User implements HttpSessionBindingListener
9. {
10. 　…
11. 　private String loginDatetime;//用户登录时间
12. 　…
13. 　public void valueBound(HttpSessionBindingEvent event)
14. 　{
15. 　　Connection conn = null;
16. 　　String sqlStr = "insert into T_LOGIN_LOG(ID, USER_ID, DT_LOGIN) " +
17. 　　　　　　" values(SEQ_LOGIN_LOG_ID.NEXTVAL,?,? )";
18. 　　try
19. 　　{
20. 　　　conn = DBConnection.getConnection();
21. 　　　PreparedStatement pStat = conn.prepareStatement(sqlStr);
22. 　　　loginDatetime = getCurrDatetimeStr(); //当前时间串
23. 　　　pStat.setString(1, userId);
24. 　　　pStat.setString(2, loginDatetime);
25. 　　　pStat.executeUpdate();
26.
27. 　　} catch (SQLException e)
28. 　　{
29. 　　　throw new RuntimeException(
30. 　　　　"用户登陆日志写入出错");
31. 　　} finally
32. 　{
33. 　try
34. 　{
35. 　　if (conn != null)
36. 　　{
37. 　　　conn.close();
38. 　　}
39. 　} catch (SQLException ex)
40. 　{
41. 　　ex.printStackTrace();
42. 　}
43. 　}
44. }
45.
46. public void valueUnbound(HttpSessionBindingEvent event)
47. {
48. 　Connection conn = null;
49. 　String sqlStr = " update T_LOGIN_LOG set DT_LONOUT = ? " +
50. 　　　　　" where USER_ID=? and DT_LOGIN = ?";
51. 　try
52. 　{
53. 　　conn = DBConnection.getConnection();
54. 　　PreparedStatement pStat = conn.prepareStatement(sqlStr);
55. 　　pStat.setString(1, getCurrDatetimeStr());
56. 　　pStat.setString(2, userId);
57. 　　pStat.setString(3, loginDatetime);
58. 　　pStat.executeUpdate();
59.
60. 　} catch (SQLException e)
61. 　{
62. 　　throw new RuntimeException(
63. 　　　"用户退出日志写入出错");
64. 　} finally
65. 　{
66. 　　try
67. 　　{
68. 　　　if (conn != null)
69. 　　　{
70. 　　　　conn.close();
71. 　　　}
72. 　　} catch (SQLException ex)
73. 　　{
74. 　　　ex.printStackTrace();
75. 　　}
76. 　}
77. }
78.
79. //获取当前时间字串，以yyyyMMddHHmmss格式返回，如20050505010101
80. private static String getCurrDatetimeStr()
81. {
82. 　SimpleDate表单at sdf = new SimpleDate表单at("yyyyMMddHHmmss");
83. 　return sdf.表单at(new Date());
84. }
85. }

　　valueBound()方法向T_LOGIN_LOG表插入一条登录日志，在valueUnbound()方法中更新日志表的退出时间，此外第80~84行提供了一个获取当前时间串的方法getCurrDatetimeStr()，通过该方法获取登录和退出时间点的时间字符串。

　　下面通过描述用户登录系统直到退出时所经历的步骤说明程序如何记录用户的登录和退出时间的：

　　1．用户通过login.jsp输入密码登录后，程序转向switch.jsp控制页面。

　　2．在switch.jsp中，我们通过session.setAttribute("ses_userBean", userBean)方法将User.java类的对象userBean绑定到session中。

　　3．此时userBean对象的HttpSessionBindingListener接口方法valueBound()被调用，向T_LOGIN_LOG表插入一条登录日志。

　　4．switch.jsp转向welcome.jsp页面。

　　5．用户点击welcome.jsp页面中的链接退出系统时，转向quit.jsp页面。

　　6．quit.jsp调用session.invalidate()方法，userBean对象从session中清除。

　　7．此时userBean对象的HttpSessionBindingListener接口方法valueUnbound()方法被调用，更新日志的退出时间，关闭浏览器窗口。

　　HttpSessionBindingListener接口是Web容器的事件接口，实现接口的类在某个事件发生时自动被调用，Web容器有多个这样的事件接口，它们分别是：

　　·ServletContextListener 接口：Web容器启动和销毁的事件处理接口，接口中定义了两个方法。

　　·ServletContextAttributeListener接口：Web上下文属性发生更改时的事件处理接口。

　　·HttpSessionListener接口：Session创建和销毁事件的事件处理接口。

　　·HttpSessionAttributeListener接口：Session会话中属性对象更改的事件处理接口，该接口和我们在前面使用的HttpSessionBindingListener接口相似。

　　此外在J2EE1.4中还提供了另外两个事件处理接口，它们是：

　　·ServletRequestListener接口：Request请求对象创建和销毁事件处理接口。

　　·ServletRequestAttributeListener接口：更改Request中属性对象时的事件处理接口。

程序部署

　　在Web程序开发完成后，我们开始着手程序部署的工作，我们希望将这个Web应用程序部署到Tomcat5.0的Web应用服务器中。

　　首先我们设置Web应用程序的默认首页，然后再将整个Web程序打成一个WAR档案文件包。

　　1．设置默认访问的页面，双击工程窗格中的webModule节点，JBuilder在内容窗格显示如下的页面：

图 26 设置Web程序默认访问的页面

　　点击Welcome files列表右边的Add…按钮，在弹出的对话框中录入login.jsp并按确定按钮，将login.jsp页面作为默认页面，这样web.xml部署描述文件中将新增以下粗体的部署信息：

　　代码清单 19 Web应用程序默认页面
1. …
2. ＜web-app＞
3. ＜display-name＞webModule＜/display-name＞
4. ＜welcome-file-list＞
5. ＜welcome-file＞login.jsp＜/welcome-file＞
6. ＜/welcome-file-list＞
7. …
8. ＜/web-app＞

　　当用户在URL中没有指定具体的访问文件名时，Web容器自动查看URI下是否有login.jsp文件，如果直接调出这个文件。

　　2．在工程窗格中的资源树中右击webModule节点，Properties…-＞Build-＞在Build设置面中，将Build Web archive设置为When building project or module选项，如下图所示：

图 27 设置在Rebuild工程或Web模块时创建WAR档案文件

　　3．在工程窗格中右击chapter13.jpx，在弹出的菜单中选择Rebuild编译整个工程。

　　4．编译完成后，在工程根目录下将产生一个webModule.war文件。

　　5．拷贝webModule.war文件至＜JBuilder2005安装目录＞/thirdparty/jakarta-tomcat-5.0.27/webapps目录下。

　　这样就完成Web应用程序的部署了，下面我们启动Tomcat 5.0 Web应用程序服务器，并访问刚才部署的webModule.war应用程序。

　　1．双击＜JBuilder2005安装目录＞/thirdparty/jakarta-tomcat-5.0.27/bin下的startup.bat启动Tomcat 5.0 Web应用服务器（请保证这时JBuilder中没有运行Web应用程序，以免冲突）。

　　2．打开IE，键入http://localhost:8080/webModule，将正确访问到刚才部署的Web应用程序，如下图所示：

图 28 部署后login.jsp的访问效果

　　Tomcat 服务器默认工作于8080端口，所以在机器名后需要添加端口号，可以通过更改Tomca位于conf目录下的server.xml配置文件可以更改这个端口号。

　　由于我们的web应用程序的WAR文件名为webModule.war，web服务器启动后，会自动将WAR文件解压到webModule目录下，所以必须通过http://localhost:8080/webModule访问。此外，由于默认访问页面为login.jsp，所以没有指定具体的页面时，login.jsp页面被调用访问。

版权所有：UML软件工程组织