image.png

什么是会话技术

1.用户打开同一个浏览器，访问到我们的web服务器的资源建立会话，对方断开连接该会话才会结束，在一次会话中可以包含多次请求和响应。通俗易懂的理解：一种维护浏览器状态的方法，服务器需要识别多次请求是否来自于用一个浏览器，以便于在同一次会话的多次请求间共享数据。
2.这是因为http协议是无状态的，每次浏览器向服务器请求时，没有绑定会话信息服务器都会认为该请求是为新请求，没有任何记忆功能，所以我们需要会话跟踪技术实现会话内数据共享。
会话技术实现方式
实现方式：
1.客户端会话跟踪技术：Cookie
2.服务端会话跟踪技术：Session
3.token或者jwt——新的

cookie

什么是Cookie

Cookie:客户端会话技术，将数据保存到客户端，以后每次请求都携带Cookie数据进行访问
Cookie 数据存放在浏览器端(客户端)

创建Cookie

1.创建Cookie
Cookie cookie = new Cookie(“key”,”value”);
2.使用response响应Cookie给客户端（浏览器）
response.addCookie(cookie);
3.使用response响应Cookie给客户端（浏览器）
image.png

获取Cookie

获取客户端携带的所有Cookie，使用request对象

  1. Cookie[] cookies = request.getCookies();
  2. cookie.getName();
  3. cookie.getValue();
  1. package com.mayikt.servlet;
  3. import jakarta.servlet.ServletException;
  4. import jakarta.servlet.annotation.WebServlet;
  5. import jakarta.servlet.http.Cookie;
  6. import jakarta.servlet.http.HttpServlet;
  7. import jakarta.servlet.http.HttpServletRequest;
  8. import jakarta.servlet.http.HttpServletResponse;
  10. import java.io.IOException;
  12. /**
  13.  * @author 余胜军
  14.  * @ClassName AddCookieServlet
  15.  * @qq 644064779
  16.  * @addres www.mayikt.com
  17.  * 微信:yushengjun644
  18.  */
  19. @WebServlet("/addCookieServlet")
  20. public class AddCookieServlet extends HttpServlet {
  21.     @Override
  22.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  23.         Cookie cookie = new Cookie("mayikt", "yushengjun");
  24.         resp.addCookie(cookie);
  25.     }
  26. }
  27. package com.mayikt.servlet;
  29. import jakarta.servlet.ServletException;
  30. import jakarta.servlet.annotation.WebServlet;
  31. import jakarta.servlet.http.Cookie;
  32. import jakarta.servlet.http.HttpServlet;
  33. import jakarta.servlet.http.HttpServletRequest;
  34. import jakarta.servlet.http.HttpServletResponse;
  36. import java.io.IOException;
  38. /**
  39.  * @author 余胜军
  40.  * @ClassName GetCookieServlet
  41.  * @qq 644064779
  42.  * @addres www.mayikt.com
  43.  * 微信:yushengjun644
  44.  */
  45. @WebServlet("/getCookieServlet")
  46. public class GetCookieServlet extends HttpServlet {
  47.     @Override
  48.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  49.         Cookie[] cookies = req.getCookies();
  50.         for (int i = 0; i < cookies.length; i++) {
  51.             Cookie cookie = cookies[i];
  52.             System.out.println("key:" + cookie.getName() + "," +cookie.getValue());
  53.         }
  54.     }
  55. }

在没有清理浏览器缓存的情况下？请问重启tomcat服务器？cookie数据会丢失吗？
不会的

Cookie的原理解析

基本实现原理

Cookie实现是基于HTTP协议的
1.响应头：set—cookie
客户端（浏览器端）发送请求达到服务器端，服务器端会创建cookie，会将该cookie数据
返回给客户端，在响应头中设置 set—cookie value cookie数据。
image.png
2.请求头：cookie
同一个浏览器发送请求时，在请求中设置该cookie数据 存放在请求头中。
cookie value

Cookie过期时间

setMaxAge(int seconds):设置Cookie存活时间
1.正数：将Cookie写入浏览器所在的电脑硬盘，持久化存储，到期自动删除
2.负数：默认值，Cookie存储在浏览器内存中，当浏览器关闭，内存释放，则Cookie被销毁。
3.零：删除对应Cookie

session使用

1.服务器端会话跟踪技术：将数据保存在服务器端
底层基于cookie实现封装的
2.常用的API：
2.1void session.setAttribute(k,v) session存入值 key=name,value ‘yushengjun’
2.2Object session.getAttribute(k) 获取到session中的值
2.3void removeAttribute(k) 删除我们的session

session原理

1.当我们客户端发送请求达到服务器端时创建session，会得到一个sessionid，在将该
sessionid 响应在响应头
2.客户端（浏览器）接受响应头中的sessionid ，会将该sessionid的值 存放在浏览器中。
session本质上就是基于cookie实现封装的。
3.使用同一个浏览器发送请求时，访问通一个服务器端，会在请求头中设定该sessionid 的值，服务器端就会从请求头中获取到该sessionid 查找对应session。
session 数据存放在服务器端 cookie将数据存放在本地。

image.png

session细节

