SpringBoot整合Mybatis-Plus、Jwt实现登录token设置

àì夳堔傛蜴生んèń 2023-10-09 20:52 15阅读 0赞

Spring Boot整合Mybatis-plus实现登录常常需要使用JWT来生成用户的token并设置用户权限的拦截器。本文将为您介绍JWT的核心讲解、示例代码和使用规范，以及如何实现token的生成和拦截器的使用。  
![在这里插入图片描述][890af0c6c3b149368e8f2fede70185db.png_pic_center]  
一、JWT的核心讲解

JWT（JSON Web Token）是一种基于JSON的，用于在网络上安全传输信息的开放标准（RFC 7519）。JWT有三个部分组成，分别是Header（头部）、Payload（载荷）和Signature（签名）。

1.  Header

Header部分通常由两部分组成：令牌的类型和使用的加密算法。例如：

{
        
      "alg": "HS256",
      "typ": "JWT"
    }

其中，“alg” 参数表示签名的算法（例如HS256），“typ” 参数表示令牌的类型（例如JWT）。

1.  Payload

Payload是JWT的核心部分，其中包含了需要传输的信息。示例：

{
        
      "sub": "1234567890",
      "name": "John Doe",
      "iat": 1516239022
    }

其中，“sub” 参数表示主题（Subject），“name” 参数表示名称，“iat” 参数表示令牌的签发时间。

1.  Signature

Signature部分是JWT的第三部分，它由头部和载荷组合后进行签名而产生。

二、JWT 的使用规范

1.  生成 JWT

使用 Java JWT 库生成 JWT，示例代码如下：

import io.jsonwebtoken.Claims;
    import io.jsonwebtoken.Jws;
    import io.jsonwebtoken.Jwts;
    import io.jsonwebtoken.SignatureAlgorithm;
    import io.jsonwebtoken.security.Keys;
    
    import javax.crypto.SecretKey;
    import java.util.Date;
    
    public class JwtUtil {
        
    
        private static final byte[] SECRET_KEY = "secretkeyhere".getBytes();
        private static final long EXPIRATION_TIME = 3600000L; // 1 hour
    
        public static String createJwt(String subject, String scopes) {
        
            SecretKey key = Keys.hmacShaKeyFor(SECRET_KEY);
            Date now = new Date();
            Date expiration = new Date(now.getTime() + EXPIRATION_TIME);
            String jwt = Jwts.builder()
                    .setIssuer("demo")
                    .setSubject(subject)
                    .setExpiration(expiration)
                    .claim("scopes", scopes)
                    .setIssuedAt(now)
                    .signWith(key, SignatureAlgorithm.HS512)
                    .compact();
            return jwt;
        }
    
        public static Jws<Claims> parseJwt(String jwt) {
        
            SecretKey key = Keys.hmacShaKeyFor(SECRET_KEY);
            Jws<Claims> jws = Jwts.parserBuilder()
                    .setSigningKey(key)
                    .build()
                    .parseClaimsJws(jwt);
            return jws;
        }
    }

其中，SECRET\_KEY 是用于签名的密钥，建议使用足够随机的字符串或 byte 数组；EXPIRATION\_TIME 是过期时间，设置为 1 小时；createJwt() 方法会创建 JWT，并将用户标识（subject）和权限（scopes）作为载荷；parseJwt() 方法用于解析 JWT。

1.  解析 JWT

