【Shiro第九篇】SpringBoot + Shiro整合JWT

目录

一、概述

二、Shiro整合JWT

三、总结


一、概述

JWT,即Json Web Token,JWT作为当下比较流行的身份认证方式之一主要的特点是无状态,把信息放在客户端,服务器端不需要保存session,适合在分布式环境下使用。

  • 传统的Token认证方式:用户登录,服务器端返回Token,并将Token保存在服务器端,以后用户再次访问时,需携带Token,服务器端获取Token后,再去数据库中获取Token进行校验。
  • 基于JWTToken认证方式:用户登录,服务器端给用户返回一个Token,但是服务器端不保存,以后用户再次访问时,需要携带Token,服务器端获取Token后,再做Token校验。

通过上面的对比,JWT跟传统方式最明显的区别就是服务端不保存Token,这样服务端校验Token时就少了很多数据库操作。

Jwt token结构:JWT Token一般分为三个部分:Header、Payload、Signature。下图是一个JWT Token,每一种颜色对应一个部分。 

Header:内部包含算法和类型。 生成的逻辑:将json转换成字符串,然后使用Base64Url进行编码加密 。

{
  "alg": "HS256",
  "typ": "JWT"
}
  • Payload:主要存放自定义的信息,如userId、用户名等,但是不要把敏感信息放在这里。生成的逻辑:将json转换成字符串,然后使用Base64Url进行编码加密。
{
  "userId": "1234567890",
  "username": "John Doe",
  "exp": 12345678950   #超时时间
}

Signature:将第一部分、第二部分的密文使用 "." 拼接起来,然后使用HS256算法进行加密 + 加盐,HS256算法进行加密后的密文再进行Base64Url进行编码加密。

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret)

下面介绍一下jwt实现过程:

  1. 第一步:用户提交用户名和密码给服务器端,如果登录成功,使用jwt创建一个token,并给用户返回;
  2. 第二步:以后用户再来访问时,需携带token,后端需要对token进行校验;
  3. 第三步:获取token,对token进行切割,对第二段进行Base64Url解密,获取Payload消息,检测token是否超时;
  4. 第四步:将第一段和第二段进行拼接,然后使用HS256加密 + 加盐生成密文1,将第三段密文进行Base64Url解密生成密文2,最后比较两个密文1,2是否相等,如果相等表示token有效;

二、Shiro整合JWT

使用基于 Token 的身份验证方法,在服务端不需要存储用户的登录记录。

  1. 客户端使用用户名跟密码请求登录;
  2. 服务端收到请求,去验证用户名与密码;
  3. 验证成功后,服务端会签发一个 Token,再把这个 Token 发送给客户端;
  4. 客户端收到 Token 以后可以把它存储起来,比如放在 Cookie 里;
  5. 客户端每次向服务端请求资源的时候需要带着服务端签发的Token;
  6. 服务端收到请求,然后去验证客户端请求里面带着的 Token,如果验证成功,就向客户端返回请求的数据;

【a】引入JWT相关依赖

<!--jjwt 依赖-->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

【b】application.yml配置中增加JWT相关配置

#jwt 配置
jwt:
  config:
    #加密密匙
    secret: weixiaohuai
    # token有效期,单位秒
    timeout: 3600
    # 后端免认证接口 url
    noAuthUrl: /userLogin,

【c】创建JWT工具类,负责生成JWT和解析JWT

import com.wsh.springboot.springbootshiro.properties.JWTProperties;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
public class JwtUtils {

    @Autowired
    private JWTProperties jwtProperties;

    /**
     * 生成JWTToken
     *
     * @param id      用户id
     * @param subject 用户名
     * @return java.lang.String
     */
    public String createJWTToken(String id, String subject) {
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        JwtBuilder builder = Jwts.builder()
                .setId(id) //id
                .setSubject(subject) //主题
                .setIssuedAt(now) //签发时间
                .signWith(SignatureAlgorithm.HS256, jwtProperties.getSecret()); //加密
        //超时大于0 设置token超时
        if (jwtProperties.getTimeout() > 0) {
            //转换成超时毫秒
            long timeout = nowMillis + (jwtProperties.getTimeout() * 1000);
            builder.setExpiration(new Date(timeout));
        }
        return builder.compact();
    }

