脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → JavaWeb 转发与重定向

JavaWeb中转发与重定向的区别小结

 更新时间：2023年10月24日 09:55:42   作者：m0nesy小孩  
转发和重定向是JavaWeb中常用的两种页面跳转方式,它们在实现上有一些区别,本文主要介绍了JavaWeb中转发与重定向的区别小结,具有一定的参考价值,感兴趣的可以了解一下

在一个web应用中通过两种方式，可以完成资源的跳转：

  • 第一种方式：转发
  • 第二种方式：重定向

1. Forward 转发

转发 ：指内部转发。当一个Servlet处理请求的时候，它可以决定自己不继续处理，而是转发给另一个Servlet处理。

// 获取请求转发器对象
RequestDispatcher dispatcher = request.getRequestDispatcher("/dept/list");
// 调用请求转发器对象的forward方法完成转发
dispatcher.forward(request, response);
 
// 合并一行代码
request.getRequestDispatcher("/dept/list").forward(request, response);
// 转发的时候是一次请求，不管你转发了多少次。都是一次请求。
// AServlet转发到BServlet，再转发到CServlet，再转发到DServlet，不管转发了多少次，都在同一个request当中。
// 这是因为调用forward方法的时候，会将当前的request和response对象传递给下一个Servlet。

注意： 因为转发是服务器内部的进行的，所以 request.getRequestDispatcher(/不要项目名的).forward(request, response);编写的转发路径是不要加项目名的。

举例： 浏览器向 AServlet 发送请求，AServlet 将该请求 “转发”给了 BServlet。但是前端的浏览器并不知道该请求被 BServlet 处理了，浏览器的地址栏上显示的还是发送给 AServlet 请求的路径信息。

package com.RainbowSea.servlet;
 
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
 
import java.io.IOException;
 
public class AServlet extends HttpServlet {
    // 地址栏上回车操作是 doGet()请求
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
 
        // 转发到 BServlet，转发的路径不要加项目名
        request.getRequestDispatcher("/b").forward(request, response);
 
    }
}
package com.RainbowSea.servlet;
 
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
 
import java.io.IOException;
import java.io.PrintWriter;
 
public class BServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
 
        // 设置浏览器端显示响应的，格式类型，以及字符集
        response.setContentType("text/html;charSet=UTF-8");
        PrintWriter writer = response.getWriter();
 
        writer.println("<h2> 这里是BServlet 的响应处理 </h2>");
 
    }
}

转发是由WEB服务器来控制的。A资源跳转到B资源，这个跳转动作是Tomcat服务器内部完成的 ，而我们前端也就是浏览器端是不知道我们服务器端对这个请求内部转发处理了多少次。 并且无论我们服务器内部转发了多少次，前端浏览器都仅仅只会认为仅仅只转发了一次，也就是仅仅发送了一次请求 。因为我们服务器端虽然进行了转发但是，浏览器的地址栏上的请求路径的地址是没有改变的（还是初始的请求路径）

转发：是可以将 一个Servlet 类当中的信息转发到另一个 Servlet 当中去的，可以实现 Servlet 数据的共享，需要用到 请求域

注意： 请求域的作用域（请求域当中存储的信息），只在一次 请求 范围内有效。而转发机制的特点决定了可以实现请求域的共享：因为无论服务器内部转发了多少次，前端浏览器都只视为是一次请求。

转发机制，将AServlett 类当中的信息转发到 BServlet 当中去

package com.RainbowSea.servlet;
 
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Date;
 
public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        // 设置，在浏览器上响应的格式类型
        Date nowTime = new Date();  // 创建当前时间的 Date 对象
 
        // 将 nowTime 的数据存储(绑定)到请求域当中
        request.setAttribute("sysTime",nowTime);
 
        // 第一步: 获取到转发对象，注意：/ 开始，不家项目名 , / + 对应跳转的 Servlet 当中的 web.xml 当中的url映射的路径
        RequestDispatcher requestDispatcher = request.getRequestDispatcher("/B");
 
        // 第二步: 调用转发器的forward方法完成跳转/转发
        requestDispatcher.forward(request,response);
 
 
 
 
    }
}
package com.RainbowSea.servlet;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
 
