SpringBoot+jwt+shiro实现登录验证及接口权限校验

SpringBoot+jwt+shiro+token实现对接口权限校验

最近在一个项目上实现登录模块，就想到了权限验证功能，了解了Spring Security和Shiro之后，决定使用Shiro来实现简单的鉴权功能，Spring Security相比Shiro功能更加强大，相应的，学习成本也更高。

1.Shiro介绍

Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。
三个核心组件：Subject, SecurityManager 和 Realms

三大核心组件关系：

Subject：主体，代表了当前的“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是主体，如第三方进程、网络爬虫、机器人等，Subject是一个抽象概念，所有的Subject都绑定到SecurityManager，与Subject的所有交互都会委托给SecurityManager，可以把Subject认为是一个门面；SecurityManager才是实际的执行者；

SecurityManager：安全管理器，即所有与安全有关的操作都会与SecurityManager进行交互，是Shiro框架的核心，管理所有的Subject，类似于Spring MVC的前端控制器DispatcherServlet；

Realm域：Shiro从Realm中获取安全数据（比如用户、角色、权限），SecurityManager要验证用户身份，需要从Realm中获取相应的用户进行比较确定用户是否合法；验证用户角色/权限也需要从Realm获得相应数据进行比较，类似于DataSource，安全数据源；它封装了数据源的连接细节，并在需要时将相关数据提供给Shiro.

Realm域的认证和授权

认证（authentication）
在程序中认证要做的事情主要是搞明白访问者是谁，他有没有在我们系统中注册过？他是不是我们系统中的用户？如果是，那么这个用户有没有被我们加入黑名单！这是认证要做的事情。举个例子：进一个旅游景区首先要买票吧，要是你手里没有票在检票口会被检票大叔/大妈直接拦住，不让你进去，如果你手里有票，大叔还会看一眼你票是不是今天买的，有没有过期啊……如果你有票并且一切正常，那么你进可以进去了。这就是一个认证的过程！

授权（authorization）
授权的作用主要是验证你有没有访问某项资源的权利！我们都知道在MySQL数据库中，root用户可以随便增删改查各个库的数据，但是普通用户可能就只有查看到权利，而没有删除和修改的权利。在程序中也一样，有一个很常见的需求：用户A可以访问和并修改一个页面，对于用户B可能就只有访问这个页面的权利，而不能修改！

需要注意的是：Shiro本身不提供维护用户、权限，而是通过Realm让开发人员自己注入到SecurityManager，从而让SecurityManager能得到合法的用户以及权限进行判断；

2.JWT介绍

JWT(JSON Web Token)，由请求头、请求体和签名3部分组成，它主要用来生成token，进行认证。

3.实现认证和授权的整体思路

客户端访问服务端，服务端对请求进行认证，主要包括用户名和密码是否正确，如果认证成功会给客户端颁发一个凭证token，后面客户端再访问服务端的时候都要携带这个token，如果不携带或者token被篡改，都会认证失败！如果token认证成功，客户端访问资源，那么此时服务端还会去认证该用户是否有访问此资源的权利！如果此用户没有访问这个资源的权利，同样会访问失败！

4.前置准备

4.1 数据库设计

权限的认证和校验采用RBAC模型，总共有5张表，分别为user、user_role、role、role_permission和permission，
其中user_role和role_permission为中间表，user表和role表示一对多的关系，
role表和permission表也是一对多的关系。

4.2Maven依赖

        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.5.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version> 1.5.3</version>
        </dependency>
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.18.1</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

5.代码实现

5.1工具类

JWT基础工具，用于提供token生成和解密底层功能

import io.jsonwebtoken.*;

import java.util.Date;

public class JwtUtils {
    /**
     * 实例（单例）
     */
    private volatile static JwtUtils instance;

    /**
     * 发行者
     */
    private String subObject = "发行者名称";

    /**
     * 过期时间，默认7天
     */
    private long expired = 1000 * 60 * 60 * 24 * 7;

    /**
     * jwt构造
     */
    private static JwtBuilder jwtBuilder;

    /**
     * 密钥
     */
    private String secret = "你的密钥";// 密钥

    private JwtUtils(){}

    /**
     * 获取实例
     * @return
     */
    public static JwtUtils getInstance(){
        if (instance == null){
            synchronized (JwtUtils.class){
                if (instance == null){
                    instance = new JwtUtils();
                }
            }
        }
        jwtBuilder = Jwts.builder();
        return instance;
    }

