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

打印 上一主题 下一主题

主题 862|帖子 862|积分 2588

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



目录

每博一文案
  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;
  2. import jakarta.servlet.ServletException;
  3. import jakarta.servlet.annotation.WebServlet;
  4. import jakarta.servlet.http.HttpServlet;
  5. import jakarta.servlet.http.HttpServletRequest;
  6. import jakarta.servlet.http.HttpServletResponse;
  7. import jakarta.servlet.http.HttpSession;
  8. import java.io.IOException;
  9. import java.io.PrintWriter;
  10. @WebServlet("/session")
  11. public class TestSessionServlet extends HttpServlet {
  12.     @Override
  13.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
  14.             IOException {
  15.         HttpSession session = request.getSession();
  16.         response.setContentType("text/html;charSet=UTF-8");
  17.         PrintWriter out = response.getWriter();
  18.         out.println(" session对象:  " + session);
  19.     }
  20. }
复制代码

从 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 对象
  2. // 该访问获取到 session 对象,如果服务器端没有 session 对象会自动创建出  session 对象
  3. HttpSession session = request.getSession();
  4.         
  5. // 获取到 session 对象,(参数为 false )表示:如果服务器当中没有 session 是不会自动创建的。
  6. 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;
  2. import jakarta.servlet.ServletException;
  3. import jakarta.servlet.annotation.WebServlet;
  4. import jakarta.servlet.http.HttpServlet;
  5. import jakarta.servlet.http.HttpServletRequest;
  6. import jakarta.servlet.http.HttpServletResponse;
  7. import jakarta.servlet.http.HttpSession;
  8. import java.io.IOException;
  9. import java.io.PrintWriter;
  10. @WebServlet("/test/session")
  11. public class TestSessionServlet extends HttpServlet {
  12.     @Override
  13.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
  14.             IOException {
  15.         // request 和 session 都是在服务端的java对象,都在JVM当中
  16.         // request对象代表一次请求,(一次请求对应一个request对象,再次请求就会对应两个不同的request对象)
  17.         // session对象代表一次会话,(一次会话对应一个session 对象)
  18.         // 获取session,如何服务器当中没有 session 对象就会自动创建一个,
  19.         HttpSession session = request.getSession();
  20.         // 获取到服务器端的 session ,如果没有不会自动创建 session 对象
  21.         //HttpSession session1 = request.getSession(false);
  22.         //session.setAttribute(); 将数据存储到 session 会话当中。
  23.         //session.getAttribute() 将数据从 session 会话当中取出
  24.         // 将session 对象响应到浏览器端
  25.         response.setContentType("text/html;charset=UTF-8");
  26.         PrintWriter out = response.getWriter();
  27.         out.println("会话对象:" + session);
  28.     }
  29. }
复制代码
结果:



什么表示一个会话
粗略的可以认为一个:当我们打开一个浏览器访问一个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;
  2. import jakarta.servlet.ServletException;
  3. import jakarta.servlet.annotation.WebServlet;
  4. import jakarta.servlet.http.HttpServlet;
  5. import jakarta.servlet.http.HttpServletRequest;
  6. import jakarta.servlet.http.HttpServletResponse;
  7. import jakarta.servlet.http.HttpSession;
  8. import java.io.IOException;
  9. import java.io.PrintWriter;
  10. @WebServlet("/session")
  11. public class TestSessionServlet extends HttpServlet {
  12.     @Override
  13.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
  14.             IOException {
  15.         HttpSession session = request.getSession();
  16.         //
  17.         response.setContentType("text/html;charSet=UTF-8");
  18.         PrintWriter out = response.getWriter();
  19.         //
  20.         out.println(" session对象:  " + session);
  21.     }
  22. }
复制代码
如下是我们的浏览器(客户端) 向服务器 第一次 发送请求(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 打开,访问




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) {
  3.    // 成功,跳转到用户列表页面
  4.    // 这里使用重定向(没有资源的共享):重定向需要加/项目名 +
  5.    // 获取session 对象(这里的要求是: 必须获取到 session ,没有session 也要新建一个 session 对象)
  6.    // 注意:我们下面的这个会话是不能删除的,因为上面我们虽然通过 welcome Servlet 进行了一个会话
  7.    // 但是 welcome 当中是当我们cookie 当中存在并且用户名和密码正确的时候才会进行一个 session 的
  8.    HttpSession session = request.getSession();  // 服务器当中没有 session 会话域自动创建
  9.    session.setAttribute("username", username);  // 将用户名存储到 session 会话域当中
  10.    response.sendRedirect(request.getContextPath() + "/dept/list");
  11.    } else {
  12.      // 失败,跳转到失败页面
  13.      response.sendRedirect(request.getContextPath() + "/error.jsp");
  14.    }
