SpringBoot 整合 JWT 实现登录和拦截

深藏阁楼爱情的钟 2022-10-04 14:57 206阅读 0赞

**前言：**

用户登录的功能就是需要服务提供者知道调用者是一个合法用户，非法用户不给予服务。SpringBoot + JWT（Json web token）是目前比较成熟的方案，整体逻辑如下：

1. 服务提供者对所有调用（部分接口除外，例如登录接口）都进行拦截认证，只有认证通过才提供服务

2. 用户通过登录获取认证信息

3. 用户携带认证信息调用服务即可通过拦截认证获取服务

## 一、版本和工具 ##

1. SpringBoot：2.3.2.RELEASE

2. JDK：1.8\_251

3. JWT依赖：

## 二、用户的基本信息 ##

用户结构体一般信息不少，这里为了简化就写两个核心字段：

public class User {
        private String userName;
        private String password;
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    }

## 三、认证和登录服务 ##

认证服务使用 java-jwt 包的一些方法：

import com.auth0.jwt.JWT;
    import com.auth0.jwt.JWTVerifier;
    import com.auth0.jwt.algorithms.Algorithm;
    import com.auth0.jwt.exceptions.JWTVerificationException;
    import com.auth0.jwt.interfaces.DecodedJWT;
    
    import java.util.Date;
    import java.util.HashMap;
    
    public class JwtTokenUtils {
    
        private static final int EXPIRE_TIME = 5 * 60 * 1000;  // 过期时间5分钟
        private static final String SECRET_KEY = "123"; // 加密的密钥
    
        public static String sign(User user) {
            Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
            HashMap<String, Object> head = new HashMap<String, Object>() {
                {
                    put("typ", "JWT");
                    put("alg", "HS256");
                }
            }; // 这块是 JWT 认证的一些声明信息
            Algorithm algorithm = Algorithm.HMAC256(SECRET_KEY);
            return JWT.create()
                    .withHeader(head)
                    .withClaim("username", user.getUserName())  // 把用户名整合到 token 里加密
                    .withClaim("password", user.getPassword())  // 把用密码整合到 token 里加密，其实密码没必要
                    .withExpiresAt(date).sign(algorithm);
        }
    
        public static boolean verity(String token) {
            try {
                Algorithm algorithm = Algorithm.HMAC256(SECRET_KEY);
                JWTVerifier verifier = JWT.require(algorithm).build();
                DecodedJWT jwt = verifier.verify(token);
                System.out.println("调用 username:" + jwt.getClaim("username"));  // 整合到 token 里加密的信息都是可以取出来的
                return true;
            } catch (IllegalArgumentException | JWTVerificationException e) {
                return false;
            }
        }
    
    }

登录服务，这里把token直接刷到响应头里面：

import org.springframework.stereotype.Service;
    
    import javax.servlet.http.HttpServletResponse;
    
    @Service
    public class LoginService {
    
    
        public String login(HttpServletResponse response, User user) {
    
            // 对账号和密码进行验证，一般是和数据库的数据对比，这里简化
            if (!user.getUserName().equals("admin")) return "账号错误";
            if (!user.getPassword().equals("admin")) return "密码错误";
    
            String token = JwtTokenUtils.sign(user);
            response.setHeader("token", token);
            return "登录成功";
        }
    
    }

## 四、拦截器 ##

拦截器的作用就是拦截调用：

import com.test.login.JwtTokenUtils;
    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;
    
    @Component
    public class AuthHandlerInterceptor implements HandlerInterceptor {
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            System.out.println("进入拦截器.......");
            String token = request.getHeader("token");
            if (null == token) {
                System.out.println("缺少认证信息");
                return false;  // 这里一般都是抛出自定义异常给全局异常处理，这里为了简化不做扩展说明
            }
            System.out.println("header token:" + token);
            boolean auth = JwtTokenUtils.verity(token);
            System.out.println("认证结果:" + auth);
            return auth;
        }
    
        @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 {
    
        }
    }

注册拦截器，并配置排除登录接口：

