③JSP经典回顾

jsp概述

　　jsp实际就是一个高级servlet，比servlet容易很多。jsp/servlet在jsp容器中运行。例如，Tomcat就是一个Servlet/jsp容器。

　　关于tomcat：[传送门]

隐式对象

　　JSP隐式对象是Web容器加载的一组类的实例。它是可以直接在JSP页面使用的对象。分为4个主要类别：

　　　　输入和输出对象：控制页面的输入和输出(request、response、out)。

　　　　作用域通信对象：检索与JSP页面的Servlet相关的信息(session、application、pageContext)。

　　　　Servlet对象：提供有关页面环境的信息(page、config)。

　　　　错误对象：处理页面中的错误(exception)。

　　1.pageContext对象

　　　　(1)pageContext对象是javax.servlet.jsp.PageContext类的实例对象，javax.servlet.jsp.PageContext类是javax.servlet.jsp.JspContext的子类。

　　　　(2)pageContext对象是通过调用JspFactory.getPageContext方法返回的。

　　　　(3)pageContext对象封装了当前JSP页面的运行信息，它提供了返回JSP页面的其他隐式对象的方法。

　　　　(4)在JSP页面中只需将pageContext对象传递给某个Java类的实例对象，在该Java对象中就可以访问和调用其他隐式对象的功能了。

　　　　(5)pageContext对象使用户可以访问当前页面作用域中定义的所有隐式对象。

　　　　a)getException()方法返回exception隐式对象

　　　　b)getPage()方法返回page隐式对象

　　　　c)getRequest()方法返回request隐式对象

　　　　d)getResponse()方法返回response隐式对象

　　　　e)getServletConfig()方法返回config隐式对象

　　　　f)getServletContext()方法返回application隐式对象

　　　　g)getSession()方法返回session隐式对象

　　　　h)getOut()方法返回out隐式对象

　　　　删除属性的方法：public void removeAttribute(String name)

　　　　查找属性的名称：findAttribute方法,在制定的作用域中查找。找到了，就返回该属性的值，没找到就返回null.

　　　　请求的转发对象：

RequestDispatcher rd=request.getRequestDispatcher(“result.jsp”);

rd.forward(request,response);//转交到目的地

rd.include(request,response);

　　Servlet对象：

　　　　page对象:它代表的就是this，表示的是页面的本身。

　　　　<%!void fun(){

　　　　}%>

　　ServletConfig

　　在web.xml中进行配置：

<servlet>

    <servlet-name>ExampleServlet</servlet-name>

    <servlet-class>com.csdn.servlet.ExampleServlet</servlet-class>

    <init-param>

        <param-name>website</param-name>

        <param-value>www.csdn.com</param-value>

    </init-param>

  </servlet>

　　(6)PageContext类中定义了一个forward方法和两个include方法来分别简化和替代RequestDispatcher.forward方法和RequestDispatcher.include方法的调用：

　　　　a)public void forward(java.lang.String relativeUrlPath)throws javax.servlet.ServletException,java.io.IOException

　　　　b)public void include(java.lang.String relativeUrlPath)

　　　　throws javax.servlet.ServletException,java.io.IOException

　　　　c)public void include(java.lang.String relativeUrlPath,boolean flush) throws javax.servlet.ServletException,java.io.IOException

　　注意：传递给这些方法的资源路径都只能是相对路径，如果路径以“/”开头，表示相对于当前WEB应用程序的根目录，否则，表示相对于当前JSP所映射到的访问路径。

　　2、Servlet对象

　　　　a)page对象

　　　　　　page对象提供对网页上定义的所有对象的访问。page对象表示页面本身，它是java.lang.Object类的一个实例。

　　　　b)config对象

　　　　　　config对象存储Servlet的一些初始信息。config对象是javax.servlet.ServletConfig接口的一个实例，ServletConfig接口提供方法以检索Servlet初始化参数。config对象表示编译JSP页面的Servlet初始化数据的配置。

　　3、错误对象exception

　　　　（1）exception对象处理JSP页面中的错误

　　　　　　printStackTrace()方法用于显示异常的堆栈跟踪。

　　举个例子：

<%@page import="java.util.Enumeration"%>
<html>
<head>
	<title>
		Jsp
	</title>
</head>
<body>
	<b>
		Https headers:
	</b>
	<br/>
	<%
		for(Enumeration<String> e = request.getHeaderNames();e.hasMoreElements();){
			String header = e.nextElement();
			out.println(header+":"+request.getHeader(header)+"<br/>");
		}
	%>
	<hr/>
	<%
		out.println("Buffer size:"+response.getBufferSize());
		out.println("Session id:"+session.getId());
		out.println("Servlet Name:"+config.getServletName());
		out.println("Server Info:"+application.getServerInfo());
	%>
</body>
</html>

JSP页面结构

