JavaWeb 中 “转发”与 “重定向”的区别

JavaWeb 中 “转发”与 “重定向”的区别


每博一文案

1. 人生的常态，就是有聚有散，有得有失，就像山峰一样，总有高低，起伏不断。
2. 曾经，我们是鲜衣怒马的少年，一日看尽长安花。
3. 走着走着，渐渐明白生活并不都是尽心尽情的，万事万物都有力所不能及之处。此时我们能做的，就是看透，看清，看淡。
4. 走着走着，愈发觉得孤独是人生的常态，能遇到一个懂你的固然好，没有也不必强求。
5. 毕竟这个世界上，没有真正的感同身受。
6. 每个人心中都有一个角落，你走不进来，我也走不出去，它的用处，是用来安放疲惫的心灵。
7. 网上有一条教人快乐的微博，内容是这样的： "无法开心享受人生的人可以记下以下 4 点："
8. 第一，人生没办法取消。出生在人世之后就无法重来，不好好享受就亏大了。
9. 第二，今天不快乐并不代表明天也不快乐。
10. 第三，只要有享受人生的意志，做出行动的勇气，就一定可以好好的享受人生。若人生会因此变好的，没关系的。
11. 第四，感到不安，就睡吧，睡得饱饱的。
12. 你看，快乐说到底，是要自己给自己的，即使没有人陪，也要学会照顾好自己的心情。
13. 毕竟人生这场迎来送往的修行，就是你送送别人，别人也送送你，大部分人只能陪你一程，不能陪你一生。
15.                               ——————   《一禅心灵庙语》

复制代码

@
目录

• JavaWeb 中 “转发”与 “重定向”的区别
  
  
  
  • 每博一文案
    
  • 1. Forward 转发
    
  • 2. Redirect重定向
    
  • 3. 转发使用不当的危害：转发刷新问题
    
  • 4. 转发 与 重定向的区别
    
  • 5. “重写向”与“转发”的合理选择
    
  • 6. 总结：
    
  • 7. 最后：
    
  
  

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

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

1. Forward 转发

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

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

复制代码

注意： 因为转发是服务器内部的进行的，所以 request.getRequestDispatcher(/不要项目名的).forward(request, response);编写的转发路径是不要加项目名的。
举例： 浏览器向 AServlet 发送请求，AServlet 将该请求 “转发”给了 BServlet。但是前端的浏览器并不知道该请求被 BServlet 处理了，浏览器的地址栏上显示的还是发送给 AServlet 请求的路径信息。

1. package com.RainbowSea.servlet;
3. import jakarta.servlet.ServletException;
4. import jakarta.servlet.http.HttpServlet;
5. import jakarta.servlet.http.HttpServletRequest;
6. import jakarta.servlet.http.HttpServletResponse;
8. import java.io.IOException;
10. public class AServlet extends HttpServlet {
11.     // 地址栏上回车操作是 doGet()请求
12.     @Override
13.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
14.             IOException {
16.         // 转发到 BServlet，转发的路径不要加项目名
17.         request.getRequestDispatcher("/b").forward(request, response);
19.     }
20. }

复制代码

1. package com.RainbowSea.servlet;
3. import jakarta.servlet.ServletException;
4. import jakarta.servlet.http.HttpServlet;
5. import jakarta.servlet.http.HttpServletRequest;
6. import jakarta.servlet.http.HttpServletResponse;
8. import java.io.IOException;
9. import java.io.PrintWriter;
11. public class BServlet extends HttpServlet {
12.     @Override
13.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
14.             IOException {
16.         // 设置浏览器端显示响应的，格式类型，以及字符集
17.         response.setContentType("text/html;charSet=UTF-8");
18.         PrintWriter writer = response.getWriter();
20.         writer.println("<h2> 这里是BServlet 的响应处理 </h2>");
22.     }
23. }

复制代码

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

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

