B/S结构系统的会话机制(session)

B/S结构系统的会话机制(session)



目录

• B/S结构系统的会话机制(session)
  
  
  
  • 每博一文案
    
  • 1. session 会话机制的概述
    
  • 2. 什么是 session 的会话
    
  • 3. session 的作用
    
  • 4. session 的实现原理解释
    
  • 5. 补充： Cookie禁用了，session还能找到吗 ？
    
  • 6. 总结一下到目前位置我们所了解的域对象：
    
  • 7. oa 项目的优化体验：使用上 session 会话机制：
    
  • 8. 总结:
    
  • 9. 最后：
    
  
  

每博一文案

1. 你跑得快，22岁有个家，身边全是赞叹，你跑得慢，30岁还在路上追求梦想。有的人为了车，房拼了一辈子，
2. 有的人买辆摩托车走遍了大好江山。你想成为怎样的人，过怎样的生活，只要你不后悔就行。
3. 并不是所有人都能在早上七点钟起床的，也别拿一碗饭来衡量一个人的胃口的大小。
4. 有的人喜欢狼吞虎咽，有的人喜欢细嚼慢咽，允许别人做，别人允许自己做自己。
5. 一岁有一岁的味道，跟着自己的心就好。不是所有选择都要做正确的选项的，只要你想，你可以选择
6. 你喜欢的选项。沿途的花会一直开，以后的路也是，祝你祝我。

复制代码

1. session 会话机制的概述

在Web应用程序中，我们经常要跟踪用户身份。当一个用户登录成功后，如果他继续访问其他页面，Web程序如何才能识别出该用户身份？
因为HTTP协议是一个无状态协议，即Web应用程序无法区分收到的两个HTTP请求是否是同一个浏览器发出的。为了跟踪用户状态，服务器可以向浏览器分配一个唯一ID，并以Cookie的形式发送到浏览器，浏览器在后续访问时总是附带此Cookie，这样，服务器就可以识别用户身份。
我们把这种基于唯一ID识别用户身份的机制称为Session。每个用户第一次访问服务器后，会自动获得一个Session ID。如果用户在一段时间内没有访问服务器，那么Session会自动失效，下次即使带着上次分配的Session ID访问，服务器也认为这是一个新用户，会分配新的Session ID。
2. 什么是 session 的会话

会话对应的英语单词：session
当用户打开浏览器，进行一系列操作，然后最终将浏览器关闭，这个整个过程叫做：一次会话。会话在服务器端也有一个对应的java对象，这个java对象叫做：session。
什么是一次请求：用户在浏览器上点击了一下，然后到页面停下来，可以粗略认为是一次请求。请求对应的服务器端的java对象是：request。 这里提前透露一点后面的内容： session 对象是用服务器端生成的，所以这里是通过 request 请求的方式向服务器获取到一个 session 会话对象

• 一个会话当中包含多次请求（一次会话对应N次请求。）
  

这里我们可以打印显示我们的 session 地址信息

1. package com.RainbowSea.session;
3. import jakarta.servlet.ServletException;
4. import jakarta.servlet.annotation.WebServlet;
5. import jakarta.servlet.http.HttpServlet;
6. import jakarta.servlet.http.HttpServletRequest;
7. import jakarta.servlet.http.HttpServletResponse;
8. import jakarta.servlet.http.HttpSession;
10. import java.io.IOException;
11. import java.io.PrintWriter;
14. @WebServlet("/session")
15. public class TestSessionServlet extends HttpServlet {
17.     @Override
18.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
19.             IOException {
21.         HttpSession session = request.getSession();
23.         response.setContentType("text/html;charSet=UTF-8");
24.         PrintWriter out = response.getWriter();
26.         out.println(" session对象:  " + session);
28.     }
29. }

复制代码

从 session 对象当中存在于: org.apache.catalina.session.StandardSession 的位置。
在Java的servlet 的规范当中，session 对应的类名为： HttpSession(jarkata.servlett.http.HttpSession) 。

注意：
sessioin 机制属于 B/S结构的一部分。如果使用php语言开发WEB项目，同样也是有session这种机制的。session机制实际上是一个规范。然后不同的语言对这种会话机制都有实现。
获取 sessoin 的对象方法：

1. // 注意: sessio 是存储在服务器端的，所以我们这里使用的是 request 请求的方式，向服务器请求获取到 session 对象
3. // 该访问获取到 session 对象，如果服务器端没有 session 对象会自动创建出  session 对象
4. HttpSession session = request.getSession();
5.         
6. // 获取到 session 对象，(参数为 false )表示：如果服务器当中没有 session 是不会自动创建的。
7. HttpSession session1 = request.getSession(false);

复制代码

3. session 的作用

session对象最主要的作用是：保存会话状态。（用户登录成功了，这是一种登录成功的状态，你怎么把登录成功的状态一直保存下来呢？使用session对象可以保留会话状态。）
那我们为什么需要session 对象来保存会话状态呢？

因为HTTP协议是一种无状态协议。
什么是无状态：请求的时候，B和S是连接的，但是请求结束之后，连接就断了。为什么要这么做？HTTP协议为什么要设计成这样？因为这样的无状态协议，可以降低服务器的压力。请求的瞬间是连接的，请求结束之后，连接断开，这样服务器压力小。
只要B和S断开了，那么关闭浏览器这个动作，服务器知道吗？
因为 HTTP 协议是无状态的连接的，所以当我们关闭了 浏览器的时候，我们的服务器端是无法接收到浏览器被关闭的一个信息的。所以：我们的服务器自然也就无法知道浏览器关闭了。

一个会话对应一个 sessoin 对象，一个 session 对应上一个 ID也就是 (JSESSIONID) 。
比如：张三打开一个浏览器 A，李四打开一个浏览器B，访问服务器之后，在服务端会生成：

• 张三专属的session对象，同时会标记上一个 对应的 ID 信息
  