public class BServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
 
        // 设置，在浏览器上响应的格式类型
        response.setContentType("text/html;charSet=utf-8");
        PrintWriter writer = response.getWriter();
 
        // 取出请求域当中的数据: 这里的name值与上面setAttribute(String name,Object obj) 保持一致。
        Object sysTime = request.getAttribute("sysTime");
 
        writer.println("sysTime = " + sysTime);  // 显示到浏览器页面当中的数据
    }
}

转发的下一个资源必须是一个Servlet吗 ？

不一定，只要是Tomcat服务器当中的合法资源，都是可以转发的。例如：html....

举例：转发一个html文件

注意： 如果对应的不是 Servlet ，默认是从项目的中的web目录开始的，如果是转发web的目录下的子目录的话，需要指定对应的子目录的文件。

package com.RainbowSea.servlet;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
 
public class TestServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        // 转发的下一个资源不一定是Servlet 资源，
        // 只要是Tomcat服务器当中合法的资源，都是可以转发的，例如: html...
        // 注意：转发的时候，路径的写法要注意，转发的路径以 “/” 开始，不加项目名
        // 默认是从项目的中的web目录开始的，如果是转发web的目录下的子目录的话，需要指定对应的子目录
        // 如下是含有子目录的 / 表示 web目录
        request.getRequestDispatcher("/test/test.html").forward(request,response);
 
    }
}

2. Redirect重定向

重定向： 是指当浏览器请求一个 URL时，服务器返回一个重定向指令，告诉浏览器地址已经变了，麻烦使用新的URL再重新发送新请求。

重定向有两种： 一种是302响应，称为临时重定向，一种是301响应，称为永久重定向。两者的区别是，如果服务器发送301永久重定向响应，浏览器会缓存/hi到/hello这个重定向的关联，下次请求/hi的时候，浏览器就直接发送/hello请求了。

说明： 所谓的重定向是将新的路径交给浏览器的地址栏上，然后自动执行的，而前端的信息获取是需要指明项目名的，所以：注意：重定向 response.sendRedirect("/项目名/xxx/xx");的跳转路径是需要写明项目名的 。

// 下面这种是 302 响应，临时重定向
// 注意：路径上要加一个项目名。为什么？
// 浏览器发送请求，请求路径上是需要添加项目名的。
// 以下这一行代码会将请求路径“/oa/dept/list”发送给浏览器
// 浏览器会自发的向服务器发送一次全新的请求：/oa/dept/list
response.sendRedirect("/oa/dept/list");

HttpServletResponse提供了快捷的redirect()方法实现302重定向。如果要实现301永久重定向，可以这么写：

response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); // 301
response.setHeader("Location", "/hello");

举例： 浏览器向 AServlet 发送请求，AServlet 将该请求 “重定向”给了 BServlet。重定向一个新的URL地址，告诉浏览器发送的处理请求的URL地址改变了，将该请求发送到该重定向的URL中去，也就是这里的BServlet。

package com.RainbowSea.servlet;
 
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
 
import java.io.IOException;
 
public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
 
        // 重定向的路径 需要加项目名
        response.sendRedirect("/servlet12/b");
        // 可以使用 request.getContextPath() 获取到项目名(也就是项目名的根路径)，注意该返回的路径是带 “/”的 /项目名
        // 所以不要多写了 “/”
        // response.sendRedirect(request.getContextPath()+"/b");
 
 
 
    }
}
package com.RainbowSea.servlet;
 
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
 
import java.io.IOException;
import java.io.PrintWriter;
 
public class BServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
 
        // 设置浏览器端显示响应的，格式类型，以及字符集
        response.setContentType("text/html;charSet=UTF-8");
        PrintWriter writer = response.getWriter();
 
        writer.println("<h2> 这里是BServlet 的响应处理 </h2>");
 
    }
}
 // 重定向： (重新定方向)