    /**
     * 解析JWT
     */
    public Claims parseJWToken(String jwtToken) {
        return Jwts.parser()
                .setSigningKey(jwtProperties.getSecret())
                .parseClaimsJws(jwtToken)
                .getBody();
    }

}

【d】自定义JWT属性配置文件,用于注入配置文件中的值

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

/**
 * 自定义JWT属性配置文件,用于注入配置文件中的值
 */
@Configuration
@Component
@ConfigurationProperties(prefix = "jwt.config")
public class JWTProperties {
    /**
     * jwt加密秘钥
     */
    private String secret;
    /**
     * jwt有效时间
     */
    private long timeout;
    /**
     * 过滤不需要认证的URL
     */
    private String noAuthUrl;

    public JWTProperties() {
    }

    public String getSecret() {
        return secret;
    }

    public void setSecret(String secret) {
        this.secret = secret;
    }

    public long getTimeout() {
        return timeout;
    }

    public void setTimeout(long timeout) {
        this.timeout = timeout;
    }

    public String getNoAuthUrl() {
        return noAuthUrl;
    }

    public void setNoAuthUrl(String noAuthUrl) {
        this.noAuthUrl = noAuthUrl;
    }
}

【e】创建统一结果返回包装类

/**
 * 自定义返回结果
 */
public class CustomResultSet {
    private String code;
    private String msg;
    private String data;

    public CustomResultSet() {
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    public CustomResultSet(String code, String msg, String data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }
}

【f】自定义过滤器CutomJWTFilter

我们使用的是 shiro 默认的权限拦截 Filter,而因为JWT的整合,我们需要自定义自己的过滤器 CutomJWTFilter,CutomJWTFilter 继承了 BasicHttpAuthenticationFilter,并部分方法进行了重写。

  1. 检验请求头是否带有 token ((HttpServletRequest) request).getHeader("Token") != null;
  2. 如果带有 token,执行 shiro 的 login() 方法,将 token 提交到 Realm 中进行检验;如果没有 token,说明当前状态为游客状态(或者其他一些不需要进行认证的接口);
import com.fasterxml.jackson.databind.ObjectMapper;
import com.wsh.springboot.springbootshiro.entity.CustomResultSet;
import com.wsh.springboot.springbootshiro.entity.JWTToken;
import com.wsh.springboot.springbootshiro.properties.JWTProperties;
import org.apache.shiro.authz.UnauthorizedException;
import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.util.AntPathMatcher;
import org.springframework.web.bind.annotation.RequestMethod;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @Description 自定义JWT过滤器, 继承自BasicHttpAuthenticationFilter
 * @Date 2020/11/7 20:23
 * @Author weishihuai
 * 说明:
 */
public class CustomJWTFilter extends BasicHttpAuthenticationFilter {
    private static final Logger logger = LoggerFactory.getLogger(CustomJWTFilter.class);
    //请求头中"access_token"
    private static final String ACCESS_TOKEN = "access_token";
    //JWT属性配置信息
    private JWTProperties jwtProperties;
    private AntPathMatcher pathMatcher = new AntPathMatcher();

    //因为CustomJWTFilter并没有注册到IOC容器中,所以不能使用@Autowired注入JWTProperties,得使用setter或者构造方法注入
    public CustomJWTFilter(JWTProperties jwtProperties) {
        this.jwtProperties = jwtProperties;
    }