1.当客户端关闭后，服务器不关闭的话，获取到的session是否是同一个。因为客户端关闭后，cookie对象被销毁，客户端请求服务器会创建新的session。如果需要相同，可以设置cookie的最大存活时间，让cookie持久化保存两次获取Session是否为同一个
2.在默认情况下，不是同一个。如果需要两个Session相同，则可以创建一个Cookie对象，key为：JSESSIONID，设置一下最大存活时间，让Cookie持久化保存Session的ID，就可以实现客户端关闭，两次获取Session就是同一个。

  1. Cookie c = new Cookie("JSESSIONID",session.getId());
  2.         c.setMaxAge(60*60); //1个小时有效期
  3.         response.addCookie(c);

2.客户端不关闭，服务器关闭后的话，两次获取的Session是同一个吗？
不是同一个，但是为了确保数据不丢失，因为同样服务器关闭后session对象会被销毁 ，如果想确保数据不丢失，可以使session钝化，即在服务器正常关闭之前，将session对象序列化到硬盘上。下次在服务器启动后，将session文件反序列化转化为内存中的session对象即可。
0D202066E021E4F4FB978F1647C0D742
tomcat自动完成以下工作：
1.session的钝化：在服务器正常关闭之前，将session对象系列化到硬盘上。
2.session的活化： 在服务器启动后，将session文件转化为内存中的session对象即可。
3.session什么时候被销毁？
1.服务器关闭；
2.session对象调用invalidate() ；
3.session默认失效时间 30分钟。
token—-

session与cookie区别

1.session用于存储一次会话的多次请求的数据，存在服务器端；
2.session可以存储任意类型，任意大小的数据。
session与Cookie的区别：
1.session存储数据在服务器端，Cookie在客户端；
2.session没有数据大小限制，Cookie有数据大小限制；
3.session数据安全，Cookie相对于不安全。

用户登录注册案例

用户登录

使用session保存用户会话信息。

数据库访问层

  1. package com.mayikt.dao;
  3. import com.mayikt.entity.MayiktUserEntity;
  4. import com.mayikt.utils.MayiktJdbcUtils;
  6. import java.sql.Connection;
  7. import java.sql.PreparedStatement;
  8. import java.sql.ResultSet;
  10. /**
  11. * @author 余胜军
  12. * @ClassName MayiktDao
  13. * @qq 644064779
  14. * @addres www.mayikt.com
  15. * 微信:yushengjun644
  16. */
  17. public class MayikUsertDao {
  19.     /**
  20.     * 用户登录成功之后 该方法返回 用户登录成功之后对象
  21.     */
  22.     public MayiktUserEntity login(String userName, String userPwd) {
  23.         try {
  24.             Connection connection = MayiktJdbcUtils.getConnection();
  25.             String loginSql = "select  * from  mayikt_users where userName=? and userPwd=?;";
  26.             PreparedStatement preparedStatement = connection.prepareStatement(loginSql);
  27.             preparedStatement.setString(1, userName);
  28.             preparedStatement.setString(2, userPwd);
  29.             ResultSet resultSet = preparedStatement.executeQuery();
  30.             if (!resultSet.next()) {  // 查询不到用户数据
  31.                 return null;
  32.             }
  33.             // 将db中数据 返回给客户端 查询到数据
  34.             Integer id = resultSet.getInt(1);
  35.             String dbUserName = resultSet.getString(2);
  36.             String dbUserPwd = resultSet.getString(3);
  37.             MayiktUserEntity mayiktUserEntity = new MayiktUserEntity(id, dbUserName, dbUserPwd);
  38.             return mayiktUserEntity;
  39.         } catch (Exception e) {
  40.             e.printStackTrace();
  41.             return null;
  42.         }
  44.     }
  45. }

业务逻辑层

  1. package com.mayikt.service;
  3. import com.mayikt.dao.MayikUsertDao;
  4. import com.mayikt.entity.MayiktUserEntity;
  6. /**
  7.  * @author 余胜军
  8.  * @ClassName MayikUsertService
  9.  * @qq 644064779
  10.  * @addres www.mayikt.com
  11.  * 微信:yushengjun644
  12.  */
  13. public class MayikUsertService {
  14.     private MayikUsertDao mayikUsertDao = new MayikUsertDao();
  16.     public MayiktUserEntity login(String userName, String userPwd) {
  17.         return mayikUsertDao.login(userName, userPwd);
  18.     }
  19. }

