Springboot2集成Shiro框架（三）自定义Realm

ゝ一纸荒年。 2024-04-18 08:51 36阅读 0赞

### 目录 ###

*   *  1、realm的作用
     *  2、数据库设计
     *  3、创建自定义realm
     *   *  3.1 userService为null问题
     *  4、把自定义的Realm交给SecurityManager
     *  5、user类
     *  6、 业务层
     *   *  6.1service
         *  6.2serviceImpl
     *  7、controller
     *  8、添加对权限注解支持
     *  9、补充
     *  10、测试页面
     *  11、进行测试
     *   *  11.1测试结果
     *  12、源码

## 1、realm的作用 ##

Realm充当了Shiro与应用安全数据间的“桥梁”或者“连接器”。也就是说，当对用户执行认证（登录）和授权（访问控制）验证时，Shiro会从应用配置的Realm中查找用户及其权限信息。  
　　从这个意义上讲，Realm实质上是一个安全相关的DAO：它封装了数据源的连接细节，并在需要时将相关数据提供给Shiro。当配置Shiro时，你必须至少指定一个Realm，用于认证和（或）授权。配置多个Realm是可以的，但是至少需要一个。  
　　Shiro内置了可以连接大量安全数据源（又名目录）的Realm，如LDAP、关系数据库（JDBC）、类似INI的文本配置资源以及属性文件等。如果缺省的Realm不能满足需求，你还可以插入代表自定义数据源的自己的Realm实现。

## 2、数据库设计 ##

下图是一个简单的权限关系库，主要是有三个表，**用户**、**角色**、**权限**，为了容易管理，用户只关联角色，而不同的角色对应不同的权限，shiro框架允许我们随意配置权限粗细度，可以精确到角色，也可以细微至某个权限（比如：用户添加权限等），***我们需要了解的是用户和角色是一对多的关系（一个用户对应多个角色），而权限和角色关系亦是一对多的关系。***  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70]

## 3、创建自定义realm ##

即使shiro提供了如jdbcrealm，jndiRealm，和使用配置文件的realm，但是实际开发中，大部分情况仍需要我们根据实际情况定制适合自己项目的realm处理器，shiro提供了 ***AuthorizingRealm*** 抽象类，创建 ***MyShiroRealm*** 类继承 ***AuthorizingRealm*** 抽象类，重写 ***doGetAuthorizationInfo*** 方法，和 ***doGetAuthenticationInfo*** 方法，完成自定义realm，下面是我配置的realm。

> 需要注意的是，***doGetAuthenticationInfo*** 是每次登录会调用，而 ***doGetAuthorizationInfo*** 方法则是访问到需要权限、角色的接口的时候才会调用！

