关于token身份验证的集成

最近项目遇到了跨域的问题，选择整合token来解决这个问题。

整合思路：

1. 用户发出登录请求，带着用户名和密码到服务器经行验证，服务器验证成功就在后台生成一个token返回给客户端
2. 客户端将token存储到cookie或者（localStorage和sessionStorage）中，服务端将token存储到redis中，可以设置存储token的有效期。
3. 后续客户端的每次请求资源都必须携带token，这里放在请求头中，服务端接收到请求首先校验是否携带token，以及token是否和redis中的匹配，若不存在或不匹配直接拦截返回错误信息（如未认证）。
4. token中可以自行存放一些用户的身份信息。

首先在pom.xml中加入依赖

<!-- token -->
 <dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.4.0</version>
</dependency>

生成token的类,直接复制粘贴就可以。

package com.xxxx.xxxx.xxxx;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class TokenUse{
    //过期时间24小时
    private static final long overdeuTime=1440*60*1000;
    //私钥uuid生成，确定唯一性
   public static final String  tokenSecRet="fde35b32-0f47-46be-ae2a-49bcb7ed7d7f";
    /**
     * 生成token，用户退出后消失
     * @param userCode
     * @param userId
     * @return
     */
    public static String sign(String userCode,String userId){
        try {
            //设置过期时间
            Date date=new Date(System.currentTimeMillis()+overdeuTime);
            //token私钥加密
            Algorithm algorithm=Algorithm.HMAC256(tokenSecRet);
            //设置头部信息
            Map<String,Object> requestHender=new HashMap<String,Object>(2);
            requestHender.put("type","JWT");
            requestHender.put("encryption","HS256");
            long date1=new Date().getTime();
 
            //返回带有用户信息的签名
            return JWT.create().withHeader(requestHender)
                    .withClaim("userCode",userCode)
                    .withClaim("userId",userId)
                    .withClaim("Time",date1)
                    .withExpiresAt(date)
                    .sign(algorithm);
        } catch (Exception e) {
            return null;
        }
    }
 
    /**
     * 验证token是否正确
     * @param token
     * @return
     */
    public static  boolean tokenVerify(String token){
        try {
            Algorithm algorithm=Algorithm.HMAC256(tokenSecRet);
            JWTVerifier verifier=JWT.require(algorithm).build();
            //验证
            DecodedJWT decodedJWT=verifier.verify(token);
            return true;
        }catch (Exception e){
            return false;
        }
    }
 
    /**
     * 获取登陆用户token中的用户ID
     * @param token
     * @return
     */
    public static String getUserID(String token){
        DecodedJWT decodedJWT=JWT.decode(token);
        return decodedJWT.getClaim("userId").asString();
    }
    /**
     * 获取登陆用户token中的用户名称
     * @param token
     * @return
     */
    public static String getUserName(String token){
        DecodedJWT decodedJWT=JWT.decode(token);
        return decodedJWT.getClaim("userCode").asString();
    }
}
 

登陆时获取token的方法

TokenUse.sign(user.getAccount(), user.getUserid());

                         用户名称                 用户ID

登录成功时将token发送给前端进行保存，前端每次调用接口都需要请求头携带token，后端进行统一拦截认证身份。

【拦截器逻辑】

package com.xxxx.xxxx.interceptor;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.util.StringUtils;

import com.xxxx.xxxx.xxxx.TokenUse;

/**
* @author 作者xxl:
* @version 创建时间：2019年12月30日 下午13:59:01
* 类说明
*/
public class TokenInterceptor implements Filter{
	
	private String defaultPage="page/login.jsp"; 

	@Override
	public void destroy() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
			throws IOException, ServletException {
		// TODO Auto-generated method stub
		
		    HttpServletRequest request=(HttpServletRequest)req;
		    HttpServletResponse response=(HttpServletResponse)resp;
		    String requestURI = request.getRequestURI();
		
			String token = request.getHeader("access_token");
			
			
			if(StringUtils.isEmpty(token)){
					System.out.println("token 为空");
			} else {
				//todo  校验
			boolean isvalid =               
         TokenUse.tokenVerify((String)request.getSession().getAttribute("access_token"));
			if (isvalid) {//如果token正确则放行
				chain.doFilter(req, resp);
			} else {//不正确则跳转至登录页面
				response.sendRedirect(defaultPage);
			}			
	        }

	@Override
	public void init(FilterConfig config) throws ServletException {
		// TODO Auto-generated method stub
	}
}

通俗一点就是拦截所有请求后台的接口，然后获取token，判断token是否正确。

至此初步的登录验证token的整合就完成辣，后续还要根据项目实际情况做相应改动。