springboot集成shiro完成token认证，以及需要注意的点_springboot shiro token

作者：weixin_40725706 | 2024-04-05 21:42:29

踩

springboot shiro token

依赖：


<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring-boot-web-starter</artifactId>
    <version>1.4.1</version>
</dependency>

1.自定义token继承UsernamePasswordToken


public class JwtToken extends UsernamePasswordToken {
   private String token;
 
    public String getToken() {
        return token;
    }
 
    public void setToken(String token) {
        this.token = token;
    }
 
    public JwtToken(String username, String password) {
        super(username, password);
    }
}

注意：继承 UsernamePasswordToken 类后，账号跟密码使用了 UsernamePasswordToken 类的构造方法

2.自定义Realm


import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
 
public class CustomerRealm extends AuthorizingRealm {
 
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JwtToken;
    }
 
    //授权
 
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
 
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        /*
          常见的方法：
          addRole(String role)：向授权信息中添加角色。
          addRoles(Collection<String> roles)：向授权信息中添加多个角色。
          addStringPermission(String permission)：向授权信息中添加权限（字符串形式）。
          addStringPermissions(Collection<String> permissions)：向授权信息中添加多个权限（字符串形式）。
          setRoles(Set<String> roles)：设置授权信息的角色集合。
          setStringPermissions(Set<String> permissions)：设置授权信息的权限集合。
          getRoles()：获取授权信息中的角色集合。
          getStringPermissions()：获取授权信息中的权限集合。
         */
        // 在这里只是设置权限了一个普通的权限：字符串
        authorizationInfo.addStringPermission("user:add:*");
        return authorizationInfo;
    }
 
    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        JwtToken jwtToken = (JwtToken) authenticationToken;
        return new SimpleAuthenticationInfo("任意对象","147258369",this.getName());
    }
}

自定义Realm注意的点：

第一点：

在 doGetAuthenticationInfo 方法里面，他的返回值：
return new SimpleAuthenticationInfo("任意对象","147258369",this.getName());
SimpleAuthenticationInfo 对象是要重点说一下的：

第一个参数是验证成功之后保存的用户数据，是一个Object类型，
第二个参数传递的是要做密码比较的参数：

首先来看下这个图，这个是我模拟登录时候的代码，可以看到我把账号跟密码传递给了 JwtToken：

而 JwtToken 继承了 UsernamePasswordToken 类，继续点进源码：

可以看到在 UsernamePasswordToken 类中获取账号跟密码相对应的方法，然后我在登录的controller中，继续调用以下方法进行登录：
Subject subject = SecurityUtils.getSubject();
subject.login(token);
以上代码执行之后，会进入 doGetAuthenticationInfo 这个方法里面，进行登录认证（拿账号密码去数据库里面查询）成功之后，如果SimpleAuthenticationInfo 的第二个参数跟我传递给 new JwtToken("123456789","147258369") 的第二个参数不一样的话，就会认证失败，个人觉得 SimpleAuthenticationInfo 的第二个参数类型是：

而在登录的时候，传递进来的 JwtToken 继承的 UsernamePasswordToken类的密码：

命名一样，所以我觉得会做比较，如果不一致，会报错异常：（个人猜测）

如果登录的时候，认证失败：会返回：IncorrectCredentialsException 异常

第二点（进入doGetAuthorizationInfo 方法的时机）：

doGetAuthorizationInfo方法不是主动调用的，而是被动调用的，当请求的接口上有类似这种 RequiresPermissions 注解的时候，就会去执行方法，判断是否有对应的权限

执行流程（请求设置了拦截路径的接口）：在过滤器中使用 shrio 的登录方法，进入doGetAuthenticationInfo 方法中进行认证，认证成功之后会请求接口，如果接口上有shiro的权限或者角色注解，那么就会进入 doGetAuthorizationInfo 方法中获取相对应的权限或者角色，然后就会再返回接口中，如果有权限就执行接口的方法

第三点：我在测试的时候，发现加入了AOP依赖之后，对于放行路径，过滤器一样会进行拦截，目前这个我还没找到解决方法，只能无奈把AOP依赖去掉了（这个不知道你们会不会这样）

第四点：

3.设置shrio的配置类


import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.mgt.DefaultSubjectDAO;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
import javax.servlet.Filter;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
 
 
@Configuration
public class shiroConfig {
 