1. package com.RainbowSea.servlet;
3. import javax.servlet.RequestDispatcher;
4. import javax.servlet.ServletException;
5. import javax.servlet.http.HttpServlet;
6. import javax.servlet.http.HttpServletRequest;
7. import javax.servlet.http.HttpServletResponse;
8. import java.io.IOException;
9. import java.util.Date;
11. public class AServlet extends HttpServlet {
12.     @Override
13.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
14.             IOException {
15.         // 设置，在浏览器上响应的格式类型
16.         Date nowTime = new Date();  // 创建当前时间的 Date 对象
18.         // 将 nowTime 的数据存储(绑定)到请求域当中
19.         request.setAttribute("sysTime",nowTime);
21.         // 第一步: 获取到转发对象，注意：/ 开始，不家项目名 , / + 对应跳转的 Servlet 当中的 web.xml 当中的url映射的路径
22.         RequestDispatcher requestDispatcher = request.getRequestDispatcher("/B");
24.         // 第二步: 调用转发器的forward方法完成跳转/转发
25.         requestDispatcher.forward(request,response);
30.     }
31. }

复制代码

1. package com.RainbowSea.servlet;
3. import javax.servlet.ServletException;
4. import javax.servlet.http.HttpServlet;
5. import javax.servlet.http.HttpServletRequest;
6. import javax.servlet.http.HttpServletResponse;
7. import java.io.IOException;
8. import java.io.PrintWriter;
10. public class BServlet extends HttpServlet {
11.     @Override
12.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
13.             IOException {
15.         // 设置，在浏览器上响应的格式类型
16.         response.setContentType("text/html;charSet=utf-8");
17.         PrintWriter writer = response.getWriter();
19.         // 取出请求域当中的数据: 这里的name值与上面setAttribute(String name,Object obj) 保持一致。
20.         Object sysTime = request.getAttribute("sysTime");
22.         writer.println("sysTime = " + sysTime);  // 显示到浏览器页面当中的数据
23.     }
24. }

复制代码

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

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

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

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

复制代码

2. Redirect重定向

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

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

复制代码

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

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

复制代码

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

1. package com.RainbowSea.servlet;
3. import jakarta.servlet.ServletException;
4. import jakarta.servlet.http.HttpServlet;
5. import jakarta.servlet.http.HttpServletRequest;
6. import jakarta.servlet.http.HttpServletResponse;
8. import java.io.IOException;
10. public class AServlet extends HttpServlet {
11.     @Override
12.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
13.             IOException {
15.         // 重定向的路径 需要加项目名
16.         response.sendRedirect("/servlet12/b");
17.         // 可以使用 request.getContextPath() 获取到项目名(也就是项目名的根路径)，注意该返回的路径是带 “/”的 /项目名
18.         // 所以不要多写了 “/”
19.         // response.sendRedirect(request.getContextPath()+"/b");
23.     }
24. }

复制代码

1. package com.RainbowSea.servlet;
3. import jakarta.servlet.ServletException;
4. import jakarta.servlet.http.HttpServlet;
5. import jakarta.servlet.http.HttpServletRequest;
6. import jakarta.servlet.http.HttpServletResponse;
8. import java.io.IOException;
9. import java.io.PrintWriter;
11. public class BServlet extends HttpServlet {
12.     @Override
13.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
14.             IOException {
16.         // 设置浏览器端显示响应的，格式类型，以及字符集
17.         response.setContentType("text/html;charSet=UTF-8");
18.         PrintWriter writer = response.getWriter();
20.         writer.println("<h2> 这里是BServlet 的响应处理 </h2>");
22.     }
23. }

复制代码

1. // 重定向： (重新定方向)
2. //response.sendRedirect("/项目名/");
3. // 重定向时的路径当中需要以项目名开始，或者说需要添加项目名的
4. // 因为所谓的重定向是将新的路径交给浏览器的地址栏上，然后自动执行的，而前端的信息获取是需要指明项目名的
5. // response对将这个路径: /servlet10/B 响应给了浏览器了。
6. // 浏览器又自发的向服务器发送了一个全新的请求: http://127.0.0.1:8080/servlet12/a
7. // 所以浏览器一共发送了 "两次"请求:
8. // 第一次请求: http://127.0.0.1:8080/servlet12/a
9. // 第二次请求: http://127.0.0.1:8080/servlet12/b
10. // 最终浏览器地址栏上显示的地址信息当然就是最后那一次请求的地址，所以重定向会导致浏览器
11. // 地址栏上的地址发生改变。
12. // 但是重定向是一次新的请求，是无法获取到请求域当中（只在一次请求中有效）信息的
13. // 重定向操作是由：跳转到哪个资源，是由浏览器的地址栏说的算的。
14. // 注意: request.getContextPath()返回的项目名的根路径是带有了 "/"了的
15. response.sendRedirect(request.getContextPath()+"/B");

