登录认证《JWT+Filter+Interceptor》

已于 2024-02-26 17:27:30 修改
阅读量159 收藏
点赞数
文章标签： spring java 后端
于 2023-09-23 10:41:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64340669/article/details/133199730
版权

登录认证《JWT+Filter+Interceptor》

∫ b i r t h d e a t h 卷 d t = l i f e \int_{birth}^{death}卷dt = life ∫birthdeath​卷dt=life🥇 🍔:happy:💔

一、会话技术

  • 会话：用户打开浏览器，访问web服务器的资源，会话建立，直到有一方断开连接，会话结束。在一次会话中可以包含多次请求和响应
  • 会话跟踪：一种维护浏览器状态的方法，服务器需要识别多次请求是否来自同一浏览器，以便在同一次会话的多次请求间共享数据
  • 会话跟踪方案：
    1. 客户端会话跟踪技术：Cookie
    2. 服务端会话跟踪技术：Session
    3. 令牌技术

二、会话跟踪方案对比

2.1、方案一：Cookie【传统】

Cookie是保存在浏览器本地的，用户向后端发起登录请求之后，后端服务器会自动返回一个Cookie值给浏览器，同时浏览器将该Cookie值保存在浏览器本地中，之后的每一次浏览器请求，都会自动带上这个Cookie值，后端根据Cookie值判断该浏览器是否登陆过。

image-20230921213226025

优点：HTTP协议中支持的技术

缺点：

  1. 移动端APP无法使用Cookie
  2. 不安全，用户可以自己禁用Cookie
  3. Cookie不能跨域【跨域是什么？自己去了解】
代码实现：操作Cookie

下面实现操作Cookie的代码，通过访问：

  1. http://localhost:3000/study/setcookie：访问该地址，服务器会向前端发送一个Cookie
  2. http://localhost:3000/study/getcookie：访问改地址，服务器获取前端传递的Cookie
@Slf4j
@RestController
@RequestMapping("/study")
public class StudyController {
    /**
     * 访问地址：http://localhost:3000/study/setcookie 设置Cookie值在响应response中
     * @param response
     * @return
     */
    @GetMapping("/setcookie")
    public Result setCookie(HttpServletResponse response){
        log.info("获取设置Cookie的请求");
        response.addCookie(new Cookie("login_username","zhangsan"));
        return Result.success();
    }

    /**
     * 从请求request中获取Cookie值
     * @param request
     * @return
     */
    @GetMapping("/getcookie")
    public Result getCookie(HttpServletRequest request){
        log.info("获取得到Cookie的请求");
        Cookie[] cookies = request.getCookies();    //获取到所有Cookie
        for(Cookie cookie : cookies){
            if(cookie.getName().equals("login_username")){ //输出name为login_username的Cookie
                System.out.println("login_username: " + cookie.getValue());
            }
        }
        return Result.success();
    }
}
设置Cookie效果图展示

首先F12打开浏览器的调试工具点击NetWork选项查看发送的请求信息

可以看到请求了http://localhost:3000/study/setcookie路径之后，服务器向前端的响应Response中包含Set-Cookie一项

image-20230921215243363

然后我们继续点击Application一项可以看到我们设置的Cookie值成功保存在浏览器本地存储

image-20230921215746870

获取Cookie效果图展示

继上述设置Cookie操作之后，继续访问页面http://localhost:3000/study/getcookie，同样的，打开调试工具，并点击NetWork选项查看请求request中的Cookie一栏，确实是我们刚才设置的cookie

image-20230921220327371

查看我们的后端的显示，确实得到了前端向后端请求中的cookie值

image-20230921220603439

2.2、方案二：Session【传统】

Session是保存在服务器中的，Session的底层是基于Cookie来实现的。

浏览器第一次向服务器发送请求的时候，服务器会自动创建会话对象Session，每一个会话对象都有一个ID，称之为Session的ID，接下来服务器向浏览器响应数据的时候会将Session的ID通过Cookie响应给浏览器，浏览器接收到这个响应数据之后会自动将存有SessionId的cookie保存在浏览器本地，然后后续的请求中，浏览器会将该Cookie的值携带到服务端，服务器拿到这个前端传来的cookie后，会从全部请求对象中找到当前请求对应的会话对象

