Shiro整合SpringBoot项目实战

忘是亡心i 2022-10-12 14:57 199阅读 0赞

### 文章目录 ###

*   *  6.整合SpringBoot项目实战
     *   *  6.0 整合思路
         *  6.1 创建springboot项目
         *  6.2 引入shiro依赖
         *  6.3 配置shiro环境
         *   *   *  0.创建配置类
                 *  1.配置shiroFilterFactoryBean
                 *  2.配置WebSecurityManager
                 *  3.创建自定义realm
                 *  4.配置自定义realm
                 *  5.编写控制器跳转至index.html
                 *  6.启动springboot应用访问index
                 *  7.加入权限控制
                 *  8.重启项目访问查看
         *  6.4 常见过滤器
         *  6.5 认证实现
         *   *   *  1. 在login.jsp中开发认证界面
                 *  2. 开发controller
                 *  3.开发realm中返回静态数据(未连接数据库)
                 *  4.启动项目以realm中定义静态数据进行认证
         *  6.6 退出认证
         *   *   *  1.开发页面退出连接
                 *  2.开发controller
                 *  3.修改退出连接访问退出路径
                 *  4.退出之后访问受限资源立即返回认证界面
         *  6.7 MD5、Salt的认证实现
         *   *  1.开发数据库注册
             *   *  0.开发注册界面
                 *  1.创建数据表结构
                 *  2.项目引入依赖
                 *  3.配置application.properties配置文件
                 *  4.创建entity
                 *  5.创建DAO接口
                 *  6.开发mapper配置文件
                 *  7.开发service接口
                 *  8.创建salt工具类
                 *  9.开发service实现类
                 *  10.开发Controller
                 *  11.启动项目进行注册
             *  2.开发数据库认证
             *   *  0.开发DAO
                 *  1.开发mapper配置文件
                 *  2.开发Service接口
                 *  3.开发Service实现类
                 *  4.开发在工厂中获取bean对象的工具类
                 *  5.修改自定义realm
                 *  6.修改ShiroConfig中realm使用凭证匹配器以及hash散列
         *  6.8 授权实现
         *   *   *  0.页面资源授权
                 *  1.代码方式授权
                 *  2.方法调用授权
                 *  3.授权数据持久化
                 *  4.创建dao方法
                 *  5.mapper实现
                 *  6.Service接口
                 *  7.Service实现
                 *  8.修改自定义realm
                 *  9.启动测试
         *  6.9 使用CacheManager
         *   *  1.Cache 作用
             *  2.使用shiro中默认EhCache实现缓存
             *   *  1.引入依赖
                 *  2.开启缓存
                 *  3.启动刷新页面进行测试
             *  3.shiro中使用Redis作为缓存实现
             *   *  1.引入redis依赖
                 *  2.配置redis连接
                 *  3.启动redis服务
                 *  4.开发RedisCacheManager
                 *  5.开RedisCache实现
                 *  6.启动项目测试发现报错
                 *  7.再次启动测试,发现可以成功放入redis缓存
             *  4. 加入验证码验证
             *   *  0.开发页面加入验证码
     *

## 6.整合SpringBoot项目实战 ##

源码：[https://download.csdn.net/download/qq\_43753724/20031203?spm=1001.2014.3001.5501][https_download.csdn.net_download_qq_43753724_20031203_spm_1001.2014.3001.5501]

### 6.0 整合思路 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center]

### 6.1 创建springboot项目 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 1]

### 6.2 引入shiro依赖 ###

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

### 6.3 配置shiro环境 ###

##### 0.创建配置类 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 2]

##### 1.配置shiroFilterFactoryBean #####

@Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(SecurityManager securityManager){ 
      //创建shiro的filter
      ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
      //注入安全管理器
      shiroFilterFactoryBean.setSecurityManager(securityManager);
     	
      return shiroFilterFactoryBean;
    }

##### 2.配置WebSecurityManager #####

@Bean
    public DefaultWebSecurityManager getSecurityManager(Realm realm){ 
      DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
      defaultWebSecurityManager.setRealm(realm);
      return defaultWebSecurityManager;
    }

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 3]

public class CustomerRealm extends AuthorizingRealm { 
        //处理授权
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) { 
            return null;
        }
    		//处理认证
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws 
          																																		AuthenticationException { 
            return null;
        }
    }