• 李四专属的session对象 ，同时会标记上一个对应的 ID 信息。
  
• 注意了：这两者之间的 ID信息是不一样的。
  

代码举例：

1. package com.RainbowSea.serssion;
3. import jakarta.servlet.ServletException;
4. import jakarta.servlet.annotation.WebServlet;
5. import jakarta.servlet.http.HttpServlet;
6. import jakarta.servlet.http.HttpServletRequest;
7. import jakarta.servlet.http.HttpServletResponse;
8. import jakarta.servlet.http.HttpSession;
10. import java.io.IOException;
11. import java.io.PrintWriter;
13. @WebServlet("/test/session")
14. public class TestSessionServlet extends HttpServlet {
16.     @Override
17.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
18.             IOException {
20.         // request 和 session 都是在服务端的java对象，都在JVM当中
21.         // request对象代表一次请求，(一次请求对应一个request对象，再次请求就会对应两个不同的request对象)
22.         // session对象代表一次会话，（一次会话对应一个session 对象）
23.         // 获取session，如何服务器当中没有 session 对象就会自动创建一个，
24.         HttpSession session = request.getSession();
25.         // 获取到服务器端的 session ，如果没有不会自动创建 session 对象
26.         //HttpSession session1 = request.getSession(false);
28.         //session.setAttribute(); 将数据存储到 session 会话当中。
29.         //session.getAttribute() 将数据从 session 会话当中取出
34.         // 将session 对象响应到浏览器端
35.         response.setContentType("text/html;charset=UTF-8");
36.         PrintWriter out = response.getWriter();
37.         out.println("会话对象：" + session);
41.     }
42. }

复制代码

结果：



什么表示一个会话

粗略的可以认为一个：当我们打开一个浏览器访问一个A服务器的时候，如果这个浏览器不关闭的情况下，该浏览器发送的请求都是向 A服务器，那么哪个浏览器发送对于这个A服务器发送的所有的请求都可以理解为是一个 session 会话。
我们也可以再精细一点的再说一下：就是我们在京东网站，A用户登录以后，在京东网站当中的，进行查询商品，购买商品，添加商品购物车，等等，都是属于该 A用户专属的一个 session 的会话，当我们再在京东网站当中，B用户登录以后，在京东网站当中的，进行查询商品，购买商品，添加商品购物车，等等这些是 B用户请求操作的都是专属于一个 session 会话。

为什么不使用request对象保存会话状态？为什么不使用ServletContext对象保存会话状态？

• request.setAttribute()存数据，request.getAttribute()取数据，ServletContext也有这个方法。request是请求域。ServletContext是应用域。
  
• request是一次请求一个对象。
  
• ServletContext对象是服务器启动的时候创建，服务器关闭的时候销毁，这个ServletContext对象只有一个。
  
• ServletContext对象的域太大。
  
• request请求域（HttpServletRequest）、session会话域（HttpSession）、application应用域（ServletContext）
  
• 三个域之间的作用域的大小关系：request (请求域)< session(会话域) < application（应用域） 。
  

4. session 的实现原理解释

1. HttpSession session = request.getSession();

复制代码

这行代码很神奇。张三访问的时候获取的  session 对象就是张三专属的。李四访问的时候获取的 session 对象就是李四专属的。
这是如何做到的呢？我们可以举一个有关于我们实际生活当中的一个例子：

比如： 我们张三，李四都是在同一个大学的班级当中，张三和李四上的都是同一个篮球课(体育课)，当他们上课的时候
，他们的体育老师带来了（一筐篮球）(就是 session )，让同学们自行挑选好自己的篮球，用于上篮球课。这时候我们的张三认真的挑选到了一个篮球，并且试了试手感，感觉十分的不错。心里就有了一点小心思：就是想要，自己每次上篮球课的时候，都可以找到，并拿到这个手感不错的篮球。怎么实现这个想法呢？于是，张三同学就在，这个他手中的(手感不错)篮球上做了一个标记（SESSIONID=xxxxxx）。这个标记只有张三自己知道是干什么的，其他同学都不知道。这样当下次以后的每一节篮球课，张三都可以根据自己所作的这个标记，从众多篮球当中，找到这个，自己标记到的篮球了。
这个例子当中的： 一筐篮球就可以比作是 ： 服务器的当中的 session 会话对象，而其中的 张三自己在篮球上作的标记就可以比作是:  SESSIONID=xxxxxx 是 session 对象的 ID 了。

session 生成的过程：
一个 session 会话对象 对应一个  JSESSIONID=xxxxxx (就是一个标记 session 会话对象的 ID （类似于一个人的身份证信息）是唯一的)。
服务器当中是有一个类似于 Map 的一个 session 列表。该 session 列表当中存在两样东西： key 对应的是 JSESSIONID=xxxxxx (也就是 session 的ID的标记) ，而 value 对应的则是 session 对象。
key (session 的 ID)value ( session 对象)JSESSIONID=123session1JSESSIONID=456session2当用户第一次请求服务器的时候，服务器会为该用户生成一个 session 会话对象，同时服务器会将该 session 对应 JSESSIONID=123，也就是： sessionID 发送给客户端。客户端会接收到服务器发送过来的 JSESSIONID ,并存储到 客户端的缓存(Cookie) 当中。同时需要注意的是： JSESSIONID=xxxxxx  这个是以Cookie的形式保存在浏览器的内存中的。浏览器只要关闭。这个cookie就没有了。(当然这是默认的情况下，你是可以自定义设置的。关于 Cookie 的内容这里就不会说明了。)
举例：具体代码详细如下：

