SpringBoot:JWT+Interceptor 实现基本的登录验证

最新推荐文章于 2024-09-23 17:39:00 发布
最新推荐文章于 2024-09-23 17:39:00 发布
阅读量1.1k 收藏 23
点赞数 10
文章标签： spring boot java mysql 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56146092/article/details/140686685
版权

前置背景

Result类

：

package com.example.day724test.Dao;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//统一响应结果
@NoArgsConstructor
@AllArgsConstructor
@Data
public class Result<T> {
    private Integer code;//业务状态码  0-成功  1-失败
    private String message;//提示信息
    private T data;//响应数据

    //快速返回操作成功响应结果(带响应数据)
    public static <E> Result<E> success(E data) {
        return new Result<>(0, "操作成功", data);
    }

    //快速返回操作成功响应结果
    public static Result success() {
        return new Result(0, "操作成功", null);
    }

    public static Result error(String message) {
        return new Result(1, message, null);
    }
}

Mapper:

Service:

Controler:

    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestParam("username") String username, @RequestParam("password") String password) {
        try {
            SysUser user = userService.get_by_name(username);
            if (user == null || !user.getPassword().equals(password)) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("用户名或密码错误");
            }
          return ResponseEntity.ok().body(user);

        } catch (Exception e) {
            log.error("登录异常", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("服务器内部错误");
        }
    }

    /*
    添加一个查看所有的用户的信息方法去验证token相关
     */

    @GetMapping("/all")
    public ResponseEntity<?> getAllUser() {
        try {
            List<SysUser> users = userService.get_all();
            return ResponseEntity.ok().body(users);
        } catch (Exception e) {
            log.error("获取用户列表异常", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("服务器内部错误");
        }
    }

测试一下是否成功:

login接口：

all接口：

测试成功：步入正题

JSON Web Tokens (JWT) 和拦截器实现登录验证的详细步骤：

. 用户登录
- 用户提交用户名和密码到服务器。
- 服务器验证用户凭证。
- 如果验证成功，服务器生成一个 JWT 并将其返回给客户端。

引入jwt依赖项：这里使用的是版本低一些的

创建JwtUtil类：


    //接收业务数据,生成token并返回
    public static String genToken(Map<String, Object> claims) {
        return JWT.create()
                .withClaim("claims", claims)
                //.withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 ))
                .withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 24 * 7))
                .sign(Algorithm.HMAC256(KEY));
    }




    //接收token,验证token,并返回业务数据
    public static Map<String, Object> parseToken(String token) {
        return JWT.require(Algorithm.HMAC256(KEY))
                .build()
                .verify(token)
                .getClaim("claims")
                .asMap();
    }

测试一波：

生成token:

将生成的token复制准备验证：

 经过验证可以使用去usercontroller实现登录验证：

原来的登录代码：


    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestParam("username") String username, @RequestParam("password") String password) {
        try {
            SysUser user = userService.get_by_name(username);
            if (user == null || !user.getPassword().equals(password)) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("用户名或密码错误");
            }
          return ResponseEntity.ok().body(user);

        } catch (Exception e) {
            log.error("登录异常", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("服务器内部错误");
        }
    }