视图层

  1. package com.mayikt.servlet;
  3. import com.mayikt.entity.MayiktUserEntity;
  4. import com.mayikt.service.MayikUsertService;
  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;
  11. import org.apache.commons.lang3.StringUtils;
  13. import java.io.IOException;
  15. /**
  16.  * @author 余胜军
  17.  * @ClassName LoginServlet
  18.  * @qq 644064779
  19.  * @addres www.mayikt.com
  20.  * 微信:yushengjun644
  21.  */
  22. @WebServlet("/login")
  23. public class LoginServlet extends HttpServlet {
  24.     private MayikUsertService mayikUsertService = new MayikUsertService();
  26.     @Override
  27.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  28.         // 转发login页面
  29.         req.getRequestDispatcher("login.jsp").forward(req, resp);
  30.     }
  32.     @Override
  33.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  34.         // 点击登录的时候 获取到用户的参数
  35.         String userName = req.getParameter("userName");
  36.         if (StringUtils.isEmpty(userName)) {
  37.             //转发到错误页面
  38.             req.setAttribute("errorMsg", "用户名称不能够是为空!");
  39.             req.getRequestDispatcher("error.jsp").forward(req, resp);
  40.             return;
  41.         }
  42.         String userPwd = req.getParameter("userPwd");
  43.         // 参数验证
  44.         if (StringUtils.isEmpty(userPwd)) {
  45.             //转发到错误页面
  46.             req.setAttribute("errorMsg", "userPwd不能够是为空!");
  47.             req.getRequestDispatcher("error.jsp").forward(req, resp);
  48.             return;
  49.         }
  50.         // 在调用业务逻辑层
  51.         MayiktUserEntity mayiktUserEntity = mayikUsertService.login(userName, userPwd);
  52.         if (mayiktUserEntity == null) {
  53.             // 用户名称或者密码错误!
  54.             req.setAttribute("errorMsg", "用户名称或者是密码错误!");
  55.             req.getRequestDispatcher("login.jsp").forward(req, resp);
  56.             return;
  57.         }
  58.         // 能够db中查询到对象 登录成功了  将用户数据存放在session中
  59.         HttpSession session = req.getSession();
  60.         session.setAttribute("user", mayiktUserEntity);
  61.         // 在转发到首页（重定向到首页）
  62. //        req.getRequestDispatcher("index.jsp").forward(req, resp);
  63.         resp.sendRedirect("index.jsp");
  64.     }
  65. }
  1. <%--
  2.   Created by IntelliJ IDEA.
  3.   User: mayikt
  4.   Date: 2022/6/6
  5.   Time: 17:12
  6.   To change this template use File | Settings | File Templates.
  7. --%>
  8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  9. <!DOCTYPE html>
  10. <html>
  11. <head>
  12.     <title>登录测试页面</title>
  13.     <form action="/mayikt_session_war_exploded/login" method="post">
  14.         <label>用户名: </label><input type="text" name="userName"/><br>
  15.         <label>密&nbsp码&nbsp: </label><input type="password" name="userPwd"/><br>
  16.         ${errorMsg}
  17.         <input type="submit" value="登录 "/>
  18.     </form>
  20. </head>
  21. </html>

相关配置文件

  1. driverClass=com.mysql.cj.jdbc.Driver
  2. url=jdbc:mysql://127.0.0.1:3306/mayikt?serverTimezone=GMT%2B8
  3. user=root
  4. password=root

记住密码

思路：
用户登录成功之后，会将用户的名称和密码 写入在cookie中，
当我们用户下次登录时，会直接从cookie中获取到数据 回显到
login.jsp中 这样的话就不需要用户重复的数据用户名称和密码。

image.png

改造servlet

  1. package com.mayikt.servlet;
  3. import com.mayikt.entity.MayiktUserEntity;
  4. import com.mayikt.service.MayikUsertService;
  5. import jakarta.servlet.ServletException;
  6. import jakarta.servlet.annotation.WebServlet;
  7. import jakarta.servlet.http.*;
  8. import org.apache.commons.lang3.StringUtils;
  10. import java.io.IOException;
  12. /**
  13.  * @author 余胜军
  14.  * @ClassName LoginServlet
  15.  * @qq 644064779
  16.  * @addres www.mayikt.com
  17.  * 微信:yushengjun644
  18.  */
  19. @WebServlet("/login")
  20. public class LoginServlet extends HttpServlet {
  21.     private MayikUsertService mayikUsertService = new MayikUsertService();
  23.     @Override
  24.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  25.         // 转发login页面
  26.         req.getRequestDispatcher("login.jsp").forward(req, resp);
  27.     }
  29.     @Override
  30.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  31.         // 点击登录的时候 获取到用户的参数
  32.         String userName = req.getParameter("userName");
  33.         if (StringUtils.isEmpty(userName)) {
  34.             //转发到错误页面
  35.             req.setAttribute("errorMsg", "用户名称不能够是为空!");
  36.             req.getRequestDispatcher("error.jsp").forward(req, resp);
  37.             return;
  38.         }
  39.         String userPwd = req.getParameter("userPwd");
  40.         // 参数验证
  41.         if (StringUtils.isEmpty(userPwd)) {
  42.             //转发到错误页面
  43.             req.setAttribute("errorMsg", "userPwd不能够是为空!");
  44.             req.getRequestDispatcher("error.jsp").forward(req, resp);
  45.             return;
  46.         }
  47.         // 在调用业务逻辑层
  48.         MayiktUserEntity mayiktUserEntity = mayikUsertService.login(userName, userPwd);
  49.         if (mayiktUserEntity == null) {
  50.             // 用户名称或者密码错误!
  51.             req.setAttribute("errorMsg", "用户名称或者是密码错误!");
  52.             req.getRequestDispatcher("login.jsp").forward(req, resp);
  53.             return;
  54.         }
  55.         // 判断用户是否记住密码
  56.         String rememberPassword = req.getParameter("rememberPassword");
  57.         if ("on".equals(rememberPassword)) {
  58.             // 如果有记住密码则 将密码保存在cookie中
  59.             Cookie userNameCookie = new Cookie("userName", userName);
  60.             Cookie userPwdCookie = new Cookie("userPwd", userPwd);
  61.             resp.addCookie(userNameCookie);
  62.             resp.addCookie(userPwdCookie);
  63.         }
  64.         // 能够db中查询到对象 登录成功了  将用户数据存放在session中
  65.         HttpSession session = req.getSession();
  66.         session.setAttribute("user", mayiktUserEntity);
  67.         // 在转发到首页（重定向到首页）
  68. //        req.getRequestDispatcher("index.jsp").forward(req, resp);
  69.         resp.sendRedirect("index.jsp");
  70.     }
  71. }

