JSP和Servlet

1.       描述JSP和Servlet的区别、共同点、各自应用的范围
Jsp是带有java代码的html，而servlet是html编译成的java代码。
上述就是两者的区别。而共同点是jsp是servlet的另一种书写方式，最红jsp都要编译成servlet并装载到内存中进行执行。
一般jsp用于动态页面的表现，所以多用于视图层，而servlet擅长业务逻辑的处理，多用于控制层。
2.在Web开发中需要处理HTML标记时，应做什么样的处理，要筛选那些字符（< > & “”）
要筛选：<  > & “”。>用& lt代替，<用& gt代替，“和”用& quot代替，&用& amp代替。
3.在JSP中如何读取客户端的请求，如何访问CGI变量，如何确定某个Jsp文件的真实路径。
都是使用jsp的内置对象request来进行。
访问cgi变量时可以获取http请求的头信息。Socket套接字的信息。
获取jsp文件的真实路径可以通过servletContext.getRealPath() + jsp的相对路径
4.描述Cookie和Session的作用，区别和各自的应用范围，Session工作原理。
Cookie是客户端存放信息的地方，session是在Web  Server上为了保持一个用户的状态而创建的对象。Session工作原理请参见session工作原理。
5.列出Jsp中包含外部文件的方式，两者有何区别。
<%@include file=””%>这是指令，是静态包含即在第一次编译时会把被包含的页面的响应加到主页面的响应中， 而以后被包含页面如果代码改变了主页面不会重新编译被包含页面
<jsp:include page=””/>这是动作，随时检查包含页面的改变，会随时根据页面的变化而变化。
6.说明Jsp中errorPage的作用，应用范围。
如果设置了errorpage（一般是在jsp第一行<%@page isErrorPage=”true”%>来设定）那么如果JSP页面出现异常则会跳转到错误页面，然后即可在错误页面中通过exception取得异常进行处理。一般用于扑获不可预见的异常  
7.介绍在Jsp中如何使用JavaBeans。
jsp:useBean 创建javabean
jsp:setProperty  和javabean的set方法相对应
jsp:getProperty  和javabean的get方法相对应
8.简单介绍JSP的标记库
以jsp:开头的标记库
包含了页面跳转的控制，业务数据的使用，以及页面的包含等
大概有jsp：useBean,jsp:setProperty，jsp：getProperty，jsp：include，jsp：forword等
9.Jsp和Servlet中的请求转发分别如何实现。
Jsp：一般使用标签动作<jsp:forword >来实现。
Servlet中使用RequestDispatcher对象的forword方法
10.jsp的九个内置对象分别是什么，只要有什么作用
 request      客户端端请求，此请求会包含来自GET/POST请求的参数
       response      网页传回客户端的回应
       pageContext     网页的属性是在这里管理
       session      与请求有关的会话期
       application        servlet 正在执行的内容
       out        用来传送回应的输出
       config        servlet的构架部件
       page        JSP网页本身
       exception      针对错误网页，未捕捉的例外
 
11. jsp有哪些动作作用分别是什么
       jsp:include：在页面被请求的时候引入一个文件。
       jsp:useBean：寻找或者实例化一个JavaBean。
       jsp:setProperty：设置JavaBean的属性。
       jsp:getProperty：输出某个JavaBean的属性。
       jsp:forward：把请求转到一个新的页面。
       jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记
12.jsp两种跳转方式是什么，有什么区别
   <jsp:include page="included.jsp" flush="true">
<jsp:forward page= "nextpage.jsp"/>
前者页面不会转向include所指的页面，只是显示该页的结果，主页面还是原来的页面。执行完后还会回来，相当于函数调用。并且可以带参数.后者完全转向新页面，不会再回来。相当于go to 语句。
 
13. servlet的生命周期
web容器加载servlet，生命周期开始。通过调用servlet的init()方法进行servlet的初始化。通过调用service()方法实现，根据请求的不同调用不同的doGet()或者doPost（）方法。结束服务，web容器调用servlet的destroy()方法。此时servlet生命周期结束。
Servlet运行在Web容器中，其生命周期由容器来管理。Servlet的生命周期通过javax.servlet.Servlet接口中的init,service和destroy方法来表示。Servlet的生命周期包含以下四个阶段：加载和实例化、初始化、处理请求以及服务结束。
 
14. 种会话跟踪技术
会话作用域ServletsJSP 页面描述
page是代表与一个页面相关的对象和属性。一个页面由一个编译好的 Java servlet 类（可以带有任何的 include 指令，但是没有 include 动作）表示。这既包括 servlet 又包括被编译成 servlet 的JSP 页面
request是是代表与 Web 客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个 Web 组件（由于 forward 指令和 include 动作的关系）
session是是代表与用于某个 Web 客户机的一个用户体验相关的对象和属性。一个 Web 会话可以也经常会跨越多个客户机请求
application是是代表与整个 Web 应用程序相关的对象和属性。这实质上是跨越整个 Web 应用程序，包括多个页面、请求和会话的一个全局作用域
15. Servlet执行时一般实现哪几个方法？
public void init(ServletConfig config)
public ServletConfig getServletConfig()
public String getServletInfo()
public void service(ServletRequest request,ServletResponse response)
public void destroy()JSP


Servlet：
Servlet 没有 main 方法，不能够独立的运行，它的运行需要容器的支持，Tomcat 是最常用的 JSP/Servlet 容器。

Servlet 运行在 Servlet 容器中，并由容器管理从创建到销毁的整个过程。

Servlet 的生命周期：

(1) 加载和实例化
Servlet 容器装载和实例化一个 Servlet。创建出该 Servlet 类的一个实例。
(2) 初始化
在 Servlet 实例化完成之后，容器负责调用该 Servlet 实例的 init() 方法，在处理用户请求之前，来做一些额外的初始化工作。
(3) 处理请求
当 Servlet 容器接收到一个 Servlet 请求时，便运行与之对应的 Servlet 实例的 service() 方法，service() 方法再派遣运行与请求相对应的 
doXX(doGet，doPost) 方法来处理用户请求。
(4) 销毁
当 Servlet 容器决定将一个 Servlet 从服务器中移除时 ( 如 Servlet 文件被更新 )，便调用该 Servlet 实例的 destroy() 方法，在销毁该 Servlet 实例之前，
来做一些其他的工作。
其中，(1)(2)(4) 在 Servlet 的整个生命周期中只会被执行一次。

