JWT实现登录校验

为什么会使用JWT


因为客户要求尽快上线,项目临时抽调人员来整项目。一开始只关注数据方面的问题,并没有考虑到登录校验,加上当时这个项目只为了一个客户提供所以没有考虑登录校验的问题。随着时间的推进,客户变得更多了,这时候突然就需要登录校验了。 PS(其实一开始就需要登录校验的只不过大佬说话菜鸡不敢插嘴)

什么是JWT


官方文档是这样解释的: JSON Web Token(JWT)是一个开放标准(RFC 7519),它定义了一种紧凑且独立的方式,可以在各方之间作为JSON对象安全地传输信息。此信息可以通过数字签名进行验证和信任。JWT可以使用秘密(使用HMAC算法)或使用RSA或ECDSA的公钥/私钥对进行签名。
虽然 JWT可以加密以在各方之间提供保密,但只将专注于签名令牌。签名令牌可以验证其中包含的声明的完整性,而加密令牌则隐藏其他方的声明。当使用公钥/私钥对签署令牌时,签名还证明只有持有私钥的一方是签署私钥的一方。

JWT的结构


JWT由三部分组成,分别是头信息、有效载荷、签名,中间以(.)分隔,格式 : header.Payload.Signature

1. header(头信息)
由两部分组成,令牌类型(即:JWT)、散列算法(HMAC、RSASSA、RSASSA-PSS等)

2. Payload(有效载荷)
JWT的第二部分是payload,其中包含claims。claims是关于实体(常用的是用户信息)和其他数据的声明,claims有三种类型: registered, public, and private claims。
Registered claims: 这些是一组预定义的claims,非强制性的,但是推荐使用, iss(发行人), exp(到期时间), sub(主题), aud(观众)等;
Public claims: 自定义claims,注意不要和JWT注册表中属性冲突,这里可以查看JWT注册表
Private claims: 这些是自定义的claims,用于在同意使用这些claims的各方之间共享信息,它们既不是Registered claims,也不是Public claims。

这里需要注意的是不要将敏感信息存放在此,如果非要存放最好是加密,以此保证安全

3.Signature(签名)
要创建签名部分,必须采用编码的Header,编码的Payload,秘钥,Header中指定的算法,并对其进行签名。
签名用于验证消息在此过程中未被篡改,并且,在使用私钥签名令牌的情况下,它还可以验证JWT的请求方是否是它所声明的请求方。

项目中实际使用


JWT的工具类 JwtUtil 创建JWT 验证是否Token是否合法
import com.nimbusds.jose.*;
import com.nimbusds.jose.crypto.MACSigner;
import com.nimbusds.jose.crypto.MACVerifier;
import lombok.extern.slf4j.Slf4j;
import net.minidev.json.JSONObject;
import java.text.ParseException;
import java.util.HashMap;
import java.util.Map;
@Slf4j
public class JwtUtil {
  private static final byte[] SECRET = "这里写上你要签名的信息".getBytes();
  //下方是JWT的头部信息
  private static final JWSHeader JWTHEADER = new JWSHeader(JWSAlgorithm.HS256, JOSEObjectType.JWT, 
             null, null, null, null, null, null, null, null, null, null, null);
  // 下方是创建JWT的方法,传入payload,并合并header.payload.signature
  public static String createToken(Map<String, Object> payload){
    String tokenString = null;
    JWSObject jwsObject = new JWSObject(JWTHEADER, new Payload(new JSONObject(payload)));
    try {
      jwsObject.sign(new MACSigner(SECRET));
      tokenString = jwsObject.serialize();
    } catch (JOSEException e) {
      e.printStackTrace();
    }
    return tokenString;
  }
  //这里是请求到达后台时的验证方法
  public static Map<String, Object> validToken(String token){
    Map<String, Object> resultMap = new HashMap<>();
    try {
      JWSObject jwsObject = JWSObject.parse(token);
      Payload payload = jwsObject.getPayload();
      JWSVerifier verifier = new MACVerifier(SECRET);
      //这一步判断签名是否正确,如果不正确则返回非法登录
      if (jwsObject.verify(verifier)) {
        //将payload取出,转化为JSONObject方便取过期时间
        JSONObject jsonObject = new JSONObject(payload.toJSONObject());
        resultMap.put("state", TokenState.VALID.toString());
        if (jsonObject.containsKey("ext")) {
          long extTime = Long.parseLong(jsonObject.get("ext").toString());
          long curTime = System.currentTimeMillis();
          if (curTime > extTime){
            resultMap.clear();
            resultMap.put("state", TokenState.EXPIRED.toString());
          }
        }
        //resultMap.put("data", jsonObject);
      } else {
        resultMap.put("state", TokenState.INVALID.toString());
      }
    } catch (JOSEException | ParseException e) {
      resultMap.put("state", TokenState.INVALID.toString());
      e.printStackTrace();
    }
    return resultMap;
  }
}
生成payload方法
private String createPayload(String username) {
  Map<String, Object> payload = new HashMap<>();
  Date date = new Date();
  payload.put("uid", username);
  payload.put("iat", date.getTime());
  payload.put("ext", date.getTime() + 1000 * 60 * 60 * 24); // 1000*60*30
 return JwtUtil.createToken(payload);
}
请求预处理类 JwtInterceptor
import org.springframework.beans.factory.annotation.Autowired;
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;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Map;
import java.util.Objects;
import static org.apache.commons.lang3.StringUtils.isNotEmpty;
@Component
public class JwtInterceptor implements HandlerInterceptor {
  
