5948人阅读
Web-编程语言（153）
Java-编程语言（94）
前言这一篇是接着上一篇的继续在上一篇中， 介绍了在html,js 和JSP中如何跳转和重定向。基本是在页面层级进行页面的跳转， 进入一个页面后跳入另一个页面。这一篇将从项目和服务端来看看有可能在实际的项目中使用到的状况。旧的地址跳转到新的地址在系统开发过程中， 新旧系统并存是一种常见的处理方法，新旧系统有着各自独立的域名地址。 、当新系统开发完成的时候，就需要把旧地址的域名导到新地址中了。方法之一 就是进行DNS 修改映射了。如果系统没有域名， 只有IP, 或是不想修改DNS 的话， 就可以在旧系统中修改主页面。最简单的就是类似：&TITLE&New System&/TITLE&
&META name=&description& content=&New System Forward&&
&META name=&keywords& content=&New System&&
&META name=&robots& content=&index,follow,all&&
&meta http-equiv=&refresh& content=&0; URL=http://newurl&&当然也可以使用上一篇中提到的其他方式。Tomcat 中的地址设定Tomcat 默认安装的状况下（port:8080）, 项目部署在webapps 目录下。举例： 这里的域名myweb ，这里的项目名 myproject ,&&
本地的访问地址就是 ：& http://IP:8080/myproject.域名映射后地址就是： http://myweb:8080/myproject1.& 如何去除端口?方法一： 在安装是设置成 80 端口方法二： 如果已经安装完成， 可以修改conf\server.xml 的下面配置修改成 80 就可以了。这样就可以通过以下方式访问了：http://myweb/myproject2. 如何去除项目名称。最方便的访问方式应该就是直接输入 域名就进入了。http://myweb方法一： 修改 conf\server.xml 配置在host 中添加如下Context 的配置：方法二： 如果不使用方法一的话， 默认状况上面的地址， 会进入 webapps\ROOT\index.html 这个文件。所以使用以上的方法修改这个页面的跳转应该就能达到所需要的效果了。二级域名的重定向新系统虽然已开发完成， 但是还是想有些旧的模块功能使用旧的系统。这样的话， 访问新系统的某些url 的时候，重定向到旧的页面地址中去。以访问& http://myweb/old 的方式访问旧的地址（比如旧的地址就是http://www.csdn.net）方法一：& 增加 filter步骤一： 新增 Filter 的java 文件， 文件名& UrlRewriteFilter.java, 内容如下/*
* @author: oscar999
* Copyright (c) oscar999. All rights reserved.
package com.oscar999;
import java.io.IOE
import javax.servlet.F
import javax.servlet.FilterC
import javax.servlet.FilterC
import javax.servlet.ServletE
import javax.servlet.ServletR
import javax.servlet.ServletR
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletR
/** &description&
* @version
public class UrlRewriteFilter implements Filter{
public void destroy() {
// TODO Auto-generated method stub
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,
ServletException {
// TODO Auto-generated method stub
HttpServletRequest httpRequest = (HttpServletRequest)
HttpServletResponse httpResponse = (HttpServletResponse)
String requestPath = httpRequest.getRequestURI();
if(requestPath.indexOf(&/old&)&0)
//request.getRequestDispatcher(&/redirect.html&).forward(request, response);
httpResponse.sendRedirect(&http://www.csdn.net&);
chain.doFilter(request, response);
public void init(FilterConfig arg0) throws ServletException {
// TODO Auto-generated method stub
步骤二：& 在web.xml 中 添加filter 的定义 &filter&
&filter-name&UrlRewriteFilter&/filter-name&
&filter-class&com.oscar999.UrlRewriteFilter&/filter-class&
&filter-mapping&
&filter-name&UrlRewriteFilter&/filter-name&
&url-pattern&/old&/url-pattern&
&/filter-mapping&
说明：1. 在Java 中,满足转向的状况， 一定要return 。 否则会报 IllegalStateException错误2. 可以比较一下， forward 和 redirect 的使用差别 ？&1)& 调用的对象不同(request , response)&2)& 使用的场景不同(是否是本项目中的文件)&3)& url 的地址的变化3. 转向的逻辑的可以通过init-param 配置在filter 的 xml 中
&init-param&
&param-name&&/param-name&
&param-value&&/param-value&
&/init-param&
在filter 的init方法 中，通过&Enumeration&?& e = filterConfig.getInitParameterNames(); 读到。这样的话， 就可以灵活配置转向的逻辑了。方法二：& 直接使用 urlwrite 组件其实上面的方式， 已经有共用的组件可以用了。组件的介绍地址 ：http://tuckey.org/urlrewrite/目前最新版的下载地址：也可以到：下载有了方法一的介绍， 这个组件的使用就很容易了。1. 下载jar , 放入项目路径中2. 配置 web.xml&filter&
&filter-name&UrlRewriteFilter&/filter-name&
&filter-class&org.tuckey.web.filters.urlrewrite.UrlRewriteFilter&/filter-class&
&filter-mapping&
&filter-name&UrlRewriteFilter&/filter-name&
&url-pattern&/*&/url-pattern&
&/filter-mapping&3. 在web.xml 的同路径下，添加 urlrewrite.xml 文件， 内容如下：&?xml version=&1.0& encoding=&UTF-8&?&
&urlrewrite&
&from&/old&/from&
&to type=&redirect&&http://www.csdn.net&/to&
&/urlrewrite&这里可以配置很多的转向逻辑，不过有上下层级关系时，也就是既有二级域名又有三级域名的话， 配置起来会有一些问题。不难理解三级在二级的基础上又换了一次， 导致url 会不对。另外， 如果项目使用的是 http://myweb/myproject 这种通过项目名访问的话，映射旧的地址可以在 tomcat/webapps 中放入一个旧项目同名的项目，里面没什么内容，专门用来做重定向。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1957820次
积分：19031
积分：19031
排名：第281名
原创：417篇
转载：66篇
评论：209条
文章：40篇
阅读：126132
文章：28篇
阅读：37140
文章：14篇
阅读：38928
(3)(1)(1)(1)(2)(1)(3)(5)(4)(4)(1)(6)(5)(5)(8)(3)(2)(7)(14)(7)(5)(4)(3)(16)(8)(8)(4)(13)(20)(27)(5)(9)(9)(16)(1)(8)(5)(10)(2)(6)(18)(4)(1)(3)(1)(5)(12)(19)(5)(2)(3)(15)(11)(3)(2)(3)(6)(13)(2)(1)(3)(1)(2)(2)(1)(1)(2)(4)(3)(3)(4)(1)(6)(7)(4)(5)(5)(3)(15)(15)(7)(1)(1)(1)(5)forward/redirect跳转页面的区别 - 推酷
forward/redirect跳转页面的区别
forward方式：request.getRequestDispatcher(&/somePage.jsp&).forwardrequest, response);
redirect方式：response.sendRedirect(&/somePage.jsp&);
forward是服务器内部重定向，程序收到请求后重新定向到另一个程序，客户机并不知道；redirect则是服务器收到请求后发送一个状态头给客户，客户将再请求一次，这里多了两次网络通信的来往。当然forward也有缺点，就是forward的页面的路径如果是相对路径就会有些问题了。
forward 会将 request state , bean 等等信息带往下一个 jsp
redirect 是送到 client 端后再一次 request , 所以资料不被保留.
使用 forward 你就可以用 getAttribute() 来取的前一个 jsp 所放入的 bean 等等资料
在网上看到一些帖子，总结了一些区别，可以从以下几个方面来看：
1.从地址栏显示来说
forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址.
redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.所以redirect等于客户端向服务器端发出两次request，同时也接受两次response。
2.从数据共享来说
forward:转发页面和转发到的页面可以共享request里面的数据.
redirect:不能共享数据.
redirect不仅可以重定向到当前应用程序的其他资源,还可以重定向到同一个站点上的其他应用程序中的资源,甚至是使用绝对URL重定向到其他站点的资源.
forward,方法只能在同一个Web应用程序内的资源之间转发请求.forward 是服务器内部的一种操作.
redirect 是服务器通知客户端,让客户端重新发起请求.
所以,你可以说 redirect 是一种间接的请求, 但是你不能说&一个请求是属于forward还是redirect &
3.从运用地方来说
forward:一般用于用户登陆的时候,根据角色转发到相应的模块.
redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等.
4.从效率来说
forward:高.
redirect:低.
5.jsp 语法
&jsp:forward page={&relativeurl& | &&%= expression %&&} /&
或者这样写：
&jsp:forward page={&relativeurl& | &&%= expression %&&} &
&jsp:param name=&parametername& value=&{parametervalue | &%= expression %&}& /&+
&/jsp:forward&
&jsp:forward page=&/servlet/login.jsp& /&
&jsp:forward page=&/servlet/login.jsp&&
&jsp:param name=&username& value=&jsmith& /&
&/jsp:forward&
&jsp:forward&标签从一个jsp文件向另一个文件传递一个包含用户请求的request对象.&jsp:forward&标签以下的代码，将不能执行.
你能够向目标文件传送参数和值，在这个例子中我们传递的参数名为username,值为scott,如果你使用了&jsp:param&标签的话，目标文件必须是一个动态的文件，能够处理参数.
如果你使用了非缓冲输出的话，那么使用&jsp:forward&时就要小心。
如果在你使用&jsp:forward&之前，jsp文件已经有了数据，那么文件执行就会出错.
page=&{relativeurl | &%= expression %&}&
这里是一个表达式或是一个字符串用于说明你将要定向的文件或url.这个文件可以是jsp,程序段，或者其它能够处理request对象的文件(如asp,cgi,php).
&jsp:param name=&parametername& value=&{parametervalue | &%= expression %&}& /&+
向一个动态文件发送一个或多个参数，这个文件一定是动态文件.
如果你想传递多个参数，你可以在一个jsp文件中使用多个&jsp:param&。name指定参数名，value指定参数值.
&jsp:forward&例子
&%@ page contentType=&text/charset=gb2312& %&
&title&test&/title&
&jsp:forward page=&forwardTo.jsp&&
&jsp:param name=&userName& value=&riso&/&
&/jsp:forward&
forwardTo.jsp
&%@ page contentType=&text/charset=gb2312& %&
&!--forwardTo.jsp--&
String useName=request.getParameter(&userName&);
String outStr= &谢谢光临！&;
outStr+=useN
out.println(outStr);
redirect的例子：
譬如：client 通过XXX\index.jsp?name=gauss&pwd=123访问index.jsp,而index.jsp中有& jsp:forward page=&login.jsp&/&,则在login.jsp中可以通过request.getParameter()得到name和pwd，而&%response.sendRedirect(&login.jsp&);%&得不到。
--------------------------------------------------------------------------------------------------
在Java Web开发中，经常会用到跳转页面的方法，一般有下面两种方法。
HttpServletResponse response = new HttpServletResponse();
response.sendRedirect(location);
RequestDispatcher rd = new RequestDispatcher();
rd.forward(request, response);
运用forward方法只能重定向到同一个Web应用程序中的一个资源。而sendRedirect方法可以让你重定向到任何URL。
表单form的action= “/uu “;sendRedirect( “/uu “);表示相对于服务器根路径。如应用（则提交至）;
Forward代码中的 “/uu “则代表相对与WEB应用的路径。如应用（则提交至/uu）;
（运用RequestDispatcher接口的Forward）方法
forward()无法重定向至有frame的jsp文件,可以重定向至有frame的html文件,
同时forward()无法在后面带参数传递,比如servlet?name=frank,这样不行,可以程序内通过response.setAttribute( “name “,name)来传至下一个页面.
重定向后浏览器地址栏URL不变.
只有在客户端没有输出时才可以调用forward方法。如果当前页面的缓冲区（buffer）不是空的，那么你在调用forward方法前必须先清空缓冲区。
“/ “代表相对与web应用路径
RequestDispatcher
request.getRequestDispatcher( “/ooo “);
rd.forward(request,
response);提交至/ooo
RequestDispatcher
getServletContext().getRequestDispatcher( “/ooo “);
rd.forward(request,
response);提交至/ooo
RequestDispatcher
=getServletContext().getNamedDispatcher( “TestServlet “);（TestServlet为一个 &servlet-name& ）
rd.forward(request,
response);提交至名为TestServlet的servlet
如果在 &jsp:forward& 之前有很多输出,前面的输出已使缓冲区满,将自动输出到客户端,那么该语句将不起作用,这一点应该特别注意。
另外要注意：它不能改变浏览器地址，刷新的话会导致重复提交
从/gw/page.jsp中转发
&jsp:forward
page= “OtherPage.jsp “/& 在JSP页面被解析后转换成pageContext.forward( “OtherPage.jsp [...]
--------------------------------------------------------------------------------------------------
清空当前缓存：
在之前撰写JSP的例子中，实用了out这个对象，这个对象您不用事先宣告，就可以在JSP网页中使用，这是JSP所提供的隐含对象
(Implicit Object)，在转译为Servlet之后，out会转换为对应于javax.servlet.jsp.JspWriter型态的对象。
JspWriter直接继承自java.io.Writer，您可以使用println()、print()方法将指定的数据以字符的方式传送至客户端，println()会
在送出数据之后进行换行，而print()则否，注意换行指的是在HTML原始码中设定换行字符，而不是输出&br&标签使得在网页中可以
out(JspWriter)具有缓冲区功能，HTTP的特性是为了要取得一份资源，就进行一份协议沟通，如果资源数目很多(例如一份HTML文件
还包括了许多的小图片)，而每份资源的容量实际上很小，那么为了要取得完整的资源，将会花费很多通讯在协议往来上，假设如果
out(JspWriter)不具有缓冲功能，则每一次out.println()，就会直接将数据送出至客户端，那么单要完成一个完整网页的传送，就
会花费不少的网络资源，每一个JSP网页预设上都会具有缓冲，您可以使用page指令元素的autoFlush属性来设定是否使用缓冲区功能
在Tomcat5上，预设为每一个JSP网页备有8192字节的缓冲区(您可以使用page指令元素的buffer属性来自缓冲区的大小)，在缓冲区还
没有满之前，数据不会真正被送出至客户端，在这之前，您还有机会重设送出的数据，如果缓冲区满了，数据将会被清出并送至客户
端，可以使用下面这个程序来示范：
buffer.jsp
&%@page contentType=&text/charset=Big5&%&
out.println(&预设缓冲区大小：& + out.getBufferSize() + &&br&&);
out.flush();
//下面的文字不会出现在客户端
out.println(&您看的到这段文字吗?&);
out.clearBuffer();
out.println(&这段您可以看到!&);
您可以使用flush()直接清出缓冲区的内容，而clearBuffer()会将缓冲区的内容清除，所以第二段文字不会出现在客户端的网页上，
而最后一段会整个JSP网页执行完整后自动送出至客户端，执行结果如下：
预设缓冲区大小：8192
这段您可以看到!
您可以使用page指令元素的autoFlush来设定JSP页面是否使用缓冲区自动清出功能，out(JspWriter)以一种方式与
HttpServletResponse的PrintWriter建立关系，两者之间的行为关系取决于是否使用缓冲区自动清出，如果使用缓冲区自动清出，则
在缓冲区满之前，或是使用flush()之前不会建立PrintWriter对象来对客户端进行输出，如果不使用缓冲区自动清出，则写入out
(JspWriter)对象的数据会直接写入PrintWriter对象，然后在指定flush()之后输出至客户端。
如果您将autoFlush设定为false，则您必须明确的使用flush()来输出数据，否则缓冲区满了的话，就会发生IOException例外，使用
缓冲区有其好处，但由于缓冲区在满之前，数据并不会真正送出客户端，所以会有响应延迟的问题，如果您要实时性将结果响应至客
户端，则可以关闭缓冲区。
下面这个程序测试缓冲区关闭之后，如果缓冲区满了，会有什么结果：
buffer.jsp
&%@page contentType=&text/charset=Big5& %&
for(int i=0; i&2000; i++){
out.println(&test&);
//out.flush();
如果没有移开out.flush()的批注符号，则会响应一下的错误讯息：
HTTP Status 500 -
type Exception report
description The server encountered an internal error() that prevented it from fulfilling this request.
java.io.IOException: Error: JSP Buffer overflow
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
没有分页内容
图片无法显示
视频无法显示
与原文不一致<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
您的访问请求被拒绝 403 Forbidden - ITeye技术社区
您的访问请求被拒绝
亲爱的会员，您的IP地址所在网段被ITeye拒绝服务，这可能是以下两种情况导致：
一、您所在的网段内有网络爬虫大量抓取ITeye网页，为保证其他人流畅的访问ITeye，该网段被ITeye拒绝
二、您通过某个代理服务器访问ITeye网站，该代理服务器被网络爬虫利用，大量抓取ITeye网页
请您点击按钮解除封锁&下面列了五个例子来详细说明，这几个例子的主要功能是：在5秒后，自动跳转到同目录下的hello.html（根据自己需要自行修改）文件。1) html的实现
&!-- 以下方式只是刷新不跳转到其他页面 --&
&meta http-equiv="refresh" content="10"&
&!-- 以下方式定时转到其他页面 --&
&meta http-equiv="refresh" content="5;url=hello.html"&
优点：简单缺点：Struts Tiles中无法使用
2) javascript的实现
&script language="javascript" type="text/javascript"&
// 以下方式直接跳转
window.location.href='hello.html';
// 以下方式定时跳转
setTimeout("javascript:location.href='hello.html'", 5000);
优点：灵活，可以结合更多的其他功能缺点：受到不同浏览器的影响3) 结合了倒数的javascript实现（IE）
&span id="totalSecond"&5&/span&
&script language="javascript" type="text/javascript"&
var second = totalSecond.innerT
setInterval("redirect()", 1000);
function redirect(){
totalSecond.innerText=--
if(second&0) location.href='hello.html';
优点：更人性化缺点：firefox不支持（firefox不支持span、div等的innerText属性）3') 结合了倒数的javascript实现（firefox）
&script language="javascript" type="text/javascript"&
var second = document.getElementById('totalSecond').textC
setInterval("redirect()", 1000);
function redirect()
document.getElementById('totalSecond').textContent = --
if (second & 0) location.href = 'hello.html';
4) 解决Firefox不支持innerText的问题
&span id="totalSecond"&5&/span&
&script language="javascript" type="text/javascript"&
if(navigator.appName.indexOf("Explorer") & -1){
document.getElementById('totalSecond').innerText = "my text innerText";
document.getElementById('totalSecond').textContent = "my text textContent";
5) 整合3)和3')
&span id="totalSecond"&5&/span&
&script language="javascript" type="text/javascript"&
var second = document.getElementById('totalSecond').textC
if (navigator.appName.indexOf("Explorer") & -1)
second = document.getElementById('totalSecond').innerT
second = document.getElementById('totalSecond').textC
setInterval("redirect()", 1000);
function redirect() {
if (second & 0) {
location.href = 'hello.html';
if (navigator.appName.indexOf("Explorer") & -1) {
document.getElementById('totalSecond').innerText = second--;
document.getElementById('totalSecond').textContent = second--;
阅读(...) 评论() &随笔 - 1157&
文章 - 45&评论 - 172&trackbacks - 0
1. forward方法使用
request.getRequestDispatcher(path).forward(request.response);首先来看getRequestDispatcher方法，path必须是相对路径。
getRequestDispatcher
getRequestDispatcher(&path)
Returns a&&object that acts as a wrapper for the resource located at the given path. A&RequestDispatcher&object can be used to forward a request to the resource or to include the resource in a response. The resource can be dynamic or static.
The pathname specified may be relative, although it cannot extend outside the current servlet context. If the path begins with a "/" it is interpreted as relative to the current context root. This method returns&null&if the servlet container cannot return a&RequestDispatcher.
The difference between this method and&&is that this method can take a relative path.
Parameters:path&- a&String&specifying the pathname to the resource. If it is relative, it must be relative against the current servlet.Returns:a&RequestDispatcher&object that acts as a wrapper for the resource at the specified path, or&null&if the servlet container cannot return a&RequestDispatcherSee Also:,&
接着forward方法，
void forward(&request,
&response)
Forwards a request from a servlet to another resource (servlet, JSP file, or HTML file) on the server. This method allows one servlet to do preliminary processing of a request and another resource to generate the response.
For a&RequestDispatcher&obtained via&getRequestDispatcher(), the&ServletRequest&object has its path elements and parameters adjusted to match the path of the target resource.
forward&should be called before the response has been committed to the client (before response body output has been flushed). If the response already has been committed, this method throws an&IllegalStateException. Uncommitted output in the response buffer is automatically cleared before the forward.
The request and response parameters must be either the same objects as were passed to the calling servlet's service method or be subclasses of the&or&&classes that wrap them.
Parameters:request&- a&&object that represents the request the client makes of the servletresponse&- a&&object that represents the response the servlet returns to the clientThrows:&- if the target resource throws this exception&- if the target resource throws this exception&- if the response was already committed
2.sendRedirect方法使用
HttpServletResponse中使用sendRedirect可以实现跳转，可以接受相对路径或者绝对路径。
sendRedirect
public void sendRedirect(java.lang.String&location)
throws java.io.IOException
Sends a temporary redirect response to the client using the specified redirect location URL. This method can accept relative URLs; the servlet container must convert the relative URL to an absolute URL before sending the response to the client. If the location is relative without a leading '/' the container interprets it as relative to the current request URI. If the location is relative with a leading '/' the container interprets it as relative to the servlet container root.
If the response has already been committed, this method throws an IllegalStateException. After using this method, the response should be considered to be committed and should not be written to.
参数定位&- the redirect location URLThrows:java.io.IOException&- If an input or output exception occursjava.lang.IllegalStateException&- If the response was committed or if a partial URL is given and cannot be converted into a valid URL
Servlet 跳转 redirect与forward跳转的区别
当然，在servlet中，一般跳转都发生在doGet, doPost等方法里面。
1) redirect 方式
response.sendRedirect("/a.jsp");
页面的路径是相对路径。sendRedirect可以将页面跳转到任何页面，不一定局限于本web应用中，如：
response.sendRedirect("");
跳转后浏览器地址栏变化。
这种方式要传值出去的话，只能在url中带parameter或者放在session中，无法使用request.setAttribute来传递。
这种方式是在客户端作的重定向处理。该方法通过修改HTTP协议的HEADER部分,对浏览器下达重定向指令的，让浏览器对在location中指定的URL提出请求，使浏览器显示重定向网页的内容。该方法可以接受绝对的或相对的URLs。如果传递到该方法的参数是一个相对的URL，那么Web container在将它发送到客户端前会把它转换成一个绝对的URL。public void doPost(HttpServletRequest request,HttpServletResponse response)&&& throws ServletException,IOException
&&&&&&& response.setContentType("text/ charset=UTF-8");
&&&&&&& response.sendRedirect("/index.jsp");
2) forward方式
RequestDispatcher dispatcher = request.getRequestDispatcher("/a.jsp");
dispatcher .forward(request, response);
页面的路径是相对路径。forward方式只能跳转到本web应用中的页面上。
跳转后浏览器地址栏不会变化。
使用这种方式跳转，传值可以使用三种方法：url中带parameter，session，request.setAttribute
这种方式是在服务器端作的重定向。服务器往client发送数据的过程是这样的：服务器在向客户端发送数据之前，是先将数据输出到缓冲区，然后将缓冲区中数据发送给client端。什么时候将缓冲区里的数据发送给client端呢？（1）当对来自client的request处理完，并把所有数据输出到缓冲区，（2）当缓冲区满，（3）在程序中调用缓冲区的输出方法out.flush()或response.flushbuffer()，web container才将缓冲区中的数据发送给client。
这种重定向方式是利用服务器端的缓冲区机制，在把缓冲区的数据发送到客户端之前，原来的数据不发送，将执行转向重定向页面，发送重定向页面的数据，重定向调用页的数据将被清除。如果在&JSP:FORWORD&之前有很多输出，前面的输出已使缓冲区满，将自动输出到客户端，那么这种重定向方式将不起作用，这一点应该特别注意。
public void doPost(HttpServletRequest request,HttpServletResponse response)&& throws ServletException,IOException
&&&&&&& response.setContentType("text/ charset=UTF-8");
&&&&&&& ServletContext sc = getServletContext();
&&&&&&& RequestDispatcher rd =
&&&&&&& rd = sc.getRequestDispatcher("/index.jsp");
&&&&&&& rd.forward(request, response);
1、forward重定向是在容器内部实现的同一个Web应用程序的重定向，所以forward方法只能重定向到同一个Web应用程序中的一个资源，重定向后浏览器地址栏URL不变，而sendRedirect方法可以重定向到任何URL， 因为这种方法是修改http头来实现的，URL没什么限制，重定向后浏览器地址栏URL改变。
2、forward重定向将原始的HTTP请求对象（request）从一个servlet实例传递到另一个实例，而采用sendRedirect方式两者不是同一个application。
3、基于第二点，参数的传递方式不一样。forward的form参数跟着传递，所以在第二个实例中可以取得HTTP请求的参数。sendRedirect只能通过链接传递参数，response.sendRedirect(&login.jsp?param1=a&)。
4、sendRedirect能够处理相对URL，自动把它们转换成绝对URL，如果地址是相对的，没有一个&/&，那么Web container就认为它是相对于当前的请求URI的。比如，如果为response.sendRedirect("login.jsp")，则会从当前servlet 的URL路径下找login.jsp： http://10.1.18.8:8081/dms/servlet/Servlet 重定向的URL: http://10.1.18.8:8081/dms/servlet/login.jsp，如果为response.sendRedirect("/login.jsp")则会从当前应用径下查找。而forward不能这样处理相对路径。
他们的区别是：
response.sendRedirect是向客户浏览器发送页面重定向指令，浏览器接收后将向web服务器重新发送页面请求，所以执行完后浏览器的url显示的是跳转后的页面。跳转页面可以是一个任意的url（本服务器的和其他服务器的均可）。
RequestDispatcher.forward则是直接在服务器中进行处理，将处理完后的信息发送给浏览器进行显示,所以完成后在url中显示的是跳转前的页面。在forward的时候将上一页面中传送的request和response信息一同发送给下一页面（而response.sendRedirect不能将上一页面的request和response信息发送到下一页面）。由于forward是直接在服务器中进行处理，所以forward的页面只能是本服务器的。
1) response.sendRedirect();
和servlet的response.sendRedirect()方式一样。
此语句前不允许有out.flush()，如果有，会有异常：
java.lang.IllegalStateException: Can't sendRedirect() after data has committed to the client.
at com.caucho.server.connection.AbstractHttpResponse.sendRedirect(AbstractHttpResponse.java:558)
跳转后浏览器地址栏变化
如果要跳到不同主机下，跳转后，此语句后面的语句会继续执行，如同新开了线程，但是对response的操作已经无意义了；
如果要跳到相同主机下，此语句后面的语句执行完成后才会跳转；
2) response.setHeader("Location","");
此语句前不允许有out.flush()，如果有，页面不会跳转。
跳转后浏览器地址栏变化
此语句后面的语句执行完成后才会跳转
3) &jsp:forward page="" /&
此语句前不允许有out.flush()，如果有，会有异常：
java.lang.IllegalStateException: forward() not allowed after buffer has committed.
at com.caucho.server.webapp.RequestDispatcherImpl.forward(RequestDispatcherImpl.java:134)
at com.caucho.server.webapp.RequestDispatcherImpl.forward(RequestDispatcherImpl.java:101)
at com.caucho.jsp.PageContextImpl.forward(PageContextImpl.java:836)
跳转后浏览器地址栏不变，但是只能跳到当前主机下
此语句后面的语句执行完成后才会跳转
来自：/link?url=Z8dLJDFT1MX6-yDqajj71B3rc32Zx79iybgSkMoqg922FApVCTviGuYhflaWUiaMYhcAc-It1pKKq2Y127JCYp41U_y4sNsVpQ8AJ_vaEvS
阅读(...) 评论()