JSP程序的成分主要有如下四种：注释（Comment）、指令（Directive）、脚本元素（Scripting Element）、动作（Action）。JSP指令用来从整体上控制Servlet的结构；脚本元素用来嵌入Java代码，这些Java代码将成为转换得到的Servlet的一部分；动作用来引入现有的组件或者控制JSP引擎的行为。

为了简化脚本元素，JSP定义了一组由容器实现和管理的对象（内置对象）。这些内置对象在JSP页面中可以直接使用，不需要JSP页面编写者实例化。通过存取这些内置对象，可以实现与JSP页面Servlet环境的互访。

JSP页面构成如图4.2所示.

图4.2 JSP程序构成

【例4.1】一个简单的JSP页面。文件名为showJsp.jsp。

<%@ page contentType="text/html; charset=gb2312" language="java" import="java.sql.*" errorPage="" %>

<html>

<head>

<title>无标题文档</title>

</head>

<body>

<% out.println("Hello World!");%>

</body>

</html>

上述代码运行结果是输出"Hello World!"。

注释

和其他的程序语言一样，JSP也同样提供注释语句。JSP注释分为HTML注释和隐藏注释两种。JSP隐藏注释语句在JSP页面执行的时候会被忽略，不会执行。并且注释语句信息不会被送到客户端的浏览器中，也就是说，用户通过查看源文件是无法看到这些注释信息的，所以称之为隐藏注释。HTML注释和JSP注释的不同之处在于HTML注释在客户端浏览器能通过查看源文件而被查看到。

JSP隐藏注释

JSP注释语句的语法：

<%--comment--%>

【例4.2】文件comment.jsp

<%@ page contentType="text/html; charset=gb2312" language="java" import="java.sql.*" errorPage="" %>

<html>

<head>

<title>测试JSP的注释语句</title>

</head>

<body>

<h2>测试JSP注释语句</h2>

<%-- 这是一些注释信息，不会在查看网页源文件的时候看到 --%>

</body>

</html>

还有一种使用Java注释机制的注释方法：

<% /**comment */ %>

在使用的时候，一定要注意<%--和--%>必须成对出现，否则会编译出错。

HTML注释

HTML注释语句的语法：

例如：

在客户端的HTML源代码中产生和上面一样的数据：

又例如：

在客户端的HTML源代码中显示为：

这种注释和HTML语言很像，它可以在“查看源代码”中看到。唯一有些不同的就是，你可以在这个注释中使用表达式。这个表达示是不定的，由页面不同而不同，你能够使用各种表达式，只要是合法的就行。

JSP指令

在JSP页面中，可以使用JSP指令来指定页面的有关输出方式、引用包、加载文件、缓冲区、出错处理等相关设置，主要作用是用来于JSP引擎之间进行沟通。

JSP指令常用以下形式：

<%@ directive attribute=”value”%>

可以将多个属性写在一个语句中：

<%@ directive attribute1="value1" attribute2="value2" attributeN="valueN" %>

主要的三种指令是page include指令taglib，下面对三种指令进行详细说明。

page指令

在JSP文件中，可以通过<%@ page %>命令定义整个JSP页面的属性，通过这个命令定义的属性会对该JSP文件和包含进来的JSP页面起作用。此命令的语法比较复杂一些，下面就是语法定义：

<%@ page

[ language="java" ]

[ extends="package.class" ]

[ import="{package.class | package.*}, ..." ]

[ session="true | false" ]

[ buffer="none | 8kb | sizekb" ]

[ autoFlush="true | false" ]

[ isThreadSafe="true | false" ]

[ info="text" ]

[ errorPage="relativeURL" ]

[ contentType="mimeType [ ;charset=characterSet ]" | "text/html ; charset=ISO-8859-1" ]

[ isErrorPage="true | false" ]

下面是使用Page命令的几个小例子：

<%@ page contentType="text/html; charset=gb2312" language="java" import="java.sql.*" buffer="5kb" autoFlush="false" errorPage=" error.jsp " %>

通过Page命令，你可以为整个JSP页面定义上面提到的全局属性，其中除了“import”之外，其他的都只能引用一次，import属性和Java语言中的import非常相似，可以在JSP页面中多次使用它。

关于<%@ page %>的位置可以不去考虑，放在任何地方都可以很好的工作，但出于良好的编程习惯，建议放在JSP页面的顶部。几乎所有的JSP页面顶部都可以找到指令page。

1．language属性

定义JSP页面使用的脚本语言，若使用JSP引擎支持Java以外的语言，可指定所使用的语言种类。默认语言为Java

language=”java”

指明JSP文件中使用的脚本语言，目前只能使用Java。

2．contentType属性

contentType属性定义了JSP页面字符编码和页面响应的MIME类型。默认的MIME类型是text/html,默认的字符集是ISO-8859-1。例如：

<%@ page contentType="text/html; charset=gb2312" language="java" import="java.sql.*" %>

3．import属性

该属性用于JSP引入Java包中的类，如果你要包含多个包的话，将这些包的名称用逗号隔开放在一个import中，或者使用多个import分别声明。它是唯一可以多次指定的属性。

