登录认证功能中的会话技术

谁践踏了优雅 2023-09-27 17:11 54阅读 0赞

### 1.登录校验分析 ###

什么是登录校验？

所谓登录校验，指的是我们在服务器端接收到浏览器发送过来的请求之后，首先我们要对请求进行校验。先要校验一下用户登录了没有，如果用户已经登录了，就直接执行对应的业务操作就可以了；如果用户没有登录，此时就不允许他执行相关的业务操作，直接给前端响应一个错误的结果，最终跳转到登录页面，要求他登录成功之后，再来访问对应的数据。

首先我们知道HTTP协议是无状态协议。什么又是无状态的协议？

所谓无状态，指的是每一次请求都是独立的，下一次请求并不会携带上一次请求的数据。而浏览器与服务器之间进行交互，基于HTTP协议也就意味着现在我们通过浏览器来访问了登陆这个接口，实现了登陆的操作，接下来我们在执行其他业务操作时，服务器也并不知道这个员工到底登陆了没有。因为HTTP协议是无状态的，两次请求之间是独立的，所以是无法判断这个员工到底登陆了没有。

那应该怎么来实现登录校验的操作呢？具体的实现思路可以分为两部分：

1. 在员工登录成功后，需要将用户登录成功的信息存起来，记录用户已经登录成功的标记。  
2. 在浏览器发起请求时，需要在服务端进行统一拦截，拦截后进行登录校验。

我们要完成以上操作，会涉及到web开发中的两个技术：

1. 会话技术  
2. 统一拦截技术

而统一拦截技术现实方案也有两种：

1. Servlet规范中的Filter过滤器  
2. Spring提供的interceptor拦截器

### 2.会话技术 ###

#### (1)说明 ####

在web开发当中，会话指的就是浏览器与服务器之间的一次连接，我们就称为一次会话。

在用户打开浏览器第一次访问服务器的时候，这个会话就建立了，直到有任何一方断开连接，此时会话就结束了。在一次会话当中，是可以包含多次请求和响应的。比如：打开了浏览器来访问web服务器上的资源（浏览器不能关闭、服务器不能断开）

\* 第1次：访问的是登录的接口，完成登录操作  
\* 第2次：访问的是部门管理接口，查询所有部门数据  
\* 第3次：访问的是员工管理接口，查询员工数据

只要浏览器和服务器都没有关闭，以上3次请求都属于一次会话当中完成的。

会话跟踪技术：

1. Cookie（客户端会话跟踪技术）：数据存储在客户端浏览器当中  
2. Session（服务端会话跟踪技术）： 数据存储在储在服务端  
3. 令牌技术

#### (2)Cookie ####

cookie 是客户端会话跟踪技术，它是存储在客户端浏览器的，我们使用 cookie 来跟踪会话，我们就可以在浏览器第一次发起请求来请求服务器的时候，我们在服务器端来设置一个cookie。

比如第一次请求了登录接口，登录接口执行完成之后，我们就可以设置一个cookie，在 cookie 当中我们就可以来存储用户相关的一些数据信息。比如我可以在 cookie 当中来存储当前登录用户的用户名，用户的ID。

服务器端在给客户端在响应数据的时候，会**自动**的将 cookie 响应给浏览器，浏览器接收到响应回来的 cookie 之后，会**自动**的将 cookie 的值存储在浏览器本地。接下来在后续的每一次请求当中，都会将浏览器本地所存储的 cookie**自动**地携带到服务端。

![1c167bda9e494231acdbe24d88575a12.png][]

接下来在服务端我们就可以获取到 cookie 的值。我们可以去判断一下这个 cookie 的值是否存在，如果不存在这个cookie，就说明客户端之前是没有访问登录接口的；如果存在 cookie 的值，就说明客户端之前已经登录完成了。这样我们就可以基于 cookie 在同一次会话的不同请求之间来共享数据。

我刚才在介绍流程的时候，用了 3 个自动：

服务器会自动的将 cookie 响应给浏览器。  
  
浏览器接收到响应回来的数据之后，会自动的将 cookie 存储在浏览器本地。  
  
在后续的请求当中，浏览器会自动的将 cookie携带到服务器端。

为什么这一切都是自动化进行的？