复制代码

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

注意：重定向是“重定向几次，就会发送几次请求，导致的结果就是，重定向无法使用 请求域，因为请求域的作用范围是再一次请求当中的，重定向无法实现 Servlet 之间的数据共享。
举例如下：定义了一个 名为 User 类的JavaBean，在 AServlet 当中 new 一个 User 对象，并存储到AServlet请求域当中，存储好以后，重定向给 BServlet ，在BServlet 当中想将存储到 AServlet 请求域当中的数据取出来，这是不行的，因为请求域只在一次请求中有效，而这里重定向了一次，就会多一次请求也就是两次请求。无法获取到AServlet 请求域当的存储的数据。

1. package com.RainbowSea.servlet;
3. import java.io.Serializable;
4. import java.util.Objects;
7. /**
8. * 1. 一个普通的Javabean
9. * 2. 什么是javabean
10. * Java是咖啡，bean 是豆子
11. * javabean 咖啡豆
12. * 咖啡是由咖啡豆研磨而成的，寓意:是Java程序是由一个一个的javabean组成的
13. * 3. 一个javaBean一般是有规范的
14. *     有无参数的构造方法
15. *     属性私有化
16. *     对外提供 get/set()方法
17. *     重写toString()
18. *     重写hashCode() + equals
19. *     实现java.io.Serializable 接口 可序列化的
20. */
21. public class User implements Serializable {
22.     private String id;
23.     private String name;
25.     @Override
26.     public boolean equals(Object o) {
27.         if (this == o) return true;
28.         if (!(o instanceof User)) return false;
29.         User user = (User) o;
30.         return Objects.equals(getId(), user.getId()) && Objects.equals(getName(), user.getName());
31.     }
33.     @Override
34.     public int hashCode() {
35.         return Objects.hash(getId(), getName());
36.     }
38.     public User() {
40.     }
42.     public User(String id, String name) {
43.         this.id = id;
44.         this.name = name;
45.     }
47.     public String getId() {
48.         return id;
49.     }
51.     public void setId(String id) {
52.         this.id = id;
53.     }
55.     public String getName() {
56.         return name;
57.     }
59.     public void setName(String name) {
60.         this.name = name;
61.     }
63.     @Override
64.     public String toString() {
65.         return "User{" +
66.                 "id='" + id + '\'' +
67.                 ", name='" + name + '\'' +
68.                 '}';
69.     }
70. }

复制代码

1. package com.RainbowSea.servlet;
3. import jakarta.servlet.ServletException;
4. import jakarta.servlet.http.HttpServlet;
5. import jakarta.servlet.http.HttpServletRequest;
6. import jakarta.servlet.http.HttpServletResponse;
8. import java.io.IOException;
10. public class AServlet extends HttpServlet {
11.     @Override
12.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
13.             IOException {
15.         // 创建 User 对象
16.         User user = new User("001","张三");
18.         // 将 user 对象存储到 请求域当中
19.         request.setAttribute("userObj",user);
21.         // 重定向的路径 需要加项目名
22.         response.sendRedirect("/servlet12/b");
23.         // 可以使用 request.getContextPath() 获取到项目名(也就是项目名的根路径)，注意该返回的路径是带 “/”的 /项目名
24.         // 所以不要多写了 “/”
25.         // response.sendRedirect(request.getContextPath()+"/b");
29.     }
30. }

复制代码