image-20230921231659057

**优点：**存储在服务器，安全

缺点：

  1. 服务器级群环境下无法直接使用Session
  2. Cookie的缺点【Session底层实现为Cookie】
代码实现：操作Session
@Slf4j
@RestController
@RequestMapping("/study")
public class StudyController {
    /**
     * 设置Session对象,hashCode可以理解为SessionId每一个Session对象有唯一的hashCode
     * @param session
     * @return
     */
    @GetMapping("/setsession")
    public Result setSession(HttpSession session){
        log.info("HttpSession-setSession:{}",session.hashCode());
        session.setAttribute("loginUser","tom");
        return Result.success();
    }

    /**
     * 从HttpSession中获取Session，并获取其hashCode
     * @param request
     * @return
     */
    @GetMapping("/getsession")
    public Result getSession(HttpServletRequest request){
        HttpSession session = request.getSession();
        log.info("HttpSession-getSession:{}",session.hashCode());
        Object loginUser = session.getAttribute("loginUser");
        log.info("loginUser:{}",loginUser);
        return Result.success();
    }

}
设置Session的效果图

首先F12打开浏览器的调试工具点击NetWork选项查看发送的请求信息

可以看到请求了http://localhost:3000/study/setsession路径之后，服务器向前端的响应Response中包含Set-Cookie一项，并且保存的值是Session的ID

image-20230921230445503

然后我们继续点击Application一项可以看到我们设置的session值成功保存在浏览器本地存储

image-20230921230617782

获取Session效果图展示

继上述设置session操作之后，继续访问页面http://localhost:3000/study/getsession，同样的，打开调试工具，并点击NetWork选项查看请求request中的Cookie一栏，确实是我们刚才设置的session

image-20230921230938366

查看我们的后端的显示，看到setsession和getsession两次请求输出的ID值相同，表明确实是同一个Session对象

image-20230921231145486

2.3、方案三：令牌JWT【主流】

image-20230921233534209

优点：

  1. 支持PC端、移动端
  2. 解决集群环境下的认证问题
  3. 减轻服务器端存储压力

缺点：需要自己实现

了解JWT
  • 全称：JSON Web Token
  • 定义了一种简洁、自包含的格式，用于在通信双方以JSON数据格式安全的传输信息。由于数字签名的存在，这些信息是可靠的
  • 组成：
    1. 第一部分：Header(头)，记录令牌类型、签名算法等。例如：{“alg”:“HS256”,“type”:“JWT”}
    2. 第二部分：Payload(有效载荷)，携带一些自定义信息、默认信息等。例如：{“id”:“1”,“username”:“Tom”}
    3. 第三部分：Signature(签名)，防止Token被串改、确保安全性。将header、payload，并加入指定秘钥，通过指定签名算法计算而来

image-20230921234520362

细节：JWT组成的前两部分[Payload、Signature]是JSON数据通过Base64编码组成，第三部分的数字签名融入前两部分的内容并加入秘钥通过特定算法计算出来的，所以核心就是第三部分的签名，该签名唯一标识我们的令牌

【Base64：是一种基于64个可打印字符（A-Z a-z 0-9 + /）来表示二进制数据的编码方式】

使用场景
  • 典型使用场景：登录认证。
    1. 登录成功后，生成令牌【令牌生成：登录成功后生成JWT令牌，并返回给前端】
    2. 后续每个请求，都要携带JWT令牌，系统在每次请求处理之前，先校验令牌，通过后，在处理【在请求到达服务端后，对令牌进行统一拦截，校验】

image-20230921235042977

代码实现
  • 要使用JWT技术，首先导入JWT的依赖
<dependency>
	<groupId>io.jsonwebtoken</groupId>
	<artifactId>jjwt</artifactId>
	<version>0.9.1</version>
</dependency>
生成JWT