改造jsp

  1. <%--
  2.   Created by IntelliJ IDEA.
  3.   User: mayikt
  4.   Date: 2022/6/6
  5.   Time: 17:12
  6.   To change this template use File | Settings | File Templates.
  7. --%>
  8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  9. <!DOCTYPE html>
  10. <html>
  11. <head>
  12.     <title>登录测试页面</title>
  13.     <form action="/mayikt_session_war_exploded/login" method="post">
  14.         <label>用户名: </label><input type="text" name="userName" value="${cookie.userName.value}"/><br>
  15.         <label>密&nbsp码&nbsp: </label><input type="password" name="userPwd" value="${cookie.userPwd.value}"/><br>
  16.         <label>记住密码: </label><input type="checkbox" name="rememberPassword"/><br>
  17.         ${errorMsg}
  18.         <input type="submit" value="登录 "/>
  19.     </form>
  21. </head>
  22. </html>

用户注册

数据库访问层

  1. package com.mayikt.dao;
  3. import com.mayikt.entity.MayiktUserEntity;
  4. import com.mayikt.utils.MayiktJdbcUtils;
  6. import java.sql.Connection;
  7. import java.sql.PreparedStatement;
  8. import java.sql.ResultSet;
  10. /**
  11. * @author 余胜军
  12. * @ClassName MayiktDao
  13. * @qq 644064779
  14. * @addres www.mayikt.com
  15. * 微信:yushengjun644
  16. */
  17. public class MayikUsertDao {
  19.     /**
  20.     * 用户登录成功之后 该方法返回 用户登录成功之后对象
  21.     */
  22.     public MayiktUserEntity login(String userName, String userPwd) {
  23.         ResultSet resultSet = null;
  24.         PreparedStatement preparedStatement = null;
  25.         Connection connection = null;
  26.         try {
  27.             connection = MayiktJdbcUtils.getConnection();
  28.             String loginSql = "select  * from  mayikt_users where userName=? and userPwd=?;";
  29.             preparedStatement = connection.prepareStatement(loginSql);
  30.             preparedStatement.setString(1, userName);
  31.             preparedStatement.setString(2, userPwd);
  32.             resultSet = preparedStatement.executeQuery();
  33.             if (!resultSet.next()) {  // 查询不到用户数据
  34.                 return null;
  35.             }
  36.             // 将db中数据 返回给客户端 查询到数据
  37.             Integer id = resultSet.getInt(1);
  38.             String dbUserName = resultSet.getString(2);
  39.             String dbUserPwd = resultSet.getString(3);
  40.             MayiktUserEntity mayiktUserEntity = new MayiktUserEntity(id, dbUserName, dbUserPwd);
  41.             return mayiktUserEntity;
  42.         } catch (Exception e) {
  43.             e.printStackTrace();
  44.             return null;
  45.         } finally {
  46.             MayiktJdbcUtils.closeConnection(resultSet, preparedStatement, connection);
  47.         }
  48.     }
  50.     public MayiktUserEntity findByUserName(String userName) {
  51.         ResultSet resultSet = null;
  52.         PreparedStatement preparedStatement = null;
  53.         Connection connection = null;
  54.         try {
  55.             connection = MayiktJdbcUtils.getConnection();
  56.             String loginSql = "select  * from  mayikt_users where userName=?";
  57.             preparedStatement = connection.prepareStatement(loginSql);
  58.             preparedStatement.setString(1, userName);
  59.             resultSet = preparedStatement.executeQuery();
  60.             if (!resultSet.next()) {  // 查询不到用户数据
  61.                 return null;
  62.             }
  63.             // 将db中数据 返回给客户端 查询到数据
  64.             Integer id = resultSet.getInt(1);
  65.             String dbUserName = resultSet.getString(2);
  66.             String dbUserPwd = resultSet.getString(3);
  67.             MayiktUserEntity mayiktUserEntity = new MayiktUserEntity(id, dbUserName, dbUserPwd);
  68.             return mayiktUserEntity;
  69.         } catch (Exception e) {
  70.             e.printStackTrace();
  71.             return null;
  72.         } finally {
  73.             MayiktJdbcUtils.closeConnection(resultSet, preparedStatement, connection);
  74.         }
  75.     }
  77.     public int register(String userName, String userPwd) {
  78.         Connection connection = null;
  79.         PreparedStatement preparedStatement = null;
  80.         try {
  81.             connection = MayiktJdbcUtils.getConnection();
  82.             // sql语句写的操作 ----加上事务
  83.             MayiktJdbcUtils.beginTransaction(connection); // 开启事务
  84.             String insertSql = "INSERT INTO `mayikt`.`mayikt_users` (`id`, `userName`, `userPwd`) VALUES (null, ?, ?);";
  85.             preparedStatement = connection.prepareStatement(insertSql);
  86.             preparedStatement.setString(1, userName);
  87.             preparedStatement.setString(2, userPwd);
  88.             int result = preparedStatement.executeUpdate();
  89.             // 代码执行没有问题的情况下 则会提交数据
  90.             MayiktJdbcUtils.commitTransaction(connection); // 提交事务
  91.             return result;
  92.         } catch (Exception e) {
  93.             // 程序代码报错之后 是需要回滚事务
  94.             e.printStackTrace();
  95.             MayiktJdbcUtils.rollBackTransaction(connection);// 回滚事务
  96.             return 0;
  97.         } finally {
  98.             MayiktJdbcUtils.closeConnection(preparedStatement, connection);
  99.         }
  101.     }
  102. }