Servlet 的工作原理：

结合右边给出的流程图：
当客户端浏览器向服务器请求一个 Servlet 时，服务器收到该请求后，首先到容器中检索与请求
匹配的 Servlet 实例是否已经存在。若不存在，则 Servlet 容器负责加载并实例化出该类 Servlet
的一个实例对象，接着容器框架负责调用该实例的 init() 方法来对实例做一些初始化工作，然后
Servlet 容器运行该实例的 service() 方法。
若 Servlet 实例已经存在，则容器框架直接调用该实例的 service() 方法。
service() 方法在运行时，自动派遣运行与用户请求相对应的 doXX() 方法来响应用户发起的请求。
通常，每个 Servlet 类在容器中只存在一个实例，每当请求到来时，则分配一条线程来处理该请求。

JSP 工作原理：

结合右边给出的流程图：
当客户端浏览器向服务器请求一个 JSP 页面时，服务器收到该请求后，首先检查所请求的这个
JSP 文件内容 ( 代码 ) 是否已经被更新，或者是否是 JSP 文件创建后的第一次被访问，如果是，
那么，这个 JSP 文件就会在服务器端的 JSP 引擎作用下转化为一个 Servlet 类的 Java 源代码
文件。紧接着，这个 Servlet 类会在 Java 编译器的作用下被编译成一个字节码文件，并装载
到 jvm 解释执行。剩下的就等同于 Servlet 的处理过程了。
如果被请求的 JSP 文件内容 ( 代码 ) 没有被修改，那么它的处理过程也等同于一个 Servlet 的
处理过程。即直接由服务器检索出与之对应的 Servlet 实例来处理。

需要注意的是，JSP 文件不是在服务器启动的时候转换成 Servlet 类的。而是在被客户端访问
的时候才可能发生转换的 ( 如 JSP 文件内容没有被更新等，就不再发生 Servlet 转换 )。
就 Tomcat 而言，打开目录 %Tomcat%/work/%您的工程文件目录%，然后会看到里面有 3
个子目录：org/apache/jsp，若没有这 3 个目录，说明项目的 JSP 文件还没有被访问过，
打开进到 jsp 目录下，会看到一些 *_jsp.java 和 *_jsp.class 文件，这就是 JSP 文件被转换成
Servlet 类的源文件和字节码文件了。
有兴趣的话，可以使用浏览器访问服务器中的 JSP，然后观察 JSP 转换 Servlet 以及编译的时机。

Servlet 与 JSP：

JSP 本质是一个 Servlet，它的运行也需要容器的支持。
在 JSP 和 Servlet 文件中都可以编写 Java 和 HTML 代码，不同的是，
Servlet 虽然也可以动态的生成页面内容，但更加偏向于逻辑的控制。
JSP 最终被转换成 Servlet 在 jvm 中解释执行，在 JSP 中虽然也可以编写 Java 代码，但它更加偏向于页面视图的展现。
在 MVC 架构模式中，就 JSP 和 Servlet 而言，C 通常由 Servlet 充当，V 通常由 JSP 来充当。

servlet框架搭建：

servlet框架由两个JAVA包组成：javax.servlet和javax.servlet.http。在我们的编程中，需要在开头import进去，

javax.servlet.*;

servlet框架核心：javax.servlet.Servlet接口，所有的Servlet都必须实现它。

javax.servlet类包含了所有要实现的接口和类；javax.servlet.http包含了所有采用HTTP通信协议的类。

 

注：具体的类的介绍和使用方法，http://wenku.baidu.com/view/e54426c52cc58bd63186bd28.html这个连接里讲的比较详细。

开发工具

JDK：jdk1.6.0_10

服 务 器：C:/Tomcat 5.0(严格讲应该是WEB容器)

编译工具：JCreator Pro 3.50.013 汉化版（我用的这个，支持中文显示，CSDN下载里有下载。）

注： 1，JDK：版本为jdk-7-windows-i586.exe
  下载地址http://www.oracle.com/technetwork/java/javase/downloads/index.html
2，tomcat：版本为apache-tomcat-7.0.33-windows-x86.zip
  下载地址http://tomcat.apache.org/
3，windows2003,32bit

一、安装JDK和Tomcat

1. 1，安装JDK：直接运行jdk-7-windows-i586.exe可执行程序，默认安装即可。

   备注：路径可以其他盘符，不建议路径包含中文名及特殊符号。

   2、安装Tomcat：直接解压缩下载文件“apache-tomcat-7.0.33-windows-x86.zip”到C盘下。安装路径建议修改为：c:\tomcat。

   备注：如下载的是可执行文件，双击运行，默认安装即可。

2. 二、配置JDK环境变量（在步骤查看如何配置环境变量）

   1，新建变量名：JAVA_HOME，变量值：C:\Program Files\Java\jdk1.7.0

   2，打开PATH，添加变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin

   3，新建变量名：CLASSPATH，变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar

   备注：

   1，.表示当前路径，%JAVA_HOME%就是引用前面指定的JAVA_HOME；

   2，JAVA_HOME指明JDK安装路径，此路径下包括lib，bin，jre等文件夹，tomcat，eclipse等的运行都需要依靠此变量。

   3，PATH使得系统可以在任何路径下识别java命令。

   4，CLASSPATH为java加载类(class or lib)路径，只有类在classpath中，java命令才能识别。

3. 三、测试JDK

   在CMD命令下输入javac，java，javadoc命令：出现图示界面，表示安装成功。

   

4. 
   四、配置Tomcat环境变量

   1，新建变量名：CATALINA_BASE，变量值：C:\tomcat

   2，新建变量名：CATALINA_HOME，变量值：C:\tomcat

   3，打开PATH，添加变量值：%CATALINA_HOME%\lib;%CATALINA_HOME%\bin

5. 
   