生成JWT需要使用Jwts的三个方法

  • signWith：设置签名算法以及秘钥【jwt组成三部分的第一部分】
  • setClaims：设置载荷数据【jwt组成三部分的第二部分】
  • setExpiration：设置过期时间 ( 参数以毫秒为单位 ) (参数以毫秒为单位) (参数以毫秒为单位)
@Test
public void genJwt(){
	Map<String, Object> claims = new HashMap<>();		//载荷部分接收一个Map作为参数
	claims.put("id",1);
	claims.put("name","tom");
    
	String jwt = Jwts.builder()
		.signWith(SignatureAlgorithm.HS256,"token")     	//设置签名算法
		.setClaims(claims)                                  //设置载荷数据
		.setExpiration(new Date(System.currentTimeMillis()+3600 * 1000)) //设置令牌的过期时间
		.compact();
        System.out.println(jwt);
}
解析JWT

解析JWT使用的方法

  • setSigningKey：设置解析JWT的秘钥
  • parseClaimsJws：将JWT作为该方法的参数
  • getBody：获取到载荷部分的数据
@Test
public void parseJWT(){
	Claims payload = Jwts.parser()
		.setSigningKey("token")		 //输入JWT的秘钥
        .parseClaimsJws("生成的JWT")	//将JWT放入parseClaimJws
		.getBody();
	System.out.println(payload);
}

注意事项

  • JWT校验时使用的签名秘钥，必须和生成JWT令牌时使用的秘钥是相同的。
  • 如果JWT令牌解析校验时报错，则说明JWT被篡改或失效了，令牌非法。
编写一个JWT工具类【JwtUtils】
public class JwtUtil {
    /**
     * 生成jwt
     * 使用Hs256算法, 私匙使用固定秘钥
     *
     * @param secretKey jwt秘钥               [签名]
     * @param ttlMillis jwt过期时间(毫秒)     [token的过期时间]
     * @param claims    设置的信息       [把json数据放进map然后当做参数传递]
     * @return
     */
    public static String createJWT(String secretKey, long ttlMillis, Map<String, Object> claims) {
        // 指定签名的时候使用的签名算法，也就是header那部分
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        // 生成JWT的时间,设置JWT的过期时间
        long expMillis = System.currentTimeMillis() + ttlMillis;
        Date exp = new Date(expMillis);

        // 设置jwt的body
        JwtBuilder builder = Jwts.builder()
                // 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
                .setClaims(claims)
                // 设置签名使用的签名算法和签名使用的秘钥
                .signWith(signatureAlgorithm, secretKey.getBytes(StandardCharsets.UTF_8))
                // 设置过期时间
                .setExpiration(exp);

        return builder.compact();
    }

    /**
     * 解析Token
     *
     * @param secretKey jwt秘钥 此秘钥一定要保留好在服务端, 不能暴露出去, 否则sign就可以被伪造
     * @param token     加密后的token
     * @return
     */
    public static Claims parseJWT(String secretKey, String token) {
        // 得到DefaultJwtParser
        Claims claims = Jwts.parser()
                // 设置签名的秘钥
                .setSigningKey(secretKey.getBytes(StandardCharsets.UTF_8))
                // 设置需要解析的jwt
                .parseClaimsJws(token).getBody();
        return claims;
    }

}

三、过滤器Filter

这了给出一篇简短高效的文章：有关Filter的使用方法

3.1、概述

  • 概念：Filter过滤器，是JavaWeb三大组件（Servlet、Filter、Listener）之一
  • 过滤器可以把对资源的请求拦截下来，从而实现一些特殊功能
  • 过滤器一般完成一些通用操作，比如：登录校验、统一编码处理、敏感字符处理等

image-20230922140633954

3.2、快速入门

  1. 定义Filter：定义一个类，实现Filter接口，并重写其所有方法，Filter类上加上@WebFilter注解，配置拦截资源路径。

    @WebFilter(urlPatterns = "/*")  //配置拦截路径
