JavaWeb 中 “轉發”與 “重定向”的區別

在這里插入圖片描述

每博一文案

人生的常態，就是有聚有散，有得有失，就像山峰一樣，總有高低，起伏不斷，
曾經，我們是鮮衣怒馬的少年，一日看盡長安花，
走著走著，漸漸明白生活并不都是盡心盡情的，萬事萬物都有力所不能及之處，此時我們能做的，就是看透，看清，看淡，
走著走著，愈發覺得孤獨是人生的常態，能遇到一個懂你的固然好，沒有也不必強求，
畢竟這個世界上，沒有真正的感同身受，
每個人心中都有一個角落，你走不進來，我也走不出去，它的用處，是用來安放疲憊的心靈，
網上有一條教人快樂的微博，內容是這樣的： "無法開心享受人生的人可以記下以下 4 點："
第一，人生沒辦法取消，出生在人世之后就無法重來，不好好享受就虧大了，
第二，今天不快樂并不代表明天也不快樂，
第三，只要有享受人生的意志，做出行動的勇氣，就一定可以好好的享受人生，若人生會因此變好的，沒關系的，
第四，感到不安，就睡吧，睡得飽飽的，
你看，快樂說到底，是要自己給自己的，即使沒有人陪，也要學會照顧好自己的心情，
畢竟人生這場迎來送往的修行，就是你送送別人，別人也送送你，大部分人只能陪你一程，不能陪你一生，

                              ——————   《一禪心靈廟語》

JavaWeb 中 “轉發”與 “重定向”的區別
- 每博一文案
- 1. Forward 轉發
- 2. Redirect重定向
- 3. 轉發使用不當的危害：轉發重繪問題
- 4. 轉發與重定向的區別
- 5. “重寫向”與“轉發”的合理選擇
- 6. 總結：
- 7. 最后：

在一個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");的跳轉路徑是需要寫明專案名的 ，
注意：轉發機制存在的一個重繪問題，
轉發與重定向的區別

7. 最后：

限于自身水平，其中存在的錯誤，希望大家，給予指教，韓信點兵——多多益善，謝謝大家，江湖再見，后會有期！！！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/549606.html

標籤：Java

上一篇：Java入門5（多型）

下一篇：day06-SpringCloud Ribbon

JavaWeb 中 “轉發”與 “重定向”的區別

JavaWeb 中 “轉發”與 “重定向”的區別

每博一文案

1. Forward 轉發

2. Redirect重定向

3. 轉發使用不當的危害：轉發重繪問題

4. 轉發 與 重定向的區別

5. “重寫向”與“轉發”的合理選擇

6. 總結：

7. 最后：

4. 轉發與重定向的區別