1. package com.RainbowSea.servlet;
3. import jakarta.servlet.ServletException;
4. import jakarta.servlet.http.HttpServlet;
5. import jakarta.servlet.http.HttpServletRequest;
6. import jakarta.servlet.http.HttpServletResponse;
8. import java.io.IOException;
9. import java.io.PrintWriter;
11. public class BServlet extends HttpServlet {
12.     @Override
13.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
14.             IOException {
16.         // 无法取出 AServlet 请求域当中的数据
17.         Object userObj = request.getAttribute("userObj");
19.         // 设置浏览器端显示响应的，格式类型，以及字符集
20.         response.setContentType("text/html;charSet=UTF-8");
21.         PrintWriter writer = response.getWriter();
23.         writer.println("从AServlet 获取的数据：" + userObj);
25.     }
26. }

复制代码

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

1. package com.RainbowSea.servlet;
3. import jakarta.servlet.ServletException;
4. import jakarta.servlet.http.HttpServlet;
5. import jakarta.servlet.http.HttpServletRequest;
6. import jakarta.servlet.http.HttpServletResponse;
8. import java.io.IOException;
10. public class AServlet extends HttpServlet {
11.     @Override
12.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
13.             IOException {
15.         // 重定向一个名为 index.html 的资源
16.         // request.getContextPath() 返回的是该webapp的项目的根路径：也就是/项目名，注意是带 “/”的，不要多写了
17.         response.sendRedirect(request.getContextPath()+"/index.html");
18.         
20.     }
21. }

复制代码

1. <!DOCTYPE html>
2. <html lang="en">
3. <head>
4.     <meta charset="UTF-8">
5.     <title>index</title>
6. </head>
7. <body>
8.   <h1>Hello World</h1>
9.   <h1>你好世界</h1>
11. </body>
12. </html>

复制代码

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

说明： 由于转发的机制的特点：无论转发了服务器内部 转发 多少次，浏览器都视为是请求了一次，而且还是原来（最初的那一次请求，不是转发之后到的页面的请求）。这样的特征，如果使用不当的话，就会存在 一个刷新问题：就是你服务器内部虽然发送了转发性质的跳转到了一个新的页面，服务器内部转发到一个新的页面成功后，你在浏览器端重新刷新的话，还是对最初的一个URL请求刷新的（因为转发是不会改变浏览器地址栏上的 URL 地址的）。
举例： 我们在 StudentServlet 中执行向数据库的一张名为 studnet 表插入一条记录的操作。插入成功跳转到一个名为 succeed.html的页面，插入失败跳转到一个名为  error.html失败的页面。然后我们对跳转到 succeed.html* 页面后，在浏览器 执行刷新 操作看看会导致一个什么样的结果 ？
准备工作： 创建一个数据表，并插入一些数据

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

复制代码

1. package com.RainbowSea.servlet;
3. import com.RainbowSea.DBUtil.DBUtil;
4. import jakarta.servlet.ServletException;
5. import jakarta.servlet.http.HttpServlet;
6. import jakarta.servlet.http.HttpServletRequest;
7. import jakarta.servlet.http.HttpServletResponse;
9. import java.io.IOException;
10. import java.sql.Connection;
11. import java.sql.PreparedStatement;
12. import java.sql.SQLException;
14. public class StudentServlet extends HttpServlet {
17.     @Override
18.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
19.             IOException {
21.         /*
22.         思路： 获取到前端的提交的数据
23.         连接数据库，操作数据库
24.          */
25.         // 获取到前端提交的数据
26.         request.setCharacterEncoding("UTF-8");
27.         String no = request.getParameter("no");
28.         String name = request.getParameter("name");
29.         Connection connection = null;
30.         PreparedStatement preparedStatement = null;
31.         // 表示影响数据库的行数
32.         int count = 0;
34.         try {
35.             // 1. 连接数据库,这里的DBUtil.getConnection(); 是我写的一个连接数据库的工具类，大家不用太在意
36.             connection = DBUtil.getConnection();
38.             // 2. 获取操作数据库对象，预编译sql语句，注意测试sql是否存在错误
39.             // 注意： ? 不要加 '', ""单双引号，不然无法识别到该占位符的
40.             String sql = "INSERT INTO studnet (`no`,`name`) VALUES(?,?)";
41.             preparedStatement = connection.prepareStatement(sql);
43.             // 3. 填充占位符，真正执行sql语句
44.             preparedStatement.setString(1,no);
45.             preparedStatement.setString(2,name);
47.             count = preparedStatement.executeUpdate();
48.         } catch (SQLException e) {
49.             throw new RuntimeException(e);
50.         } finally {
51.             // 4. 释放资源
52.             DBUtil.close(connection,preparedStatement,null);
53.         }
55.         if(count == 1) {
56.             // 添加成功
57.             // 先用 转发机制 ,转发服务器内部，不要加项目名
58.             request.getRequestDispatcher("/succeed.html").forward(request,response);
59.         } else {
60.             request.getRequestDispatcher("/error.html").forward(request,response);
61.         }
62.     }
63. }