在使用Java包中的元素之前一定要先声明该包的import引用。下面一些Java包，是默认包含的，不用再在JSP页面中声明。

java.lang.*

javax.servlet.*

javax.servlet.jsp.*

javax.servlet.http.*

4．extends属性

定义此JSP页面产生的Servlet是继承自哪个父类。请特别谨慎使用这一功能，因为，服务器也许已经定义了一个。JSP规范对不完全理解其隐意的情况下使用此属性提出警告。

5．isErrorPage属性

isErrorPage="true|false"

默认值为“true”,设置是否显示错误信息。如果为true，可以看到出错信息，如果为false，就看不到了。

6．errorPage属性

errorPage="relativeURL"

设置处理异常事件的JSP文件的位置。表示如果发生异常错误，网页会被重新指向一个URL页面。错误页面必须在其page指令元素中指定isErrorPage="true"。

7．session属性

session="true|false"

默认值为“true”，定义是否在JSP页面使用HTTP的session。如果值为true，则可以使用session对象；如果值为false,那么JSP页面就不被加入到session中，session内置对象则不能使用，而同时会造成Bean的scope属性值只能是“page”。

8．Buffer属性

buffer="none|8kb|sizekb"

为内置对象out指定发送信息到客户端浏览器的信息缓存大小。以kb为单位。默认值是8kb.你也可以自行指定缓存的大小。也可以设置为“none”，那么就没有缓冲区，所有的输出都不经缓存而直接输出。

9．autoFlush属性

autoFlush="true|false"

指定是否当缓存填满时自动刷新，输出缓存中的内容。如果为true，则自动刷新。否则，当缓存填满后，可能会出现严重的错误。当你把buffer设置为none时，就不能将autoFlush设置为false。

10．isThreadSafe属性

isThreadSafe="true|false"

指定JSP页面是否支持多线程访问。默认值是ture，表示可以同时处理多个客户请求，但是你应该在JSP页面中添加处理多线程的同步控制代码。如果设置为false，JSP页面在一个时刻就只能响应一个请求。

11．info属性

info="text"

指定任何一段字符串，该字符串被直接加入到翻译好的页面中。可以通过Servlet.getServletInfo()方法得到。

4.3.2 include指令

Include指令的功能是在JSP编译时插入包含的文件。包含的过程是静态的。它可以把内容分成更多可管理的元素，如包括普通页面的页眉或页脚的元素。包含的文件可以是JSP、HTML、文本或是Java程序。

include指令的语法：

<%@ include file="relativeURL" %>

其中只有一个file属性，这个属性指定了被包含文件的路径。

如果路径是以"/"开头的，那么这个路径应该就是相对于JSP应用程序上下文而言的。而如果以目录名或文件名开头则是以JSP文件所在路径为当前路径而言。例如：

"header.jsp"

"/templates/onlinestore.html"

"/beans/calendar.jsp"

在JSP中，你可以用Include指令将JSP文件，HTML文件，或Text文件包含到一个JSP文件中，这种包含是静态包含，也就是说当使用这种方法包含文件的时候，会将被包含文件的内容插入包含文件中，替换掉<%@ include %>这行语句。如果你包含的是一个JSP文件，那么包含在这个文件中的JSP程序将被执行。

当你使用Include包含一个文件的时候，一定要注意，在被包含文件中不能含有<html>，</html>，<body>，</body>等HTML元素，否则的话会导致执行错误。因为被包含的文件会整个加入到JSP文件中去，这些标记会与JSP文件中类似的标记相冲突。

使用包含文件有以下一些优点：

（１）被包含文件可以在多个文件中被使用，实现了代码共享和重用。

（２）当被包含文件修改后，包含此文件的JSP文件的执行结果也发生变化，这样就提高修改效率，为维护提供方便。

【例4.3】

include.jsp

<html>

<head><title>An Include Test</title></head>

The current date and time are

<%@ include file="date.jsp" %>

</font>

</body>

</html>

date.jsp

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

<%= (new java.util.Date()).toLocaleString() %>

上面的例子在执行后，会在客户端的浏览器中显示和下面类似的信息：

The current date and time are

Aug 30,1999 2:38:40

taglib指令

taglib指令的功能是使用标签库定义新的自定义标签，在JSP页面中启用定制行为。

taglib指令的语法：

<%@ taglib uri="URIToTagLibrary" prefix="tagPrefix" %>

例如

<%@ taglib uri="http://www.jspcentral.com/tags" prefix="public" %>

<public:loop>

</public:loop>

<% @ taglib %>指令声明此JSP文件使用了自定义的标签，同时引用标签库，也指定了标签的前缀。

