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

在这里插入图片描述

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

每博一文案

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

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 地址信息

package com.RainbowSea.session;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;
import java.io.PrintWriter;


@WebServlet("/session")
public class TestSessionServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

        HttpSession session = request.getSession();

        response.setContentType("text/html;charSet=UTF-8");
        PrintWriter out = response.getWriter();

        out.println(" session对象:  " + session);

    }
}

在这里插入图片描述

从 session 对象当中存在于: org.apache.catalina.session.StandardSession 的位置。

在Java的servlet 的规范当中，session 对应的类名为： HttpSession(jarkata.servlett.http.HttpSession) 。
在这里插入图片描述

注意：

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

获取 sessoin 的对象方法：

// 注意: sessio 是存储在服务器端的，所以我们这里使用的是 request 请求的方式，向服务器请求获取到 session 对象 

// 该访问获取到 session 对象，如果服务器端没有 session 对象会自动创建出  session 对象
 HttpSession session = request.getSession();
        
// 获取到 session 对象，(参数为 false )表示：如果服务器当中没有 session 是不会自动创建的。
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信息是不一样的。

代码举例：

package com.RainbowSea.serssion;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/test/session")
public class TestSessionServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

        // request 和 session 都是在服务端的java对象，都在JVM当中
        // request对象代表一次请求，(一次请求对应一个request对象，再次请求就会对应两个不同的request对象)
        // session对象代表一次会话，（一次会话对应一个session 对象）
        // 获取session，如何服务器当中没有 session 对象就会自动创建一个，
        HttpSession session = request.getSession();
        // 获取到服务器端的 session ，如果没有不会自动创建 session 对象
        //HttpSession session1 = request.getSession(false);

        //session.setAttribute(); 将数据存储到 session 会话当中。
        //session.getAttribute() 将数据从 session 会话当中取出




        // 将session 对象响应到浏览器端
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        out.println("会话对象：" + session);



    }
}

结果：

在这里插入图片描述

什么表示一个会话

粗略的可以认为一个：当我们打开一个浏览器访问一个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 的实现原理解释

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=123	session1
JSESSIONID=456	session2

当用户第一次请求服务器的时候，服务器会为该用户生成一个 session 会话对象，同时服务器会将该 session 对应 JSESSIONID=123，也就是： sessionID 发送给客户端。客户端会接收到服务器发送过来的 JSESSIONID ,并存储到客户端的缓存(Cookie) 当中。同时需要注意的是： JSESSIONID=xxxxxx 这个是以Cookie的形式保存在浏览器的内存中的。浏览器只要关闭。这个cookie就没有了。(当然这是默认的情况下，你是可以自定义设置的。关于 Cookie 的内容这里就不会说明了。)

举例：具体代码详细如下：

package com.RainbowSea.session;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;
import java.io.PrintWriter;


@WebServlet("/session")
public class TestSessionServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

        HttpSession session = request.getSession();

        // 
        response.setContentType("text/html;charSet=UTF-8");
        PrintWriter out = response.getWriter();


        //
        out.println(" session对象:  " + session);

    }
}