复制代码

1. <!DOCTYPE html>
2. <html lang="en">
3. <head>
4.     <meta charset="UTF-8">
5.     <title>添加成功</title>
6. </head>
7. <body>
8.   <h1>添加成功</h1>
10. </body>
11. </html>

复制代码

1. <!DOCTYPE html>
2. <html lang="en">
3. <head>
4.     <meta charset="UTF-8">
5.     <title>添加失败</title>
6. </head>
7. <body>
9.   <h1>添加失败</h1>
11. </body>
12. </html>

复制代码

实验效果如下：


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

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

1. package com.RainbowSea.servlet;
3. import com.RainbowSea.DBUtil.DBUtil;
4. import jakarta.servlet.ServletException;
5. import jakarta.servlet.http.HttpServlet;
6. import jakarta.servlet.http.HttpServletRequest;
7. import jakarta.servlet.http.HttpServletResponse;
9. import java.io.IOException;
10. import java.sql.Connection;
11. import java.sql.PreparedStatement;
12. import java.sql.SQLException;
14. public class StudentServlet extends HttpServlet {
17.     @Override
18.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
19.             IOException {
21.         /*
22.         思路： 获取到前端的提交的数据
23.         连接数据库，操作数据库
24.          */
25.         // 获取到前端提交的数据
26.         request.setCharacterEncoding("UTF-8");
27.         String no = request.getParameter("no");
28.         String name = request.getParameter("name");
29.         Connection connection = null;
30.         PreparedStatement preparedStatement = null;
31.         // 表示影响数据库的行数
32.         int count = 0;
34.         try {
35.             // 连接数据库
36.             connection = DBUtil.getConnection();
38.             // 注意： ? 不要加 '', ""单双引号，不然无法识别到该占位符的
39.             String sql = "INSERT INTO studnet (`no`,`name`) VALUES(?,?)";
40.             preparedStatement = connection.prepareStatement(sql);
42.             preparedStatement.setString(1,no);
43.             preparedStatement.setString(2,name);
45.             count = preparedStatement.executeUpdate();
46.         } catch (SQLException e) {
47.             throw new RuntimeException(e);
48.         } finally {
49.             // 释放资源
50.             DBUtil.close(connection,preparedStatement,null);
51.         }
53.         if(count == 1) {
54.             // 添加成功
55.             // 先用 转发机制 ,转发服务器内部，不要加项目名
56.             // request.getRequestDispatcher("/succeed.html").forward(request,response);
58.             // 优化修改为重定向：重定向前端需要指明 项目名(/项目的根路径)
59.             // request.getContextPath() 该方法可以获取到: "/项目的根路径"，注意是带有 / 的，所以不要多写了 /
60.             response.sendRedirect(request.getContextPath()+"/succeed.html");
61.         } else {
62.             // request.getRequestDispatcher("/error.html").forward(request,response);
63.             response.sendRedirect(request.getContextPath()+"/error.html");
64.         }
65.     }
66. }

复制代码

4. 转发 与 重定向的区别

• 代码上的区别：
  

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

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

复制代码

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

1. response.sendRedirect("/servlet12/b");
2. // 可以使用 request.getContextPath() 获取到项目名(也就是项目名的根路径)，注意该返回的路径是带 “/”的 /项目名，所以不要多写了 “/”
3. 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. 最后：

限于自身水平，其中存在的错误，希望大家，给予指教，韩信点兵——多多益善，谢谢大家，江湖再见，后会有期！！！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！