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

今天药忘吃喽~ 2023-10-09 18:39 68阅读 0赞

> 依赖：
> 
>     <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：**
> 
> ![86da4f47fdf04e78af372017495b81a5.png][]
> 
>   
> **而 JwtToken 继承了**  **UsernamePasswordToken 类，继续点进源码：**
> 
> ![42cf364ac8374a049ec79ee0d5539c9b.png][]
> 
>  **可以看到在 UsernamePasswordToken 类中获取账号跟密码相对应的方法，然后我在登录的controller中，继续调用以下方法进行登录：**
> 
>     Subject subject = SecurityUtils.getSubject();
>     subject.login(token);
> 
> **以上代码执行之后，会进入 doGetAuthenticationInfo 这个方法里面，进行登录认证（拿账号密码去数据库里面查询）成功之后，如果SimpleAuthenticationInfo 的第二个参数跟我传递给 new JwtToken("123456789","147258369")****的第二个参数不一样的话，就会认证失败，个人觉得 SimpleAuthenticationInfo 的第二个参数类型是**：
> 
> ![bb89267bcdae4b1f874900d058aba451.png][]
> 
> **而在登录的时候，传递进来的 JwtToken 继承的 UsernamePasswordToken类的密码：**
> 
> ![57b72feb30de4d3cb087712daa6856ed.png][]
> 
> **命名一样，所以我觉得会做比较，如果不一致，会报错异常：（个人猜测）**
> 
> **如果登录的时候，认证失败：会返回：****IncorrectCredentialsException 异常**
> 
>   
>   
> **第二点（进入doGetAuthorizationInfo 方法的时机）：**
> 
>  *  **doGetAuthorizationInfo方法不是主动调用的，而是被动调用的，当请求的接口上有类似这种 RequiresPermissions 注解的时候，就会去执行方法，判断是否有对应的权限**
> 
> **执行流程（请求设置了拦截路径的接口）：在过滤器中使用 shrio 的登录方法，进入doGetAuthenticationInfo 方法中进行认证，认证成功之后会请求接口，如果接口上有shiro的权限或者角色注解，那么就会进入 doGetAuthorizationInfo 方法中获取相对应的权限或者角色，然后就会再返回接口中，如果有权限就执行接口的方法**
> 
>   
>   
> **第三点：我在测试的时候，发现加入了AOP依赖之后，对于放行路径，过滤器一样会进行拦截，目前这个我还没找到解决方法，只能无奈把AOP依赖去掉了（这个不知道你们会不会这样）  
>   
> 第四点：**  
> 
> 
> ![35aedb96b7d248f08488311af0aef641.png][]

## **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 ，然后配置路径的时候，不用拦截的请求放在前面，一般 /\*\* 是放在最后的：**
> 
> ![6c432dd89d4a42788473df51a06524bc.png][]

## **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_login]**
> 
> ![be82962f78b74079a962f5b26a93d7d4.png][]

>  *  **进入要权限的接口：[http://localhost:8080/user/test][http_localhost_8080_user_test]** ，[http://localhost:8080/user/test][http_localhost_8080_user_test]1
> 
> ![39ffa13c0696428984397c2e5591c454.png][]
> 
>  **这两个接口需要权限为 user:add:\* 和 user:add:a 才能访问，在本案例中：**
> 
> ![4188ab49408445c6ba7e46865c4633d0.png][]
> 
> **设置的权限就是 user:add:\* ，所以按道理来说，test跟test1接口都能访问，\* 代表的通配符**
> 
> ![9acd0bf2855b4266be4d3c6797594b04.png][]
> 
> **可以看到，都访问成功了**

>  *  **修改权限**
> 
> ![dbd6a8a55ae34f26adde31db6e1768ee.png][]
> 
> **我在这里把权限设置为了 user:add:a ，所以无法访问test接口，尝试一波：**
> 
> ![f5ec6d22040a44168c6bdbc488b96ff9.png][]
> 
>   
> ![30941c151e85404fbfb909c210c94536.png][]
> 
>  **可以看到，如果没有权限，会直接报错**

## **6.演示文件：** ##

>  **本项目已经上传到本博客，需要的可自行下载，可直接使用**
> 
> ![7900142c23204ee8a12aa11012bfe1c8.png][]

## 7.注意！！！！！： ##

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

[86da4f47fdf04e78af372017495b81a5.png]: https://img-blog.csdnimg.cn/86da4f47fdf04e78af372017495b81a5.png
[42cf364ac8374a049ec79ee0d5539c9b.png]: https://img-blog.csdnimg.cn/42cf364ac8374a049ec79ee0d5539c9b.png
[bb89267bcdae4b1f874900d058aba451.png]: https://img-blog.csdnimg.cn/bb89267bcdae4b1f874900d058aba451.png
[57b72feb30de4d3cb087712daa6856ed.png]: https://img-blog.csdnimg.cn/57b72feb30de4d3cb087712daa6856ed.png
[35aedb96b7d248f08488311af0aef641.png]: https://img-blog.csdnimg.cn/35aedb96b7d248f08488311af0aef641.png
[6c432dd89d4a42788473df51a06524bc.png]: https://img-blog.csdnimg.cn/6c432dd89d4a42788473df51a06524bc.png
[http_localhost_8080_user_login]: http://localhost:8080/user/login
[be82962f78b74079a962f5b26a93d7d4.png]: https://img-blog.csdnimg.cn/be82962f78b74079a962f5b26a93d7d4.png
[http_localhost_8080_user_test]: http://localhost:8080/user/test
[39ffa13c0696428984397c2e5591c454.png]: https://img-blog.csdnimg.cn/39ffa13c0696428984397c2e5591c454.png
[4188ab49408445c6ba7e46865c4633d0.png]: https://img-blog.csdnimg.cn/4188ab49408445c6ba7e46865c4633d0.png
[9acd0bf2855b4266be4d3c6797594b04.png]: https://img-blog.csdnimg.cn/9acd0bf2855b4266be4d3c6797594b04.png
[dbd6a8a55ae34f26adde31db6e1768ee.png]: https://img-blog.csdnimg.cn/dbd6a8a55ae34f26adde31db6e1768ee.png
[f5ec6d22040a44168c6bdbc488b96ff9.png]: https://img-blog.csdnimg.cn/f5ec6d22040a44168c6bdbc488b96ff9.png
[30941c151e85404fbfb909c210c94536.png]: https://img-blog.csdnimg.cn/30941c151e85404fbfb909c210c94536.png
[7900142c23204ee8a12aa11012bfe1c8.png]: https://img-blog.csdnimg.cn/7900142c23204ee8a12aa11012bfe1c8.png
[Controller_Transactional_404_transactional controller_-CSDN]: https://blog.csdn.net/lidelin10/article/details/113437548