这里自定义的标签有标签和元素之分。因为JSP文件能够转化为XML,所以了解标签和元素之间的联系很重要。标签只不过是一个在意义上被抬高了点的标记，是JSP元素的一部分。JSP元素是JSP语法的一部分，和HTML一样有开始标记和结束标记。元素可以包含其它的文本，标记，元素。使用自定义标签之前必须使用<% @ taglib %>指令，而且可以在一个页面中多次使用，但是同一前缀只能引用一次。

URI根据标签的前缀对自定义的标签进行唯一的命名prefix="tagPrefix"，在自定义标签前的前缀，比如，在<public:loop>中的public，如果不写public，就是不合法的。请不要用jsp, jspx, java, javax, servlet, sun, 和sunw作为前缀。

JSP脚本元素

JSP脚本元素用来插入Java代码，这些Java代码将出现在由当前JSP页面生成的Servlet中。脚本元素有三种格式：声明格式＜%! declaration; %＞，其作用是把声明加入到Servlet类（在任何方法之外）；表达式格式＜%= expression %＞，作用是计算表达式并输出其结果；Scriptlet格式＜% code %＞，作用是把代码插入到Servlet的service方法。

4.4.1 JSP声明

JSP声明用来声明JSP程序中的变量、实例、方法和类。声明是以<%!为起始，以%>结尾。在JSP程序中，在使用一个变量或引用一个对象的方法和属性前，必须先对使用的变量和对象进行声明。声明后，你才可以在后面的程序中使用它们。

JSP的声明可以让你定义页面一级的变量以保存信息或定义该JSP页面可能需要的方法。其内容必须是一个采用page指令所定义的语言编写和完整有效的声明。JSP内置对象在声明元素中不可见，此时声明的变量作为编译单元的成员变量处理。

其语法如下：

<%! declaration; %>

例如：

<%! int i=0; %>

<%! int a,b,c; %>

注意：

1.编译JSP时，脚本小程序生成于jspService()方法的内部，而声明却生成于jspService()方法之外，与源文件合成一体。使用<%! %>方式所声明的变量为全局变量，即表示若同时n个用户在执行此JSP网页时将会共享此变量。因此应尽量少用声明变量，若要使用变量时，请直接在scriptlet之中声明使用即可。

2.每一个声明仅在一个页面中有效，如果你想每个页面都用到一些声明，最好把它们写成一个单独的JSP页面或单独的Java类，然后用<%@ include %>或<jsp:include >动作元素包含进来。

由于声明不会有任何输出，因此它们往往和JSP表达式或脚本小程序结合在一起使用。例如，下面的JSP代码片断输出自从服务器启动（或Servlet类被改动并重新装载以来）当前页面被请求的次数：

<%! private int accessCount = 0; %>

自从服务器启动以来页面访问次数为：

<%= ++accessCount %>

4.4.2 JSP表达式

JSP表达式用来计算输出Java数据，表达式的结果被自动转换成字符型数据，结果可以作为HTML的内容，显示在浏览器窗口中。JSP表达式包含在“<%= %>”标记中，不以分号结束，除非在加引号的字符串部分使用分号。开始字符和结束字符之间必须是一个完整合法的Java表达式。可以是复杂的表达式，在处理这个表达式的时候按照从左向右的方式来处理。

其语法如下：

＜%= expression %＞

例如：

<%= i %>

<%= "Hello" %>

<%= a+b %>

下面的代码显示页面被请求的日期/时间：

当前时间为：＜%= new java.util.Date() %＞

为简化这些表达式，JSP预定义了一组可以直接使用的对象变量。内置对象在表达式中可见。对于JSP表达式来说，最重要的几个内置对象及其类型如下，后面我们将详细介绍这些内置对象。

（1）request：HttpServletRequest。

（2）response：HttpServletResponse。

（3）session：和request关联的HttpSession。

（4）out：PrintWriter，用来把输出发送到客户端。

例如：

Your hostname: ＜%= request.getRemoteHost() %＞

4.4.3脚本小程序

如果要完成的任务比简单的表达式复杂时，可以使用JSP脚本小程序（Scriptlet）。脚本小程序中可以包含有效的程序片段，只要是合乎Java本身的标准语法即可。通常我们核心程序都写在这里，是我们实际编写的JSP程序的主要部分。

JSP脚本小程序的语法如下：

＜% Java Code %>

由于JSP和其他一些嵌入式语言一样，都会嵌在HTML语言内部使用，所以JSP页面中是由一段一段的JSP程序嵌在HTML语言里面组成的。脚本小程序能够包含要用到的变量或方法的声明和表达式。和JSP表达式一样，脚本小程序可以访问所有内置对象，所有的内建对象在小脚本中可见。例如，如果你要向结果页面输出内容，可以使用out变量。

String queryData = request.getQueryString();

out.println("Attached GET data: " + queryData);

注意：在程序段中定义的变量是局部变量，且程序段中的“表达式”必须使用“；”作为结束符，程序片段并不局限于一行代码中。

编译JSP时，编译器在jspService()方法中只简单地不作修改地包含脚本小程序的内容。当Web服务器响应请求时，Java代码就会运行。在脚本片段周围可能有纯粹的HTML代码，在这些地方，代码片段可以使你创建执行代码的条件，或调用另外的代码片段。