//response.sendRedirect("/项目名/");
// 重定向时的路径当中需要以项目名开始，或者说需要添加项目名的
// 因为所谓的重定向是将新的路径交给浏览器的地址栏上，然后自动执行的，而前端的信息获取是需要指明项目名的
// response对将这个路径: /servlet10/B 响应给了浏览器了。
// 浏览器又自发的向服务器发送了一个全新的请求: http://127.0.0.1:8080/servlet12/a
// 所以浏览器一共发送了 "两次"请求:
// 第一次请求: http://127.0.0.1:8080/servlet12/a
// 第二次请求: http://127.0.0.1:8080/servlet12/b
// 最终浏览器地址栏上显示的地址信息当然就是最后那一次请求的地址，所以重定向会导致浏览器
// 地址栏上的地址发生改变。
// 但是重定向是一次新的请求，是无法获取到请求域当中（只在一次请求中有效）信息的
// 重定向操作是由：跳转到哪个资源，是由浏览器的地址栏说的算的。
// 注意: request.getContextPath()返回的项目名的根路径是带有了 "/"了的
response.sendRedirect(request.getContextPath()+"/B");

重定向： 浏览器是知道，实际转发了多少次请求的。

注意：重定向是“重定向几次，就会发送几次请求，导致的结果就是，重定向无法使用 请求域，因为请求域的作用范围是再一次请求当中的，重定向无法实现 Servlet 之间的数据共享。

举例如下：定义了一个 名为 User 类的JavaBean，在 AServlet 当中 new 一个 User 对象，并存储到AServlet请求域当中，存储好以后，重定向给 BServlet ，在BServlet 当中想将存储到 AServlet 请求域当中的数据取出来，这是不行的，因为请求域只在一次请求中有效，而这里重定向了一次，就会多一次请求也就是两次请求。无法获取到AServlet 请求域当的存储的数据。

package com.RainbowSea.servlet;
 
import java.io.Serializable;
import java.util.Objects;
 
 
/**
 * 1. 一个普通的Javabean
 * 2. 什么是javabean
 * Java是咖啡，bean 是豆子
 * javabean 咖啡豆
 * 咖啡是由咖啡豆研磨而成的，寓意:是Java程序是由一个一个的javabean组成的
 * 3. 一个javaBean一般是有规范的
 *     有无参数的构造方法
 *     属性私有化
 *     对外提供 get/set()方法
 *     重写toString()
 *     重写hashCode() + equals
 *     实现java.io.Serializable 接口 可序列化的
 */
public class User implements Serializable {
    private String id;
    private String name;
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(getId(), user.getId()) && Objects.equals(getName(), user.getName());
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(getId(), getName());
    }
 
    public User() {
 
    }
 
    public User(String id, String name) {
        this.id = id;
        this.name = name;
    }
 
    public String getId() {
        return id;
    }
 
    public void setId(String id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}
package com.RainbowSea.servlet;
 
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
 
import java.io.IOException;
 
public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
 
        // 创建 User 对象
        User user = new User("001","张三");
 
        // 将 user 对象存储到 请求域当中
        request.setAttribute("userObj",user);
 
        // 重定向的路径 需要加项目名
        response.sendRedirect("/servlet12/b");
        // 可以使用 request.getContextPath() 获取到项目名(也就是项目名的根路径)，注意该返回的路径是带 “/”的 /项目名
        // 所以不要多写了 “/”
        // response.sendRedirect(request.getContextPath()+"/b");
 
 
 
    }
}
package com.RainbowSea.servlet;
 
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
 
import java.io.IOException;
import java.io.PrintWriter;
 
public class BServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
 
        // 无法取出 AServlet 请求域当中的数据
        Object userObj = request.getAttribute("userObj");
 
        // 设置浏览器端显示响应的，格式类型，以及字符集
        response.setContentType("text/html;charSet=UTF-8");
        PrintWriter writer = response.getWriter();
 
        writer.println("从AServlet 获取的数据：" + userObj);
 
    }
}

重定向：除了重定向 Servlet 资源以外，还可以重定向其他资源，比如 html...等等只要是服务器当中合法的资源都可以。

举例：AServlet 重定向一个名为 index.html 的资源

package com.RainbowSea.servlet;
 
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
 
import java.io.IOException;
 
public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
 
        // 重定向一个名为 index.html 的资源
        // request.getContextPath() 返回的是该webapp的项目的根路径：也就是/项目名，注意是带 “/”的，不要多写了
        response.sendRedirect(request.getContextPath()+"/index.html");
        
 
    }
}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>index</title>
</head>
<body>
  <h1>Hello World</h1>
  <h1>你好世界</h1>
 
</body>
</html>

3. 转发使用不当的危害：转发刷新问题