如下是我们的浏览器(客户端) 向服务器 第一次 发送请求(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 对象。

第一种：手动销毁
// 销毁 session 对象的
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 分钟



    <session-config>
        <session-timeout>30</session-timeout>
    </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
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当中(这里我们存储到用户的用户名信息。)

核心优化代码：

// 登录成功与否
if (success) {

   // 成功，跳转到用户列表页面
   // 这里使用重定向(没有资源的共享)：重定向需要加/项目名 +

   // 获取session 对象(这里的要求是： 必须获取到 session ,没有session 也要新建一个 session 对象)
   // 注意：我们下面的这个会话是不能删除的，因为上面我们虽然通过 welcome Servlet 进行了一个会话
   // 但是 welcome 当中是当我们cookie 当中存在并且用户名和密码正确的时候才会进行一个 session 的
   HttpSession session = request.getSession();  // 服务器当中没有 session 会话域自动创建
   session.setAttribute("username", username);  // 将用户名存储到 session 会话域当中


   response.sendRedirect(request.getContextPath() + "/dept/list");
   } else {
     // 失败，跳转到失败页面
     response.sendRedirect(request.getContextPath() + "/error.jsp");
   }

全部的代码：

package com.RainbowSea.servlet;

import com.RainbowSea.DBUtil.DBUtil;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;


@WebServlet({"/user/login", "/user/exit"})
public class UserServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

        // 获取到浏览器地址栏上的URL路径
        String servletPath = request.getServletPath();

        if ("/user/login".equals(servletPath)) {
            doLogin(request, response);
        } else if ("/user/exit".equals(servletPath)) {
            doExit(request, response);
        }


    }

    private void doExit(HttpServletRequest request, HttpServletResponse response) throws IOException {
    }

    protected void doLogin(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

        // 一个用户登录验证的方式：验证用户名和密码是否正确
        // 获取用户名和密码
        // 前端提交是数据是：username=111&password=fads
        // 注意：post 提交的数据是在请求体当中，而get提交的数据是在请求行当中

        boolean success = false;  // 标识登录成功

        String username = request.getParameter("username");
        String password = request.getParameter("password");

        String exempt = request.getParameter("exempt");

        // 连接数据库验证用户名和密码
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            // 1. 获取连接，注册驱动
            connection = DBUtil.getConnection();

            // 2. 获取操作数据对象，预编译sql语句, ? 占位符不要加，“”,'' 单双引号，成了字符串了，无法识别成占位符了。
            String sql = "select username,password from t_user where username = ? and password = ?";
            preparedStatement = connection.prepareStatement(sql);

            // 3. 填充占位符，真正执行sql语句
            preparedStatement.setString(1, username);
            preparedStatement.setString(2, password);

            resultSet = preparedStatement.executeQuery();

            // 4. 处理查询结果集
            // 只有一条结果集
            if (resultSet.next()) {
                // 登录成功
                success = true;
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            // 5. 关闭资源，最后使用的最先关闭，
            DBUtil.close(connection, preparedStatement, resultSet);
        }

        // 登录成功与否
        if (success) {
            
            // 成功，跳转到用户列表页面
            // 这里使用重定向(没有资源的共享)：重定向需要加/项目名 +

            // 获取session 对象(这里的要求是： 必须获取到 session ,没有session 也要新建一个 session 对象)
            // 注意：我们下面的这个会话是不能删除的，因为上面我们虽然通过 welcome Servlet 进行了一个会话
            // 但是 welcome 当中是当我们cookie 当中存在并且用户名和密码正确的时候才会进行一个 session 的
            HttpSession session = request.getSession();  // 服务器当中没有 session 会话域自动创建
            session.setAttribute("username", username);  // 将用户名存储到 session 会话域当中


            response.sendRedirect(request.getContextPath() + "/dept/list");
        } else {
            // 失败，跳转到失败页面
            response.sendRedirect(request.getContextPath() + "/error.jsp");
        }


    }
}

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

思路是：

我们通过 session 会话机制，判断用户是否登录过，如果用户没有登录就想要访问到其信息，不可以，因为我们这里判断了一次是否登录过，只有登录入过了，才会将中登录到用户名为 “username” 的信息存储到 session 会话当中，如果没有的话是查询不到的，返回的是 null。需要注意的一点就是，我们的jsp 当中的内置对象，是会自动创建一个 session 会话对象的(所以就会导致，就算我们没有登录成功，session 对象也是不为空的，因为JSP创建了 session 对象，我们可以通过JSP 指令禁止 JSP 生成 session 内置对象 <%@page session = false %>，需要所有会被访问，生成的 Jsp 文件都需要设置该指令。这里所谓的禁用了就是，对应的访问生成的 xxx_jsp.java）当中不会翻译生成其中内置的 session 对象)，但是因为这里我们进行了一个双重的判断机制。
if(session != null && session.getAttribute("username") != null)
// 双重的判断，一个是 session 会话域要存在，其次是 会话域当中存储了名为 "username" 的信息，可以用户登录的信息可以从 session 找到，如果找不到 ，返回 null ,找到不为 null 。这样就解决了 JSP 内置session 对象的没有登录 session 不为 null 的影响了。
需要注意一点的就是：这里我们要使用HttpSession session = request.getSession(false)
HttpSession session = request.getSession(false);  // 获取到服务器当中的session ，没有不会创建的,
// session 是用户登录成功才创建的，其他情况不要创建 session 会话对象。

