Java Web编程技术实验指导书

更新时间：2024-01-10 14:18:01 阅读量：教育文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

java培训班推荐度：
相关推荐

《Java Web编程技术》

实验指导书

2010年3月

实验一简单的Servlet与JSP .................................................................................................................. 1 实验二 HTTP请求对象 ........................................................................................................................... 3 实验三 HTTP响应对象 ........................................................................................................................... 7 实验四 Servlet容器模型 .......................................................................................................................... 9 实验五会话管理 .................................................................................................................................... 13 实验六 JSP基本语法与页面指令 ......................................................................................................... 16 实验七 JSP隐含对象与作用域 ............................................................................................................. 20 实验八 Web组件重用与JavaBeans ...................................................................................................... 24 实验九 JDBC访问数据库 ..................................................................................................................... 27 实验十表达式语言的使用 .................................................................................................................... 35 实验十一用户自定义标签 .................................................................................................................... 41 实验十二 JSTL与标签文件 .................................................................................................................. 44 实验十三 Servlet事件处理 .................................................................................................................... 50 实验十四 Servlet过滤器的使用 ............................................................................................................ 55 实验十五 Web应用的安全性 ................................................................................................................ 59

说明：

本实验指导书根据《Java Web编程技术》课程教学大纲编写，共包括15个实验，每个实验2学时，学生每周完成一个实验。

实验一简单的Servlet与JSP

一、实验目的

1. 了解和掌握Servlet和JSP页面的编写和运行。

2. 比较Servlet与JSP的区别和联系，体会动态页面的含义。二、实验原理

Servlet是运行在服务器端的Java程序，它主要是为了扩展服务器的功能。编写和运行Servlet一般要经过4个步骤：（1）编辑源文件，它是继承HttpServlet的Java类；（2）编译源文件；（3）在服务器中部署该Servlet，即将类文件存放到服务器的适当目录中，并修改web.xml部署描述文件；（4）使用浏览器访问该Servlet程序。

JSP是一种服务器端的动态页面技术，它的实质也是Servlet。它的编写较Servlet容易。二者的主要区别是：Servlet通常是实现业务逻辑，而JSP通常实现表示逻辑。

三、实验内容与步骤

（一）编写和运行一个简单的Servlet 【步骤1】在Tomcat安装目录的webapps下建立一个helloapp的目录，在其中再建立一个WEB-INF目录，在WEB-INF目录中建立一个classes目录。这样就建立了一个名为helloapp的Web应用程序。【步骤2】编写下面Servlet类，编译并将类文件放入classes目录中 package com.demo; import java.io.*;

import javax.servlet.*; import javax.servlet.http.*;