说明： 由于转发的机制的特点：无论转发了服务器内部 转发 多少次，浏览器都视为是请求了一次，而且还是原来（最初的那一次请求，不是转发之后到的页面的请求）。这样的特征，如果使用不当的话，就会存在 一个刷新问题：就是你服务器内部虽然发送了转发性质的跳转到了一个新的页面，服务器内部转发到一个新的页面成功后，你在浏览器端重新刷新的话，还是对最初的一个URL请求刷新的（因为转发是不会改变浏览器地址栏上的 URL 地址的）。

举例： 我们在 StudentServlet 中执行向数据库的一张名为 studnet 表插入一条记录的操作。插入成功跳转到一个名为 succeed.html的页面，插入失败跳转到一个名为 error.html失败的页面。然后我们对跳转到 succeed.html* 页面后，在浏览器 执行刷新 操作看看会导致一个什么样的结果 ？

准备工作： 创建一个数据表，并插入一些数据

CREATE TABLE studnet (
`no` VARCHAR(255),
 `name` VARCHAR(255)
);
 
 
INSERT INTO studnet (`no`,`name`) VALUES('1','张三'),('2','李四');

package com.RainbowSea.servlet;
 
import com.RainbowSea.DBUtil.DBUtil;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
 
import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
 
public class StudentServlet extends HttpServlet {
 
 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
 
        /*
        思路： 获取到前端的提交的数据
        连接数据库，操作数据库
         */
        // 获取到前端提交的数据
        request.setCharacterEncoding("UTF-8");
        String no = request.getParameter("no");
        String name = request.getParameter("name");
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        // 表示影响数据库的行数
        int count = 0;
 
        try {
            // 1. 连接数据库,这里的DBUtil.getConnection(); 是我写的一个连接数据库的工具类，大家不用太在意
            connection = DBUtil.getConnection();
 
            // 2. 获取操作数据库对象，预编译sql语句，注意测试sql是否存在错误
            // 注意： ? 不要加 '', ""单双引号，不然无法识别到该占位符的
            String sql = "INSERT INTO studnet (`no`,`name`) VALUES(?,?)";
            preparedStatement = connection.prepareStatement(sql);
 
            // 3. 填充占位符，真正执行sql语句
            preparedStatement.setString(1,no);
            preparedStatement.setString(2,name);
 
            count = preparedStatement.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            // 4. 释放资源
            DBUtil.close(connection,preparedStatement,null);
        }
 
        if(count == 1) {
            // 添加成功
            // 先用 转发机制 ,转发服务器内部，不要加项目名
            request.getRequestDispatcher("/succeed.html").forward(request,response);
        } else {
            request.getRequestDispatcher("/error.html").forward(request,response);
        }
    }
}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>添加成功</title>
</head>
<body>
  <h1>添加成功</h1>
 
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>添加失败</title>
</head>
<body>
 
  <h1>添加失败</h1>
 
</body>
</html>

实验效果如下：

但是，如果我们这时候，在浏览器端点击刷新,这里我们，点击了 3次刷新。导致的结果如下：

优化： 这里我们将转发 修改为 重定向 就没有这样的问题了，因为重定向是会改变浏览器地址栏上的 URL 地址的（为最后我们重定向(跳转)的页面的URL地址）。

package com.RainbowSea.servlet;
 
import com.RainbowSea.DBUtil.DBUtil;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
 
import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
 
public class StudentServlet extends HttpServlet {
 
 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
 
        /*
        思路： 获取到前端的提交的数据
        连接数据库，操作数据库
         */
        // 获取到前端提交的数据
        request.setCharacterEncoding("UTF-8");
        String no = request.getParameter("no");
        String name = request.getParameter("name");
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        // 表示影响数据库的行数
        int count = 0;
 
        try {
            // 连接数据库
            connection = DBUtil.getConnection();
 
            // 注意： ? 不要加 '', ""单双引号，不然无法识别到该占位符的
            String sql = "INSERT INTO studnet (`no`,`name`) VALUES(?,?)";
            preparedStatement = connection.prepareStatement(sql);
 
            preparedStatement.setString(1,no);
            preparedStatement.setString(2,name);
 
            count = preparedStatement.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            // 释放资源
            DBUtil.close(connection,preparedStatement,null);
        }
 
