springboot使用jwt进行权限验证

springboot使用jwt进行权限验证

依赖准备

首先导入对应的依赖

<dependencies>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.0</version>
    </dependency>
    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
    </dependency>
        <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-core</artifactId>
    </dependency>
</dependencies>

这里需要用到一些工具类来方便我们进行操作

工具类中默认的数据封装对应的user只有两个属性，即用户名、密码，一般也不需要进行修改。

属性配置

对于信息的加密解密，我们需要有公钥和私钥，在application.yml中我们需要定义配置信息。

tens:
  jwt:
    secret: leyou@Login(Auth}*^31)&heiMa%
    pubKeyPath: G:\\tensquare\\rsa\\rsa.pub
    priKeyPath: G:\\tensquare\\rsa\\rsa.pri
    expire: 30
    cookieName: TQ_TOKEN
    cookieMaxAge: 30

注意格式，以及目录不要使用中文路径，还有在IDEA的编码属性没设置好的话不要使用中文注解，不然都会报错！

接下来自然是在属性类中加载这些数据了

@ConfigurationProperties(prefix = "tens.jwt")
public class JwtProperties {
    private String secret;
    private String pubkeyPath;
    private String prikeyPath;
    private int expire;
    private PublicKey publicKey;
    private PrivateKey privateKey;
    private String cookieName;
    private Integer cookieMaxAge;
    private static final Logger logger = LoggerFactory.getLogger(JwtProperties.class);
    /**
     * @PostContruct: 在构造方法执行后执行该方法
     */
    @PostConstruct
    public void init(){
        try{
            File pubkey  = new File(pubkeyPath);
            File prikey = new File(prikeyPath);
            if(!pubkey.exists() || !prikey.exists()){
                //如果没有密钥文件的话，就生成公钥和私钥
                RsaUtils.generateKey(pubkeyPath,prikeyPath,secret);
            }
            //获取公钥私钥
            this.publicKey = RsaUtils.getPublicKey(pubkeyPath);
            this.privateKey = RsaUtils.getPrivateKey(prikeyPath);
        }catch (Exception e){
            logger.error("初始化公钥私钥失败！",e);
            throw new RuntimeException();
        }
    }
}

这里省略了getter、setter，记得要写，不然数据加载会出错。还有配置文件的前缀要写对。这里并没有使用@Compenent这种方式将配置类加载到spring容器里去。而是选择了在需要使用配置类的地方加上@EnableConfigurationProperties({JwtProperties.class})注解。

登录验证

接下来我们就可以将登陆方法修改成先进行数据库验证，如果验证成功就利用jwt来生成对应的token以及公钥密钥，再将token放入cookie，这样用户进行其他操作的时候我们就可以进行状态以及权限判断了。

AuthController下的登录验证方法

@PostMapping("accredit")
    public Result authentication(@RequestParam("username")String username,
                                 @RequestParam("password")String password,
                                 HttpServletRequest request, HttpServletResponse response){
        //首先进行登录验证,即先判断账号密码是否正确，不正确的话直接返回失败信息，正确的话就把token写入cookie
        String token = this.authService.authentication(username,password);
        System.out.println(prop);
        if(StringUtils.isBlank(token)){//即用户名或者密码错误，没有成功获取token
            return new Result(false, StatusCode.ERROR,"登录失败");
        }
        //将token写入cookie，并指定HttpOnly为true，防止前端通过js进行修改
        CookieUtils.setCookie(request,response,prop.getCookieName(),token,prop.getCookieMaxAge(),null,true);
        return new Result(true,StatusCode.OK,"登录验证成功");
    }

接下来就该写验证的service了。

AuthService

