JWT 实现登录

已于 2023-05-23 14:34:17 修改
阅读量8.2k 收藏 58
点赞数 12
分类专栏： Spring 文章标签： spring
于 2022-06-24 00:09:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dailyblue/article/details/125436846
版权

我们首先回顾下过去登录的方式，用户页面中输入账号和密码，点击提交发送到 controller 类中，controller 类接收账号和密码，并且调用业务和数据层去判断账号和密码是否正确，如果错误，返回到登录页面，如果正确，将用户信息保存到 session 中并跳转到主页面。

这里会发现，我们是通过 session 来记录用户登录状态，跟踪用户信息，那么就要在这里提一提 session 登录的缺陷：

  1. session 是将客户端数据储存在服务器的内存，当客户端的数据过多，连接较多，服务器的内存开销大。
  2. session 的数据储存在某台服务器，在分布式的项目中无法做到共享。
  3. 前后端分离的项目中共享 session 比较困难。
  4. jwt 不需要在服务端去保留用户的认证信息或者会话信息。

什么是 JWT

jwt 全称是 json web token。是由用户以用户名、密码登录，服务端验证后，会生成一个 token，返回给客户端，客户端在下次访问的过程中携带这个 token，服务端责每次验证这个token。 

JWT 的构成

jwt 由三部分组成，每一部分之间用符号"."进行分割，整体可以看做是一个长字符串。一个经典的jwt的样子：xxx.xxx.xxx。

Header 头部

头部由两部分组成：第一部分是声明类型，在 jwt 中声明类型就 jwt，第二部分是声明加密的算法，加密算法通常使用 HMAC|SHA256。一个经典的头部：

{
  'typ': 'JWT',      //  'typ':'声明类型'
  'alg': 'HS256'	//	'alg':'声明的加密算法'
}

Payload 载体、载荷

这一部分是jwt的主体部分，这一部分也是json对象，可以包含需要传递的数据，其中jwt指定了七个默认的字段选择，这七个字段是推荐但是不强制使用的：

  • iss：发行人
  • exp：到期时间
  • sub：主题
  • aud：用户
  • nbf：在此之前不可用
  • iat：发布时间
  • jti：JWT ID 用于识别该 JWT

除了上述的七个默认字段之外，还可以自定义字段，通常我们说 JWT 用于用户登陆，就可以在这个地方放置用户的id和用户名。下面这个json对象是一个 jwt 的 Payload 部分：

{
"sub": "一个演示",
"nickname": "dailyblue",
"id": "001"
}

这里注意虽然可以放自定的信息，但是不要存放一些敏感信息，除非是加密过的，因为这里的信息可能会被截获。 

signature  签证

这部分是对前两部分进行base64编码在进行加密，这个加密的方式使用的是jwt的头部声明中的加密方式，在加上一个密码（secret）组成的，secret 通常是一个随机的字符串，这个 secret是服务器特有的，不能够让其他人知道。这部分的组成公式是：

HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload),secret)

JWT 的优点

  1. json形式，而json非常通用性可以让它在很多地方使用
  2. jwt所占字节很小，便于传输信息
  3. 需要服务器保存信息，易于扩展 

使用 JWT 登录流程

  1. 第一次登录的时候，前端调后端的登陆接口，发送帐号和密码。
  2. 后端收到请求，验证帐号和密码，验证成功，就给前端返回一个 jwt。
  3. 前端拿到 jwt，将 jwt 存储到 localStroage 或 header 中，并跳转到页面。
  4. 前端每次跳转页面，就判断 localStroage 中有无 jwt ，没有就跳转到登录页面，有则跳转到对应页面。
  5. 每次调后端接口，都要在请求头中加 jwt。
  6. 后端判断请求头中有无 jwt，有 jwt，就拿到 jwt 并验证 jwt，验证成功就返回数据，验证失败（例如：jwt 过期）就返回401，请求头中没有 jwt 也返回401。
  7. 如果前端拿到状态码为401，就清除 jwt 信息并跳转到登录页面。

所需依赖

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
</dependency>
<dependency>
   <groupId>io.jsonwebtoken</groupId>
   <artifactId>jjwt</artifactId>
   <version>0.9.1</version>
</dependency>
<!-- jaxb依赖包 -->
<dependency>
   <groupId>javax.xml.bind</groupId>
   <artifactId>jaxb-api</artifactId>
   <version>2.3.0</version>