public class DemoFilter implements Filter {
    @Override   //初始化方法,只调用一次: 通常做环境以及资源的准备工作
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init 初始化开始了...");
        Filter.super.init(filterConfig);
    }

    @Override   //每次拦截到请求之后调用，调用多次
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("拦截到了请求...【放行前逻辑】");
        //doFilter是放行操作
        chain.doFilter(request,response);
        System.out.println("拦截到了请求...【放行后逻辑】");
    }

    @Override   //销毁方法,只会调用一次: 通常做资源和环境的销毁工作
    public void destroy() {
        System.out.println("destory 销毁执行了...");
        Filter.super.destroy();
    }
}

  2. 配置Filter：引导类上加@ServletComponentScan开启Servlet组件支持

    @SpringBootApplication		
@ServletComponentScan()		//扫描Servlet的组件
public class ServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServerApplication.class, args);
    }
}

  • 通常在init方法中做一些资源以及环境的准备工作

  • 通常在destory方法做资源的释放以及环境的清理工作

  • 在Spring启动类上加上注解ServletComponentScan：因为Filter是JavaWeb三大组件之一并不属于SpringBoot，因此想要在SpringBoot上使用JavaWeb的三大组件那就需要加上注解，加上注解就表示当前项目是支持Servlet相关组件的

3.3、Filter拦截路径

拦截路径URLPatterns值含义
拦截具体路径/login只有访问/login路径时，才会被拦截
目录拦截/emps/*访问/emps下所有资源，都会被拦截
拦截所有/*访问所有资源，都会被拦截【

3.4、过滤器链

  • 介绍：一个web应用中，可以配置多个过滤器，这多个过滤器就形成了一个过滤器链
  • 顺序：注解配置的Filter，优先级是按照过滤器类名（字符串）的自然排序

image-20230922141513652

举个例子

我创建了一个AFilter和一个BFilter因为两个拦截器的名字A比B靠前，所以过滤器链的先后顺序是

  • 浏览器请求资源：浏览器 → \to → AFilter$\to ‘ B F i l t e r ‘ `BFilter` ‘BFilter‘\to$服务端
  • 服务端返回资源：浏览器 ← \leftarrow ← AFilter$\leftarrow ‘ B F i l t e r ‘ `BFilter` ‘BFilter‘\leftarrow$后端资源

定义的两个测试过滤器如下：

启动服务，发送请求，查看拦截结果可以看到是A拦截器先捕获到请求

3.5 登录操作过滤器的实现(例子)

image-20230922163502367

步骤：

  1. 获取请求 url
  2. 判断请求 url 中是否包含login，如果包含，说明是登录操作，放行
  3. 获取请求头中的令牌（token）
  4. 判断令牌是否存在，如果不存在，返回错误结果（未登录）
  5. 解析 token ，如果解析失败，返回错误结果（未登录）
  6. 放行
代码实现的基本逻辑
@Slf4j
@WebFilter("/*")
public class LoginFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest)request;
        HttpServletResponse res = (HttpServletResponse)response;
        //1. 获取到请求的url
        String url = req.getRequestURI().toString();
        log.info("拦截到请求,请求地址为: {}",url);
        //2. 判断请求是否包含login，如果包含，则说明是登录操作，放行
        if(url.contains("login")){
            log.info("登录操作...");
            chain.doFilter(request,response);
            return;
        }
        //3. 获取请求头中的令牌(token)
        String token = req.getHeader("token");

        //4. 判断令牌是否存在，如果不存在，返回错误结果(未登录)
        if(!StringUtils.hasLength(token)){
            log.info("请求头token为空，尚未登录...");
            Result error = Result.error("NOT_LOGIN");
            //手动转换 对象-->json--------》阿里巴巴的fastJSON
            String notLogin = JSONObject.toJSONString(error);
            res.getWriter().write(notLogin);
            return;
        }

        //5. 解析token如果解析失败，返回错误结果
        try {
            JwtUtil.parseJWT("token",token);
        } catch (Exception e) {
            e.printStackTrace();
            log.info("解析token异常..");
            Result error = Result.error("NOT_LOGIN");
            //手动转换 对象-->json--------》阿里巴巴的fastJSON
            String notLogin = JSONObject.toJSONString(error);
            res.getWriter().write(notLogin);
            return;
        }
        log.info("令牌合法...");
        //6. 放行
        chain.doFilter(request,response);
    }
}

四、拦截器Interceptor

4.1、概述

  • **概念：**是一种动态拦截方法调用的机制，类似于过滤器。Spring框架提供的，用来动态拦截控制器方法的执行。
  • **作用：**拦截请求，在指定的方法调用前后，根据业务需要执行预先设定的代码

4.2、快速入门

  1. 定义拦截器，实现HandlerInterceptor接口，并重写其所有方法

    @Component	//交给IOC管理
public class LoginCheckInterceptor implements HandlerInterceptor {
    @Override   //目标资源方法执行前执行，返回true：放行，返回false：不放行
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle方法执行了...");
        return true;
    }

    @Override   //目标资源方法执行后执行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle方法执行了...");
    }

    @Override   //视图渲染完毕后执行，最后执行
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("视图渲染完毕执行....");
    }
}

  2. 注册拦截器

    @Configuration  //表示当前类是一个配置类
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginCheckInterceptor).addPathPatterns("/**");
    }
}

4.3、Intercept拦截路径

  • 拦截器可以根据需求，配置不同的拦截路径：

    @Override
public void addInterceptors(InterceptorRegistry registry){
    registry.addInterceptor(loginCheckInterceptor)
        .addPathPatterns("/**")			//需要拦截那些资源
        .excludePathPatterns("/login");	//不需要拦截那些资源
}
    1. addPathPatterns()：配置需要拦截的路径
    2. excludePathPatterns()：配置不需要拦截的路径
拦截路径含义举例
/*一级路径能匹配/depts、/emps、/login、不能匹配/depts/1
/**任意级路径能匹配/depts、/depts/1、/depts/1/2
/depts/*/depts下的一级路径能匹配/depts/1，不能匹配/depts/1/2、/depts
/depts/**/depts下的任意路径能匹配/depts、/depts/1、/depts/1/2、不能匹配/emps/1