import java.util.Set;
    
    import org.apache.shiro.authc.AuthenticationException;
    import org.apache.shiro.authc.AuthenticationInfo;
    import org.apache.shiro.authc.AuthenticationToken;
    import org.apache.shiro.authc.IncorrectCredentialsException;
    import org.apache.shiro.authc.SimpleAuthenticationInfo;
    import org.apache.shiro.authc.UnknownAccountException;
    import org.apache.shiro.authc.UsernamePasswordToken;
    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.springframework.beans.factory.annotation.Autowired;
    
    import cn.junengxiong.bean.User;
    import cn.junengxiong.service.UserService;
    
    /** * 自定义登录权限认证 * * @ClassName: MyShiroRealm * @Description TODO * @version * @author jh * @date 2019年8月27日 下午4:12:40 */
    
    public class MyShiroRealm extends AuthorizingRealm { 
        @Autowired
        UserService userService;
    
        /** * 权限设置 */
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) { 
            if (userService == null) { 
                userService = (UserService) SpringBeanFactoryUtil.getBeanByName("userServiceImpl");
            }
            System.out.println("进入自定义权限设置方法！");
            String username = (String) principals.getPrimaryPrincipal();
            // 从数据库或换村中获取用户角色信息
            User user = userService.findByUsername(username);
            // 获取用户角色
            Set<String> roles = user.getRole();
            // 获取用户权限
            Set<String> permissions = user.getPermission();
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            // 设置权限
            simpleAuthorizationInfo.setStringPermissions(permissions);
            // 设置角色
            simpleAuthorizationInfo.setRoles(roles);
    
            return simpleAuthorizationInfo;
        }
    
       /** * 身份验证 */
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException { 
            System.out.println("进入自定义登录验证方法！");
            if (userService == null) { 
                userService = (UserService) SpringBeanFactoryUtil.getBeanByName("userServiceImpl");
            }
            // 通过username从数据库中查找 User对象，如果找到，没找到.
            // 实际项目中，这里可以根据实际情况做缓存，如果不做，Shiro自己也是有时间间隔机制，2分钟内不会重复执行该方法
            UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) token;
            String username = usernamePasswordToken.getUsername();
            String pwd = String.valueOf(usernamePasswordToken.getPassword());// 获取用户输入的密码
            User user = userService.findByUsername(username);
            if (user == null) { 
                throw new UnknownAccountException();// 用户不存在
            }
            String password = user.getPassword();// 数据库获取的密码
            // 此处对用户输入密码进行加密，对比数据库查询出来加密后的密码，自定义加密方式
            // ............................
            // password = new SimpleHash("MD5", password, username, 1024).toString();
            if (!password.equals(pwd)) { 
                throw new IncorrectCredentialsException();// 凭证错误
            }
            // 主要的（可以使用户名，也可以是用户对象），资格证书(数据库获取的密码)，区域名称（当前realm名称）
            SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(username, password, getName());
            // 加盐,使用每个用户各自的用户名加盐，保证密码相同时但是加密后密码仍然不同,如果不适用shiro自带凭证比较器，或者自定义凭证比较器，可以不设置加盐
            // simpleAuthenticationInfo.setCredentialsSalt(ByteSource.Util.bytes(username));
            return simpleAuthenticationInfo;
        }
    
    
    }

### 3.1 userService为null问题 ###

> 1.  [可以查看此文章，若解决则无需使用下面方式][Link 1]
> 2.  [解决service事务失效问题][service]

**因为springboot的bean注入机制，会导致在此realm生成的时候userService不会被注入，所有需要我们手动把UserService注入进来，用到了SpringBeanFactoryUtil工具类：**

import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    /** * * @ClassName: SpringBeanFactoryUtil * @Description 手动bean注入工具类，用于解决filter中注入service为null问题 * @version * @author jh * @date 2019年8月28日 上午10:29:37 */
    @Component
    public class SpringBeanFactoryUtil implements ApplicationContextAware { 
        private static ApplicationContext applicationContext;
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { 
            if (SpringBeanFactoryUtil.applicationContext == null) { 
                SpringBeanFactoryUtil.applicationContext = applicationContext;
            }
        }
    
        private SpringBeanFactoryUtil() { 
            // TODO Auto-generated constructor stub
        }
    
        public static ApplicationContext getApplicationContext() { 
            return applicationContext;
        }
    
        // 根据名称-------@Resource 注解
        public static Object getBeanByName(String name) { 
            return getApplicationContext().getBean(name);
        }
    
        // 根据类型-------@Autowired 注解
        public static <T> T getBeanByType(Class<T> clazz) { 
            return getApplicationContext().getBean(clazz);
        }
    
        // 根据名称和类型--------@Autowired+@Qualifier
        public static <T> T getBeanByNameAndType(String name, Class<T> clazz) { 
            return getApplicationContext().getBean(name, clazz);
        }
    }

## 4、把自定义的Realm交给SecurityManager ##

我们声明好了自定义的realm后，需要把它交给SecurityManager来管理，需要在ShiroConfig类中，添加如下代码

*  返回自定义realm，放入SecurityManager

/** * 自定义身份认证 realm; * <p> * 必须写这个类，并加上 @Bean 注解，目的是注入 MyShiroRealm， 否则会影响 MyShiroRealm类 中其他类的依赖注入 */
        @Bean
        public MyShiroRealm myShiroRealm() { 
            MyShiroRealm myShiroRealm = new MyShiroRealm();
            return myShiroRealm;
        }