1. package com.RainbowSea.session;
3. import jakarta.servlet.ServletException;
4. import jakarta.servlet.annotation.WebServlet;
5. import jakarta.servlet.http.HttpServlet;
6. import jakarta.servlet.http.HttpServletRequest;
7. import jakarta.servlet.http.HttpServletResponse;
8. import jakarta.servlet.http.HttpSession;
10. import java.io.IOException;
11. import java.io.PrintWriter;
14. @WebServlet("/session")
15. public class TestSessionServlet extends HttpServlet {
17.     @Override
18.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
19.             IOException {
21.         HttpSession session = request.getSession();
23.         //
24.         response.setContentType("text/html;charSet=UTF-8");
25.         PrintWriter out = response.getWriter();
28.         //
29.         out.println(" session对象:  " + session);
31.     }
32. }

复制代码

如下是我们的浏览器(客户端) 向服务器 第一次 发送请求(response) 的效果图：如下：

第二次，我们的浏览器（客户端）向服务器发送 第二次请求(response) ，因为我们浏览器(客户端)第一次请求的时候，已经将服务器响应过来的  JSESSIONID   存储到了，自己客户端的 Cookie 当中去了。所以，当我们的客户端再次向上一个服务器发送请求的时候，这是同属于同一个会话的，所以我们的客户端将第一次请求的时候，获取到的 JSESSIONID  发送给 服务器，服务器根据 JSESSIONID   查找session对象。 返回给客户端，所以两者之间的 session 对象的地址是一样的，因为是同属于同一个会话的。测试效果如下：

注意：我们的浏览器是遵循 HTTP 协议的，而 HTTP 协议是 无状态的，导致我们的服务器无法知道浏览器关闭了，所以我们的 会话销毁存在一种（延迟销毁的机制：简单的说就是，当一个 session 会话，在一定的时间段内没有，任何的请求发发送了，服务器就会认为该 sessoin 没有用了，会自动销毁该 session 会话对象了），当我们关闭浏览器，内存消失，Cookie 消失，Cookie 消失了，那存在其中的  JSESSIONID （也就是 sessionID ） 自然也就消失了。而 JSESSIONID  消失了，我们的客户端也就无法根据该 JSESSIONID  获取到，访问到 对应的 session 对象了，当到达一定的时间段后，还是没有任何客户端访问该 Session 会话，服务器就会自动销毁该 session 会话对象了。
关闭浏览器，重新发送请求，测试效果如下图所示：

session对象的销毁：

session 对象是什么时候销毁：
浏览器关闭的时候，服务器是不知道的，服务器无法监测到浏览器关闭了（HTTP协议是无状态协议），所以 session 的销毁要依靠 session 超时机制，
但也有一种可能，系统提供了 “安全退出”，用户可以点击这个按钮，这样服务器就知道你退出了，然后服务器会自动销毁 session 对象。

• 第一种： 手动销毁
  

1. // 销毁 session 对象的
2. session.invalidate();

复制代码

• 第二种：自动销毁(超时销毁)
  

为什么关闭浏览器，会话结束？
关闭浏览器之后，浏览器中保存的 JSESSIONID （也就是 session 的ID）消失，下次重新打开浏览器之后，
浏览器缓存中没有这个 session的ID，自然找不到 服务器中对应的 session 对象，session 对象找不到，等同于会话结束。(超时销毁，当一个 session 一段时间内没有，被访问了，就会自动被服务器销毁，这里我们的 JSESSIONID 都没有了，我们就无法找到对应 session 的对象，无法找到 session 对象，就更无法访问了。)
session 超时销毁机制的设置的时间点，默认是 Tomcat apache-tomcat-10.0.12\conf\web.xml的 web.xml  配置当中，默认配置为了 30 分钟

1.     <session-config>
2.         <session-timeout>30</session-timeout>
3.     </session-config>

复制代码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sJQQVVaF-1682775113687)(E:\博客\javaWed博客库\image-20230424221802452.png)]
当然，这个 session 超时销毁的时间点，我们也是可以设置的。
我们可以根据自己的需要设置，比如：如果是一个银行的安全信息的话，可以设置为 1~5 分钟。如果是一个长久使用的话可以设置为 24 小时，7天等等。根据实际业务需要灵活的设置。

重点：如下是 session 的生成，销毁的原理图示:

5. 补充： Cookie禁用了，session还能找到吗 ？

cookie禁用是什么意思？服务器正常发送cookie给浏览器，但是浏览器不要了。拒收了。并不是服务器不发了。
如下是： Google Chrome 浏览器禁用 Cookie 的设置：


当我们禁用了浏览器的 Cookie 设置，再次访问我们的 Servlet 服务器的效果如下：

下面这个是 Firefox火狐浏览器的禁用 Cookie 的设置。




结论：当浏览器禁用了Cookie 缓存功能，服务器正常发送cookie信息(包括了 JSESSIONID 信息)给浏览器，但是浏览器不要了。拒收了，并不是服务器不发了。所以导致的结果就是：客户端不会发送给服务器 JSESSIONID信息了，找不到了，每一次请求都会获取到新的session对象。
问题：cookie禁用了，session机制还能实现吗？

可以，需要使用 URL 重写机制。
如下：演示：当我们访问服务器时，通过浏览器的 检查功能中的 ——> 网络(NetWork) 当中的第一次请求服务器，服务器响应给客户端的 JSESSIONID 的信息会显示在其中的：response headers (请求头当中 )。

将其中的 jsessionid=19D1C99560DCBF84839FA43D58F56E16 拼接到我们访问的 URL当中，中间使用 ; 分号隔开。如下：需要注意的是，将其中的 JSESSIONID 写成小写的： jsessionid

1. http://127.0.0.1:8080/servlet14/session;jsessionid=F247C2C5CBE489F45383D116224F071B

复制代码

原理：是虽然我们浏览器没有保存住服务器响应过来的JSESSIONID信息，但是我们手动将其中的SESSIOND给记住了，并通过地址栏的方式，get的方式发送给了服务器，服务器就会帮我们去session列表当中找到该对过的JSESSIONID的
session对象，而不是新建esssion对象了。