##### 4.配置自定义realm #####

//创建自定义realm
    @Bean
    public Realm getRealm(){ 
      return new CustomerRealm();
    }

##### 5.编写控制器跳转至index.html #####

@Controller
    public class IndexController { 
        @RequestMapping("index")
        public String index(){ 
            System.out.println("跳转至主页");
            return "index";
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 5]

##### 6.启动springboot应用访问index #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 6]

*  注意:
    
     *  **默认在配置好shiro环境后默认环境中没有对项目中任何资源进行权限控制,所有现在项目中所有资源都可以通过路径访问**

##### 7.加入权限控制 #####

*  修改ShiroFilterFactoryBean配置
    
        //注入安全管理器
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        Map<String,String> map =  new LinkedHashMap<>();
        map.put("/**","authc");
        //配置认证和授权规则
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
    
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-932Hxa4K-1625454917389)(Shiro 实战教程.assets/image-20200523102303320.png)\]
    
     *  **/\***\* 代表拦截项目中一切资源 **authc** 代表shiro中的一个filter的别名,详细内容看文档的shirofilter列表

##### 8.重启项目访问查看 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70]

### 6.4 常见过滤器 ###

*  注意: **shiro提供和多个默认的过滤器，我们可以用这些过滤器来配置控制指定url的权限：**

<table> 
 <thead> 
  <tr> 
   <th>配置缩写</th> 
   <th>对应的过滤器</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>anon</td> 
   <td>AnonymousFilter</td> 
   <td>指定url可以匿名访问</td> 
  </tr> 
  <tr> 
   <td>authc</td> 
   <td>FormAuthenticationFilter</td> 
   <td>指定url需要form表单登录，默认会从请求中获取<code>username</code>、<code>password</code>,<code>rememberMe</code>等参数并尝试登录，如果登录不了就会跳转到loginUrl配置的路径。我们也可以用这个过滤器做默认的登录逻辑，但是一般都是我们自己在控制器写登录逻辑的，自己写的话出错返回的信息都可以定制嘛。</td> 
  </tr> 
  <tr> 
   <td>authcBasic</td> 
   <td>BasicHttpAuthenticationFilter</td> 
   <td>指定url需要basic登录</td> 
  </tr> 
  <tr> 
   <td>logout</td> 
   <td>LogoutFilter</td> 
   <td>登出过滤器，配置指定url就可以实现退出功能，非常方便</td> 
  </tr> 
  <tr> 
   <td>noSessionCreation</td> 
   <td>NoSessionCreationFilter</td> 
   <td>禁止创建会话</td> 
  </tr> 
  <tr> 
   <td>perms</td> 
   <td>PermissionsAuthorizationFilter</td> 
   <td>需要指定权限才能访问</td> 
  </tr> 
  <tr> 
   <td>port</td> 
   <td>PortFilter</td> 
   <td>需要指定端口才能访问</td> 
  </tr> 
  <tr> 
   <td>rest</td> 
   <td>HttpMethodPermissionFilter</td> 
   <td>将http请求方法转化成相应的动词来构造一个权限字符串，这个感觉意义不大，有兴趣自己看源码的注释</td> 
  </tr> 
  <tr> 
   <td>roles</td> 
   <td>RolesAuthorizationFilter</td> 
   <td>需要指定角色才能访问</td> 
  </tr> 
  <tr> 
   <td>ssl</td> 
   <td>SslFilter</td> 
   <td>需要https请求才能访问</td> 
  </tr> 
  <tr> 
   <td>user</td> 
   <td>UserFilter</td> 
   <td>需要已登录或“记住我”的用户才能访问</td> 
  </tr> 
 </tbody> 
</table>

### 6.5 认证实现 ###

##### 1. 在login.jsp中开发认证界面 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 7]

##### 2. 开发controller #####

@Controller
    @RequestMapping("user")
    public class UserController { 
      /** * 用来处理身份认证 * @param username * @param password * @return */
      @RequestMapping("login")
      public String login(String username,String password){ 
        //获取主体对象
        Subject subject = SecurityUtils.getSubject();
        try { 
          subject.login(new UsernamePasswordToken(username,password));
          return  "redirect:/index.jsp";
        } catch (UnknownAccountException e) { 
          e.printStackTrace();
          System.out.println("用户名错误!");
        }catch (IncorrectCredentialsException e){ 
          e.printStackTrace();
          System.out.println("密码错误!");
        }
        return "redirect:/login.jsp";
      }
    }

