java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > SpringBoot JWT Token登录验证

SpringBoot集成JWT实现Token登录验证的示例代码

作者:深情不及里子

随着技术的发展,分布式web应用的普及,通过session管理用户登录状态成本越来越高,因此慢慢发展成为token的方式做登录身份校验,本文就来介绍一下SpringBoot集成JWT实现Token登录验证的示例代码,感兴趣的可以了解一下

一,  JWT是什么?

JWT官网

在JWT官网中可以明确看到关于它的定义

JSON Web令牌(JWT)是一种开放的标准(RFC 7519),它定义了一种紧凑而独立的方式在各方之间安全地传输信息为JSON对象。该信息可以被验证和信任,因为它是数字签名的。JWT可以使用秘密(使用HMAC算法)或使用RSA或ECDSA的公开/私有密钥类型签名。 虽然JWT可以被加密以提供各方之间的保密,但我们将重点关注签名的令牌。被签名的令牌可以验证包含在其中的声明的完整性,而加密的令牌对其他各方隐藏这些声明。当使用公钥/私钥对签名时,签名还证明只有持有私钥的一方才是签名方。

1.1 JWT主要使用场景

1.2 JWT请求流程

1.3 JWT结构

JWT是由三段信息构成的,将这三段信息文本用.连接一起就构成了JWT字符串。

就像这样:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

 JWT包含了三部分:

Header

JWT的头部承载两部分信息:token类型和采用的加密算法。

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

声明类型:这里是jwt

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

加密算法是单向函数散列算法,常见的有MD5、SHA、HAMC。

MD5(message-digest algorithm 5) (信息-摘要算法)缩写,广泛用于加密和解密技术,常用于文件校验。校验?不管文件多大,经过MD5后都能生成唯一的MD5值

SHA (Secure Hash Algorithm,安全散列算法),数字签名等密码学应用中重要的工具,安全性高于MD5

HMAC (Hash Message Authentication Code),散列消息鉴别码,基于密钥的Hash算法的认证协议。用公开函数和密钥产生一个固定长度的值作为认证标识,用这个标识鉴别消息的完整性。常用于接口签名验证

Payload

载荷就是存放有效信息的地方。

有效信息包含三个部分:

标准中注册的声明 (建议但不强制使用) :

公共的声明:

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

私有的声明:

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

Signature

jwt的第三部分是一个签证信息

这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串,然后通过header中声明的加密方式进行加盐secret组合加密,然后就构成了jwt的第三部分。最主要的目的:服务器应用在接受到JWT后,会首先对头部和载荷的内容用同一算法再次签名,如果服务器应用对头部和载荷再次以同样方法签名之后发现,自己计算出来的签名和接受到的签名不一样,那么就说明这个Token的内容被别人动过的,我们应该拒绝这个Token,返回一个HTTP 401 Unauthorized响应。

密钥secret是保存在服务端的,服务端会根据这个密钥进行生成token和进行验证,所以需要保护好。

这些信息在官网上也有相关信息的说明:

二,SpringBoot集成JWT具体实现过程

这里由于只涉及对验证功能的实现,因此其他数据库,业务类编写一概省略,只对相关步骤做说明。

2.1添加相关依赖

既然要使用JWT我们肯定需要引入其依赖

 <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.10.3</version>
        </dependency>

2.2自定义跳出拦截器的注解

方便我们后续不用对在配置拦截器时排除每一个接口,只用自定义注解去标记即可。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author young
 * @date 2022/11/24 14:53
 * @description: 自定义通过token注解,如果不加该注解直接拦截
 */
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface PassToken {
    boolean required() default true;
}

@Retention注解说明

2.3自定义全局统一返回值方法,异常类及相关枚举

定义全局枚举类

package com.yy.enums;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.Getter;
import java.util.UUID;

/**
 * @author young
 * @date 2022/8/19 21:36
 * @description: 响应结果枚举
 */

@AllArgsConstructor
@Getter
public enum ResponseEnum {
   /**响应成功**/
   SUCCESS(200, "操作成功"),
   /**操作失败*/
   FAIL(201,"获取数据失败"),
   
   NO_TOKEN(400,"无token,请重新登录"), 
   TOKEN_EX(401,"token验证失败,请重新登录"),
   
   USER_EX(402,"用户不存在,请重新登录"),
   
   /**错误请求**/
   ERROR(400,"错误请求");

   /**响应码**/
   private final Integer code;
   
   /** 结果 **/
   private  final String  resultMessage;
   

   public static ResponseEnum getResultCode(Integer code){
      for (ResponseEnum value : ResponseEnum.values()) {
         if (code.equals(value.getCode())){
            return value;
         }
      }
      return ResponseEnum.ERROR;
   }
/*
简单测试一下
 */
   public static void main(String[] args) {
      ResponseEnum resultCode = ResponseEnum.getResultCode(100);
      System.out.println(resultCode);
   }
}

定义全局异常类

package com.yy.util;

import com.yy.Enums.ResultEnum;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * @author young
 * @date 2022/9/25 19:15
 * @description: 自定义运行时异常
 */