业务逻辑层

  1.     public int register(String userName, String userPwd) {
  2.         return mayikUsertDao.register(userName, userPwd);
  3.     }
  5.     public MayiktUserEntity findByUserName(String userName) {
  6.         return mayikUsertDao.findByUserName(userName);
  7.     }

视图层

  1. package com.mayikt.servlet;
  3. import com.mayikt.entity.MayiktUserEntity;
  4. import com.mayikt.service.MayikUsertService;
  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 org.apache.commons.lang3.StringUtils;
  12. import java.io.IOException;
  14. /**
  15.  * @author 余胜军
  16.  * @ClassName RegisterServlet
  17.  * @qq 644064779
  18.  * @addres www.mayikt.com
  19.  * 微信:yushengjun644
  20.  */
  21. @WebServlet("/register")
  22. public class RegisterServlet extends HttpServlet {
  23.     private MayikUsertService mayikUsertService = new MayikUsertService();
  25.     @Override
  26.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  27.         // 转发到register.jsp
  28.         req.getRequestDispatcher("register.jsp").forward(req, resp);
  29.     }
  31.     @Override
  32.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  33.         // 转发到注册插入数据
  34.         // 点击注册的时候 获取到用户的参数
  35.         String userName = req.getParameter("userName");
  36.         if (StringUtils.isEmpty(userName)) {
  37.             //转发到错误页面
  38.             req.setAttribute("errorMsg", "用户名称不能够是为空!");
  39.             req.getRequestDispatcher("register.jsp").forward(req, resp);
  40.             return;
  41.         }
  42.         String userPwd = req.getParameter("userPwd");
  43.         // 参数验证
  44.         if (StringUtils.isEmpty(userPwd)) {
  45.             //转发到错误页面
  46.             req.setAttribute("errorMsg", "userPwd不能够是为空!");
  47.             req.getRequestDispatcher("register.jsp").forward(req, resp);
  48.             return;
  49.         }
  50.         // 用户注册之前根据用户名称查询该用户是否存在如果不存在的情况下才可以注册 如果存在的话就无法注册
  51.         MayiktUserEntity dbMayiktUserEntity = mayikUsertService.findByUserName(userName);
  52.         if (dbMayiktUserEntity != null) {
  53.             req.setAttribute("errorMsg", "该用户" + userName + ",在数据库中存在无法重复注册！");
  54.             req.getRequestDispatcher("register.jsp").forward(req, resp);
  55.             return;
  56.         }
  57.         //用户数据注册
  58.         int register = mayikUsertService.register(userName, userPwd);
  59.         if (register <= 0) {
  60.             // 注册失败了   //转发到错误页面
  61.             req.setAttribute("errorMsg", "注册失败!");
  62.             req.getRequestDispatcher("register.jsp").forward(req, resp);
  63.             return;
  64.         }
  65.         // 注册成功之后就直接重定向到登录请求
  66.         resp.sendRedirect("login");
  67.     }
  68. }
  1. <%--
  2.   Created by IntelliJ IDEA.
  3.   User: mayikt
  4.   Date: 2022/6/6
  5.   Time: 17:12
  6.   To change this template use File | Settings | File Templates.
  7. --%>
  8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  9. <!DOCTYPE html>
  10. <html>
  11. <head>
  12.     <title>注册页面</title>
  13.     <form action="/mayikt_session_war_exploded/register" method="post">
  14.         <label>用户名: </label><input type="text" name="userName"/><br>
  15.         <label>密&nbsp&nbsp&nbsp码: </label><input type="password" name="userPwd"/><br>
  16.         <span style="color: red">${errorMsg}</span>
  17.         <input type="submit" value="注册"/>
  18.     </form>
  20. </head>
  21. </html>

图形验证码

图形底层实现原理
java支持根据内容生成图片
abcd 企业实际开发中图形验证码工具类 底层细节我们自己去开发的

1.生成图形验证码内容 abch
2.调用java的api 将我们的该内容 生成一张图片abch
3.将该形验证码内容 abch 存放在session中

用户点击注册时：获取用户输入的图形验证码和session中验证码比对 如果一致的情况下
则开始做注册流程。

image.png

