SpringBoot集成Shiro、JWT 进行请求认证和权限校验

添加maven依赖

 <!--JWT-->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.4.0</version>
        </dependency>
        <!--shiro-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.4.0</version>
        </dependency>

1.什么是JWT?

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

 2.jwt工具类

public class JWTUtil {
/**
 * 过期时间 24 小时
 */
private static final long EXPIRE_TIME = 60 * 24 * 60 * 1000;
/**
 * 密钥，注意这里如果真实用到，应当设置到复杂点，相当于私钥的存在。如果被人拿到，想到于它可以自己制造token了。
 */
private static final String SECRET = "LIAODASHUAI";

/**
 * 生成 token, 5min后过期
 *
 * @param username 用户名
 * @return 加密的token string
 */
public static String createToken(String username) {
    Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
    Algorithm algorithm = Algorithm.HMAC256(SECRET);
    // 附带username信息
    return JWT.create()
            .withClaim("username", username)
            //到期时间
            .withExpiresAt(date)
            //创建一个新的JWT，并使用给定的算法进行标记
            .sign(algorithm);
}

/**
 * 校验 token 是否正确
 *
 * @param token    密钥
 * @param username 用户名
 * @return 是否正确 boolean
 */
public static boolean verify(String token, String username) {
    try {
        Algorithm algorithm = Algorithm.HMAC256(SECRET);
        //在token中附带了username信息
        JWTVerifier verifier = JWT.require(algorithm)
                .withClaim("username", username)
                .build();
        //验证 token
        verifier.verify(token);
        return true;
    } catch (Exception exception) {
        return false;
    }
}

/**
 * 获得token中的信息，无需secret解密也能获得
 *
 * @param token the token
 * @return token中包含的用户名 username
 */
public static String getUsername(String token) {
    try {
        DecodedJWT jwt = JWT.decode(token);
        return jwt.getClaim("username").asString();
    } catch (JWTDecodeException e) {
        return null;
    }
}
}

 3.重新实现AuthenticationToken类，让其存放token，便于校验。

public class JWTToken implements AuthenticationToken {
private String token;

/**
 * Instantiates a new Jwt token.
 *
 * @param token the token
 */
public JWTToken(String token) {
    this.token = token;
}

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

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

4.自定义过滤器继承BasicHttpAuthenticationFilter

public class JWTFilter extends BasicHttpAuthenticationFilter {
private Logger logger = LoggerFactory.getLogger(this.getClass());

/**
 * 如果带有 token，则对 token 进行检查，否则直接通过
 */
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws UnauthorizedException {
    //判断请求的请求头是否带上 "token"
    if (isLoginAttempt(request, response)) {
        //如果存在，则进入 executeLogin 方法执行登入，检查 token 是否正确
        try {
            executeLogin(request, response);
            return true;
        } catch (Exception e) {
            //token 错误
            responseError(response, e.getMessage());
        }
    }
    //如果请求头不存在 Token，则可能是执行登陆操作或者是游客状态访问，无需检查 token，直接返回 true
    return true;
}

/**
 * 判断用户是否想要登入。
 * 检测 header 里面是否包含 Token 字段
 */
@Override
protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
    HttpServletRequest req = (HttpServletRequest) request;
    String token = req.getHeader("token");
    return token != null;
}

/**
 * 执行登陆操作
 */
@Override
protected boolean executeLogin(ServletRequest request, ServletResponse response) {
    HttpServletRequest httpServletRequest = (HttpServletRequest) request;
    String token = httpServletRequest.getHeader("token");
    JWTToken jwtToken = new JWTToken(token);
    // 提交给realm进行登入，如果错误他会抛出异常并被捕获
    getSubject(request, response).login(jwtToken);
    // 如果没有抛出异常则代表登入成功，返回true
    return true;
}

/**
 * 对跨域提供支持
 */
@Override
protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
    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);
}

/**
 * 将非法请求跳转到 /unauthorized/**
 */
private void responseError(ServletResponse response, String message) {
    try {
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        //设置编码，否则中文字符在重定向时会变为空字符串
        message = URLEncoder.encode(message, "UTF-8");
        httpServletResponse.sendRedirect("/unauthorized/" + message);
    } catch (IOException e) {
        logger.error(e.getMessage());
    }
}
}