是因为 cookie 它是 HTP 协议当中所支持的技术，而各大浏览器厂商都支持了这一标准。在 HTTP 协议官方给我们提供了一个响应头和请求头：

\* 响应头 Set-Cookie ：设置Cookie数据的  
  
\* 请求头 Cookie：携带Cookie数据的

示例代码：

@Slf4j
    @RestController
    public class SessionController {
    
        //设置Cookie
        @GetMapping("/c1")
        public Result cookie1(HttpServletResponse response){
            response.addCookie(new Cookie("login_username","itheima")); //设置Cookie/响应Cookie
            return Result.success();
        }
    
        //获取Cookie
        @GetMapping("/c2")
        public Result cookie2(HttpServletRequest request){
            Cookie[] cookies = request.getCookies();
            for (Cookie cookie : cookies) {
                if(cookie.getName().equals("login_username")){
                    System.out.println("login_username: "+cookie.getValue()); //输出name为login_username的cookie
                }
            }
            return Result.success();
        }
    }

A. 访问c1接口，设置Cookie，http://localhost:8080/c1

![db8e1e74f309414ea29290e867099550.png][]

我们可以看到，设置的cookie，通过\*\*响应头Set-Cookie\*\*响应给浏览器，并且浏览器会将Cookie，存储在浏览器端。

![0a088c847d0040a4923a6a23906cc67f.png][]

访问c2接口 http://localhost:8080/c2，此时浏览器会自动的将Cookie携带到服务端，是通过请求头Cookie，携带的。

![33f0ee1db665417899bc35b9d1efeb40.png][]

优缺点

优点：HTTP协议中支持的技术（像Set-Cookie 响应头的解析以及 Cookie 请求头数据的携带，都是浏览器自动进行的，是无需我们手动操作的）  
缺点：  
移动端APP(Android、IOS)中无法使用Cookie  
不安全，用户可以自己禁用Cookie  
Cookie不能跨域

#### (3)Session ####

Session，它是服务器端会话跟踪技术，所以它是存储在服务器端的。而 Session 的底层其实就是基于我们刚才所介绍的 Cookie 来实现的。

如果我们现在要基于 Session 来进行会话跟踪，浏览器在第一次请求服务器的时候，我们就可以直接在服务器当中来获取到会话对象Session。如果是第一次请求Session ，会话对象是不存在的，这个时候服务器会自动的创建一个会话对象Session 。而每一个会话对象Session ，它都有一个ID（示意图中Session后面括号中的1，就表示ID），我们称之为 Session 的ID。

接下来，服务器端在给浏览器响应数据的时候，它会将 Session 的 ID 通过 Cookie 响应给浏览器。其实在响应头当中增加了一个 Set-Cookie 响应头。这个 Set-Cookie 响应头对应的值是不是cookie？ cookie 的名字是固定的 JSESSIONID 代表的服务器端会话对象 Session 的 ID。浏览器会自动识别这个响应头，然后自动将Cookie存储在浏览器本地。

接下来，在后续的每一次请求当中，都会将 Cookie 的数据获取出来，并且携带到服务端。接下来服务器拿到JSESSIONID这个 Cookie 的值，也就是 Session 的ID。拿到 ID 之后，就会从众多的 Session 当中来找到当前请求对应的会话对象Session。

这就是基于 Session 进行会话跟踪的流程。

@Slf4j
    @RestController
    public class SessionController {
    
        @GetMapping("/s1")
        public Result session1(HttpSession session){
            log.info("HttpSession-s1: {}", session.hashCode());
    
            session.setAttribute("loginUser", "tom"); //往session中存储数据
            return Result.success();
        }
    
        @GetMapping("/s2")
        public Result session2(HttpServletRequest request){
            HttpSession session = request.getSession();
            log.info("HttpSession-s2: {}", session.hashCode());
    
            Object loginUser = session.getAttribute("loginUser"); //从session中获取数据
            log.info("loginUser: {}", loginUser);
            return Result.success(loginUser);
        }
    }

访问 s1 接口，http://localhost:8080/s1

![f9c55904e8e44ebf80dfa730a8367d03.png][]

请求完成之后，在响应头中，就会看到有一个Set-Cookie的响应头，里面响应回来了一个Cookie，就是JSESSIONID，这个就是服务端会话对象 Session 的ID。