图形验证码工具类

  1. package com.mayikt.utils;
  3. import jakarta.servlet.http.HttpServletRequest;
  4. import jakarta.servlet.http.HttpServletResponse;
  5. import jakarta.servlet.http.HttpSession;
  7. import java.awt.Color;
  8. import java.awt.Font;
  9. import java.awt.Graphics;
  10. import java.awt.image.BufferedImage;
  11. import java.util.Random;
  12. import javax.imageio.ImageIO;
  14. /**
  15.  * 工具类,生成随机验证码
  16.  */
  17. public class RandomValidateCode {
  18.     public static final String MAYIKT_RANDOMVALIDATECODE = "RandomValidateCode";// 放到session中的key
  19.     private Random random = new Random();
  20.     private String randString = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";//随机产生的字符串
  21.     private int width = 100;// 图片宽度
  22.     private int height = 26;// 图片高度
  23.     private int lineSize = 40;// 干扰线数量
  24.     private int stringNum = 4;// 随机产生的字符数量
  26.     /*
  27.      * 获得字体
  28.      */
  29.     private Font getFont() {
  30.         return new Font("Fixedsys", Font.CENTER_BASELINE, 18);
  31.     }
  33.     /*
  34.      * 获得颜色
  35.      */
  36.     private Color getRandColor(int fc, int bc) {
  37.         if (fc > 255)
  38.             fc = 255;
  39.         if (bc > 255)
  40.             bc = 255;
  41.         int r = fc + random.nextInt(bc - fc - 16);
  42.         int g = fc + random.nextInt(bc - fc - 14);
  43.         int b = fc + random.nextInt(bc - fc - 18);
  44.         return new Color(r, g, b);
  45.     }
  47.     /**
  48.      * 生成随机图片
  49.      */
  50.     public void getRandcode(HttpServletRequest request, HttpServletResponse response) {
  51.         HttpSession session = request.getSession();
  52.         // BufferedImage类是具有缓冲区的Image类,Image类是用于描述图像信息的类
  53.         BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_BGR);
  54.         Graphics g = image.getGraphics();// 产生Image对象的Graphics对象,该对象可以在图像上进行各种绘制操作
  55.         g.fillRect(0, 0, width, height);
  56.         g.setFont(new Font("Times New Roman", Font.ROMAN_BASELINE, 18));
  57.         g.setColor(getRandColor(110, 133));
  58.         // 绘制干扰线
  59.         for (int i = 0; i <= lineSize; i++) {
  60.             drowLine(g);
  61.         }
  62.         // 绘制随机字符
  63.         String randomString = "";
  64.         for (int i = 1; i <= stringNum; i++) {
  65.             randomString = drowString(g, randomString, i);
  66.         }
  67.         session.removeAttribute(MAYIKT_RANDOMVALIDATECODE);
  68.         session.setAttribute(MAYIKT_RANDOMVALIDATECODE, randomString);
  69.         g.dispose();
  70.         try {
  71.             ImageIO.write(image, "JPEG", response.getOutputStream());// 将内存中的图片通过流动形式输出到客户端
  72.         } catch (Exception e) {
  73.             e.printStackTrace();
  74.         }
  75.     }
  77.     /*
  78.      * 绘制字符串
  79.      */
  80.     private String drowString(Graphics g, String randomString, int i) {
  81.         g.setFont(getFont());
  82.         g.setColor(new Color(random.nextInt(101), random.nextInt(111), random.nextInt(121)));
  83.         String rand = getRandomString(random.nextInt(randString.length()));
  84.         randomString += rand;
  85.         g.translate(random.nextInt(3), random.nextInt(3));
  86.         g.drawString(rand, 13 * i, 16);
  87.         return randomString;
  88.     }
  90.     /*
  91.      * 绘制干扰线
  92.      */
  93.     private void drowLine(Graphics g) {
  94.         int x = random.nextInt(width);
  95.         int y = random.nextInt(height);
  96.         int xl = random.nextInt(13);
  97.         int yl = random.nextInt(15);
  98.         g.drawLine(x, y, x + xl, y + yl);
  99.     }
  101.     /*
  102.      * 获取随机的字符
  103.      */
  104.     public String getRandomString(int num) {
  105.         return String.valueOf(randString.charAt(num));
  106.     }
  107. }
  109. package com.mayikt.servlet;
  111. import jakarta.servlet.ServletException;
  112. import jakarta.servlet.annotation.WebServlet;
  113. import jakarta.servlet.http.HttpServlet;
  114. import jakarta.servlet.http.HttpServletRequest;
  115. import jakarta.servlet.http.HttpServletResponse;
  117. import java.io.IOException;
  119. /**
  120.  * 前台验证码处点击刷新,发送到该servlet的请求,
  121.  * 该servlet调用生成验证码的工具类返回一个图像验证码
  122.  */
  123. @WebServlet(name = "VerifycodeServlet", urlPatterns = "/VerifycodeServlet")
  124. public class VerifycodeServlet extends HttpServlet {
  125.     private static final long serialVersionUID = 1L;
  127.     public void doGet(HttpServletRequest request, HttpServletResponse response)
  128.             throws ServletException, IOException {
  129.         response.setContentType("image/jpeg");//设置相应类型,告诉浏览器输出的内容为图片
  130.         response.setHeader("Pragma", "No-cache");//设置响应头信息，告诉浏览器不要缓存此内容
  131.         //做浏览器兼容
  132.         response.setHeader("Cache-Control", "no-cache");
  133.         response.setDateHeader("Expire", 0);
  134.         RandomValidateCode randomValidateCode = new RandomValidateCode();
  135.         try {
  136.             randomValidateCode.getRandcode(request, response);//输出图片方法
  137.         } catch (Exception e) {
  138.             e.printStackTrace();
  139.         }
  140.     }
  142.     public void doPost(HttpServletRequest request, HttpServletResponse response)
  143.             throws ServletException, IOException {
  144.         doGet(request, response);
  145.     }
  146. }