例如，下面的JSP片断混合了HTML语言和脚本小程序：

<% if (Math.random() < 0.5) { %>

Have a <B>nice</B> day!

<% } else { %>

Have a <B>lousy</B> day!

<% } %>

上述JSP代码将被转换成如下Servlet代码：

if (Math.random() <0.5) {

out.println("Have a <B>nice</B> day!");

}

Else

{

out.println("Have a <B>lousy</B> day!");

}

【例4.4】 num.jsp

<html>

<head>

<title>JSP程序段</title>

</head>

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

<body>

double num=0;

num=20;

if(num>10)

{ %> <%/*这里体现了JSP与HTML的结合*/%>

<h2>num的值大于10</h2> <%/*不属于JSP的这段HTML用%>……<%隔开*/%>

}

else out.println("num的值小于10");

</body>

</html>

运行结果：num的值大于10

例如，以下的代码组合使用表达式和代码片段，显示H1、H2、H3和H4标记中的字符串“Hello”。代码片段并不局限于一行源代码：

<% for (int i=1; i<=4; i++) { %>

<H<%=i%>>Hello</H<%=i%>>

<% } %>.

4.5 JSP动作

JSP动作利用XML语法格式的标记来控制Servlet引擎的行为。动作组件用于执行一些标准的常用的JSP页面。利用JSP动作可以动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码。

JSP动作元素包括：

jsp:include：当页面被请求时引入一个文件。

jsp:forward：请求转到一个新的页面。

jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记。

jsp:useBean：寻找或者实例化一个JavaBean。

jsp:setProperty：设置JavaBean的属性。

jsp:getProperty：输出某个JavaBean的属性。

4.5.1 include动作元素

<jsp:include>动作元素表示在JSP文件被请求时包含一个静态的或者动态的文件。

语法：

<jsp:include page="path" flush="true" />

其中，page="path"表示相对路径，或者为相对路径的表达式。flush="true"表示缓冲区满时会被清空，一般使用flush为true，它默认值是false。

例如：

inc.jsp

<%= 2 + 2 %>

test.jsp

Header

<jsp:include page="inc.jsp"/>

Footer

运行结果：4

【例4.5】下面的JSP页面把4则新闻摘要插入到 “WhatsNew.jsp”页面。改变新闻摘要时只需改变new文件夹下的四个具体新闻文件，而主JSP页面却可以不作修改：

WhatNews.jsp

<HTML>

<HEAD>

</HEAD>

<BODY BGCOLOR="#FDF5E6" TEXT="#000000" LINK="#0000EE"

VLINK="#551A8B" ALINK="#FF0000">

<TR＞<TH class="TITLE">

What's New at JspNews.com</TABLE>

</CENTER>

<P>

Here is a summary of our four most recent news stories:

<OL>

<LI＞<jsp:include page="news/Item4.html" flush="true"/>

</OL>

</BODY>

</HTML>

一般而言，不能直接从文件名称上来判断一个文件是动态的还是静态的。但是<jsp:include>能够自行判断此文件是动态的还是静态的，于是能同时处理这两种文件。如果包含的只是静态文件，那么只是把静态文件的内容加到JSP网页中；如果包含的是动态文件，那么把动态文件的输出加到JSP网页中。被包含的动态文件和主文件会被JSP Container分别编译执行。

前面已经介绍过include指令，它是在JSP文件被转换成Servlet的时候引入文件，而这里的jsp:include动作不同，插入文件的时间是在页面被请求的时候。jsp:include动作的文件引入时间决定了它的效率要稍微差一点，而且被引用文件不能包含某些JSP代码（例如不能设置HTTP头），但它的灵活性却要好得多。

include指令是在JSP文件执行时被转换成Servlet的时候，将被包含文件调入到主文件，然后二者一起被JSP容器编译，产生一个Servlet.

<jsp:include>动作是在JSP文件被请求时，被包含文件和主文件分别被JSP容器编译，产生两个Servlet，然后将被包含文件的Servlet调入到主文件的Servlet中。因此同样引入文件，使用include指令要比使用<jsp:include>动作的响应速度快。

4.5.2 forword动作元素

<jsp:forward>将客户端所发出来的请求，从一个JSP页面转交给另一个页面（可以是一个 HTML文件，JSP 文件，PHP文件，CGI文件，甚至可以是一个Java程序段。

语法：

<jsp:forward page={"relativeURL"|"<%= expression %>"}/>

page属性包含的是一个相对URL。page的值既可以直接给出，也可以在请求的时候动态计算，如下面的例子所示：

<jsp:forward page="/utils/errorReporter.jsp" /.>

<jsp:forward page="＜%= someJavaExpression %＞" />

有一点要特别注意，<jsp:forward>标签之后的程序将不能被执行。

例如

out.println("会被执行!!! ");