@Data
@ApiModel(value = "自定义全局异常类")
public class MyException extends RuntimeException{
    @ApiModelProperty(value = "异常状态码")
    private final Integer code;

    /**
     * 通过状态码和异常信息创建异常对象
     * @param code
     * @param message
     */
    public MyException(Integer code,String message) {
        super(message);
        this.code = code;
    }

    /**
     * 接受枚举类型对象
     * @param resultEnum
     */
    public MyException(ResponseEnum responseEnum){
        super(responseEnum.getMessage());
        this.code = responseEnum.getCode();
    }
}
package com.yy.Config;

import com.yy.utils.MyException;
import com.yy.utils.R;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
/**
 * @author young
 * @date 2022/9/12 15:43
 * @description: 自定义异常配置
 */
@RestControllerAdvice
public class GlobalExceptionConfig{
    @ExceptionHandler(MyException.class)
    public R<MyException> handle(MyException e){
        e.printStackTrace();
        return R.exception(e.getCode(),e.getMessage());
    }
}

定义统一返回结果类

package com.yy.utils;
import com.yy.enums.ResponseEnum;
import lombok.Data;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

/**
 * @author young
 * @date 2022/8/19 21:52
 * @description: 统一返回结果的类
 */

@Data
public class  R<T> implements Serializable {
    
    private static final long serialVersionUID = 56665257248936049L;
    /**响应码**/
    private Integer code;

    /**返回消息**/
    private String message;

    /**返回数据**/
    private T data;

   private R(){}
    /**
     * 操作成功ok方法
     */
    public static <T> R<T> ok(T data) {
        R<T> response = new R<>();
     response.setCode(ResponseEnum.SUCCESS.getCode());   response.setMessage(ResponseEnum.SUCCESS.getResultMessage());
        response.setData(data);
        return response;
    }

    /**
     * 编译失败方法
     */
    public static <T> R<T> buildFailure(Integer errCode, String errMessage){
        R<T> response = new R<>();
        response.setCode(errCode);
        response.setMessage(errMessage);
        return response;
    }
    

    public static <T> R<T> exception(Integer errCode, String errMessage){
        R<T> response = new R<>();
        response.setCode(errCode);
        response.setMessage(errMessage);
        return response;
    }
}

2.4编写JWT工具类,用于生成Token令牌

package com.yy.utils;

import cn.hutool.core.date.DateUtil;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import java.util.Date;
/**
 * @author young
 * @date 2022/9/12 14:46
 * @description: 整合JWT生成token
 */
public class JwtTokenUtils {
    private JwtTokenUtils() {
        throw new IllegalStateException("Utility class");
    }
    /**
     * 生成token
     * @param userId
     * @param sign
     * @return
     */
    public static String getToken(String userId,String sign){
      return  JWT.create()
              //签收者
              .withAudience(userId)
              //主题
               .withSubject("token")
                //2小时候token过期
                .withExpiresAt(DateUtil.offsetHour(new Date(),2))
                //以password作为token的密钥
                .sign(Algorithm.HMAC256(sign));
    }
}

Algorithm.HMAC256():使用HS256生成token,密钥则是用户的密码,唯一密钥的话可以保存在服务端。

withAudience():存入需要保存在token的信息,这里我们把用户ID存入token中

2.5编写拦截器并注入容器

package com.yy.Config.inteceptor;

import cn.hutool.core.text.CharSequenceUtil;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.exceptions.JWTVerificationException;
import com.yy.enums.ResponseEnum;
import com.yy.admin.pojo.Admin;
import com.yy.admin.service.Impl.AdminServiceImpl;
import com.yy.utils.MyException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;

/**
 * @author young
 * @date 2022/9/12 15:37
 * @description: 获取token并验证
 */
@Component
public class MyJwtInterceptor implements HandlerInterceptor {
    @Autowired
    private AdminServiceImpl adminService;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String token = request.getHeader("token");
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();
        //检查是否通过有PassToken注解
        if (method.isAnnotationPresent(PassToken.class)) {
            //如果有则跳过认证检查
            PassToken passToken = method.getAnnotation(PassToken.class);
            if (passToken.required()) {
                return true;
            }
        }
        //否则进行token检查
        if (CharSequenceUtil.isBlank(token)) {
            throw new MyException(ResponseEnum.TOKEN_EX.getCode(), ResponseEnum.TOKEN_EX.getResultMessage());
        }
        //获取token中的用户id
        String userId;
        try {
            userId = JWT.decode(token).getAudience().get(0);
        } catch (JWTDecodeException j) {
            throw new MyException(ResponseEnum.TOKEN_EX.getCode(), ResponseEnum.TOKEN_EX.getResultMessage());
        }
        //根据token中的userId查询数据库
        Admin user = adminService.getById(userId);
        if (user == null) {
            throw new MyException(ResponseEnum.USER_EX.getCode(), ResponseEnum.USER_EX.getResultMessage());
        }

        //验证token
        JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(user.getPwd())).build();
        try {
            jwtVerifier.verify(token);
        } catch (JWTVerificationException e) {
            throw new MyException(406, "权限验证失败!");
        }
        return true;
    }
}