注册jsp加上图形验证码

  1. <%--
  2.   Created by IntelliJ IDEA.
  3.   User: mayikt
  4.   Date: 2022/6/6
  5.   Time: 17:12
  6.   To change this template use File | Settings | File Templates.
  7. --%>
  8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  9. <!DOCTYPE html>
  10. <html>
  11. <head>
  12.     <title>注册页面</title>
  13.     <form action="/mayikt_session_war_exploded/register" method="post">
  14.         <label>用户名: </label><input type="text" name="userName"/><br>
  15.         <label>密&nbsp&nbsp&nbsp码: </label><input type="password" name="userPwd"/><br>
  16.         <label>验证码: </label><input type="text" name="code"/><img id="exchangecode" src="VerifycodeServlet">
  17.         <a id="ecode" href="#">看不清？换一张图片</a><br>
  18.         <span style="color: red">${errorMsg}</span>
  19.         <input type="submit" value="注册"/>
  20.     </form>
  21.     <script type="text/javascript">
  22.         window.onload = function () {
  23.             //获取img标签的对象
  24.             img = document.getElementById("exchangecode");
  25.             img.onclick = function () {
  26.                 //加时间戳,避免浏览器缓存
  27.                 var date = new Date().getTime()
  28.                 img.src = "VerifycodeServlet?" + date;
  29.             }
  30.             //获取a标签的对象
  31.             ec = document.getElementById("ecode");
  32.             ec.onclick = function () {
  33.                 //加时间戳
  34.                 var date = new Date().getTime()
  35.                 img.src = "VerifycodeServlet?" + date;
  36.             }
  37.         }
  39.     </script>
  40. </head>
  41. </html>

注册验证图形验证码

  1. package com.mayikt.servlet;
  3. import com.mayikt.entity.MayiktUserEntity;
  4. import com.mayikt.service.MayikUsertService;
  5. import com.mayikt.utils.RandomValidateCode;
  6. import jakarta.servlet.ServletException;
  7. import jakarta.servlet.annotation.WebServlet;
  8. import jakarta.servlet.http.HttpServlet;
  9. import jakarta.servlet.http.HttpServletRequest;
  10. import jakarta.servlet.http.HttpServletResponse;
  11. import jakarta.servlet.http.HttpSession;
  12. import org.apache.commons.lang3.StringUtils;
  14. import java.io.IOException;
  16. /**
  17.  * @author 余胜军
  18.  * @ClassName RegisterServlet
  19.  * @qq 644064779
  20.  * @addres www.mayikt.com
  21.  * 微信:yushengjun644
  22.  */
  23. @WebServlet("/register")
  24. public class RegisterServlet extends HttpServlet {
  25.     private MayikUsertService mayikUsertService = new MayikUsertService();
  27.     @Override
  28.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  29.         // 转发到register.jsp
  30.         req.getRequestDispatcher("register.jsp").forward(req, resp);
  31.     }
  33.     @Override
  34.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  35.         // 转发到注册插入数据
  36.         // 点击注册的时候 获取到用户的参数
  37.         String userName = req.getParameter("userName");
  38.         if (StringUtils.isEmpty(userName)) {
  39.             //转发到错误页面
  40.             req.setAttribute("errorMsg", "用户名称不能够是为空!");
  41.             req.getRequestDispatcher("register.jsp").forward(req, resp);
  42.             return;
  43.         }
  44.         String userPwd = req.getParameter("userPwd");
  45.         // 参数验证
  46.         if (StringUtils.isEmpty(userPwd)) {
  47.             //转发到错误页面
  48.             req.setAttribute("errorMsg", "userPwd不能够是为空!");
  49.             req.getRequestDispatcher("register.jsp").forward(req, resp);
  50.             return;
  51.         }
  52.         // 图形验证码  比较 是在 注册之前
  53.         // 比较图形验证码
  54.         String userCode = req.getParameter("code"); // 用户输入的图形验证码
  55.         // 从session中获取图形验证码
  56.         HttpSession session = req.getSession();
  57.         String sessionCode = (String) session.getAttribute(RandomValidateCode.MAYIKT_RANDOMVALIDATECODE);
  58.         if (!sessionCode.equalsIgnoreCase(userCode)) {
  59.             req.setAttribute("errorMsg", "图形验证码不正确，请重新输入!");
  60.             req.getRequestDispatcher("register.jsp").forward(req, resp);
  61.             return;
  62.         }
  63.         // 用户注册之前根据用户名称查询该用户是否存在如果不存在的情况下才可以注册 如果存在的话就无法注册
  64.         MayiktUserEntity dbMayiktUserEntity = mayikUsertService.findByUserName(userName);
  65.         if (dbMayiktUserEntity != null) {
  66.             req.setAttribute("errorMsg", "该用户" + userName + ",在数据库中存在无法重复注册！");
  67.             req.getRequestDispatcher("register.jsp").forward(req, resp);
  68.             return;
  69.         }
  70.         //用户数据注册
  71.         int register = mayikUsertService.register(userName, userPwd);
  72.         if (register <= 0) {
  73.             // 注册失败了   //转发到错误页面
  74.             req.setAttribute("errorMsg", "注册失败!");
  75.             req.getRequestDispatcher("register.jsp").forward(req, resp);
  76.             return;
  77.         }
  78.         // 注册成功之后就直接重定向到登录请求
  79.         resp.sendRedirect("login");
  80.     }
  81. }

过滤器

过滤器应用场景

过滤器是处于客户端与服务器资源文件之间的一道过滤网，在访问资源文件之前，通过一系列的过滤器对请求进行修改、判断等，把不符合规则的请求在中途拦截或修改。也可以对响应进行过滤，拦截或修改响应.
应用场景： 判断用户是否登录、过滤器请求记录日志、身份验证、权限控制等。
什么是过滤器 拦截过滤请求
过滤器可以 减少代码冗余性问题