public class HelloServlet extends HttpServlet{

public void service(HttpServletRequest request,

HttpServletResponse response)

throws ServletException,IOException{

PrintWriter out = response.getWriter(); out.println(\out.println(\ out.println(\out.println(\

out.println(\out.println(\out.println(\} }

【步骤3】在WEB-INF目录中建立一个名为web.xml的文件，该文件为Web应用程序的部署描述文件，简称DD。具体内容如下：

xmlns:xsi=\ xsi:schemaLocation=\http://java.sun.com/xml/ns/j2ee/web-app_2_5.xsd\ version=\

helloServlet

com.demo.HelloServlet

helloServlet /hello

【步骤4】在浏览器的地址栏中输入下列地址访问该Servlet。

http://localhost:8080/helloapp/hello

在浏览器的窗口中应该显示Hello, World!内容。

（二）下面的Servlet可显示系统当前时间。请编译并部署该Servlet，然后使用浏览器访问。

package com.demo; import java.io.*;

import javax.servlet.*; import javax.servlet.http.*;

public class HelloWorldServlet extends HttpServlet{

public void service( )

throws ServletException,IOException{

PrintWriter out = ; out.println(\ out.println(\ out.println(\ out.println(\

out.println(\ out.println(\

out.println(\ out.println(\ out.println(\} }

（三）编写下面的JSP文件，将其用hello.jsp名保存到helloapp目录中

A Simple JSP Page

Hello,World!

The time now is:<%=new java.util.Date()%>

使用下面的URL访问该页面： http://localhost:8080/helloapp/hello.jsp （四）运行下面的JSP页面square.jsp

numbersquared <% for ( int i=0; i<10; i++ ) { %>

<%= i %><%= (i * i) %> <% } %>

（五）改写上述页面，使其运行后产生下列页面。

图1.1 square.jsp运行结果

四、思考题

1. 如何安装配置JDK和Tomcat?

2. 如何在Tomcat中运行Servlet和JSP页面？

实验二 HTTP请求对象

一、实验目的

1. 掌握如何获得请求参数； 2. 掌握如何检索请求头；

3. 了解如何通过请求对象获得客户信息；

4. 重点掌握使用请求对象存储数据和请求转发。二、实验原理

对客户的请求，容器根据请求调用Servlet的相应doXxx()方法，该方法带有两个参数，一个是HttpServletRequest，一个是HttpServletResponse，它们分别表示请求对象和响应对象，它们是容器自动创建的两个对象。可以使用这两个接口定义的若干方法完成有关操作。

三、实验内容与步骤

（一）通过查询串传递请求参数，并在Servlet中检索请求参数【步骤1】编写下面的Servlet。 package com.demo; import java.io.*;

import javax.servlet.*; import javax.servlet.http.*;

public class HelloUserServlet extends HttpServlet{

public void service(HttpServletRequest request,HttpServletResponse response)

throws ServletException, IOException{

String userName = request.getParameter(\PrintWriter pw = response.getWriter(); pw.println(\pw.println(\pw.println(\pw.println(\

pw.println(%userName + \pw.println(\

pw.println(\}

}

【步骤2】编译该Servlet，然后修改web.xml文件，将下面代码添加到其中：

helloUserServlet

com.demo.HelloUserServlet

helloUser /hellouser

【步骤3】使用下面的URL访问之。

http://localhost:8080/helloapp/hellouser?userName=John

将userName的值改为你自己的名字，看输出结果。若不给出查询字符串，结果如何？参数值使用汉字如何？

（二）通过表单传递请求参数，使用HttpServletRequest对象获得请求参数

【步骤1】首先编写一个input.html文件，存放在helloapp目录中。该页面在屏幕上显示一个表单，其中包括姓名和年龄域，点击“确定”按钮后，将表单参数传递给ParamServlet并显示出来。

input.html代码如下：

参数传递

从表单向Servlet传递参数

【步骤2】编写ParamServlet.java，其代码如下： package com.demo; import java.io.*; import java.util.*; import javax.servlet.*; import javax.servlet.http.*;

public class ParamServlet extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{ response.setCharacterEncoding(\

response.setContentType(\

String name = request.getParameter(\

name = new String(name.getBytes(\ String age = request.getParameter(\

age = new String(age.getBytes(\

PrintWriter pw = response.getWriter(); pw.println(\ pw.println(\ pw.println(\ pw.println(\

pw.println(\姓名：\ pw.println(\年龄：\ pw.println(\ pw.println(\ }

public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{ doGet(request, response); } }

【步骤3】修改web.xml文件，将下面代码添加到其中：

ParamServlet

com.demo.ParamServlet

ParamServlet /paramtest

【步骤4】测试参数传递。在浏览器的地址栏中输入：http://localhost:8080/helloapp/input.html。输入数据，点击“确定”按钮，体会表单参数的传递。

问题1：如何通过超链接的锚标签（）传递请求参数？（三）编写一个Servlet，显示所有请求头

【步骤1】ShowHeadersServlet.java的Servlet能够检索所有的请求头，代码如下： package com.demo; import java.io.*; import java.util.*; import javax.servlet.*; import javax.servlet.http.*;

public class ShowHeadersServlet extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{

response.setContentType(\ PrintWriter out = response.getWriter();

out.println(\

out.println(\ out.println(\

out.println(\

out.println(\ out.println(\ \

\alue\ Enumeration headerNames = request.getHeaderNames(); while(headerNames.hasMoreElements()){

String headerName = (String)headerNames.nextElement();

out.println(\

out.println(\ }

public void doPost(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException{ doGet(request, response); } }

【步骤2】修改web.xml，加入下面内容：

ShowHeadersServlet

/showheaders

【步骤3】在浏览器地址栏中输入下面URL访问该Servlet

（四）简单的综合应用

【步骤1】创建一个名为input.html的HTML页面，其中包括一个表单，表单中包含两个文本域，分别供用户输入学号和姓名，该页面也包含提交和重置按钮。

【步骤2】定义一个名为com.demo.Student类，其中包括学号sno和姓名name两个private的成员变量，定义访问和修改sno和name的方法。

【步骤3】编写名为FirstServlet的Servlet，要求当用户在input.html中输入信息后点击“提交”按钮，请求FirstServlet对其处理。在FirstServlet中使用表单传递的参数（学号和姓名）创建一个Student对象并将其作为属性存储在请求对象中，然后获得通过请求对象的getRequestDispatcher()方法获得RequestDispatcher()对象，将请求转发到SecondServlet。

【步骤4】在SecondServlet中取出请求对象上存储的Student对象，并显示输出该学生的学号和姓名。在SecondServlet的输出中应该包含一个超链接，点击该连接可以返回input.html页面。

图2.1 input.html页面显示结果图2.2 SecondServlet显示结果

四、思考题

1. 在Servlet中如何获得请求参数？

2. 如何实现请求转发？如何在请求对象中共享数据？

实验三 HTTP响应对象

一、实验目的

1. 了解和掌握如何从响应对象获得输出流对象； 2. 掌握如何设置响应类型；

3. 掌握如何设置响应头和状态码； 4. 重点掌握如何实现响应重定向。二、实验原理

对Servlet的请求目的是要获得响应消息。Servlet要向用户发送响应数据首先要获得输出流对象。另外，通过响应对象还可向客户端发送状态码，也可以设置有关响应头，还可以对响应重定向。

三、实验内容与步骤

（一）通过设置响应内容类型构建Excel电子表格 package com.demo; import java.io.*; import java.util.*; import javax.servlet.*; import javax.servlet.http.*;

public class ExcelServlet extends HttpServlet{

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException{

response.setHeader(\

response.setContentType(\ PrintWriter out = response.getWriter();

out.println(\ out.println(\学号\\t姓名\\t性别\\t年龄\\t所在系\ out.println(\李勇\\t男\\t20\\t信息\ out.println(\刘晨\\t女\\t19\\t数学\ } }

该程序的运行结果如下图所示：

图3.1 生成Excel电子表格

（二）向客户发送二进制文件 package com.demo; import java.io.*; import java.util.*;

import javax.servlet.*; import javax.servlet.http.*;

public class DownloadServlet extends HttpServlet{ public void doGet(HttpServletRequest request,

HttpServletResponse response) throws ServletException, IOException{

response.setContentType(\ File f = new File(\

FileInputStream is = new FileInputStream(f);

ServletOutputStream os = response.getOutputStream(); byte[] bytearray = new byte[1024]; int bytesread = 0;

while( (bytesread = is.read(bytearray) ) != -1 ){ os.write(bytearray, 0, bytesread); }

os.flush(); } }

注意：此Servlet正确运行，需要将servlet-api.jar文件复制到C盘根目录下。

（三）下面的ShowTimeServlet通过设置refresh响应头实现每2秒钟刷新一次页面。 package com.demo; import java.io.*; import java.util.*;

import java.text.SimpleDateFormat; import javax.servlet.*; import javax.servlet.http.*;

public class ShowTimeServlet extends HttpServlet{ public void doGet(HttpServletRequest request,

HttpServletResponse response) throws ServletException, IOException{

response.setContentType(\ response.setHeader(\

PrintWriter out = response.getWriter(); Date date = new Date();

SimpleDateFormat sdf = new SimpleDateFormat(\ String s = sdf.format(date);

out.println(\ out.println(\

out.println(\每5秒钟刷新一次页面

\ out.println(\现在的时间是：\

out.println(\ out.println(\ } }

（四）响应重定向

【步骤1】建立下面的login.html登录页面

【步骤2】编写一个名为RedirectServlet的Servlet，在其中检索用户名和口令参数值，然后判断其是否正确（若用户名和口令都为admin即认为正确），如果正确将响应重定向到welcome.html页面，否则将响应重定向到error.html页面，这两个页面请你自己编写，存放在应用程序根目录。下面是Servlet的部分代码。

package com.demo; import java.io.*;

import javax.servlet.*; import javax.servlet.http.*;

public class RedirectServlet extends HttpServlet{ public void doPost(HttpServletRequest request,

HttpServletResponse response) throws IOException,ServletException{

// 此处添加若干代码

if( ){

response.sendRedirect( ); }else{

response.sendRedirect( ); } } }

四、思考题

1. 如何理解Servlet的生命周期？ 2. 如何理解请求转发与响应重定向？

实验四 Servlet容器模型

一、实验目的

1. 掌握Web应用程序的DD文件web.xml的配置方法和作用； 2. 掌握如何通过ServletConfig获取Servlet的初始化参数；

3. 掌握ServletContext的概念，如何获得ServletContext对象； 4. 掌握如何通过RequestDispatcher转发请求。二、实验原理

Web应用程序有严格定义的目录结构，它需要一个称为部署描述文件的文件web.xml来配置。对应用程序的每个Servlet，可以在web.xml中定义若干个初始化参数，然后通过ServletConfig对象获取这些参数。

ServletContext对象表示该应用程序的环境，通过该对象可以获得应用程序范围的初始化参数、容器版本信息、资源的URL、在其中存放共享数据以及登录日志等。

三、实验内容与步骤

（一）建立一个名为bookstore的Web应用程序

在Tomcat的webapps目录下，建立一个如下所示的目录结构：

|- bookstore

|- html (包含所有的HTML文件) |- jsp (包含所有的JSP文件)

|- images (包含所有的GIF、JPEG和BMP图象文件) |- index.html (默认的HTML文件)

|- WEB-INF |-classes ├ lib

├ web.xml

图4.1 bookstore应用程序的目录结构

这样就建立了一个名为bookstore的Web应用程序，本实验后面的题目都在该应用程序下面完成。（二）使用ServletConfig检索Servlet的初始化参数【步骤1】编写ConfigDemoServlet程序，内容如下： package com.demo; import java.io.*; import java.sql.*; import javax.servlet.*; import javax.servlet.http.*;

public class ConfigDemoServlet extends HttpServlet{ String servletName=null; ServletConfig config=null; String email=null; String telephone=null;

public void init() {

config = getServletConfig();

servletName = config.getServletName(); email = config.getInitParameter(\

telephone = config.getInitParameter(\ }

public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException,IOException{ response.setContentType(\ PrintWriter out = response.getWriter(); out.println(\

out.println(\名称：\ out.println(\地址：\ out.println(\电话：\ out.println(\} }

【步骤2】修改web.xml文件，在其中添加下面Servlet定义和初始化参数定义

configDemoServlet

com.demo.ConfigDemoServlet

hacker@163.com

telephone 8899123

configDemoServlet /configDemo.do

【步骤3】在浏览器的地址栏中输入下面URL访问该Servlet： http://localhost:8080/bookstore/configDemo.do 程序运行结果如下图所示：

图4.1 ConfigDemoServlet程序的运行结果

（三）ServletContext的使用

修改上面程序，将email地址和电话使用ServletContext初始化参数传递给ConfigDemoServlet。使用ServletContext对象将email地址和电话信息写入日志文件中，并查看日志文件。（五）下面是一个Servlet，它可以获得有关服务器的信息。 package com.demo; import java.io.*; import java.util.*; import javax.servlet.*;

public class ServerInfo extends GenericServlet {

public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException { response.setContentType(\ PrintWriter out = response.getWriter(); ServletContext sc = getServletContext();

out.println(\ out.println(\ out.println(\ out.println(\获取服务器端信息\ out.println(\ out.println(\ out.println(\服务器端信息：\ out.println(\ out.println(\ out.println(\站点名\ out.println(\ out.println(\ out.println(\ out.println(\端口号\ out.println(\ out.println(\ out.println(\ out.println(\服务器类型\ out.println(\ out.println(\ out.println(\ out.println(\支持Servlet版本\ out.println(\ out.println(\ out.println(\ out.println(\服务器属性\ out.println(\ // 获得服务器属性集合 Enumeration attributes = sc.getAttributeNames(); while (attributes.hasMoreElements()) { String name = (String)attributes.nextElement(); out.println(name); } out.println(\ out.println(\ out.println(\ out.println(\ out.println(\ } }

（六）简单的综合应用

【步骤1】创建一个名为input.html的HTML页面，其中包括一个表单，表单中包含两个文本域，分别供用户输入学号和姓名，该页面也包含提交和重置按钮。

【步骤2】定义一个名为com.demo.Student类，其中包括学号sno和姓名name两个private的成员变量，定义访问和修改sno和name的方法。

【步骤3】编写名为FirstServlet的Servlet，要求当用户在input.html中输入信息后点击“提交”按钮，请求FirstServlet对其处理。在FirstServlet中使用表单传递的参数（学号和姓名）创建一个Student对象并将其作为属性存储在ServletContext对象中，然后获得通过ServletContext的getRequestDispatcher()

方法获得RequestDispatcher()对象，将请求转发到SecondServlet。

【步骤4】在SecondServlet中取出ServletContext上存储的Student对象，并显示输出该学生的学号和姓名。在SecondServlet的输出中应该包含一个超链接，点击该连接可以返回input.html页面。

图4.2 input.html页面显示结果图4.3 SecondServlet显示结果

四、思考题

1. 如何通过ServletConfig获得Servlet参数？

2. 如何获得ServletContext对象，如何通过该对象获得上下文参数？ 3. 如何使用ServletContext共享数据？

实验五会话管理

一、实验目的

1. 了解Web服务器对客户跟踪的各种方法；

2. 重点掌握使用HttpSession对象跟踪会话的方法； 3. 掌握使用Cookie技术跟踪会话的方法； 4. 了解URL重写和隐藏表单域的方法。二、实验原理

HTTP协议是无状态的协议。在很多情况下，Web服务器必须能够跟踪客户的状态。比如，对于一个购物网站，在一个时刻可能有多个客户购物，Web服务器必须能够区分不同的客户。一般情况下，Web服务器为每个客户配置了虚拟的购物车（ShoppingCart）。当某个客户请求将一个商品放入购物车时，Web服务器必须根据发出请求的客户的身份，找到该客户的购物车，然后把商品放入其中。

Web服务器跟踪客户的状态通常有4种方法：（1）使用HttpSession对象管理会话；（2）使用持久的Cookie对象；（3）使用URL重写机制；（4）使用隐藏的表单域。

三、实验内容与步骤

（一）使用HttpSession对象管理会话。 package com.demo; import java.io.*;

import javax.servlet.*; import javax.servlet.http.*; import java.util.Date;

public class ShowSession extends HttpServlet{ public void doGet(HttpServletRequest request,

HttpServletResponse response) throws ServletException, IOException {

response.setContentType(\

HttpSession session = request.getSession(); String heading =null;

Integer accessCount = (Integer)session.getAttribute(\

if(accessCount==null){

accessCount = new Integer(0); heading = \ }else{

heading = \

accessCount = new Integer(accessCount.intValue()+1); }

session.setAttribute(\

PrintWriter out = response.getWriter(); out.println(\

out.println(\ out.println(\

out.println(\

out.println(\ out.println(\

out.println(\ out.println(\ out.println(\

out.println(\ out.println(\

out.println(\ out.println(\ out.println(\ } }

图5.1 ShowSession程序的运行结果

（二）使用Cookie跟踪会话

使用Cookie跟踪会话涉及到向客户端写入Cookie和从客户端读取Cookie。【步骤1】向客户端写入Cookie对象 package test;

import java.io.*;

import javax.servlet.*; import javax.servlet.http.*;

public class SendCookie extends HttpServlet{ public void doGet(HttpServletRequest request,

HttpServletResponse response)

throws IOException,ServletException{ Cookie userCookie = new Cookie(\ userCookie. setMaxAge(60*60*24*7); response.addCookie(userCookie); response.setContentType(\ PrintWriter out=response.getWriter(); out.println(\ out.println(\

\ out.println(\ } }

访问上述Servlet将向客户端写入一个Cookie，执行后可查看客户机对应目录看是否写了一个文件。

图5.2 SendCookie程序的运行结果【步骤2】从客户端读取Cookie对象 package test;

import java.io.*;

import javax.servlet.*; import javax.servlet.http.*;

public class GetCookie extends HttpServlet{ public void doGet(HttpServletRequest request,HttpServletResponse response)

throws IOException,ServletException{

String cookieName = \ String cookieValue = null;

Cookie[] cookies = request.getCookies(); if (cookies!=null){

for(int i = 0;i

if(cookie.getName().equals(cookieName)) cookieValue = cookie.getValue(); } } response.setContentType(\ PrintWriter out=response.getWriter(); out.println(\ out.println(\ out.println(\ out.println(\ out.println(\

} }

图5.3 GetCookie程序的运行结果

四、思考题

1. 简述会话管理的常用方法有哪些？ 2. 如何使用HttpSession对象共享数据？

实验六 JSP基本语法与页面指令

一、实验目的

1. 熟练掌握JSP的声明、表达式、小脚本和注释的使用； 2. 理解JSP页面（page）指令和动作的语法格式； 3. 理解JSP页面的生命周期。

4. 熟练掌握page指令的下面的属性：import、session、errorPage、isErrorPage、contentType、pageEncoding。

5. 理解page指令的下面的属性：language、extends、buffer、autoFlush、info。

二、实验原理

JSP有三个指令元素：page、include和taglib。这些指令元素是针对JSP引擎的，并不会产生任何看得见的输出。它们都包含在<%@和%>标签内。本实验主要学习page指令。

<%@ page %>指令作用于整个JSP页面，包括静态包含的页面，但不包括动态包含的页面。可以在一个页面中包含多个<%@ page %>指令，但其属性除import外只能在整个页面中出现一次。

<%@ page %>指令可以放在页面的任何位置，但为了JSP程序的可读性，一般将<%@ page %>指令放在页面的前面。

三、实验内容与步骤

（一）输入并执行下面JSP页面，文件名为counter.jsp

<%@ page language=\<%! int count = 0; %> <% count++; %>

Welcome! You are visitor number <%= count %>

【步骤1】该JSP页面包含哪些JSP语法元素。在浏览器中访问该页面，输出结果如何？多次刷新页面，结果如何？

【步骤2】打开counter.jsp转换后的源文件counter_jsp.java，对应的类文件在哪里？文件名是什么？

【步骤3】查看count变量是在哪里声明的？

【步骤4】将上面JSP页面中的<%! int count = 0; %>一行改为<% int count = 0; %>，页面能否正常执行，它与上面页面有什么区别？（二）有下面expression.jsp页面：

<%@ page language=\<%!

int anInt = 3;

boolean aBool = true;

Integer anIntObj = new Integer(3); Float aFloatObj = new Float(8.6); String str = \

StringBuffer sBuff = new StringBuffer(); char getChar(){ return 'A'; } %>

<%= 500 %>

<%= anInt*3.5/100-500 %> <%= aBool %> <%= false %> <%= !false %> <%= getChar() %>

<%= Math.random() %> <%= aVector %> <%= aFloatObj %>

<%= aFloatObj.floatValue() %> <%= aFloatObj.toString() %> <%= aBool; %> <%= int i = 20 %>

<%= sBuff.setLength(12); %>

你能找出其中的错误吗？你可试着执行该页面，看会出现什么结果？将其中错误修改过来，最后输出下面结果：

图6.1 expression.jsp的运行结果

（三）运行下面persistent_counter.jsp页面，体会如何实现持久的计数器的？ <%@ page language=\<%!

int count = 0; String dbPath;

public void jspInit(){ try{

dbPath = getServletContext().getRealPath(\FileInputStream fis = new FileInputStream(dbPath); DataInputStream dis = new DataInputStream(fis); count = dis.readInt();

dis.close();

}

catch(Exception e){

log(\}

} %>

<%--下面是向浏览器输出的主要内容，

它将成为产生的_jspService()方法的一部分 --%>

<% count++; %>

Welcome! You are <%= count %> th visitor(s). <%!

public void jspDestroy(){ try{

FileOutputStream fos = new FileOutputStream(dbPath); DataOutputStream dos = new DataOutputStream(fos); dos.writeInt(count); dos.close(); }

catch(Exception e){

log(\} } %>

（四）输入并运行下面的import_test.jsp页面：

<%@ page import=\

page指令示例

<% Date date = new Date();
String s = DateFormat.getDateInstance().format(date);
String s2 = DateFormat.getDateInstance(DateFormat.FULL).format(date); %>

访问上述JSP页面，输出结果如下图所示：

图6.2 import_test.jsp页面的运行结果
可以看到页面中最后一行的中文显示为乱码，将下面代码加到JSP页面中： <%@ page contentType=\

18
重新访问页面，中文显示正常。这说明可以使用page指令的contentType属性指定页面输出使用的字符编码。默认情况下，JSP页面使用的字符集是iso-8859-1编码，如使用汉字编码应指定为gb2312或gbk。
（五） errorPage属性和isErrorPage属性的使用。
【步骤1】下面的hello.jsp页面执行时将抛出一个异常，它指定了错误处理页面为errorHandler.jsp。
<%@ page contentType=\
<%@ page errorPage=\ <%
String name = request.getParameter(\if (name == null){
throw new RuntimeException(\没有指定name 属性。\} %>
Hello, <%= name %>
【步骤2】下面的errorHandler.jsp是错误处理页面。
<%@ page contentType=\<%@ page isErrorPage=\
请求不能被处理：<%=exception.getMessage()%>
请重试！
用下面的URL访问hello.jsp页面，就会产生下面结果：
http://localhost:8080/bookstore/hello.jsp

图6.3 errorHandler.jsp页面的运行结果
这说明没有提供name参数，hello.jsp页面中抛出RuntimeException异常，所以调用错误页面。如果使用下面URL访问 hello.jsp页面，将产生下面正常的页面： http://localhost:8080/bookstore/hello.jsp?name=Mary

19
图6.4 hello.jsp页面的运行结果
注意：如果请求参数值使用汉字，仍然产生乱码，例如： http://localhost:8080/bookstore/hello.jsp?name=欧阳清风
这是因为请求参数默认使用iso-8859-1编码传递，如果要正确显示中文，应将请求参数编码转换为gb2312编码。
按下面方法修改hello.jsp页面，将请求参数值编码转换为汉字编码。 <%@ page contentType=\<%@ page errorPage=\ <%
String name = request.getParameter(\if (name==null){
throw new RuntimeException(\没有指定name 属性。\} else{
// 将字符串name的字符编码转换为汉字编码
name = new String(name.getBytes(\} %>
Hello, <%=name %>
四、思考题
1. JSP语法元素有哪些？使用时应注意什么问题？ 2. JSP页面的生命周期有哪几个阶段？ 3. 如何理解JSP页面本质上是Servlet？
4. page指令有哪些常用的属性，各自的功能是什么？
实验七 JSP隐含对象与作用域
一、实验目的
1. 掌握全部9个隐含对象的使用； 2. 理解4种作用域对象。二、实验原理
在JSP页面的转换阶段，JSP引擎在_jspService()方法中声明并初始化了9个隐含对象，它们主要是为了方便在JSP页面对这些对象的访问。这些隐含对象包括：application、session、request、response、out、page、pageContext、config、exception。
在上述9个隐含对象中，有下面4个作用域对象，它们是：application、session、request、pageContext。它们主要用来在不同作用域中共享数据。
三、实验内容与步骤
（一）了解隐含对象是如何定义的。
在helloapp应用程序中编写一个名为implicit.jsp的页面，内容为空。然后在浏览器中访问该页面。接下来打开\\work\\Catalina\\localhost\\helloapp\\org\\apache\\jsp目录中的implicit_jsp.java文件，查看隐含对象是如何定义的。
20
完成下面的填空：
JSP页面转换后定义的类名为：（）该类继承了哪个类：（）隐含对象request的类型为：（）隐含对象response的类型为：（）隐含对象pageContext的类型为：（）隐含对象session的类型为：（）隐含对象application的类型为：（）隐含对象config的类型为：（）隐含对象out的类型为：（）隐含对象page的类型为：（）修改implicit.jsp页面，在中加入下面一行： <%@ page isErrorPage = \
然后再访问该页面，再次查看上述Java源文件，则可看到exception隐含对象的定义。隐含对象exception的类型为：（）说明下面4个隐含对象是如何得到的：
application（） config （） session （） out （）（二）各种隐含对象与作用域变量的使用
【步骤1】request隐含对象的使用（request.jsp）
<%@ page contentType=\<%
String remoteAddr = request.getRemoteAddr(); String remoteHost = request.getRemoteHost(); int serverPort = request.getServerPort(); %>
你的IP地址为：<%=remoteAddr %>
你的主机名为：<%=remoteHost %>
服务器的端口号为：<%=serverPort %>

页面运行结果如下图所示：

图7.1 request.jsp页面的运行结果
【步骤2】out隐含对象的使用（out.jsp）
<%@ page contentType=\Out Example

out对象的使用

out.print(\学习使用out对象\ int buffer = out.getBufferSize(); int available = out.getRemaining(); %>

out对象的类型为：<%= out.getClass().getName() %>
BufferSize=<%= buffer %>
Available=<%= available %>

上述页面运行结果如下图所示：

图7.2 out.jsp页面的运行结果

【步骤3】application隐含对象的使用（application.jsp） <%@ page contentType=\<%

int number = 0;

Integer num =(Integer)application.getAttribute(\ if(num==null){

application.setAttribute(\ } else{

number = num.intValue()+1;

application.setAttribute(\ } %>

application example

本页面文件的实际路径是：
<%=application.getRealPath(\application对象中变量num的值为：<%=application.getAttribute(\

上述页面运行结果如下图所示：

图7.3 application.jsp页面的运行结果

【步骤4】session隐含对象的使用（session.jsp）

<%@ page contentType=\<%@ page session=\<%

session.setAttribute(\欧阳清风\%>

您的会话ID是：<%=session.getId()%>

session对象中存放的变量user的值为：<%=session.getAttribute(\

上述页面运行结果如下图所示：

图7.4 session.jsp页面的运行结果

（三）错误页面与异常处理

【步骤1】下面的syntax_error.jsp页面将产生异常，exception.jsp页面使用exception对象处理异常。syntax_error.jsp页面的代码如下：

<%@ page contentType=\<%@ page import=\

<%@ page errorPage=\ <%

Calendar rightNow = null;

//下行代码将产生NullPointerException异常 rightNow.getTime(); %>

【步骤2】exception.jsp页面的代码

<%@ page contentType=\<%@ page isErrorPage=\<%@ page import=\

Exception Example

exception变量使用示例

exception.printStackTrace();

StringWriter sout = new StringWriter(); PrintWriter pout = new PrintWriter(sout);

exception.printStackTrace(pout); %>

 
   <%= sout.toString() %>

四、思考题

1. 在JSP页面中可以使用的隐含对象有哪几个？

2. 在JSP页面中可以使用的作用域对象有哪几个？它们都属于什么作用域？

实验八 Web组件重用与JavaBeans

一、实验目的

1. 理解静态包含和动态包含的概念，掌握相关指令和动作的使用； 2. 掌握JavaBeans的含义和创建；

3. 重点掌握在JSP页面中使用JavaBeans的标准动作。二、实验原理

通过重用Web组件可以提高应用程序开发的效率和其可维护性。在JSP中可以通过包含机制和JavaBean实现Web组件的重用。

包含分为静态包含和动态包含。静态包含通过include指令实现，动态包含通过标准动作jsp:include实现。

在JSP页面中使用JavaBean是最重要的组件重用技术，这主要是通过下面3个标准动作实现的：

三、实验内容与步骤

（一）include指令的使用

本实验包括3个文件header.htmlf、footer.jspf和main.jsp。在main.jsp文件中使用include指令实现静态包含，即实现页面组装技术。3个文件的代码如下：

【步骤1】创建header.htmlf文件

【步骤2】创建footer.jspf文件

<%@ page contentType=\

New Century Web Bookstore

<%@ include file=\

【步骤4】最后执行main.jsp文件，结果如下图所示：

图8.1 main.jsp页面的运行结果

（二）、、标准动作的使用

【步骤1】将上面的mian.jsp修改成下面这样（注意加粗部分的修改），重新执行main.jsp将得到相同的结果。

<%@ page contentType=\

New Century Web Bookstore

（三）标准动作的使用

【步骤1】action_forward.jsp的代码如下：

<%@ page contentType=\

Forward Test

【步骤2】forwardTo.jsp的代码如下：

<%@ page contentType=\<%

String userName = request.getParameter(\ String welcomeStr = \欢迎光临本站\ welcomeStr = userName+\ out.print(welcomeStr); %>

执行action_forward.jsp页面的结果如下：

图8.2 action_forward.jsp页面的运行结果

（四）、、的使用

从HTML页面login.html中输入用户名和口令等，然后提交给display.jsp页面，在该页面中通过JavaBeans保存数据并输出。

【步骤1】UserBean.java程序代码如下： package com.beans;

public class UserBean { private String username; private String password; private String email;

public UserBean(){}

public void setUsername(String username){ this.username = username; }

public void setPassword(String password){ this.password = password; } public void setEmail(String email){ this.email = email; }

public String getUsername(){

return username; } public String getPassword(){ return password; } public String getEmail(){ return email; } }

【步骤2】登录页面login.html代码如下：

Please input:

【步骤3】display.jsp页面使用JavaBeans显示输入的信息。

<%@ page import=\

UserName: Password: Email:

四、思考题

1. 试说明静态包含与动态包含的区别？

2．在JSP页面中使用JavaBean的动作有哪几个？

实验九 JDBC访问数据库

一、实验目的

1. 掌握使用传统的方法访问数据库； 2. 掌握使用数据源的方法访问数据库。二、实验原理

数据库应用是Web应用开发的一个重要应用。Web应用程序访问数据库有两种方法：传统的方法

和使用JNDI数据源的方法。

传统方法访问数据库的步骤是：①加载数据库驱动程序；②建立连接对象；③创建语句对象；④获得结果集；⑤关闭有关连接对象。

使用数据源访问数据库的步骤是：①配置数据源（局部数据源或全局数据源）；②通过JNDI机制查找命名数据源；③通过数据源对象创建连接对象；④其他与传统方法一致。

三、实验内容与步骤

（一）使用传统方法通过JSP页面访问数据库【步骤1】创建数据库。假设在PostgreSQL建立了一个名为bookstore的数据库，在其中建立books表，代码如下：

CREATE TABLE books (

bookid character(5) PRIMARY KEY, --书号 title text, --书名 author character varying(20), --作者 publisher character varying (40), --出版社 price real --价格 );

向books表中插入几条记录，代码如下： INSERT INTO books VALUES

('204','Head First Servlets & JSP', 'Bryan Basham', '中国电力出版社',98.00); INSERT INTO books VALUES

('201', 'Servlets 与JSP 核心教程', 'Hall Marty','清华大学出版社',45); INSERT INTO books VALUES

('202', 'Tomcat与Java Web 开发技术祥解', '孙卫琴', '机械工业出版社',45); INSERT INTO books VALUES

('203', 'JSP 应用开发技术', '柳永坡','人民邮电出版社',52); INSERT INTO books VALUES

('205', 'J2EE 1.4 编程指南', 'Spielman Sue','电子工业出版社',68);

注意：需要将数据库的JDBC驱动程序安装到应用程序的WEB-INF\\lib目录中。【步骤2】使用下面JSP页面displayBooks.jsp访问books表中的数据。 <%@ page contentType=\<%@ page import=\

Database Access Test <% try {

Class.forName(\

String dburl = \

Connection conn = DriverManager.getConnection(dburl, \ Statement stmt = conn.createStatement(); String sql = \ResultSet rs = stmt.executeQuery(sql); out.println(\

out.println(\书号书名作者价格\while (rs.next()){

out.println(\

}

out.println(\rs.close();

stmt.close(); conn.close();

}catch (Exception e) {

out.println(e.getMessage()); } %>

（二）通过数据源访问数据库

注意：需要将数据库的JDBC驱动程序安装到Tomcat安装目录的\\lib目录中,并重新启动Tomcat服务器。

【步骤1】建立局部数据源

在Web应用程序中建立一个META-INF目录，在其中建立一个context.xml文件，内容如下：

name=\jdbc/bookDS\

type=\ maxActive=\ maxIdle=\

username=\ maxWait=\

driverClassName=\ password=\

url=\

【步骤2】使用下面的JSP页面displayBooks.jsp访问数据库 <%@ page contentType=\

<%@ page import=\

DataSource Test <% try {

Context context = new InitialContext();

DataSource ds = (DataSource) context.lookup(\Connection conn = ds.getConnection(); Statement stmt = conn.createStatement();

ResultSet rs = stmt.executeQuery(\out.println(\

out.println(\书号书名作者价格\while (rs.next()){

out.println(\

}

out.println(\rs.close(); stmt.close(); conn.close();

}catch (Exception e) {

out.println(e.getMessage());

} %>

（三）综合应用。本实验采用MVC设计模式，通过数据源和DAO对象访问数据库。其中JavaBeans实现模型，访问数据库，Servlet实现控制器，JSP页面实现视图。

? 模型包括2个JavaBean：BookBean用于存放图书信息，BookDAO用于访问数据库。

? 控制器包括2个Servlet：BookQueryServlet根据请求参数查询图书信息、BookInsertServlet用

来向数据库中插入数据。

? 视图包括4个JSP页面：bookQuery.jsp显示查询页面、bookInsert.jsp显示插入页面、display.jsp

显示查询结果页面和errorPage.jsp显示错误页面。

【步骤1】存放图书信息的JavaBeans代码BookBean.java，它也是一个传输对象。 package com.beans; import java.io.*;

public class BookBean implements Serializable{ private String bookid = null; private String title = null; private String author = null; private String publisher = null; private float price = 0.0F;

public BookBean(){}

public BookBean(String bookId, String author,

String title, String publisher, float price) { this.bookid = bookId; this.title = title; this.author = author;

this.publisher = publisher;

this.price = price;

}

public String getBookid() { return this.bookid; } public String getTitle() { return title; }

public String getAuthor() { return this.author; } public float getPrice() { return price; }

public String getPublisher () { return publisher; }

public void setBookid(String bookid){ this.bookid=bookid; } public void setTitle(String title){this.title=title; }

public void setAuthor(String author){ this. author = author; } public void setPrice(float price){this.price=price; }

public void setPublisher (String publisher){ this.publisher = publisher;} }

【步骤2】下面的BookDAO是一个简单的JavaBeans，它实现数据库的访问。

package com.beans; import java.sql.*; import javax.sql.*; import javax.naming.*; import java.util.ArrayList; import com.beans.BookBean;

public class BookDAO{

private static InitialContext context= null; private DataSource dataSource = null;

public BookDAO(){ try{

if(context == null){ context = new InitialContext(); } dataSource = (DataSource)context.lookup(\ }catch(NamingException e2){ } }

// 根据书号查询图书信息

public BookBean searchBook(String bookid){ Connection conn = null;

PreparedStatement pstmt = null; ResultSet rst = null;

BookBean book = new BookBean(); try{

conn = dataSource.getConnection();

pstmt = conn.prepareStatement(\ pstmt.setString(1,bookid); rst = pstmt.executeQuery(); if(rst.next()){

book.setBookid(rst.getString(\ book.setTitle(rst.getString(\ book.setAuthor(rst.getString(\

book.setPublisher(rst.getString(\ book.setPrice(rst.getFloat(\ return book; }else{

return null; }

}catch(SQLException se){ return null; }finally{ try{

conn.close();

}catch(SQLException se){ } } }

// 插入一本图书记录

public boolean insertBook(BookBean book){ Connection conn = null;

PreparedStatement pstmt = null; try{

conn = dataSource.getConnection(); pstmt = conn.prepareStatement(

\ pstmt.setString(1,book.getBookid()); pstmt.setString(2,book.getTitle()); pstmt.setString(3,book.getAuthor()); pstmt.setString(4,book.getPublisher()); pstmt.setFloat(3,book.getPrice());

pstmt.executeUpdate(); pstmt.close(); return true;

}catch(SQLException se){ return false; }finally{ try{

conn.close();

}catch(SQLException se){ } } } }

【步骤3】下面的JSP页面bookQuery.jsp实现根据书号查询图书信息 <%@ page contentType=\ Book Query

请输入一个书号:

【步骤4】下面的JSP页面bookInsert.jsp实现向数据库中插入数据 <%@ page contentType=\ Book Insert

请输入图书信息：

<% if(request.getAttribute(\ out.print(request.getAttribute(\%>

【步骤5】显示查询结果的JSP页面display.jsp：

<%@ page contentType=\

书号：

出版社：

【步骤6】错误页面errorPage.jsp代码如下：

<%@ page contentType=\

对不起，您查的图书不存在！

【步骤7】下面的Servlet实现从请求参数获得书号，然后从数据库中查找该书，最后根据查询结果将请求转发到显示页面(display.jsp)或错误页面(errorPage.jsp)。

package com.control;

import java.io.*; import java.sql.*; import javax.servlet.*; import javax.servlet.http.*; import com.beans.BookBean; import com.beans.BookDAO;

public class BookQueryServlet extends HttpServlet{

public void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{ String bookid = request.getParameter(\ BookDAO bookdao = new BookDAO();

BookBean book = bookdao.searchBook(bookid);

if(book!=null){

request.getSession().setAttribute(\

RequestDispatcher view = request.getRequestDispatcher(\ view.forward(request, response); }else{

RequestDispatcher view = request.getRequestDispatcher(\ view.forward(request, response); } } }

【步骤8】下面的Servlet实现向数据库插入数据，并将控制请求的转发到bookInsert.jsp页面。

package com.control;

import java.io.*; import java.sql.*; import javax.servlet.*; import javax.servlet.http.*; import com.beans.BookBean; import com.beans.BookDAO;

public class BookInsertServlet extends HttpServlet{

public void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{

request.setCharacterEncoding(\ String message = null;

BookBean book = new BookBean(

request.getParameter(\ request.getParameter(\ Float.parseFloat(request.getParameter(\ );

BookDAO bookdao = new BookDAO();

boolean success = bookdao.insertBook(book); if(success){

message = \成功插入一条记录！\ }else{

message = \插入记录错误！\

}

request.setAttribute(\

RequestDispatcher view = request.getRequestDispatcher(\ view.forward(request, response); } }

【步骤9】在DD文件中部署Servlet，将下列代码添加到DD文件的适当位置：

bookQuery

com.control.BookQueryServlet

bookInsert

com.control.BookInsertServlet

bookQuery /bookquery.do

bookInsert

/bookinsert.do 四、思考题

1. 简述使用数据源访问数据库一般步骤。

2. 简述使用数据源访问数据库比使用传统方法的优点。

实验十表达式语言的使用

一、实验目的

1. 了解表达式语言的功能； 2. 掌握表达式语言的使用。二、实验原理

表达式语言（EL）是JSP 2.0新增的功能。它是一种简洁的数据访问语言，通过它可以在JSP页面中方便地访问应用程序数据，无需使用JSP表达式（<%=和%>）。EL的目标是使动态网页的设计、开发和维护更加容易。

EL的特点是访问数据可以使用点（.）运算符或方括号（[]）运算符；可以访问隐含对象；有自己的运算符构造表达式；可以使用Java语言编写的函数等。

三、实验内容与步骤

（一）表达式语言运算符的使用

下面的JSP页面operator.jsp演示了EL运算符的使用： <%@ page contentType=\

JSP 2.0 Expression Language - Basic Arithmetic

JSP 2.0 表达式语言 - 基本算术运算符

该例说明了基本的表达式语言的算术运算符的使用，其中包括加(+),减(-), 乘(*),除(/ 或 div), 取余 (% 或 mod)。

EL 表达式结果 \\${1} ${1} \\${1 + 2} ${1 + 2} \\${1.2 + 2.3} ${1.2 + 2.3} \\${1.2E4 + 1.4} ${1.2E4 + 1.4} \\${-4 - 2} ${-4 - 2} \\${21 * 2} ${21 * 2} \\${3/4} ${3/4} \\${3 div 4} ${3 div 4} \\${3/0} ${3/0} 35 \\${10%4} ${10%4} \\${10 mod 4} ${10 mod 4}
\\${(1==2) ? 3 : 4} ${(1==2) ? 3 : 4}

（二）访问作用域变量

编写一个名为EmployeeBean的JavaBean，其中包括3个属性eno表示雇员号、ename表示雇员名和ecompany表示雇员公司名。

【步骤1】EmployeeBean.java程序代码 package com.beans;

public class EmployeeBean { private String eno = \ private String ename = \ private String ecompany = \

public EmployeeBean() { }

public void setEno(String eno){ this.eno = eno; }

public void setEname(String ename){ this.ename = ename; }

public void setEcompany(String ecompany){ this.ecompany = ecompany; }

public String getEno(){ return eno; }

public String getEname(){ return ename; }

public String getEcompany(){ return ecompany; } }

【步骤2】编写一个JSP页面，在其中通过表单输入雇员信息，将请求转发到一个Servlet。

<%@ page contentType=\

请输入雇员信息:

【步骤3】下面的Servlet从JSP页面得到客户信息

package com.control;

import java.io.*;

import javax.servlet.*; import javax.servlet.http.*;

import com.beans.EmployeeBean;

public class EmployeeServlet extends HttpServlet{

public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,IOException{

String eno = request.getParameter(\

String ename = request.getParameter(\

String ecompany = request.getParameter(\ EmployeeBean employee = new EmployeeBean(); employee.setEno(eno);

employee.setEname(ename);

employee.setEcompany(ecompany);

request.setAttribute(\ RequestDispatcher view =

request.getRequestDispatcher(\ view.forward(request, response); } }

【步骤4】下面的JSP使用EL表达式显示用户的信息

<%@ page contentType=\

雇员的信息如下：

雇员号:${employee.eno} 雇员名:${employee.ename} 公司名:${employee.ecompany}

（三）隐含对象的使用

下面的JSP页面implicit.jsp演示了EL隐含对象的使用。 <%@ page contentType=\

EL implicit objects

JSP 2.0 表达式语言-隐含对象

输入foo参数值

37

EL 表达式结果
\\${param.foo}
${param.foo}
\\${param[\
${param[\
\\${header[\ ${header[\
\\${header[\ ${header[\
\\${header[\ ${header[\

（四）在JSP页面中使用Java函数

设要在JSP页面中使用一个add()函数，实现两个整数的加法运算。在JSP中使用Java函数要经过如下3个步骤：

【步骤1】函数的定义，创建类文件Compute.java。它定义了要在JSP中使用的add()方法。

package com.demo;

public class Compute{

public static int add(String x,String y){ int a = 0; int b = 0; try{ a = Integer.parseInt(x); b = Integer.parseInt(y); }catch(Exception e){

System.err.println(\} return a+b; } }

package beans;

import java.util.*;

public class Functions {

public static String reverse( String text ) {

return new StringBuffer( text ).reverse().toString();

}

public static int numVowels( String text ) { String vowels = \ int result = 0;

for( int i = 0; i < text.length(); i++ ) { if( vowels.indexOf( text.charAt( i ) ) != -1 ) { result++; } } return result; }

public static String caps( String text ) { return text.toUpperCase(); } }

【步骤2】创建标签库描述文件taglib.tld。它实现将每个Java方法与函数名相匹配。

xmlns:xsi=\ xsi:schemaLocation=\ http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd\ version=\

A Simple Taglib File. 1.0

Simple Tag Library

http://www.mydomain.com/function

Adding two numbers add

com.demo.Compute

int add( java.lang.String, java.lang.String)

Reverses the characters in the given String reverse

beans.Functions

java.lang.String reverse( java.lang.String )

Counts the number of vowels (a,e,i,o,u) in the given String countVowels

beans.Functions

java.lang.String numVowels( java.lang.String )

Converts the string to all caps caps

beans.Functions

java.lang.String caps( java.lang.String )

注意：将该文件保存在Web应用程序WEB-INF\\classes目录中。

【步骤3】编写JSP文件sum.jsp，使用标签库URI以及函数名调用Java函数，代码如下： <%@ page contentType=\

<%@ taglib prefix=\demo\http://www.mydomain.com/function\

Using Function

计算两个整数之和

两个整数的和为：${demo:add(param[\)}

该页面运行结果为：

图10.1 sum.jsp页面的运行结果

（四）编写一个名为palindrome(String str)的Java函数，实现判断用户输入的字符串是否是回文（palindrome）。编写一个JSP页面，通过EL使用该函数。 public static boolean palindrome(String str){ StringBuffer sb = new StringBuffer(str); if((sb.reverse().toString()).equals(str)){ return true; }else{ return false; } }

四、思考题

1. 简述JSP表达式语言的主要功能有哪些？ 2．简述在JSP页面中使用Java函数的步骤。

实验十一用户自定义标签

一、实验目的

1. 了解什么是自定义标签；

2. 掌握使用SimpleTag和SimpleTagSuppot开发简单标签； 3. 了解传统自定义标签的接口和类的使用。二、实验原理

自定义标签（custom tag）是JSP 1.1技术规范引进的，它也常称为自定义动作。自定义标签实际上是实现了某些特定接口的Java类。在JSP 1.1规范中提供了3个接口和2个实现类，它们是：Tag、IterationTag和BodyTag接口与TagSupport和BodyTagSupport实现类。这些API一般称为传统的标签扩展API。

为了简化标签库的开发，JSP 2.0在标签扩展API中增加了一个SimpleTag接口以及它的一个实现类SimpleTagSupport。使用它们会使开发自定义标签大大简化。创建和使用自定义标签一般包含下面三个步骤：

【步骤1】创建标签处理类(tag handler)；【步骤2】创建标签库描述文件（TLD）；

【步骤3】在JSP文件中引入标签库和使用标签。

三、实验内容与步骤

（一）开发一个简单的SimpleTag标签；【步骤1】创建简单标签类 package mytags;

import java.io.*;

import javax.servlet.jsp.*;

import javax.servlet.jsp.tagext.*;

public class MathTag extends SimpleTagSupport { int x = 289;

public void doTag() throws JspException, IOException { getJspContext().getOut().print(

} }

【步骤2】创建taglib.tld文件，将其存放在WEB-INF目录中，内容如下：

xmlns:xsi=\ xsi:schemaLocation=\ http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd\ version=\

www.mydomain.com/math 1.0 2.0

Sends a math expression to the JSP

sqrt

mytags.MathTag

empty

【步骤3】编写JSP页面math.jsp访问该标签，代码如下：

<%@ taglib prefix=\www.mydomain.com/math\

该页面的运行结果如下：

图11.1 math.jsp页面的运行结果

（二）开发一个空标签，该标签显示一个红色星号【步骤1】创建标签处理类(tag handler)

下面是RedStarTag标签的处理类的源代码： package sampleLib;

import java.io.*;

import javax.servlet.jsp.*;

import javax.servlet.jsp.tagext.*;

public class RedStarTag extends SimpleTagSupport {

public void doTag() throws JspException, IOException{ JspWriter out = getJspContext().getOut(); out.print(\ } }

【步骤2】创建标签库描述文件（TLD）

在WEB-INF目录中创建一个名为sampleLib.tld标签库描述文件，内容如下：

xmlns:xsi=\ xsi:schemaLocation=\ http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd\ version=\

A simple tag handler 1.0 2.0

mytaglib /WEB-INF/sampleLib.tld

star

sampleLib.RedStarTag empty

Prints * wherever it occurs

【步骤3】在JSP文件中引入标签库和使用标签

<%@ page contentType=\

<%@ taglib uri=\

请输入客户信息，带的域必须填写。

（三）开发带属性的标签【步骤1】创建标签处理类 package sampleLib;

import java.io.*;

import javax.servlet.jsp.*;

import javax.servlet.jsp.tagext.*;

public class GreetTag extends SimpleTagSupport { private String user;

public void setUser(String user) { this.user = user; }

public void doTag() throws JspException, IOException { JspWriter out = getJspContext().getOut(); try{

if (user==null)

out.print(\ else

out.print(\ } catch(Exception e){

throw new JspException(\ } } }

【步骤2】在TLD文件中对标签的定义

greet

sampleLib.GreetTag empty

Prints Hello user!

user

false

true

【步骤3】标签测试JSP页面greet.jsp

<%@ taglib prefix=\

pageScope.number =
requestScope.number =
sessionScope.number = （三）流程控制标签的使用。本实验包括2个页面，一个是flowControl.html，一个是flowControl.jsp。【步骤1】flowControl.html的代码如下：
JSTL中用于流程控制的标签
使用JSTL流程控制标签

请选择一个填入文本框中:Tom\\Jerry\\Mike\\Ben
【步骤2】flowControl.jsp的代码如下：
<%@ page contentType=\
<%@ taglib prefix=\
JSTL中用于流程控制的标签

标签c:if的使用

标签c:choose c:when c:otherwise使用

您好,Ben
执行flowControl.jsp的结果如下图所示：

47
图12.2 flowControl.html页面的运行结果
在文本框中输入Tom后，点击“传送”按钮，则出现下面的结果：

图12.3 flowControl.jsp页面的运行结果
（四）URL相关标签的使用
【步骤1】included.jsp是被包含的页面，代码如下： <%@ page contentType=\
<%@ taglib uri=\

Included Page
这是被包含页面中的内容

用户名：

【步骤2】import_test.jsp是包含页面，代码如下： <%@ page contentType=\
<%@ taglib uri=\

Using URL JSTL
这是包含页面中的内容

运行该页面，结果如下图所示：
48

本文来源：https://www.bwwdw.com/article/7h0o.html

相关文章：

正在阅读：

Java Web编程技术实验指导书01-10

主题活动中幼儿自主性的培养策略01-19

常见的词根词缀08-05

绿色建筑运营管理措施03-31

工程项目管理01-07

文明施工、环境保护及水土保持管理制度及细则(正式)08-12

上一篇：2015年扶风教师进修学校师训工作总结（修改）下一篇：企业物流管理信息系统设计