*  **在认证过程中使用subject.login进行认证**

##### 3.开发realm中返回静态数据(未连接数据库) #####

@Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException { 
            System.out.println("==========================");
            String principal = (String) token.getPrincipal();
            if("xiaochen".equals(principal)){ 
                return new SimpleAuthenticationInfo(principal,"123",this.getName());
            }
            return null;
        }
    }

##### 4.启动项目以realm中定义静态数据进行认证 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 10]

*  **认证功能没有md5和随机盐的认证就实现啦**

### 6.6 退出认证 ###

##### 1.开发页面退出连接 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 11]

##### 2.开发controller #####

@Controller
    @RequestMapping("user")
    public class UserController { 
      /** * 退出登录 * */
      @RequestMapping("logout")
      public String logout(){ 
        Subject subject = SecurityUtils.getSubject();
        subject.logout();//退出用户
        return "redirect:/login.jsp";
      }
    }

##### 3.修改退出连接访问退出路径 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 12]

##### 4.退出之后访问受限资源立即返回认证界面 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 13]

### 6.7 MD5、Salt的认证实现 ###

#### 1.开发数据库注册 ####

##### 0.开发注册界面 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 14]

##### 1.创建数据表结构 #####

SET NAMES utf8mb4;
    SET FOREIGN_KEY_CHECKS = 0;
    -- ----------------------------
    -- Table structure for t_user
    -- ----------------------------
    DROP TABLE IF EXISTS `t_user`;
    CREATE TABLE `t_user` (
      `id` int(6) NOT NULL AUTO_INCREMENT,
      `username` varchar(40) DEFAULT NULL,
      `password` varchar(40) DEFAULT NULL,
      `salt` varchar(255) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
    
    SET FOREIGN_KEY_CHECKS = 1;

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 15]

##### 2.项目引入依赖 #####

<dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>2.1.2</version>
    </dependency>
    
    
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.38</version>
    </dependency>
    
    
    
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.19</version>
    </dependency>

##### 3.配置application.properties配置文件 #####

server.port=8888
    server.servlet.context-path=/shiro
    spring.application.name=shiro
    
    spring.mvc.view.suffix=/
    spring.mvc.view.prefix=.jsp
    
    #数据源
    spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/shiro?characterEncoding=UTF-8
    spring.datasource.username=root
    spring.datasource.password=123456
    
    mybatis.type-aliases-package=com.baizhi.springboot_jsp_shiro.entity
    mybatis.mapper-locations=classpath:com/baizhi/mapper/*.xml
    
    #redis
    spring.redis.database=0
    spring.redis.host=192.168.159.22
    spring.redis.port=6379
    
    
    
    
    #logging.level.root=debug
    logging.level.com.baizhi.springboot_jsp_shiro.dao=debug

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70 1]

##### 4.创建entity #####

@Data
    @Accessors(chain = true)
    @AllArgsConstructor
    @NoArgsConstructor
    public class User { 
        private String  id;
        private String username;
        private String password;
        private String salt;
    }

##### 5.创建DAO接口 #####

@Mapper
    public interface UserDAO { 
        void save(User user);
    }

##### 6.开发mapper配置文件 #####

<insert id="save" parameterType="User" useGeneratedKeys="true" keyProperty="id">
      insert into t_user values(#{id},#{username},#{password},#{salt})
    </insert>

##### 7.开发service接口 #####

public interface UserService { 
        //注册用户方法
        void register(User user);
    }

##### 8.创建salt工具类 #####

public class SaltUtils { 
        /** * 生成salt的静态方法 * @param n * @return */
        public static String getSalt(int n){ 
            char[] chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890!@#$%^&*()".toCharArray();
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < n; i++) { 
                char aChar = chars[new Random().nextInt(chars.length)];
                sb.append(aChar);
            }
            return sb.toString();
        }
    }

##### 9.开发service实现类 #####