</dependency>
<dependency>
   <groupId>com.sun.xml.bind</groupId>
   <artifactId>jaxb-impl</artifactId>
   <version>2.3.0</version>
</dependency>
<dependency>
   <groupId>com.sun.xml.bind</groupId>
   <artifactId>jaxb-core</artifactId>
   <version>2.3.0</version>
</dependency>
<dependency>
   <groupId>javax.activation</groupId>
   <artifactId>activation</artifactId>
   <version>1.1.1</version>
</dependency>

JWT 工具类

package com.dailyblue.java.spring.config;

import com.dailyblue.java.spring.bean.User;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import java.util.Date;

/**
 * @author dailyblue
 * @since 2022/6/23
 */
public class JwtConfig {

    //常量
    public static final long EXPIRE = 1000 * 60 * 60 * 24; //token过期时间
    public static final String APP_SECRET = "1234"; //秘钥，加盐

    //	@param id 当前用户ID
    //	@param issuer 该JWT的签发者，是否使用是可选的
    //	@param subject 该JWT所面向的用户，是否使用是可选的
    //	@param ttlMillis 什么时候过期，这里是一个Unix时间戳，是否使用是可选的
    //	@param audience 接收该JWT的一方，是否使用是可选的
    //生成token字符串的方法
    public static String getJwtToken(User user) {

        String JwtToken = Jwts.builder()
                .setHeaderParam("typ", "JWT")    //头部信息
                .setHeaderParam("alg", "HS256")    //头部信息
                //下面这部分是payload部分
                // 设置默认标签
                .setSubject("dailyblue")    //设置jwt所面向的用户
                .setIssuedAt(new Date())    //设置签证生效的时间
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))    //设置签证失效的时间
                //自定义的信息，这里存储id和姓名信息
                .claim("id", user.getId())  //设置token主体部分 ，存储用户信息
                .claim("name", user.getUserName())
                //下面是第三部分
                .signWith(SignatureAlgorithm.HS256, APP_SECRET)
                .compact();
        // 生成的字符串就是jwt信息，这个通常要返回出去
        return JwtToken;
    }

    /**
     * 判断token是否存在与有效
     * 直接判断字符串形式的jwt字符串
     *
     * @param jwtToken
     * @return
     */
    public static boolean checkToken(String jwtToken) {
        if (StringUtils.isEmpty(jwtToken)) return false;
        try {
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 判断token是否存在与有效
     * 因为通常jwt都是在请求头中携带，此方法传入的参数是请求
     *
     * @param request
     * @return
     */
    public static boolean checkToken(HttpServletRequest request) {
        try {
            String jwtToken = request.getHeader("token");//注意名字必须为token才能获取到jwt
            if (StringUtils.isEmpty(jwtToken)) return false;
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 根据token字符串获取会员id
     * 这个方法也直接从http的请求中获取id的
     *
     * @param request
     * @return
     */
    public static String getMemberIdByJwtToken(HttpServletRequest request) {
        String jwtToken = request.getHeader("token");
        if (StringUtils.isEmpty(jwtToken)) return "";
        Jws<Claims> claimsJws = Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        Claims claims = claimsJws.getBody();
        return claims.get("id").toString();
    }

    /**
     * 解析JWT
     * @param jwt
     * @return
     */
    public static Claims parseJWT(String jwt) {
        Claims claims = Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwt).getBody();
        return claims;
    }
}

相关工具类在网上有很多，有兴趣的童鞋也可以相互借鉴。 

返回结果工具类

状态码返回

package com.dailyblue.java.spring.util;

/**
 * @Author: Dailyblue
 * @Description: 返回码定义
 * 规定:
 * #1表示成功
 * #1001～1999 区间表示参数错误
 * #2001～2999 区间表示用户错误
 * #3001～3999 区间表示接口异常
 * @Date Create in 2022/06/21 19:28
 */
public enum ResultCode {
    /* 成功 */
    SUCCESS(200, "成功"),

    /* 默认失败 */
    COMMON_FAIL(999, "失败"),

    /* 参数错误：1000～1999 */
    PARAM_NOT_VALID(1001, "参数无效"),
    PARAM_IS_BLANK(1002, "参数为空"),
    PARAM_TYPE_ERROR(1003, "参数类型错误"),
    PARAM_NOT_COMPLETE(1004, "参数缺失"),

    /* 用户错误 */
    USER_NOT_LOGIN(2001, "用户未登录"),
    USER_ACCOUNT_EXPIRED(2002, "账号已过期"),
    USER_CREDENTIALS_ERROR(2003, "密码错误"),
    USER_CREDENTIALS_EXPIRED(2004, "密码过期"),
    USER_ACCOUNT_DISABLE(2005, "账号不可用"),
    USER_ACCOUNT_LOCKED(2006, "账号被锁定"),
    USER_ACCOUNT_NOT_EXIST(2007, "账号不存在"),
    USER_ACCOUNT_ALREADY_EXIST(2008, "账号已存在"),
    USER_ACCOUNT_USE_BY_OTHERS(2009, "账号下线"),

    /* 业务错误 */
    NO_PERMISSION(3001, "没有权限");
    private Integer code;
    private String message;

    ResultCode(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    /**
     * 根据code获取message
     *
     * @param code
     * @return
     */
    public static String getMessageByCode(Integer code) {
        for (ResultCode ele : values()) {
            if (ele.getCode().equals(code)) {
                return ele.getMessage();
            }
        }
        return null;
    }
}

统一返回实体

package com.dailyblue.java.spring.util;

import lombok.Data;

import java.io.Serializable;

/**
 * @Author: Dailyblue
 * @Description: 统一返回实体
 * @Date Create in 2022/06/21 19:28
 */
@Data
public class JsonResult<T> implements Serializable {
    private Boolean success;
    private Integer errorCode;
    private String errorMsg;
    private T data;

    public JsonResult() {
    }

    public JsonResult(boolean success) {
        this.success = success;
        this.errorCode = success ? ResultCode.SUCCESS.getCode() : ResultCode.COMMON_FAIL.getCode();
        this.errorMsg = success ? ResultCode.SUCCESS.getMessage() : ResultCode.COMMON_FAIL.getMessage();
    }

    public JsonResult(boolean success, ResultCode resultEnum) {
        this.success = success;
        this.errorCode = success ? ResultCode.SUCCESS.getCode() : (resultEnum == null ? ResultCode.COMMON_FAIL.getCode() : resultEnum.getCode());
        this.errorMsg = success ? ResultCode.SUCCESS.getMessage() : (resultEnum == null ? ResultCode.COMMON_FAIL.getMessage() : resultEnum.getMessage());
    }

    public JsonResult(boolean success, T data) {
        this.success = success;
        this.errorCode = success ? ResultCode.SUCCESS.getCode() : ResultCode.COMMON_FAIL.getCode();
        this.errorMsg = success ? ResultCode.SUCCESS.getMessage() : ResultCode.COMMON_FAIL.getMessage();
        this.data = data;
    }

    public JsonResult(boolean success, ResultCode resultEnum, T data) {
        this.success = success;
        this.errorCode = success ? ResultCode.SUCCESS.getCode() : (resultEnum == null ? ResultCode.COMMON_FAIL.getCode() : resultEnum.getCode());
        this.errorMsg = success ? ResultCode.SUCCESS.getMessage() : (resultEnum == null ? ResultCode.COMMON_FAIL.getMessage() : resultEnum.getMessage());
        this.data = data;
    }

}

返回体构造器

package com.dailyblue.java.spring.util;

/**
 * @Author: Dailyblue
 * @Description: 返回体构造工具
 * @Date Create in 2022/06/21 19:28
 */
public class ResultTool {
    public static JsonResult success() {
        return new JsonResult(true);
    }

    public static <T> JsonResult<T> success(T data) {
        return new JsonResult(true, data);
    }

    public static JsonResult fail() {
        return new JsonResult(false);
    }

    public static JsonResult fail(ResultCode resultEnum) {
        return new JsonResult(false, resultEnum);
    }
}

前端发送时携带 jwt

axios.get('url',{
  headers: 
  {
    'key': value
  }
})

拦截器的跨域问题 

起初解决 Springboot 跨域问题的方法是直接在 Controller 上添加 @CrossOrigin 注解，实现了前后端分离中的跨域请求。但随着业务代码的编写，做了 token 会话保持的检验，添加了拦截器后，再次出现了跨域问题。

很纳闷，按理说后台已经允许了跨域请求，之前的测试也证明了这一点，那为什么又突然出现了跨域拦截问题呢？

首先，在登录拦截器中作了校验，对于需要登录后才能访问的接口，如果请求头中没有携带 token，则是非法请求，直接返回404码。然后由于一直有对拦截到的请求中的请求头中的 token 做打印，所以出现问题的时候，控制台打印的 token 值为null，打开浏览器的开发者工具查看请求头也发现没有携带成功。而在没有添加拦截器之前上述问题都是不存在的，都是正常的，所以都不用考虑是前端问题，问题肯定出在后端，准确的说是拦截器。

那么为什么浏览器不能成功发送 token 呢？根据线索在更详细的查看了 CROS 的介绍后发现，原来 CROS 复杂请求时会首先发送一个 OPTIONS 请求做嗅探，来测试服务器是否支持本次请求，请求成功后才会发送真实的请求；而 OPTIONS 请求不会携带任何数据，导致这个请求不符合我们拦截器的校验规则被拦截了，直接返回了状态码，响应头中也没携带解决跨域需要的头部信息，进而出现了跨域问题。所以在浏览器调试工具中会发现该次请求没有携带 token，后端控制台打印 token 也为 null。

其次，就算这样，为什么会发生在添加跨域相关头部信息前就提前结束请求的这种情况呢？难道自定义的拦截器优先于 @CrossOrigin 注解执行？

通过查阅资料，解析 @CrossOrigin 注解的源码得知，如果 Controller 在类上标了 @CrossOrigin 或在方法上标了 @CrossOrigin 注解，则 Spring 在记录 mapper 映射时会记录对应跨域请求映射，将结果返回到 AbstractHandlerMethodMapping，当一个跨域请求过来时，Spring 在获取 handler 时会判断这个请求是否是一个跨域请求，如果是，则会返回一个可以处理跨域的 handler。总结起来 @CrossOrigin 的原理相当于和 Handler 进行强绑定。

于是现在的问题又到了：Handler 和拦截器的执行顺序？

DispatchServlet.doDispatch() 方法是 SpringMVC 的核心入口方法，经过分析发现所有的拦截器的 preHandle() 方法的执行都在实际 handler 的方法之前，其中任意拦截器返回 false 都会跳过后续所有处理过程。而 SpringMVC 对预检请求的处理则在 PreFlightHandler.handleRequest() 中处理，在整个处理链条中出于后置位。由于预检请求中不带数据，因此先被权限拦截器拦截了。

所以每次获取不到 token 的请求都是 OPTIONS 请求，那么解决的方法就很明了了：把所有的OPTIONS请求统统放行。

//拦截器取到请求先进行判断，如果是OPTIONS请求，则放行
if("OPTIONS".equals(httpServletRequest.getMethod().toUpperCase())) {
    System.out.println("Method:OPTIONS");
	return true;
 }

还有另一种方式，就是通过过滤器来处理跨域请求，众所周知，过滤器在拦截器之前执行，能够有效避免拦截处理的情况发生。

@Slf4j
@WebFilter("/*")
// 跨域过滤器
public class CrosFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("过滤处理过滤器启动了...");
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        log.info("跨域处理过滤器");
        HttpServletResponse response = (HttpServletResponse) res;
        HttpServletRequest request = (HttpServletRequest) req;
        if (StringUtils.isEmpty(request.getHeader("Origin"))) {
            response.setHeader("Access-Control-Allow-Origin", "*");
        } else {
            response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin"));
        }
        response.setHeader("Access-Control-Allow-Headers", "*");
        response.setHeader("Access-Control-Allow-Methods", "*");
        response.setHeader("Access-Control-Max-Age", "3600");
        if ("OPTIONS".equals(request.getMethod())) {
            response.setStatus(HttpServletResponse.SC_OK);
            return;
        }
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {
    }
}

详细的代码会在课程中涉及到，这里只罗列了流程和概念性问题。

Dailyblue
关注
  • 12
    点赞
  • 踩
  • 58
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
基于JWT实现单点登录
Lyh_ok的博客
05-15 1万+
单点登录概述： 多系统共存下，用户在一处地方登录，得到其他所有系统的信任，无需再次登录。 自己的理解：在进行用户登录的时候，jwt生成一个token，用户带着这个token去其他页面进行验证。(token设置过期时间) 这里介绍一些jwt基本概念 JWT：1.认证流程 a.首先，前端通过web表单将自己的用户民和密码发送到后端的接口，这一过程一般是一个HTTP,POST请求。建议的方式是通过SSL 加密的方式传输(https协议)，从而避免敏感信息被嗅探。 b.后端核对用户名和密码成功后，将用户的id
StringCloud_JWT（鉴权）
qq_44509920的博客
08-27 573
文章目录1. 为什么要学习JWT？1.1.简介1.2.数据格式1.3. JWT详解1.3.1 base64编码原理（了解）1.3.2 jwt测试-JwtUtil的使用1.4. JWT交互流程1.5.结合Zuul的鉴权流程2. 项目整体架构3. 搭建父工程jwt-parent3.1 创建项目3.2 pom4. 搭建Eureka注册中心4.1 创建项目4.2 pom4.3 yml配置4.4 开启EuerkaServer注解4.5 测试5.准备工作5.1 创建jwt-common模块5.1.1 创建项目5.1.2
用户登录 JWT原理剖析 JWT与单点登录实例解释
看花容易绣花难
05-01 3116
首先从用户的登录原理和实现讲起，然后引申出JWT的登录方式，在详细的讲解了JWT的原理之后我们会通过案例讲解JWT是如何保存用户信息。
jwt 实现用户登录完整java
最新发布
qq_62383709的博客
06-02 917
保护所有受保护的接口增加jwt合法性逻辑 custom.interceptor.AuthenticationInterceptor。我们约定，前端登录后，后续请求都将JWT，放置于HTTP请求的Header中，其Header的key为。登录接口需要为登录成功的用户创建并返回JWT，本项目使用开源的JWT工具。创建JWT和工具类 common.utils.JwtUtil。用户登录的校验逻辑分为三个主要步骤，分别是。，配置如下，具体内容可参考。controller逻辑。编写mapper逻辑。
基于JWT实现简单的用户登陆验证（超详细）
weixin_47025166的博客
06-20 9474
基于JWT实现简单的用户登陆验证
JWT单点登录
weixin_45427945的博客
06-09 1664
JWT单点登录
使用JWT实现无状态登录验证
sean的博客
02-21 942
使用JSON Web Token（JWT）实现登录认证是一种常见的无状态身份验证机制，它允许服务器在一次登录后向客户端发送一个签名的令牌，客户端随后可以在每次请求中携带这个令牌以证明其身份。以下是JWT实现登录认证的一种方式（使用手机+验证码登录例子）。
vue+egg+jwt实现登录验证的示例代码
10-16
主要介绍了vue+egg+jwt实现登录验证的示例代码，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
springboot+springSecurity+jwt实现登录认证后令牌授权
09-12
在这个项目中，我们将探讨如何利用Spring Boot、Spring Security和JWT来实现登录认证后的令牌授权。 首先，让我们从Spring Boot开始。Spring Boot简化了Spring应用的初始搭建以及开发过程。通过提供默认配置，它极...
SpringBoot使用JWT实现登录验证的方法示例
08-25
在SpringBoot应用中，我们可以利用JWT来实现登录验证，为用户提供安全的身份验证体验。 在SpringBoot中使用JWT的基本步骤如下： 1. **添加JWT依赖**： 首先，我们需要在项目的pom.xml文件中添加JWT库的依赖，例如...
JWT 实现登录认证 + Token 自动续期方案，这才是正确的使用姿势！
03-17
本文将深入探讨如何使用JWT实现登录认证，并结合Token自动续期方案，确保用户会话的安全与持久性。以下是关于这个主题的详细知识点： 1. JWT简介： JWT是一种开放标准（RFC 7519），用于在网络应用之间安全地传输...
详解使用JWT实现单点登录（完全跨域方案）
10-16
JSON Web Token（JWT）是一种流行的轻量级身份验证和授权机制，常用于实现单点登录（Single Sign-On, SSO）系统，特别是在完全跨域的场景下。JWT允许用户在多个相关应用或服务之间共享认证信息，而无需多次登录。...
厉害，我带的实习生仅用四步就整合好SpringSecurity+JWT实现登录认证
热门推荐
沉默王二
04-07 2万+
小二是新来的实习生，作为技术 leader，我还是很负责任的，有什么锅都想甩给他，啊，不，一不小心怎么把心里话全说出来了呢？重来！ 小二是新来的实习生，作为技术 leader，我还是很负责任的，有什么好事都想着他，这不，我就安排了一个整合SpringSecurity+JWT实现登录认证的小任务交，没想到，他仅用四步就搞定了，这让我感觉倍有面。 一、关于 SpringSecurity 在 Spring Boot 出现之前，SpringSecurity 的使用场景是被另外一个安全管理框架 Shiro 牢牢霸占
JWT实现单点登录(SSO)
拾信
04-25 6550
相关技术名词： SSO、JWT、Redis、AOP、RSA、MD5 - salt
使用JWT实现的登录控制，如何给token自动续期？
m0_54187478的博客
01-24 1078
在使用JWT（JSON Web Tokens）进行身份验证时，自动续期通常是指在当前令牌即将过期时自动发放一个新的令牌。
java基于springboot+jwt实现用户登录功能
qq_58493322的博客
06-07 767
总之，使用Spring Boot框架和JWT技术实现用户登录功能可以提高应用程序的安全性和可靠性，同时也可以提高用户体验和功能性。
java写一个用户登陆的jwt工具类
weixin_35749786的博客
01-04 119
好的，这是一个使用Java编写的JWT工具类供用户登录： import com.auth0.jwt.JWT; import com.auth0.jwt.algorithms.Algorithm; import com.auth0.jwt.exceptions.JWTCreationException; import com.auth0.jwt.interfaces.DecodedJWT; imp...
后台实战——用户登录之JWT
itKingOne的博客
03-26 1万+
现在的app往往会有登录功能，一般移动端app登录后都会得到一个token，今天就将token的一种实现方式Json Web Token（JWT），对于不了解JWT的同学可以参考这里，这里还有一个在线的的JWT生成器。在java中要使用jwt，需要pom.xml中添加如下依赖[html] view plain copy&lt;dependency&gt;      &lt;groupId&gt;c...
jwt实现注册与登陆系统
张致豪
08-01 5251
前言 自己用react+koa实现了一个包含登陆和注册功能的网址，在这里记录一下实现过程 项目地址： 预览地址： 注册 注册其实没什么好说的，就是要注意不要明文保存密码，否则数据库泄露后，密码会被其他人用来撞库使用。 前台加密主要是为了防止post请求明文传递密码，本来我想在前端加密，然后数据库直接保存加密的密码到数据库，登陆时传递加密后的密码进行登陆，但是前端使用的加密工具加密同一个密码每次都...
springboot集成jwt实现登录
09-07
对于Spring Boot集成JWT实现登录的步骤，可以按照以下几个步骤进行操作： 1. 添加依赖：在`pom.xml`文件中添加以下依赖，以引入JWT相关的库： ```xml <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-api</artifactId> <version>0.11.2</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-impl</artifactId> <version>0.11.2</version> <scope>runtime</scope> </dependency> dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-jackson</artifactId> <version>0.11.2</version> <scope>runtime</scope> </dependency> ``` 2. 创建JWT工具类：创建一个JWT工具类，用于生成和解析JWT。你可以使用`Jwts.builder()`来创建JWT，并设置相关的声明（例如，用户ID、角色等）和过期时间。 3. 创建登录接口：创建一个登录接口，用于验证用户名和密码，并生成相应的JWT。在验证通过后，可以使用JWT工具类生成JWT并返回给客户端。 4. 配置Spring Security：为了保护你的API，你需要进行Spring Security的配置。你可以创建一个继承`WebSecurityConfigurerAdapter`的类，并重写`configure()`方法来配置安全规则。在这个方法中，你可以配置哪些URL需要进行认证，哪些URL不需要认证（例如，登录接口）。 5. 创建Token过滤器：创建一个Token过滤器，用于验证请求中的JWT，并将用户信息存储到SecurityContext中，以便在后续的请求中使用。 6. 配置Token过滤器：在Spring Security配置类中，将Token过滤器添加到过滤器链中，以保证每个请求都会经过Token过滤器的验证。 通过以上步骤，你就可以实现Spring Boot集成JWT实现登录功能。当用户登录成功后，会生成一个JWT，并在后续的请求中使用该JWT进行身份验证。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值