6. 五、启动Tomcat服务

   方法两种：

   1，方法一：在CMD命令下输入命令：startup，出现如下对话框，表明服务启动成功。

   2，方法二：右键点击桌面上的“我的电脑”->“管理”->“服务和应用程序”->“服务”，找到“Apache     Tomcat”服务，右键点击该服务，选择“属性”，将“启动类型”由“手动”改成“自动”。

   

7. 
   六、测试Tomcat

   打开浏览器，在地址栏中输入http://localhost:8080回车，如果看到Tomcat自带的一个JSP页面，说明你的JDK和Tomcat已搭建成功。

   
   
   

注意事项

• 1，JAVA_HOME中的路径不能用分号结尾，如C:\Program     Files\Java\jdk1.7.0。
  

  2，CATALINA_BASE，CATALINA_HOME，TOMCAT_HOME中的路径不能以“\”结尾。

  3，JAVA_HOME的路径一定不要写成了JRE的路径。

  4，在环境变量中修改添加变量时，一定要注意分号、空格，是否有多余的字母。作者就是因为path路径中多了一个字母，怎么都配置不成功。如果配置不成功，一定要反复检查。

     以上错误，非常容易出现错误：CATALINA_HOME或是JAVA_HOME没有配置好。如错误提示“The CATALINA_HOME environment variable is not defined correctly”

tomcat配置文件解析：

配置文件一般都在conf文件夹里，主要有server.xml，context.xml，tomcat_user.xml，web.xml四个常用配置文件，server主要是服务器设置的，例如端口设置，路径设置。context里设置tomcat数据源，用来连接数据库。tomcat_user主要是用户名和密码的设置。web是默认首页等等之类的设置。

元素名	属性	解释
server	port	指定一个端口，这个端口负责监听关闭tomcat 的请求
	shutdown	指定向端口发送的命令字符串
service	name	指定service 的名字
Connector ( 表示客户端和service之间的连接)	port	指定服务器端要创建的端口号，并在这个断口监听来自客户端的请求
	minProcessors	服务器启动时创建的处理请求的线程数
	maxProcessors	最大可以创建的处理请求的线程数
	enableLookups	如果为true ，则可以通过调用request.getRemoteHost() 进行DNS 查询来得到远程客户端的实际主机名，若为false 则不进行DNS 查询，而是返回其ip 地址
	redirectPort	指定服务器正在处理http 请求时收到了一个SSL 传输请求后重定向的端口号
	acceptCount	指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理
	connectionTimeout	指定超时的时间数( 以毫秒为单位)
Engine ( 表示指定service 中的请求处理机，接收和处理来自Connector的请求)	defaultHost	指定缺省的处理请求的主机名，它至少与其中的一个host 元素的name 属性值是一样的
Context ( 表示一个web 应用程序，通常为WAR 文件，关于WAR 的具体信息见servlet 规范)	docBase	应用程序的路径或者是WAR 文件存放的路径
	path	表示此web 应用程序的url 的前缀，这样请求的url为http://localhost:8080/path/ ****
	reloadable	这个属性非常重要，如果为true ，则tomcat 会自动检测应用程序的/WEB-INF/lib 和/WEB-INF/classes 目录的变化，自动装载新的应用程序，我们可以在不重起tomcat 的情况下改变应用程序
host ( 表示一个虚拟主机 )	name	指定主机名
	appBase	应用程序基本目录，即存放应用程序的目录
	unpackWARs	如果为true ，则tomcat 会自动将WAR 文件解压，否则不解压，直接从WAR 文件中运行应用程序
Logger ( 表示日志，调试和错误信息)	className	指定logger 使用的类名，此类必须实现org.apache.catalina.Logger 接口
	prefix	指定log 文件的前缀
	suffix	指定log 文件的后缀
	timestamp	如果为true ，则log 文件名中要加入时间，如下例:localhost_log.2001-10-04.txt
Realm ( 表示存放用户名，密码及role 的数据库)	className	指定Realm 使用的类名，此类必须实现org.apache.catalina.Realm 接口
Valve ( 功能与Logger 差不多，其prefix 和suffix 属性解释和Logger 中的一样)	className	指定Valve 使用的类名，如用org.apache.catalina.valves.AccessLogValve 类可以记录应用程序的访问信息
	directory	指定log 文件存放的位置
	pattern	有两个值，common 方式记录远程主机名或ip 地址，用户名，日期，第一行请求的字符串，HTTP 响应代码，发送的字节数。combined 方式比common 方式记录的值更多

 