5.继承AuthorizingRealm，实现用户授权的验证和权限的验证

public class CustomRealm extends AuthorizingRealm {
@Autowired
UserInfoMapper userInfoMapper;
@Autowired
RoleMapper roleMapper;

/**
 * 必须重写此方法，不然会报错
 */
@Override
public boolean supports(AuthenticationToken token) {
    return token instanceof JWTToken;
}

/**
 * 默认使用此方法进行用户名正确与否验证，错误抛出异常即可。
 */
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    System.out.println("————身份认证方法————");
    String token = (String) authenticationToken.getCredentials();
    // 解密获得username，用于和数据库进行对比
    String username = JWTUtil.getUsername(token);
    if (username == null || !JWTUtil.verify(token, username)) {
        throw new AuthenticationException("token认证失败！");
    }
    UserInfo userInfo = userInfoMapper.selectByName(username);
    if (userInfo == null) {
        throw new AuthenticationException("该用户不存在！");
    }
    if (userInfo.getState() == 1) {
        throw new AuthenticationException("该用户已被封号！");
    }
    return new SimpleAuthenticationInfo(token, token, "MyRealm");
}

/**
 * 只有当需要检测用户权限的时候才会调用此方法，例如checkRole,checkPermission之类的
 */
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
    System.out.println("————权限认证————");
    String username = JWTUtil.getUsername(principals.toString());
    SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
    // 此处最好使用缓存提升速度
    UserInfo userInfo = userInfoMapper.selectByName(username);
    userInfo = userInfoMapper.selectUserOfRole(userInfo.getUid());
    if (userInfo == null || userInfo.getRoleList().isEmpty()) {
        return authorizationInfo;
    }
    for (Role role : userInfo.getRoleList()) {
        authorizationInfo.addRole(role.getRole());
        role = roleMapper.selectRoleOfPerm(role.getId());
        if (role == null || role.getPermissions().isEmpty()) {
            continue;
        }
        for (Permission p : role.getPermissions()) {
            authorizationInfo.addStringPermission(p.getPermission());
        }
    }
    return authorizationInfo;
}
}

6.配置ShiroConfig，将自定义的过滤器设置进去

@Configuration
public class ShiroConfig {
    /**
     * 先走 filter ，然后 filter 如果检测到请求头存在 token，则用 token 去 login，走 Realm 去验证
     *
     * @param securityManager the security manager
     * @return the shiro filter factory bean
     */
    @Bean
    public ShiroFilterFactoryBean factory(SecurityManager securityManager) {
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        Map<String, Filter> filterMap = new HashMap<>();
        //设置我们自定义的JWT过滤器
        filterMap.put("jwt", new JWTFilter());
        factoryBean.setFilters(filterMap);
        factoryBean.setSecurityManager(securityManager);
        // 设置无权限时跳转的 url;
        factoryBean.setUnauthorizedUrl("/unauthorized/无权限");
        Map<String, String> filterRuleMap = new HashMap<>();
        //访问/login和/unauthorized 不需要经过过滤器
        filterRuleMap.put("/login", "anon");
        filterRuleMap.put("/unauthorized/**", "anon");
        // 所有请求通过我们自己的JWT Filter
        filterRuleMap.put("/**", "jwt");
        // 访问 /unauthorized/** 不通过JWTFilter
        factoryBean.setFilterChainDefinitionMap(filterRuleMap);
        return factoryBean;
    }

/**
 * 注入 securityManager
 *
 * @return the security manager
 */
@Bean
public SecurityManager securityManager() {
    DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    // 设置自定义 realm.
    securityManager.setRealm(customRealm());
    /*
     * 关闭shiro自带的session，详情见文档
     * http://shiro.apache.org/session-management.html#SessionManagement-StatelessApplications%28Sessionless%29
     */
    DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
    DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
    defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
    subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
    securityManager.setSubjectDAO(subjectDAO);
    return securityManager;
}

@Bean
public CustomRealm customRealm() {
    return new CustomRealm();
}

/**
 * 开启shiro aop注解支持. 使用代理方式; 所以需要开启代码支持;
 *
 * @param securityManager 安全管理器
 * @return 授权Advisor
 */
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
    AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
    advisor.setSecurityManager(securityManager);
    return advisor;
}
}