        if(count == 1) {
            // 添加成功
            // 先用 转发机制 ,转发服务器内部，不要加项目名
            // request.getRequestDispatcher("/succeed.html").forward(request,response);
 
            // 优化修改为重定向：重定向前端需要指明 项目名(/项目的根路径)
            // request.getContextPath() 该方法可以获取到: "/项目的根路径"，注意是带有 / 的，所以不要多写了 /
            response.sendRedirect(request.getContextPath()+"/succeed.html");
        } else {
            // request.getRequestDispatcher("/error.html").forward(request,response);
            response.sendRedirect(request.getContextPath()+"/error.html");
        }
    }
}

4. 转发 与 重定向的区别

代码上的区别：

转发 ：转发的路径 不要 写项目名(项目的根路径)

// 获取请求转发器对象
RequestDispatcher dispatcher = request.getRequestDispatcher("/dept/list");
// 调用请求转发器对象的forward方法完成转发
dispatcher.forward(request, response);
 
// 合并一行代码
request.getRequestDispatcher("/dept/list").forward(request, response);
// 转发的时候是一次请求，不管你转发了多少次。都是一次请求。
// AServlet转发到BServlet，再转发到CServlet，再转发到DServlet，不管转发了多少次，都在同一个request当中。
// 这是因为调用forward方法的时候，会将当前的request和response对象传递给下一个Servlet。

重定向 ：重定向的路径，需要 写项目名(项目的根路径)

response.sendRedirect("/servlet12/b");
// 可以使用 request.getContextPath() 获取到项目名(也就是项目名的根路径)，注意该返回的路径是带 “/”的 /项目名，所以不要多写了 “/”
 response.sendRedirect(request.getContextPath()+"/index.html");

形式上有什么区别 ？

转发（一次请求）

在浏览器地址栏上发送的请求是：http://localhost:8080/servlet10/a ，最终请求结束之后，浏览器地址栏上的地址还是这个。没变。

重定向（两次请求）

在浏览器地址栏上发送的请求是：http://localhost:8080/servlet10/a ，最终在浏览器地址栏上显示的地址是：http://localhost:8080/servlet10/b（也就是最后重定向的地址）

转发和重定向的本质区别 ？

转发：是由WEB服务器来控制的。A资源跳转到B资源，这个跳转动作是Tomcat服务器内部完成的。所以无论 服务器转发了多少次，而我们前端也就是浏览器端是不知道我们服务器端对这个请求内部转发处理了多少次。 并且无论我们服务器内部转发了多少次，前端浏览器都仅仅只会认为仅仅只转发了一次，也就是仅仅发送了一次请求 。因为我们服务器端虽然进行了转发，但是浏览器的地址栏上的请求路径的地址是没有改变的（还是初始的请求路径）

重定向：是浏览器完成的。具体跳转到哪个资源，是浏览器说了算。当浏览器请求一个 URL时，服务器返回一个重定向指令，告诉浏览器要处理该请求的URL地址已经变了，麻烦使用新的URL再重新发送新请求。所以，前端浏览器是知道我们重定向了多少次的，而且重定向是“重定向几次，就会发送几次请求”。

相同点： 无论是 “转发”还是 “重定向”都可以跳转到另外一个资源当中，都是不仅仅是 Servlet 资源，也可以是其他的服务器上合法的资源比如：html等等。

优缺点上的区别：

转发： 可以通过请求域存储数据的方式，实现多个Servlet 数据的共享。因为：多少次转发都是只视为一次请求。但是转发存在刷新问题 。

重定向：没有刷新问题，但是无法通过请求域存储数据的方式，实现多个Servlet 数据的共享。因为：“重定向几次，就会发送几次请求”。而请求域只在一次请求范围有效。

转发与重定向 举例图示上的描述：

转发：

重定向：

5. “重写向”与“转发”的合理选择

  • 如果在上一个Servlet当中向request域当中绑定了数据，希望从下一个Servlet当中把request域里面的数据取出来，使用转发机制。
  • 剩下所有的请求均使用重定向。（重定向使用较多。）

重定向的目的是当Web应用升级后，如果请求路径发生了变化，可以将原来的路径重定向到新路径，从而避免浏览器请求原路径找不到资源。

6. 总结：

转发 ：指内部转发。当一个Servlet处理请求的时候，它可以决定自己不继续处理，而是转发给另一个Servlet处理。