URL重写机制会提高开发者的成本。开发人员在编写任何请求路径的时候，后面都要添加一个sessionid，给开发带来了很大的难度，很大的成本。所以大部分的网站都是这样设计的：你要是禁用cookie，你就别用了。
怎么理解这个： 你要是禁用了 Cookie 缓存机制，你就别用了。就是说，如果你把 Cookie 禁用了一些网站你可能打不开来，或者说无法显示全部内容信息。当你开始这个设置 禁用Cookie 都会有一些提示的信息给到你的。比如：

。如下当我们把 Firefox火狐浏览器的禁用 Cookie 打开，访问

• 京东网站：https://www.jd.com/
  

• 访问淘宝：https://www.taobao.com/
  

• 访问唯品会：https://www.vip.com/
  

• 访问12306 网站：https://www.12306.cn/index/
  

6. 总结一下到目前位置我们所了解的域对象：

• request（对应的类名：HttpServletRequest）请求域（请求级别的）
  
• session（对应的类名：HttpSession）会话域（用户级别的）
  
• application（对应的类名：ServletContext）应用域（项目级别的，所有用户共享的。）
  
• 这三个域对象的大小关系：request < session < application
  
• 他们三个域对象都有以下三个公共的方法：
  
  
  
  • setAttribute（向域当中绑定数据）
    
  • getAttribute（从域当中获取数据）
    
  • removeAttribute（删除域当中的数据）
    
  
  
• 使用原则：尽量使用小的域。
  

7. oa 项目的优化体验：使用上 session 会话机制：

阅读如下内容，大家可以先移步至：Servlet注解的使用，简化配置 以及，使用模板方法设计模式优化oa项目_ChinaRainbowSea的博客-CSDN博客看看有助于阅读理解。
session掌握之后，我们怎么解决oa项目中的登录问题：就是我们的登录页面是一个摆设，当用户没有登录的情况下，可以直接通过在地址栏上输入 URL 可以访问到对应的资源信息。
这里我们可以使用： session 会话机制，让登录起作用：就是如果用户直接通过在地址栏上输入 URL 可以访问到对应的资源信息的时候，判断用户是否登录过，如果登录过，则可以直接访问。如果没有登录过就跳转到登录页面，进行一个正确的登录成功的操作，才可以访问。同时设置一个安全退出系统，销毁 session 对象的按钮设置。

登录成功之后，可以将用户的登录信息存储到session当中。也就是说session中如果有用户的信息就代表用户登录成功了。session中没有用户信息，表示用户没有登录过。则跳转到登录页面。

优化源码如下：
首先是登录页面的优化：当用户登录成功，将用户的登录信息存储到session当中(这里我们存储到用户的用户名信息。)
核心优化代码：

1. // 登录成功与否
2. if (success) {
4.    // 成功，跳转到用户列表页面
5.    // 这里使用重定向(没有资源的共享)：重定向需要加/项目名 +
7.    // 获取session 对象(这里的要求是： 必须获取到 session ,没有session 也要新建一个 session 对象)
8.    // 注意：我们下面的这个会话是不能删除的，因为上面我们虽然通过 welcome Servlet 进行了一个会话
9.    // 但是 welcome 当中是当我们cookie 当中存在并且用户名和密码正确的时候才会进行一个 session 的
10.    HttpSession session = request.getSession();  // 服务器当中没有 session 会话域自动创建
11.    session.setAttribute("username", username);  // 将用户名存储到 session 会话域当中
14.    response.sendRedirect(request.getContextPath() + "/dept/list");
15.    } else {
16.      // 失败，跳转到失败页面
17.      response.sendRedirect(request.getContextPath() + "/error.jsp");
18.    }

复制代码

全部的代码：

1. package com.RainbowSea.servlet;
3. import com.RainbowSea.DBUtil.DBUtil;
4. import jakarta.servlet.ServletException;
5. import jakarta.servlet.annotation.WebServlet;
6. import jakarta.servlet.http.HttpServlet;
7. import jakarta.servlet.http.HttpServletRequest;
8. import jakarta.servlet.http.HttpServletResponse;
9. import jakarta.servlet.http.HttpSession;
11. import java.io.IOException;
12. import java.sql.Connection;
13. import java.sql.PreparedStatement;
14. import java.sql.ResultSet;
15. import java.sql.SQLException;
18. @WebServlet({"/user/login", "/user/exit"})
19. public class UserServlet extends HttpServlet {
20.     @Override
21.     protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException,
22.             IOException {
24.         // 获取到浏览器地址栏上的URL路径
25.         String servletPath = request.getServletPath();
27.         if ("/user/login".equals(servletPath)) {
28.             doLogin(request, response);
29.         } else if ("/user/exit".equals(servletPath)) {
30.             doExit(request, response);
31.         }
34.     }
36.     private void doExit(HttpServletRequest request, HttpServletResponse response) throws IOException {
37.     }
39.     protected void doLogin(HttpServletRequest request, HttpServletResponse response) throws ServletException,
40.             IOException {
42.         // 一个用户登录验证的方式：验证用户名和密码是否正确
43.         // 获取用户名和密码
44.         // 前端提交是数据是：username=111&password=fads
45.         // 注意：post 提交的数据是在请求体当中，而get提交的数据是在请求行当中
47.         boolean success = false;  // 标识登录成功
49.         String username = request.getParameter("username");
50.         String password = request.getParameter("password");
52.         String exempt = request.getParameter("exempt");
54.         // 连接数据库验证用户名和密码
55.         Connection connection = null;
56.         PreparedStatement preparedStatement = null;
57.         ResultSet resultSet = null;
59.         try {
60.             // 1. 获取连接，注册驱动
61.             connection = DBUtil.getConnection();
63.             // 2. 获取操作数据对象，预编译sql语句, ? 占位符不要加，“”,'' 单双引号，成了字符串了，无法识别成占位符了。
64.             String sql = "select username,password from t_user where username = ? and password = ?";
65.             preparedStatement = connection.prepareStatement(sql);
67.             // 3. 填充占位符，真正执行sql语句
68.             preparedStatement.setString(1, username);
69.             preparedStatement.setString(2, password);
71.             resultSet = preparedStatement.executeQuery();
73.             // 4. 处理查询结果集
74.             // 只有一条结果集
75.             if (resultSet.next()) {
76.                 // 登录成功
77.                 success = true;
78.             }
79.         } catch (SQLException e) {
80.             throw new RuntimeException(e);
81.         } finally {
82.             // 5. 关闭资源，最后使用的最先关闭，
83.             DBUtil.close(connection, preparedStatement, resultSet);
84.         }
86.         // 登录成功与否
87.         if (success) {
88.             
89.             // 成功，跳转到用户列表页面
90.             // 这里使用重定向(没有资源的共享)：重定向需要加/项目名 +
92.             // 获取session 对象(这里的要求是： 必须获取到 session ,没有session 也要新建一个 session 对象)
93.             // 注意：我们下面的这个会话是不能删除的，因为上面我们虽然通过 welcome Servlet 进行了一个会话
94.             // 但是 welcome 当中是当我们cookie 当中存在并且用户名和密码正确的时候才会进行一个 session 的
95.             HttpSession session = request.getSession();  // 服务器当中没有 session 会话域自动创建
96.             session.setAttribute("username", username);  // 将用户名存储到 session 会话域当中
99.             response.sendRedirect(request.getContextPath() + "/dept/list");
100.         } else {
101.             // 失败，跳转到失败页面
102.             response.sendRedirect(request.getContextPath() + "/error.jsp");
103.         }
106.     }
107. }