解析 JWT 部分和生成 JWT 略有不同。示例代码如下：

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.HttpStatus;
    import org.springframework.http.ResponseEntity;
    import org.springframework.stereotype.Component;
    import org.springframework.web.filter.OncePerRequestFilter;
    import javax.servlet.FilterChain;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Set;
    import java.util.stream.Collectors;
    
    @Component
    public class JwtAuthenticationFilter extends OncePerRequestFilter {
        
    
        private static final List<String> ALLOWED_URIS = Arrays.asList("/login");
    
        @Autowired
        private JwtProperties jwtProperties;
    
        @Override
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
                throws ServletException, IOException {
        
            String jwt = request.getHeader("Authorization");
            if (jwt != null) {
        
                jwt = jwt.replace("Bearer ", "");
                try {
        
                    Jwts.parserBuilder().setSigningKey(jwtProperties.getSecret()).build().parseClaimsJws(jwt);
                    String[] scopes = ((String)Jwts.parserBuilder().setSigningKey(jwtProperties.getSecret().parseClaimsJws(jwt).getBody().get("scopes")).split(",");
                    Set<String> allowedScopes = Arrays.stream(scopes)
                            .map(String::trim)
                            .collect(Collectors.toSet());
                    String uri = request.getRequestURI();
                    if (!ALLOWED_URIS.contains(uri)) {
        
                        if (!allowedScopes.contains("all") && !allowedScopes.contains(uri)) {
        
                            response.sendError(HttpStatus.FORBIDDEN.value());
                            return;
                        }
                    }
                } catch (Exception e) {
        
                    response.sendError(HttpStatus.UNAUTHORIZED.value());
                    return;
                }
            }
            filterChain.doFilter(request, response);
        }
    }

这段代码定义了一个JwtAuthenticationFilter，它会在每次请求进入 Controller 之前进行拦截，解析 JWT 并根据用户权限进行拦截。ALLOWED\_URIS 定义了不需要 JWT 验证的 URL，比如登录接口。jwtProperties 用于读取一些 JWT 相关的配置，比如密钥（secret）等。

三、Mybatis-plus 使用 JWT 实现登录

在 Mybatis-plus 中使用 JWT 时，我们需要在登录成功之后生成 JWT，并将其返回给客户端。客户端在以后的请求中都会带上 JWT，我们需要在拦截器中解析 JWT 并进行权限校验。

首先，在 pom.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>

然后，我们需要创建一个 JwtUtil 工具类，用于生成和解析 JWT：

import io.jsonwebtoken.Claims;
    import io.jsonwebtoken.JwtBuilder;
    import io.jsonwebtoken.Jwts;
    import io.jsonwebtoken.SignatureAlgorithm;
    import io.jsonwebtoken.impl.DefaultClaims;
    
    import java.util.Date;
    
    public class JwtUtil {
        
    
        private static final String SECRET = "secretkey";
    
        public static String generateToken(String username, Long expiration) {
        
            Date now = new Date();
            Date expireTime = new Date(now.getTime() + expiration * 1000);
            JwtBuilder builder = Jwts.builder()
                    .setId(username)
                    .setIssuedAt(now)
                    .setExpiration(expireTime)
                    .signWith(SignatureAlgorithm.HS256, SECRET);
            return builder.compact();
        }
    
        public static Claims parseToken(String token) {
        
            return Jwts.parser()
                    .setSigningKey(SECRET)
                    .parseClaimsJws(token)
                    .getBody();
        }
    }

在登录成功之后，我们需要调用 JwtUtil.generateToken() 方法生成 JWT，并将其返回给客户端。客户端在以后的请求中都会带上 JWT，我们需要在拦截器中解析 JWT 并进行权限校验：

import io.jsonwebtoken.Claims;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.web.servlet.HandlerInterceptor;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    @Component
    public class JwtIntercepter implements HandlerInterceptor {
        
    
        @Autowired
        private JwtProperties jwtProperties;
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        
            String authorization = request.getHeader("Authorization");
            if (authorization != null && authorization.startsWith("Bearer ")) {
        
                String token = authorization.substring(7);
                try {
        
                    Claims claims = JwtUtil.parseToken(token);
                    request.setAttribute("username", claims.getSubject());
                    return true;
                } catch (Exception e) {
        
                    response.sendError(HttpServletResponse.SC_FORBIDDEN, e.getMessage());
                    return false;
                }
            } else {
        
                response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "No token provided in the request header");
                return false;
            }
        }
    }

在拦截器中，我们通过 request.setAttribute() 方法将解析出来的用户信息保存在 Request 中，后续可以通过 Request 获取到用户信息。在拦截器中，我们也可以实现权限校验的逻辑。如果校验失败，我们可以通过 response.sendError() 方法返回403 或 401 状态码，告知客户端请求被拒绝或未经授权。

最后，定义一个 WebMvcConfigurerAdapter，将 JwtIntercepter 注册为拦截器：

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    
    @Configuration
    public class WebConfig implements WebMvcConfigurer {
        
    
        @Autowired
        private JwtIntercepter jwtIntercepter;
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
        
            registry.addInterceptor(jwtIntercepter)
                    .addPathPatterns("/**")
                    .excludePathPatterns("/login");
        }
    }

在上述代码中，我们通过 addPathPatterns() 方法设置需要拦截的 URL 路径，并通过 excludePathPatterns() 方法排除不需要拦截的 URL 路径。其中，“/login” 路径为登录接口，一般不需要拦截。

四、总结

本文介绍了在 Spring Boot 整合 Mybatis-plus 实现登录时，使用 JWT 来生成用户 Token 并设置用户权限拦截器的方法。首先，我们需要了解 JWT 的核心框架和使用规范，并通过代码实现 JWT 的生成和解析。然后，我们在拦截器中实现 JWT 的解析和权限校验，最后通过 WebMvcConfigurerAdapter 将 JwtIntercepter 注册为拦截器。

[890af0c6c3b149368e8f2fede70185db.png_pic_center]: https://img-blog.csdnimg.cn/890af0c6c3b149368e8f2fede70185db.png#pic_center