<jsp:forward page="other.jsp" />

out.println("不会执行!!!");

上面这个范例在执行时，会打印出“会被执行!!!”，随后马上会转入到other.jsp的网页中，至于out.println("不会执行!!! ")将不会被执行。

【例4.6】该实例需要四个文件：login.jsp，test.jsp，ok.htm，no.htm

首先看一下login.jsp

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

<html>

<head>

</head>

<body>

username<input type=text name=username>

password<input type=password name=password>

</form>

</center>

</body>

</html>

test.jsp代码如下：

<html>

string username=request.getparameter("username");

if(username.trim().equals("abc"))

{%>

<jsp:forward page="ok.html" />

<%}

else

{%>

<jsp:forward page="no.html" />

<%}

</html>

ok.htm和no.htm非常简单，可以分别写为：

运行效果是当你输入用户名为abc时,页面会自动跳转到ok.htm页面,否则跳到no.htm页面。

4.5.3 plugin动作元素

jsp:plugin动作用来根据浏览器的类型，插入通过Java插件运行Java Applet所必需的OBJECT或EMBED元素。

语法：

<jsp:plugin

type="bean|applet"

code="classFileName"

codebase="classFileDirectoryName"

[name="instanceName"]

[align="bottom|top|middle|left|right"]

[height="displsyPixels"]

[width="displsyPixels"]

[hspace="leftRightPixels"]

[vspace="topButtomPixels"]

[jreversion="java的版本"]

[<jsp:params>

[<jsp:param name="parameterName" value="参数的值"/>]

</jsp:params>]

[<jsp:fallback> 这里是在不能启动插件的时候，显示给用户的文本信息</jsp:fallback>]

</jsp:plugin>

Plugin中的各个属性如下：

（1）type="bean|applet"

插件将执行的对象的类型，必须指定。

（2）code="classFileName"

插件将执行的java类文件的名称，在名称中必须包含扩展名，且此文件必须在用"codebase"属性指明的目录下。

（3）codebase="classFileDirectoryName"

包含插件将运行的java类的目录或指相对这个目录的路径。

4.5.4. param动作元素

param动作元素用于传递参数。我们还可以使用<jsp:param>将当前JSP页面的一个或多个参数传递给所包含的或是跳转的JSP页面。该动作元素必须和<jsp:include>、<jsp:plugin>、<jsp:forward>动作一起使用。

和<jsp:include>一起使用的语法如下：

<jsp:include page="相对的URL值"|"<% =表达式%> " flush="true">

<jsp:param name="参数名1" value="{参数值|<%=表达式 %>}"/>

<jsp:param name="参数名2" value="{参数值|<%=表达式 %>}"/>

</ jsp:include>

和<jsp: forward>一起使用的语法如下：

<jsp:forward page="path"} >

<jsp:param name="paramname" value="paramvalue" />

</jsp:forward>

<jsp:param>中name指定参数名，value指定参数值。参数被发送到一个动态文件，参数可以是一个或多个值。要传递多个参数，则可以在一个jsp文件中使用多个<jsp:param>将多个参数发送到一个动态文件中。如果用户选择使用<jsp:param>标签的功能，那么被重定向的目标文件就必须是一个动态的文件。

例如：

<jsp:include page="scripts/login.jsp">

<jsp:param name="username" value="Aqing" />

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

</jsp:include>

4.5.5 useBean及setProperty和getProperty动作元素

1．useBean动作元素

<jsp:useBean>动作用来查找或实例化一个JSP页面使用的JavaBean组件。javaBean是特殊类型的java类，它与普通java类相比主要区别是包含了两种特殊的方法：setXXX( )(设置属性值的方法)、getXXX( )（取属性值的方法）。

在程序中可把逻辑控制、数据库操作放在javabeans组件中，然后在jsp文件中调用它。这个功能非常有用，因为它使得我们既可以发挥Java组件重用的优势，同时也避免了损失JSP区别于Servlet的方便性。所以<jsp:useBean>动作几乎是JSP最重要的用法。

其语法形式：

<jsp:usebean id="name" scope="page | request | session | application" typespec />

其中typespec有以下几种可能的情况：

class="classname" | class="classname" type="typename" | beanname="beanname" type="typename" | type="typename" |

＜jsp:useBean id="name" class="package.class" /＞

注意必须使用class或type，但不能同时使用class和beanname。beanname表示bean的名字，其形式为“a.b.c”。

只有当第一次实例化Bean时才执行Body部分，如果是利用已有的Bean实例则不执行Body部分，jsp:useBean并非总是意味着创建一个新的Bean实例。

获得Bean实例之后，要修改Bean的属性既可以通过jsp:setProperty动作进行，也可以在脚本小程序中利用id属性所命名的对象变量，通过调用该对象的方法显式地修改其属性。当说“某个Bean有一个类型为X的属性foo”时，就意味着“这个类有一个返回值类型为X的getfoo方法，还有一个setfoo方法以X类型的值为参数”。