复制代码

其次是当用户想要直接通过 URL访问的时候，判断用户是否登录成功过，登录成功过可以访问，没有登录成功过无法访问：
思路是：

我们通过 session 会话机制，判断用户是否登录过，如果用户没有登录就想要访问 到其信息，不可以，因为我们这里判断了一次是否登录过，只有登录入过了，才会将中登录到用户名为 “username” 的信息存储到 session 会话当中，如果没有的话是查询不到的，返回的是 null。需要注意的一点就是，我们的jsp 当中的内置对象，是会自动创建一个 session 会话对象的(所以就会导致，就算我们没有登录成功 ，session 对象也是不为空的，因为JSP创建了 session 对象，我们可以通过JSP 指令禁止 JSP 生成 session 内置对象 ，需要所有会被访问，生成的 Jsp 文件都需要设置该指令。这里 所谓的禁用了就是，对应的访问生成的 xxx_jsp.java） 当中不会翻译生成其中内置的 session 对象)，但是因为这里我们进行了一个 双重的判断机制。

1. if(session != null && session.getAttribute("username") != null)
2. // 双重的判断，一个是 session 会话域要存在，其次是 会话域当中存储了名为 "username" 的信息，可以用户登录的信息可以从 session 找到，如果找不到 ，返回 null ,找到不为 null 。这样就解决了 JSP 内置session 对象的没有登录 session 不为 null 的影响了。

复制代码

需要注意一点的就是：这里我们要使用HttpSession session = request.getSession(false)

1. HttpSession session = request.getSession(false);  // 获取到服务器当中的session ，没有不会创建的,
2. // session 是用户登录成功才创建的，其他情况不要创建 session 会话对象。

复制代码

核心代码：

1. // 可以使用模糊查询 @WebServlet("/dept/*")
2. @WebServlet({"/dept/list", "/dept/detail", "/dept/delete", "/dept/save", "/dept/modify"})
3. public class DeptServlet extends HttpServlet {
4.     @Override
5.     protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException,
6.             IOException {
8.         String servletPath = request.getServletPath();  // 获取到浏览器当中的uri
10.         // 获取session 这个 session 是不不需要新建的
11.         // 只是获取当前session ,获取不到这返回null,
12.         HttpSession session = request.getSession(false);  // 获取到服务器当中的session ，没有不会创建的
15.         /**
16.          * 说明这里我们通过 session 会话机制，判断用户是否登录过，如果用户没有登录就想要访问
17.          * 到其信息，不可以，因为我们这里判断了一次是否登录过，只有登录入过了，才会将中登录到
18.          * 用户名为 “username” 的信息存储到 session 会话当中，如果没有的话是查询不到的，返回的是 null
19.          * 需要注意的一点就是，我们的jsp 当中的内置对象，是会自动创建一个 session 会话对象的，但是
20.          * 因为这里我们进行了一个 双重的判断机制。注意：需要先将对应的 xx_jsp.java 生成才行。同时
21.          * 使用 <%@page session = false %> 指令的话，需要所有会被访问，生成的 Jsp 文件都需要设置。
22.          *
23.          *   jakarta.servlet.http.HttpSession session = null;
24.          *   session = pageContext.getSession();
25.          */
26.         if(session != null && session.getAttribute("username") != null) {
27.             // 双重的判断，一个是 session 会话域要存在，其次是 会话域当中存储了名为 "username" 的信息
28.             if ("/dept/list".equals(servletPath)) {
29.                 doList(request, response);
30.             } else if ("/dept/detail".equals(servletPath)) {
31.                 doDetail(request, response);
32.             } else if ("/dept/delete".equals(servletPath)) {
33.                 doElete(request,response);
34.             } else if("/dept/save".equals(servletPath)) {
35.                 doSave(request,response);
36.             } else if("/dept/modify".equals(servletPath)) {
37.                 doModify(request,response);
38.             }
39.         } else {
40.             response.sendRedirect(request.getContextPath());  // 访问的web 站点的根即可，自动找到的是名为 index.jsp
41.         }
43.     }
44. }

复制代码