核心代码：


// 可以使用模糊查询 @WebServlet("/dept/*")
@WebServlet({"/dept/list", "/dept/detail", "/dept/delete", "/dept/save", "/dept/modify"})
public class DeptServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

        String servletPath = request.getServletPath();  // 获取到浏览器当中的uri

        // 获取session 这个 session 是不不需要新建的
        // 只是获取当前session ,获取不到这返回null,
        HttpSession session = request.getSession(false);  // 获取到服务器当中的session ，没有不会创建的


        /**
         * 说明这里我们通过 session 会话机制，判断用户是否登录过，如果用户没有登录就想要访问
         * 到其信息，不可以，因为我们这里判断了一次是否登录过，只有登录入过了，才会将中登录到
         * 用户名为 “username” 的信息存储到 session 会话当中，如果没有的话是查询不到的，返回的是 null
         * 需要注意的一点就是，我们的jsp 当中的内置对象，是会自动创建一个 session 会话对象的，但是
         * 因为这里我们进行了一个 双重的判断机制。注意：需要先将对应的 xx_jsp.java 生成才行。同时
         * 使用 <%@page session = false %> 指令的话，需要所有会被访问，生成的 Jsp 文件都需要设置。
         *
         *   jakarta.servlet.http.HttpSession session = null;
         *   session = pageContext.getSession();
         */
        if(session != null && session.getAttribute("username") != null) {
            // 双重的判断，一个是 session 会话域要存在，其次是 会话域当中存储了名为 "username" 的信息
            if ("/dept/list".equals(servletPath)) {
                doList(request, response);
            } else if ("/dept/detail".equals(servletPath)) {
                doDetail(request, response);
            } else if ("/dept/delete".equals(servletPath)) {
                doElete(request,response);
            } else if("/dept/save".equals(servletPath)) {
                doSave(request,response);
            } else if("/dept/modify".equals(servletPath)) {
                doModify(request,response);
            }
        } else {
            response.sendRedirect(request.getContextPath());  // 访问的web 站点的根即可，自动找到的是名为 index.jsp
        }

    }
}

最后就是：用户点击安全退出系统，销毁 session 对象的实现了。

当我们点击安全退出，手动将 session 会话对象销毁了。就需要重新登录了。只有重新登录，建立新的登录成功的 session 会话信息，才能再次通过URL访问。

核心代码如下：

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

/**
* 用户手动点击安全退出，销毁 session 对象
* @param request
 * @param response
* @throws IOException
*/
private void doExit(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // 获取到客户端发送过来的 sessoin
        HttpSession session = request.getSession();

        if (session != null) {
            // 手动销毁 session 对象
            // 注意：会话销毁的了，自然需要重写登录了，没有登录过，无法进行一个路径的访问的
            session.invalidate();
            
            // 跳转会登录的页面
            response.sendRedirect(request.getContextPath());  // 项目名路径默认就是访问的index.html 的欢迎页面
        }
    }

全部具体代码：

package com.RainbowSea.servlet;

import com.RainbowSea.DBUtil.DBUtil;
import com.RainbowSea.bean.Dept;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