通过jsp:setProperty和jsp:getProperty修改和提取Bean的属性。

useBean动作元素属性如下：

（1）id用来引用Bean实例的变量。如果能够找到id和scope相同的Bean实例，jsp:useBean动作将使用已有的Bean实例而不是创建新的实例。

（2）class指定Bean的完整包名，表明bean具体是对哪个类的实例化。

（3）scope指定Bean的有效范围，可取四个值分别为：page，request，session和application。默认值是page，表示该Bean只在当前页面内可用（保存在当前页面的PageContext内），有效范围是当前页面。request表示该Bean在当前的客户请求内有效（保存在ServletRequest对象内）。有效范围在一个单独客户请求的生命周期内。session表示该Bean对当前HttpSession内的所有页面都有效。有效范围是整个用户会话的生命周期内。最后，如果取值application，则表示该Bean对所有具有相同ServletContext的页面都有效。有效范围是应用的生命周期内。

scope之所以很重要，是因为jsp:useBean只有在不存在具有相同id和scope的对象时才会实例化新的对象；如果已有id和scope都相同的对象则直接使用已有的对象，此时jsp:useBean开始标记和结束标记之间的任何内容都将被忽略。

（4）type指定引用该对象的变量的类型，它必须是Bean类的名字、超类名字、该类所实现的接口名字之一。请记住变量的名字是由id属性指定的。

（5）beanName指定Bean的名字。如果提供了type属性和beanName属性，允许省略class属性。

2．setProperty动作元素

<jsp:setproperty>标签表示用来设置bean中的属性值。在JSP表达式或Scriptlet中读取Bean属性通过调用相应的getXXX方法实现，或者更一般地，使用jsp:getProperty动作。

可以使用两种语法实现方式：

（1）在jsp:usebean后使用jsp:setproperty：

<jsp:usebean id="myuser"/>

<jsp:setproperty name="user" property="user"/>

在这种方式中，jsp:setproperty将被执行。

（2）jsp:setproperty出现在jsp:usebean标签内：

<jsp:usebean id="myuser">

<jsp:setproperty name="user" property="user"/>

</jsp:usebean>

在这种方式中，jsp:setproperty只会在新的对象被实例化时才将被执行。

在<jsp:setproperty>中的name值应和<jsp:usebean>中的id值相同。我们既可以通过jsp:setProperty动作的value属性直接提供一个值，也可以通过param属性声明Bean的属性值来指定请求参数，还可以列出Bean属性表明它的值应该来自请求参数中的同名变量。该动作的含义是使用bean中相应的set()方法设置一个或多个属性的值，值的来源是通过value属性明确给出，或者利用request对象中相应的参数。

<jsp:setproperty>动作有下面四个属性：

（1）name用来表明对哪个bean实例执行下面的动作，这个值和动作<jsp:useBean>中定义的id必须对应起来，包括大小写都必须一致。这个属性是必须的。

（2）property用来表示要设置哪个属性。如果property的值是"*"，表示用户在可见的JSP页面中输入的全部值，存储在匹配的bean属性中。匹配的方法是：bean的属性名称必须与输入框的名字相同。property property属性是必需的。它表示要设置哪个属性。有一个特殊用法：如果property的值是“*”，表示所有名字和Bean属性名字匹配的请求参数都将被传递给相应的属性set方法。这个属性也是必须的。

（3）value属性是可选的。该属性用来指定Bean属性的值。字符串数据会在目标类中通过标准的valueOf方法自动转换成数字、boolean、Boolean、byte、Byte、char、Character。例如，boolean和Boolean类型的属性值（比如“true”）通过Boolean.valueOf转换，int和Integer类型的属性值（比如“42”）通过Integer.valueOf转换。

value和param不能同时使用，但可以使用其中任意一个。

（4）param属性是可选的。它指定用哪个请求参数作为Bean属性的值。如果当前请求没有参数，则什么事情也不做，系统不会把null传递给Bean属性的set方法。因此，你可以让Bean自己提供默认属性值，只有当请求参数明确指定了新值时才修改默认属性值。

例如，下面的代码片断表示：如果存在numItems请求参数的话，把numberOfItems属性的值设置为请求参数numItems的值；否则什么也不做。

<jsp:setProperty name="orderBean"

property="numberOfItems"

param="numItems" />

如果同时省略value和param，其效果相当于提供一个param且其值等于property的值。进一步利用这种借助请求参数和属性名字相同进行自动赋值的思想，你还可以在property（Bean属性的名字）中指定“*”，然后省略value和param。此时，服务器会查看所有的Bean属性和请求参数，如果两者名字相同则自动赋值。

3．getProperty元素

<jsp:getproperty>标签表示获取bean的属性的值并将之转化为一个字符串，然后将其插入到输出的页面中。该动作实际是调用了bean的get()方法。

在使用<jsp:getproperty>之前，必须用<jsp:usebean>来创建它。不能使用<jsp:getproperty>来检索一个已经被索引了的属性。