    /**
     *
     * 为什么最终返回的都是true,即允许访问?
     * 例如我们提供一个地址 GET /list, 登入用户和游客看到的内容是不同的, 如果在这里返回了false,请求会被直接拦截,用户看不到任何东西
     * 所以我们在这里返回true,Controller中可以通过 subject.isAuthenticated() 来判断用户是否登入.
     * 如果有些资源只有登入用户才能访问,我们只需要在方法上面加上 @RequiresAuthentication 注解即可.
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws UnauthorizedException {
        logger.info("CustomJWTFilter ---> isAccessAllowed().....");
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String[] split = jwtProperties.getNoAuthUrl().split(",");
        for (String url : split) {
            //如果是在配置文件中配置的免认证URL,则直接返回true,表示放行
            if (pathMatcher.match(url, httpServletRequest.getRequestURI())) {
                return true;
            }
        }
        //判断请求的请求头是否带上access_token属性
        if (isLoginAttempt(request, response)) {
            //如果请求头中包含access_token属性,则执行executeLogin方法进行登入操作,检查access_token是否正确
            try {
                return executeLogin(request, response);
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            try {
                this.returnErrorMsg(response, "token为空");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return false;
    }

    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws IOException {
        logger.info("CustomJWTFilter ---> executeLogin().....");
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader(ACCESS_TOKEN);
        try {
            // 提交给realm进行登入,如果错误他会抛出异常并被捕获
            getSubject(request, response).login(new JWTToken(token));
            // 如果没有抛出异常则代表登入成功,返回true
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            this.returnErrorMsg(response, "executeLogin--->token认证失败");
            return false;
        }
    }

    /**
     * 判断用户是否想要登入。
     * 检查请求头中是否包含access_token即可
     */
    @Override
    protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
        logger.info("CustomJWTFilter ---> isLoginAttempt().....");
        HttpServletRequest req = (HttpServletRequest) request;
        return null != req.getHeader(ACCESS_TOKEN);
    }

    /**
     * 返回自定义错误信息
     *
     * @param response
     * @param msg
     * @throws IOException
     */
    private void returnErrorMsg(ServletResponse response, String msg) throws IOException {
        CustomResultSet resultSet = new CustomResultSet("500", msg, null);
        //响应token为空
        response.setContentType("application/json;charset=UTF-8");
        response.setCharacterEncoding("UTF-8");
        //清空第一次流响应的内容
        response.resetBuffer();
        //转成json格式
        ObjectMapper object = new ObjectMapper();
        String asString = object.writeValueAsString(resultSet);
        response.getWriter().println(asString);
    }

    /**
     * 对跨域提供支持
     */
    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        logger.info("CustomJWTFilter ---> preHandle().....");
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
        httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
        // 跨域时会首先发送一个 option请求,这里我们给 option请求直接返回正常状态
        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }

所有的请求都会先经过Filter,所以我们继承官方的BasicHttpAuthenticationFilter,并且重写鉴权的方法。代码的执行流程preHandle -> isAccessAllowed -> isLoginAttempt -> executeLogin。

【g】自定义JWTToken,继承自AuthenticationToken

JWTToken差不多就是Shiro用户名密码的载体。因为我们是前后端分离,服务器无需保存用户状态,所以不需要RememberMe这类功能,我们简单的实现下AuthenticationToken接口即可。

/**
 * 自定义JWTToken,继承AuthenticationToken
 */
public class JWTToken implements AuthenticationToken {

    private String token;

    public JWTToken(String token) {
        this.token = token;
    }

    public JWTToken() {
    }

    @Override
    public Object getPrincipal() {
        return this.token;
    }

    @Override
    public Object getCredentials() {
        return this.token;
    }

}

【h】Shiro全局配置类中增加自定义jwtFilter过滤器,用来拦截并处理携带JWT token的请求

package com.wsh.springboot.springbootshiro.config;