*  SecurityManager 配置

/** * 注入 securityManager */
        @Bean
        public SecurityManager securityManager() { 
            DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
            securityManager.setRealm(myShiroRealm());
            return securityManager;
        }

## 5、user类 ##

上面已经讲过了，一个用户对应着多个角色，而一个角色对应多个权限，  
为了方便，不进行数据库的操作，在service中伪造三个用户，而每个用户拥有n个角色和n个权限，我们用set集合表示，可以根据情况随意拓展。

import java.util.Set;
    
    public class User { 
        private String username;
        private String password;
        private Set<String> role;
        private Set<String> permission;
        public String getUsername() { 
            return username;
        }
    
        public void setUsername(String username) { 
            this.username = username;
        }
    
        public String getPassword() { 
            return password;
        }
    
        public void setPassword(String password) { 
            this.password = password;
        }
    
        public Set<String> getRole() { 
            return role;
        }
    
        public void setRole(Set<String> role) { 
            this.role = role;
        }
    
        public Set<String> getPermission() { 
            return permission;
        }
    
        public void setPermission(Set<String> permission) { 
            this.permission = permission;
        }
    
        @Override
        public String toString() { 
            return "User [username=" + username + ", password=" + password + ", role=" + role + ", permission=" + permission
                    + "]";
        }
    
    
    }

## 6、 业务层 ##

### 6.1service ###

public interface UserService { 
        User findByUsername(String username);
    }

### 6.2serviceImpl ###

import java.util.HashSet;
    import java.util.Set;
    
    import org.springframework.stereotype.Service;
    
    import cn.junengxiong.bean.User;
    import cn.junengxiong.service.UserService;
    
    @Service
    public class UserServiceImpl implements UserService { 
    
        @Override
        public User findByUsername(String username) { 
            User user = new User();
            user.setUsername(username);
            Set<String> roleList = new HashSet<>();
            Set<String> permissionsList = new HashSet<>();
            switch (username) { 
            case "admin":
                roleList.add("admin");
                user.setPassword("admin");
                permissionsList.add("user:add");
                permissionsList.add("user:delete");
                break;
            case "consumer":
                roleList.add("consumer");
                user.setPassword("consumer");
                permissionsList.add("consumer:modify");
                break;
            default:
                roleList.add("guest");
                user.setPassword("guest");
                break;
            }
            user.setRole(roleList);
            user.setPermission(permissionsList);
            return user;
        }
    
    }

## 7、controller ##