4.4、拦截器执行流程

image-20230922224235319

使用浏览器访问web服务器时

定义的过滤器Filter会首先拦截到请求，然后执行放行前的逻辑，接着执行放行操作（doFilter）

由于当前是基于SpiringBoot开发，所以放行之后会入到Spring的环境当中访问定义的Controller

因为Tomcat是一个Servlet容器，可以识别Servlet程序，但是不识别Controller

SpringWeb提供了一个核心的Servlet容器（称之为前端控制器：DispatcherServlet）

由DispatchServelt将请求转发给Controller然后执行对应的接口方法

但是因为定义了拦截器，所以请求先到拦截器然后才到Controller

Filter与Interceptor区别

  • 接口规范不同：过滤器需要实现Filter接口，而拦截器需要实现HandlerInterceptor接口
  • 拦截范围不同：过滤器Filter会拦截所有资源，而Interceptor只会拦截Spring环境中的资源

4.5、登录操作拦截器的实现（例子）

  1. 获取请求 url
  2. 判断请求 url 中是否包含login，如果包含，说明是登录操作，放行
  3. 获取请求头中的令牌（token）
  4. 判断令牌是否存在，如果不存在，返回错误结果（未登录）
  5. 解析 token ，如果解析失败，返回错误结果（未登录）
  6. 放行
@Slf4j
@Component
public class LoginCheckInterceptor implements HandlerInterceptor {
    @Override   //目标资源方法执行前执行，返回true：放行，返回false：不放行
    public boolean preHandle(HttpServletRequest req, HttpServletResponse res, Object handler) throws Exception {
        //1. 获取到请求的url
        String url = req.getRequestURI().toString();
        log.info("拦截到请求,请求地址为: {}",url);
        //2. 判断请求是否包含login，如果包含，则说明是登录操作，放行
        if(url.contains("login")){
            log.info("登录操作...");
            return true;
        }
        //3. 获取请求头中的令牌(token)
        String token = req.getHeader("token");

        //4. 判断令牌是否存在，如果不存在，返回错误结果(未登录)
        if(!StringUtils.hasLength(token)){
            log.info("请求头token为空，尚未登录...");
            Result error = Result.error("NOT_LOGIN");
            //手动转换 对象-->json--------》阿里巴巴的fastJSON
            String notLogin = JSONObject.toJSONString(error);
            res.getWriter().write(notLogin);
            return false;
        }

        //5. 解析token如果解析失败，返回错误结果
        try {
            JwtUtil.parseJWT("token",token);
        } catch (Exception e) {
            e.printStackTrace();
            log.info("解析token异常..");
            Result error = Result.error("NOT_LOGIN");
            //手动转换 对象-->json--------》阿里巴巴的fastJSON
            String notLogin = JSONObject.toJSONString(error);
            res.getWriter().write(notLogin);
            return false;
        }
        log.info("令牌合法...");
        //6. 放行
        return true;
    }