导入JwtUtil包的token验证代码：

    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestParam("username") String username, @RequestParam("password") String password) {
        try {
            SysUser user = userService.get_by_name(username);
            if (user == null || !user.getPassword().equals(password)) {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("用户名或密码错误");
            }
                /*
                登录成功之后的方法内容
                 */
                Map<String,Object> claims=new HashMap<>();
                claims.put("username",user.getUsername());
                claims.put("password",user.getPassword());
                String token= JwtUtil.genToken(claims);
                log.info("登录成功, 用户名: {}", user.getUsername());
                return ResponseEntity.ok().body(token);
                /*
                在登录接口生成了token
                 */

            /*
            其他的接口需要验证token
             */

        } catch (Exception e) {
            log.error("登录异常", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("服务器内部错误");
        }
    }

查看是否返回了我们所需要的token信息：

接下来使得其它的接口验证token：验证成功返回数据 否则错误

原来的/user/all:

    @GetMapping("/all")
    public ResponseEntity<?> getAllUser() {
        try {
            List<SysUser> users = userService.get_all();
            return ResponseEntity.ok().body(users);
        } catch (Exception e) {
            log.error("获取用户列表异常", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("服务器内部错误");
        }
    }

现在的接受token验证登录信息:

   @GetMapping("/all")
   public Result<String> getAllUser(@RequestHeader("Authorization") String token, HttpServletRequest response){ //请求头中获取token
       try {
           Map<String, Object> claims = JwtUtil.parseToken(token);
           return Result.success("所有的文章数据");
       }catch (Exception e){
           return Result.error("未登录");
       }
   }
/*
    在请求头信息中获取token
*/

测试：没有加token的时候

显然在postman测试请求头里面没有携带token所以提示未登录

携带token之后：

请求成功：这便完成了基本的登录检验

但是如果有多个接口 开发大工程项目势必过于繁琐 ，那么我们就使用更加抽象性的方法：使用拦截器

拦截器原理：

拦截器（Interceptors）是一种设计模式，用于在请求到达目标之前或响应离开之后执行某些操作。这种模式在多种编程环境和技术栈中都有应用，包括但不限于HTTP客户端和服务端、数据库访问层、消息队列等。

### 拦截器的基本原理

1. **注册拦截器**：
   - 在应用程序启动时或者某个配置阶段，你需要注册一个或多个拦截器。
   - 每个拦截器通常定义了两个方法：一个用于处理请求前的操作，另一个用于处理响应后的操作。

2. **请求处理**：
   - 当一个请求被发送时，它会先经过一系列预先注册的拦截器。
   - 每个拦截器可以对请求进行一些预处理，比如修改请求头、添加日志记录、验证认证信息等。
   - 如果某个拦截器决定阻止请求继续前进，它可以终止请求流程。
   - 如果请求通过了所有的拦截器，则会被发送到最终的目标。

3. **响应处理**：
   - 当响应从目标返回时，它也会经过相同的拦截器链。
   - 每个拦截器可以对响应进行一些后处理，例如修改响应体、添加额外的响应头等。
   - 响应最终被传递给最初发起请求的代码。

### 应用场景示例

#### AngularJS / Angular

1. **注册拦截器**：
   - 在AngularJS中，你可以通过 `$httpProvider.interceptors` 注册HTTP拦截器。
   - 在Angular中，你可以使用 `HttpClientInterceptor` 类型来创建自定义拦截器。

2. **请求与响应处理**：
   - 当发出一个HTTP请求时，请求会经过所有的请求拦截器。
   - 当收到响应时，响应会经过所有的响应拦截器。

#### Axios

1. **注册拦截器**：
   - Axios 提供了一个简单的API来注册请求和响应拦截器。
   - 可以通过 `axios.interceptors.request.use` 和 `axios.interceptors.response.use` 来注册拦截器函数。

2. **请求与响应处理**：
   - 当请求被发送之前，会依次调用请求拦截器。
   - 当响应被接收到之后，会依次调用响应拦截器。

#### Spring Framework

1. **注册拦截器**：
   - 在Spring MVC中，你可以创建实现了 `HandlerInterceptor` 接口的类，并在配置文件中注册它们。
   - 这些拦截器可以用来处理请求前后的操作。

2. **请求与响应处理**：
   - 当一个请求到达控制器之前，会调用拦截器的 `preHandle` 方法。
   - 如果请求被允许继续，那么在控制器处理完请求后，会调用拦截器的 `postHandle` 方法。
   - 最后，在视图渲染完成后，会调用拦截器的 `afterCompletion` 方法。

### 总结

拦截器提供了一种灵活的方式来扩展应用程序的功能，而不需要直接修改核心逻辑。它们可以在不改变现有代码结构的情况下增加新的功能，例如日志记录、性能监控、认证和授权、错误处理等。拦截器的设计使得系统的模块化程度更高，更易于维护和扩展。

源自黑马程序员springboot讲解 讲的很清楚

具体实现：

  • 继承Interceptor接口，
  • 获取到请求头中的token,
  • 得到token就可以让其继续执行，否则返回false：不允许进行
package com.example.day724test.intercepor;

import com.example.day724test.Utils.JwtUtil;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;


@Component
public class LoginInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 获取请求头中的token
        String token = request.getHeader("Authorization");
        // 判断token是否为空，如果为空表示未登录，返回登录页面
        try {
            Map<String, Object> claims = JwtUtil.parseToken(token);
            /*
            放行
             */
            return true;
        }catch (Exception e){
            return false;
            /*
            不放行
             */
        }
    }
}