import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.authc.AuthenticationException;
    import org.apache.shiro.authc.ExcessiveAttemptsException;
    import org.apache.shiro.authc.IncorrectCredentialsException;
    import org.apache.shiro.authc.LockedAccountException;
    import org.apache.shiro.authc.UnknownAccountException;
    import org.apache.shiro.authc.UsernamePasswordToken;
    import org.apache.shiro.authz.annotation.Logical;
    import org.apache.shiro.authz.annotation.RequiresRoles;
    import org.apache.shiro.subject.Subject;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import cn.junengxiong.bean.ReturnMap;
    
    @RestController
    public class ShiroController { 
    
        @RequestMapping("/consumer/{str}")
        @RequiresRoles(value = {  "admin", "consumer" }, logical = Logical.OR)
        public ReturnMap getMessage(@PathVariable(value = "str") String str) { 
            return new ReturnMap().success().data(str);
        }
    
        @RequestMapping("/admin/{str}")
        @RequiresRoles("admin")
        public ReturnMap getMessageAdmin(@PathVariable(value = "str") String str) { 
            return new ReturnMap().success().data(str);
        }
    
        @RequestMapping("/guest/{str}")
        public ReturnMap getMessageGuest(@PathVariable(value = "str") String str) { 
            return new ReturnMap().success().data(str);
        }
    
        @RequestMapping("/login")
        public ReturnMap login(String username, Boolean rememberMe, String password) { 
            Subject subject = SecurityUtils.getSubject();
            UsernamePasswordToken token = new UsernamePasswordToken(username, password);
            if (rememberMe != null) { 
                token.setRememberMe(rememberMe);
            }
            try { 
                // 登录
                subject.login(token);
            } catch (UnknownAccountException uae) { 
                // 用户名未知...
                return new ReturnMap().fail().message("用户不存在！");
            } catch (IncorrectCredentialsException ice) { 
                // 凭据不正确，例如密码不正确 ...
                return new ReturnMap().fail().message("密码不正确！");
            } catch (LockedAccountException lae) { 
                // 用户被锁定，例如管理员把某个用户禁用...
                return new ReturnMap().fail().message("用户被锁定！");
            } catch (ExcessiveAttemptsException eae) { 
                // 尝试认证次数多余系统指定次数 ...
                return new ReturnMap().fail().message("尝试认证次数过多，请稍后重试！");
            } catch (AuthenticationException ae) { 
                // 其他未指定异常
                return new ReturnMap().fail().message("未知异常！");
            }
            return new ReturnMap().success().data("登录成功！");
        }
    
        @RequestMapping("/loginout")
        public ReturnMap getMessageGuest() { 
            Subject subject = SecurityUtils.getSubject();
            // 登出
            subject.logout();
            return new ReturnMap().success().message("登出成功！");
        }
    
        /** * 无权限访问时 * * @return */
        @RequestMapping("/unauthorized")
        public ReturnMap unauthorized() { 
            return new ReturnMap().invalid();
        }
    }

## 8、添加对权限注解支持 ##

这一步卡了我一些时间，刚开始接触shiro框架，但是加入权限控制注解，每次只会在登录的时候调用登录验证接口，但是访问有权限的接口时，并不会进入自定义realm中的 ***doGetAuthorizationInfo*** 方法，经查询，该方法只会在用户访问到需要权限的接口的时候才会调用，如果未使用缓存，则每次访问权限接口均会调用一次 ***doGetAuthorizationInfo*** 方法，另外权限注解需要加入两个配置项来支持，在shiroConfig配置类中添加如下代码，启动对权限注解的支持。

class ShiroConfig
    ....................
     /** * 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证 * 配置以下两个bean(DefaultAdvisorAutoProxyCreator和AuthorizationAttributeSourceAdvisor)即可实现此功能 * * @return */
        @Bean
        public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() { 
            DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
            advisorAutoProxyCreator.setProxyTargetClass(true);
            return advisorAutoProxyCreator;
        }
    
        /** * 开启aop注解支持 * * @param securityManager * @return */
        @Bean
        public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) { 
            AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
            authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
            return authorizationAttributeSourceAdvisor;
        }

## 9、补充 ##

在学习shiro中查看了很多资料，博客，发现一些教学中会在ShiroConfig配置中添加如下配置

/** * 配置Shiro生命周期处理器 * * @return */
    // @Bean(name = "lifecycleBeanPostProcessor")
    // public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() { 
    // return new LifecycleBeanPostProcessor();
    // }

但是，如果配合spring食用时，是无需配置此项的，可以查看  
\* shiro-spring-config.ShiroBeanConfiguration文件，此配置已经帮我们配置好了

## 10、测试页面 ##