最后就是：用户点击安全退出系统，销毁 session 对象的实现了。
当我们点击 安全退出，手动将 session 会话对象销毁了。就需要重新登录了。只有重新登录，建立新的登录成功的 session 会话信息，才能再次通过URL访问。
核心代码如下：

1. session.invalidate();  // 销毁 session 对象。

复制代码

1. /**
2. * 用户手动点击安全退出，销毁 session 对象
3. * @param request
4. * @param response
5. * @throws IOException
6. */
7. private void doExit(HttpServletRequest request, HttpServletResponse response) throws IOException {
8.         // 获取到客户端发送过来的 sessoin
9.         HttpSession session = request.getSession();
11.         if (session != null) {
12.             // 手动销毁 session 对象
13.             // 注意：会话销毁的了，自然需要重写登录了，没有登录过，无法进行一个路径的访问的
14.             session.invalidate();
15.             
16.             // 跳转会登录的页面
17.             response.sendRedirect(request.getContextPath());  // 项目名路径默认就是访问的index.html 的欢迎页面
18.         }
19.     }

复制代码

全部具体代码：

1. package com.RainbowSea.servlet;
3. import com.RainbowSea.DBUtil.DBUtil;
4. import com.RainbowSea.bean.Dept;
5. import jakarta.servlet.ServletException;
6. import jakarta.servlet.annotation.WebServlet;
7. import jakarta.servlet.http.HttpServlet;
8. import jakarta.servlet.http.HttpServletRequest;
9. import jakarta.servlet.http.HttpServletResponse;
10. import jakarta.servlet.http.HttpSession;
12. import java.io.IOException;
13. import java.sql.Connection;
14. import java.sql.PreparedStatement;
15. import java.sql.ResultSet;
16. import java.sql.SQLException;
17. import java.util.ArrayList;
18. import java.util.List;
20. // 可以使用模糊查询 @WebServlet("/dept/*")
21. @WebServlet({"/dept/list", "/dept/detail", "/dept/delete", "/dept/save", "/dept/modify"})
22. public class DeptServlet extends HttpServlet {
23.     @Override
24.     protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException,
25.             IOException {
27.         String servletPath = request.getServletPath();  // 获取到浏览器当中的uri
29.         // 获取session 这个 session 是不不需要新建的
30.         // 只是获取当前session ,获取不到这返回null,
31.         HttpSession session = request.getSession(false);  // 获取到服务器当中的session ，没有不会创建的
34.         /**
35.          * 说明这里我们通过 session 会话机制，判断用户是否登录过，如果用户没有登录就想要访问
36.          * 到其信息，不可以，因为我们这里判断了一次是否登录过，只有登录入过了，才会将中登录到
37.          * 用户名为 “username” 的信息存储到 session 会话当中，如果没有的话是查询不到的，返回的是 null
38.          * 需要注意的一点就是，我们的jsp 当中的内置对象，是会自动创建一个 session 会话对象的，但是
39.          * 因为这里我们进行了一个 双重的判断机制。注意：需要先将对应的 xx_jsp.java 生成才行。同时
40.          * 使用 <%@page session = false %> 指令的话，需要所有会被访问，生成的 Jsp 文件都需要设置。
41.          *
42.          *   jakarta.servlet.http.HttpSession session = null;
43.          *   session = pageContext.getSession();
44.          */
45.         if(session != null && session.getAttribute("username") != null) {
46.             // 双重的判断，一个是 session 会话域要存在，其次是 会话域当中存储了名为 "username" 的信息
47.             if ("/dept/list".equals(servletPath)) {
48.                 doList(request, response);
49.             } else if ("/dept/detail".equals(servletPath)) {
50.                 doDetail(request, response);
51.             } else if ("/dept/delete".equals(servletPath)) {
52.                 doElete(request,response);
53.             } else if("/dept/save".equals(servletPath)) {
54.                 doSave(request,response);
55.             } else if("/dept/modify".equals(servletPath)) {
56.                 doModify(request,response);
57.             }
58.         } else {
59.             response.sendRedirect(request.getContextPath());  // 访问的web 站点的根即可，自动找到的是名为 index.jsp
60.         }
62.     }
65.     /**
66.      * 修改部门信息
67.      *
68.      * @param request
69.      * @param response
70.      */
71.     private void doModify(HttpServletRequest request, HttpServletResponse response) throws IOException {
72.         request.setCharacterEncoding("UTF-8");  // 设置获取的的信息的编码集
73.         Connection connection = null;
74.         PreparedStatement preparedStatement = null;
75.         // 影响数据库的行数
76.         int count = 0;
79.         String deptno = request.getParameter("deptno");
80.         String dname = request.getParameter("dname");
81.         String loc = request.getParameter("loc");
84.         try {
85.             // 1. 注册驱动，连接数据库
86.             connection = DBUtil.getConnection();
88.             // 2. 获取到操作数据库的对象，预编译sql语句，sql测试
89.             String sql = "update dept set dname = ?,loc = ? where depton = ?";
90.             preparedStatement = connection.prepareStatement(sql);
92.             // 3. 填充占位符，真正执行sql语句
93.             // 从下标 1开始
94.             preparedStatement.setString(1, dname);
95.             preparedStatement.setString(2, loc);
96.             preparedStatement.setString(3, deptno);
98.             count = preparedStatement.executeUpdate();
99.         } catch (SQLException e) {
100.             throw new RuntimeException(e);
101.         } finally {
102.             // 4. 释放资源，最后使用的优先被释放
103.             DBUtil.close(connection, preparedStatement, null);
104.         }
106.         if (count == 1) {
107.             // 更新成功
108.             // 跳转到部门列表页面（部门列表表面是通过java程序动态生成的，所以还需要再次执行另一个Servlet）
109.             // 转发是服务器内部的操作，“/” 不要加项目名
110.             // request.getRequestDispatcher("/dept/list/").forward(request,response);
112.             // 优化使用重定向,自发前端(需要指明项目名)
113.             response.sendRedirect(request.getContextPath() + "/dept/list");
115.         }
116.     }
119.     /**
120.      * 保存部门信息
121.      *
122.      * @param request
123.      * @param response
124.      */
125.     private void doSave(HttpServletRequest request, HttpServletResponse response) throws IOException {
127.         request.setCharacterEncoding("UTF-8");
129.         // 获取到前端的数据，建议 name 使用复制
130.         String deptno = request.getParameter("deptno");
131.         String dname = request.getParameter("dname");
132.         String loc = request.getParameter("loc");
134.         // 连接数据库，添加数据
135.         Connection connection = null;
136.         PreparedStatement preparedStatement = null;
137.         // 影响数据库的行数
138.         int count = 0;
140.         try {
141.             // 1. 注册驱动，连接数据库
142.             connection = DBUtil.getConnection();
144.             // 2. 获取操作数据库对象，预编译sql语句，Sql测试
145.             String sql = "insert into dept(depton,dname,loc) values(?,?,?)";
146.             preparedStatement = connection.prepareStatement(sql);
148.             // 3. 填充占位符, 真正执行sql语句，
149.             // 注意： 占位符的填充是从 1 开始的，基本上数据库相关的起始下标索引都是从 1下标开始的
150.             preparedStatement.setString(1, deptno);
151.             preparedStatement.setString(2, dname);
152.             preparedStatement.setString(3, loc);
154.             // 返回影响数据库的行数
155.             count = preparedStatement.executeUpdate();
157.             // 5.释放资源
158.         } catch (SQLException e) {
159.             throw new RuntimeException(e);
160.         } finally {
161.             DBUtil.close(connection, preparedStatement, null);
162.         }
164.         // 保存成功，返回部门列表页面
165.         if (count == 1) {
166.             // 这里应该使用，重定向
167.             // 这里用的转发，是服务器内部的，不要加项目名
168.             //request.getRequestDispatcher("/dept/list/").forward(request, response);
170.             // 重定向
171.             response.sendRedirect(request.getContextPath() + "/dept/list");
172.         }
173.     }
176.     /**
177.      * 通过部门删除部门
178.      *
179.      * @param request
180.      * @param response
181.      */
182.     private void doElete(HttpServletRequest request, HttpServletResponse response) throws IOException {
184.         request.setCharacterEncoding("UTF-8");  // 设置获取的的信息的编码集
185.         // 获取到发送数据
186.         String deptno = request.getParameter("deptno");
188.          /*
189.         根据部门编号删除信息，
190.         删除成功，跳转回原来的部门列表页面
191.         删除失败，跳转删除失败的页面
192.          */
194.         Connection connection = null;
195.         PreparedStatement preparedStatement = null;
197.         // 记录删除数据库的行数
198.         int count = 0;
201.         // 连接数据库进行删除操作
203.         try {
204.             // 1.注册驱动，连接数据库
205.             connection = DBUtil.getConnection();
207.             // 开启事务（取消自动提交机制）,实现可回滚
208.             connection.setAutoCommit(false);
210.             // 2. 预编译sql语句,sql测试
211.             String sql = "delete from dept where depton = ?"; // ? 占位符
212.             preparedStatement = connection.prepareStatement(sql);
214.             // 3. 填充占位符，真正的执行sql语句
215.             preparedStatement.setString(1, deptno);
216.             // 返回影响数据库的行数
217.             count = preparedStatement.executeUpdate();
218.             connection.commit();  // 手动提交数据
219.         } catch (SQLException e) {
220.             // 遇到异常回滚
221.             if (connection != null) {
222.                 try {
223.                     // 事务的回滚
224.                     connection.rollback();
225.                 } catch (SQLException ex) {
226.                     throw new RuntimeException(ex);
227.                 }
228.             }
229.             throw new RuntimeException(e);
230.         } finally {
231.             // 4. 释放资源
232.             // 因为这里是删除数据，没有查询操作，所以 没有 ResultSet 可以传null
233.             DBUtil.close(connection, preparedStatement, null);
234.         }
236.         if (count == 1) {
237.             // 删除成功
238.             // 仍然跳转到部门列表页面
239.             // 部门列表页面的显示需要执行另外一个Servlet，怎么办，可以使用跳转，不过这里最后是使用重定向
240.             // 注意：转发是在服务器间的，所以不要加“项目名” 而是 / + web.xml 映射的路径即可
241.             //request.getRequestDispatcher("/dept/list/").forward(request,response);
243.             // 优化：使用重定向机制 注意: 重定向是自发到前端的地址栏上的，前端所以需要指明项目名
244.             // 注意: request.getContextPath() 返回的根路径是，包含了 "/" 的
245.             response.sendRedirect(request.getContextPath() + "/dept/list");
246.         }
247.     }
250.     /**
251.      * 通过部门编号，查询部门的详情
252.      *
253.      * @param request
254.      * @param response
255.      */
256.     private void doDetail(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
258.         request.setCharacterEncoding("UTF-8");  // 设置获取的的信息的编码集
260.         Connection connection = null;
261.         PreparedStatement preparedStatement = null;
262.         ResultSet resultSet = null;
263.         // 获取到部门编号
264.         String dno = request.getParameter("dno");
265.         Dept dept = new Dept();
267.         // 获取到部门编号，获取部门信息，将部门信息收集好，然后跳转到JSP做页面展示
270.         try {
271.             // 2. 连接数据库，根据部门编号查询数据库
272.             // 1.注册驱动，连接数据库
273.             connection = DBUtil.getConnection();
275.             // 2. 预编译SQL语句,sql要测试
276.             String sql = "select dname,loc from dept where depton = ?";  // ? 占位符
277.             preparedStatement = connection.prepareStatement(sql);
279.             // 3. 填充占位符,真正执行sql语句
280.             preparedStatement.setString(1, dno);
281.             resultSet = preparedStatement.executeQuery();
283.             // 4. 处理查询结果集
284.             while (resultSet.next()) {
285.                 String dname = resultSet.getString("dname");
286.                 String loc = resultSet.getString("loc");
288.                 // 封装对象(建议使用咖啡豆，因为只有一个对象)
289.                 dept.setDeptno(dno);
290.                 dept.setDname(dname);
291.                 dept.setLoc(loc);
292.             }
293.         } catch (SQLException e) {
294.             throw new RuntimeException(e);
295.         } finally {
296.             // 5. 释放资源
297.             DBUtil.close(connection, preparedStatement, resultSet);
298.         }
300.         // 这个咖啡豆只有一个，所以不需要袋子，只需要将这个咖啡豆放到request请求域当中，
301.         // 用于对应的 jsp显示
302.         request.setAttribute("dept", dept);
303.         //String sign = request.getParameter("f");
305.         /*if("m".equals(sign)) {
307.             // 转发：多个请求为一个请求(地址栏不会发生改变)
308.             // 注意: 该路径默认是从 web 开始找的 / 表示 web
309.             // 转发到修改页面
310.             request.getRequestDispatcher("/edit.jsp").forward(request,response);
311.         } else if("d".equals(sign)) {
312.             // 跳转到详情页面
313.             request.getRequestDispatcher("/detail.jsp").forward(request,response);
314.         }*/
316.         // 或者优化
317.         // 注意 无论是转发还是重定向都是从 “/” 开始的
318.         // request.getParameter()拿到的是 f=edit，还是f=detail 就是跳转到的哪个页面
319.         //<a target="_blank" href="https://www.cnblogs.com/<%=request.getContextPath()%>/dept/detail?f=edit&dno=<%=dept.getDeptno()%>">修改</a>
320.         //<a target="_blank" href="https://www.cnblogs.com/<%=request.getContextPath()%>/dept/detail?f=detail&dno=<%=dept.getDeptno()%>">详情</a>
321.         String forward = "/" + request.getParameter("f") + ".jsp";
322.         request.getRequestDispatcher(forward).forward(request, response);
323.     }
326.     /**
327.      * 连接数据库，查询所有的部门信息，将部门信息收集好，然后跳转到JSP页面展示
328.      *
329.      * @param request
330.      * @param response
331.      */
332.     private void doList(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
333.         request.setCharacterEncoding("UTF-8");  // 设置获取的的信息的编码集
334.         Connection connection = null;
335.         PreparedStatement preparedStatement = null;
336.         ResultSet resultSet = null;
338.         // 创建一个集合List 存储查询到的信息
339.         List<Dept> depts = new ArrayList<Dept>();
342.         try {
343.             // 连接数据库，查询所有部门:
344.             // 1. 注册驱动,获取连接
345.             connection = DBUtil.getConnection();
346.             // 2. 获取操作数据库对象，预编译sql语句
347.             String sql = "select depton as det,dname,loc from dept"; // 在mysql中测试一下是否正确
348.             preparedStatement = connection.prepareStatement(sql);
350.             // 3. 执行sql语句
351.             resultSet = preparedStatement.executeQuery();
353.             // 4. 处理查询结果集
354.             while (resultSet.next()) {
355.                 String det = resultSet.getString("det");  // 有别名要使用别名
356.                 String dname = resultSet.getString("dname");
357.                 String loc = resultSet.getString("loc");
359.                 Dept dept = new Dept(det, dname, loc);
361.                 // 将部门对象放到List集合当中
362.                 depts.add(dept);
364.             }
365.         } catch (SQLException e) {
366.             throw new RuntimeException(e);
367.         } finally {
369.             // 5. 关闭资源
370.             DBUtil.close(connection, preparedStatement, resultSet);
371.         }
374.         // 查询到数据，将数据提交给 list.jsp 显示数据
375.         // 将集合存储的数据放到请求域当中，用于其他Servlet 使用 jsp 也是Servelt
376.         request.setAttribute("depList", depts);
378.         // 转发(注意不要重定向)，重定向无法共用 request 请求域当中的数据
379.         // 转发路径，/ 默认是从 web 目录开始找的
380.         request.getRequestDispatcher("/list.jsp").forward(request, response);
381.     }
382. }