此外，定义

WebConfig类
 选择性过滤掉login,register  这两种接口外的其它接口需要实现登录验证
package com.example.day724test.config;

import com.example.day724test.intercepor.LoginInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Component
@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private LoginInterceptor loginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //登录接口和注册接口不拦截
        registry.addInterceptor(loginInterceptor).excludePathPatterns("/user/login","/user/register");
    }
}

修改原来的Controller逻辑：

   @GetMapping("/all")
   public Result<String> getAllUser(@RequestHeader("Authorization") String token, HttpServletRequest response){ //请求头中获取token
//       try {
//           Map<String, Object> claims = JwtUtil.parseToken(token);
//           return Result.success("所有的文章数据");
//       }catch (Exception e){
//           return Result.error("未登录");
//       }
       return Result.success("所有的文章数据,,,,,,,,,");
   }

来进行测试：

直接访问/user/all：

携带token之后：

请求成功：基本的登录验证已经完成

项目保存的gitee地址：gitee地址

百年孤独_
关注
SpringBoot集成shiro+redis+jwt实现无状态授权验证
liangshitian的博客
01-03 3万+
前言 1.放弃Cookie,Session,使用JWT进行鉴权，完全实现无状态鉴权。 2.JWT密钥支持过期时间；jwt作为创建验证token工具，并选择一种验证方式与算法。 3.使用redis做缓存处理，缓存token等等登录信息，以实现单点登录与超时登录功能。 4.密码加密(采用AES-128 + Base64的方式)。 5.根据RefreshToken自动刷新AccessToken...
后台管理系统Springboot+Shiro+JWT+Vue
libin372767477的专栏
10-24 1351
项目开发中，后台系统尤为重要，最近就想搞一套能拿来直接使用的后台管理系统。 框架： Shiro，Shiro作为安全框架，实现登录、登出、身份验证、授权、会话管理。 JWT，Json Web Token负责访问接口时的验证。 Vue，前端框架，因为本身不是前端开发，所以Clone了某位高人在github上的模版。写的非常好，简单易用。https://github.com/PanJiaChen/vue-admin-template 前端代码就是照葫芦画瓢，不过很多地方也googl
SpringBoot之登录校验关于JWT、Filter、interceptor、异常处理的使用
最新发布
abcd7970的博客
09-23 1285
SpringBoot之登录校验关于JWT、Filter、interceptor、异常处理的使用
SpringBoot JWT
fantasyfzg的博客
11-30 217
token
SpringBoot开发——整合 JWT 轻松搞定跨站点统一登录
bjzhang75的博客
09-03 876
私有声明是提供者和消费者所共同定义的声明，一般不建议存放敏感信息，因为base64是对称解密的，意味着该部分信息可以归类为明文信息。公共的声明可以添加任何的信息，一般添加用户的相关信息或其他业务需要的必要信息，但不建议添加敏感信息，因为该部分在客户端可解密。但是，假如应用服务器的请求量变得很大，而单台服务器能支撑的请求量是有限的，这个时候就容易出现请求变慢或者OOM。中获取用户的基本信息，既然客户端可以获取，肯定是不能存放敏感信息的，因为浏览器可以直接从token获取用户信息。
【springboot开发】JWT实现用户验证登录
idiotyi的博客
06-07 1721
JWT完整流程如下：用户使用账号和密码发起 POST 请求；服务器使用私钥创建一个 JWT；服务器返回这个 JWT 给浏览器；浏览器将该 JWT 串在请求头中像服务器发送请求；服务器验证该 JWT；返回响应的资源给浏览器。
SpringBoot配置JWT拦截器
Kristabo的博客
03-24 1450
JWT在之前文章提到过，JWT（JSON Web Token）是一种用于身份验证和授权的开放标准（RFC 7519），它允许在网络中安全地传输声明（claims）作为 JSON 对象。JWT 可以通过数字签名或加密来验证数据的完整性和真实性，从而保证数据在传输过程中不被篡改。工作流程用户通过用户名和密码等方式进行身份验证。服务器验证用户身份，并生成一个 JWT。服务器将 JWT 发送给客户端。客户端将 JWT 存储起来，通常是在本地存储或者内存中。
springboot-JWT
FA的博客
07-23 123
JWT原理 单点登录
Springboot：JWT
沉迷写代码的程序猿的博客
03-22 4266
文章目录Springboot：JWT一、JWT简介1、JWT的优势2、JWT的结构2.1、标头（Header）2.2、有效负荷（Payload）2.3、签名（Signature）二、SpringBoot整合JWT Springboot：JWT 一、JWT简介 JWT，是指JSON Web Token，也就指通过JSON形式作为Web应用中的令牌，用于在各方之间安全地将信息作为JSON对象传输。在数据传输过程中还可以完成数据加密、签名等相关处理。 1、JWT的优势 在JavaWeb阶段，经常使用ses
springboot + jwt + websocket + 拦截
09-02
在IT行业中，Spring Boot、JWT（JSON Web Token）和WebSocket是三个非常重要的技术概念，而“拦截”通常指的是在系统中实现的一种中间件机制，用于处理请求或响应。结合提供的标题和描述，我们可以深入探讨这四个...
SpringBoot整合JWT + Shiro
weixin_43920711的博客
10-28 7270
一、什么是Shiro Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。 三个核心组件：Subject, SecurityManager 和 Realms 三大核心组件： Subject：主体 主体，代表了当前的“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是主体，如第三方进程、网络爬虫、机器人等，Subject是一个抽象概念，所有的Subject都绑定到Securi
基于springboot实现JWT登录拦截及验证(超详细版)
Java程序员十六的博客
06-26 743
基于Springboot通过Jwt实现登录拦截及验证
Springboot整合JWT完成验证登录
吉屋安的博客
09-09 824
这个Java类是一个工具类，用于生成和验证JSON Web Tokens（JWT）。JWT是一种开放标准（RFC 7519），它定义了一种紧凑且自包含的方式，用于在各方之间作为JSON对象安全地传输信息。这个信息可以被验证和信任，因为它是数字签名的。在这个例子中，使用了Java的jsonwebtoken库。这是一个使用Java语言和Spring框架编写的简单的登录控制器。
SpringBoot中使用JWT
cxzhq2002的杂记
11-04 1741
JWT是什么我就不说了，这里只说名SpringBoot中怎么用。 首先在pom中天际依赖 1 <dependency> 2 <groupId>org.bitbucket.b_c</groupId> 3 <artifactId>jose4j</artifactId> 4 <version>0.6.5</version> 5 </dependency> 这里我用
Springboot集成jwt
chen的博客
03-16 922
导入依赖 <!--jwt--> <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.10.3</version> </dependency> 编写jwt工具类 TokenUt
springboot实现JWT
weixin_41849346的博客
09-08 327
pom.xml <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- JWT依赖 -->
SpringBoot集成Jwt
Xu_Ren的博客
05-07 301
JWT 简介 Json Web Token（JWT），是为了在网络应用环境之间传递声明而执行的一种基于JSON的开放标准（RFC7519），该 token 被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者之间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其他业务逻辑所必须声明信息，该token也可以直接被...
springboot+jwt
while(life)++；
05-06 385
流程： 1.用户访问login接口，验证用户身份信息，并生成token绑定用户信息，token返回前端 2.前端把token存入request header中访问后端接口即可成功，否则提示无权访问 代码部分： 1.JwtUtil类 （生成token，校验token等） /* * * @Author qy * <p> JWT工具类 </p> * @Param * @Return */ public class JwtUtil { // Token过期时间30分钟
SpringBoot+JWT+Vue实现权限管理系统源码解析
资源摘要信息:"本资源是一个完整的权限管理系统，采用SpringBoot作为后端开发框架，Vue作为前端界面框架，使用JSON Web Tokens（JWT）作为身份验证机制。SpringBoot作为一个轻量级的Java应用框架，极大地简化了基于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值