• $CATALINA_HOME/conf/web.xml配置简介
• • 默认Web应用的首页文件的设置
  • • <welcome-file-list>        <welcome-file>index.html</welcome-file>        <welcome-file>index.htm</welcome-file>        <welcome-file>index.jsp</welcome-file> </welcome-file-list>
  • 报错文件的设置
  • • a.如果某文件资源没有找到，服务器要报404错误，按下述配置则会调用\webapps\ROOT\notFileFound.jsp <error-page>        <error-code>404</error-code>        <location>/notFileFound.jsp</location> </error-page> b.如果执行的某个JSP文件产生NullPointException，则会调用\webapps\ROOT\null.jsp <error-page>         <exception-type>java.lang.NullPointerException</exception-type>         <location>/null.jsp</location> </error-page>
  • session 会话过期时间的设置,单位是分钟
  • • <session-config>               <session-timeout>30</session-timeout>  </session-config>
  • servlet的设置
  • • <servlet>      <servlet-name>default</servlet-name>      <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>      <init-param>             <param-name>debug</param-name>             <param-value>0</param-value>       </init-param>       <init-param>             <param-name>listings</param-name>             <param-value>true</param-value>       </init-param>       <load-on-startup>1</load-on-startup>   </servlet> 说明：<servlet-name>：定义Servlet的名字。<servlet-class>：指定实现这个Servlet的类。<init-param>：定义Servlet的初始化参数（包括参数名和参数值），一个 <servlet>元素中可以有多个<init-param>元素。<load-on-startup>：指定当Web应用启动时，装载Servlet的次序。当这个值为正数或零，Servlet容器先加载数值小的Servlet，再一次加载其他数值大的Servlet。如果这个值为负数或没有设定，Servlet将在Web客户首次访问这个Servlet时加载它。
  • filter过滤器的设置 <filter>        <filter-name>FilterSource</filter-name>        <filter-class>project4. FilterSource </filter-class> </filter> <filter-mapping>        <filter-name>FilterSource</filter-name>        <url-pattern>/WwwServlet</url-pattern>       (<url-pattern>/haha/*</url-pattern>) </filter-mapping> 过滤：1) 身份验证的过滤Authentication Filters2) 日志和审核的过滤Logging and Auditing Filters3) 图片转化的过滤Image conversion Filters4) 数据压缩的过滤Data compression Filters5) 加密过滤Encryption Filters6) Tokenizing Filters7) 资源访问事件触发的过滤Filters that trigger resource access events XSL/T 过滤XSL/T filters9) 内容类型的过滤Mime-type chain Filter注意监听器的顺序，如：先安全过滤，然后资源，然后内容类型等，顺序可以自己定。

• Tomcat管理
• • 管理员帐户配置（$CATALINA_HOME/conf/tomcat-users.xml）在tomcat-users.xml文件相应的位置添加一行：<user name="user" password="user" roles="standard,manager"/>用来添加一个管理员帐户。然后重起tomcat，在浏览器中输入地址http://localhost:8080/manager/，在弹出的对话框输入上面的用户名和密码即可
  • Web应用列表在浏览器中输入http://localhost:8080/manager/list，浏览器将会列出目前存在的所有Web应用的信息，分别为：Web应用程序的路径、当前状态、连接这个Web应用的Session数目
  • 重新装载Web应用程序在浏览器中输入 http://localhost:8080/manager/reload?path=/examples，浏览器显示如下：OK - Reloaded application at context path /examples，这表示example应用程序装载成功，如果我们将server.xml的Context元素的reloadable属性设为true，则没必要利用这种方式重新装载Web应用程序，因为tomcat会自动装载。
  • 显示Session信息在浏览器中输入http://localhost:8080/manager/sessions?path=/examples，浏览器显示如下：OK - Session information for application at context path /examples Default maximum session inactive interval 30 minutes
  • 启动和关闭应用程序在浏览器中输入http://localhost:8080/manager/start?path=/example和http://localhost:8080/manager/stop?path=/examples分别启动和关闭examples应用程序。
  • 部署及撤销部署WAR有两种组织方式，一种是按一定的目录结构组织文件，一种是一个后缀为WAR的压缩包，因此它的部署方式也有两种：a.在浏览器中输入：http://localhost:8080/manager/install?path=/examples&war=file:/c:\examples，就会将按目录结构组织的WAR部署b.在浏览器中输入：http://localhost:8080/manager/install?path=/examples&war=jar:file:/c:\examples.war!/，就会将按压缩包组织的WAR部署，注意此url后半部分一定要有!/号部署后就可以用：http://localhost:8080/examples访问了在浏览器中输入：http://localhost:8080/manager/remove?path=/examples，就会撤销刚才部署的应用程序

servlet与jsp传值：

Jsp与Servlet之间的传值有两种，一种是Jsp传值给Sevlet，另一种是Servlet传值给Jsp；使用request、response对象完成传值，具体实现如下：

1.JSP传值给Servlet

JSP传值给Servlet有几种形式：Form表单传值，url传值，其他方式传值

a、form表单传值：

JSP页面有：<input type="radio" name="staffdepartment" value="1" id="department1" />，将department的id传到Sevlet

中，在程序中如下：ServletRequest request；String staffdepartment=request.getParameter("staffdepartment");可获取jsp传的department，但要获取id还要进行转化：int int_staffdepartment=Integer.parseInt(staffdepartment);

b、url传值

比如这里的 <a>标签的 href属性与 <form>标签的 action属性的值 "JspServlet?action=toServlet"，在 servlet同样用 request.getParameter("action")获取；

c、java代码传值

java片段代码，servlet只能接到 session.setAttribute("testSession","Hello session")的内容，而接不到 request的内容。在 servlet里用 request.getSession().getAttribute("testSession")获取 session内容。

2.Servlet传值给Jsp

具体实现如下：

java代码：String   a= "abccdefg ";               request.setAttribute( "ValueA ",a);               request.getRequestDispatcher( "网址/jsp页面 ").forward(request,response); 

jsp页面：

<%

String   s   =(String)request.getAttribute( "ValueA ");

%>

jsp页面就可以取出Servlet的值。

jsp与servlet之间页面跳转及参数传递实例

1.从一个jsp页面跳转到另一个jsp页面时的参数传递

    (1)使用request对象获取客户端提交的信息

     login.jsp页面代码如下：

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         <form action="getinfo.jsp">  
7.             <input type="text" name="name">  
8.             <input type="submit" value="Enter" name="submit">  
9.         </form>  
10.     </body>  
11. </html>  

1. getinfo.jsp页面代码如下：

[java]  view plain copy

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         <p>获取文本框提交的信息：  
7.         <%  
8.             String textContent = request.getParameter("name");  
9.          %>  
10.          <br/>  
11.          <%=textContent%>  
12.            
13.         </p>获取按钮的名字：  
14.          <%  
15.             String buttonName = request.getParameter("submit");  
16.           %>  
17.          <br/>  
18.          <%=buttonName%>  
19.           
20.     </body>  
21. </html>  

 (2)使用session对象获取从客户端提交的信息

    session1.jsp页面代码如下：

1.   <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         <form action="session2.jsp" method="post">  
7.             请输入您的姓名：  
8.             <input type="text" name="thename">  
9.             <input type="submit" value="submit">  
10.         </form>  
11.     </body>  
12. </html>  

    session2.jsp通过request对象提取session1.jsp表单中的thename值,并将其保存到session对象中，session2.jsp代码如下：

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         <%  
7.             String name = request.getParameter("thename");  
8.             session.setAttribute("thename",name);  
9.          %>  
10.          您的姓名是：<%=name%>  
11.          <p>  
12.         <form action="session3.jsp?pwd=123456" method="post">  
13.             您喜欢吃什么？  
14.             <input type="text" name="food"/>  
15.             <p>  
16.             <input type="submit" value="submit">  
17.         </form>          
18.     </body>  
19. </html>  

[java]  view plain cop

     session3.jsp的主要任务是显示结果，它从session对象提取thename的值并显示它，以证明在多个页面中可以通过session对象存储和维持信息，session3.jsp代码如下：

1. <pre name="code" class="java"><%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         <%  
7.             String food = request.getParameter("food");  
8.             String name = (String)session.getAttribute("thename");  
9.             String pwd = request.getParameter("pwd");  
10.          %>  
11.          您的姓名是：<%=name%>  
12.          <p>  
13.          您喜欢吃：<%=food%>  
14.          <p>  
15.          您的密码是：<%=pwd%>  
16.     </body>  
17. </html></pre>  
18. <pre></pre>  
19. <pre></pre>  
20. <pre></pre>  
21. <pre></pre>  
22. <pre></pre>  
23. <pre></pre>  
24. <pre></pre>  

[java]  view plain cop 程序运行结果如图2所示：

    (3)利用隐藏域传递数据

    使用隐藏空间记录用户提交日期的hiddenindex.jsp代码如下：

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         <form action="hidden.jsp" method="post" name="form1">  
7.             <!-- 隐藏字段，系统时间，并转换为毫秒数 -->  
8.             <input type="hidden" name="time" value="<%=new java.util.Date()%>">  
9.             <p>  
10.                 请输入您的姓名：<input type="text" name="name">  
11.             </p>  
12.             <input type="submit" name="submit" value="submit">  
13.         </form>  
14.     </body>  
15. </html>  

     显示隐藏空间信息的hidden.jsp代码如下：

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         <%  
7.             String name = request.getParameter("name");  
8.             String date = request.getParameter("time");  
9.         %>  
10.         <p>您的姓名是：  
11.             <%=name %>  
12.         </p>  
13.         <p>提交时的系统时间为：  
14.             <%=date %>  
15.         </p>  
16.     </body>  
17. </html>  

    程序运行结果如下：

 

                                        

    使用隐藏域的一个缺点是用户可通过查看网页源程序读到隐藏域的值。

(4)通过超链接传递数据

    建立链接到其他分页的超级链接page.jsp代码如下：

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <%  
5.     int PageCount = 15;  
6. %>  
7. <html>  
8.     <body>  
9.         <table>  
10.             <tr>  
11.                 <td>  
12.                     <a href=showpage.jsp?ToPage=<%=1%>>到第1页</a>  
13.                 </td>  
14.                 <td>  
15.                     <a href=showpage.jsp?ToPage=<%=PageCount%>>到最后一页</a>  
16.                 </td>  
17.             </tr>  
18.         </table>        
19.     </body>  
20. </html>  

    接收显示分页showpage.jsp代码如下：

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         <%  
7.         String toPage = request.getParameter("ToPage");  
8.         out.println("第" + toPage + "页");  
9.         %>  
10.     </body>  
11. </html>  

     运行结果如下：

2.jsp页面传递参数给servlet

    (1)使用request对象接收参数

    新建名为ForwardServlet的Servlet类，代码如下：

1. package com.shi.servlet;  
2.   
3. import java.io.IOException;  
4.   
5. import javax.servlet.ServletException;  
6. import javax.servlet.http.HttpServlet;  
7. import javax.servlet.http.HttpServletRequest;  
8. import javax.servlet.http.HttpServletResponse;  
9.   
10. /** 
11.  * 本类用来获得表单请求信息，并根据请求信息转发页面 
12.  */  
13. public class ForwardServlet extends HttpServlet  
14. {  
15.     private static final long serialVersionUID = 1L;  
16.   
17.     /** 
18.      * 构造函数 
19.      */  
20.     public ForwardServlet()  
21.     {  
22.         super();  
23.     }  
24.       
25.     /** 
26.      * 初始化 
27.      */  
28.     public void init() throws ServletException  
29.     {}  
30.       
31.     /** 
32.      * doGet()方法 
33.      */  
34.     public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  
35.     {  
36.         doPost(request, response);  
37.     }  
38.       
39.     /** 
40.      * doPost()方法 
41.      */  
42.     public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  
43.     {  
44.         String name = request.getParameter("name");  
45.         String pwd = request.getParameter("pwd");  
46.         if((name!=null && !name.equals("")) && (pwd!=null && !pwd.equals("")))  
47.         {  
48.             if(name.equals("mr")&&pwd.equals("123"))  
49.             {  
50.                 request.getRequestDispatcher("success.jsp").forward(request, response);  
51.             }  
52.             else  
53.             {  
54.                 request.getRequestDispatcher("error.jsp").forward(request, response);  
55.             }  
56.         }  
57.     }  
58.       
59.     /** 
60.      * 销毁 
61.      */  
62.     public void destroy()  
63.     {  
64.         super.destroy();  
65.     }  
66. }  

在web.xml中配置ForwardServlet类，代码如下：

[java]  view plain copy

1. <?xml version="1.0" encoding="GB2312"?>  
2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   
5.     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
6.       
7.     <!-- 配置servlet -->  
8.     <servlet>  
9.         <servlet-name>ForwardServlet</servlet-name>  
10.         <servlet-class>com.shi.servlet.ForwardServlet</servlet-class>  
11.     </servlet>  
12.     <servlet-mapping>  
13.         <servlet-name>ForwardServlet</servlet-name>  
14.         <url-pattern>/forward</url-pattern>  
15.     </servlet-mapping>  
16.       
17.     <welcome-file-list>  
18.         <welcome-file>index.jsp</welcome-file>  
19.     </welcome-file-list>  
20. </web-app>  

    新建index.jsp，其中<form>中的action属性值为Servlet类在web.xml中配置的url，提交方式为post，代码如下：

[java]  view plain copy

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         <form action="forward" method="post">  
7.             <table align="center">  
8.                 <tr>  
9.                     <td>用户名：</td>  
10.                     <td>  
11.                         <input type="text" name="name"/>  
12.                     </td>  
13.                 </tr>  
14.                 <tr>  
15.                     <td>密码：</td>  
16.                     <td>  
17.                         <input type="password" name="pwd"/>  
18.                     </td>  
19.                 </tr>  
20.                 <tr>  
21.                     <td colspan="2">  
22.                         <input type="submit" value="登录"/>  
23.                     </td>  
24.                 </tr>  
25.             </table>  
26.         </form>  
27.     </body>  
28. </html>  

    登录成功页面success.jsp，代码如下：

[java]  view plain copy

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         欢迎<%=request.getParameter("name") %>，登录成功！  
7.     </body>  
8. </html>  

    程序的运行结果图5所示：

(2)使用session对象，url，form表单传递参数

    在jsp2servlet.jsp中，分别使用request对象，session对象，url，form表单设置需要传递的参数，代码如下：

[java]  view plain copy

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         <%  
7.         session.setAttribute("testSession","Hello session");  
8.         request.setAttribute("testRequest","Hello request");  
9.         %>  
10.         <a href="http://localhost:8080/086/jsp2servlet?hrefAction=toServlet">单击此处</a>  
11.         <form action="jsp2servlet?action=toServlet" method="post" name="form1">  
12.             <input type="text" name="username"/>  
13.             <input type="submit" value="submit"/>  
14.         </form>  
15.     </body>  
16. </html>  

    在Jsp2Servlet中接收jsp页面中传递的参数并将其显示，代码如下：

[java]  view plain copy

1. package com.shi.servlet;  
2.   
3. import java.io.IOException;  
4. import java.io.PrintWriter;  
5.   
6. import javax.servlet.ServletException;  
7. import javax.servlet.http.HttpServlet;  
8. import javax.servlet.http.HttpServletRequest;  
9. import javax.servlet.http.HttpServletResponse;  
10.   
11. public class Jsp2Servlet extends HttpServlet  
12. {  
13.     /** 
14.      * 自动生成 
15.      */  
16.     private static final long serialVersionUID = 1L;  
17.   
18.     /** 
19.      * 构造函数 
20.      */  
21.     public Jsp2Servlet()  
22.     {  
23.         super();  
24.     }  
25.       
26.     /** 
27.      * 初始化 
28.      */  
29.     public void init()  
30.     {}  
31.       
32.     /** 
33.      * doGet() 
34.      */  
35.     public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  
36.     {  
37.         doPost(request, response);  
38.     }  
39.       
40.     /** 
41.      * doPost() 
42.      */  
43.     public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  
44.     {  
45.         String strSession = (String)request.getSession().getAttribute("testSession");         
46.         String strRequest = (String)request.getAttribute("testRequest");          
47.         String strHref = request.getParameter("hrefAction");          
48.         String strForm = request.getParameter("action");          
49.         String username = request.getParameter("username");  
50.           
51.         PrintWriter out = response.getWriter();  
52.         out.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">");  
53.         out.println("<html>");  
54.         out.println("<body>");  
55.         out.println("保存到session中的内容： " + strSession + "<br>");  
56.         out.println("保存到request中的内容：" + strRequest + "<br>");  
57.         out.println("超链接中传递的参数值为：" + strHref + "<br>");  
58.         out.println("form表单中传递的action值为：" + strForm + "<br>");  
59.         out.println("form表单内input标签中username的值： " + username + "<br>");  
60.         out.println("</body>");  
61.         out.println("</html>");         
62.     }  
63.       
64.     /** 
65.      * 销毁 
66.      */  
67.     public void destroy()  
68.     {  
69.         super.destroy();  
70.     }  
71. }  

 程序运行结果如图6所示：

    servlet无法获取request.setAttribute()中的内容，因为在jsp2servlet.jsp中提交时，生成的一个新的request，因此无法取到jsp页面中request.setAttribute()中设置的值。

 3.从servlet到jsp页面中传递参数

    从servlet到jsp页面传递参数，可以使用URL，request对象，session对象，新建Servlet2Jsp.java，代码如下：