// 可以使用模糊查询 @WebServlet("/dept/*")
@WebServlet({"/dept/list", "/dept/detail", "/dept/delete", "/dept/save", "/dept/modify"})
public class DeptServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

        String servletPath = request.getServletPath();  // 获取到浏览器当中的uri

        // 获取session 这个 session 是不不需要新建的
        // 只是获取当前session ,获取不到这返回null,
        HttpSession session = request.getSession(false);  // 获取到服务器当中的session ，没有不会创建的


        /**
         * 说明这里我们通过 session 会话机制，判断用户是否登录过，如果用户没有登录就想要访问
         * 到其信息，不可以，因为我们这里判断了一次是否登录过，只有登录入过了，才会将中登录到
         * 用户名为 “username” 的信息存储到 session 会话当中，如果没有的话是查询不到的，返回的是 null
         * 需要注意的一点就是，我们的jsp 当中的内置对象，是会自动创建一个 session 会话对象的，但是
         * 因为这里我们进行了一个 双重的判断机制。注意：需要先将对应的 xx_jsp.java 生成才行。同时
         * 使用 <%@page session = false %> 指令的话，需要所有会被访问，生成的 Jsp 文件都需要设置。
         *
         *   jakarta.servlet.http.HttpSession session = null;
         *   session = pageContext.getSession();
         */
        if(session != null && session.getAttribute("username") != null) {
            // 双重的判断，一个是 session 会话域要存在，其次是 会话域当中存储了名为 "username" 的信息
            if ("/dept/list".equals(servletPath)) {
                doList(request, response);
            } else if ("/dept/detail".equals(servletPath)) {
                doDetail(request, response);
            } else if ("/dept/delete".equals(servletPath)) {
                doElete(request,response);
            } else if("/dept/save".equals(servletPath)) {
                doSave(request,response);
            } else if("/dept/modify".equals(servletPath)) {
                doModify(request,response);
            }
        } else {
            response.sendRedirect(request.getContextPath());  // 访问的web 站点的根即可，自动找到的是名为 index.jsp
        }

    }


    /**
     * 修改部门信息
     *
     * @param request
     * @param response
     */
    private void doModify(HttpServletRequest request, HttpServletResponse response) throws IOException {
        request.setCharacterEncoding("UTF-8");  // 设置获取的的信息的编码集
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        // 影响数据库的行数
        int count = 0;


        String deptno = request.getParameter("deptno");
        String dname = request.getParameter("dname");
        String loc = request.getParameter("loc");


        try {
            // 1. 注册驱动，连接数据库
            connection = DBUtil.getConnection();

            // 2. 获取到操作数据库的对象，预编译sql语句，sql测试
            String sql = "update dept set dname = ?,loc = ? where depton = ?";
            preparedStatement = connection.prepareStatement(sql);

            // 3. 填充占位符，真正执行sql语句
            // 从下标 1开始
            preparedStatement.setString(1, dname);
            preparedStatement.setString(2, loc);
            preparedStatement.setString(3, deptno);

            count = preparedStatement.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            // 4. 释放资源，最后使用的优先被释放
            DBUtil.close(connection, preparedStatement, null);
        }

        if (count == 1) {
            // 更新成功
            // 跳转到部门列表页面（部门列表表面是通过java程序动态生成的，所以还需要再次执行另一个Servlet）
            // 转发是服务器内部的操作，“/” 不要加项目名
            // request.getRequestDispatcher("/dept/list/").forward(request,response);

            // 优化使用重定向,自发前端(需要指明项目名)
            response.sendRedirect(request.getContextPath() + "/dept/list");

        }
    }


    /**
     * 保存部门信息
     *
     * @param request
     * @param response
     */
    private void doSave(HttpServletRequest request, HttpServletResponse response) throws IOException {

        request.setCharacterEncoding("UTF-8");

        // 获取到前端的数据，建议 name 使用复制
        String deptno = request.getParameter("deptno");
        String dname = request.getParameter("dname");
        String loc = request.getParameter("loc");

        // 连接数据库，添加数据
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        // 影响数据库的行数
        int count = 0;

        try {
            // 1. 注册驱动，连接数据库
            connection = DBUtil.getConnection();

            // 2. 获取操作数据库对象，预编译sql语句，Sql测试
            String sql = "insert into dept(depton,dname,loc) values(?,?,?)";
            preparedStatement = connection.prepareStatement(sql);

            // 3. 填充占位符, 真正执行sql语句，
            // 注意： 占位符的填充是从 1 开始的，基本上数据库相关的起始下标索引都是从 1下标开始的
            preparedStatement.setString(1, deptno);
            preparedStatement.setString(2, dname);
            preparedStatement.setString(3, loc);

            // 返回影响数据库的行数
            count = preparedStatement.executeUpdate();

            // 5.释放资源
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            DBUtil.close(connection, preparedStatement, null);
        }

        // 保存成功，返回部门列表页面
        if (count == 1) {
            // 这里应该使用，重定向
            // 这里用的转发，是服务器内部的，不要加项目名
            //request.getRequestDispatcher("/dept/list/").forward(request, response);

            // 重定向
            response.sendRedirect(request.getContextPath() + "/dept/list");
        }
    }


    /**
     * 通过部门删除部门
     *
     * @param request
     * @param response
     */
    private void doElete(HttpServletRequest request, HttpServletResponse response) throws IOException {

        request.setCharacterEncoding("UTF-8");  // 设置获取的的信息的编码集
        // 获取到发送数据
        String deptno = request.getParameter("deptno");

         /*
        根据部门编号删除信息，
        删除成功，跳转回原来的部门列表页面
        删除失败，跳转删除失败的页面
         */

        Connection connection = null;
        PreparedStatement preparedStatement = null;

        // 记录删除数据库的行数
        int count = 0;


        // 连接数据库进行删除操作

        try {
            // 1.注册驱动，连接数据库
            connection = DBUtil.getConnection();

            // 开启事务（取消自动提交机制）,实现可回滚
            connection.setAutoCommit(false);

            // 2. 预编译sql语句,sql测试
            String sql = "delete from dept where depton = ?"; // ? 占位符
            preparedStatement = connection.prepareStatement(sql);

            // 3. 填充占位符，真正的执行sql语句
            preparedStatement.setString(1, deptno);
            // 返回影响数据库的行数
            count = preparedStatement.executeUpdate();
            connection.commit();  // 手动提交数据
        } catch (SQLException e) {
            // 遇到异常回滚
            if (connection != null) {
                try {
                    // 事务的回滚
                    connection.rollback();
                } catch (SQLException ex) {
                    throw new RuntimeException(ex);
                }
            }
            throw new RuntimeException(e);
        } finally {
            // 4. 释放资源
            // 因为这里是删除数据，没有查询操作，所以 没有 ResultSet 可以传null
            DBUtil.close(connection, preparedStatement, null);
        }

        if (count == 1) {
            // 删除成功
            // 仍然跳转到部门列表页面
            // 部门列表页面的显示需要执行另外一个Servlet，怎么办，可以使用跳转，不过这里最后是使用重定向
            // 注意：转发是在服务器间的，所以不要加“项目名” 而是 / + web.xml 映射的路径即可
            //request.getRequestDispatcher("/dept/list/").forward(request,response);

            // 优化：使用重定向机制 注意: 重定向是自发到前端的地址栏上的，前端所以需要指明项目名
            // 注意: request.getContextPath() 返回的根路径是，包含了 "/" 的
            response.sendRedirect(request.getContextPath() + "/dept/list");
        }
    }


    /**
     * 通过部门编号，查询部门的详情
     *
     * @param request
     * @param response
     */
    private void doDetail(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        request.setCharacterEncoding("UTF-8");  // 设置获取的的信息的编码集

        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        // 获取到部门编号
        String dno = request.getParameter("dno");
        Dept dept = new Dept();

        // 获取到部门编号，获取部门信息，将部门信息收集好，然后跳转到JSP做页面展示


        try {
            // 2. 连接数据库，根据部门编号查询数据库
            // 1.注册驱动，连接数据库
            connection = DBUtil.getConnection();

            // 2. 预编译SQL语句,sql要测试
            String sql = "select dname,loc from dept where depton = ?";  // ? 占位符
            preparedStatement = connection.prepareStatement(sql);

            // 3. 填充占位符,真正执行sql语句
            preparedStatement.setString(1, dno);
            resultSet = preparedStatement.executeQuery();

            // 4. 处理查询结果集
            while (resultSet.next()) {
                String dname = resultSet.getString("dname");
                String loc = resultSet.getString("loc");

                // 封装对象(建议使用咖啡豆，因为只有一个对象)
                dept.setDeptno(dno);
                dept.setDname(dname);
                dept.setLoc(loc);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            // 5. 释放资源
            DBUtil.close(connection, preparedStatement, resultSet);
        }

        // 这个咖啡豆只有一个，所以不需要袋子，只需要将这个咖啡豆放到request请求域当中，
        // 用于对应的 jsp显示
        request.setAttribute("dept", dept);
        //String sign = request.getParameter("f");

        /*if("m".equals(sign)) {

            // 转发：多个请求为一个请求(地址栏不会发生改变)
            // 注意: 该路径默认是从 web 开始找的 / 表示 web
            // 转发到修改页面
            request.getRequestDispatcher("/edit.jsp").forward(request,response);
        } else if("d".equals(sign)) {
            // 跳转到详情页面
            request.getRequestDispatcher("/detail.jsp").forward(request,response);
        }*/

        // 或者优化
        // 注意 无论是转发还是重定向都是从 “/” 开始的
        // request.getParameter()拿到的是 f=edit，还是f=detail 就是跳转到的哪个页面
        //<a href="<%=request.getContextPath()%>/dept/detail?f=edit&dno=<%=dept.getDeptno()%>">修改</a>
        //<a href="<%=request.getContextPath()%>/dept/detail?f=detail&dno=<%=dept.getDeptno()%>">详情</a>
        String forward = "/" + request.getParameter("f") + ".jsp";
        request.getRequestDispatcher(forward).forward(request, response);
    }


    /**
     * 连接数据库，查询所有的部门信息，将部门信息收集好，然后跳转到JSP页面展示
     *
     * @param request
     * @param response
     */
    private void doList(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("UTF-8");  // 设置获取的的信息的编码集
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        // 创建一个集合List 存储查询到的信息
        List<Dept> depts = new ArrayList<Dept>();


        try {
            // 连接数据库，查询所有部门:
            // 1. 注册驱动,获取连接
            connection = DBUtil.getConnection();
            // 2. 获取操作数据库对象，预编译sql语句
            String sql = "select depton as det,dname,loc from dept"; // 在mysql中测试一下是否正确
            preparedStatement = connection.prepareStatement(sql);

            // 3. 执行sql语句
            resultSet = preparedStatement.executeQuery();

            // 4. 处理查询结果集
            while (resultSet.next()) {
                String det = resultSet.getString("det");  // 有别名要使用别名
                String dname = resultSet.getString("dname");
                String loc = resultSet.getString("loc");

                Dept dept = new Dept(det, dname, loc);

                // 将部门对象放到List集合当中
                depts.add(dept);

            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {

            // 5. 关闭资源
            DBUtil.close(connection, preparedStatement, resultSet);
        }


        // 查询到数据，将数据提交给 list.jsp 显示数据
        // 将集合存储的数据放到请求域当中，用于其他Servlet 使用 jsp 也是Servelt
        request.setAttribute("depList", depts);

        // 转发(注意不要重定向)，重定向无法共用 request 请求域当中的数据
        // 转发路径，/ 默认是从 web 目录开始找的
        request.getRequestDispatcher("/list.jsp").forward(request, response);
    }
}

用户界面的优化：显示登录的用户名：(该用户名信息，从存储到 session 会话对象当中，获取到的。)

核心代码如下：

需要注意的点就是：这里我们使用的是 JSP 内置的 session 对象，所以在这个 JSP页面当，你不可以把 session 禁用了。

不要设置这个禁用 session 的指令： <%@page session = false %>

在这里插入图片描述

优化演示：

在这里插入图片描述

8. 总结:

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

在这里插入图片描述

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

9. 最后：

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

posted @ 2023-04-29 21:56 Rainbow-Sea 阅读(160) 评论(0) 编辑收藏举报

刷新页面返回顶部

TheMagicalRainbowSea

一个人的资金一定是与他(她)的能力相匹配的，无一例外。掘金: [ https://juejin.cn/user/752533564566951 ] 腾讯云: [ https://cloud.tencent.com/developer/user/10317357 ] CSDN: [ https://blog.csdn.net/weixin_61635597?spm=1000.2115.3001.5343 ]

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

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

每博一文案

1. session 会话机制的概述

2. 什么是 session 的会话

3. session 的作用

4. session 的实现原理解释

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

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

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

8. 总结:

9. 最后：

公告

TheMagicalRainbowSea

一个人的资金一定是与他(她)的能力相匹配的，无一例外。 掘金: [ https://juejin.cn/user/752533564566951 ] 腾讯云: [ https://cloud.tencent.com/developer/user/10317357 ] CSDN: [ https://blog.csdn.net/weixin_61635597?spm=1000.2115.3001.5343 ]

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

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

每博一文案

1. session 会话机制的概述

2. 什么是 session 的会话

3. session 的作用

4. session 的实现原理解释

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

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

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

8. 总结:

9. 最后：

公告

一个人的资金一定是与他(她)的能力相匹配的，无一例外。掘金: [ https://juejin.cn/user/752533564566951 ] 腾讯云: [ https://cloud.tencent.com/developer/user/10317357 ] CSDN: [ https://blog.csdn.net/weixin_61635597?spm=1000.2115.3001.5343 ]

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