复制代码
全部的代码:
  1. package com.RainbowSea.servlet;
  2. import com.RainbowSea.DBUtil.DBUtil;
  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;
  9. import java.io.IOException;
  10. import java.sql.Connection;
  11. import java.sql.PreparedStatement;
  12. import java.sql.ResultSet;
  13. import java.sql.SQLException;
  14. @WebServlet({"/user/login", "/user/exit"})
  15. public class UserServlet extends HttpServlet {
  16.     @Override
  17.     protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException,
  18.             IOException {
  19.         // 获取到浏览器地址栏上的URL路径
  20.         String servletPath = request.getServletPath();
  21.         if ("/user/login".equals(servletPath)) {
  22.             doLogin(request, response);
  23.         } else if ("/user/exit".equals(servletPath)) {
  24.             doExit(request, response);
  25.         }
  26.     }
  27.     private void doExit(HttpServletRequest request, HttpServletResponse response) throws IOException {
  28.     }
  29.     protected void doLogin(HttpServletRequest request, HttpServletResponse response) throws ServletException,
  30.             IOException {
  31.         // 一个用户登录验证的方式:验证用户名和密码是否正确
  32.         // 获取用户名和密码
  33.         // 前端提交是数据是:username=111&password=fads
  34.         // 注意:post 提交的数据是在请求体当中,而get提交的数据是在请求行当中
  35.         boolean success = false;  // 标识登录成功
  36.         String username = request.getParameter("username");
  37.         String password = request.getParameter("password");
  38.         String exempt = request.getParameter("exempt");
  39.         // 连接数据库验证用户名和密码
  40.         Connection connection = null;
  41.         PreparedStatement preparedStatement = null;
  42.         ResultSet resultSet = null;
  43.         try {
  44.             // 1. 获取连接,注册驱动
  45.             connection = DBUtil.getConnection();
  46.             // 2. 获取操作数据对象,预编译sql语句, ? 占位符不要加,“”,'' 单双引号,成了字符串了,无法识别成占位符了。
  47.             String sql = "select username,password from t_user where username = ? and password = ?";
  48.             preparedStatement = connection.prepareStatement(sql);
  49.             // 3. 填充占位符,真正执行sql语句
  50.             preparedStatement.setString(1, username);
  51.             preparedStatement.setString(2, password);
  52.             resultSet = preparedStatement.executeQuery();
  53.             // 4. 处理查询结果集
  54.             // 只有一条结果集
  55.             if (resultSet.next()) {
  56.                 // 登录成功
  57.                 success = true;
  58.             }
  59.         } catch (SQLException e) {
  60.             throw new RuntimeException(e);
  61.         } finally {
  62.             // 5. 关闭资源,最后使用的最先关闭,
  63.             DBUtil.close(connection, preparedStatement, resultSet);
  64.         }
  65.         // 登录成功与否
  66.         if (success) {
  67.             
  68.             // 成功,跳转到用户列表页面
  69.             // 这里使用重定向(没有资源的共享):重定向需要加/项目名 +
  70.             // 获取session 对象(这里的要求是: 必须获取到 session ,没有session 也要新建一个 session 对象)
  71.             // 注意:我们下面的这个会话是不能删除的,因为上面我们虽然通过 welcome Servlet 进行了一个会话
  72.             // 但是 welcome 当中是当我们cookie 当中存在并且用户名和密码正确的时候才会进行一个 session 的
  73.             HttpSession session = request.getSession();  // 服务器当中没有 session 会话域自动创建
  74.             session.setAttribute("username", username);  // 将用户名存储到 session 会话域当中
  75.             response.sendRedirect(request.getContextPath() + "/dept/list");
  76.         } else {
  77.             // 失败,跳转到失败页面
  78.             response.sendRedirect(request.getContextPath() + "/error.jsp");
  79.         }
  80.     }
  81. }