[java]  view plain copy

1. package com.shi.servlet;  
2.   
3. import java.io.IOException;  
4.   
5. import javax.servlet.ServletException;  
6. import javax.servlet.http.HttpServlet;  
7. import javax.servlet.http.HttpServletRequest;  
8. import javax.servlet.http.HttpServletResponse;  
9.   
10. public class Servlet2Jsp extends HttpServlet  
11. {  
12.     /** 
13.      * 自动生成 
14.      */  
15.     private static final long serialVersionUID = 1L;  
16.   
17.     /** 
18.      * 构造函数 
19.      */  
20.     public Servlet2Jsp()  
21.     {  
22.         super();  
23.     }  
24.       
25.     /** 
26.      * 初始化 
27.      */  
28.     public void init()  
29.     {}  
30.       
31.     /** 
32.      * doGet() 
33.      */  
34.     public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  
35.     {  
36.         doPost(request, response);  
37.     }  
38.       
39.     /** 
40.      * doPost() 
41.      */  
42.     public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  
43.     {  
44.         String url = "result.jsp?first=传递第一个参数&second=传递第二个参数";  
45.         String strRequest = "request传值";  
46.         String strSession = "session传值";  
47.         request.setAttribute("strRequest", strRequest);  
48.         request.getSession().setAttribute("strSession", strSession);  
49.           
50.         /** 
51.          * 客户端跳转：效率低 
52.          * session范围属性，url中的参数会传递下去，request范围属性不传递 
53.          */  
54.         //response.sendRedirect(url);  
55.           
56.         /** 
57.          * 服务器端跳转：常用，效率高 
58.          * request范围属性，session范围属性，url中的参数会传递 
59.          */  
60.         request.getRequestDispatcher(url).forward(request, response);  
61.     }  
62.       
63.     /** 
64.      * 销毁 
65.      */  
66.     public void destroy()  
67.     {  
68.         super.destroy();  
69.     }  
70. }  