@Service
    @Transactional
    public class UserServiceImpl implements UserService { 
    
        @Autowired
        private UserDAO userDAO;
    
        @Override
        public void register(User user) { 
            //处理业务调用dao
            //1.生成随机盐
            String salt = SaltUtils.getSalt(8);
            //2.将随机盐保存到数据
            user.setSalt(salt);
            //3.明文密码进行md5 + salt + hash散列
            Md5Hash md5Hash = new Md5Hash(user.getPassword(),salt,1024);
            user.setPassword(md5Hash.toHex());
            userDAO.save(user);
        }
    }

##### 10.开发Controller #####

@Controller
    @RequestMapping("user")
    public class UserController { 
    
        @Autowired
        private UserService userService;
    
        /** * 用户注册 */
        @RequestMapping("register")
        public String register(User user) { 
            try { 
                userService.register(user);
                return "redirect:/login.jsp";
            }catch (Exception e){ 
                e.printStackTrace();
                return "redirect:/register.jsp";
            }
        }
    }

##### 11.启动项目进行注册 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 16]

--------------------

#### 2.开发数据库认证 ####

##### 0.开发DAO #####

@Mapper
    public interface UserDAO { 
    
        void save(User user);
    		//根据身份信息认证的方法
        User findByUserName(String username);
    }

##### 1.开发mapper配置文件 #####

<select id="findByUserName" parameterType="String" resultType="User">
      select id,username,password,salt from t_user
      where username = #{username}
    </select>

##### 2.开发Service接口 #####

public interface UserService { 
        //注册用户方法
        void register(User user);
        //根据用户名查询业务的方法
        User findByUserName(String username);
    }

##### 3.开发Service实现类 #####

@Service("userService")
    @Transactional
    public class UserServiceImpl implements UserService { 
        @Autowired
        private UserDAO userDAO;
        @Override
        public User findByUserName(String username) { 
            return userDAO.findByUserName(username);
        }
    }

##### 4.开发在工厂中获取bean对象的工具类 #####

@Component
    public class ApplicationContextUtils implements ApplicationContextAware { 
    
        private static ApplicationContext context;
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { 
            this.context = applicationContext;
        }
    
    
        //根据bean名字获取工厂中指定bean 对象
        public static Object getBean(String beanName){ 
            return context.getBean(beanName);
        }
    }

##### 5.修改自定义realm #####

@Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException { 
            System.out.println("==========================");
    
            //根据身份信息
            String principal = (String) token.getPrincipal();
            //在工厂中获取service对象
            UserService userService = (UserService) ApplicationContextUtils.getBean("userService");
    				//根据身份信息查询
            User user = userService.findByUserName(principal);
    
            if(!ObjectUtils.isEmpty(user)){ 
                //返回数据库信息
                return new SimpleAuthenticationInfo(user.getUsername(),user.getPassword(), 
                                                   ByteSource.Util.bytes(user.getSalt()),this.getName());
            }
            return null;
        }

##### 6.修改ShiroConfig中realm使用凭证匹配器以及hash散列 #####