@Service
public class AuthService {
    @Autowired
    private UserDao userDao;
    @Autowired
    private JwtProperties properties;
    public String authentication(String username, String password) {
        try{
            UserInfo userInfo = new UserInfo();
            userInfo.setUsername(username);
            userInfo.setPassword(password);
            UserInfo user = this.userDao.selectOne(userInfo);
            if (user ==null){
                return null;
            }
            String token = JwtUtils.generateToken(new UserInfo(user.getId(),user.getUsername()),
                    properties.getPrivateKey(), properties.getExpire());
            return token;
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

这便是从登陆验证到生成token的过程了。初次登录后在token有效的时间内，我们都不是直接接收前端传来的username、password来判断用户了，而是直接获取token来检验，当然，token不一定非要放在cookie里，前端也可以每次请求的时候把token传过来。

那么这里就需要一个检验用户的接口，用以将token转化为用户信息。

用户检验

用户检验接口

    /**
     * 验证用户信息
     * @param token
     * @return
     */
    @GetMapping("verify")
    public Result verifyUser(@CookieValue("LY_TOKEN")String token){
        try {
            // 从token中解析token信息
            UserInfo userInfo = JwtUtils.getInfoFromToken(token, this.prop.getPublicKey());
            // 解析成功返回用户信息
            return new Result(true,StatusCode.OK,"",userInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 出现异常则，响应错误
        return new Result(false,StatusCode.ERROR,"");
    }

刷新token

配置文件中写的token有效时间是30分钟，但是用户有可能一直在线，因此应该加上刷新token的机制，即再某个节点又重新覆盖一遍token。

前端对很多地方的操作都需要获取用户信息，因此我们在用户检验接口那里增加一个刷新操作。

    /**
     * 验证用户信息
     * @param token
     * @return
     */
    @GetMapping("verify")
    public Result verifyUser(@CookieValue("LY_TOKEN")String token,HttpServletRequest request, HttpServletResponse response){
        try {
            // 从token中解析token信息
            UserInfo userInfo = JwtUtils.getInfoFromToken(token, this.prop.getPublicKey());
            // 解析成功要重新刷新token
            token = JwtUtils.generateToken(userInfo, this.prop.getPrivateKey(), this.prop.getExpire());
            // 更新cookie中的token
            CookieUtils.setCookie(request, response, this.prop.getCookieName(), token, this.prop.getCookieMaxAge());
            // 解析成功返回用户信息
            return new Result(true,StatusCode.OK,"",userInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 出现异常则，响应错误
        return new Result(false,StatusCode.ERROR,"");
    }

很多时候我们从token中获取用户信息只是前端的请求中的一部分需求，因此上述逻辑感觉封装在一个service里面的用处更大。

利用拦截器进行权限检验

很多时候我们不会专门去对每一个请求接口都加上这么一个用户信息检验这样的逻辑，那么这里我们就需要配置一个拦截器来对请求进行拦截。通过判断token来判断该请求是否是在登录状态发起的，如果不是登录状态，那就转发到登录界面让其登录。

拦截器：

通过实现springmvc的HandlerInterceptor接口来声明一个拦截器

@EnableConfigurationProperties(JwtProperties.class)
public class LoginInterceptor implements HandlerInterceptor {
    @Autowired
    private JwtProperties properties;
    @Override
    public boolean preHandle (HttpServletRequest request, HttpServletResponse response, Object handle) throws IOException {
        String token = CookieUtils.getCookieValue(request, properties.getCookieName());
        // 校验
        try {
            // 校验通过什么都不做，即放行
            JwtUtils.getInfoFromToken(token, this.properties.getPublicKey());
        } catch (Exception e) {
            // 校验出现异常，返回403
            response.sendRedirect("/auth/accredit");
            return false;
        }
        return true;
    }
    /**
     * 在请求被处理后，视图渲染之前调用
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    }
    /**
     * 在整个请求结束后调用
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    }
}

注意照理来说我们就应该在这里加上一个@Component注解才对，这样在springmvc的配置类那里我们也可以直接调用来注册，但是现实告诉我那样会报错，会导致我们的资源文件JwtProperties加载不到我们在yml中的数据，然而controller中的数据依旧是能读取到的。

注册拦截器以及声明白名单：

先来了解一下WebMvcConfigurer这个接口

WebMvcConfigurer配置类其实是Spring内部的一种配置方式
采用JavaBean的形式来代替传统的xml配置文件形式进行针对框架个性化定制
基于java-based方式的spring mvc配置
需要创建一个配置类并实现WebMvcConfigurer 接口。

作用就和我们之前在xml中注册声明ssm的各项基本参数一样

@Configuration
public class LoginConfiguration implements WebMvcConfigurer {

    @Bean
    public LoginInterceptor loginInterceptor(){
        return new LoginInterceptor();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry){
        // 注册拦截器
        InterceptorRegistration loginRegistry = registry.addInterceptor(loginInterceptor());
        // 拦截路径
        loginRegistry.addPathPatterns("/**");
        // 排除路径
        loginRegistry.excludePathPatterns("/");
        loginRegistry.excludePathPatterns("/auth/accredit");
        /*loginRegistry.excludePathPatterns("/loginout");*/
        // 排除资源请求
        loginRegistry.excludePathPatterns("/css/login/*.css");
        loginRegistry.excludePathPatterns("/js/login/**/*.js");
        loginRegistry.excludePathPatterns("/image/login/*.png");

    }
}

注意上面的@Bean形式声明的过滤器，这样才能让配置的加载都不出问题，才能让JwtProperties配置类读取到application.yml中的配置信息。这是由于拦截器的额加载是在springcontext之前的，所以要在这里来声明。