XJL:Java的Web开发基础知识

服务器通过配置文件将符合特定格式的 URL 同 Servlet 建立对应关系，当一个客户端请求到达服务器的时候，服务器就会分析其 URL 格式并派发给合适的 Servlet 处理，然后将 Servlet 处理完成的结果返回给客户。

与 ASP 、 PHP 等 Web 技术相比较， Servlet 具有如下优势：

可移植性： Servlet 是由 Java 开发的，所以它可以在任何支持 Java 的操作系统下运行。

功能强大： ASP 只能使用 ASP 内置的功能对象，要实现更复杂的功能必须调用用其他语言编写的 COM 模块； PHP 也只能使用其内置的功能，要实现更复杂的功能也必须挂接其他模块。由于 Servlet 本身是用 Java 语言编写的，所以可以使用 Java 中所有的功能，这些功能包括图像处理、文件处理、数据压缩解压、多线程、 JDBC 、 XML 、 EJB 、网络访问、加密解密等等。

开发方便： Java 本身是高度类型安全的，而且有强大的 IDE 支持。 Servlet 也是一个普通的 Java 类，所以编写 Servlet 的时候可以在开发时就发现程序中的错误，可以充分利用 IDE 提供的代码自动完成、调试、重构等功能加快开发速度。

1.1 Servlet

Servlet ，全称为 Java Servlet ，也被称为 Java 服务器端小程序，是用 Java 编写的服务器端程序，其主要功能在于交互式地浏览和修改数据，生成动态生成响应内容。 Servlet 是 Java 平台下的 Web 服务器处理请求的基本单位，可以看做是 Java 版的 CGI ，但是其功能和性能比 CGI 更加强大。从实现上讲， Servlet 可以响应 Http 、 Ftp 等任何类型的请求，但绝大多数情况下 Servlet 只用来扩展基于 Http 协议的 Web 服务器。

所有 Servlet 必须实现 javax.servlet.Servlet 接口，如果仅仅编写影响 Http 请求的 Servlet 的话从 javax.servlet.http.HttpServlet 派生即可， HttpServlet 封装了编写基于 Http 协议的 Servlet 的大部分功能。一个简单的 Servlet 如下：

package com.cownew.Char07;

import java.io.IOException;

import java.io.PrintWriter;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

public class DemoServlet extends HttpServlet