在web.xml中配置该servlet后，新建参数接收页result.jsp，代码如下：

[java]  view plain copy

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         <%  
7.         String strURL = request.getParameter("first");  
8.         String strRequest = (String)request.getAttribute("strRequest");  
9.         String strSession = (String)request.getSession().getAttribute("strSession");  
10.           
11.         %>  
12.         <p>  
13.             URL中取得的属性值为：<%=strURL%>  
14.         </p>        
15.         <p>  
16.             request中取得的属性值为：<%=strRequest%>  
17.         </p>  
18.         <p>  
19.             session中取得的属性值为：<%=strSession%>  
20.         </p>  
21.     </body>  
22. </html>  

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

  4.从一个servlet到另一个servlet时的参数传递

    (1)通过超链接和表单传递数据

    通过超链接后面给定要传递参数的值，但长度有限制，通过超链接和表单传递数据，使用request.getParamter()方法，代码如下：

[java]  view plain copy

1. package com.shi.servlet;  
2.   
3. import java.io.IOException;  
4. import java.io.PrintWriter;  
5.   
6. import javax.servlet.ServletException;  
7. import javax.servlet.http.HttpServlet;  
8. import javax.servlet.http.HttpServletRequest;  
9. import javax.servlet.http.HttpServletResponse;  
10.   
11. public class ServletA extends HttpServlet  
12. {  
13.     /** 
14.      * 自动生成 
15.      */  
16.     private static final long serialVersionUID = 1L;  
17.   
18.     /** 
19.      * 构造函数 
20.      */  
21.     public ServletA()  
22.     {  
23.         super();  
24.     }  
25.       
26.     /** 
27.      * 初始化 
28.      */  
29.     public void init()  
30.     {}  
31.       
32.     /** 
33.      * doGet() 
34.      */  
35.     public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  
36.     {  
37.         doPost(request, response);  
38.     }  
39.       
40.     /** 
41.      * doPost() 
42.      */  
43.     public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  
44.     {  
45.         response.setContentType("text/html");  
46.         PrintWriter out = response.getWriter();  
47.         String name = "hello, servlet";  
48.         out.println("<html>");  
49.         out.println("<body>");  
50.         /** 
51.          * 超链接 
52.          */  
53.         out.println("<a href='ServletB?name="+name+"'>this is a test</a>");  
54.         /** 
55.          * 表单 
56.          */  
57.         out.println("<form action='ServletB' method='post'>");          
58.         out.println("用户名：");  
59.         out.println("<input type='text' name='username'>");  
60.         out.println("<input type='submit' vlue='提交'>");  
61.         out.println("</form>");  
62.         out.println("</body>");  
63.         out.println("</html>");  
64.         out.flush();  
65.   
66.     }  
67.       
68.     /** 
69.      * 销毁 
70.      */  
71.     public void destroy()  
72.     {  
73.         super.destroy();  
74.     }  
75. }  

