SpringBoot集成JWT实现token验证

红太狼 2022-12-24 05:50 124阅读 0赞

# 前言 #

最近项目使用JWT，进行token校验

--------------------

# 概述 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyMzcwOTEz_size_16_color_FFFFFF_t_70_pic_center]

1.  用户使用账号和面发出post请求；
2.  服务器使用私钥创建一个jwt；
3.  服务器返回这个jwt给浏览器；
4.  浏览器将该jwt串在请求头中像服务器发送请求；
5.  服务器验证该jwt；
6.  返回响应的资源给浏览器

*  JWT概述  
    Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).定义了一种简洁的，自包含的方法用于通信双方之间以JSON对象的形式安全的传递信息。因为数字签名的存在，这些信息是可信的，JWT可以使用HMAC算法或者是RSA的公私秘钥对进行签名。
 *  JWT的主要应用场景  
    身份认证在这种场景下，一旦用户完成了登陆，在接下来的每个请求中包含JWT，可以用来验证用户身份以及对路由，服务和资源的访问权限进行验证。由于它的开销非常小，可以轻松的在不同域名的系统中传递，所有目前在单点登录（SSO）中比较广泛的使用了该技术。 信息交换在通信的双方之间使用JWT对数据进行编码是一种非常安全的方式，由于它的信息是经过签名的，可以确保发送者发送的信息是没有经过伪造的。

### JWT的结构 ###

*  Header 头部(标题包含了令牌的元数据，并且包含签名和/或加密算法的类型)
 *  Payload 负载
 *  Signature 签名/签证

声明加密的算法:通常直接使用 HMAC SHA256

##### Payload #####

载荷就是存放有效信息的地方。  
有效信息包含三个部分  
1.标准中注册的声明  
2.公共的声明  
3.私有的声明

标准中注册的声明 (建议但不强制使用) ：  
iss: jwt签发者  
sub: 面向的用户(jwt所面向的用户)  
aud: 接收jwt的一方  
exp: 过期时间戳(jwt的过期时间，这个过期时间必须要大于签发时间)  
nbf: 定义在什么时间之前，该jwt都是不可用的.  
iat: jwt的签发时间  
jti: jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。

#### 公共的声明 ： ####

公共的声明可以添加任何的信息，一般添加用户的相关信息或其他业务需要的必要信息.但不建议添加敏感信息，因为该部分在客户端可解密.

#### 私有的声明 ： ####

私有声明是提供者和消费者所共同定义的声明，一般不建议存放敏感信息，因为base64是对称解密的，意味着该部分信息可以归类为明文信息。

#### Signature ####

jwt的第三部分是一个签证信息  
这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串，然后通过header中声明的加密方式进行加盐secret组合加密，然后就构成了jwt的第三部分。  
密钥secret是保存在服务端的，服务端会根据这个密钥进行生成token和进行验证，所以需要保护好。

# 代码实现 #

#### 自定义注解 ####

*  用来跳过验证的PassToken