这里需要说明一下实现拦截器的方法,我们只需要实现HandlerInterceptor接口即可,它主要定义了三个方法:

boolean preHandle ()

预处理回调方法,实现处理器的预处理,第三个参数为响应的处理器,自定义Controller,返回值为true表示继续流程(如调用下一个拦截器或处理器)或者接着执行postHandle()和afterCompletion();false表示流程中断,不会继续调用其他的拦截器或处理器,中断执行。

void postHandle()

后处理回调方法,实现处理器的后处理(DispatcherServlet进行视图返回渲染之前进行调用),此时我们可以通过modelAndView(模型和视图对象)对模型数据进行处理或对视图进行处理,modelAndView也可能为null。

void afterCompletion():

整个请求处理完毕回调方法,该方法也是需要当前对应的Interceptor的preHandle()的返回值为true时才会执行,也就是在DispatcherServlet渲染了对应的视图之后执行。用于进行资源清理。

整个请求处理完毕回调方法。如性能监控中我们可以在此记录结束时间并输出消耗时间,还可以进行一些资源清理,类似于try-catch-finally中的finally,但仅调用处理器执行链中。

这里我们主要需要调用预处理回调方法即可,如果有其他业务需求,也可自行更改。

主要流程:

然后通过配置类将我们自定义的拦截类注入到spring容器中,并进行拦截配置。

package com.yy.Config.inteceptor;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @author young
 * @date 2022/9/12 15:36
 * @description: JWT拦截配置
 */
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(jwtInterceptor())
 //拦截所有请求,通过判断token来决定是否需要登陆
                .addPathPatterns("/**");
    }

    @Bean
    public MyJwtInterceptor jwtInterceptor(){
        return new MyJwtInterceptor();
    }
}

至此,我们对于JWT在SpringBoot中的基本配置就算完成了。我们只需在controller层在自己想要放行的api接口上添加我们自定义的放行注解,即可实现对api接口的放行,其他接口均要进行Token令牌的验证判断。如果没有Token则返回自定义的异常信息。

三,测试

3.1放行一般类接口

这里我们先只对一个业务接口进行放行。

/**
     * 查找指定id信息
     *
     * @param id
     * @return
     */
    @GetMapping("/getOne/{id}")
    @CostTime
    @PassToken
    public R<TestUser> selectOne(@PathVariable Integer id) {
        TestUser user = testUserService.getById(id);
        return R.ok(user);
    }

进行接口测试后发现,该接口获取数据正常。

 其他没有加@PassToken的接口由于没有token进行验证,均会被拦截器拦截,并返回我们预期的异常信息"token验证失败,请重新登录"

因此,同理我们只需要在登陆注册或其他不需要token验证的接口上添加自定义注解即可实现拦截。

为了达到业务需求,我们需要在用户登录成功后获取到token,然后将token信息存放在每次的接口请求头(headers)上,这样就能实现对用户接口信息基本保护了。

3.2放行登录接口

在业务层处理token,将生成的token信息带到用户实体类中,这样登录获取用户信息时就能读取到token信息了

package com.yy.admin.service.Impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yy.admin.pojo.Admin;
import com.yy.admin.service.AdminService;
import com.yy.admin.dao.AdminDao;
import com.yy.utils.JwtTokenUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Optional;

/**
* @author young
* @description 针对表【admin】的数据库操作Service实现
* @createDate 2022-09-05 13:41:54
*/
@Service
@Slf4j
public class AdminServiceImpl extends ServiceImpl<AdminDao, Admin>
    implements AdminService{
  @Resource
  private AdminDao adminDao;

    @Override
    public Admin getMsg(String username, String pwd){
         Admin admin = adminDao.selectByUsernameAndPwd(username, pwd);
         Optional.ofNullable(admin).ifPresent(u->{
             //添加token信息设置到用户实体上
             String token = JwtTokenUtils.getToken(String.valueOf(admin.getId()),pwd);
             log.info("token的值为:{}",token);
             admin.setToken(token);
         });
         return admin;
     }
}




编写用户登录的业务接口并放行Token

@PostMapping("/login")
    @PassToken
    public Object loginStatus(@RequestParam("username") String username, @RequestParam("password") String password){
        JSONObject object = new JSONObject();
        Admin admin = adminService.getMsg(username, password);
        if (admin!=null){
            object.put("code",1);
            object.put("msg","登陆成功");
            object.put("success",true);
            object.put("type","success");
            object.put("userMsg",admin);
        }else {
            object.put("code",0);
            object.put("success",false);
            object.put("msg","用户名或密码错误");
            object.put("type","error");
        }
        return object;
    }

进行接口测试

 这样就可以看到生成的Token信息了,然后我们将token信息设置在请求头上对其他接口进行测试。

此时就能看到,接口请求成功。

注意:这里的参数名token对应拦截器配置String token=request.getHeader("token")中的getHeader中设置的的参数名。

到此这篇关于SpringBoot集成JWT实现Token登录验证的示例代码的文章就介绍到这了,更多相关SpringBoot JWT Token登录验证内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:
阅读全文