转发是由WEB服务器来控制的。A资源跳转到B资源，这个跳转动作是Tomcat服务器内部完成的 ，而我们前端也就是浏览器端是不知道我们服务器端对这个请求内部转发处理了多少次。 并且无论我们服务器内部转发了多少次，前端浏览器都仅仅只会认为仅仅只转发了一次，也就是仅仅发送了一次请求 。因为我们服务器端虽然进行了转发但是，浏览器的地址栏上的请求路径的地址是没有改变的（还是初始的请求路径） 编写的转发路径是不要加项目名的。

重定向： 是指当浏览器请求一个 URL时，服务器返回一个重定向指令，告诉浏览器地址已经变了，麻烦使用新的URL再重新发送新请求。

  • 重定向有两种： 一种是302响应，称为临时重定向，一种是301响应，称为永久重定向。两者的区别是，如果服务器发送301永久重定向响应，浏览器会缓存/hi到/hello这个重定向的关联，下次请求/hi的时候，浏览器就直接发送/hello请求了。
  • 说明： 所谓的重定向是将新的路径交给浏览器的地址栏上，然后自动执行的，而前端的信息获取是需要指明项目名的，所以：注意：重定向 response.sendRedirect("/项目名/xxx/xx");的跳转路径是需要写明项目名的 。

注意：转发机制存在的一个刷新问题。

转发 与 重定向的区别

到此这篇关于JavaWeb中转发与重定向的区别小结的文章就介绍到这了,更多相关JavaWeb 转发与重定向内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • 详解Spring注解--@Autowired、@Resource和@Service

    详解Spring注解--@Autowired、@Resource和@Service

    本篇文章主要介绍最重要的三个Spring注解，也就是@Autowired、@Resource和@Service，具有很好的参考价值。下面跟着小编一起来看下吧
    2017-05-05
  • 一文带你掌握Java SPI的原理和实践

    一文带你掌握Java SPI的原理和实践

    在Java中，我们经常会提到面向接口编程，这样减少了模块之间的耦合，更加灵活，Java SPI (Service Provider Interface)就提供了这样的机制，本文就来讲讲它的原理与具体使用吧
    2023-05-05
  • 学习Java中的List集合

    学习Java中的List集合

    这篇文章主要介绍了学习Java中的List集合，List是一个有序集合， 说是集合，其实只是只是Collection接口的一个子接口，下面关于List的相关资料 需要的小伙伴可以参考一下，希望对你有所帮助
    2022-02-02
  • 探究Android系统中解析JSON数据的方式

    探究Android系统中解析JSON数据的方式

    这篇文章主要介绍了探究Android系统中解析JSON数据的方式,文中讲到了使用Java代码实现的处理JSON的一些主要方法,需要的朋友可以参考下
    2015-07-07
  • Java可变参数列表详解

    Java可变参数列表详解

    这篇文章主要介绍了Java可变参数列表详解的相关资料,需要的朋友可以参考下
    2017-05-05
  • 利用JStack排查死锁问题和CPU100%问题

    利用JStack排查死锁问题和CPU100%问题

    无论是再面试过程中还是再实际项目开发当中我们都有可能遇到这两个问题如何利用JStack排查死锁问题和CPU100%问题,文中给出了详细的排查过程和解决方法,需要的朋友可以参考下
    2023-12-12
  • Java多线程编程之Lock用法实例

    Java多线程编程之Lock用法实例

    这篇文章主要介绍了Java多线程编程之Lock用法实例,本文直接给出代码实例,需要的朋友可以参考下
    2015-05-05
  • SpringBoot集成Graphql Query实战示例

    SpringBoot集成Graphql Query实战示例

    这篇文章主要为大家介绍了SpringBoot集成Graphql Query实战示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-09-09
  • 详解JDK中ExecutorService与Callable和Future对线程的支持

    详解JDK中ExecutorService与Callable和Future对线程的支持

    这篇文章主要介绍了详解JDK中ExecutorService与Callable和Future对线程的支持的相关资料,希望通过本文能帮助到大家，需要的朋友可以参考下
    2017-09-09
  • 浅谈Java常见的排序算法

    浅谈Java常见的排序算法

    今天给大家带来的是关于Java的相关知识,文章围绕着Java常见的排序算法展开,文中有非常详细的介绍及代码示例,需要的朋友可以参考下
    2021-06-06

最新评论