  //这里做一个输出工作
  private void output(User user, HttpServletResponse response) throws IOException {
    response.setContentType("text/html;charset=UTF-8;");
    PrintWriter out = response.getWriter();
    try {
      out.write(Objects.requireNonNull(JsonUtils.objectToJsonStr(user)));
    } catch (Exception e) {
      e.printStackTrace();
    }
    out.flush();
    out.close();
  }
  @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
      throws Exception {
    //如果是OPTIONS请求一律放行
    if (request.getMethod().equalsIgnoreCase("OPTIONS")) {
      return true;
    }
    User user = new User();
    //前端将token放在自定义请求头中
    String token = request.getHeader("X-Auth-Token");
    if (token != null) {
      //调用上面JWTUtil工具类中的验证方法
      Map<String, Object> resultMap = JwtUtil.validToken(token);
      TokenState state = TokenState.getTokenState((String) resultMap.get("state"));
      switch (state) {
        case VALID:
          //request.setAttribute("data", resultMap.get("data"));
          user.setWorking(true);
          return true;
        case EXPIRED:
          user.setToken("Token fails");
          user.setWorking(false);
          output(user, response);
          break;
        case INVALID:
          user.setToken("Token is illegal");
          user.setWorking(false);
          output(user, response);
          break;
        default:
          break;
      }
    } else {
      user.setToken("There is no token in your request header");
      user.setWorking(false);
      output(user, response);
    }
    return false;
  }
  
  @Override
 public void postHandle(
      HttpServletRequest httpServletRequest,
      HttpServletResponse httpServletResponse,
      Object o,
      ModelAndView modelAndView) {
  }
  @Override
 public void afterCompletion(
      HttpServletRequest httpServletRequest,
      HttpServletResponse httpServletResponse,
      Object o,
      Exception e) {
  }
}
状态的枚举类 TokenState
public enum TokenState {
  EXPIRED("EXPIRED"),
  INVALID("INVALID"),
  VALID("VALID");
  private String state;
  TokenState(String state){
    this.state = state;
  }
  public static TokenState getTokenState(String tokenState){
    TokenState[] values = TokenState.values();
    TokenState ts = null;
    for (TokenState value : values) {
      if (value.state.equals(tokenState)){
        ts = value;
        break;
      }
    }
    return ts;
  }
  @Override
 public String toString() {
    return this.state;
  }
}
定义拦截规则的类

CORS_ALLOW_ORIGINS: http://localhost:8080
CORS_ALLOW_METHOD: OPTIONS,GET,POST,DELETE,PUT

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.format.FormatterRegistry;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.validation.MessageCodesResolver;
import org.springframework.validation.Validator;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.config.annotation.*;
import java.util.List;
@Configuration
public class InterceptorConfiguration implements WebMvcConfigurer {
  @Autowired private JwtInterceptor jwtInterceptor;
  @Value("${CORS_ALLOW_ORIGINS}")
  private String corsOrigins;
  @Value("${CORS_ALLOW_METHOD}")
  private String corsMethod;
  
  /* 这里是解决跨域问题
   * addMapping() 设置拦截的路径
   * allowedOrigins() 设置跨域的域名
   * allowCredentials() 如果你想携带cookie那就加上  不需要就不用这句
   * allowedMethods() 设置支持什么类型的请求跨域
   * allowedHeaders() 自定义请求头
  */
  @Override
 public void addCorsMappings(CorsRegistry registry) {
    registry
        .addMapping("/**")
        .allowedOrigins(corsOrigins)
        .allowCredentials(true)
        .allowedMethods(corsMethod)
        .maxAge(3600)
        .allowedHeaders("X-Auth-Token");
  }
  @Override
 public void addInterceptors(InterceptorRegistry registry) {
    /* 注册拦截器并定义拦截规则  如果想放行某一条api
    * 或者拦截某条api 则把路径写全即可
    */
    registry
        .addInterceptor(jwtInterceptor)
        .addPathPatterns("/controller里的api/**")
        .excludePathPatterns("/controller里的api/**");
  }
  @Override
 public void configurePathMatch(PathMatchConfigurer pathMatchConfigurer) {}
  @Override
 public void configureContentNegotiation(
      ContentNegotiationConfigurer contentNegotiationConfigurer) {}
  @Override
 public void configureAsyncSupport(AsyncSupportConfigurer asyncSupportConfigurer) {}
  @Override
 public void configureDefaultServletHandling(
      DefaultServletHandlerConfigurer defaultServletHandlerConfigurer) {}
  @Override
 public void addFormatters(FormatterRegistry formatterRegistry) {}
  @Override
 public void addResourceHandlers(ResourceHandlerRegistry resourceHandlerRegistry) {}
  @Override
 public void addViewControllers(ViewControllerRegistry viewControllerRegistry) {}
  @Override
 public void configureViewResolvers(ViewResolverRegistry viewResolverRegistry) {}
  @Override
 public void addArgumentResolvers(List<HandlerMethodArgumentResolver> list) {}
  @Override
 public void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> list) {}
  @Override
 public void configureMessageConverters(List<HttpMessageConverter<?>> list) {}
  @Override
 public void extendMessageConverters(List<HttpMessageConverter<?>> list) {}
  @Override
 public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> list) {}
  @Override
 public void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> list) {}
  @Override
 public Validator getValidator() {
    return null;
  }
  @Override
 public MessageCodesResolver getMessageCodesResolver() {
    return null;
  }
}
以上就是JWT的全部内容了 实测可用 菜鸟一个 如有问题欢迎指正

评论

暂无评论