访问 s2 接口，http://localhost:8080/s2

![3fba97c1b4d14c149bc389e5572b7f7b.png][]

接下来，在后续的每次请求时，都会将Cookie的值，携带到服务端，那服务端呢，接收到Cookie之后，会自动的根据JSESSIONID的值，找到对应的会话对象Session。

那经过这两步测试，大家也会看到，在控制台中输出如下日志：

![ed61655534594876a0dd18befaee9c75.png][]

两次请求，获取到的Session会话对象的hashcode是一样的，就说明是同一个会话对象。而且，第一次请求时，往Session会话对象中存储的值，第二次请求时，也获取到了。 那这样，我们就可以通过Session会话对象，在同一个会话的多次请求之间来进行数据共享了。

优缺点

优点：Session是存储在服务端的，安全  
缺点：  
服务器集群环境下无法直接使用Session  
移动端APP(Android、IOS)中无法使用Cookie  
用户可以自己禁用Cookie  
Cookie不能跨域

#### (4)令牌技术 ####

1.说明

为了解决这些问题，在现在的企业开发当中，基本上都会采用第三种方案，通过令牌技术来进行会话跟踪。接下来我们就来介绍一下令牌技术，来看一下令牌技术又是如何跟踪会话的。

这里我们所提到的令牌，其实它就是一个用户身份的标识，看似很高大上，很神秘，其实本质就是一个字符串。

如果通过令牌技术来跟踪会话，我们就可以在浏览器发起请求。在请求登录接口的时候，如果登录成功，我就可以生成一个令牌，令牌就是用户的合法身份凭证。接下来我在响应数据的时候，我就可以直接将令牌响应给前端。

接下来我们在前端程序当中接收到令牌之后，就需要将这个令牌存储起来。这个存储可以存储在 cookie 当中，也可以存储在其他的存储空间(比如：localStorage)当中。

接下来，在后续的每一次请求当中，都需要将令牌携带到服务端。携带到服务端之后，接下来我们就需要来校验令牌的有效性。如果令牌是有效的，就说明用户已经执行了登录操作，如果令牌是无效的，就说明用户之前并未执行登录操作。

此时，如果是在同一次会话的多次请求之间，我们想共享数据，我们就可以将共享的数据存储在令牌当中就可以了。

优缺点

优点：  
支持PC端、移动端  
解决集群环境下的认证问题  
减轻服务器的存储压力（无需在服务器端存储）  
缺点：需要自己实现（包括令牌的生成、令牌的传递、令牌的校验）

JWT全称：JSON Web Token （官网：https://jwt.io/）

定义了一种简洁的、自包含的格式，用于在通信双方以json数据格式安全的传输信息。由于数字签名的存在，这些信息是可靠的。

简洁：是指jwt就是一个简单的字符串。可以在请求参数或者是请求头当中直接传递。

自包含：指的是jwt令牌，看似是一个随机的字符串，但是我们是可以根据自身的需求在jwt令牌中存储自定义的数据内容。如：可以直接在jwt令牌中存储用户的相关信息。简单来讲，jwt就是将原始的json数据格式进行了安全的封装，这样就可以直接基于jwt在通信双方安全的进行信息传输了。

JWT的组成： （JWT令牌由三个部分组成，三个部分之间使用英文的点来分割）