    /**
     * 荷载信息(通常是一个User信息，还包括一些其他的元数据)
     * @param key
     * @param val
     * @return
     */
    public JwtUtils setClaim(String key,Object val){
        jwtBuilder.claim(key,val);
        return this;
    }

    /**
     * 生成 jwt token
     * @return
     */
    public String generateToken(){
        String token = jwtBuilder
                .setSubject(subObject) // 发行者
                //.claim("id","121") // 参数
//                .setIssuedAt(new Date()) // 发行时间
                .setExpiration(new Date(System.currentTimeMillis() + expired))
                .signWith(SignatureAlgorithm.HS256,secret) // 签名类型 与 密钥
                .compressWith(CompressionCodecs.DEFLATE)// 对载荷进行压缩
                .compact(); // 压缩一下
        return token;
    }

    /**
     * 解析 token
     * @param token
     * @return
     */
    public Claims check(String token){
        try{
            final Claims claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
            return claims;
        }catch (Exception e){}
        return null;
    }

    public String getSubObject() {
        return subObject;
    }

    /**
     * 设置发行者
     * @param subObject
     * @return
     */
    public JwtUtils setSubObject(String subObject) {
        this.subObject = subObject;
        return this;
    }

    public long getExpired() {
        return expired;
    }

    /**
     * 设置过期时间
     * @param expired
     * @return
     */
    public JwtUtils setExpired(long expired) {
        this.expired = expired;
        return this;
    }

    public String getSecret() {
        return secret;
    }

    /**
     * 设置密钥
     * @param secret
     * @return
     */
    public JwtUtils setSecret(String secret) {
        this.secret = secret;
        return this;
    }
}

Token业务工具类，用于根据自己业务需要来生成相应token，包括写入redis等，此处我们业务上是用户手机号唯一（根据业务可以替换为用户id等）

@Component
public class TokenUtil {

   @Resource
   RedisTemplate<String,Object> redisTemplate;

    public static final String TOKEN = "login_user.token:";
    private static final String PHONE = "login_user.phone:";

    /**
     * jwt生成token
     * */
    public  String makeToken(String telephone){
        JwtUtils jwt = JwtUtils.getInstance();
        return jwt.setClaim(PHONE, telephone).generateToken();
    }

    /**
     * 生成token，存入redis中，设置七天失效时间
     * */
    public  String makeTokenInRedis(UserInfoDTO userInfoDTO){
        final String telephone = userInfoDTO.getTelephone();
        String token = makeToken(telephone);
        Map<String,Object> map = new HashMap<>();
        map.put("信息","用户信息");
        ...用户其他信息省略，根据业务需要自行添加
        String s = JSON.toJSONString(map);
//        RedisTemplate<Object,Object> redisTemplate = new RedisTemplate<>();
        
//redis具体存储逻辑可以自行调整  
redisTemplate.opsForValue().set(TOKEN+telephone,s,7,TimeUnit.DAYS);
        return token;
    }

    /**
     * 解析token
     * */
    public  JSONObject tokenAnalysis(String token){
        JwtUtils jwt = JwtUtils.getInstance();
        Claims check = jwt.check(token);
        if (check==null){
            return null;
        }
        String msg = (String)redisTemplate.boundValueOps(TOKEN+check.get(PHONE)).get();
        if (msg==null){
            return null;
        }
        return JSONObject.parseObject(msg);

    }

}

shiro token信息封装

@AllArgsConstructor
public class JwtToken implements AuthenticationToken {

    private String token;

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

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

5.2 业务层

实体（已简化，可以根据需要将Role和Permission展开）

import lombok.Data;

import java.util.List;

/**
 * 简化版，如果后续需要，将role和permission分别建立实体。
 */
@Data
public class UserRole {

    //用户id
    Long userId;

    //角色名称集合
    List<String> roles;

    //权限名称集合
    List<String> permissions;
}

Service层(接口已省略，只贴实现类)

@Service
public class UserRoleImpl implements UserRoleService {
    @Resource
    UserRoleMapper userRoleMapper;