    @Override   //目标资源方法执行后执行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle方法执行了...");
    }

    @Override   //视图渲染完毕后执行，最后执行
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("视图渲染完毕执行....");
    }
}
_橙留香
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
JwtFilter （过滤器）
10000guo的博客
01-07 3258
JWTFilter&JWT&Filter
登录认证（全集）--jwt，Filter，Interceptor详细说明
m0_63144319的博客
06-24 769
概念:Filter过滤器，是JavaWeb三大组件(Servlet、Filter、Listener)之一。过滤器可以把对资源的请求拦截下来，从而实现一些特殊的功能。过滤器一般完成一些通用登录校验统一编码处理敏感字符处理等。概念:是一种动态拦截方法调用的机制，类似于过滤器。Spring框架中提供的，用来动态拦截控制器方法的执行。作用:拦截请求，在指定的方法调用前后，根据业务需要执行预先设定的代码。与过滤器Filter的使用差不多。
SpringBoot配置JWT拦截器
最新发布
Kristabo的博客
03-24 937
JWT在之前文章提到过，JWT（JSON Web Token）是一种用于身份验证和授权的开放标准（RFC 7519），它允许在网络中安全地传输声明（claims）作为 JSON 对象。JWT 可以通过数字签名或加密来验证数据的完整性和真实性，从而保证数据在传输过程中不被篡改。工作流程用户通过用户名和密码等方式进行身份验证。服务器验证用户身份，并生成一个 JWT。服务器将 JWT 发送给客户端。客户端将 JWT 存储起来，通常是在本地存储或者内存中。
登录校验，JWT令牌技术，过滤器（Filter）拦截器（interceptor）
烛照@123的博客
12-16 583
JWt令牌技术，过滤器，拦截器，都是我们在开发中常用的技术。
jwt过滤器
samgreat911的博客
12-02 430
log.debug("从JWT中获取authoritiesJsonString：{}", authoritiesJsonString);log.debug("解析JWT时出现Throwable，需要开发人员在JWT过滤器补充对异常的处理");log.debug("从JWT中获取username：{}", username);log.debug("获取客户端携带的JWT：{}", jwt);// 对于无效的JWT，直接放行，交由后续的组件进行处理。log.debug("从JWT中获取id：{}", id);
Spring Security采用JWT验证时filter异常处理和JWT续期问题
hey_lie的博客
11-03 1810
1.spring security JWT过滤器异常自定义处理 2.spring security 认证和授权时的异常自定义处理 3.JWT 续期问题
Vue+Jwt+SpringBoot+Ldap完成登录认证的示例代码
08-27
Vue+Jwt+SpringBoot+Ldap完成登录认证的示例代码 本篇文章主要介绍了使用Vue、Jwt、SpringBoot和Ldap完成登录认证的示例代码，旨在帮助读者了解如何使用这些技术来实现安全的登录认证机制。 首先，让我们了解一下...
springboot + jwt + websocket + 拦截
09-02
springboot + jwt + websocket + 拦截
springboot + jwt 登录认证 + 实时日志显示
09-02
springboot + jwt 登录认证 + 实时日志显示
基于SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端商城系统源码
05-13
yshop基于当前流行技术组合的前后端分离商城系统： SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue的前后端分离的商城系统， 包含分类、sku、运费模板、素材库、小程序直播、拼团、砍价、商户管理、 秒杀、...
springboot+security+jwt+mybaits-plus+mysql实现权限管理
03-13
1.传统spring boot框架 2.security框架 3.jwt取代session 4.mybatis-plus+mysql【sql文件项目中有】 5.不想下载，可以看博客，博客中有写
Jwt认证过滤器实现
qq_58137891的博客
05-09 1142
定义Jwt过滤器后，当用户是已登录状态时，在请求头中携带token便可访问相关网页。
简单的鉴权登录-java后端实现部分(JWT令牌+拦截器Interceptor)
WWX19990724的博客
04-11 2804
拦截器的主要是基于Java的反射机制，属于面向切面编程(AOP)的一种运用，就是在Service或者一个方法前调用一个方法，或者在方法后调用一个方法，甚至在抛出异常的时候做业务逻辑的操作。拦截器的作用类似于Servlet中的Filter，都可以用于对处理器进行预处理和后处理。在Spring MVC 与Spring Boot 中使用拦截器一般是实现接口。拦截器的作用：拦截请求，在指定方法调用前后，根据业务需要执行预先设定的代码。
JWT实现拦截器和token认证
AsFarmer的博客
07-28 3408
Jwt实现拦截器
Jwt+Filter+SpringBoot+Redis实现Cookie自动登陆
m0_62314761的博客
05-21 434
FIlter拦截器拦截前端发送过来的请求，然后通过检查请求的cookie然后进行匹配检查，如果没有cookie则证明没有登录过，则需要过滤跳转到查询数据库验证用户名和密码看看是否有此人，如果有则以用户的名字(或者其他信息)通过Jwt生成Token并存入到Cookie里返回给客户端。下次登录的时候拦截器再拦截请求然后通过Jwt工具解码检查里面的cookie并与Redis里存的cookie进行匹配，如果符合了就直接跳转不再需要登录。
JWT 生成 token 与 fliter 过滤器的简单应用
qq_42649533的博客
05-31 243
这是一个比较简单易行的方式去实现token验证，不用将token放入session。
关于JWT登录拦截验证token方式一
weixin_46098310的博客
03-31 1819
SpringBoot+Mybatis-plus+Mysql+JWT
登录 jwt ,filter
zhaogengzi的专栏
08-22 170
当前所在位置和请求位置，然后从3维度来判断是否是跨哉请求，只要有一个不同就属于。cookie 在请求头中叫做cookie，在响应头中叫set-cookie。session基于cookie实现。
jwt+springsecurity登录
08-24
JWT（JSON Web Token）是一种身份验证和授权的安全方案，可以在无状态（Stateless）的环境下实现用户的登录功能。Spring Security是一个用于在Java应用程序中提供身份验证和授权的框架。 在使用JWT和Spring Security实现登录功能时，需要进行以下几个步骤： 首先，客户端会向服务器发送登录请求，提供用户名和密码。 服务器端接收到登录请求后，会验证用户名和密码的正确性。 如果用户名和密码验证通过，服务器端会生成一个JWT，并将其返回给客户端。 客户端在接收到JWT后，将其保存在本地进行后续请求的身份验证。 当客户端发送需要授权的请求时，会在请求头中携带JWT。 服务端在接收到请求后，会从请求头中解析出JWT，并验证其有效性。 如果JWT有效且权限满足要求，服务器端会响应请求，否则会返回相应的错误信息。 在Spring Security中，可以使用`JwtAuthenticationFilter`和`JwtAuthorizationFilter`来实现JWT的验证和授权功能。`JwtAuthenticationFilter`用于检查用户的登录请求，并生成JWT，`JwtAuthorizationFilter`用于解析JWT，并验证其有效性。 同时，为了安全地存储和验证JWT，应该使用密钥（Secret Key）来对JWT进行签名。密钥只有服务器端知道，客户端无法获取。这样可以确保只有服务器端能够签发和验证JWT，保证了其安全性。 总之，使用JWT和Spring Security可以实现安全的用户登录功能。用户在进行登录时，服务器端会生成一个JWT并返回给客户端，客户端保存在本地并在后续请求中进行验证。服务器端在接收到请求时，会验证JWT的有效性，确保请求的合法性，并进行相应的授权。这样可以实现无状态的安全登录功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_橙留香

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值