@Target({ ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface PassToken { 
        boolean required() default true;
    }

*  需要登录才能进行操作的注解UserLoginToken

@Target({ ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface UserLoginToken { 
        boolean required() default true;
    }

@Target:注解的作用目标  
@Target(ElementType.TYPE):接口、类、枚举、注解  
@Target(ElementType.FIELD):字段、枚举的常量  
@Target(ElementType.METHOD):方法  
@Target(ElementType.PARAMETER):方法参数  
@Target(ElementType.CONSTRUCTOR): 构造函数  
@Target(ElementType.LOCAL\_VARIABLE):局部变量  
@Target(ElementType.ANNOTATION\_TYPE):注解  
@Target(ElementType.PACKAGE):包

@Retention：注解的保留位置  
RetentionPolicy.SOURCE:这种类型的Annotations只在源代码级别保留,编译时就会被忽略,在class字节码文件中不包含。  
RetentionPolicy.CLASS:这种类型的Annotations编译时被保留,默认的保留策略,在class文件中存在,但JVM将会忽略,运行时无法获得。  
RetentionPolicy.RUNTIME:这种类型的Annotations将被JVM保留,所以他们能在运行时被JVM或其他使用反射机制的代码所读取和使用。  
@Document：说明该注解将被包含在javadoc中  
@Inherited：说明子类可以继承父类中的该注解

*  token生成方法：在用户登录时生成，并放回给前端

public String getToken(User user) { 
            String token="";
            token= JWT.create().withAudience(user.getId())
                    .sign(Algorithm.HMAC256(user.getPassword()));
            return token;
        }

Algorithm.HMAC256():使用HS256生成token,密钥则是用户的密码，唯一密钥的话可以保存在服务端。  
withAudience()存入需要保存在token的信息，这里我把用户ID存入token中

*  编写自定义拦截器，拦截前端传递的token，

import org.springframework.stereotype.Component;
    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    /** * @program: phb-server * @description: * @author: Zhaocunwei * @create: 2020-11-26 22:01 **/
    @Component
    public class LoginInterceptor implements HandlerInterceptor { 
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
                throws Exception { 
                //TODO token 校验
            System.out.println("hahah");
                return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                               ModelAndView modelAndView) throws Exception { 
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
                throws Exception { 
        }
    }

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.CorsRegistry;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    
    /** * @program: phb-server * @description: * @author: Zhaocunwei * @create: 2020-11-26 21:49 **/
    @Configuration
    public class WebConfig implements WebMvcConfigurer { 
    
       @Autowired
       private LoginInterceptor loginInterceptor;
        @Override
        public void addCorsMappings(CorsRegistry registry) { 
            registry.addMapping("/**")
                    .allowedHeaders("*")
                    .allowedMethods("*")
                    .allowedOrigins("*");
        }
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) { 
            registry.addInterceptor(loginInterceptor);
        }
    }

*  自定义拦截器里面可以这样操作：【来自网上】

public class AuthenticationInterceptor implements HandlerInterceptor { 
        @Autowired
        UserService userService;
        @Override
        public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object object) throws Exception { 
            String token = httpServletRequest.getHeader("token");// 从 http 请求头中取出 token
            // 如果不是映射到方法直接通过
            if(!(object instanceof HandlerMethod)){ 
                return true;
            }
            HandlerMethod handlerMethod=(HandlerMethod)object;
            Method method=handlerMethod.getMethod();
            //检查是否有passtoken注释，有则跳过认证
            if (method.isAnnotationPresent(PassToken.class)) { 
                PassToken passToken = method.getAnnotation(PassToken.class);
                if (passToken.required()) { 
                    return true;
                }
            }
            //检查有没有需要用户权限的注解
            if (method.isAnnotationPresent(UserLoginToken.class)) { 
                UserLoginToken userLoginToken = method.getAnnotation(UserLoginToken.class);
                if (userLoginToken.required()) { 
                    // 执行认证
                    if (token == null) { 
                        throw new RuntimeException("无token，请重新登录");
                    }
                    // 获取 token 中的 user id
                    String userId;
                    try { 
                        userId = JWT.decode(token).getAudience().get(0);
                    } catch (JWTDecodeException j) { 
                        throw new RuntimeException("401");
                    }
                    User user = userService.findUserById(userId);
                    if (user == null) { 
                        throw new RuntimeException("用户不存在，请重新登录");
                    }
                    // 验证 token
                    JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(user.getPassword())).build();
                    try { 
                        jwtVerifier.verify(token);
                    } catch (JWTVerificationException e) { 
                        throw new RuntimeException("401");
                    }
                    return true;
                }
            }
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest httpServletRequest, 
                                      HttpServletResponse httpServletResponse, 
                                Object o, ModelAndView modelAndView) throws Exception { 
    
        }
        @Override
        public void afterCompletion(HttpServletRequest httpServletRequest, 
                                              HttpServletResponse httpServletResponse, 
                                              Object o, Exception e) throws Exception { 
        }

# 主要流程: #

1.从 http 请求头中取出 token，  
2.判断是否映射到方法  
3.检查是否有passtoken注释，有则跳过认证  
4.检查有没有需要用户登录的注解，有则需要取出并验证  
5.认证通过则可以访问，不通过会报相关错误信息

**在数据访问接口中加入登录操作注解**

@RestController
    @RequestMapping("api")
    public class UserApi { 
        @Autowired
        UserService userService;
        @Autowired
        TokenService tokenService;
        //登录
        @PostMapping("/login")
        public Object login(@RequestBody User user){ 
            JSONObject jsonObject=new JSONObject();
            User userForBase=userService.findByUsername(user);
            if(userForBase==null){ 
                jsonObject.put("message","登录失败,用户不存在");
                return jsonObject;
            }else { 
                if (!userForBase.getPassword().equals(user.getPassword())){ 
                    jsonObject.put("message","登录失败,密码错误");
                    return jsonObject;
                }else { 
                    String token = tokenService.getToken(userForBase);
                    jsonObject.put("token", token);
                    jsonObject.put("user", userForBase);
                    return jsonObject;
                }
            }
        }
        @UserLoginToken
        @GetMapping("/getMessage")
        public String getMessage(){ 
            return "你已通过验证";
        }
    }

不加注解的话默认不验证，登录接口一般是不验证的。在getMessage()中我加上了登录注解，说明该接口必须登录获取token后，在请求头中加上token并通过验证才可以访问

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyMzcwOTEz_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/e18d1e2c1dad4a30834fcd179b0955ec.png