<!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>登录</title>
    </head>
    
    <body>
    	<table>
    		<tr>
    			<td>请输入姓名</td>
    			<td><input type="text" name="username" id="username" /></td>
    		</tr>
    		<tr>
    			<td>请输入密码</td>
    			<td><input type="password" name="password" id="password" /></td>
    		</tr>
    		<tr>
    			<td>记住我</td>
    			<td><input type="checkbox" name="rememberMe" id="rememberMe" /></td>
    		</tr>
    	</table>
    	<button type="button" onclick="login()">登录</button>
    	<button type="button" onclick="loginout()">登出</button>
    	<table>
    		<tr>
    		  <td><button onclick="authority('/admin/可以访问admin')">admin 管理员接口</button></td>
    		  <td><button onclick="authority('/consumer/可以访问consumer')">consumer 用户接口</button></td>
    		  <td><button onclick="authority('/guest/可以访问guest')">guest 访客接口</button></td>
    		</tr>
    	</table>
    	<textarea rows="5" cols="60" id="textarea"></textarea>
    	<script src="https://cdn.bootcss.com/jquery/3.1.1/jquery.min.js"></script>
    </body>
    <script type="text/javascript"> function login() { //登录 var username = $('#username').val(); var password = $('#password').val(); var flag = $('#rememberMe').prop('checked'); console.log(flag) $.ajax({ url : '/login', data : { 'username' : username, 'password' : password, 'rememberMe' : flag }, success : function(res) { console.log(res) $('#textarea').val(JSON.stringify(res)); } }) } function loginout() { //登出 $.ajax({ url : '/loginout', success : function(res) { $('#textarea').val(JSON.stringify(res)); } }) } //权限测试 function authority(url){ $.ajax({ url : url, success : function(res) { $('#textarea').val(JSON.stringify(res)); } }) } </script>
    </html>

## 11、进行测试 ##

下面是这次的controller配置，可以看到

*  **admin**可以访问所有接口
 *  **consumer**可以访问本身和guest接口
 *  **guest**只可以访问自己的接口  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 1]

### 11.1测试结果 ###

1.admin登录，进入登录认证方法，登录成功！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 2]  
2. 测试管理员接口，进入权限验证方法，权限验证通过![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 3]  
3. consumer接口测试，可以看到，因为此接口设置了允许两种角色访问，shiro访问了两次权限认证方法![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 4]  
4. guest接口测试，可以看到，在没有加权限注解时，shiro是不会访问权限认证方法的![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 5]  
5. 换一个角色尝试一下，首先登录成功！![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 6]  
6. 访问admin接口，得到无权限访问，可以看到后台进行权限验证后抛出了 ***org.apache.shiro.authz.UnauthorizedException: Subject does not have role \[admin\]*** 权限验证异常：缺少角色admin，成功拦截访问！![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 7]  
7. 访问自己的consumer接口，可以访问，并且仍然进行了两次权限认证方法，即使我在注解上面填写所需角色为or关系也不行，有点像 ***非短路与*** 的意思，这里猜想如果填写三个是不是访问三次。。。。。。![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 8]  
8. 马上更改代码尝试，在consumer接口新增可访问角色‘superman’，直接点击访问执行了三次权限认证，猜想成功！![在这里插入图片描述][20190905162310298.png]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 9]

## 12、源码 ##

如果需要源码可以在下面地址得到，如果帮助到了你可以

."`".
      .-./ _=_ \.-.
     {  (,(oYo),) }}
     {
       { |   "   |} }
     { { $---)/  }}
     {
       {  }'-=-'{ } }
     { { }._:_.{  }}
     {
       {  } -:- { } }
     {_{ }`===`{  _}
    (((($     (/))))

[springboot 整合Shiro][springboot _Shiro]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/717b2dc791a4445b86669ac4a46502c2.png
[Link 1]: https://blog.csdn.net/New_Yao/article/details/105527265
[service]: https://blog.csdn.net/New_Yao/article/details/105527745
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/34fdd4cde1724d05825a60822c260780.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/7b6042b2a0bc4e57857cb7b7464920f4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/1f3a6aae547d4deda5959f161e7285d5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/3e0c3bff55a144409c8bbf0b3f35bb34.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/692eb96116344e3f9970671746d84839.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/a9f662bcc2634ff19e898a0b3907d9b0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/fd473a8d044b43af8a7cbf2a85813829.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/2227a42f7be64a8986691dac92c1f71c.png
[20190905162310298.png]: https://img-blog.csdnimg.cn/20190905162310298.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L05ld19ZYW8_size_16_color_FFFFFF_t_70 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/2ff97b30bddb439baef92c86304cd58c.png
[springboot _Shiro]: https://github.com/NewYao/springboot/tree/master/springboot-shiro