使用方式

  1. package com.mayikt.filter;
  3. import jakarta.servlet.*;
  4. import jakarta.servlet.annotation.WebFilter;
  5. import jakarta.servlet.http.HttpServletRequest;
  6. import jakarta.servlet.http.HttpServletResponse;
  8. import java.io.IOException;
  9. import java.io.PrintWriter;
  10. import java.util.logging.LogRecord;
  12. /**
  13. * @author 余胜军
  14. * @ClassName MayiktFilter
  15. * @qq 644064779
  16. * @addres www.mayikt.com
  17. * 微信:yushengjun644
  18. */
  19. @WebFilter("/*")
  20. public class MayiktFilter implements Filter {
  22.     @Override
  23.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
  24.         HttpServletRequest req = (HttpServletRequest) servletRequest;
  25.         HttpServletResponse response = (HttpServletResponse) servletResponse;
  26.         response.setHeader("Content-type", "text/html;utf-8");
  27.         String userName = req.getParameter("userName");
  28.         if (!"mayikt".equals(userName)) {
  29.             PrintWriter writer = response.getWriter();
  30.             writer.print("权限不足");
  31.             writer.close();
  32.             return;
  33.         }
  34.         //放行
  35.         filterChain.doFilter(req, response);
  36.     }
  37. }

拦截器路径配置

1.所有资源拦截：@WebFilter(“/“) //这是指访问所有资源的时候都会经过过滤器
静态资源(css/js/mp4)
2.具体资源路z径拦截：@WebFilter(“/index.jsp”) //这是指访问index.jsp的时候会经过过滤器
3.具体目录拦截：@WebFilter(“/mayik/“) //这是指访问mayikt目录下的所有资源时会经过过滤器
127.0.0.1:8080/mayikt/A
127.0.0.1:8080/mayikt/B
4.具体后缀名拦截：@WebFilter(“*.jsp”) //这时指访问后缀名为.jsp的资源时会经过过滤器

过滤器链

我们过滤器1执行完毕之后 在执行过滤器2
注解配置的Filter，优先级按照过滤器类名(字符串)的自然排序
image.png

使用过滤器验证会话信息

需求：使用过滤器验证用户的会话信息，判断用户是否已经登录 如果 没有登录的话 则跳转到登录页面。排查“loginServlet、RegisterServlet”

  1. package com.mayikt.filter;
  3. import jakarta.servlet.*;
  4. import jakarta.servlet.annotation.WebFilter;
  5. import jakarta.servlet.annotation.WebServlet;
  6. import jakarta.servlet.http.HttpServletRequest;
  7. import jakarta.servlet.http.HttpServletResponse;
  8. import jakarta.servlet.http.HttpSession;
  10. import java.io.IOException;
  12. /**
  13. * @author 余胜军
  14. * @ClassName UserSessionFilter
  15. * @qq 644064779
  16. * @addres www.mayikt.com
  17. * 微信:yushengjun644
  18. */
  19. @WebFilter("/*")// 过滤器所有的请求
  20. public class UserSessionFilter implements Filter {
  21.     private String[] excludeUrls = new String[]{"/login", "/register", "/VerifycodeServlet"};
  23.     @Override
  24.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
  25.         // 从session获取到用户的会话信息 判断用户是否登录过
  26.         HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
  27.         HttpServletResponse httpServletResponse = (HttpServletResponse) servletResponse;
  28.         // 定义一个数组 哪些 请求是需要排除的
  29.         for (int i = 0; i < excludeUrls.length; i++) {
  30.             String excludeUrl = "/mayikt_session_war_exploded" + excludeUrls[i];
  31.             String requestURI = httpServletRequest.getRequestURI();
  32.             if (excludeUrl.equals(requestURI)) {
  33.                 // 放行请求
  34.                 filterChain.doFilter(httpServletRequest, httpServletResponse);
  35.                 return;
  36.             }
  37.         }
  38.         // 排除请求
  39.         HttpSession session = httpServletRequest.getSession();
  40.         Object user = session.getAttribute("user");
  41.         if (user == null) {
  42.             // 当前用户没有登录或者登录会话失效
  43.             // 重定向到登录页面
  44.             httpServletResponse.sendRedirect("/mayikt_session_war_exploded/login");
  45.             return;
  46.         }
  47.         // 用户已经登录了 正常放行请求
  48.         filterChain.doFilter(httpServletRequest, httpServletResponse);
  49.     }
  50. }

获取当前上下文

request.contextPath();

监听器

  1. 监听器Listener就是在application,session,request三个对象创建、销毁或者往其中添加修改删除属性时自动执行代码的功能组件。
    2. Listener是Servlet的监听器，可以监听客户端的请求，服务端的操作等。
    3. Listener实现了javax.servlet.ServletContextListener 接口的服务器端程序，它也是随web应用的启动而启动，只初始化一次，随web应用的停止而销毁。主要作用是：做一些初始化的内容添加工作、设置一些基本的内容、比如一些参数或者是一些固定的对象等.
    1.ServletContext监听
    ServletContextListener：用于对Servlet整个上下文进行监听；
    ServletContextAttributeListener：对Servlet上下文属性的监听。
    2.Session监听
    HttpSessionListener接口：对Session的整体状态的监听；
    HttpSessionAttributeListener接口：对session的属性监听。
    3.Request监听
    ServletRequestListener：用于对Request请求进行监听；
    ServletRequestAttributeListener：对Request属性的监听。

Listener用法