复制代码
其次是当用户想要直接通过 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 {
  7.         String servletPath = request.getServletPath();  // 获取到浏览器当中的uri
  8.         // 获取session 这个 session 是不不需要新建的
  9.         // 只是获取当前session ,获取不到这返回null,
  10.         HttpSession session = request.getSession(false);  // 获取到服务器当中的session ,没有不会创建的
  11.         /**
  12.          * 说明这里我们通过 session 会话机制,判断用户是否登录过,如果用户没有登录就想要访问
  13.          * 到其信息,不可以,因为我们这里判断了一次是否登录过,只有登录入过了,才会将中登录到
  14.          * 用户名为 “username” 的信息存储到 session 会话当中,如果没有的话是查询不到的,返回的是 null
  15.          * 需要注意的一点就是,我们的jsp 当中的内置对象,是会自动创建一个 session 会话对象的,但是
  16.          * 因为这里我们进行了一个 双重的判断机制。注意:需要先将对应的 xx_jsp.java 生成才行。同时
  17.          * 使用 <%@page session = false %> 指令的话,需要所有会被访问,生成的 Jsp 文件都需要设置。
  18.          *
  19.          *   jakarta.servlet.http.HttpSession session = null;
  20.          *   session = pageContext.getSession();
  21.          */
  22.         if(session != null && session.getAttribute("username") != null) {
  23.             // 双重的判断,一个是 session 会话域要存在,其次是 会话域当中存储了名为 "username" 的信息
  24.             if ("/dept/list".equals(servletPath)) {
  25.                 doList(request, response);
  26.             } else if ("/dept/detail".equals(servletPath)) {
  27.                 doDetail(request, response);
  28.             } else if ("/dept/delete".equals(servletPath)) {
  29.                 doElete(request,response);
  30.             } else if("/dept/save".equals(servletPath)) {
  31.                 doSave(request,response);
  32.             } else if("/dept/modify".equals(servletPath)) {
  33.                 doModify(request,response);
  34.             }
  35.         } else {
  36.             response.sendRedirect(request.getContextPath());  // 访问的web 站点的根即可,自动找到的是名为 index.jsp
  37.         }
  38.     }
  39. }
复制代码
最后就是:用户点击安全退出系统,销毁 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();
  10.         if (session != null) {
  11.             // 手动销毁 session 对象
  12.             // 注意:会话销毁的了,自然需要重写登录了,没有登录过,无法进行一个路径的访问的
  13.             session.invalidate();
  14.             
  15.             // 跳转会登录的页面
  16.             response.sendRedirect(request.getContextPath());  // 项目名路径默认就是访问的index.html 的欢迎页面
  17.         }
  18.     }