复制代码

用户界面的优化：显示 登录的用户名：(该用户名信息，从 存储到 session 会话对象当中，获取到的。)
核心代码如下：
需要注意的点就是：这里我们使用的是 JSP 内置的 session 对象，所以在这个 JSP页面当，你不可以把 session 禁用了。
不要设置这个禁用 session 的指令：

优化演示：



8. 总结:

• session 会话用户场景：在Web应用程序中，我们经常要跟踪用户身份。当一个用户登录成功后，如果他继续访问其他页面，Web程序如何才能识别出该用户身份？
  
• session对象最主要的作用是：保存会话状态。
  
• 为什么要保存会话状态：因为HTTP协议是一种无状态协议。
  
  
  
  • 无状态：
    
    
    
    • 优点：这样服务器压力小。
      
    • 缺点：服务器无法知道客户端的状态（是关闭的状态，还是开启的状态）
      
    
    
  
  
• 一个 session 会话当中包含多次请求（一次会话对应N次请求。）
  
• session 对象是用服务器端生成的，所以这里是通过 request 请求的方式向服务器获取到一个 session 会话对象
  
• session 的生成，销毁，传递的原理机制：
  

• 简单的来说吧 ，session 就是一个标记，通过标记 JSESSIONID 获取到同一个  session 对象，保证你对应的操作是同一个用户。
  
• Cookie禁用了，session还能找到吗 ? 可以，使用 URL重写机制。
  
• 实现用户登录，通过 session 会话机制(保存用户登录信息)，实现用户登录成功，可以通过 URL 直接访问资源，没有登录/登录失败，则无法直接通过 URL 访问资源。
  

9. 最后：

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

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