接收servlet中传递参数的代码如下：

[java]  view plain copy

1. package com.shi.servlet;  
2.   
3. import java.io.IOException;  
4. import java.io.PrintWriter;  
5.   
6. import javax.servlet.ServletException;  
7. import javax.servlet.http.HttpServlet;  
8. import javax.servlet.http.HttpServletRequest;  
9. import javax.servlet.http.HttpServletResponse;  
10.   
11. public class ServletB extends HttpServlet  
12. {  
13.     /** 
14.      * 自动生成 
15.      */  
16.     private static final long serialVersionUID = 1L;  
17.   
18.     /** 
19.      * 构造函数 
20.      */  
21.     public ServletB()  
22.     {  
23.         super();  
24.     }  
25.       
26.     /** 
27.      * 初始化 
28.      */  
29.     public void init()  
30.     {}  
31.       
32.     /** 
33.      * doGet() 
34.      */  
35.     public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  
36.     {  
37.         doPost(request, response);  
38.     }  
39.       
40.     /** 
41.      * doPost() 
42.      */  
43.     public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  
44.     {  
45.         String name = request.getParameter("name");  
46.         String username = request.getParameter("username");  
47.   
48.           
49.         response.setContentType("text/html;charset=gb2312");  
50.         PrintWriter out = response.getWriter();  
51.         out.println("<html>");  
52.         out.println("<body>");  
53.         out.println("超链接传递的参数值为：" + name);  
54.         out.println("form表单中提交的用户名为：" + username);  
55.         out.println("</body>");  
56.         out.println("</html>");  
57.         out.flush();  
58.     }  
59.       
60.     /** 
61.      * 销毁 
62.      */  
63.     public void destroy()  
64.     {  
65.         super.destroy();  
66.     }  
67. }  

程序运行结果如图8所示：

  (2)使用setAttribute()和getAttribute()方法传递参数

    设置参数的ServletA代码如下：

[java]  view plain copy

1. package com.shi.servlet;  
2.   
3. import java.io.IOException;  
4. import java.io.PrintWriter;  
5.   
6. import javax.servlet.ServletException;  
7. import javax.servlet.http.HttpServlet;  
8. import javax.servlet.http.HttpServletRequest;  
9. import javax.servlet.http.HttpServletResponse;  
10.   
11. public class ServletA extends HttpServlet  
12. {  
13.     /** 
14.      * 自动生成 
15.      */  
16.     private static final long serialVersionUID = 1L;  
17.   
18.     /** 
19.      * 构造函数 
20.      */  
21.     public ServletA()  
22.     {  
23.         super();  
24.     }  
25.       
26.     /** 
27.      * 初始化 
28.      */  
29.     public void init()  
30.     {}  
31.       
32.     /** 
33.      * doGet() 
34.      */  
35.     public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  
36.     {  
37.         doPost(request, response);  
38.     }  
39.       
40.     /** 
41.      * doPost() 
42.      */  
43.     public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  
44.     {  
45.         /** 
46.          * setAttribute()和getAttribute() 
47.          */  
48.         String data = "This is a test, we need more test for this";  
49.         request.setAttribute("strAtt", data);  
50.         request.getRequestDispatcher("/ServletB").forward(request, response);  
51.     }  
52.       
53.     /** 
54.      * 销毁 
55.      */  
56.     public void destroy()  
57.     {  
58.         super.destroy();  
59.     }  
60. }  

    获取参数的ServletB代码如下：

[java]  view plain copy