**注意：不要继承 WebMvcConfigurationSupport ，springboot 2.x 后会导致配置失效**

import com.test.filter.login.AuthHandlerInterceptor;
    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.WebMvcConfigurationSupport;
    
    @Configuration
    public class WebAppConfig implements WebMvcConfigurer{
    
        @Autowired
        AuthHandlerInterceptor authHandlerInterceptor;
    
        @Override
        protected void addInterceptors(InterceptorRegistry registry) {
            registry.addInterceptor(authHandlerInterceptor)
                    .excludePathPatterns("/client/login"); // 排除登录接口
        }
    }

## 五、登录接口和测试调用接口 ##

登录接口和测试调用接口如下：

import com.test.login.LoginService;
    import com.test.login.User;
    import com.test.result.Data;
    import com.test.result.ResultBean;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.servlet.http.HttpServletResponse;
    
    @RestController
    @RequestMapping("/client")
    public class ControllerTest {
    
        @Autowired
        private LoginService loginService;
    
        @GetMapping("/login")
        public String login(
                HttpServletResponse response,
                @RequestParam(value = "username") String userName,
                @RequestParam(value = "password") String password
        ) {
            System.out.println("进入登录接口.....");
            User user = new User();
            user.setUserName(userName);
            user.setPassword(password);
            String loginResult = loginService.login(response, user);
            System.out.println("登录服务结果：" + loginResult);
            return loginResult;
        }
    
        @GetMapping("/test")
        public String name() {
            return "this is from client-1";
        }
    
    }

## 六、测试 ##

测试步骤：

1. 在浏览器调用 /client/test 接口，日志如下：

![20210715141404948.png][]

此时拦截器对调用拦截有效；

2. 在浏览器调用 /client/login?password=admin&username=admin 接口，日志如下：

![20210715141514283.png][]

浏览器响应头有 token 信息

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpbmdxdWFueWluZ3l1ZQ_size_16_color_FFFFFF_t_70][]

3. 把 token 信息取出来放到请求头里面再次请求  /client/test，日志如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpbmdxdWFueWluZ3l1ZQ_size_16_color_FFFFFF_t_70 1][]

浏览器响应如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpbmdxdWFueWluZ3l1ZQ_size_16_color_FFFFFF_t_70 2][]

此时拦截器认证通过，并成功调用接口。

4. 登录验证成功

## 七、一定要看 ##

上面的登录比较简单，大体理清楚了逻辑，实际使用还需要加一些额外的操作：

1. 常规的登录/注销都需要借助 redis，登录的时候把用户信息和 token 写到 redis 并设置过期时间，拦截器会优先去查询 redis 是否有对应的 token，注销的时候直接把 redis 记录删除就行了。

2. 上面样例 token 有效期5分钟，用户连续操作时需要一个 token 续期方案（网上有）；用户登录后一段时间不操作要有自动注销功能。

3. 其实大部分用的 token 是 bearer token，这是一种规范，可以参考 [HTTP authentication - HTTP | MDN (mozilla.org)][HTTP authentication - HTTP _ MDN _mozilla.org]，可以理解是约定的格式，请求头格式如下：Authorization: Bearer <JWT token>

[20210715141404948.png]: /images/20221004/bc418a1fc57d4072a7fbffb6672483d3.png
[20210715141514283.png]: /images/20221004/2e7c0e86a1764b30b0e143b131431259.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpbmdxdWFueWluZ3l1ZQ_size_16_color_FFFFFF_t_70]: /images/20221004/1d557ae0977a417580c8a41da184eb1b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpbmdxdWFueWluZ3l1ZQ_size_16_color_FFFFFF_t_70 1]: /images/20221004/ff2e9fd5a93d4235a9fc8a5b4842d1e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpbmdxdWFueWluZ3l1ZQ_size_16_color_FFFFFF_t_70 2]: /images/20221004/79250112730b4c32bccc5aebf373ee89.png
[HTTP authentication - HTTP _ MDN _mozilla.org]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication#authentication_schemes