import at.pollux.thymeleaf.shiro.dialect.ShiroDialect;
import com.wsh.springboot.springbootshiro.filter.CustomJWTFilter;
import com.wsh.springboot.springbootshiro.listener.CustomShiroSessionListener;
import com.wsh.springboot.springbootshiro.properties.JWTProperties;
import com.wsh.springboot.springbootshiro.realm.MyShiroRealm;
import org.apache.shiro.codec.Base64;
import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.mgt.DefaultSubjectDAO;
import org.apache.shiro.session.SessionListener;
import org.apache.shiro.session.mgt.SessionManager;
import org.apache.shiro.session.mgt.eis.SessionDAO;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.CookieRememberMeManager;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisManager;
import org.crazycake.shiro.RedisSessionDAO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.filter.DelegatingFilterProxy;

import javax.servlet.Filter;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * @Description: Shiro全局配置类
 * @author: weishihuai
 * @Date: 2020/11/3 09:23
 * <p>
 * 三大组件:
 * 1. Subject: 用户主体(把操作交给SecurityManager)
 * 2. SecurityManager:安全管理器(关联Realm)
 * 3. Realm:Shiro连接数据的桥梁
 */
@Configuration
public class ShiroConfiguration {

    @Autowired
    private JWTProperties jwtProperties;

    /**
     * 将Realm注册到securityManager中
     *
     * @return
     */
    @Bean("securityManager")
    public DefaultWebSecurityManager securityManager() {
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        defaultWebSecurityManager.setRealm(myShiroRealm());
        //将cookie管理器交给SecurityManager进行管理
        defaultWebSecurityManager.setRememberMeManager(rememberMeManager());
        //设置Redis缓存管理器
        defaultWebSecurityManager.setCacheManager(redisCacheManager());
        /*
         * 关闭shiro自带的session
         */
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        defaultWebSecurityManager.setSubjectDAO(subjectDAO);
        return defaultWebSecurityManager;
    }

    /**
     * 配置自定义的Realm
     *
     * @param matcher
     * @return
     */
    @Bean
    public MyShiroRealm myShiroRealm() {
        MyShiroRealm myShiroRealm = new MyShiroRealm();
        //配置密码加密
        return myShiroRealm;
    }

    /**
     * 如果没有此name,将会找不到shiroFilter的Bean
     * <p>
     * Shiro内置过滤器,可以实现权限相关的拦截器
     * 常用的过滤器:
     * anon: 无需认证(登录)可以访问
     * authc: 必须认证才可以访问
     * user: 如果使用rememberMe的功能可以直接访问
     * perms: 该资源必须得到资源权限才可以访问
     * role: 该资源必须得到角色权限才可以访问
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilter(@Qualifier("securityManager") DefaultWebSecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);

        LinkedHashMap<String, Filter> filtersMap = new LinkedHashMap<>();
        //添加自己的自定义jwt过滤器,并取名为jwt
        filtersMap.put("jwt", new CustomJWTFilter(jwtProperties));
        shiroFilterFactoryBean.setFilters(filtersMap);

        //表示指定登录页面
        shiroFilterFactoryBean.setLoginUrl("/userLogin");
        //登录成功后要跳转的链接
        shiroFilterFactoryBean.setSuccessUrl("/success");
        //未授权页面
        shiroFilterFactoryBean.setUnauthorizedUrl("/unauthorized");
        //拦截器, 配置不会被拦截的链接 顺序判断
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        //所有匿名用户均可访问到Controller层的该方法下
        filterChainDefinitionMap.put("/forceLogout", "anon");
        filterChainDefinitionMap.put("/index", "anon");
        filterChainDefinitionMap.put("/userLogin", "anon");
        filterChainDefinitionMap.put("/admin", "roles[admin]");
        filterChainDefinitionMap.put("/user", "roles[user]");
        //user表示配置记住我或认证通过可以访问的地址
        filterChainDefinitionMap.put("/remember", "user");
        filterChainDefinitionMap.put("/logout", "logout");
        //authc:所有url都必须认证通过才可以访问; anon:所有url都都可以匿名访问
//        filterChainDefinitionMap.put("/**", "authc");

        //所有url都必须认证通过jwt过滤器才可以访问
        filterChainDefinitionMap.put("/**", "jwt");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }

    /**
     * SpringShiroFilter首先注册到spring容器
     * 然后被包装成FilterRegistrationBean
     * 最后通过FilterRegistrationBean注册到servlet容器
     *
     * @return
     */
    @Bean
    public FilterRegistrationBean delegatingFilterProxy() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        DelegatingFilterProxy proxy = new DelegatingFilterProxy();
        proxy.setTargetFilterLifecycle(true);
        proxy.setTargetBeanName("shiroFilter");
        filterRegistrationBean.setFilter(proxy);
        return filterRegistrationBean;
    }

    /**
     * 开启Shiro注解配置
     *
     * @param securityManager
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(@Qualifier("securityManager") DefaultWebSecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }

    /**
     * 配置Redis缓存管理器
     */
    @Bean
    public RedisCacheManager redisCacheManager() {
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        //设置redis管理器
        redisCacheManager.setRedisManager(redisManager());
        return redisCacheManager;
    }