{

protected void doGet(HttpServletRequest request,

HttpServletResponse response) throws ServletException, IOException

{

doPost(request, response);

}

protected void doPost(HttpServletRequest request,

HttpServletResponse response) throws ServletException, IOException

{

String userName = request.getParameter("userName");

PrintWriter out = response.getWriter();

out.println("<html>");

out.println("<head>");

out.println("<title>Welcome</title>");

out.println("<body>");

out.print(" 你好 :");

out.println(userName);

out.println("</body>");

out.println("</html>");

}

DemoServlet 覆盖了父类中的两个方法： doGet 方法用来处理 Http Get 请求， doPost 用来处理 Http Post 请求。在这里 doGet 调用 doPost ，也就是 doGet 和 doPost 进行同样的处理。在 doPost 方法中，首先获得 PrintWriter 对象，然后调用 PrintWriter 的 println 等方法将要返回给客户端的 HTML 文件输出出来。

前面提到，每个 Servlet 都通过一定的 URL 规则与特定的请求相关联，因此在开发完毕 Servlet 后必须指定这些关联关系。关联的方法非常简单，只要在对应项目下的 web.xml 中添加如下内容即可：

<?xml version="1.0" encoding="UTF-8"?>

<web-app id="WebApp_ID" version="2.4"

xmlns="http://java.sun.com/xml/ns/j2ee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

<display-name>CowNewPIS</display-name>

……

<servlet-name>DemoServlet</servlet-name>

<servlet-class>

com.cownew.Char07.DemoServlet

</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>DemoServlet</servlet-name>

<url-pattern>/DemoServlet</url-pattern>

</servlet-mapping>

……

</web-app>

在 web.xml 中，首先声明 Servlet ，指定这个 Servlet 的名字和对应的 Java 类，然后在 servlet-mapping 标签中为这个 Servlet 进行映射，以后所有符合“ /DemoServlet ”格式的请求都会被派发给 DemoServlet 处理。

Servlet 是 Web 开发的基础，因此读者有必要对 Servlet 的整体框架有一个较全面的了解。

Servlet 相关的类与接口主要包括如下几类： Servlet 接口及其实现类； Servlet 配置相关类与接口；请求和响应相关类与接口 ; 过滤与监听。

Servlet 接口及其实现类

（ 1 ） javax.servlet.Servlet

这个接口是所有 Servlet 必须实现的接口，它定义了如下几个方法：

void init(ServletConfig servletconfig) ：用户初始化 Servlet ；

ServletConfig getServletConfig() ：获得 Servlet 配置相关的信息；

void service (ServletRequest request, ServletResponse response) ：响应客户端请求的入口点， request 表示客户端请求的信息， response 表示对客户端的响应信息；

String getServletInfo() ：获得 Servlet 的描述信息；

void destroy() ：销毁 Servlet ；

（2） javax.servlet.GenericServlet

它是一个抽象类，提供了对 Servlet 接口的默认实现，并且实现了 ServletConfig 等接口。

（3） javax.servlet.http.HttpServlet

这个类是针对 Http 请求的 Servlet 类，提供了对 Http 协议的响应功能，它从 GenericServlet 继承，大部分 Servlet 从它派生即可。其定义很多方法，子类可以根据需要有选择性的覆盖：

void doGet(HttpServletRequest req, HttpServletResponse resp) ：响应客户端的 Get 调用请求；

void doPost(HttpServletRequest req, HttpServletResponse resp) ：响应客户端的 Post 调用请求；

void doPut(HttpServletRequest req, HttpServletResponse resp) ：响应客户端的 Put 调用请求；

void doDelete(HttpServletRequest req, HttpServletResponse resp) ：响应客户端的 Delete 调用请求，客户端会请求此调用以删除服务端的某个文件，一般直接使用默认实现即可；

void doTrace(HttpServletRequest req, HttpServletResponse resp) ：响应客户端的 Trace 调用请求，一般只有开发调试的时候才会调用此方法，一般直接使用默认实现即可；

void doHead(HttpServletRequest req, HttpServletResponse resp) ：响应客户端的 Head 调用请求。当客户端只需要知道响应的 Head 时，它就会发出 Head 请求。比如在“断点续传”等技术中客户端就往往只关心响应的长度。

void doOptions(HttpServletRequest req, HttpServletResponse resp) ：响应客户端的 Options 调用请求。客户端可以通过此调用得知此 Servlet 支持的调用方式。 doOptions 的默认实现是根据当前类是否覆盖了 HttpServlet 的相应方法来得到 Servlet 支持的调用类型的，比如 Servlet 覆盖了 doPost 方法，那么就认为 Servlet 支持 POST 调用，一般情况下无需覆盖这个方法。

Servlet 配置相关类与接口

javax.servlet.ServletConfig 接口代表了 Servlet 的配置，一个典型的 Servlet 配置如下：

<servlet-name>action</servlet-name>

<servlet-class>

org.apache.struts.action.ActionServlet

</servlet-class>

<init-param>

<param-name>application</param-name>

<param-value>ApplicationResources</param-value>

</init-param>

<init-param>

<param-name>config</param-name>

<param-value>/WEB-INF/struts-config.xml</param-value>

</init-param>

<init-param>

<param-name>debug</param-name>

<param-value>2</param-value>

</init-param>

<load-on-startup>2</load-on-startup>

</servlet>

配置文件中描述了 Servlet 的名字， Servlet 的初始化参数等信息。

ServletConfig 接口主要方法有以下几个：

String getServletName() ：获得 Servlet 的名字；

ServletContext getServletContext() ：获得 Servlet 的上下文；

String getInitParameter(String string) ：获得初始化参数值，比如在上边的配置文件中， getInitParameter(“application”) 将返回字符串“ ApplicationResources ” ；

Enumeration getInitParameterNames() ：返回所有的初始化参数的名字的枚举器；

javax.servlet.http.HttpServletRequest

这个接口代表了 Http 请求，它从接口 javax.servlet.ServletRequest 扩展而来。我们从这个接口中获得请求参数的值、客户机的信息、服务器的信息、请求的信息等。接口还提供了获取客户端请求数据流的方法，不过只有当客户端的提交方式为 Post 或者 Put 的时候才会有效。 JSP 中的内置对象 request 就是 HttpServletRequest 的对象，其主要方法如下：

String getAuthType() ：获得认证类型；

Cookie[] getCookies() ：获得客户端发送的所有 Cookie ；

long getDateHeader(String string) ：获得日期类型的头信息值；

String getHeader(String string) ：获得字符串类型的头信息值；

Enumeration getHeaders(String string) ：获得所有头信息值；

Enumeration getHeaderNames() ：获得所有头信息名；

int getIntHeader(String string) ：获得整形的头信息值；

String getMethod() ：获得提交方式，一般是 Get 、 Post 、 Put 等；

String getPathInfo() ：获得请求路径；

String getPathTranslated() ：获得翻译以后的请求路径；

String getContextPath() ：获得上下文路径；

String getQueryString() ：获得原始的查询字符串；

String getRequestedSessionId(): 获得 Web Session 唯一标识；

HttpSession getSession() ：获得客户端 Session ，如果没有分配 Session 则返回 null ；

HttpSession getSession(boolean create) ：获得客户端 Session ，和上一个方法不同的是，如果没有分配 Session 的时候如果 create 参数为 true 的话则分配一个 Session 对象；

Object getAttribute(String string) ：获得属性值，这些值是服务端放置进去的，和客户端没有直接关系，这个方法和下面提到的 getParameter 方法没有直接关系；

void setAttribute(String key, Object value) ：设定属性值；

Enumeration getAttributeNames() ：获得所有的属性名；

void setCharacterEncoding(String encoding) ：设定编码方式；

ServletInputStream getInputStream() ：获得客户端数据流；

String getParameter(String key) ：获得请求参数值；

Enumeration getParameterNames() ：获得所有的请求参数名；

javax.servlet.http.HttpServletResponse

这个接口代表了服务器对客户端的 Http 响应，它从接口 javax.servlet.ServletResponse 扩展而来。我们通过这个接口设置响应的数据、 MIME 类型等。 JSP 中的内置对象 reponse 就是 HttpServletResponse 的对象，其主要方法如下：

void addCookie(Cookie cookie) ：为客户端添加 Cookie ；

String encodeURL(String url) ：使用 URL 和 SessionId 重写这个 URL ；

void sendRedirect(String url) ：把响应发送到另一个 JSP 页面或者 Servlet 进行处理；

ServletOutputStream getOutputStream() ：获得响应输出流对象；

void setContentType(String string); ：设定响应的 MIME 类型，当向客户端发送图片、 Excel 文件等特殊文件的时候非常有用；

void setCharacterEncoding(String encoding) ：设定响应的编码方式；

javax.servlet.Filter

Servlet 中的 Filter 技术在有的情况下能极大的简化开发任务，使用 Filter 可以在一个地方集中处理编码、权限控制等问题。 Filter 接口的实现如下：

void init(FilterConfig filterconfig) ：初始化 Filter ；

doFilter (ServletRequest request, ServletResponse response,FilterChain chain) ：这个方法是 Filter 的核心方法，进行过滤的业务逻辑要在这个方法中完成；

void destroy() ：销毁 Filter ；

javax.servlet.FilterChain

Servlet 中常常有多个 Filter ，这些 Filter 互相协作来完成任务，这些 Filter 组成一个有前后关系的链，这是“责任链”模式的典型应用。 FilterChain 接口仅仅定义了一个方法：

public void doFilter(ServletRequest request, ServletResponse response)

通过这个方法来调用下一个 Filter ，如果没有下一个 Filter ，则调用目标资源。

1.2 JSP

Servlet 是 Web 开发的基石，不过 Servlet 的缺点是明显的。所有的业务逻辑、 HTML 格式内容等全部要由 Servlet 输出，必须在 Servlet 中放置大量的 println 语句来输出页面，当页面太复杂的时候就会将开发人员搞晕。而且基本的 HTML 格式变化都必须在 Java 代码中修改，这意味着不熟悉 Java 语言的美工人员不能直接进行页面美工设计。

为了克服上述问题， JSP （ Java Server Pages ）技术应运而生。 JSP 是一种动态生成 HTML 、 XML 或其他格式的 Web 网页的技术标准。 JSP 技术是以 Java 语言作为脚本语言的， JSP 网页为整个服务器端的 Java 库单元提供了一个接口来服务于 HTTP 的应用程序。 JSP 使得开发人员在享受 Servlet 的优点的同时，使得 HTML 页面的创建更加容易。

下面演示了一个简单的 JSP 页面：

<%@ page language="java" contentType="text/html; charset=GB2312"

pageEncoding="GB18030"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<%@page import="java.util.Date"%>

<html>

<head>

<title>Welcome</title>

</head>

<body>

for(int i=0;i<3;i++)

{

<%=i %>

<%=new Date(i).toLocaleString()%>

}

</body>

</html>

当浏览器向服务器请求 JSPDemo.jsp 的时候，服务器的 JSP 编译器就会启动将 JSP 编译为 Java 源文件，该源文件定义了一个独立的类，类的名字依赖于源文件的名字。

比如在 Tomcat 服务器中会将 JSPDemo.jsp 转换成名称为 JSPDemo_jsp.java 的 Java 源文件，其内容如下：

package org.apache.jsp.Demo.Char07;

import javax.servlet.*;

import javax.servlet.http.*;

import javax.servlet.jsp.*;

import java.util.Date;

public final class JSPDemo_jsp extends org.apache.jasper.runtime.HttpJspBase

implements org.apache.jasper.runtime.JspSourceDependent {

private static java.util.Vector _jspx_dependants;

public java.util.List getDependants() {

return _jspx_dependants;

}

public void _jspService(HttpServletRequest request, HttpServletResponse response)

throws java.io.IOException, ServletException {

JspFactory _jspxFactory = null;

PageContext pageContext = null;

HttpSession session = null;

ServletContext application = null;

ServletConfig config = null;

JspWriter out = null;

Object page = this;

JspWriter _jspx_out = null;

PageContext _jspx_page_context = null;

try {

_jspxFactory = JspFactory.getDefaultFactory();

response.setContentType("text/html; charset=GB2312");

pageContext = _jspxFactory.getPageContext(this, request, response,

null, true, 8192, true);

_jspx_page_context = pageContext;

application = pageContext.getServletContext();

config = pageContext.getServletConfig();

session = pageContext.getSession();

out = pageContext.getOut();

_jspx_out = out;

out.write("\n");

out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n");

out.write("\r\n");

out.write("<html>\n");

out.write("<head>\n");

out.write(

"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=GB2312\">\n");

out.write("<title>Welcome</title>\n");

out.write("</head>\n");

out.write("<body>\r\n");

for(int i=0;i<3;i++)

{

out.write('\r');

out.write('\n');

out.write(' ');

out.print(i );

out.write('\r');

out.write('\n');

out.write(' ');

out.print(new Date(i).toLocaleString());

out.write(" \r\n");

}

out.write("\n");

out.write("</body>\n");

out.write("</html>");

} catch (Throwable t) {

if (!(t instanceof SkipPageException)){

out = _jspx_out;

if (out != null && out.getBufferSize() != 0)

out.clearBuffer();

if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);

}

} finally {

if (_jspxFactory != null) _jspxFactory.releasePageContext(_jspx_page_context);

}

可以看到编译以后的结果和编译前的形式有很大不同 , 编译之前的 JSP 文件好像将 Java 嵌入了 HTML 中，而编译之后则是将 HTML 嵌入了 Java 代码中。 JSP 文件被转换成 Java 源文件以后会继续被编译为二进制字节码，同时类中的 jspService 方法在调用的时候会传入请求和响应对象。

JSP 具有如下的优点：

业务逻辑和页面显示相分离

使用 JSP 技术， Web 页面美工人员可以使用 HTML 来设计页面，很显然 JSP 的开发方式使得代码变得更加简洁了，同时美工人员可以按照美化的要求进行页面设计，然后开发人员则可以在页面的基础上编写逻辑代码，二者互相协作而有不互相影响。

提高了可重用性

使用 JSP ，我们可以使用可重用的组件（比如 EJB 、 JMS 等）来执行应用程序所要求的更为复杂的业务逻辑。开发人员能够共享通用的组件，或者使得自己开发的组件被其他人使用。这种开发方式加速了系统的开发过程，使得团队中每个人的工作成果得到了最大程度的利用。

使用标签语言简化页面开发

JSP2.0 中加入了标签语言，这使得不懂 Java 的人员也能编写 JSP 页面， Web 页面美工人员无需熟悉脚本语言， JSP 将这些功能封装起来，使得功能的实现更加简单、方便。 JSP 标签能够访问和实例化 JavaBean 、描绘表单、插入 Flash 等，甚至能够采用无 Java 代码的方式访问数据库。而且标签语言支持扩展，这样第三方开发人员可以将常用的功能封装为标签。这样 Web 页面美工人员能够使用这些标签完成特定的功能。

拥有 Java 语言的所有优点

由于 JSP 页面的内置脚本本质上就是 Java 语言，并且所有的 JSP 页面也会被编译成 Servlet ，所以 JSP 页面就具有 Java 的所有优点，包括跨平台、高安全性等。

支持 JSP 的服务器非常多

目前有很多支持 JSP 的服务器，比如 Tomcat 、 Resin 、 Apusic 等，甚至一些非 J2EE 相关的服务器也能支持 JSP ，比如 Windows 下的 IIS 只要安装 JRun 、 ServletExec 等插件就可以运行 JSP ，著名的 Web 服务器 Apache 也内置了对 JSP 的支持，而 Apache 本身是可以运行在 Windows 、 Unix 、 Linux 等主流平台上的，因此 JSP 有非常广泛的平台支持。

内嵌标签

内嵌标签为开发人员提供了基本的功能，所有的内嵌标签以 jsp 最为前缀，最常用的内嵌标签包括： <jsp:param> 、 <jsp:include> 、 <jsp:forward> 、 <jsp:setProperty> 、 <jsp:getProperty> 、 <jsp:useBean> 、 <jsp:plugin> 、 <jsp:fallback> 、 <jsp:params> 。

（ 1 ） <jsp:param>

<jsp:param> 标签用来以“名值对”的形式为其他标签提供附加信息，它不能单独使用，必须和 <jsp:include> 、 <jsp:forward> 、 <jsp:plugin> 等标签协作使用。

（ 2 ） <jsp:include>

<jsp:include> 标签用来在页面中包含其他静态或者动态资源。被包含的对象只有对 JspWriter 对象 out 的访问权，不能设置消息头或者设置 Cookie 。 <jsp:include> 标签使用方式如下：

<jsp:include page= ” ad.htm ” />

<jsp:include page= ” showUser.jsp ” >

<jsp:param name= ” userName ” value= ” admin ” />

</jsp:include>

<jsp:include> 标签允许动态增加静态资源和动态资源。如果被包含的资源是静态的，那么被包含的资源仅仅是被添加到 JSP 文件中；如果被包含的资源是动态的，那么这些资源将会被执行，我们可以使用 <jsp:param> 为动态资源传递参数名和参数值。

我们来看一个具体的例子：

ShowInfo.jsp 是用来显示用户名和密码，用户名和密码通过参数设置：

String userName = request.getParameter("userName");

String password = request.getParameter("password");

UserName:<%=userName%>

Password:<%=password%>

IncludeTest.jsp 中使用 <jsp:include> 标签引用 ShowInfo.jsp ，并使用 <jsp:param> 标签为两个参数设置参数值。

<%@ page language="java" contentType="text/html; charset=gb2312"

pageEncoding="gb2312"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

<head>

</head>

<body>

<jsp:include flush="true" page="ShowInfo.jsp">

<jsp:param name="userName" value="<%=request.getParameter("userName") %>"/>

<jsp:param name="password" value="123456"/>

</jsp:include>

</body>

</html>

执行的效果如图所示：

图 7 . 1

从上边的例子可以看出使用 <jsp:param> 标签不仅能够设置静态的值还可以设置静态的值。

与 <%@page include%> 指令相比， <jsp:include> 标签效率比较低，不过 <jsp:include> 标签能够动态增加内容，而 <%@page include%> 包含的内容则是固定不变的，一经编译就不能改变。

（ 3 ） <jsp:forward>

<jsp:forward> 标签能够将请求转发到另一个 JSP 、 Servlet 或者静态资源。被转向的目标资源必须位于与 JSP 相同的上下文环境中，也就是不能转向服务器的其他上下问中，更不能转向外部网站上的资源。

<jsp:forward> 的使用和 <jsp:include> 是类似的，比如：

<jsp:forward page= ” newpage.jsp ” >

<jsp:param name= ” userId ” value= ” admin ” />

</jsp:forward>

（ 4 ） <jsp:setProperty>

<jsp:setProperty> 标签用户设置 Bean 的属性，此标签要和 <jsp:useBean 一起使用 > 。

（ 5 ） <jsp:getProperty>

<jsp:getProperty> 标签可以访问一个 Bean 的属性，它会调用对象的 toString 方法，将得到的字符串返回值发送到输出流中。使用方式如下：

<jsp:getProperty name=”myBean” property=”number”/>

（ 6 ） <jsp:useBean>

<jsp:useBean> 标签用来在 JSP 页面内创建一个 Bean 实例，并指定实例的名字以及作用范围。使用方法如下：

<jsp:useBean id=”varId” scope=”page|request|session|application” class=”classType”/>

id 属性用于设置实例的 ID ， ID 的名称是大小写敏感的。当需要这个 Bean 实例的时候，会通过此 ID 对实例进行引用。

scope 属性用于设置实例的存在的范围，它有如下取值“ page|request|session|application ”，默认值为 page 。 page 表示实例在此 JSP 以及此文件中的所有静态包含文件中使用，直到页面执行完毕向客户端发送响应或者转向另一个资源为止； request 表示实例在请求的范围内有效，可以使用 request 对象访问此实例，比如 request.getAttribute(“varId”) ； session 表示实例在 Session 有效范围内使用，可以使用 session 对象访问 Bean ，比如 session.getAttribute(“varId”) ； application 表示实例在整个 application 声明周期内有效，可以使用 application 对象访问此实例，比如 application.getAttribute(“varId”) 。

class 属性表示实例的类型。

（ 7 ） <jsp:plugin>

<jsp:plugin> 标签用来产生在客户端浏览器中插入 Applet 或者 JavaBean 的特别标签（ <Object> 或者 <Embed> ）， <jsp:plugin> 会根据浏览器的版本来决定生成 <Object> 元素还是 <Embed> 元素。

使用方法如下：

<jsp:plugin type = applet code = “ com.cownew.test.MyApplet.class ” codebase= ” . ” >

<jsp:params>

<jsp:param name= ” paramName ” value= ” paramValue ” />

</jsp:params>

<jsp:fallback>

插件加载失败！

</jsp:fallback>

</jsp:plugin>

type 属性表示被插入插件的类型，可选值为 applet 与 bean 。

code 属性表示将执行的 Java 类文件的名称，名称需要包含扩展名，而且必须存在于 codebase 属性指明的目录下。

codebase 属性为包含插件将运行的 Java 类的路径，默认为此 JSP 文件的当前路径。

<jsp:params> 标签用来向 Applet 或者 Bean 传递参数值。

<jsp:fallback> 用于 Java 插件不能正常启动时显示给用户的信息。

下面看一个具体的例子，首先开发一个简单的 Applet ，这个 Applet 代码如下：

package com.cownew.Char07;

import java.awt.BorderLayout;

import javax.swing.JPanel;

import javax.swing.JApplet;

import javax.swing.JTextField;

public class MyApplet extends JApplet

{

private JPanel jContentPane = null;

private JTextField jTextField = null;

public void init()

{

this.setSize(300, 200);

this.setContentPane(getJContentPane());

}

private JPanel getJContentPane()

{

if (jContentPane == null)

{

jContentPane = new JPanel();

jContentPane.setLayout(new BorderLayout());

jContentPane.add(getJTextField(), BorderLayout.CENTER);

}

return jContentPane;

}

private JTextField getJTextField()

{

if (jTextField == null)

{

jTextField = new JTextField();

jTextField.setText(getParameter("word"));

}

return jTextField;

}

在 init 方法中构建界面，在 getJTextField 方法中通过 Applet 类的 getParameter 得到参数“ word ”的值，并赋值给 jTextField 的 text 属性。

接着编写使用此 Applet 的 JSP 页面：

<%@ page language="java" contentType="text/html; charset=GB18030"

pageEncoding="GB18030"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

<jsp:plugin code="com.cownew.Char07.MyApplet.class" codebase="."

type="applet" width="200" height="200" align="middle">

<jsp:params>

<jsp:param name="word" value="2008" />

</jsp:params>

<jsp:fallback> 显示 Applet 错误 </jsp:fallback>

</jsp:plugin>

<jsp:plugin code="com.cownew.Char07.MyApplet.class" codebase="."

type="applet" width="200" height="200" align="middle">

<jsp:params>

<jsp:param name="word" value="welcome to BeiJing!" />

</jsp:params>

<jsp:fallback> 显示 Applet 错误 </jsp:fallback>

</jsp:plugin>

</body>

</html>

运行以后效果如图：

图 7 . 2

<jsp:plugin> 对于不同的浏览器会生成不同的 HTML 代码，比如对于 IE6 生成的代码如下：

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

显示 Applet 错误

</NOEMBED>

</COMMENT>

</OBJECT>

显示 Applet 错误

</NOEMBED>

</COMMENT>

</OBJECT>

</body>

</html>

JSTL

JSP 内置的标签提供的功能是非常有限的，因此在 JSP1.1 中开始支持自定义标签，但是自定义标签的广泛使用也造成了开发人员工作的重复，这就促成了 JSTL （ JavaServer Pages Standard Tag Library ， JSP 标准标签库）的诞生。

JSTL 封装了 JSP 开发中常用的功能，这样开发人员就可以以同一的方式来避免 JSP 中 Scriptlets ，甚至可以达到没有任何 Scriptlets 代码的目标。由于 JSTL 是标准的、统一的，所以很多 IDE 都支持以可视化的方式编辑含有 JSTL 标签的页面，这进一步无疑加快了开发效率。

JSTL 包含的功能是非常全面的，不仅包含数据输出、 bean 操作、条件判断，而且还包括 XML 解析和 JDBC 操作。由于直接使用 JSTL 进行 XML 解析和 JDBC 操作并不符合正规项目的分层开发思想，所以这里将不会介绍 JSTL 中 XML 解析、 JDBC 操作等标签，有兴趣的读者可以参考相关资料进一步研究。

（ 1 ） <c:out>

<c:out> 标签用于将计算的结果输出到页面中。比如：

<c:out value=”${age}”/>

其中的“ ${age} ”是被称作“表达式语言”，如果在页面上下文、 Request 、 Session 、 Application 等对象中有 age 属性的话，使用“ ${age} ”将会获得这个属性的值。

（ 2 ） <c:set>

<c:out> 标签用于在特定范围内（ Page 、 Request 、 Session 、 Application 等）中设定某个属性值，可以用来设置特定 bean 的值。

（ 3 ） <c:remove>

<c:remove> 标签用于在特定范围内（ Page 、 Request 、 Session 、 Application 等）删除某个属性值。语法如下：

<c:remove var=”varName” scope=”page|request|session|application”/>

（ 4 ） <c:if>

<c:if> 标签用于进行条件判断，如果其 test 属性计算结果为 true ，则计算其 Body 。比如：

<c:if test=”${isLogin}”>

欢迎光临

</c:if>

（ 5 ） <c:forEach>

<c:forEach> 用来迭代集合对象，并计算它的 Body 或者重复迭代固定的次数。比如：

<c:forEach var=”user” items=”${userList}”>

用户名： <c:out value=”${user.name}”/>

密码： <c:out value=”${user.password}”/>

</c:forEach>

items 属性表示被迭代的集合对象， var 为访问每个元素时所用的名称。

Struts 标签库

做为最为成熟的 Web 框架之一的 Struts 也提供了一组非常丰富的标签库，这些标签库有的和 Struts 结合的非常紧密，有的则完全可以脱离 Struts 框架而运行。 Struts 提供的标签库主要分成如下几类： HTML 标签库、 Bean 标签库、 Logic 标签库、 Template 标签库、 Titles 标签库、 Nested 标签库。

HTML 标签库

HTML 标签库包含了创建 HTML 页面的常用标签，其中最重要的就是 Form 相关标签，只有使用 Form 标签才能使得表单与 Struts 紧密结合工作。当使用 Struts 的时候，必须将整个页面用 <html:html> 标签包围起来。页面内的表单等也要使用 Struts 提供的标签。常用的标签有：代表表单的 <html:form> 、代表按钮的 <html:button> 、代表复选框的 <html:checkbox> 、代表文件输入框的 <html:file> 、代表隐藏表单的 <html:hidden> 、代表图片的 <html:img> 、代表超链接的 <html:link> 、代表密码框的 <html:password> 、代表单选按钮的 <html:radio> 、代表多行文本框的 <html:textarea> 、代表提交按钮的 <html:submit> 。

Bean 标签库

Bean 标签库为访问 Bean 提供了方便，此外 Bean 标签库也提供了访问 Cookie 、信息头、 Request 等的标签。主要包括：访问 Cookie 的 <bean:cookie> 、访问信息头的 <bean:header> 、进行页面装载的 <bean:include> 、将 bean 定义为表达式变量的 <bean:define> 。

Logic 标签库

Logic 标签库主要用于条件输出、对象迭代。这部分功能和 JSTL 中的逻辑控制标签库是类似的，不过 Struts 的 Logic 标签库更加方便易用，而且和 Struts 框架的结合也更加紧密。主要包括： <logic:empty> 、 <logic:equal> 、 <logic:greaterThan> 、 <logic:lessEqual> 、 <logic:match> 、 <logic:notEmpty> 、 <logic:notEqual> 、 <logic:present> 、 <logic:notPresent> 。

posted on 2007-02-19 21:45 CowNew开源团队阅读(776) 评论(0) 编辑收藏

新用户注册刷新评论列表


只有注册用户登录后才能发表评论。




网站导航: 博客园 IT新闻知识库 C++博客博问

CowNew开源团队

公告

常用链接

留言簿(83)

随笔分类

随笔档案

新闻档案

相册

友情链接

团队成员

搜索

最新评论

阅读排行榜

评论排行榜

1.1 Servlet

1.2 JSP