语法如下：

<jsp:getProperty name="beanInstanceName" property="propertyName"/>

jsp:getProperty有两个必需的属性，即：name，表示Bean的名字；property，表示要提取哪个属性的值。

例如

<jsp:useBean id="itemBean" ... />

<UL>

<LI>Number of items:

<jsp:getProperty name="itemBean" property="numItems" />

<LI>Cost of each:

<jsp:getProperty name="itemBean" property="unitCost" />

</UL>

本章小结

一个JSP页面主要由注释、指令、脚本元素、动作元素的内容组成。

1．注释包括HTML注释和JSP隐藏注释。

2．指令包括：

（1）page：用来定义整个JSP页面的属性和相关功能。

（2）include：用来指定JSP文件被编译时需要插入的资源,可以是文本、代码、HTML文件或JSP文件。

（3）taglib：页面使用者用来自定义标签。

3．脚本元素

（1）声明：用来定义在程序中使用的实体,它是一段Java代码，可以声明变量，也可以声明方法。格式：<%! 开始声明 %> 例如:<%! int i;%>。

（2）表达式：格式:<%=表达式%> 最后是没有分号的.例如:<%=1+2+3%>。

（3）Scriptlet：格式:<%java代码%>。

4．在JSP中的动作指令包括：Include、 Forward、 UseBean、 GetProperty、 SetProperty、 Plugin。

（1）include指令：表示包含一个静态的或者动态的文件。子句能让你传递一个或多个参数给动态文件，也可在一个页面中使用多个指令来传递多个参数给动态文件。

（2）forward指令：表示重定向一个静态html/jsp的文件，或者是一个程序段。

（3）Plugin指令：用于在浏览器中播放或显示一个对象（典型的就是Applet和Bean），而这种显示需要浏览器的Java插件。一般来说，元素会指定对象是Applet还是Bean,同样也会指定class的名字和位置，另外还会指定将从哪里下载这个Java插件。

（4）useBean指令：表示用来在JSP页面中创建一个Bean实例并指定它的名字以及作用范围。

（5）setProperty指令：用来为一个Bean的属性赋值。若在jsp:useBean后使用，jsp:setProperty将被执行。若jsp:setProperty出现在jsp:useBean标签内，jsp:setProperty只会在新的对象被实例化时才将被执行。注意name值应当和useBean中的id值相同。

（6）getProperty指令：表示获取Bean的属性的值并将之转化为一个字符串，然后将其插入到输出的页面中。

posted @ 2014-03-08 20:05 子木聊出海阅读(533) 评论(0) 编辑收藏举报

刷新页面返回顶部

子木聊出海

公号：子木聊出海博客：bysocket.com 我是子木，爱分享 Learning by Writing. 专注于出海 SaaS，探索 SEO、红人营销、Ads、EDM 等增长策略

③JSP经典回顾

jsp概述

隐式对象

JSP页面结构

注释

JSP隐藏注释

HTML注释

JSP指令

page指令

1．language属性

2．contentType属性

3．import属性

4．extends属性

5．isErrorPage属性

6．errorPage属性

7．session属性

8．Buffer属性

9．autoFlush属性

10．isThreadSafe属性

11．info属性

4.3.2 include指令

taglib指令

JSP脚本元素

4.4.1 JSP声明

4.4.2 JSP表达式

4.4.3脚本小程序

4.5 JSP动作

4.5.1 include动作元素

4.5.2 forword动作元素

4.5.3 plugin动作元素

4.5.4. param动作元素

4.5.5 useBean及setProperty和getProperty动作元素

1．useBean动作元素

2．setProperty动作元素

3．getProperty元素

本章小结

公告

子木聊出海

公号：子木聊出海 博客：bysocket.com 我是子木，爱分享 Learning by Writing. 专注于出海 SaaS，探索 SEO、红人营销、Ads、EDM 等增长策略

③JSP经典回顾

jsp概述

隐式对象

JSP页面结构

注释

JSP隐藏注释

HTML注释

JSP指令

page指令

1．language属性

2．contentType属性

3．import属性

4．extends属性

5．isErrorPage属性

6．errorPage属性

7．session属性

8．Buffer属性

9．autoFlush属性

10．isThreadSafe属性

11．info属性

4.3.2 include指令

taglib指令

JSP脚本元素

4.4.1 JSP声明

4.4.2 JSP表达式

4.4.3脚本小程序

4.5 JSP动作

4.5.1 include动作元素

4.5.2 forword动作元素

4.5.3 plugin动作元素

4.5.4. param动作元素

4.5.5 useBean及setProperty和getProperty动作元素

1．useBean动作元素

2．setProperty动作元素

3．getProperty元素

本章小结

公告

公号：子木聊出海博客：bysocket.com 我是子木，爱分享 Learning by Writing. 专注于出海 SaaS，探索 SEO、红人营销、Ads、EDM 等增长策略