//    /**
//     * Ehcache缓存管理器
//     * @return
//     */
//    @Bean
//    @Primary
//    public EhCacheManager ehCacheManager() {
//        EhCacheManager ehCacheManager = new EhCacheManager();
//        ehCacheManager.setCacheManagerConfigFile("classpath:config/shiro-ehcache-config.xml");
//        return ehCacheManager;
//    }

    /**
     * 为了在thymeleaf中使用shiro的自定义tag
     */
    @Bean
    public ShiroDialect shiroDialect() {
        return new ShiroDialect();
    }


    /**
     * 配置redis管理器
     */
    @Bean
    public RedisManager redisManager() {
        RedisManager redisManager = new RedisManager();
        //设置一小时超时,单位是秒
        redisManager.setExpire(3600);
        return redisManager;
    }

}

【i】关闭shiro自带的session

因为用了jwt的访问认证,所以要把默认session支持关掉。即不保存用户登录状态,保证每次请求都重新认证。

/*
 * 关闭shiro自带的session
 */
DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
defaultWebSecurityManager.setSubjectDAO(subjectDAO);

【j】配置自己实现的ShiroRealm

import com.wsh.springboot.springbootshiro.entity.JWTToken;
import com.wsh.springboot.springbootshiro.entity.Permission;
import com.wsh.springboot.springbootshiro.entity.Role;
import com.wsh.springboot.springbootshiro.entity.User;
import com.wsh.springboot.springbootshiro.mapper.PermissionMapper;
import com.wsh.springboot.springbootshiro.mapper.RoleMapper;
import com.wsh.springboot.springbootshiro.mapper.UserMapper;
import com.wsh.springboot.springbootshiro.util.JwtUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class MyShiroRealm extends AuthorizingRealm {

    private static final Logger logger = LoggerFactory.getLogger(MyShiroRealm.class);

    @Autowired
    private UserMapper userMapper;
    @Autowired
    private RoleMapper roleMapper;
    @Autowired
    private PermissionMapper permissionMapper;
    @Autowired
    private JwtUtils jwtUtils;

    /**
     * 支持自定义认证令牌
     * 必须重写此方法,不然Shiro会报错
     * 限定这个 Realm 只处理我们自定义的 JwtToken
     */
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JWTToken;
    }

    /**
     * 默认使用此方法进行用户名正确与否验证,错误抛出异常即可
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        logger.info("MyShiroRealm ---> doGetAuthenticationInfo()认证.....");
        // 这里的 token是从 CutomJWTFilter 的 executeLogin 方法传递过来的
        String token = (String) authenticationToken.getCredentials();
        String username;
        try {
            username = jwtUtils.parseJWToken(token).getSubject();
        } catch (Exception e) {
            //抛出token认证失败
            throw new AuthenticationException("doGetAuthenticationInfo--->token认证失败");
        }
        // 通过用户名到数据库查询用户信息
        User user = userMapper.findUserByName(username);
        if (user == null) {
            throw new UnknownAccountException("用户不存在!");
        }
        return new SimpleAuthenticationInfo(user.getUsername(), token, getName());
    }

    /**
     * 授权相关方法
     *
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        logger.info("MyShiroRealm ---> doGetAuthorizationInfo()授权.....");
        //1.获取用户名
        String username = (String) principalCollection.getPrimaryPrincipal();
        logger.info("username:" + username);

        //返回AuthorizationInfo授权类的子类
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();

        //2.根据用户名查询用户所有的角色信息
        List<Role> allRoleList = roleMapper.getAllRoleListByUsername(username);
        Set<String> rolesSet = new HashSet<>();
        for (Role r : allRoleList) {
            String roleName = r.getName();
            rolesSet.add(roleName);
        }
        logger.info("用户:{} 拥有的角色有:{}", username, rolesSet);
        //设置用户角色信息
        simpleAuthorizationInfo.setRoles(rolesSet);

        //3.根据用户名查询用户所有的权限信息
        List<Permission> allPermissionList = permissionMapper.getAllPermissionListByUsername(username);
        Set<String> permissionSet = new HashSet<>();
        for (Permission permission : allPermissionList) {
            String permissionName = permission.getName();
            permissionSet.add(permissionName);
        }
        simpleAuthorizationInfo.setStringPermissions(permissionSet);
        logger.info("用户:{} 拥有的权限有:{}", username, permissionSet);
        return simpleAuthorizationInfo;
    }

}

【k】修改登录接口,登录成功发放jwt token

@RequestMapping(value = "/userLogin", method = RequestMethod.POST)
@ResponseBody
public CustomResultSet toLogin(String username, String password) {
    // 密码加密
    String md5Password = new SimpleHash("MD5", password, username, 1024).toString();
    User user = userMapper.findUserByName(username);
    if (user != null && md5Password.equals(user.getPassword())) {
        String jwtToken = jwtUtils.createJWTToken(user.getId(), user.getUsername());
        //这里只是简单的返回到前台,实际项目中这里可以将签发的JWT token设置到 HttpServletResponse 的Header中
        //((HttpServletResponse) response).setHeader(JwtUtils.AUTH_HEADER, jwtToken);
        return new CustomResultSet("200", "获取token成功", jwtToken);
    }
    return new CustomResultSet("500", "用户不存在或者密码错误", null);
}

【l】新建一个测试jwt的controller方法

@RequestMapping("/jwtTest")
@ResponseBody
@RequiresPermissions("admin:list")
public String jwtTest() {
    return "测试shiro整合jwt......";
}

【m】测试启动项目,使用admin/123456进行登录,登录之后,可以看到返回的结果信息中包含有access_token。

{"code":"200","msg":"获取token成功","data":"eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIxIiwic3ViIjoiYWRtaW4iLCJpYXQiOjE2MDQ4MzkwMzAsImV4cCI6MTYwNDg0MjYzMH0.Ld4T92poGelbnS6GTWSCY2JGvFVlQWCsy1NPgOnfln8"}

这里我们我们选用postman进行请求测试,分为如下三种情况进行测试:

  • (1)、不带access_token

可以看到,当我们请求中没有携带token,后台返回的错误信息如下:

{
    "code": "500",
    "msg": "token为空",
    "data": null
}
  • (2)、带上错误的access_token

可见,当我们携带的token是无效时,后台返回的错误信息如下:

{
    "code": "500",
    "msg": "executeLogin--->token认证失败",
    "data": null
}
  • (3)、带上正确的access_token

可见,当我们携带登录接口返回的正确的token是,请求正常返回数据。

至此,我们简单实现了Shiro整合JWT实现认证功能。

三、总结

本文主要总结了Shiro如何整合JWT来实现用户认证功能,当然仅仅是简单实现,还有很多需要优化的地方:

  • 暂时还没实现动态刷新access_token功能;
  • access_token缓存问题;
  • ...

由于笔者水平有限,文中难免存在没有考虑到的地方,还望大家指点,相互学习,一起进步!

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页
实付 19.90元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值