1. package com.shi.servlet;  
2.   
3. import java.io.IOException;  
4. import java.io.PrintWriter;  
5.   
6. import javax.servlet.ServletException;  
7. import javax.servlet.http.HttpServlet;  
8. import javax.servlet.http.HttpServletRequest;  
9. import javax.servlet.http.HttpServletResponse;  
10.   
11. public class ServletB extends HttpServlet  
12. {  
13.     /** 
14.      * 自动生成 
15.      */  
16.     private static final long serialVersionUID = 1L;  
17.   
18.     /** 
19.      * 构造函数 
20.      */  
21.     public ServletB()  
22.     {  
23.         super();  
24.     }  
25.       
26.     /** 
27.      * 初始化 
28.      */  
29.     public void init()  
30.     {}  
31.       
32.     /** 
33.      * doGet() 
34.      */  
35.     public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  
36.     {  
37.         doPost(request, response);  
38.     }  
39.       
40.     /** 
41.      * doPost() 
42.      */  
43.     public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  
44.     {  
45.         String strAtt = (String)request.getAttribute("strAtt");  
46.           
47.         response.setContentType("text/html;charset=gb2312");  
48.         PrintWriter out = response.getWriter();  
49.         out.println("<html>");  
50.         out.println("<body>");  
51.         out.println("getAttribute()得到的数据值为：" + strAtt);       
52.         out.println("</body>");  
53.         out.println("</html>");  
54.         out.flush();  
55.     }  
56.       
57.     /** 
58.      * 销毁 
59.      */  
60.     public void destroy()  
61.     {  
62.         super.destroy();  
63.     }  
64. }  

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

 5.JSP页面跳转方法

 (1)RequestDispatcher.forward()

    在服务器端起作用，当使用forward()时，Servlet engine传递HTTP请求从当前的Servlet or JSP到另外一个Servlet，JSP或普通HTML文件，即你的form提交至a.jsp,在a.jsp用到了forward()重定向到b.jsp，此时form提交的所有信息在b.jsp都可以获得，参数自动传递。但forward()无法重定向至有frame的jsp文件，可以重定向至有frame的html文件，同时forward()无法再后面带参数传递，比如servlet?name=tom，这样不行，可以程序内通过response.setAttribute("name",name)来传至下一个页面。

    重定向后浏览器地址栏URL不变。

    通常在Servlet中使用，不在jsp中使用。

    (2)response.sendRedirect()

    在用户的浏览器端工作，sengRedirect()可以带参数传递，比如servlet?name=tom传至下个页面，同时它可以重定向至不同的主机上，sendRedirect()可以重定向至有frame的jsp文件。

    重定向后在浏览器地址栏上会出现重定向页面的URL。

    上述两种方式代码见图7。

    由于response是jsp页面中的隐含对象，故在jsp页面中可以用response.sendRedirect()直接实现重定位。

    注意：

    ①.使用response.sendRedirect()时，前面不能有HTML输出

    这并不是绝对的，不能有HTML输出其实是指不能有HTML被送到了浏览器。事实上现在的Server都有cache机制，一般在8K(JSP SERVER)，这意味着，除非你关闭了cache，或者你用out.flush()强制刷新，那么在使用sendRedirect之前，有少量的HTML输出也是允许的。

    ②.response.sendRedirect()之后，应该紧跟一句return

    我们已经知道response.sendRedirect()是通过浏览器来做转向的，所以只有在页面处理完成后，才会有实际的动作。既然你已经要做转向了，那么后面的输出还有什么意义呢？而且有可能会因为后面的输出导致转向失败。

    比较：

    ①.Dispatcher.forward()是容器中控制权的转向，在客户端浏览器地址栏中不会出现转向后的地址

    ②.response.sendRedirect()则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接。这样，从浏览器的地址栏中可以看到跳转后的链接地址。

   前者更加高效，在前者可以满足需要时，尽量使用RequestDispatcher.forward()方法。

    注：在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用HttpServletResponse.sendRedirect()方法。

    (3)<jsp:forward page=""/>

    它的底层部分是由RequestDispatcher来实现的，因此它带有RequestDispatcher.forward()方法的印记。

    如果在之前有很多输出，前面的输出已使缓冲区满，将自动输出至客户端，那么该语句将不起作用，这一点应该特别注意。

    另外要注意：它不能改变浏览器地址，刷新的话会导致重复提交。

    测试代码如下：

[java]  view plain copy

1. <%@ page language="java" import="java.util.*" pageEncoding="gb2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <head>  
6.         <link rel="stylesheet" type="text/css" href="css/style.css">  
7.     </head>  
8.     <body>  
9.         <jsp:forward page="UpdateServlet">  
10.             <jsp:param value="list" name="action" />  
11.         </jsp:forward>  
12.     </body>  
13. </html>  

    程序运行结果如图10所示：

    (4)修改HTTP header的Location属性来重定向

    通过设置直接修改地址栏来实现页面的重定向。

    索引页1.jsp代码如下：

[java]  view plain copy

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         <%  
7.         response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY);  
8.         String newLocn = "2.jsp";  
9.         response.setHeader("Location",newLocn);  
10.         %>  
11.     </body>  
12. </html>  

    转向页2.jsp代码如下：

[java]  view plain copy

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         从1.jsp跳转至此页  
7.     </body>  
8. </html>  

    程序运行结果如图11所示：

   

    (5)JSP中实现在某页面停留若干秒后，自动重定向到另一页面

    在jsp文件中，下面的代码：

[java]  view plain copy

1. <meta http-equiv="refresh" content="5; url=target.jsp"  

    含义是：在5秒后正在浏览的页面将会自动变为target.jsp页。代码中5为刷新的延迟时间，以秒为单位。target.jsp为你想转向的目标页，若为本页则自动刷新本页。

    由上可知，可以通过setHeader来实现某页面停留若干秒后，自动重定向到另一页面。

    索引页5_1.jsp代码如下：

[java]  view plain copy

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         <%  
7.         String content = "5; url=5_2.jsp";  
8.         response.setHeader("REFRESH",content);        
9.         %>  
10.         5_1.jsp页面，5秒后转向5_2.jsp页面。  
11.     </body>  
12. </html>  

    转向页5_2.jsp代码如下：

[java]  view plain copy

1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>  
2.   
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.     <body>  
6.         从5_1.jsp转到的页面  
7.     </body>  
8. </html>  

    程序运行结果如下：