@Bean![在这里插入图片描述](https://img-blog.csdnimg.cn/20210705115139870.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0,size_16,color_FFFFFF,t_70#pic_center)
    
    public Realm getRealm(){ 
      CustomerRealm customerRealm = new CustomerRealm();
      //设置hashed凭证匹配器
      HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
      //设置md5加密
      credentialsMatcher.setHashAlgorithmName("md5");
      //设置散列次数
      credentialsMatcher.setHashIterations(1024);
      customerRealm.setCredentialsMatcher(credentialsMatcher);
      return customerRealm;
    }

### 6.8 授权实现 ###

##### 0.页面资源授权 #####

<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
    
    <shiro:hasAnyRoles name="user,admin">
            <li><a href="">用户管理</a>
                <ul>
                    <shiro:hasPermission name="user:add:*">
                    <li><a href="">添加</a></li>
                    </shiro:hasPermission>
                    <shiro:hasPermission name="user:delete:*">
                        <li><a href="">删除</a></li>
                    </shiro:hasPermission>
                    <shiro:hasPermission name="user:update:*">
                        <li><a href="">修改</a></li>
                    </shiro:hasPermission>
                    <shiro:hasPermission name="user:find:*">
                        <li><a href="">查询</a></li>
                    </shiro:hasPermission>
                </ul>
            </li>
            </shiro:hasAnyRoles>
            <shiro:hasRole name="admin">
                <li><a href="">商品管理</a></li>
                <li><a href="">订单管理</a></li>
                <li><a href="">物流管理</a></li>
            </shiro:hasRole>

##### 1.代码方式授权 #####

@RequestMapping("save")
    public String save(){ 
      System.out.println("进入方法");
      //获取主体对象
      Subject subject = SecurityUtils.getSubject();
      //代码方式
      if (subject.hasRole("admin")) { 
        System.out.println("保存订单!");
      }else{ 
        System.out.println("无权访问!");
      }
      //基于权限字符串
      //....
      return "redirect:/index.jsp";
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 17]

##### 2.方法调用授权 #####

*  @RequiresRoles 用来基于角色进行授权
 *  @RequiresPermissions 用来基于权限进行授权

@RequiresRoles(value={ "admin","user"})//用来判断角色 同时具有 admin user
    @RequiresPermissions("user:update:01") //用来判断权限字符串
    @RequestMapping("save")
    public String save(){ 
      System.out.println("进入方法");
      return "redirect:/index.jsp";
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 18]

--------------------

##### 3.授权数据持久化 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 19]

SET NAMES utf8mb4;
    SET FOREIGN_KEY_CHECKS = 0;
    
    -- ----------------------------
    -- Table structure for t_pers
    -- ----------------------------
    DROP TABLE IF EXISTS `t_pers`;
    CREATE TABLE `t_pers` (
      `id` int(6) NOT NULL AUTO_INCREMENT,
      `name` varchar(80) DEFAULT NULL,
      `url` varchar(255) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- Table structure for t_role
    -- ----------------------------
    DROP TABLE IF EXISTS `t_role`;
    CREATE TABLE `t_role` (
      `id` int(6) NOT NULL AUTO_INCREMENT,
      `name` varchar(60) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- Table structure for t_role_perms
    -- ----------------------------
    DROP TABLE IF EXISTS `t_role_perms`;
    CREATE TABLE `t_role_perms` (
      `id` int(6) NOT NULL,
      `roleid` int(6) DEFAULT NULL,
      `permsid` int(6) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- Table structure for t_user
    -- ----------------------------
    DROP TABLE IF EXISTS `t_user`;
    CREATE TABLE `t_user` (
      `id` int(6) NOT NULL AUTO_INCREMENT,
      `username` varchar(40) DEFAULT NULL,
      `password` varchar(40) DEFAULT NULL,
      `salt` varchar(255) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- Table structure for t_user_role
    -- ----------------------------
    DROP TABLE IF EXISTS `t_user_role`;
    CREATE TABLE `t_user_role` (
      `id` int(6) NOT NULL,
      `userid` int(6) DEFAULT NULL,
      `roleid` int(6) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    SET FOREIGN_KEY_CHECKS = 1;

--------------------

##### 4.创建dao方法 #####

//根据用户名查询所有角色
    User findRolesByUserName(String username);
    //根据角色id查询权限集合
    List<Perms> findPermsByRoleId(String id);

##### 5.mapper实现 #####

<resultMap id="userMap" type="User">
      <id column="uid" property="id"/>
      <result column="username" property="username"/>
      
      <collection property="roles" javaType="list" ofType="Role">
        <id column="id" property="id"/>
        <result column="rname" property="name"/>
      </collection>
    </resultMap>
    
    <select id="findRolesByUserName" parameterType="String" resultMap="userMap">
      SELECT u.id uid,u.username,r.id,r.NAME rname
      FROM t_user u
      LEFT JOIN t_user_role ur
      ON u.id=ur.userid
      LEFT JOIN t_role r
      ON ur.roleid=r.id
      WHERE u.username=#{username}
    </select>
    
    <select id="findPermsByRoleId" parameterType="String" resultType="Perms">
      SELECT p.id,p.NAME,p.url,r.NAME
      FROM t_role r
      LEFT JOIN t_role_perms rp
      ON r.id=rp.roleid
      LEFT JOIN t_perms p ON rp.permsid=p.id
      WHERE r.id=#{id}
    </select>

##### 6.Service接口 #####

//根据用户名查询所有角色
    User findRolesByUserName(String username);
    //根据角色id查询权限集合
    List<Perms> findPermsByRoleId(String id);

##### 7.Service实现 #####

@Override
    public List<Perms> findPermsByRoleId(String id) { 
      return userDAO.findPermsByRoleId(id);
    }
    
    @Override
    public User findRolesByUserName(String username) { 
      return userDAO.findRolesByUserName(username);
    }

##### 8.修改自定义realm #####

public class CustomerRealm extends AuthorizingRealm { 
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) { 
            //获取身份信息
            String primaryPrincipal = (String) principals.getPrimaryPrincipal();
            System.out.println("调用授权验证: "+primaryPrincipal);
            //根据主身份信息获取角色 和 权限信息
            UserService userService = (UserService) ApplicationContextUtils.getBean("userService");
            User user = userService.findRolesByUserName(primaryPrincipal);
            //授权角色信息
            if(!CollectionUtils.isEmpty(user.getRoles())){ 
                SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
                user.getRoles().forEach(role->{ 
                    simpleAuthorizationInfo.addRole(role.getName());
                    //权限信息
                    List<Perms> perms = userService.findPermsByRoleId(role.getId());
                    if(!CollectionUtils.isEmpty(perms)){ 
                        perms.forEach(perm->{ 
                            simpleAuthorizationInfo.addStringPermission(perm.getName());
                        });
                    }
                });
                return simpleAuthorizationInfo;
            }
            return null;
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 20]

##### 9.启动测试 #####

--------------------

### 6.9 使用CacheManager ###

#### 1.Cache 作用 ####

*  Cache 缓存: **计算机内存中一段数据**
 *  作用: **用来减轻DB的访问压力,从而提高系统的查询效率**
 *  流程:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 21]

#### 2.使用shiro中默认EhCache实现缓存 ####

##### 1.引入依赖 #####

<dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-ehcache</artifactId>
      <version>1.5.3</version>
    </dependency>

##### 2.开启缓存 #####

//3.创建自定义realm
        @Bean
        public Realm getRealm(){ 
            CustomerRealm customerRealm = new CustomerRealm();
            //修改凭证校验匹配器
            HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
            //设置加密算法为md5
            credentialsMatcher.setHashAlgorithmName("MD5");
            //设置散列次数
            credentialsMatcher.setHashIterations(1024);
            customerRealm.setCredentialsMatcher(credentialsMatcher);
    
            //开启缓存管理器
            customerRealm.setCachingEnabled(true);
            customerRealm.setAuthorizationCachingEnabled(true);
            customerRealm.setAuthorizationCachingEnabled(true);
            customerRealm.setCacheManager(new EhCacheManager());
            return customerRealm;
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 22]

##### 3.启动刷新页面进行测试 #####

*  注意:如果控制台没有任何sql展示说明缓存已经开启

#### 3.shiro中使用Redis作为缓存实现 ####

##### 1.引入redis依赖 #####

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

##### 2.配置redis连接 #####

这里我用虚拟机上面的redis

#redis
    spring.redis.database=0
    spring.redis.host=192.168.159.22
    spring.redis.port=6379

##### 3.启动redis服务 #####

➜  bin ls
    dump.rdb        redis-check-aof redis-cli       redis-server    redis.conf
    redis-benchmark redis-check-rdb redis-sentinel  redis-trib.rb
    ➜  bin ./redis-server redis.conf

##### 4.开发RedisCacheManager #####

public class RedisCacheManager implements CacheManager { 
        @Override
        public <K, V> Cache<K, V> getCache(String cacheName) throws CacheException { 
            System.out.println("缓存名称: "+cacheName);
            return new RedisCache<K,V>(cacheName);
        }
    }

##### 5.开RedisCache实现 #####

public class RedisCache<K,V> implements Cache<K,V> { 
    
        private String cacheName;
    
        public RedisCache() { 
        }
    
        public RedisCache(String cacheName) { 
            this.cacheName = cacheName;
        }
    
        @Override
        public V get(K k) throws CacheException { 
            System.out.println("获取缓存:"+ k);
            return (V) getRedisTemplate().opsForHash().get(this.cacheName,k.toString());
        }
    
        @Override
        public V put(K k, V v) throws CacheException { 
            System.out.println("设置缓存key: "+k+" value:"+v);
            getRedisTemplate().opsForHash().put(this.cacheName,k.toString(),v);
            return null;
        }
    
        @Override
        public V remove(K k) throws CacheException { 
            return (V) getRedisTemplate().opsForHash().delete(this.cacheName,k.toString());
        }
    
        @Override
        public v remove(k k) throws CacheException { 
            return (v) getRedisTemplate().opsForHash().delete(this.cacheName,k.toString());
        }
    
        @Override
        public void clear() throws CacheException { 
            getRedisTemplate().delete(this.cacheName);
        }
    
        @Override
        public int size() { 
            return getRedisTemplate().opsForHash().size(this.cacheName).intValue();
        }
    
        @Override
        public Set<k> keys() { 
            return getRedisTemplate().opsForHash().keys(this.cacheName);
        }
    
        @Override
        public Collection<v> values() { 
            return getRedisTemplate().opsForHash().values(this.cacheName);
        }
    
        private RedisTemplate getRedisTemplate(){ 
            RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            return redisTemplate;
        }
    
    
        //封装获取redisTemplate
        private RedisTemplate getRedisTemplate(){ 
            RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            return redisTemplate;
        }
    }

##### 6.启动项目测试发现报错 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 23]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 24]

*  错误解释: **由于shiro中提供的simpleByteSource实现没有实现序列化,所有在认证时出现错误信息**
 *  解决方案: **需要自动salt实现序列化**
    
     *  自定义salt实现序列化
        
            //自定义salt实现 实现序列化接口
            public class MyByteSource extends SimpleByteSource implements Serializable { 
                public MyByteSource(String string) { 
                    super(string);
                }
            }
     *  在realm中使用自定义salt
        
            @Override
            protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException { 
              System.out.println("==========================");
              //根据身份信息
              String principal = (String) token.getPrincipal();
              //在工厂中获取service对象
              UserService userService = (UserService) ApplicationContextUtils.getBean("userService");
              User user = userService.findByUserName(principal);
              if(!ObjectUtils.isEmpty(user)){ 
                return new SimpleAuthenticationInfo(user.getUsername(),user.getPassword(), 
                                                  new MyByteSource(user.getSalt()),this.getName());
              }
              return null;
            }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 25]

##### 7.再次启动测试,发现可以成功放入redis缓存 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 26]

--------------------

#### 4. 加入验证码验证 ####

##### 0.开发页面加入验证码 #####

*  开发控制器
    
        @RequestMapping("getImage")
        public void getImage(HttpSession session, HttpServletResponse response) throws IOException { 
          //生成验证码
          String code = VerifyCodeUtils.generateVerifyCode(4);
          //验证码放入session
          session.setAttribute("code",code);
          //验证码存入图片
          ServletOutputStream os = response.getOutputStream();
          response.setContentType("image/png");
          VerifyCodeUtils.outputImage(220,60,os,code);
        }
 *  放行验证码

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 27]

*  开发页面

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 28]

*  修改认证流程
    
        @RequestMapping("login")
            public String login(String username, String password,String code,HttpSession session) { 
                //比较验证码
                String codes = (String) session.getAttribute("code");
                try { 
                    if (codes.equalsIgnoreCase(code)){ 
                        //获取主体对象
                        Subject subject = SecurityUtils.getSubject();
                            subject.login(new UsernamePasswordToken(username, password));
                            return "redirect:/index.jsp";
                    }else{ 
                        throw new RuntimeException("验证码错误!");
                    }
                } catch (UnknownAccountException e) { 
                    e.printStackTrace();
                    System.out.println("用户名错误!");
                } catch (IncorrectCredentialsException e) { 
                    e.printStackTrace();
                    System.out.println("密码错误!");
                }catch (Exception e){ 
                    e.printStackTrace();
                    System.out.println(e.getMessage());
                }
                return "redirect:/login.jsp";
            }
 *  修改salt不能序列化的问题
    
        //自定义salt实现 实现序列化接口
        public class MyByteSource implements ByteSource,Serializable { 
        
            private  byte[] bytes;
            private String cachedHex;
            private String cachedBase64;
        
            //加入无参数构造方法实现序列化和反序列化
            public MyByteSource(){ 
        
            }
        
            public MyByteSource(byte[] bytes) { 
                this.bytes = bytes;
            }
        
            public MyByteSource(char[] chars) { 
                this.bytes = CodecSupport.toBytes(chars);
            }
        
            public MyByteSource(String string) { 
                this.bytes = CodecSupport.toBytes(string);
            }
        
            public MyByteSource(ByteSource source) { 
                this.bytes = source.getBytes();
            }
        
            public MyByteSource(File file) { 
                this.bytes = (new MyByteSource.BytesHelper()).getBytes(file);
            }
        
            public MyByteSource(InputStream stream) { 
                this.bytes = (new MyByteSource.BytesHelper()).getBytes(stream);
            }
        
            public static boolean isCompatible(Object o) { 
                return o instanceof byte[] || o instanceof char[] || o instanceof String || o instanceof ByteSource || o instanceof File || o instanceof InputStream;
            }
        
            public byte[] getBytes() { 
                return this.bytes;
            }
        
            public boolean isEmpty() { 
                return this.bytes == null || this.bytes.length == 0;
            }
        
            public String toHex() { 
                if (this.cachedHex == null) { 
                    this.cachedHex = Hex.encodeToString(this.getBytes());
                }
        
                return this.cachedHex;
            }
        
            public String toBase64() { 
                if (this.cachedBase64 == null) { 
                    this.cachedBase64 = Base64.encodeToString(this.getBytes());
                }
        
                return this.cachedBase64;
            }
        
            public String toString() { 
                return this.toBase64();
            }
        
            public int hashCode() { 
                return this.bytes != null && this.bytes.length != 0 ? Arrays.hashCode(this.bytes) : 0;
            }
        
            public boolean equals(Object o) { 
                if (o == this) { 
                    return true;
                } else if (o instanceof ByteSource) { 
                    ByteSource bs = (ByteSource)o;
                    return Arrays.equals(this.getBytes(), bs.getBytes());
                } else { 
                    return false;
                }
            }
        
            private static final class BytesHelper extends CodecSupport { 
                private BytesHelper() { 
                }
        
                public byte[] getBytes(File file) { 
                    return this.toBytes(file);
                }
        
                public byte[] getBytes(InputStream stream) { 
                    return this.toBytes(stream);
                }
            }
        }
    
    --------------------

##  ##

[https_download.csdn.net_download_qq_43753724_20031203_spm_1001.2014.3001.5501]: https://download.csdn.net/download/qq_43753724/20031203?spm=1001.2014.3001.5501
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/180c9aefa7314a21bc9d5a2987404568.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221005/addc7a65b369497dbdec5695478a814f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221005/c8932fdd07354ae59992234ca6e8a297.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221005/c6ff81298cbd458eb377bdc43dad5771.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221005/f5c83f083ad44b83b92e54e7f6652048.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221005/6c9057d9697844ca93da195fe94260c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221005/dbad898678c844e1a30cbbb9de007912.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70]: /images/20221005/f62ed5c36d0744c7b77e134c0cc21949.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221005/96da455985f74b5ea455de90380995b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221005/1d7286c85d4a45b3b848a8e62bd61e73.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221005/5886e5b74da34ae995d21fafb84f29c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221005/eba3084957ca44a68a53e8056332c9a1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221005/12688e7e847e4130b62f3ea87fde4007.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221005/202a3c0bda414b73821112b61c7f95cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221005/de447bc718b74a20847d80521fbf661f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20221005/84289f8e64c5488aae8bd4ae0bfed85b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20221005/5eb81338f27345ae880b69b4caa71552.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70 1]: /images/20221005/f3b3014e5d0c45ab98695f8f2773a830.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20221005/5cad0e0a91c8465f8f7f161809e097c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 17]: /images/20221005/ecc9dc55fe5e487180cf646121237b34.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 18]: /images/20221005/dacaa3f3ae474dd496223167a9db8db3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 19]: /images/20221005/a3a12e8507234ff9ac29fe8365cb7c23.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 20]: /images/20221005/16645d54e66f4a8d95e5cccd338ead55.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 21]: /images/20221005/bb1b2edc7a344f999c622c2832892298.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 22]: /images/20221005/8e7ceab3077b48ceb0438a5e814f55d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 23]: /images/20221005/a1e069da409340c19ca44eec8da9394b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 24]: /images/20221005/2ca07c10b8564cd89d8cc12f9271165e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 25]: /images/20221005/9e472385fe3d4b568b31c381968778f6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 26]: /images/20221005/219f229314414e3b945b980f4b583a95.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 27]: /images/20221005/03804f59efe8430191e6d95605fb176e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzUzNzI0_size_16_color_FFFFFF_t_70_pic_center 28]: /images/20221005/6b50c2752ed44d3290c304abea53ced7.png