\* 第一部分：Header(头）， 记录令牌类型、签名算法等。 例如：\{"alg":"HS256","type":"JWT"\}  
  
\* 第二部分：Payload(有效载荷），携带一些自定义信息、默认信息等。 例如：\{"id":"1","username":"Tom"\}  
  
\* 第三部分：Signature(签名），防止Token被篡改、确保安全性。将header、payload，并加入指定秘钥，通过指定签名算法计算而来

签名的目的就是为了防jwt令牌被篡改，而正是因为jwt令牌最后一个部分数字签名的存在，所以整个jwt 令牌是非常安全可靠的。一旦jwt令牌当中任何一个部分、任何一个字符被篡改了，整个令牌在校验的时候都会失败，所以它是非常安全可靠的。

![d176bcd10bd84919b3199ad6ad519846.png][]

JWT是如何将原始的JSON格式数据，转变为字符串的呢？

其实在生成JWT令牌时，会对JSON格式的数据进行一次编码：进行base64编码

Base64：是一种基于64个可打印的字符来表示二进制数据的编码方式。既然能编码，那也就意味着也能解码。所使用的64个字符分别是A到Z、a到z、 0- 9，一个加号，一个斜杠，加起来就是64个字符。任何数据经过base64编码之后，最终就会通过这64个字符来表示。当然还有一个符号，那就是等号。等号它是一个补位的符号

需要注意的是Base64是编码方式，而不是加密方式。

JWT令牌最典型的应用场景就是登录认证：

1. 在浏览器发起请求来执行登录操作，此时会访问登录的接口，如果登录成功之后，我们需要生成一个jwt令牌，将生成的 jwt令牌返回给前端。  
2. 前端拿到jwt令牌之后，会将jwt令牌存储起来。在后续的每一次请求中都会将jwt令牌携带到服务端。  
3. 服务端统一拦截请求之后，先来判断一下这次请求有没有把令牌带过来，如果没有带过来，直接拒绝访问，如果带过来了，还要校验一下令牌是否是有效。如果有效，就直接放行进行请求的处理。

在JWT登录认证的场景中我们发现，整个流程当中涉及到两步操作：

1. 在登录成功之后，要生成令牌。  
2. 每一次请求当中，要接收令牌并对令牌进行校验。

2.生成和校验

要想使用JWT令牌，需要先引入JWT的依赖：

<dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>

生成JWT代码实现：

@Test
    public void genJwt(){
        Map<String,Object> claims = new HashMap<>();
        claims.put("id",1);
        claims.put("username","Tom");
    
        String jwt = Jwts.builder()
            .setClaims(claims) //自定义内容(载荷)          
            .signWith(SignatureAlgorithm.HS256, "itheima") //签名算法        
            .setExpiration(new Date(System.currentTimeMillis() + 24*3600*1000)) //有效期   
            .compact();
    
        System.out.println(jwt);
    }

输出的结果就是生成的JWT令牌,，通过英文的点分割对三个部分进行分割，我们可以将生成的令牌复制一下，然后打开JWT的官网，将生成的令牌直接放在Encoded位置，此时就会自动的将令牌解析出来。 也可以通过base在线解码工具也可以把令牌结果解码出来。

解析JWT代码实现：

@Test
    public void parseJwt(){
        Claims claims = Jwts.parser()
            .setSigningKey("itheima")//指定签名密钥（必须保证和生成令牌时使用相同的签名密钥）  
            .parseClaimsJws("eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwiZXhwIjoxNjcyNzI5NzMwfQ.fHi0Ub8npbyt71UqLXDdLyipptLgxBUg_mSuGJtXtBk")
            .getBody();
    
        System.out.println(claims);
    }

可以通过setExpiration方法设置令牌的过期时间

@Test
    public void genJwt(){
        Map<String,Object> claims = new HashMap<>();
        claims.put(“id”,1);
        claims.put(“username”,“Tom”);
        String jwt = Jwts.builder()
            .setClaims(claims) //自定义内容(载荷)          
            .signWith(SignatureAlgorithm.HS256, “itheima”) //签名算法        
            .setExpiration(new Date(System.currentTimeMillis() + 60*1000)) //有效期60秒   
            .compact();
    
        System.out.println(jwt);
        //输出结果：eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwiZXhwIjoxNjczMDA5NzU0fQ.RcVIR65AkGiax-ID6FjW60eLFH3tPTKdoK7UtE4A1ro
    }
    
    @Test
    public void parseJwt(){
        Claims claims = Jwts.parser()
            .setSigningKey("itheima")//指定签名密钥
    .parseClaimsJws("eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwiZXhwIjoxNjczMDA5NzU0fQ.RcVIR65AkGiax-ID6FjW60eLFH3tPTKdoK7UtE4A1ro")
            .getBody();
    
        System.out.println(claims);
    }

等待1分钟之后运行测试方法发现也报错了，说明：JWT令牌过期后，令牌就失效了，解析的为非法令牌。

通过以上测试，我们在使用JWT令牌时需 要注意：

\* JWT校验时使用的签名秘钥，必须和生成JWT令牌时使用的秘钥是配套的。  
  
\* 如果JWT令牌解析校验时报错，则说明 JWT令牌被篡改 或 失效了，令牌非法。

示例：

引入JWT工具类  
在项目工程下创建com.itheima.utils包，并把提供JWT工具类复制到该包下  
登录完成后，调用工具类生成JWT令牌并返回

引入依赖：

<dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>

JWT工具类

public class JwtUtils {
    
        private static String signKey = "itheima";//签名密钥
        private static Long expire = 43200000L; //有效时间
    
        /**
         * 生成JWT令牌
         * @param claims JWT第二部分负载 payload 中存储的内容
         * @return
         */
        public static String generateJwt(Map<String, Object> claims){
            String jwt = Jwts.builder()
                    .addClaims(claims)//自定义信息（有效载荷）
                    .signWith(SignatureAlgorithm.HS256, signKey)//签名算法（头部）
                    .setExpiration(new Date(System.currentTimeMillis() + expire))//过期时间
                    .compact();
            return jwt;
        }
    
        /**
         * 解析JWT令牌
         * @param jwt JWT令牌
         * @return JWT第二部分负载 payload 中存储的内容
         */
        public static Claims parseJWT(String jwt){
            Claims claims = Jwts.parser()
                    .setSigningKey(signKey)//指定签名密钥
                    .parseClaimsJws(jwt)//指定令牌Token
                    .getBody();
            return claims;
        }
    }

登录成功后，生成JWT令牌并返回

@RestController
    @Slf4j
    public class LoginController {
        //依赖业务层对象
        @Autowired
        private EmpService empService;
    
        @PostMapping("/login")
        public Result login(@RequestBody Emp emp) {
            //调用业务层：登录功能
            Emp loginEmp = empService.login(emp);
    
            //判断：登录用户是否存在
            if(loginEmp !=null ){
                //自定义信息
                Map<String , Object> claims = new HashMap<>();
                claims.put("id", loginEmp.getId());
                claims.put("username",loginEmp.getUsername());
                claims.put("name",loginEmp.getName());
    
                //使用JWT工具类，生成身份令牌
                String token = JwtUtils.generateJwt(claims);
                return Result.success(token);
            }
            return Result.error("用户名或密码错误");
        }
    }

在当前案例中，JWT令牌存储在浏览器的本地存储空间local storage中了。 local storage是浏览器的本地存储，在移动端也是支持的。

![e8e9d282a3554d31b5b83308174944d7.png][]

当前端再次发起其他请求时，此时我们可以看到在请求头中包含一个token(JWT令牌)，后续的每一次请求当中，都会将这个令牌携带到服务端。

![ee64c1e9fa8548ffa8889eea909fd938.png][]

[1c167bda9e494231acdbe24d88575a12.png]: https://img-blog.csdnimg.cn/1c167bda9e494231acdbe24d88575a12.png
[db8e1e74f309414ea29290e867099550.png]: https://img-blog.csdnimg.cn/db8e1e74f309414ea29290e867099550.png
[0a088c847d0040a4923a6a23906cc67f.png]: https://img-blog.csdnimg.cn/0a088c847d0040a4923a6a23906cc67f.png
[33f0ee1db665417899bc35b9d1efeb40.png]: https://img-blog.csdnimg.cn/33f0ee1db665417899bc35b9d1efeb40.png
[f9c55904e8e44ebf80dfa730a8367d03.png]: https://img-blog.csdnimg.cn/f9c55904e8e44ebf80dfa730a8367d03.png
[3fba97c1b4d14c149bc389e5572b7f7b.png]: https://img-blog.csdnimg.cn/3fba97c1b4d14c149bc389e5572b7f7b.png
[ed61655534594876a0dd18befaee9c75.png]: https://img-blog.csdnimg.cn/ed61655534594876a0dd18befaee9c75.png
[d176bcd10bd84919b3199ad6ad519846.png]: https://img-blog.csdnimg.cn/d176bcd10bd84919b3199ad6ad519846.png
[e8e9d282a3554d31b5b83308174944d7.png]: https://img-blog.csdnimg.cn/e8e9d282a3554d31b5b83308174944d7.png
[ee64c1e9fa8548ffa8889eea909fd938.png]: https://img-blog.csdnimg.cn/ee64c1e9fa8548ffa8889eea909fd938.png