复制代码
全部具体代码:
  1. package com.RainbowSea.servlet;
  2. import com.RainbowSea.DBUtil.DBUtil;
  3. import com.RainbowSea.bean.Dept;
  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;
  10. import java.io.IOException;
  11. import java.sql.Connection;
  12. import java.sql.PreparedStatement;
  13. import java.sql.ResultSet;
  14. import java.sql.SQLException;
  15. import java.util.ArrayList;
  16. import java.util.List;
  17. // 可以使用模糊查询 @WebServlet("/dept/*")
  18. @WebServlet({"/dept/list", "/dept/detail", "/dept/delete", "/dept/save", "/dept/modify"})
  19. public class DeptServlet extends HttpServlet {
  20.     @Override
  21.     protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException,
  22.             IOException {
  23.         String servletPath = request.getServletPath();  // 获取到浏览器当中的uri
  24.         // 获取session 这个 session 是不不需要新建的
  25.         // 只是获取当前session ,获取不到这返回null,
  26.         HttpSession session = request.getSession(false);  // 获取到服务器当中的session ,没有不会创建的
  27.         /**
  28.          * 说明这里我们通过 session 会话机制,判断用户是否登录过,如果用户没有登录就想要访问
  29.          * 到其信息,不可以,因为我们这里判断了一次是否登录过,只有登录入过了,才会将中登录到
  30.          * 用户名为 “username” 的信息存储到 session 会话当中,如果没有的话是查询不到的,返回的是 null
  31.          * 需要注意的一点就是,我们的jsp 当中的内置对象,是会自动创建一个 session 会话对象的,但是
  32.          * 因为这里我们进行了一个 双重的判断机制。注意:需要先将对应的 xx_jsp.java 生成才行。同时
  33.          * 使用 <%@page session = false %> 指令的话,需要所有会被访问,生成的 Jsp 文件都需要设置。
  34.          *
  35.          *   jakarta.servlet.http.HttpSession session = null;
  36.          *   session = pageContext.getSession();
  37.          */
  38.         if(session != null && session.getAttribute("username") != null) {
  39.             // 双重的判断,一个是 session 会话域要存在,其次是 会话域当中存储了名为 "username" 的信息
  40.             if ("/dept/list".equals(servletPath)) {
  41.                 doList(request, response);
  42.             } else if ("/dept/detail".equals(servletPath)) {
  43.                 doDetail(request, response);
  44.             } else if ("/dept/delete".equals(servletPath)) {
  45.                 doElete(request,response);
  46.             } else if("/dept/save".equals(servletPath)) {
  47.                 doSave(request,response);
  48.             } else if("/dept/modify".equals(servletPath)) {
  49.                 doModify(request,response);
  50.             }
  51.         } else {
  52.             response.sendRedirect(request.getContextPath());  // 访问的web 站点的根即可,自动找到的是名为 index.jsp
  53.         }
  54.     }
  55.     /**
  56.      * 修改部门信息
  57.      *
  58.      * @param request
  59.      * @param response
  60.      */
  61.     private void doModify(HttpServletRequest request, HttpServletResponse response) throws IOException {
  62.         request.setCharacterEncoding("UTF-8");  // 设置获取的的信息的编码集
  63.         Connection connection = null;
  64.         PreparedStatement preparedStatement = null;
  65.         // 影响数据库的行数
  66.         int count = 0;
  67.         String deptno = request.getParameter("deptno");
  68.         String dname = request.getParameter("dname");
  69.         String loc = request.getParameter("loc");
  70.         try {
  71.             // 1. 注册驱动,连接数据库
  72.             connection = DBUtil.getConnection();
  73.             // 2. 获取到操作数据库的对象,预编译sql语句,sql测试
  74.             String sql = "update dept set dname = ?,loc = ? where depton = ?";
  75.             preparedStatement = connection.prepareStatement(sql);
  76.             // 3. 填充占位符,真正执行sql语句
  77.             // 从下标 1开始
  78.             preparedStatement.setString(1, dname);
  79.             preparedStatement.setString(2, loc);
  80.             preparedStatement.setString(3, deptno);
  81.             count = preparedStatement.executeUpdate();
  82.         } catch (SQLException e) {
  83.             throw new RuntimeException(e);
  84.         } finally {
  85.             // 4. 释放资源,最后使用的优先被释放
  86.             DBUtil.close(connection, preparedStatement, null);
  87.         }
  88.         if (count == 1) {
  89.             // 更新成功
  90.             // 跳转到部门列表页面(部门列表表面是通过java程序动态生成的,所以还需要再次执行另一个Servlet)
  91.             // 转发是服务器内部的操作,“/” 不要加项目名
  92.             // request.getRequestDispatcher("/dept/list/").forward(request,response);
  93.             // 优化使用重定向,自发前端(需要指明项目名)
  94.             response.sendRedirect(request.getContextPath() + "/dept/list");
  95.         }
  96.     }
  97.     /**
  98.      * 保存部门信息
  99.      *
  100.      * @param request
  101.      * @param response
  102.      */
  103.     private void doSave(HttpServletRequest request, HttpServletResponse response) throws IOException {
  104.         request.setCharacterEncoding("UTF-8");
  105.         // 获取到前端的数据,建议 name 使用复制
  106.         String deptno = request.getParameter("deptno");
  107.         String dname = request.getParameter("dname");
  108.         String loc = request.getParameter("loc");
  109.         // 连接数据库,添加数据
  110.         Connection connection = null;
  111.         PreparedStatement preparedStatement = null;
  112.         // 影响数据库的行数
  113.         int count = 0;
  114.         try {
  115.             // 1. 注册驱动,连接数据库
  116.             connection = DBUtil.getConnection();
  117.             // 2. 获取操作数据库对象,预编译sql语句,Sql测试
  118.             String sql = "insert into dept(depton,dname,loc) values(?,?,?)";
  119.             preparedStatement = connection.prepareStatement(sql);
  120.             // 3. 填充占位符, 真正执行sql语句,
  121.             // 注意: 占位符的填充是从 1 开始的,基本上数据库相关的起始下标索引都是从 1下标开始的
  122.             preparedStatement.setString(1, deptno);
  123.             preparedStatement.setString(2, dname);
  124.             preparedStatement.setString(3, loc);
  125.             // 返回影响数据库的行数
  126.             count = preparedStatement.executeUpdate();
  127.             // 5.释放资源
  128.         } catch (SQLException e) {
  129.             throw new RuntimeException(e);
  130.         } finally {
  131.             DBUtil.close(connection, preparedStatement, null);
  132.         }
  133.         // 保存成功,返回部门列表页面
  134.         if (count == 1) {
  135.             // 这里应该使用,重定向
  136.             // 这里用的转发,是服务器内部的,不要加项目名
  137.             //request.getRequestDispatcher("/dept/list/").forward(request, response);
  138.             // 重定向
  139.             response.sendRedirect(request.getContextPath() + "/dept/list");
  140.         }
  141.     }
  142.     /**
  143.      * 通过部门删除部门
  144.      *
  145.      * @param request
  146.      * @param response
  147.      */
  148.     private void doElete(HttpServletRequest request, HttpServletResponse response) throws IOException {
  149.         request.setCharacterEncoding("UTF-8");  // 设置获取的的信息的编码集
  150.         // 获取到发送数据
  151.         String deptno = request.getParameter("deptno");
  152.          /*
  153.         根据部门编号删除信息,
  154.         删除成功,跳转回原来的部门列表页面
  155.         删除失败,跳转删除失败的页面
  156.          */
  157.         Connection connection = null;
  158.         PreparedStatement preparedStatement = null;
  159.         // 记录删除数据库的行数
  160.         int count = 0;
  161.         // 连接数据库进行删除操作
  162.         try {
  163.             // 1.注册驱动,连接数据库
  164.             connection = DBUtil.getConnection();
  165.             // 开启事务(取消自动提交机制),实现可回滚
  166.             connection.setAutoCommit(false);
  167.             // 2. 预编译sql语句,sql测试
  168.             String sql = "delete from dept where depton = ?"; // ? 占位符
  169.             preparedStatement = connection.prepareStatement(sql);
  170.             // 3. 填充占位符,真正的执行sql语句
  171.             preparedStatement.setString(1, deptno);
  172.             // 返回影响数据库的行数
  173.             count = preparedStatement.executeUpdate();
  174.             connection.commit();  // 手动提交数据
  175.         } catch (SQLException e) {
  176.             // 遇到异常回滚
  177.             if (connection != null) {
  178.                 try {
  179.                     // 事务的回滚
  180.                     connection.rollback();
  181.                 } catch (SQLException ex) {
  182.                     throw new RuntimeException(ex);
  183.                 }
  184.             }
  185.             throw new RuntimeException(e);
  186.         } finally {
  187.             // 4. 释放资源
  188.             // 因为这里是删除数据,没有查询操作,所以 没有 ResultSet 可以传null
  189.             DBUtil.close(connection, preparedStatement, null);
  190.         }
  191.         if (count == 1) {
  192.             // 删除成功
  193.             // 仍然跳转到部门列表页面
  194.             // 部门列表页面的显示需要执行另外一个Servlet,怎么办,可以使用跳转,不过这里最后是使用重定向
  195.             // 注意:转发是在服务器间的,所以不要加“项目名” 而是 / + web.xml 映射的路径即可
  196.             //request.getRequestDispatcher("/dept/list/").forward(request,response);
  197.             // 优化:使用重定向机制 注意: 重定向是自发到前端的地址栏上的,前端所以需要指明项目名
  198.             // 注意: request.getContextPath() 返回的根路径是,包含了 "/" 的
  199.             response.sendRedirect(request.getContextPath() + "/dept/list");
  200.         }
  201.     }
  202.     /**
  203.      * 通过部门编号,查询部门的详情
  204.      *
  205.      * @param request
  206.      * @param response
  207.      */
  208.     private void doDetail(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  209.         request.setCharacterEncoding("UTF-8");  // 设置获取的的信息的编码集
  210.         Connection connection = null;
  211.         PreparedStatement preparedStatement = null;
  212.         ResultSet resultSet = null;
  213.         // 获取到部门编号
  214.         String dno = request.getParameter("dno");
  215.         Dept dept = new Dept();
  216.         // 获取到部门编号,获取部门信息,将部门信息收集好,然后跳转到JSP做页面展示
  217.         try {
  218.             // 2. 连接数据库,根据部门编号查询数据库
  219.             // 1.注册驱动,连接数据库
  220.             connection = DBUtil.getConnection();
  221.             // 2. 预编译SQL语句,sql要测试
  222.             String sql = "select dname,loc from dept where depton = ?";  // ? 占位符
  223.             preparedStatement = connection.prepareStatement(sql);
  224.             // 3. 填充占位符,真正执行sql语句
  225.             preparedStatement.setString(1, dno);
  226.             resultSet = preparedStatement.executeQuery();
  227.             // 4. 处理查询结果集
  228.             while (resultSet.next()) {
  229.                 String dname = resultSet.getString("dname");
  230.                 String loc = resultSet.getString("loc");
  231.                 // 封装对象(建议使用咖啡豆,因为只有一个对象)
  232.                 dept.setDeptno(dno);
  233.                 dept.setDname(dname);
  234.                 dept.setLoc(loc);
  235.             }
  236.         } catch (SQLException e) {
  237.             throw new RuntimeException(e);
  238.         } finally {
  239.             // 5. 释放资源
  240.             DBUtil.close(connection, preparedStatement, resultSet);
  241.         }
  242.         // 这个咖啡豆只有一个,所以不需要袋子,只需要将这个咖啡豆放到request请求域当中,
  243.         // 用于对应的 jsp显示
  244.         request.setAttribute("dept", dept);
  245.         //String sign = request.getParameter("f");
  246.         /*if("m".equals(sign)) {
  247.             // 转发:多个请求为一个请求(地址栏不会发生改变)
  248.             // 注意: 该路径默认是从 web 开始找的 / 表示 web
  249.             // 转发到修改页面
  250.             request.getRequestDispatcher("/edit.jsp").forward(request,response);
  251.         } else if("d".equals(sign)) {
  252.             // 跳转到详情页面
  253.             request.getRequestDispatcher("/detail.jsp").forward(request,response);
  254.         }*/
  255.         // 或者优化
  256.         // 注意 无论是转发还是重定向都是从 “/” 开始的
  257.         // request.getParameter()拿到的是 f=edit,还是f=detail 就是跳转到的哪个页面
  258.         //<a target="_blank" href="https://www.cnblogs.com/<%=request.getContextPath()%>/dept/detail?f=edit&dno=<%=dept.getDeptno()%>">修改</a>
  259.         //<a target="_blank" href="https://www.cnblogs.com/<%=request.getContextPath()%>/dept/detail?f=detail&dno=<%=dept.getDeptno()%>">详情</a>
  260.         String forward = "/" + request.getParameter("f") + ".jsp";
  261.         request.getRequestDispatcher(forward).forward(request, response);
  262.     }
  263.     /**
  264.      * 连接数据库,查询所有的部门信息,将部门信息收集好,然后跳转到JSP页面展示
  265.      *
  266.      * @param request
  267.      * @param response
  268.      */
  269.     private void doList(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  270.         request.setCharacterEncoding("UTF-8");  // 设置获取的的信息的编码集
  271.         Connection connection = null;
  272.         PreparedStatement preparedStatement = null;
  273.         ResultSet resultSet = null;
  274.         // 创建一个集合List 存储查询到的信息
  275.         List<Dept> depts = new ArrayList<Dept>();
  276.         try {
  277.             // 连接数据库,查询所有部门:
  278.             // 1. 注册驱动,获取连接
  279.             connection = DBUtil.getConnection();
  280.             // 2. 获取操作数据库对象,预编译sql语句
  281.             String sql = "select depton as det,dname,loc from dept"; // 在mysql中测试一下是否正确
  282.             preparedStatement = connection.prepareStatement(sql);
  283.             // 3. 执行sql语句
  284.             resultSet = preparedStatement.executeQuery();
  285.             // 4. 处理查询结果集
  286.             while (resultSet.next()) {
  287.                 String det = resultSet.getString("det");  // 有别名要使用别名
  288.                 String dname = resultSet.getString("dname");
  289.                 String loc = resultSet.getString("loc");
  290.                 Dept dept = new Dept(det, dname, loc);
  291.                 // 将部门对象放到List集合当中
  292.                 depts.add(dept);
  293.             }
  294.         } catch (SQLException e) {
  295.             throw new RuntimeException(e);
  296.         } finally {
  297.             // 5. 关闭资源
  298.             DBUtil.close(connection, preparedStatement, resultSet);
  299.         }
  300.         // 查询到数据,将数据提交给 list.jsp 显示数据
  301.         // 将集合存储的数据放到请求域当中,用于其他Servlet 使用 jsp 也是Servelt
  302.         request.setAttribute("depList", depts);
  303.         // 转发(注意不要重定向),重定向无法共用 request 请求域当中的数据
  304.         // 转发路径,/ 默认是从 web 目录开始找的
  305.         request.getRequestDispatcher("/list.jsp").forward(request, response);
  306.     }
  307. }
复制代码
用户界面的优化:显示 登录的用户名:(该用户名信息,从 存储到 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. 最后:

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


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

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有账号?立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览

快速回复

您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

祗疼妳一个

金牌会员
这个人很懒什么都没写!

标签云

快速回复 返回顶部 返回列表