    //创建shirofilter,负责拦截所有请求
    @Bean(name = "shiroFilterFactoryBean")
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        Map<String, Filter> filters = new HashMap<>();
        filters.put("auth", new MyFilter());
        shiroFilterFactoryBean.setFilters(filters);
        //配置系统受限资源
        //配置系统公共资源
        Map<String,String> map  = new LinkedHashMap<>();
        // 在这里，我放行请求的的是我的登录接口
        map.put("/user/login","anon");
        // 其余接口我都要进行拦截 ，拦截器是 new MyFilter()
        map.put("/**","auth");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;
    }
 
    //创建shiro安全管理器
    @Bean
    public DefaultWebSecurityManager getDefaultWebSecurityManager(Realm realm){
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
 
        //关闭shiro自带的session
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        defaultWebSecurityManager.setSubjectDAO(subjectDAO);
        //配置realm
        defaultWebSecurityManager.setRealm(realm);
        return defaultWebSecurityManager;
    }
 
    //创建自定义realm
    @Bean
    public Realm getRealm(){
        CustomerRealm customerRealm = new CustomerRealm();
        //设置缓存管理器
        customerRealm.setCachingEnabled(false);
        customerRealm.setAuthenticationCachingEnabled(true);
        customerRealm.setAuthenticationCacheName("AuthenticationCache");
        customerRealm.setAuthorizationCachingEnabled(true);
        customerRealm.setAuthorizationCacheName("AuthorizationCache");
        return customerRealm;
    }
 
}

配置类要注意的点：

在配置拦截放行路径的时候，一定不能使用 hashmap，而是使用 LinkedHashMap ，然后配置路径的时候，不用拦截的请求放在前面，一般 /** 是放在最后的：

4.配置过滤器：


package com.example.mp_pring.config.shiro;
 
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
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;
 
@Component
public class MyFilter extends BasicHttpAuthenticationFilter {
    /**
     * 执行登录认证
     *
     * @param request
     * @param response
     * @param mappedValue
     * @return
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        try {
            return executeLogin(request, response);
        } catch (Exception e) {
            System.out.println("JwtFilter过滤认证失败!");
            return false;
        }
    }
 
    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        // token 一般都是放在请求头中
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader("Token");
 
        // 假设已经拿到token，并校验token了，如果校验不通过就直接 return false;
        // token校验成功，拿到账号跟密码
        JwtToken jwtToken = new JwtToken("123456789","147258369");
        try {
            // 提交给realm进行登入，如果错误他会抛出异常并被捕获
            Subject subject = SecurityUtils.getSubject();
            subject.login(jwtToken);
            // 如果没有抛出异常则代表登入成功，返回true
            return true;
        } catch (AuthenticationException e) {
            response.setCharacterEncoding("utf-8");
            response.getWriter().print("error");
            return false;
        }
 
    }
 
    /**
     * 对跨域提供支持
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @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);
    }
}

5.演示：


import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
 
import javax.servlet.http.HttpServletResponse;
 
/**
 * @Description:
 * @Author sk
 * @Date: 2023/4/4 18:40
 */
@Controller
@RequestMapping("/user")
public class UserControllerabc {
 
 
    @RequestMapping("/login")
    @ResponseBody
    public String login() throws Exception {
        JwtToken token = new JwtToken("123456789","147258369");
        try {
            Subject subject = SecurityUtils.getSubject();
            subject.login(token);
            System.out.println("认证成功");
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("认证失败");
        }
        return "success";
    }
 
    @RequestMapping("/test")
    @ResponseBody
    @RequiresPermissions("user:add:*")
    public String test() {
        Subject subject = SecurityUtils.getSubject();
        Object principal = subject.getPrincipal();
        PrincipalCollection principals = subject.getPrincipals();
        return "success:验证成功：user:add:*";
    }
 
    @RequestMapping("/test1")
    @ResponseBody
    @RequiresPermissions("user:add:a")
    public String test1() {
        return "success:验证成功：user:add:a";
    }
}

登录：http://localhost:8080/user/login

进入要权限的接口：http://localhost:8080/user/test ，http://localhost:8080/user/test1

这两个接口需要权限为 user:add:* 和 user:add:a 才能访问，在本案例中：

设置的权限就是 user:add:* ，所以按道理来说，test跟test1接口都能访问，* 代表的通配符

可以看到，都访问成功了

修改权限

我在这里把权限设置为了 user:add:a ，所以无法访问test接口，尝试一波：

可以看到，如果没有权限，会直接报错

6.演示文件：

本项目已经上传到本博客，需要的可自行下载，可直接使用

7.注意！！！！！：

我用了shrio之后，在controller层直接使用了事务的注解，导致这个controller里面的接口全报404了（但是这个在我另外一个项目里面没有出现），查了一下，是 shrio 跟 Transactional 的aop 执行时间有关系：可以参考一下别人的博客：在Controller上使用@Transactional注解导致的接口404_@transactional controller_木子的木木的博客-CSDN博客

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/368073