    @Override
    public UserRole getUserRole(UserInfoDTO userInfoDTO) {
        final Long userInfoDTOId = userInfoDTO.getId();
        final List<String> userRolesById = userRoleMapper.findUserRolesById(userInfoDTOId);
        final List<String> userPermissionsById = userRoleMapper.findUserPermissionsById(userInfoDTOId);
        UserRole userRole = new UserRole();
        userRole.setUserId(userInfoDTOId);
        userRole.setRoles(userRolesById);
        userRole.setPermissions(userPermissionsById);
        return userRole;
    }
}

DAO层(此处我的两个方法分别是根据用户id查询该用户的所有角色，以及根据用户id查询该用户的所有权限)

@Mapper
public interface UserRoleMapper {
    //id与userid相同
    List<String> findUserRolesById(@Param("id")Long id);

    List<String>  findUserPermissionsById(@Param("id")Long id);
}

5.3 shiro相关

shiro配置

@Configuration
@Slf4j
public class ShiroConfig {
    /**
     * 注册shiro的Filter，拦截请求
     */

    @Bean("securityManager")
    public SecurityManager securityManager(UserRealm userRealm) {
        /*
         * 关闭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);
        //设置manager
        DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
        manager.setRealm(userRealm);
        return manager;
    }

    @Bean("lifecycleBeanPostProcessor")
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

    /**
     * @return org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor
     * @Description 开启shiro aop注解支持.使用代理方式;所以需要开启代码支持;
     * @Param [securityManager]
     **/
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }


    @Bean("shiroFilter")
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean filter = new ShiroFilterFactoryBean();
        filter.setSecurityManager(securityManager);

        //加入自定义的filter
        // setLoginUrl 如果不设置值，默认会自动寻找Web工程根目录下的"/login.jsp"页面 或 "/login" 映射
        //前后端分离项目中该链接应该为后端接口的访问url，通过该接口返回需要登录的状态码，由前端跳转至登录页面
        //shiroFilter.setLoginUrl("/user/login");
        // 设置无权限时跳转的 url;
        //shiroFilter.setUnauthorizedUrl("/user/test");
        // 添加自己的过滤器并且取名为jwt
        Map<String, Filter> filterMap = filter.getFilters();

        filterMap.put("jwt", new jwtFilter());
        filter.setFilters(filterMap);

        //定义相关路径
        filter.setLoginUrl("/login");
        filter.setUnauthorizedUrl("/noAuthorize");

        // 设置拦截器
        //定义拦截路径,记得将静态资源也排除过滤
        /*进行权限的控制,必须使用LinkHashMap,shrio要按照顺序进行设置*/
        Map<String, String> authMap = new LinkedHashMap<>();

        //anon:无参，开放权限，可以理解为匿名用户或游客
        authMap.put("/user/login", "anon");
        authMap.put("/user/register", "anon");

        //其余接口一律拦截
        //主要这行代码必须放在所有权限设置的最后，不然会导致所有 url 都被拦截
        //authc:无参，需要认证
        authMap.put("/**", "jwt");

        filter.setFilterChainDefinitionMap(authMap);

        //配置完成
        log.info("shiro factory 创建成功");
        return filter;
    }

    @Bean("jwtFilter")
    public JwtFilter jwtFilter() {
        return new JwtFilter();
    }

    /**
     * SpringShiroFilter首先注册到spring容器
     * 然后被包装成FilterRegistrationBean
     * 最后通过FilterRegistrationBean注册到servlet容器
     * @return
     */
    @Bean
    @SuppressWarnings("all")
    public FilterRegistrationBean delegatingFilterProxy(){
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        DelegatingFilterProxy proxy = new DelegatingFilterProxy();
        proxy.setTargetFilterLifecycle(true);
        proxy.setTargetBeanName("shiroFilter");
        filterRegistrationBean.setFilter(proxy);
        return filterRegistrationBean;
    }
    @Bean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        // 强制使用cglib，防止重复代理和可能引起代理出错的问题
        // https://zhuanlan.zhihu.com/p/29161098
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        return defaultAdvisorAutoProxyCreator;
    }
}

Realm

/**
 * Shiro从从Realm获取安全数据（如用户、角色、权限）
 * ，就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应
 * 的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；
 * 可以把Realm看成DataSource，即安全数据源。Realm主要有两个方法：
 * doGetAuthorizationInfo(获取授权信息)
 * doGetAuthenticationInfo(获取身份验证相关信息)：
 * @Version 1.0
 **/
@Configuration
@Slf4j
public class UserRealm extends AuthorizingRealm {

    @Resource
    UserRoleService userRoleService;

    @Resource
    TokenUtil tokenUtil;

	//根据token解析body得到的用户部分信息来富化该用户全部信息，如果之前token是根据用户全量信息生成的，可以省略
    @Resource
    UserMapper userMapper;

    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JwtToken;
    }

    /**
     * 授权(验证权限时调用)
     * 这个方法就会从数据库中读取我们所需要的信息，最后封装成SimpleAuthorizationInfo返回去
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        UserInfo userInfo = UserCache.getCurrentUser();
        UserInfoDTO userInfoDTO = new UserInfoDTO();
        BeanUtils.copyProperties(userInfo,userInfoDTO);

        //添加角色及权限
        UserRole userRole = this.userRoleService.getUserRole(userInfoDTO);
        userRole.getRoles().forEach(authorizationInfo::addRole);
        userRole.getPermissions().forEach(authorizationInfo::addStringPermission);

        return authorizationInfo;
    }

    /**
     * 认证(登录时调用)
     */
    @SneakyThrows
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken)  {
        final String token = (String) authenticationToken.getCredentials();

        log.info("正在对token进行登录验证...");
        JSONObject object = tokenUtil.tokenAnalysis(token);
        if (Objects.isNull(object)){
            log.error("token为{}的用户token错误",token);
            throw new Exception("token错误...");
        }
        String telephone = object.getString("telephone");
        UserInfo userInfo = this.userMapper.getUserInfoByTelephone(telephone);

        if (Objects.isNull(userInfo)){
            log.error("token为{}的用户信息不存在",token);
            throw new UnknownAccountException("用户信息不存在...");
        }

         //缓存添加当前用户信息(这个就是个ThreadLocal存储登录用户信息)
         UserCache.addCurrentUser(userInfo);

        return new SimpleAuthenticationInfo(token,token,"UserRealm");
    }
}

JwtFilter

@Slf4j
public class JwtFilter extends BasicHttpAuthenticationFilter {

    @Override
    protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
        HttpServletRequest req = (HttpServletRequest) request;
        String authorization = req.getHeader("Authorization");
        return authorization != null;
    }

    /**
     * 这里我们详细说明下为什么最终返回的都是true，即允许访问
     * 例如我们提供一个地址 GET /article
     * 登入用户和游客看到的内容是不同的
     * 如果在这里返回了false，请求会被直接拦截，用户看不到任何东西
     * 所以我们在这里返回true，Controller中可以通过 subject.isAuthenticated() 来判断用户是否登入
     * 如果有些资源只有登入用户才能访问，我们只需要在方法上面加上 @RequiresAuthentication 注解即可
     * 但是这样做有一个缺点，就是不能够对GET,POST等请求进行分别过滤鉴权(因为我们重写了官方的方法)，但实际上对应用影响不大
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        log.info("JwtFilter-->>>执行登录认证:init()");
        //如果请求头不存在token,则可能是执行登陆操作或是游客状态访问,直接返回true
        if (!isLoginAttempt(request, response)) {
            return true;
        }
        //如果存在,则进入executeLogin方法执行登入,检查token 是否正确
        try {
            executeLogin(request, response);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            throw new AuthenticationException("Token失效请重新登录!");
        }
    }

    /**
     * 重写AuthenticatingFilter的executeLogin方法丶执行登陆操作
     */
    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        log.info("JwtFilter-->>>executeLogin-Method:init()");
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader("Authorization");//Access-Token
        JwtToken jwtToken = new JwtToken(token);
        //UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(UserCache.getCurrentUser().getTelephone(),UserCache.getCurrentUser().getPassword());
        // 提交给realm进行登入,如果错误他会抛出异常并被捕获, 反之则代表登入成功,返回true
        getSubject(request, response).login(jwtToken);
        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);
    }

}

OK，大功告成
直接测一下

6.使用测试

@ControllerMapping("test")
public class TestController {

    @PostMapping("test2")
    @RequiresRoles(value = {"admin","user"},logical = Logical.OR)
    public String test2(@RequestBody JSONObject object){
        int a = 1+1;
        return "SUCCESS";
    }
}

上面注解中的角色名称是数据库自定义的

注解使用说明： RequiresRoles–>RequiresPermissions–>RequiresAuthentication–>RequiresUser–>RequiresGuest
Note:如果有个多个注解的话，前面的通过了会继续检查后面的，若不通过则直接返回